983 lines
36 KiB
Java
983 lines
36 KiB
Java
/* GENERATED SOURCE. DO NOT MODIFY. */
|
|
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/**
|
|
*******************************************************************************
|
|
* Copyright (C) 2001-2016, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*******************************************************************************
|
|
*/
|
|
package android.icu.impl;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.EventListener;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.ListIterator;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
import java.util.SortedMap;
|
|
import java.util.TreeMap;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
import android.icu.util.ULocale;
|
|
import android.icu.util.ULocale.Category;
|
|
|
|
/**
|
|
* <p>A Service provides access to service objects that implement a
|
|
* particular service, e.g. transliterators. Users provide a String
|
|
* id (for example, a locale string) to the service, and get back an
|
|
* object for that id. Service objects can be any kind of object.
|
|
* The service object is cached and returned for later queries, so
|
|
* generally it should not be mutable, or the caller should clone the
|
|
* object before modifying it.</p>
|
|
*
|
|
* <p>Services 'canonicalize' the query id and use the canonical id to
|
|
* query for the service. The service also defines a mechanism to
|
|
* 'fallback' the id multiple times. Clients can optionally request
|
|
* the actual id that was matched by a query when they use an id to
|
|
* retrieve a service object.</p>
|
|
*
|
|
* <p>Service objects are instantiated by Factory objects registered with
|
|
* the service. The service queries each Factory in turn, from most recently
|
|
* registered to earliest registered, until one returns a service object.
|
|
* If none responds with a service object, a fallback id is generated,
|
|
* and the process repeats until a service object is returned or until
|
|
* the id has no further fallbacks.</p>
|
|
*
|
|
* <p>Factories can be dynamically registered and unregistered with the
|
|
* service. When registered, a Factory is installed at the head of
|
|
* the factory list, and so gets 'first crack' at any keys or fallback
|
|
* keys. When unregistered, it is removed from the service and can no
|
|
* longer be located through it. Service objects generated by this
|
|
* factory and held by the client are unaffected.</p>
|
|
*
|
|
* <p>ICUService uses Keys to query factories and perform
|
|
* fallback. The Key defines the canonical form of the id, and
|
|
* implements the fallback strategy. Custom Keys can be defined that
|
|
* parse complex IDs into components that Factories can more easily
|
|
* use. The Key can cache the results of this parsing to save
|
|
* repeated effort. ICUService provides convenience APIs that
|
|
* take Strings and generate default Keys for use in querying.</p>
|
|
*
|
|
* <p>ICUService provides API to get the list of ids publicly
|
|
* supported by the service (although queries aren't restricted to
|
|
* this list). This list contains only 'simple' IDs, and not fully
|
|
* unique ids. Factories are associated with each simple ID and
|
|
* the responsible factory can also return a human-readable localized
|
|
* version of the simple ID, for use in user interfaces. ICUService
|
|
* can also provide a sorted collection of the all the localized visible
|
|
* ids.</p>
|
|
*
|
|
* <p>ICUService implements ICUNotifier, so that clients can register
|
|
* to receive notification when factories are added or removed from
|
|
* the service. ICUService provides a default EventListener subinterface,
|
|
* ServiceListener, which can be registered with the service. When
|
|
* the service changes, the ServiceListener's serviceChanged method
|
|
* is called, with the service as the only argument.</p>
|
|
*
|
|
* <p>The ICUService API is both rich and generic, and it is expected
|
|
* that most implementations will statically 'wrap' ICUService to
|
|
* present a more appropriate API-- for example, to declare the type
|
|
* of the objects returned from get, to limit the factories that can
|
|
* be registered with the service, or to define their own listener
|
|
* interface with a custom callback method. They might also customize
|
|
* ICUService by overriding it, for example, to customize the Key and
|
|
* fallback strategy. ICULocaleService is a customized service that
|
|
* uses Locale names as ids and uses Keys that implement the standard
|
|
* resource bundle fallback strategy.<p>
|
|
* @hide Only a subset of ICU is exposed in Android
|
|
*/
|
|
public class ICUService extends ICUNotifier {
|
|
/**
|
|
* Name used for debugging.
|
|
*/
|
|
protected final String name;
|
|
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
public ICUService() {
|
|
name = "";
|
|
}
|
|
|
|
private static final boolean DEBUG = ICUDebug.enabled("service");
|
|
/**
|
|
* Construct with a name (useful for debugging).
|
|
*/
|
|
public ICUService(String name) {
|
|
this.name = name;
|
|
}
|
|
|
|
/**
|
|
* Access to factories is protected by a read-write lock. This is
|
|
* to allow multiple threads to read concurrently, but keep
|
|
* changes to the factory list atomic with respect to all readers.
|
|
*/
|
|
private final ICURWLock factoryLock = new ICURWLock();
|
|
|
|
/**
|
|
* All the factories registered with this service.
|
|
*/
|
|
private final List<Factory> factories = new ArrayList<Factory>();
|
|
|
|
/**
|
|
* Record the default number of factories for this service.
|
|
* Can be set by markDefault.
|
|
*/
|
|
private int defaultSize = 0;
|
|
|
|
/**
|
|
* Keys are used to communicate with factories to generate an
|
|
* instance of the service. Keys define how ids are
|
|
* canonicalized, provide both a current id and a current
|
|
* descriptor to use in querying the cache and factories, and
|
|
* determine the fallback strategy.</p>
|
|
*
|
|
* <p>Keys provide both a currentDescriptor and a currentID.
|
|
* The descriptor contains an optional prefix, followed by '/'
|
|
* and the currentID. Factories that handle complex keys,
|
|
* for example number format factories that generate multiple
|
|
* kinds of formatters for the same locale, use the descriptor
|
|
* to provide a fully unique identifier for the service object,
|
|
* while using the currentID (in this case, the locale string),
|
|
* as the visible IDs that can be localized.
|
|
*
|
|
* <p> The default implementation of Key has no fallbacks and
|
|
* has no custom descriptors.</p>
|
|
* @hide Only a subset of ICU is exposed in Android
|
|
*/
|
|
public static class Key {
|
|
private final String id;
|
|
|
|
/**
|
|
* Construct a key from an id.
|
|
*/
|
|
public Key(String id) {
|
|
this.id = id;
|
|
}
|
|
|
|
/**
|
|
* Return the original ID used to construct this key.
|
|
*/
|
|
public final String id() {
|
|
return id;
|
|
}
|
|
|
|
/**
|
|
* Return the canonical version of the original ID. This implementation
|
|
* returns the original ID unchanged.
|
|
*/
|
|
public String canonicalID() {
|
|
return id;
|
|
}
|
|
|
|
/**
|
|
* Return the (canonical) current ID. This implementation
|
|
* returns the canonical ID.
|
|
*/
|
|
public String currentID() {
|
|
return canonicalID();
|
|
}
|
|
|
|
/**
|
|
* Return the current descriptor. This implementation returns
|
|
* the current ID. The current descriptor is used to fully
|
|
* identify an instance of the service in the cache. A
|
|
* factory may handle all descriptors for an ID, or just a
|
|
* particular descriptor. The factory can either parse the
|
|
* descriptor or use custom API on the key in order to
|
|
* instantiate the service.
|
|
*/
|
|
public String currentDescriptor() {
|
|
return "/" + currentID();
|
|
}
|
|
|
|
/**
|
|
* If the key has a fallback, modify the key and return true,
|
|
* otherwise return false. The current ID will change if there
|
|
* is a fallback. No currentIDs should be repeated, and fallback
|
|
* must eventually return false. This implementation has no fallbacks
|
|
* and always returns false.
|
|
*/
|
|
public boolean fallback() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* If a key created from id would eventually fallback to match the
|
|
* canonical ID of this key, return true.
|
|
*/
|
|
public boolean isFallbackOf(String idToCheck) {
|
|
return canonicalID().equals(idToCheck);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Factories generate the service objects maintained by the
|
|
* service. A factory generates a service object from a key,
|
|
* updates id->factory mappings, and returns the display name for
|
|
* a supported id.
|
|
* @hide Only a subset of ICU is exposed in Android
|
|
*/
|
|
public static interface Factory {
|
|
|
|
/**
|
|
* Create a service object from the key, if this factory
|
|
* supports the key. Otherwise, return null.
|
|
*
|
|
* <p>If the factory supports the key, then it can call
|
|
* the service's getKey(Key, String[], Factory) method
|
|
* passing itself as the factory to get the object that
|
|
* the service would have created prior to the factory's
|
|
* registration with the service. This can change the
|
|
* key, so any information required from the key should
|
|
* be extracted before making such a callback.
|
|
*/
|
|
public Object create(Key key, ICUService service);
|
|
|
|
/**
|
|
* Update the result IDs (not descriptors) to reflect the IDs
|
|
* this factory handles. This function and getDisplayName are
|
|
* used to support ICUService.getDisplayNames. Basically, the
|
|
* factory has to determine which IDs it will permit to be
|
|
* available, and of those, which it will provide localized
|
|
* display names for. In most cases this reflects the IDs that
|
|
* the factory directly supports.
|
|
*/
|
|
public void updateVisibleIDs(Map<String, Factory> result);
|
|
|
|
/**
|
|
* Return the display name for this id in the provided locale.
|
|
* This is an localized id, not a descriptor. If the id is
|
|
* not visible or not defined by the factory, return null.
|
|
* If locale is null, return id unchanged.
|
|
*/
|
|
public String getDisplayName(String id, ULocale locale);
|
|
}
|
|
|
|
/**
|
|
* A default implementation of factory. This provides default
|
|
* implementations for subclasses, and implements a singleton
|
|
* factory that matches a single id and returns a single
|
|
* (possibly deferred-initialized) instance. This implements
|
|
* updateVisibleIDs to add a mapping from its ID to itself
|
|
* if visible is true, or to remove any existing mapping
|
|
* for its ID if visible is false.
|
|
* @hide Only a subset of ICU is exposed in Android
|
|
*/
|
|
public static class SimpleFactory implements Factory {
|
|
protected Object instance;
|
|
protected String id;
|
|
protected boolean visible;
|
|
|
|
/**
|
|
* Convenience constructor that calls SimpleFactory(Object, String, boolean)
|
|
* with visible true.
|
|
*/
|
|
public SimpleFactory(Object instance, String id) {
|
|
this(instance, id, true);
|
|
}
|
|
|
|
/**
|
|
* Construct a simple factory that maps a single id to a single
|
|
* service instance. If visible is true, the id will be visible.
|
|
* Neither the instance nor the id can be null.
|
|
*/
|
|
public SimpleFactory(Object instance, String id, boolean visible) {
|
|
if (instance == null || id == null) {
|
|
throw new IllegalArgumentException("Instance or id is null");
|
|
}
|
|
this.instance = instance;
|
|
this.id = id;
|
|
this.visible = visible;
|
|
}
|
|
|
|
/**
|
|
* Return the service instance if the factory's id is equal to
|
|
* the key's currentID. Service is ignored.
|
|
*/
|
|
@Override
|
|
public Object create(Key key, ICUService service) {
|
|
if (id.equals(key.currentID())) {
|
|
return instance;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* If visible, adds a mapping from id -> this to the result,
|
|
* otherwise removes id from result.
|
|
*/
|
|
@Override
|
|
public void updateVisibleIDs(Map<String, Factory> result) {
|
|
if (visible) {
|
|
result.put(id, this);
|
|
} else {
|
|
result.remove(id);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If this.id equals id, returns id regardless of locale,
|
|
* otherwise returns null. (This default implementation has
|
|
* no localized id information.)
|
|
*/
|
|
@Override
|
|
public String getDisplayName(String identifier, ULocale locale) {
|
|
return (visible && id.equals(identifier)) ? identifier : null;
|
|
}
|
|
|
|
/**
|
|
* For debugging.
|
|
*/
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder buf = new StringBuilder(super.toString());
|
|
buf.append(", id: ");
|
|
buf.append(id);
|
|
buf.append(", visible: ");
|
|
buf.append(visible);
|
|
return buf.toString();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convenience override for get(String, String[]). This uses
|
|
* createKey to create a key for the provided descriptor.
|
|
*/
|
|
public Object get(String descriptor) {
|
|
return getKey(createKey(descriptor), null);
|
|
}
|
|
|
|
/**
|
|
* Convenience override for get(Key, String[]). This uses
|
|
* createKey to create a key from the provided descriptor.
|
|
*/
|
|
public Object get(String descriptor, String[] actualReturn) {
|
|
if (descriptor == null) {
|
|
throw new NullPointerException("descriptor must not be null");
|
|
}
|
|
return getKey(createKey(descriptor), actualReturn);
|
|
}
|
|
|
|
/**
|
|
* Convenience override for get(Key, String[]).
|
|
*/
|
|
public Object getKey(Key key) {
|
|
return getKey(key, null);
|
|
}
|
|
|
|
/**
|
|
* <p>Given a key, return a service object, and, if actualReturn
|
|
* is not null, the descriptor with which it was found in the
|
|
* first element of actualReturn. If no service object matches
|
|
* this key, return null, and leave actualReturn unchanged.</p>
|
|
*
|
|
* <p>This queries the cache using the key's descriptor, and if no
|
|
* object in the cache matches it, tries the key on each
|
|
* registered factory, in order. If none generates a service
|
|
* object for the key, repeats the process with each fallback of
|
|
* the key, until either one returns a service object, or the key
|
|
* has no fallback.</p>
|
|
*
|
|
* <p>If key is null, just returns null.</p>
|
|
*/
|
|
public Object getKey(Key key, String[] actualReturn) {
|
|
return getKey(key, actualReturn, null);
|
|
}
|
|
|
|
// debugging
|
|
// Map hardRef;
|
|
|
|
public Object getKey(Key key, String[] actualReturn, Factory factory) {
|
|
if (factories.size() == 0) {
|
|
return handleDefault(key, actualReturn);
|
|
}
|
|
|
|
if (DEBUG) System.out.println("Service: " + name + " key: " + key.canonicalID());
|
|
|
|
CacheEntry result = null;
|
|
if (key != null) {
|
|
try {
|
|
// The factory list can't be modified until we're done,
|
|
// otherwise we might update the cache with an invalid result.
|
|
// The cache has to stay in synch with the factory list.
|
|
factoryLock.acquireRead();
|
|
|
|
Map<String, CacheEntry> cache = this.cache; // copy so we don't need to sync on this
|
|
if (cache == null) {
|
|
if (DEBUG) System.out.println("Service " + name + " cache was empty");
|
|
// synchronized since additions and queries on the cache must be atomic
|
|
// they can be interleaved, though
|
|
cache = new ConcurrentHashMap<String, CacheEntry>();
|
|
}
|
|
|
|
String currentDescriptor = null;
|
|
ArrayList<String> cacheDescriptorList = null;
|
|
boolean putInCache = false;
|
|
|
|
int NDebug = 0;
|
|
|
|
int startIndex = 0;
|
|
int limit = factories.size();
|
|
boolean cacheResult = true;
|
|
if (factory != null) {
|
|
for (int i = 0; i < limit; ++i) {
|
|
if (factory == factories.get(i)) {
|
|
startIndex = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (startIndex == 0) {
|
|
throw new IllegalStateException("Factory " + factory + "not registered with service: " + this);
|
|
}
|
|
cacheResult = false;
|
|
}
|
|
|
|
outer:
|
|
do {
|
|
currentDescriptor = key.currentDescriptor();
|
|
if (DEBUG) System.out.println(name + "[" + NDebug++ + "] looking for: " + currentDescriptor);
|
|
result = cache.get(currentDescriptor);
|
|
if (result != null) {
|
|
if (DEBUG) System.out.println(name + " found with descriptor: " + currentDescriptor);
|
|
break outer;
|
|
} else {
|
|
if (DEBUG) System.out.println("did not find: " + currentDescriptor + " in cache");
|
|
}
|
|
|
|
// first test of cache failed, so we'll have to update
|
|
// the cache if we eventually succeed-- that is, if we're
|
|
// going to update the cache at all.
|
|
putInCache = cacheResult;
|
|
|
|
// int n = 0;
|
|
int index = startIndex;
|
|
while (index < limit) {
|
|
Factory f = factories.get(index++);
|
|
if (DEBUG) System.out.println("trying factory[" + (index-1) + "] " + f.toString());
|
|
Object service = f.create(key, this);
|
|
if (service != null) {
|
|
result = new CacheEntry(currentDescriptor, service);
|
|
if (DEBUG) System.out.println(name + " factory supported: " + currentDescriptor + ", caching");
|
|
break outer;
|
|
} else {
|
|
if (DEBUG) System.out.println("factory did not support: " + currentDescriptor);
|
|
}
|
|
}
|
|
|
|
// prepare to load the cache with all additional ids that
|
|
// will resolve to result, assuming we'll succeed. We
|
|
// don't want to keep querying on an id that's going to
|
|
// fallback to the one that succeeded, we want to hit the
|
|
// cache the first time next goaround.
|
|
if (cacheDescriptorList == null) {
|
|
cacheDescriptorList = new ArrayList<String>(5);
|
|
}
|
|
cacheDescriptorList.add(currentDescriptor);
|
|
|
|
} while (key.fallback());
|
|
|
|
if (result != null) {
|
|
if (putInCache) {
|
|
if (DEBUG) System.out.println("caching '" + result.actualDescriptor + "'");
|
|
cache.put(result.actualDescriptor, result);
|
|
if (cacheDescriptorList != null) {
|
|
for (String desc : cacheDescriptorList) {
|
|
if (DEBUG) System.out.println(name + " adding descriptor: '" + desc + "' for actual: '" + result.actualDescriptor + "'");
|
|
|
|
cache.put(desc, result);
|
|
}
|
|
}
|
|
// Atomic update. We held the read lock all this time
|
|
// so we know our cache is consistent with the factory list.
|
|
// We might stomp over a cache that some other thread
|
|
// rebuilt, but that's the breaks. They're both good.
|
|
this.cache = cache;
|
|
}
|
|
|
|
if (actualReturn != null) {
|
|
// strip null prefix
|
|
if (result.actualDescriptor.indexOf("/") == 0) {
|
|
actualReturn[0] = result.actualDescriptor.substring(1);
|
|
} else {
|
|
actualReturn[0] = result.actualDescriptor;
|
|
}
|
|
}
|
|
|
|
if (DEBUG) System.out.println("found in service: " + name);
|
|
|
|
return result.service;
|
|
}
|
|
}
|
|
finally {
|
|
factoryLock.releaseRead();
|
|
}
|
|
}
|
|
|
|
if (DEBUG) System.out.println("not found in service: " + name);
|
|
|
|
return handleDefault(key, actualReturn);
|
|
}
|
|
private Map<String, CacheEntry> cache;
|
|
|
|
// Record the actual id for this service in the cache, so we can return it
|
|
// even if we succeed later with a different id.
|
|
private static final class CacheEntry {
|
|
final String actualDescriptor;
|
|
final Object service;
|
|
CacheEntry(String actualDescriptor, Object service) {
|
|
this.actualDescriptor = actualDescriptor;
|
|
this.service = service;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Default handler for this service if no factory in the list
|
|
* handled the key.
|
|
*/
|
|
protected Object handleDefault(Key key, String[] actualIDReturn) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Convenience override for getVisibleIDs(String) that passes null
|
|
* as the fallback, thus returning all visible IDs.
|
|
*/
|
|
public Set<String> getVisibleIDs() {
|
|
return getVisibleIDs(null);
|
|
}
|
|
|
|
/**
|
|
* <p>Return a snapshot of the visible IDs for this service. This
|
|
* set will not change as Factories are added or removed, but the
|
|
* supported ids will, so there is no guarantee that all and only
|
|
* the ids in the returned set are visible and supported by the
|
|
* service in subsequent calls.</p>
|
|
*
|
|
* <p>matchID is passed to createKey to create a key. If the
|
|
* key is not null, it is used to filter out ids that don't have
|
|
* the key as a fallback.
|
|
*/
|
|
public Set<String> getVisibleIDs(String matchID) {
|
|
Set<String> result = getVisibleIDMap().keySet();
|
|
|
|
Key fallbackKey = createKey(matchID);
|
|
|
|
if (fallbackKey != null) {
|
|
Set<String> temp = new HashSet<String>(result.size());
|
|
for (String id : result) {
|
|
if (fallbackKey.isFallbackOf(id)) {
|
|
temp.add(id);
|
|
}
|
|
}
|
|
result = temp;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Return a map from visible ids to factories.
|
|
*/
|
|
private Map<String, Factory> getVisibleIDMap() {
|
|
synchronized (this) { // or idcache-only lock?
|
|
if (idcache == null) {
|
|
try {
|
|
factoryLock.acquireRead();
|
|
Map<String, Factory> mutableMap = new HashMap<String, Factory>();
|
|
ListIterator<Factory> lIter = factories.listIterator(factories.size());
|
|
while (lIter.hasPrevious()) {
|
|
Factory f = lIter.previous();
|
|
f.updateVisibleIDs(mutableMap);
|
|
}
|
|
// Capture the return value in a local variable.
|
|
// Avoids returning an idcache value changed by another thread (could be null after clearCaches()).
|
|
Map<String, Factory> result = Collections.unmodifiableMap(mutableMap);
|
|
this.idcache = result;
|
|
return result;
|
|
} finally {
|
|
factoryLock.releaseRead();
|
|
}
|
|
}
|
|
return idcache;
|
|
}
|
|
}
|
|
private Map<String, Factory> idcache;
|
|
|
|
/**
|
|
* Convenience override for getDisplayName(String, ULocale) that
|
|
* uses the current default locale.
|
|
*/
|
|
public String getDisplayName(String id) {
|
|
return getDisplayName(id, ULocale.getDefault(Category.DISPLAY));
|
|
}
|
|
|
|
/**
|
|
* Given a visible id, return the display name in the requested locale.
|
|
* If there is no directly supported id corresponding to this id, return
|
|
* null.
|
|
*/
|
|
public String getDisplayName(String id, ULocale locale) {
|
|
Map<String, Factory> m = getVisibleIDMap();
|
|
Factory f = m.get(id);
|
|
if (f != null) {
|
|
return f.getDisplayName(id, locale);
|
|
}
|
|
|
|
Key key = createKey(id);
|
|
while (key.fallback()) {
|
|
f = m.get(key.currentID());
|
|
if (f != null) {
|
|
return f.getDisplayName(id, locale);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
|
|
* uses the current default Locale as the locale, null as
|
|
* the comparator, and null for the matchID.
|
|
*/
|
|
public SortedMap<String, String> getDisplayNames() {
|
|
ULocale locale = ULocale.getDefault(Category.DISPLAY);
|
|
return getDisplayNames(locale, null, null);
|
|
}
|
|
|
|
/**
|
|
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
|
|
* uses null for the comparator, and null for the matchID.
|
|
*/
|
|
public SortedMap<String, String> getDisplayNames(ULocale locale) {
|
|
return getDisplayNames(locale, null, null);
|
|
}
|
|
|
|
/**
|
|
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
|
|
* uses null for the matchID, thus returning all display names.
|
|
*/
|
|
public SortedMap<String, String> getDisplayNames(ULocale locale, Comparator<Object> com) {
|
|
return getDisplayNames(locale, com, null);
|
|
}
|
|
|
|
/**
|
|
* Convenience override of getDisplayNames(ULocale, Comparator, String) that
|
|
* uses null for the comparator.
|
|
*/
|
|
public SortedMap<String, String> getDisplayNames(ULocale locale, String matchID) {
|
|
return getDisplayNames(locale, null, matchID);
|
|
}
|
|
|
|
/**
|
|
* Return a snapshot of the mapping from display names to visible
|
|
* IDs for this service. This set will not change as factories
|
|
* are added or removed, but the supported ids will, so there is
|
|
* no guarantee that all and only the ids in the returned map will
|
|
* be visible and supported by the service in subsequent calls,
|
|
* nor is there any guarantee that the current display names match
|
|
* those in the set. The display names are sorted based on the
|
|
* comparator provided.
|
|
*/
|
|
public SortedMap<String, String> getDisplayNames(ULocale locale, Comparator<Object> com, String matchID) {
|
|
SortedMap<String, String> dncache = null;
|
|
LocaleRef ref = dnref;
|
|
|
|
if (ref != null) {
|
|
dncache = ref.get(locale, com);
|
|
}
|
|
|
|
while (dncache == null) {
|
|
synchronized (this) {
|
|
if (ref == dnref || dnref == null) {
|
|
dncache = new TreeMap<String, String>(com); // sorted
|
|
|
|
Map<String, Factory> m = getVisibleIDMap();
|
|
Iterator<Entry<String, Factory>> ei = m.entrySet().iterator();
|
|
while (ei.hasNext()) {
|
|
Entry<String, Factory> e = ei.next();
|
|
String id = e.getKey();
|
|
Factory f = e.getValue();
|
|
dncache.put(f.getDisplayName(id, locale), id);
|
|
}
|
|
|
|
dncache = Collections.unmodifiableSortedMap(dncache);
|
|
dnref = new LocaleRef(dncache, locale, com);
|
|
} else {
|
|
ref = dnref;
|
|
dncache = ref.get(locale, com);
|
|
}
|
|
}
|
|
}
|
|
|
|
Key matchKey = createKey(matchID);
|
|
if (matchKey == null) {
|
|
return dncache;
|
|
}
|
|
|
|
SortedMap<String, String> result = new TreeMap<String, String>(dncache);
|
|
Iterator<Entry<String, String>> iter = result.entrySet().iterator();
|
|
while (iter.hasNext()) {
|
|
Entry<String, String> e = iter.next();
|
|
if (!matchKey.isFallbackOf(e.getValue())) {
|
|
iter.remove();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// we define a class so we get atomic simultaneous access to the
|
|
// locale, comparator, and corresponding map.
|
|
private static class LocaleRef {
|
|
private final ULocale locale;
|
|
private SortedMap<String, String> dnCache;
|
|
private Comparator<Object> com;
|
|
|
|
LocaleRef(SortedMap<String, String> dnCache, ULocale locale, Comparator<Object> com) {
|
|
this.locale = locale;
|
|
this.com = com;
|
|
this.dnCache = dnCache;
|
|
}
|
|
|
|
|
|
SortedMap<String, String> get(ULocale loc, Comparator<Object> comp) {
|
|
SortedMap<String, String> m = dnCache;
|
|
if (m != null &&
|
|
this.locale.equals(loc) &&
|
|
(this.com == comp || (this.com != null && this.com.equals(comp)))) {
|
|
|
|
return m;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private LocaleRef dnref;
|
|
|
|
/**
|
|
* Return a snapshot of the currently registered factories. There
|
|
* is no guarantee that the list will still match the current
|
|
* factory list of the service subsequent to this call.
|
|
*/
|
|
public final List<Factory> factories() {
|
|
try {
|
|
factoryLock.acquireRead();
|
|
return new ArrayList<Factory>(factories);
|
|
}
|
|
finally{
|
|
factoryLock.releaseRead();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A convenience override of registerObject(Object, String, boolean)
|
|
* that defaults visible to true.
|
|
*/
|
|
public Factory registerObject(Object obj, String id) {
|
|
return registerObject(obj, id, true);
|
|
}
|
|
|
|
/**
|
|
* Register an object with the provided id. The id will be
|
|
* canonicalized. The canonicalized ID will be returned by
|
|
* getVisibleIDs if visible is true.
|
|
*/
|
|
public Factory registerObject(Object obj, String id, boolean visible) {
|
|
String canonicalID = createKey(id).canonicalID();
|
|
return registerFactory(new SimpleFactory(obj, canonicalID, visible));
|
|
}
|
|
|
|
/**
|
|
* Register a Factory. Returns the factory if the service accepts
|
|
* the factory, otherwise returns null. The default implementation
|
|
* accepts all factories.
|
|
*/
|
|
public final Factory registerFactory(Factory factory) {
|
|
if (factory == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
try {
|
|
factoryLock.acquireWrite();
|
|
factories.add(0, factory);
|
|
clearCaches();
|
|
}
|
|
finally {
|
|
factoryLock.releaseWrite();
|
|
}
|
|
notifyChanged();
|
|
return factory;
|
|
}
|
|
|
|
/**
|
|
* Unregister a factory. The first matching registered factory will
|
|
* be removed from the list. Returns true if a matching factory was
|
|
* removed.
|
|
*/
|
|
public final boolean unregisterFactory(Factory factory) {
|
|
if (factory == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
|
|
boolean result = false;
|
|
try {
|
|
factoryLock.acquireWrite();
|
|
if (factories.remove(factory)) {
|
|
result = true;
|
|
clearCaches();
|
|
}
|
|
}
|
|
finally {
|
|
factoryLock.releaseWrite();
|
|
}
|
|
|
|
if (result) {
|
|
notifyChanged();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Reset the service to the default factories. The factory
|
|
* lock is acquired and then reInitializeFactories is called.
|
|
*/
|
|
public final void reset() {
|
|
try {
|
|
factoryLock.acquireWrite();
|
|
reInitializeFactories();
|
|
clearCaches();
|
|
}
|
|
finally {
|
|
factoryLock.releaseWrite();
|
|
}
|
|
notifyChanged();
|
|
}
|
|
|
|
/**
|
|
* Reinitialize the factory list to its default state. By default
|
|
* this clears the list. Subclasses can override to provide other
|
|
* default initialization of the factory list. Subclasses must
|
|
* not call this method directly, as it must only be called while
|
|
* holding write access to the factory list.
|
|
*/
|
|
protected void reInitializeFactories() {
|
|
factories.clear();
|
|
}
|
|
|
|
/**
|
|
* Return true if the service is in its default state. The default
|
|
* implementation returns true if there are no factories registered.
|
|
*/
|
|
public boolean isDefault() {
|
|
return factories.size() == defaultSize;
|
|
}
|
|
|
|
/**
|
|
* Set the default size to the current number of registered factories.
|
|
* Used by subclasses to customize the behavior of isDefault.
|
|
*/
|
|
protected void markDefault() {
|
|
defaultSize = factories.size();
|
|
}
|
|
|
|
/**
|
|
* Create a key from an id. This creates a Key instance.
|
|
* Subclasses can override to define more useful keys appropriate
|
|
* to the factories they accept. If id is null, returns null.
|
|
*/
|
|
public Key createKey(String id) {
|
|
return id == null ? null : new Key(id);
|
|
}
|
|
|
|
/**
|
|
* Clear caches maintained by this service. Subclasses can
|
|
* override if they implement additional that need to be cleared
|
|
* when the service changes. Subclasses should generally not call
|
|
* this method directly, as it must only be called while
|
|
* synchronized on this.
|
|
*/
|
|
protected void clearCaches() {
|
|
// we don't synchronize on these because methods that use them
|
|
// copy before use, and check for changes if they modify the
|
|
// caches.
|
|
cache = null;
|
|
idcache = null;
|
|
dnref = null;
|
|
}
|
|
|
|
/**
|
|
* Clears only the service cache.
|
|
* This can be called by subclasses when a change affects the service
|
|
* cache but not the id caches, e.g., when the default locale changes
|
|
* the resolution of ids changes, but not the visible ids themselves.
|
|
*/
|
|
protected void clearServiceCache() {
|
|
cache = null;
|
|
}
|
|
|
|
/**
|
|
* ServiceListener is the listener that ICUService provides by default.
|
|
* ICUService will notify this listener when factories are added to
|
|
* or removed from the service. Subclasses can provide
|
|
* different listener interfaces that extend EventListener, and modify
|
|
* acceptsListener and notifyListener as appropriate.
|
|
* @hide Only a subset of ICU is exposed in Android
|
|
*/
|
|
public static interface ServiceListener extends EventListener {
|
|
public void serviceChanged(ICUService service);
|
|
}
|
|
|
|
/**
|
|
* Return true if the listener is accepted; by default this
|
|
* requires a ServiceListener. Subclasses can override to accept
|
|
* different listeners.
|
|
*/
|
|
@Override
|
|
protected boolean acceptsListener(EventListener l) {
|
|
return l instanceof ServiceListener;
|
|
}
|
|
|
|
/**
|
|
* Notify the listener, which by default is a ServiceListener.
|
|
* Subclasses can override to use a different listener.
|
|
*/
|
|
@Override
|
|
protected void notifyListener(EventListener l) {
|
|
((ServiceListener)l).serviceChanged(this);
|
|
}
|
|
|
|
/**
|
|
* When the statistics for this service is already enabled,
|
|
* return the log and resets he statistics.
|
|
* When the statistics is not enabled, this method enable
|
|
* the statistics. Used for debugging purposes.
|
|
*/
|
|
public String stats() {
|
|
ICURWLock.Stats stats = factoryLock.resetStats();
|
|
if (stats != null) {
|
|
return stats.toString();
|
|
}
|
|
return "no stats";
|
|
}
|
|
|
|
/**
|
|
* Return the name of this service. This will be the empty string if none was assigned.
|
|
*/
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Returns the result of super.toString, appending the name in curly braces.
|
|
*/
|
|
@Override
|
|
public String toString() {
|
|
return super.toString() + "{" + name + "}";
|
|
}
|
|
}
|