src/com/ibm/icu/impl/ICULocaleService.java - external/github.com/unicode-org/icu - Git at Google

 /**
  *******************************************************************************
  * Copyright (C) 2001-2002, International Business Machines Corporation and    *
  * others. All Rights Reserved.                                                *
  *******************************************************************************
  *
  * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/impl/ICULocaleService.java,v $
  * $Date: 2002/08/13 23:40:52 $
  * $Revision: 1.5 $
  *
  *******************************************************************************
  */
 package com.ibm.icu.impl;

 import java.lang.ref.SoftReference;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Locale;
 import java.util.Map;
 import java.util.ResourceBundle;
 import java.util.Set;


 public class ICULocaleService extends ICUService {
     Locale fallbackLocale;
     String fallbackLocaleName;

     /**
      * Construct an ICULocaleService with a fallback locale string based on the current
      * default locale at the time of construction.
      */
     public ICULocaleService() {
 	fallbackLocale = Locale.getDefault();
 	fallbackLocaleName = LocaleUtility.canonicalLocaleString(fallbackLocale.toString());
     }

     /**
      * A subclass of Key that implements a locale fallback mechanism.
      * The first locale to search for is the locale provided by the
      * client, and the fallback locale to search for is the current default
      * locale.  This is instantiated by ICULocaleService.</p>
      *
      * <p>Canonicalization adjusts the locale string so that the
      * section before the first understore is in lower case, and the rest
      * is in upper case, with no trailing underscores.</p>
      */
     public static class LocaleKey extends ICUService.Key {
 	private String primaryID;
 	private String fallbackID;
 	private String currentID;

 	/**
 	 * Convenience method for createWithCanonical that canonicalizes both the
 	 * primary and fallback IDs first.
 	 */
 	public static LocaleKey create(String primaryID, String fallbackID) {
 	    String canonicalPrimaryID = LocaleUtility.canonicalLocaleString(primaryID);
 	    String canonicalFallbackID = LocaleUtility.canonicalLocaleString(fallbackID);
 	    return new LocaleKey(primaryID, canonicalPrimaryID, canonicalFallbackID);
 	}

 	/**
 	 * Convenience method for createWithCanonical that canonicalizes the
 	 * primary ID first, the fallback is assumed to already be canonical.
 	 */
 	public static LocaleKey createWithCanonicalFallback(String primaryID, String canonicalFallbackID) {
 	    String canonicalPrimaryID = LocaleUtility.canonicalLocaleString(primaryID);
 	    return new LocaleKey(primaryID, canonicalPrimaryID, canonicalFallbackID);
 	}

 	/**
 	 * Create a LocaleKey with canonical primary and fallback IDs.
 	 */
 	public static LocaleKey createWithCanonical(String canonicalPrimaryID, String canonicalFallbackID) {
 	    return new LocaleKey(canonicalPrimaryID, canonicalPrimaryID, canonicalFallbackID);
 	}

 	/**
 	 * PrimaryID is the user's requested locale string,
 	 * canonicalPrimaryID is this string in canonical form,
 	 * fallbackID is the current default locale's string in
 	 * canonical form.
 	 */
         protected LocaleKey(String primaryID, String canonicalPrimaryID, String canonicalFallbackID) {
 	    super(primaryID);

 	    if (canonicalPrimaryID == null) {
 		this.primaryID = "";
 	    } else {
 		this.primaryID = canonicalPrimaryID;
 	    }
 	    if (this.primaryID == "") {
 		this.fallbackID = null;
 	    } else {
 		if (canonicalFallbackID == null || this.primaryID.equals(canonicalFallbackID)) {
 		    this.fallbackID = "";
 		} else {
 		    this.fallbackID = canonicalFallbackID;
 		}
 	    }

 	    this.currentID = this.primaryID;
         }

 	/**
 	 * Return the (canonical) original ID.
 	 */
 	public String canonicalID() {
 	    return primaryID;
 	}

         /**
          * Return the (canonical) current ID.
          */
         public String currentID() {
 	    return currentID;
         }

         /**
          * If the key has a fallback, modify the key and return true,
          * otherwise return false.</p>
 	 *
 	 * <p>First falls back through the primary ID, then through
 	 * the fallbackID.  The final fallback is the empty string,
 	 * unless the primary id was the empty string, in which case
 	 * there is no fallback.
 	 */
         public boolean fallback() {
 	    String current = currentID();
 	    int x = current.lastIndexOf('_');
 	    if (x != -1) {
 		currentID = current.substring(0, x);
 		return true;
 	    }
 	    if (fallbackID != null) {
 		currentID = fallbackID;
 		fallbackID = fallbackID.length() == 0 ? null : "";
 		return true;
 	    }
 	    currentID = null;
 	    return false;
         }
     }

     /**
      * This is a factory that handles multiple keys, and records
      * information about the keys it handles or doesn't handle.  This
      * allows it to quickly filter subsequent queries on keys it has
      * seen before.  Subclasses implement handleCreate instead of
      * create.  Before updateVisibleIDs is called, it keeps track of
      * keys that it doesn't handle.  If its ids are visible, once
      * updateVisibleIDs is called, it builds a set of all the keys it
      * does handle and keeps track of the keys it does handle.
      */
     public static abstract class MultipleKeyFactory implements ICUService.Factory {
 	protected final boolean visible;
 	private SoftReference cacheref;
 	private boolean included;

 	/**
 	 * Convenience overload of MultipleKeyFactory(boolean) that defaults
 	 * visible to true.
 	 */
 	public MultipleKeyFactory() {
 	    this(true);
 	}

 	/**
 	 * Constructs a MultipleKeyFactory whose ids are visible iff visible is true.
 	 */
 	public MultipleKeyFactory(boolean visible) {
 	    this.visible = visible;
 	}

 	/**
 	 * Get the cache of IDs.  These are either the ids that we know we
 	 * don't understand, if included is false, or the entire set of ids
 	 * we do know we understand, if included is true.  Note that if
 	 * the cache has been freed by gc, we reset the included flag, so
 	 * it must not be tested before this method is called.
 	 */
 	private HashSet getCache() {
 	    HashSet cache = null;
 	    if (cacheref != null) {
 		cache = (HashSet)cacheref.get();
 	    }
 	    if (cache == null) {
 		cache = new HashSet();
 		cacheref = new SoftReference(cache);
 		included = false;
 	    }
 	    return cache;
 	}

 	/**
 	 * Get the cache of IDs we understand.
 	 */
 	private HashSet getIncludedCache() {
 	    HashSet cache = getCache();
 	    if (!included) {
 		cache.clear();
 		handleUpdateVisibleIDs(cache);
 		included = true;
 	    }
 	    return cache;
 	}

 	public final Object create(Key key) {
 	    Object result = null;
 	    String id = key.currentID();
 	    HashSet cache = getCache();
 	    if (cache.contains(id) == included) {
 		result = handleCreate(key);
 		if (!included && result == null) {
 		    cache.add(id);
 		}
 	    }
 	    return result;
 	}

 	public final void updateVisibleIDs(Map result) {
 	    if (visible) {
 		Set cache = getIncludedCache();
 		Iterator iter = cache.iterator();
 		while (iter.hasNext()) {
 		    result.put((String)iter.next(), this);
 		}
 	    }
 	}

 	public final String getDisplayName(String id, Locale locale) {
 	    if (visible) {
 		Set cache = getIncludedCache();
 		if (cache.contains(id)) {
 		    return handleGetDisplayName(id, locale);
 		}
 	    }
 	    return null;
 	}

 	/**
 	 * Subclasses implement this instead of create.
 	 */
 	protected abstract Object handleCreate(Key key);

 	/**
 	 * Subclasses implement this instead of updateVisibleIDs.  Any
 	 * id known to and handled by this class should be added to
 	 * result.
 	 */
 	protected abstract void handleUpdateVisibleIDs(Set result);

 	/**
 	 * Subclasses implement this instead of getDisplayName.
 	 * Return the display name for the (visible) id in the
 	 * provided locale.  The default implementation just returns
 	 * the id.
 	 */
 	protected String handleGetDisplayName(String id, Locale locale) {
 	    return id;
 	}
     }

     /**
      * A factory that creates a service based on the ICU locale data.
      * Subclasses specify a prefix (default is LocaleElements), a
      * semicolon-separated list of required resources, and a visible flag.
      * This factory will search the ICU locale data for a bundle with
      * the exact prefix.  Then it will test whether the required resources
      * are all in this exact bundle.  If so, it instantiates the full
      * resource bundle, and hands it to createServiceFromResource, which
      * subclasses must implement.  Otherwise it returns null.
      */
     public static class ICUResourceBundleFactory extends MultipleKeyFactory {
 	protected final String name;
 	protected final String[] requiredContents;

 	/**
 	 * A service factory based on ICU resource data in the LocaleElements resources.
 	 */
 	public ICUResourceBundleFactory(String requiredContents, boolean visible) {
 	    this(ICULocaleData.LOCALE_ELEMENTS, requiredContents, visible);
 	}

 	/**
 	 * A service factory based on ICU resource data in resources
 	 * with the given name.  If requiredContents is not null, all
 	 * listed resources must come directly from the same bundle.
 	 */
 	public ICUResourceBundleFactory(String name, String requiredContents, boolean visible) {
 	    super(visible);

 	    this.name = name;
 	    if (requiredContents != null) {
 		ArrayList list = new ArrayList();
 		for (int i = 0, len = requiredContents.length();;) {
 		    while (i < len && requiredContents.charAt(i) == ';') {
 			++i;
 		    }
 		    if (i == len) {
 		      break;
 		    }
 		    int j = requiredContents.indexOf(';', i);
 		    if (j == -1) {
 		      j = len;
 		    }
 		    list.add(requiredContents.substring(i, j));
 		    i = j;
 		}
 		this.requiredContents = (String[])list.toArray(new String[list.size()]);
 	    } else {
 		this.requiredContents = null;
 	    }
 	}

 	/**
 	 * Overrides parent handleCreate call.  Parent will filter out keys that it
 	 * knows are not accepted by this factory before calling this method.
 	 */
 	protected Object handleCreate(Key key) {
 	    Locale loc = LocaleUtility.getLocaleFromName(key.currentID());
 	    if (acceptsLocale(loc)) {
 		ResourceBundle bundle = ICULocaleData.getResourceBundle(name, loc); // full resource bundle tree lookup
 		return createFromBundle(bundle, key);
 	    }
 	    return null;
 	}

 	/**
 	 * Queries all the available locales in ICU and adds the names
 	 * of those which it accepts to result.  This is quite
 	 * time-consuming so we don't want to do it more than once if
 	 * we have to.  This is only called if we are visible.
 	 */
 	protected void handleUpdateVisibleIDs(Set result) {
 	    Locale[] locales = ICULocaleData.getAvailableLocales(name);
 	    for (int i = 0; i < locales.length; ++i) {
 		Locale locale = locales[i];
 		if (acceptsLocale(locale)) {
 		    result.add(LocaleUtility.canonicalLocaleString(locale.toString()));
 		}
 	    }
 	}

 	/**
 	 * Return a localized name for the locale represented by id.
 	 */
 	protected String handleGetDisplayName(String id, Locale locale) {
 	    // use java's display name formatting for now
 	    return LocaleUtility.getLocaleFromName(id).getDisplayName(locale);
 	}

 	/**
 	 * We only accept the locale if there is a bundle for this exact locale and if
 	 * all the required resources are directly in this bundle (none is from an
 	 * inherited bundle);
 	 */
 	protected boolean acceptsLocale(Locale loc) {
 	    try {
 		ResourceBundle bundle = ICULocaleData.loadResourceBundle(name, loc); // single resource bundle lookup
 		if (requiredContents != null) {
 		    for (int i = 0; i < requiredContents.length; ++i) {
 			if (bundle.getObject(requiredContents[i]) == null) {
 			    return false;
 			}
 		    }
 		}
 		return true;
 	    }
 	    catch (Exception e) {
 	    }
 	    return false;
 	}

 	/**
 	 * Subclassers implement this to create their service object based on the bundle and key.
 	 * The default implementation just returns the bundle.
 	 */
          protected Object createFromBundle(ResourceBundle bundle, Key key) {
 	     return bundle;
          }
     }

     protected Key createKey(String id) {
 	Locale loc = Locale.getDefault();
 	if (loc != fallbackLocale) {
 	    synchronized (this) {
 		if (loc != fallbackLocale) {
 		    fallbackLocale = loc;
 		    fallbackLocaleName = LocaleUtility.canonicalLocaleString(loc.toString());
 		    clearServiceCache();
 		}
 	    }
 	}

 	return LocaleKey.createWithCanonicalFallback(id, fallbackLocaleName);
     }
 }
	/**
	*******************************************************************************
	* Copyright (C) 2001-2002, International Business Machines Corporation and *
	* others. All Rights Reserved. *
	*******************************************************************************
	*
	* $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/impl/ICULocaleService.java,v $
	* $Date: 2002/08/13 23:40:52 $
	* $Revision: 1.5 $
	*
	*******************************************************************************
	*/
	package com.ibm.icu.impl;

	import java.lang.ref.SoftReference;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Locale;
	import java.util.Map;
	import java.util.ResourceBundle;
	import java.util.Set;


	public class ICULocaleService extends ICUService {
	Locale fallbackLocale;
	String fallbackLocaleName;

	/**
	* Construct an ICULocaleService with a fallback locale string based on the current
	* default locale at the time of construction.
	*/
	public ICULocaleService() {
	fallbackLocale = Locale.getDefault();
	fallbackLocaleName = LocaleUtility.canonicalLocaleString(fallbackLocale.toString());
	}

	/**
	* A subclass of Key that implements a locale fallback mechanism.
	* The first locale to search for is the locale provided by the
	* client, and the fallback locale to search for is the current default
	* locale. This is instantiated by ICULocaleService.</p>
	*
	* <p>Canonicalization adjusts the locale string so that the
	* section before the first understore is in lower case, and the rest
	* is in upper case, with no trailing underscores.</p>
	*/
	public static class LocaleKey extends ICUService.Key {
	private String primaryID;
	private String fallbackID;
	private String currentID;

	/**
	* Convenience method for createWithCanonical that canonicalizes both the
	* primary and fallback IDs first.
	*/
	public static LocaleKey create(String primaryID, String fallbackID) {
	String canonicalPrimaryID = LocaleUtility.canonicalLocaleString(primaryID);
	String canonicalFallbackID = LocaleUtility.canonicalLocaleString(fallbackID);
	return new LocaleKey(primaryID, canonicalPrimaryID, canonicalFallbackID);
	}

	/**
	* Convenience method for createWithCanonical that canonicalizes the
	* primary ID first, the fallback is assumed to already be canonical.
	*/
	public static LocaleKey createWithCanonicalFallback(String primaryID, String canonicalFallbackID) {
	String canonicalPrimaryID = LocaleUtility.canonicalLocaleString(primaryID);
	return new LocaleKey(primaryID, canonicalPrimaryID, canonicalFallbackID);
	}

	/**
	* Create a LocaleKey with canonical primary and fallback IDs.
	*/
	public static LocaleKey createWithCanonical(String canonicalPrimaryID, String canonicalFallbackID) {
	return new LocaleKey(canonicalPrimaryID, canonicalPrimaryID, canonicalFallbackID);
	}

	/**
	* PrimaryID is the user's requested locale string,
	* canonicalPrimaryID is this string in canonical form,
	* fallbackID is the current default locale's string in
	* canonical form.
	*/
	protected LocaleKey(String primaryID, String canonicalPrimaryID, String canonicalFallbackID) {
	super(primaryID);

	if (canonicalPrimaryID == null) {
	this.primaryID = "";
	} else {
	this.primaryID = canonicalPrimaryID;
	}
	if (this.primaryID == "") {
	this.fallbackID = null;
	} else {
	if (canonicalFallbackID == null \|\| this.primaryID.equals(canonicalFallbackID)) {
	this.fallbackID = "";
	} else {
	this.fallbackID = canonicalFallbackID;
	}
	}

	this.currentID = this.primaryID;
	}

	/**
	* Return the (canonical) original ID.
	*/
	public String canonicalID() {
	return primaryID;
	}

	/**
	* Return the (canonical) current ID.
	*/
	public String currentID() {
	return currentID;
	}

	/**
	* If the key has a fallback, modify the key and return true,
	* otherwise return false.</p>
	*
	* <p>First falls back through the primary ID, then through
	* the fallbackID. The final fallback is the empty string,
	* unless the primary id was the empty string, in which case
	* there is no fallback.
	*/
	public boolean fallback() {
	String current = currentID();
	int x = current.lastIndexOf('_');
	if (x != -1) {
	currentID = current.substring(0, x);
	return true;
	}
	if (fallbackID != null) {
	currentID = fallbackID;
	fallbackID = fallbackID.length() == 0 ? null : "";
	return true;
	}
	currentID = null;
	return false;
	}
	}

	/**
	* This is a factory that handles multiple keys, and records
	* information about the keys it handles or doesn't handle. This
	* allows it to quickly filter subsequent queries on keys it has
	* seen before. Subclasses implement handleCreate instead of
	* create. Before updateVisibleIDs is called, it keeps track of
	* keys that it doesn't handle. If its ids are visible, once
	* updateVisibleIDs is called, it builds a set of all the keys it
	* does handle and keeps track of the keys it does handle.
	*/
	public static abstract class MultipleKeyFactory implements ICUService.Factory {
	protected final boolean visible;
	private SoftReference cacheref;
	private boolean included;

	/**
	* Convenience overload of MultipleKeyFactory(boolean) that defaults
	* visible to true.
	*/
	public MultipleKeyFactory() {
	this(true);
	}

	/**
	* Constructs a MultipleKeyFactory whose ids are visible iff visible is true.
	*/
	public MultipleKeyFactory(boolean visible) {
	this.visible = visible;
	}

	/**
	* Get the cache of IDs. These are either the ids that we know we
	* don't understand, if included is false, or the entire set of ids
	* we do know we understand, if included is true. Note that if
	* the cache has been freed by gc, we reset the included flag, so
	* it must not be tested before this method is called.
	*/
	private HashSet getCache() {
	HashSet cache = null;
	if (cacheref != null) {
	cache = (HashSet)cacheref.get();
	}
	if (cache == null) {
	cache = new HashSet();
	cacheref = new SoftReference(cache);
	included = false;
	}
	return cache;
	}

	/**
	* Get the cache of IDs we understand.
	*/
	private HashSet getIncludedCache() {
	HashSet cache = getCache();
	if (!included) {
	cache.clear();
	handleUpdateVisibleIDs(cache);
	included = true;
	}
	return cache;
	}

	public final Object create(Key key) {
	Object result = null;
	String id = key.currentID();
	HashSet cache = getCache();
	if (cache.contains(id) == included) {
	result = handleCreate(key);
	if (!included && result == null) {
	cache.add(id);
	}
	}
	return result;
	}

	public final void updateVisibleIDs(Map result) {
	if (visible) {
	Set cache = getIncludedCache();
	Iterator iter = cache.iterator();
	while (iter.hasNext()) {
	result.put((String)iter.next(), this);
	}
	}
	}

	public final String getDisplayName(String id, Locale locale) {
	if (visible) {
	Set cache = getIncludedCache();
	if (cache.contains(id)) {
	return handleGetDisplayName(id, locale);
	}
	}
	return null;
	}

	/**
	* Subclasses implement this instead of create.
	*/
	protected abstract Object handleCreate(Key key);

	/**
	* Subclasses implement this instead of updateVisibleIDs. Any
	* id known to and handled by this class should be added to
	* result.
	*/
	protected abstract void handleUpdateVisibleIDs(Set result);

	/**
	* Subclasses implement this instead of getDisplayName.
	* Return the display name for the (visible) id in the
	* provided locale. The default implementation just returns
	* the id.
	*/
	protected String handleGetDisplayName(String id, Locale locale) {
	return id;
	}
	}

	/**
	* A factory that creates a service based on the ICU locale data.
	* Subclasses specify a prefix (default is LocaleElements), a
	* semicolon-separated list of required resources, and a visible flag.
	* This factory will search the ICU locale data for a bundle with
	* the exact prefix. Then it will test whether the required resources
	* are all in this exact bundle. If so, it instantiates the full
	* resource bundle, and hands it to createServiceFromResource, which
	* subclasses must implement. Otherwise it returns null.
	*/
	public static class ICUResourceBundleFactory extends MultipleKeyFactory {
	protected final String name;
	protected final String[] requiredContents;

	/**
	* A service factory based on ICU resource data in the LocaleElements resources.
	*/
	public ICUResourceBundleFactory(String requiredContents, boolean visible) {
	this(ICULocaleData.LOCALE_ELEMENTS, requiredContents, visible);
	}

	/**
	* A service factory based on ICU resource data in resources
	* with the given name. If requiredContents is not null, all
	* listed resources must come directly from the same bundle.
	*/
	public ICUResourceBundleFactory(String name, String requiredContents, boolean visible) {
	super(visible);

	this.name = name;
	if (requiredContents != null) {
	ArrayList list = new ArrayList();
	for (int i = 0, len = requiredContents.length();;) {
	while (i < len && requiredContents.charAt(i) == ';') {
	++i;
	}
	if (i == len) {
	break;
	}
	int j = requiredContents.indexOf(';', i);
	if (j == -1) {
	j = len;
	}
	list.add(requiredContents.substring(i, j));
	i = j;
	}
	this.requiredContents = (String[])list.toArray(new String[list.size()]);
	} else {
	this.requiredContents = null;
	}
	}

	/**
	* Overrides parent handleCreate call. Parent will filter out keys that it
	* knows are not accepted by this factory before calling this method.
	*/
	protected Object handleCreate(Key key) {
	Locale loc = LocaleUtility.getLocaleFromName(key.currentID());
	if (acceptsLocale(loc)) {
	ResourceBundle bundle = ICULocaleData.getResourceBundle(name, loc); // full resource bundle tree lookup
	return createFromBundle(bundle, key);
	}
	return null;
	}

	/**
	* Queries all the available locales in ICU and adds the names
	* of those which it accepts to result. This is quite
	* time-consuming so we don't want to do it more than once if
	* we have to. This is only called if we are visible.
	*/
	protected void handleUpdateVisibleIDs(Set result) {
	Locale[] locales = ICULocaleData.getAvailableLocales(name);
	for (int i = 0; i < locales.length; ++i) {
	Locale locale = locales[i];
	if (acceptsLocale(locale)) {
	result.add(LocaleUtility.canonicalLocaleString(locale.toString()));
	}
	}
	}

	/**
	* Return a localized name for the locale represented by id.
	*/
	protected String handleGetDisplayName(String id, Locale locale) {
	// use java's display name formatting for now
	return LocaleUtility.getLocaleFromName(id).getDisplayName(locale);
	}

	/**
	* We only accept the locale if there is a bundle for this exact locale and if
	* all the required resources are directly in this bundle (none is from an
	* inherited bundle);
	*/
	protected boolean acceptsLocale(Locale loc) {
	try {
	ResourceBundle bundle = ICULocaleData.loadResourceBundle(name, loc); // single resource bundle lookup
	if (requiredContents != null) {
	for (int i = 0; i < requiredContents.length; ++i) {
	if (bundle.getObject(requiredContents[i]) == null) {
	return false;
	}
	}
	}
	return true;
	}
	catch (Exception e) {
	}
	return false;
	}

	/**
	* Subclassers implement this to create their service object based on the bundle and key.
	* The default implementation just returns the bundle.
	*/
	protected Object createFromBundle(ResourceBundle bundle, Key key) {
	return bundle;
	}
	}

	protected Key createKey(String id) {
	Locale loc = Locale.getDefault();
	if (loc != fallbackLocale) {
	synchronized (this) {
	if (loc != fallbackLocale) {
	fallbackLocale = loc;
	fallbackLocaleName = LocaleUtility.canonicalLocaleString(loc.toString());
	clearServiceCache();
	}
	}
	}

	return LocaleKey.createWithCanonicalFallback(id, fallbackLocaleName);
	}
	}