Returns all simple type sub values.<p>

@param value the value

@return the simple type sub values
334354
public List<I_CmsXmlContentValue> getAllSimpleSubValues(I_CmsXmlContentValue value) {

        List<I_CmsXmlContentValue> result = new ArrayList<I_CmsXmlContentValue>();
        for (I_CmsXmlContentValue subValue : getSubValues(value.getPath(), value.getLocale())) {
            if (subValue.isSimpleType()) {
                result.add(subValue);
            } else {
                result.addAll(getAllSimpleSubValues(subValue));
            }
        }
        return result;
    }
300529
private short getDataType(String value)
    {
        short ret = STRING_TYPE;

        if(value.equals("number"))
            ret = NUMBER_TYPE;
        else if(value.equals("integer"))
            ret = INTEGER_TYPE;
        else if(value.equals("decimal"))
            ret = DECIMAL_TYPE;
        else if(value.equals("seconds"))
            ret = SECONDS_TYPE;
        else if(value.equals("datetime"))
            ret = DATETIME_TYPE;
        else if(value.equals("boolean"))
            ret = BOOLEAN_TYPE;

        return ret;
    }
575645
public TypeValuePairType getTypeValuePair(String type, String value) {
        return getTypeValuePair(type, value.getBytes(StandardCharsets.UTF_8));
    }
1343348
protected static String valueString(Object value) {
        if (value == null) {
            return "null";
        } else if (value instanceof String) {
            return "\"" + ((String) value).codePoints()
                    .flatMap(cp ->
                        (cp == '"')
                            ? "\\\"".codePoints()
                            : (cp < 256)
                                ? charRep[cp].codePoints()
                                : IntStream.of(cp))
                    .collect(
                            StringBuilder::new,
                            StringBuilder::appendCodePoint,
                            StringBuilder::append)
                    .toString() + "\"";
        } else if (value instanceof Character) {
            char cp = (char) (Character) value;
            return "'" + (
                (cp == '\'')
                    ? "\\\'"
                    : (cp < 256)
                            ? charRep[cp]
                            : String.valueOf(cp)) + "'";
        } else if (value.getClass().isArray()) {
            int dims = 0;
            Class<?> t = value.getClass();
            while (true) {
                Class<?> ct = t.getComponentType();
                if (ct == null) {
                    break;
                }
                ++dims;
                t = ct;
            }
            String tn = t.getTypeName();
            int len = Array.getLength(value);
            StringBuilder sb = new StringBuilder();
            sb.append(tn.substring(tn.lastIndexOf('.') + 1, tn.length()));
            sb.append("[");
            sb.append(len);
            sb.append("]");
            for (int i = 1; i < dims; ++i) {
                sb.append("[]");
            }
            sb.append(" { ");
            for (int i = 0; i < len; ++i) {
                sb.append(valueString(Array.get(value, i)));
                if (i < len - 1) {
                    sb.append(", ");
                }
            }
            sb.append(" }");
            return sb.toString();
        } else {
            return value.toString();
        }
    }
433505
protected String[] getTypes(boolean all) {

        if (!all) {
            String[] array = new String[3];
            return Arrays.asList(m_types).subList(0, 3).toArray(array);
        }
        return m_types;
    }
1240116
public static String toPrettyString(Object value) {
		if (value == null) {
			return NULL;
		}

		Class<?> type = value.getClass();

		if (type.isArray()) {
			Class componentType = type.getComponentType();

			if (componentType.isPrimitive()) {
				return primitiveArrayToString(value, componentType);
			} else {
				return objectArrayToString(value);
			}
		} else if (value instanceof Iterable) {
			// 因为Collection的处理也是默认调用元素的toString(),
			// 为了处理元素是数组的情况，同样需要重载
			return collectionToString(value);
		}

		return value.toString();
	}
1231735
public static <V extends Value> ValueList<V> getInstance(V... value) {
        ValueList<V> result = new ValueList<>(value.length);
        for (V val : value) {
            result.add(val);
        }
        return result;
    }
229426
public DiscriminatorJdbcSubBuilder when(String value, Type type) {
        return when(new DiscriminatorPredicate(value), type);
    }
288293
public static List<CmsRelationType> getAll() {

        List<CmsRelationType> all = new ArrayList<CmsRelationType>(Arrays.asList(VALUE_ARRAY));
        all.addAll(OpenCms.getResourceManager().getRelationTypes());
        return Collections.unmodifiableList(all);
    }
961196
protected<T> List<T> toList (T value) {

        if (value == null) {
            return null;
        }

        return Arrays.asList(value);
    }
822621
@ReplacedBy("java.util.Collections#addAll()")
    public static <T, E extends T, C extends Collection<T>> C addAll (C col, E[] values)
    {
        if (values != null) {
            for (E value : values) {
                col.add(value);
            }
        }
        return col;
    }
564697
public static MediaType fromString(String value) {
        if (value == null) {
            throw new NullPointerException("value");
        }
        List<ParameterizedHeaderWithValue> headerValues = ParameterizedHeaderWithValue.fromString(value);
        if (headerValues.isEmpty()) {
            throw new IllegalArgumentException("The value '" + value + "' did not contain a valid header value");
        }
        ParameterizedHeaderWithValue v = headerValues.get(0);
        String[] split = v.value().split("/");
        if (split.length != 2) {
            throw new IllegalArgumentException("Media types must be in the format 'type/subtype'; this is inavlid: '" + v.value() + "'");
        }
        return new MediaType(split[0], split[1], v.parameters());
    }
103840
public boolean containsValue(Object value) {
        Entry tab[] = mTable;
        
        if (value == null) {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                    if (e.getKey() == null) {
                        // Clean up after a cleared Reference.
                        mModCount++;
                        if (prev != null) {
                            prev.mNext = e.mNext;
                        }
                        else {
                            tab[i] = e.mNext;
                        }
                        mCount--;
                    }
                    else if (e.mValue == null) {
                        return true;
                    }
                    else {
                        prev = e;
                    }
                }
            }
        }
        else {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                    if (e.getKey() == null) {
                        // Clean up after a cleared Reference.
                        mModCount++;
                        if (prev != null) {
                            prev.mNext = e.mNext;
                        }
                        else {
                            tab[i] = e.mNext;
                        }
                        mCount--;
                    }
                    else if (value.equals(e.mValue)) {
                        return true;
                    }
                    else {
                        prev = e;
                    }
                }
            }
        }

        return false;
    }
107117
public Collection<String> split(String value) {
    String[] parts = splitter.split(value);
    Collection<String> values = new ArrayList(parts.length);
    for (int ix = 0; ix < parts.length; ix++)
      values.add(parts[ix]);
    return values;
  }

  public String getSplitOn() {
	return splitter.toString();
  }
}
891767
public static int getTypeForValue( Object value ) {
        if (value == null) return Type.NULL;
        if (value instanceof String) return Type.STRING;
        if (value instanceof Symbol) return Type.SYMBOL;
        if (value instanceof Integer) return Type.INT32;
        if (value instanceof Long) return Type.INT64;
        if (value instanceof Double) return Type.DOUBLE;
        if (value instanceof List) return Type.ARRAY;
        if (value instanceof Document) return Type.DOCUMENT;
        if (value instanceof Boolean) return Type.BOOLEAN;
        if (value instanceof Binary) return Type.BINARY;
        if (value instanceof ObjectId) return Type.OBJECTID;
        if (value instanceof Date) return Type.DATETIME;
        if (value instanceof Null) return Type.NULL;
        if (value instanceof Pattern) return Type.REGEX;
        if (value instanceof Symbol) return Type.DBPOINTER;
        if (value instanceof Code) return Type.JAVASCRIPT;
        if (value instanceof CodeWithScope) return Type.JAVASCRIPT_WITH_SCOPE;
        if (value instanceof Timestamp) return Type.TIMESTAMP;
        if (value instanceof MinKey) return Type.MINKEY;
        if (value instanceof MaxKey) return Type.MAXKEY;
        return Type.UNDEFINED;
    }
391622
public static MimeType getMimeType(String value) {
        if (StringUtils.isNotBlank(value)) {
            try {
                return getMimeTypes().forName(value);
            } catch (MimeTypeException e) {
                MediaType mediaType = getMediaType(null, value);
                if (mediaType != null) {
                    try {
                        return getMimeTypes().forName(mediaType.toString());
                    } catch (MimeTypeException e1) {
                        // detection not successful
                    }
                }
            }
        }
        return null;
    }
468549
private List<Integer> asIntList(Object value) {
        int[] values = (int[]) value;
        List<Integer> list = new ArrayList<Integer>(values.length);
        for (int integer : values) {
            list.add(integer);
        }
        return list;
    }