1 /* 2 * Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /* 27 ******************************************************************************* 28 * Copyright (C) 2009, International Business Machines Corporation and * 29 * others. All Rights Reserved. * 30 ******************************************************************************* 31 */ 32 package sun.util.locale; 33 34 import java.util.List; 35 import java.util.Map; 36 import java.util.Set; 37 38 /** 39 * Collection of static utility methods for Locale support. The 40 * methods which manipulate characters or strings support ASCII only. 41 */ 42 public final class LocaleUtils { 43 LocaleUtils()44 private LocaleUtils() { 45 } 46 47 /** 48 * Compares two ASCII Strings s1 and s2, ignoring case. 49 */ caseIgnoreMatch(String s1, String s2)50 public static boolean caseIgnoreMatch(String s1, String s2) { 51 if (s1 == s2) { 52 return true; 53 } 54 55 int len = s1.length(); 56 if (len != s2.length()) { 57 return false; 58 } 59 60 for (int i = 0; i < len; i++) { 61 char c1 = s1.charAt(i); 62 char c2 = s2.charAt(i); 63 if (c1 != c2 && toLower(c1) != toLower(c2)) { 64 return false; 65 } 66 } 67 return true; 68 } 69 caseIgnoreCompare(String s1, String s2)70 static int caseIgnoreCompare(String s1, String s2) { 71 if (s1 == s2) { 72 return 0; 73 } 74 return toLowerString(s1).compareTo(toLowerString(s2)); 75 } 76 toUpper(char c)77 static char toUpper(char c) { 78 return isLower(c) ? (char)(c - 0x20) : c; 79 } 80 toLower(char c)81 static char toLower(char c) { 82 return isUpper(c) ? (char)(c + 0x20) : c; 83 } 84 85 /** 86 * Converts the given ASCII String to lower-case. 87 */ toLowerString(String s)88 public static String toLowerString(String s) { 89 int len = s.length(); 90 int idx = 0; 91 for (; idx < len; idx++) { 92 if (isUpper(s.charAt(idx))) { 93 break; 94 } 95 } 96 if (idx == len) { 97 return s; 98 } 99 100 char[] buf = new char[len]; 101 for (int i = 0; i < len; i++) { 102 char c = s.charAt(i); 103 buf[i] = (i < idx) ? c : toLower(c); 104 } 105 return new String(buf); 106 } 107 toUpperString(String s)108 static String toUpperString(String s) { 109 int len = s.length(); 110 int idx = 0; 111 for (; idx < len; idx++) { 112 if (isLower(s.charAt(idx))) { 113 break; 114 } 115 } 116 if (idx == len) { 117 return s; 118 } 119 120 char[] buf = new char[len]; 121 for (int i = 0; i < len; i++) { 122 char c = s.charAt(i); 123 buf[i] = (i < idx) ? c : toUpper(c); 124 } 125 return new String(buf); 126 } 127 toTitleString(String s)128 static String toTitleString(String s) { 129 int len; 130 if ((len = s.length()) == 0) { 131 return s; 132 } 133 int idx = 0; 134 if (!isLower(s.charAt(idx))) { 135 for (idx = 1; idx < len; idx++) { 136 if (isUpper(s.charAt(idx))) { 137 break; 138 } 139 } 140 } 141 if (idx == len) { 142 return s; 143 } 144 145 char[] buf = new char[len]; 146 for (int i = 0; i < len; i++) { 147 char c = s.charAt(i); 148 if (i == 0 && idx == 0) { 149 buf[i] = toUpper(c); 150 } else if (i < idx) { 151 buf[i] = c; 152 } else { 153 buf[i] = toLower(c); 154 } 155 } 156 return new String(buf); 157 } 158 isUpper(char c)159 private static boolean isUpper(char c) { 160 return c >= 'A' && c <= 'Z'; 161 } 162 isLower(char c)163 private static boolean isLower(char c) { 164 return c >= 'a' && c <= 'z'; 165 } 166 isAlpha(char c)167 static boolean isAlpha(char c) { 168 return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); 169 } 170 isAlphaString(String s)171 static boolean isAlphaString(String s) { 172 int len = s.length(); 173 for (int i = 0; i < len; i++) { 174 if (!isAlpha(s.charAt(i))) { 175 return false; 176 } 177 } 178 return true; 179 } 180 isNumeric(char c)181 static boolean isNumeric(char c) { 182 return (c >= '0' && c <= '9'); 183 } 184 isNumericString(String s)185 static boolean isNumericString(String s) { 186 int len = s.length(); 187 for (int i = 0; i < len; i++) { 188 if (!isNumeric(s.charAt(i))) { 189 return false; 190 } 191 } 192 return true; 193 } 194 isAlphaNumeric(char c)195 static boolean isAlphaNumeric(char c) { 196 return isAlpha(c) || isNumeric(c); 197 } 198 isAlphaNumericString(String s)199 public static boolean isAlphaNumericString(String s) { 200 int len = s.length(); 201 for (int i = 0; i < len; i++) { 202 if (!isAlphaNumeric(s.charAt(i))) { 203 return false; 204 } 205 } 206 return true; 207 } 208 isEmpty(String str)209 static boolean isEmpty(String str) { 210 return str == null || str.length() == 0; 211 } 212 isEmpty(Set<?> set)213 static boolean isEmpty(Set<?> set) { 214 return set == null || set.isEmpty(); 215 } 216 isEmpty(Map<?, ?> map)217 static boolean isEmpty(Map<?, ?> map) { 218 return map == null || map.isEmpty(); 219 } 220 isEmpty(List<?> list)221 static boolean isEmpty(List<?> list) { 222 return list == null || list.isEmpty(); 223 } 224 } 225