HC specific settings, operands etc. use this method.
Creates an uppercase string from the given string.

@param s the given string
@return an uppercase string, or {@code null}/empty if the string is {@code null}/empty
176030
public static String upperCaseInternal(String s) {
        if (isNullOrEmpty(s)) {
            return s;
        }
        return s.toUpperCase(LOCALE_INTERNAL);
    }
387826
public static String toUpperCase(String string) {
    int length = string.length();
    for (int i = 0; i < length; i++) {
      if (isLowerCase(string.charAt(i))) {
        char[] chars = string.toCharArray();
        for (; i < length; i++) {
          char c = chars[i];
          if (isLowerCase(c)) {
            chars[i] = (char) (c & 0x5f);
          }
        }
        return String.valueOf(chars);
      }
    }
    return string;
  }
601941
public static String nullIfEmpty(String s) {
      if (s != null && s.length() == 0) {
         return null;
      } else {
         return s;
      }
   }
1324810
public AsciiString toUpperCase() {
        boolean uppercased = true;
        int i, j;
        final int len = length() + arrayOffset();
        for (i = arrayOffset(); i < len; ++i) {
            byte b = value[i];
            if (b >= 'a' && b <= 'z') {
                uppercased = false;
                break;
            }
        }

        // Check if this string does not contain any lowercase characters.
        if (uppercased) {
            return this;
        }

        final byte[] newValue = PlatformDependent.allocateUninitializedArray(length());
        for (i = 0, j = arrayOffset(); i < newValue.length; ++i, ++j) {
            newValue[i] = toUpperCase(value[j]);
        }

        return new AsciiString(newValue, false);
    }
937888
public String form( String s ) {
        if (fmt != 's') {
            throw new java.lang.IllegalArgumentException();
        }
        if (precision >= 0 && precision < s.length()) {
            s = s.substring(0, precision);
        }

        return pad(s);
    }
566084
public static String toLowerString(String s) {
        int len = s.length();
        int idx = 0;
        for (; idx < len; idx++) {
            if (isUpper(s.charAt(idx))) {
                break;
            }
        }
        if (idx == len) {
            return s;
        }

        char[] buf = new char[len];
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
            buf[i] = (i < idx) ? c : toLower(c);
        }
        return new String(buf);
    }
902415
public static String toLowerCase(final String s) {
        if (s == null) {
            return null;
        } else {
            return s.toLowerCase(Locale.ENGLISH);
        }
    }
691218
public static String capitalize(String s) {
		if (s == null || isEmpty(s)) {
			return s;
		}
		return (new StringBuilder(s.length())).append(Character.toTitleCase(s.charAt(0))).append(s.substring(1)).toString();
	}
613695
public static String initCap(String str) {
        assertStringNotNull(str);
        if (is_Null_or_Empty(str)) {
            return str;
        }
        if (str.length() == 1) {
            return str.toUpperCase();
        }
        final char chars[] = str.toCharArray();
        chars[0] = Character.toUpperCase(chars[0]);
        return new String(chars);
    }
341424
public static String encodeString(String s) {

        try {
            return CODEC.encode(s.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            // shouldn't happen
            return null;
        }
    }
175021
public static boolean startWith(@Nullable CharSequence s, char c) {
		if (StringUtils.isEmpty(s)) {
			return false;
		}
		return s.charAt(0) == c;
	}
1104988
public static String normalize(String s) {
    StringBuilder b = new StringBuilder();
    for (int i = 0; i < s.length(); i++)
      b.append(normalize(s.charAt(i)));
    return (b.toString());
  }
788360
private static String upperCaseHex(String s) {
        char chars[] = s.toCharArray();
        int length = s.length();

        for (int i = 0; i < length; i++) {

            switch (chars[i]) {
                case 'a':
                    chars[i] = 'A';
                    break;
                case 'b':
                    chars[i] = 'B';
                    break;
                case 'c':
                    chars[i] = 'C';
                    break;
                case 'd':
                    chars[i] = 'D';
                    break;
                case 'e':
                    chars[i] = 'E';
                    break;
                case 'f':
                    chars[i] = 'F';
                    break;
            }
        }

        return new String(chars);
    }
80269
public static String[] tokenize(final String s) {
        final List<String> result = new ArrayList<>();
        
        int start = 0;                  // start of current token
        boolean uppercaseToken = false; // if current token is all uppercase
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (! Character.isJavaIdentifierPart(c) ||
                (result.isEmpty() && start == i &&
                    !Character.isJavaIdentifierStart(c))) {
                // This character should not appear in a Java name at all,
                // or this would be the first character of the result, 
                //    but it is not valid here.
                // Treat it as a separator.
                c = '_';
            }
            if (Character.isLowerCase(c) || Character.isDigit(c)) {
                // the token goes on, unless it's all uppercase
                if (uppercaseToken) {
                    // uppercase token ends here. The last uppercase
                    // character already was part of the next token.
                    add(result, start, i-1, s);
                    start = i-1;
                    // this is no uppercase token
                    uppercaseToken = false;
                }
            } else if (Character.isUpperCase(c)) {
                if (!uppercaseToken) {
                    // token ends here, new token starts
                    add(result, start, i, s);
                    start = i;
                }
                if (start == i) {
                    // first character is uppercase, this has potential for
                    // being an uppercase token, such as "HTTP"
                    uppercaseToken = true;
                } else {
                    assert uppercaseToken : "token should be uppercase";
                }
            } else { // c == '_'
                // token ends here, next char is start of next token
                add(result, start, i, s);
                start = i+1;
                // if this was an uppercase token, it ends now anyway
                uppercaseToken = false;
            }
        }
        // add last token
        add(result, start, s.length(), s);

        return result.toArray(new String[result.size()]);
    }
1076152
public static String convertCase(Match.CaseConversion conversion, String s, String sample, Language lang) {
    if (StringTools.isEmpty(s)) {
      return s;
    }
    String token = s;
    switch (conversion) {
      case NONE:
        break;
      case PRESERVE:
        if (StringTools.startsWithUppercase(sample)) {
          if (StringTools.isAllUppercase(sample)) {
            token = token.toUpperCase(Locale.ENGLISH);
          } else {
            token = StringTools.uppercaseFirstChar(token, lang);
          }
        }
        break;
      case STARTLOWER:
        token = token.substring(0, 1).toLowerCase() + token.substring(1);
        break;
      case STARTUPPER:
        token = StringTools.uppercaseFirstChar(token, lang);
        break;
      case ALLUPPER:
        token = token.toUpperCase(Locale.ENGLISH);
        break;
      case ALLLOWER:
        token = token.toLowerCase();
        break;
      default:
        break;
    }
    return token;
  }
942053
function stringCase(str, caseValue) {
		switch (String(caseValue || '').toLowerCase()) {
			case 'lower':
				return str.toLowerCase();
			case 'upper':
				return str.toUpperCase();
		}
		
		return str;
	}
605364
public static String normalizeCharset(String s) {
        String n = CHARSETS.get(s);
        return (n == null) ? s : n;
    }