| /* |
| ****************************************************************************** |
| * Copyright (C) 1996-2006, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ****************************************************************************** |
| * |
| ****************************************************************************** |
| */ |
| |
| package com.ibm.icu.impl; |
| |
| import java.util.Locale; |
| |
| /** |
| * A class to hold utility functions missing from java.util.Locale. |
| */ |
| public class LocaleUtility { |
| |
| /** |
| * A helper function to convert a string of the form |
| * aa_BB_CC to a locale object. Why isn't this in Locale? |
| */ |
| public static Locale getLocaleFromName(String name) { |
| String language = ""; |
| String country = ""; |
| String variant = ""; |
| |
| int i1 = name.indexOf('_'); |
| if (i1 < 0) { |
| language = name; |
| } else { |
| language = name.substring(0, i1); |
| ++i1; |
| int i2 = name.indexOf('_', i1); |
| if (i2 < 0) { |
| country = name.substring(i1); |
| } else { |
| country = name.substring(i1, i2); |
| variant = name.substring(i2+1); |
| } |
| } |
| |
| return new Locale(language, country, variant); |
| } |
| |
| /** |
| * Compare two locale strings of the form aa_BB_CC, and |
| * return true if parent is a 'strict' fallback of child, that is, |
| * if child =~ "^parent(_.+)*" (roughly). |
| */ |
| public static boolean isFallbackOf(String parent, String child) { |
| if (!child.startsWith(parent)) { |
| return false; |
| } |
| int i = parent.length(); |
| return (i == child.length() || |
| child.charAt(i) == '_'); |
| } |
| |
| /** |
| * Compare two locales, and return true if the parent is a |
| * 'strict' fallback of the child (parent string is a fallback |
| * of child string). |
| */ |
| public static boolean isFallbackOf(Locale parent, Locale child) { |
| return isFallbackOf(parent.toString(), child.toString()); |
| } |
| |
| |
| /** |
| * Convenience method that calls canonicalLocaleString(String) with |
| * locale.toString(); |
| */ |
| public static String canonicalLocaleString(Locale locale) { |
| return canonicalLocaleString(locale.toString()); |
| } |
| |
| /** |
| * You'd think that Locale canonicalizes, since it munges the |
| * renamed languages, but it doesn't quite. It forces the region |
| * to be upper case but doesn't do anything about the language or |
| * variant. Our canonical form is 'lower_UPPER_UPPER'. |
| */ |
| public static String canonicalLocaleString(String id) { |
| if (id != null) { |
| int x = id.indexOf("_"); |
| if (x == -1) { |
| id = id.toLowerCase(Locale.ENGLISH); |
| } else { |
| StringBuffer buf = new StringBuffer(); |
| buf.append(id.substring(0, x).toLowerCase(Locale.ENGLISH)); |
| buf.append(id.substring(x).toUpperCase(Locale.ENGLISH)); |
| |
| int len = buf.length(); |
| int n = len; |
| while (--n >= 0 && buf.charAt(n) == '_') { |
| } |
| if (++n != len) { |
| buf.delete(n, len); |
| } |
| id = buf.toString(); |
| } |
| } |
| return id; |
| } |
| |
| /** |
| * Fallback from the given locale name by removing the rightmost _-delimited |
| * element. If there is none, return the root locale ("", "", ""). If this |
| * is the root locale, return null. NOTE: The string "root" is not |
| * recognized; do not use it. |
| * |
| * @return a new Locale that is a fallback from the given locale, or null. |
| */ |
| public static Locale fallback(Locale loc) { |
| |
| // Split the locale into parts and remove the rightmost part |
| String[] parts = new String[] |
| { loc.getLanguage(), loc.getCountry(), loc.getVariant() }; |
| int i; |
| for (i=2; i>=0; --i) { |
| if (parts[i].length() != 0) { |
| parts[i] = ""; |
| break; |
| } |
| } |
| if (i<0) { |
| return null; // All parts were empty |
| } |
| return new Locale(parts[0], parts[1], parts[2]); |
| } |
| } |