Construct collection from delimited string expression.
@param value
@return
480120
private List<String> getCollection(String value) {
        String arrayString = value;

        if (arrayString.startsWith("[") && arrayString.endsWith("]")) {
            arrayString = arrayString.substring(1, arrayString.length()-1);
        }

        return Arrays.stream(StringUtils.commaDelimitedListToStringArray(arrayString))
                .map(String::trim)
                .map(VariableUtils::cutOffDoubleQuotes)
                .collect(Collectors.toList());
    }
581673
private List<String> createListFromValue(String value) {

        if (value == null) {
            return null;
        }
        List<String> result = CmsStringUtil.splitAsList(value, VALUE_LIST_DELIMITER);
        if (value.indexOf(VALUE_LIST_DELIMITER_REPLACEMENT) != -1) {
            List<String> tempList = new ArrayList<String>(result.size());
            Iterator<String> i = result.iterator();
            while (i.hasNext()) {
                String item = i.next();
                tempList.add(rebuildDelimiter(item, VALUE_LIST_DELIMITER, VALUE_LIST_DELIMITER_REPLACEMENT));
            }
            result = tempList;
        }

        return result;
    }
1241356
public Expression<Long> lt(long value) {
		String valueString = "'" + value + "'";
		return new Expression<Long>(this, Operation.lt, valueString);
	}
1203974
public static Set<String> references(final String value) {

        final HashSet<String> names = new HashSet<String>();
        if ((value == null) || (value.length() == 0)) {
            return names;
        }

        int end = -1;
        int from = 0;
        int start = -1;
        while ((start = value.indexOf("${", from)) > -1) {
            end = value.indexOf('}', start + 1);
            if (end == -1) {
                // No closing bracket found...
                from = value.length();
            } else {
                names.add(value.substring(start + 2, end));
                from = end + 1;
            }
        }

        return names;

    }
449002
public static Set<String> parseParameterList(String values) {
		Set<String> result = new TreeSet<String>();
		if (values != null && values.trim().length() > 0) {
			// the spec says the scope is separated by spaces
			String[] tokens = values.split("[\\s+]");
			result.addAll(Arrays.asList(tokens));
		}
		return result;
	}
107147
private List<TypePattern> getPatternsFrom(String value) {
		if (value == null) {
			return Collections.emptyList();
		}
		List<TypePattern> typePatterns = new ArrayList<TypePattern>();
		StringTokenizer st = new StringTokenizer(value, ",");
		while (st.hasMoreElements()) {
			String typepattern = st.nextToken();
			TypePattern typePattern = null;
			if (typepattern.endsWith("..*")) {
				typePattern = new PrefixTypePattern(typepattern);
				if (GlobalConfiguration.isRuntimeLogging && log.isLoggable(Level.INFO)) {
					log.info("registered package prefix '" + typepattern + "'");
				}
			}
			else if (typepattern.equals("*")) {
				typePattern = new AnyTypePattern();
			}
			else {
				typePattern = new ExactTypePattern(typepattern);
			}
			typePatterns.add(typePattern);
		}
		return typePatterns;
	}
600804
public static String appendArray(final String value, final String[] appends) {
        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
        if (appends == null || appends.length == 0) {
            return value;
        }
        StringJoiner joiner = new StringJoiner("");
        for (String append : appends) {
            joiner.add(append);
        }
        return value + joiner.toString();
    }
435122
public static String join(Collection strings, String delimiter) {
        StringBuilder builder = new StringBuilder();
        Iterator<String> iter = strings.iterator();
        while (iter.hasNext()) {
            builder.append(iter.next());
            if (!iter.hasNext()) {
                break;
            }
            builder.append(delimiter);
        }
        return builder.toString();
    }
279811
@SuppressWarnings({ "rawtypes", "unchecked" })
    public static String join(final Map value, final String delim) {
        if (value == null || value.isEmpty()) {
            return "";
        }
        final StringBuilder buf = new StringBuilder();
        for (final Iterator<Map.Entry<String, String>> i = value.entrySet().iterator(); i.hasNext();) {
            final Map.Entry<String, String> e = i.next();
            buf.append(e.getKey()).append(EQUAL).append(e.getValue());
            if (i.hasNext()) {
                buf.append(delim);
            }
        }
        return buf.toString();
    }
427432
private static InputMapping<Object> createInputMapping( Object value ){
        if( value instanceof String ){
            String text = (String)value;
            if( ElUtil.hasBrackets( text ) ){
                return new ExpressionLanguageMapping<Object>( text );
            }
        }
        return ConstantMapping.of( value );
    }
911886
private List<Serializable> transformValue(@NotNull Object value) {
        List<Serializable> values = new ArrayList<>();

        if (value instanceof String) {
            List<String> build = extractWords((String) value, Language.RU);

            values.addAll(build);

        } else if (value instanceof Collection) {
            Collection<Serializable> collection = (Collection) value;
            List<Serializable> collect = collection.stream()
                                                   .flatMap(item -> transformValue(item).stream())
                                                   .collect(Collectors.<Serializable>toList());

            values.addAll(collect);
        } else {
            values.add((Serializable) value);
        }

        return values;
    }
761568
@Override
    public Boolean fromString(String value) {
        return value != null && TRUE.contains(value.toLowerCase());
    }
1166075
private Set<String> parseValueList(String value) {

        if (value.charAt(0) == '(') {
            value = value.substring(1);
        }
        int len = value.length() - 1;
        if (value.charAt(len) == ')') {
            value = value.substring(0, len);
        }
        if (value.charAt(len - 1) == ',') {
            value = value.substring(0, len - 1);
        }
        if (LOG.isDebugEnabled()) {
            LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXCACHEKEY_PARSE_VALUES_1, value));
        }
        List<String> tokens = CmsStringUtil.splitAsList(value, ',', true);
        Set<String> result = new HashSet<String>();
        result.addAll(tokens);
        return result;
    }
1142891
public Expression<String> gt(String value) {
		String valueString = "'" + value + "'";
		return new Expression<String>(this, Operation.gt, valueString);
	}
141735
public static <T> Collection<T> matchToString(Collection<T> values, String name) {
        List<T> result = new ArrayList<>();
        for (T value : values) {
            if (value == null) {
                continue;
            }
            if (startsWithIgnoreCase(value.toString(), name)) {
                result.add(value);
            }
        }
        return result;
    }
940913
public Expression<java.util.Date> in(java.util.Date[] value) {
		SimpleDateFormat formatter = getDateTimeFormatter();
		String valueString = "";
		Boolean firstCalendar = true;
		for (Date v : value) {
			if (firstCalendar) {
				valueString = valueString.concat("('").concat(formatter.format(v).concat("Z")).concat("'");
				firstCalendar = false;
			} else {
				valueString = valueString.concat(", '").concat(formatter.format(v).concat("Z")).concat("'");
			}
		}

		valueString = valueString.concat(")");
		return new Expression<java.util.Date>(this, Operation.in, valueString);
	}
51097
private static final ArrayList<String> convertStringToArrayList(String value) {
        if (value != null && value.length() > 0) {
            ArrayList<String> result = new ArrayList<String>();
            StringTokenizer st = new StringTokenizer(value, STRING_ATTRIB_DELIM);
            while (st.hasMoreTokens()) {
                String nextString = unescape(st.nextToken());
                if (nextString != null) {
                    result.add(nextString);
                }
            }
            return result;
        }
        return null;
    }