private boolean hasUpperCase() { for (char c : chars) { if (Ascii.isUpperCase(c)) { return true; } } return false; }
/** * If the argument is an {@linkplain #isUpperCase(char) uppercase ASCII character} returns the * lowercase equivalent. Otherwise returns the argument. */ public static char toLowerCase(char c) { return isUpperCase(c) ? (char) (c ^ CASE_MASK) : c; }
private boolean hasUpperCase() { for (char c : chars) { if (Ascii.isUpperCase(c)) { return true; } } return false; }
/** * If the argument is an {@linkplain #isUpperCase(char) uppercase ASCII character} returns the * lowercase equivalent. Otherwise returns the argument. */ public static char toLowerCase(char c) { return isUpperCase(c) ? (char) (c ^ CASE_MASK) : c; }
private boolean hasUpperCase() { for (char c : chars) { if (Ascii.isUpperCase(c)) { return true; } } return false; }
/** * If the argument is an {@linkplain #isUpperCase(char) uppercase ASCII character} returns the * lowercase equivalent. Otherwise returns the argument. */ public static char toLowerCase(char c) { return isUpperCase(c) ? (char) (c ^ CASE_MASK) : c; }
/** * Returns a copy of the input string in which all {@linkplain #isUpperCase(char) uppercase ASCII * characters} have been converted to lowercase. All other characters are copied without * modification. */ public static String toLowerCase(String string) { int length = string.length(); for (int i = 0; i < length; i++) { if (isUpperCase(string.charAt(i))) { char[] chars = string.toCharArray(); for (; i < length; i++) { char c = chars[i]; if (isUpperCase(c)) { chars[i] = (char) (c ^ CASE_MASK); } } return String.valueOf(chars); } } return string; }
@VisibleForTesting static String fromSecondLevel(String qualifiedTemplateClass) { List<String> path = Splitter.on('.').splitToList(qualifiedTemplateClass); for (int topLevel = 0; topLevel < path.size() - 1; topLevel++) { if (Ascii.isUpperCase(path.get(topLevel).charAt(0))) { return Joiner.on('_').join(path.subList(topLevel + 1, path.size())); } } return Iterables.getLast(path); }
/** * Returns a copy of the input string in which all {@linkplain #isUpperCase(char) uppercase ASCII * characters} have been converted to lowercase. All other characters are copied without * modification. */ public static String toLowerCase(String string) { int length = string.length(); for (int i = 0; i < length; i++) { if (isUpperCase(string.charAt(i))) { char[] chars = string.toCharArray(); for (; i < length; i++) { char c = chars[i]; if (isUpperCase(c)) { chars[i] = (char) (c ^ CASE_MASK); } } return String.valueOf(chars); } } return string; }
/** * Returns a copy of the input string in which all {@linkplain #isUpperCase(char) uppercase ASCII * characters} have been converted to lowercase. All other characters are copied without * modification. */ public static String toLowerCase(String string) { int length = string.length(); for (int i = 0; i < length; i++) { if (isUpperCase(string.charAt(i))) { char[] chars = string.toCharArray(); for (; i < length; i++) { char c = chars[i]; if (isUpperCase(c)) { chars[i] = (char) (c ^ CASE_MASK); } } return String.valueOf(chars); } } return string; }
@Override public String apply(String input) { unresolved = false; boolean assumedUnqualified = Ascii.isUpperCase(input.charAt(0)); if (assumedUnqualified) { input = qualifyImportedIfPossible(input, false); } return input; }
public String apply(String input) { if (!input.isEmpty()) { if (this == CAPITALIZED && !Ascii.isUpperCase(input.charAt(0))) { return CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, input); } if (this == LOWERIZED && !Ascii.isLowerCase(input.charAt(0))) { return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, input); } } return input; } }
String resolveTopForAttribute(String input) { unresolved = false; boolean assumedUnqualified = Ascii.isUpperCase(input.charAt(0)); if (assumedUnqualified) { input = qualifyImportedIfPossible(input, !unresolvedYetArguments.contains(input)); } return input; }
@Override public String detect(String identifier) { if (identifier.length() <= lengthsOfPrefixAndSuffix) { return NOT_DETECTED; } boolean prefixMatches = prefix.isEmpty() || (identifier.startsWith(prefix) && Ascii.isUpperCase(identifier.charAt(prefix.length()))); boolean suffixMatches = suffix.isEmpty() || identifier.endsWith(suffix); if (prefixMatches && suffixMatches) { String detected = identifier.substring(prefix.length(), identifier.length() - suffix.length()); return prefix.isEmpty() ? detected : CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, detected); } return NOT_DETECTED; }
@VisibleForTesting static String toHeaderName(String name) { requireNonNull(name, "name"); checkArgument(!name.isEmpty(), "name is empty"); final String upperCased = Ascii.toUpperCase(name); if (name.equals(upperCased)) { return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_HYPHEN, name); } final String lowerCased = Ascii.toLowerCase(name); if (name.equals(lowerCased)) { return CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_HYPHEN, name); } // Ensure that the name does not contain '_'. // If it contains '_', we give up to make it lower hyphen case. Just converting it to lower case. if (name.indexOf('_') >= 0) { return lowerCased; } if (Ascii.isUpperCase(name.charAt(0))) { return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, name); } else { return CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, name); } }
&& Ascii.isUpperCase(identifier.charAt(1)) && Ascii.isLowerCase(identifier.charAt(2))) {
private static boolean shouldDisableFor(Reporter reporter, Element element) { while (element != null) { if (element.getKind() == ElementKind.PACKAGE) { for (String segment : DOT_SPLITTER.split(((PackageElement) element).getQualifiedName())) { if (!segment.isEmpty() && Ascii.isUpperCase(segment.charAt(0))) { reporter.warning(About.INCOMPAT, WARNING_START + " uppercase package names"); return true; } } } if (element.getKind().isClass() || element.getKind().isInterface()) { if (Ascii.isLowerCase(element.getSimpleName().charAt(0))) { reporter.warning(About.INCOMPAT, WARNING_START + " lowercase class names"); return true; } } element = element.getEnclosingElement(); } return false; } }
public void testCharsLower() { for (char c : LOWER.toCharArray()) { String str = String.valueOf(c); assertTrue(str, c == Ascii.toLowerCase(c)); assertFalse(str, c == Ascii.toUpperCase(c)); assertTrue(str, Ascii.isLowerCase(c)); assertFalse(str, Ascii.isUpperCase(c)); } }
public void testCharsUpper() { for (char c : UPPER.toCharArray()) { String str = String.valueOf(c); assertFalse(str, c == Ascii.toLowerCase(c)); assertTrue(str, c == Ascii.toUpperCase(c)); assertFalse(str, Ascii.isLowerCase(c)); assertTrue(str, Ascii.isUpperCase(c)); } }
public void testCharsIgnored() { for (char c : IGNORED.toCharArray()) { String str = String.valueOf(c); assertTrue(str, c == Ascii.toLowerCase(c)); assertTrue(str, c == Ascii.toUpperCase(c)); assertFalse(str, Ascii.isLowerCase(c)); assertFalse(str, Ascii.isUpperCase(c)); } }