1 /*

     2  * Copyright (c) 2010, 2011, 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 

    44     private LocaleUtils() {

    45     }

    46 

    47     /**

    48      * Compares two ASCII Strings s1 and s2, ignoring case.

    49      */

    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 

    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 

    77     static char toUpper(char c) {

    78         return isLower(c) ? (char)(c - 0x20) : c;

    79     }

    80 

    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      */

    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 

   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 

   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 

   159     private static boolean isUpper(char c) {

   160         return c >= 'A' && c <= 'Z';

   161     }

   162 

   163     private static boolean isLower(char c) {

   164         return c >= 'a' && c <= 'z';

   165     }

   166 

   167     static boolean isAlpha(char c) {

   168         return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');

   169     }

   170 

   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 

   181     static boolean isNumeric(char c) {

   182         return (c >= '0' && c <= '9');

   183     }

   184 

   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 

   195     static boolean isAlphaNumeric(char c) {

   196         return isAlpha(c) || isNumeric(c);

   197     }

   198 

   199     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 

   209     static boolean isEmpty(String str) {

   210         return str == null || str.length() == 0;

   211     }

   212 

   213     static boolean isEmpty(Set<?> set) {

   214         return set == null || set.isEmpty();

   215     }

   216 

   217     static boolean isEmpty(Map<?, ?> map) {

   218         return map == null || map.isEmpty();

   219     }

   220 

   221     static boolean isEmpty(List<?> list) {

   222         return list == null || list.isEmpty();

   223     }

   224 }