Returns a {@code String} between matcher that matches any character in the given left and ending

@param target
@param separator
@return
420507
public static Betner after(String target, String separator) {
    	return betn(target).after(separator);
    }
264420
public static String join(final Collection<?> collection, final String separator) {
        StringBuffer buffer = new StringBuffer();
        boolean first = true;
        Iterator<?> iter = collection.iterator();
        while (iter.hasNext()) {
            Object next = iter.next();
            if (first) {
                first = false;
            } else {
                buffer.append(separator);
            }
            buffer.append(next);
        }
        return buffer.toString();
    }
162241
public static String format( Collection<String> items, String separator ) {

		StringBuilder sb = new StringBuilder();
		for( Iterator<String> it = items.iterator(); it.hasNext(); ) {
			sb.append( it.next());
			if( it.hasNext())
				sb.append( separator );
		}

		return sb.toString();
	}
851451
private static void translateSeparator(final String path, final int startIdx, final int endIdx,
            final boolean stripFinalSeparator, final StringBuilder buf) {
        for (int i = startIdx; i < endIdx; i++) {
            final char c = path.charAt(i);
            if (c == '\\' || c == '/') {
                // Strip trailing separator, if necessary
                if (i < endIdx - 1 || !stripFinalSeparator) {
                    // Remove duplicate separators
                    final char prevChar = buf.length() == 0 ? '\0' : buf.charAt(buf.length() - 1);
                    if (prevChar != '/') {
                        buf.append('/');
                    }
                }
            } else {
                buf.append(c);
            }
        }
    }
1118342
public static PathMatcher getPathMatcher(
      String syntaxAndPattern, String separators, ImmutableSet<PathNormalization> normalizations) {
    int syntaxSeparator = syntaxAndPattern.indexOf(':');
    checkArgument(
        syntaxSeparator > 0, "Must be of the form 'syntax:pattern': %s", syntaxAndPattern);

    String syntax = Ascii.toLowerCase(syntaxAndPattern.substring(0, syntaxSeparator));
    String pattern = syntaxAndPattern.substring(syntaxSeparator + 1);

    switch (syntax) {
      case "glob":
        pattern = GlobToRegex.toRegex(pattern, separators);
        // fall through
      case "regex":
        return fromRegex(pattern, normalizations);
      default:
        throw new UnsupportedOperationException("Invalid syntax: " + syntaxAndPattern);
    }
  }
485716
protected String addEndSlash(@NonNull String target) {
        if (!target.endsWith(File.separator)) target = target + File.separator;
        return target;
    }
1179743
@Deprecated
    public static int matchAfter(CharSequence a, CharSequence b, int aIndex, int bIndex) {
        int i = aIndex, j = bIndex;
        int alen = a.length();
        int blen = b.length();
        for (; i < alen && j < blen; ++i, ++j) {
            char ca = a.charAt(i);
            char cb = b.charAt(j);
            if (ca != cb) {
                break;
            }
        }
        // if we failed a match make sure that we didn't match half a character
        int result = i - aIndex;
        if (result != 0 && !onCharacterBoundary(a, i) && !onCharacterBoundary(b, j)) {
            --result; // backup
        }
        return result;
    }
285387
public static String join(String separator, Object... values) {
		return join(Arrays.asList(values), separator);
	}
538319
public static <K, V> String joinIgnoreNull(Map<K, V> map, String separator, String keyValueSeparator) {
		return join(map, separator, keyValueSeparator, true);
	}
190574
public static String join(Collection<?> collection, String separator)
  {
    return StringUtils.join(collection, separator);
  }
1193767
public static String[] splitPreserveAllTokens(String value, char separatorChar) {
    if (value == null) {
      return ArrayUtils.EMPTY_STRING_ARRAY;
    }
    int len = value.length();
    if (len == 0) {
      return ArrayUtils.EMPTY_STRING_ARRAY;
    }
    List<String> list = new ArrayList<>();
    int i = 0;
    int start = 0;
    boolean match = false;
    boolean lastMatch = false;
    int escapeStart = -2;
    while (i < len) {
      char c = value.charAt(i);
      if (c == ESCAPE_CHAR) {
        escapeStart = i;
      }
      if (c == separatorChar && escapeStart != i - 1) {
        lastMatch = true;
        list.add(value.substring(start, i));
        match = false;
        start = ++i;
        continue;
      }
      match = true;
      i++;
    }
    if (match || lastMatch) {
      list.add(value.substring(start, i));
    }
    return list.toArray(new String[list.size()]);
  }
1128503
public static <E> String listAsString(List<E> list, String separator) {

        StringBuffer string = new StringBuffer(128);
        Iterator<E> it = list.iterator();
        while (it.hasNext()) {
            string.append(it.next());
            if (it.hasNext()) {
                string.append(separator);
            }
        }
        return string.toString();
    }
753177
public String getDelimited(String[] outTemplate, String separator) {
        StringBuilder b = new StringBuilder(1024);

        for (String var : outTemplate) {
            if (b.length() > 0) {
                b.append(separator);
            }
            b.append(getDataMap().get(var));
        }

        return b.toString();
    }
1328330
public static List<String> split(String s, String separator) {
        if (s == null) return null;
        List<String> rslt = null;
        if (s.isEmpty() || isEmpty(separator)) {
            rslt = new ArrayList<>(1);
            rslt.add(s);
            return rslt;
        }

        //return s.split(COMMA_SPLIT); - NOT WORKING when compiled to JS

        int start = 0;
        int p = start;
        do {
            int j = s.indexOf(separator, p);
            if (j == -1) {
                if (rslt == null) {
                    rslt = new ArrayList<>(1);
                    rslt.add(s);
                    return rslt;
                }
                rslt.add(s.substring(start));
                break;
            }
            if (j > 0 && s.charAt(j - 1) == '\\') {
                p = j + 1;
                continue;
            } else {
                if (rslt == null) rslt = new ArrayList<String>();
                rslt.add(s.substring(start, j));
                start = j + 1;
                p = start;
            }

        } while (true);

        return rslt;
    }
670674
public String getHintImpl(String hint, String parameter, String separator) {
		if (hint == null) {
			return null;
		}
		if (hint.indexOf(parameter) == -1) {
			return null;
		}
		String[] split = hint.split("[" + separator + "]");
		split = trim(split);
		for (int i = 0; i < split.length; i++) {
			int indexOfEq = split[i].indexOf("=");
			if (indexOfEq == -1) {
				if (split[i].equals(parameter)) {
					return "";
				}
			} else {
				if (split[i].substring(0, indexOfEq).trim().equals(parameter)) {
					return split[i].substring(indexOfEq + 1).trim();
				}
			}
		}

		// not found
		return null;
	}
865644
public static String[] split(String str, String separator){
    
    	return Pattern.compile(separator).split(str, -1);
    }
674848
public String extractToString(final String separator, final String endSeparator) throws DevFailed {
        logger.debug(LOG_EXTRACTING, this);
        return attributeImpl.extractToString(separator, endSeparator);
    }