ICU-1949 ICUService API (private for now)

X-SVN-Rev: 10173

icu4c/source/common/common.dsp

@@ -203,6 +203,22 @@ SOURCE=.\filestrm.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\iculserv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icunotif.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icurwlck.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icuserv.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=.\locid.cpp
 # End Source File
 # Begin Source File
@@ -845,6 +861,26 @@ SOURCE=.\hash.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\iculdata.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\iculserv.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icunotif.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icurwlck.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icuserv.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\unicode\locid.h
 
 !IF  "$(CFG)" == "common - Win32 Release"

icu4c/source/common/iculserv.cpp

@@ -0,0 +1,748 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2002, International Business Machines Corporation and    *
+ * others. All Rights Reserved.                                                *
+ *******************************************************************************
+ *
+ *******************************************************************************
+ */
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_SERVICE
+
+#include "unicode/resbund.h"
+#include "cmemory.h"
+#include "iculserv.h"
+
+U_NAMESPACE_BEGIN
+
+/*
+ ******************************************************************
+ */
+
+UnicodeString& 
+LocaleUtility::canonicalLocaleString(const UnicodeString* id, UnicodeString& result) 
+{
+  if (id == NULL) {
+    result.setToBogus();
+  } else {
+    result = *id;
+    int32_t i = 0;
+    int32_t n = result.indexOf(UNDERSCORE_CHAR);
+    if (n < 0) {
+      n = result.length();
+    }
+    for (; i < n; ++i) {
+      UChar c = result.charAt(i);
+      if (c >= 0x0041 && c <= 0x005a) {
+        c += 0x20;
+        result.setCharAt(i, c);
+      }
+    }
+    for (n = result.length(); i < n; ++i) {
+      UChar c = result.charAt(i);
+      if (c >= 0x0061 && c <= 0x007a) {
+        c -= 0x20;
+        result.setCharAt(i, c);
+      }
+    }
+  }
+  return result;
+}
+
+Locale& 
+LocaleUtility::initLocaleFromName(const UnicodeString& id, Locale& result) 
+{
+  if (id.isBogus()) {
+    result.setToBogus();
+  } else {
+    const int32_t BUFLEN = 128; // larger than ever needed
+    char buffer[BUFLEN];
+    int len = id.extract(0, BUFLEN, buffer);
+    if (len >= BUFLEN) {
+      result.setToBogus();
+    } else {
+      buffer[len] = '\0';
+      result = Locale::createFromName(buffer);
+    }
+  }
+  return result;
+}
+
+UnicodeString& 
+LocaleUtility::initNameFromLocale(const Locale& locale, UnicodeString& result) 
+{
+  if (locale.isBogus()) {
+    result.setToBogus();
+  } else {
+    result.append(locale.getName());
+  }
+  return result;
+}
+
+const Hashtable* 
+LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID) 
+{
+  // have to ignore bundleID for the moment, since we don't have easy C++ api.
+  // assume it's the default bundle
+
+  if (cache == NULL) {
+    Hashtable* result = new Hashtable();
+    if (result) {
+      UErrorCode status = U_ZERO_ERROR;
+      int32_t count = uloc_countAvailable();
+      for (int32_t i = 0; i < count; ++i) {
+        UnicodeString temp(uloc_getAvailable(i));
+        result->put(temp, (void*)result, status);
+        if (U_FAILURE(status)) {
+          delete result;
+          return NULL;
+        }
+      }
+      {
+        Mutex mutex(&lock);
+        if (cache == NULL) {
+          cache = result;
+          return cache;
+        }
+      }
+      delete result;
+    }
+  }
+  return cache;
+}
+
+UBool 
+LocaleUtility::isFallbackOf(const UnicodeString& root, const UnicodeString& child)
+{
+  return child.indexOf(root) == 0 &&
+    (child.length() == root.length() ||
+     child.charAt(root.length()) == UNDERSCORE_CHAR);
+}
+
+Hashtable * LocaleUtility::cache = NULL;
+
+const UChar LocaleUtility::UNDERSCORE_CHAR = 0x005f;
+
+UMTX LocaleUtility::lock = 0;
+
+/*
+ ******************************************************************
+ */
+
+const UChar LocaleKey::UNDERSCORE_CHAR = 0x005f;
+
+const int32_t LocaleKey::KIND_ANY = -1;
+
+LocaleKey* 
+LocaleKey::createWithCanonicalFallback(const UnicodeString* primaryID, 
+                                       const UnicodeString* canonicalFallbackID) 
+{
+  return LocaleKey::createWithCanonicalFallback(primaryID, canonicalFallbackID, KIND_ANY);
+}
+	    
+LocaleKey* 
+LocaleKey::createWithCanonicalFallback(const UnicodeString* primaryID, 
+                                       const UnicodeString* canonicalFallbackID, 
+                                       int32_t kind) 
+{
+  if (primaryID == NULL) {
+    return NULL;
+  }
+  UnicodeString canonicalPrimaryID;
+  LocaleUtility::canonicalLocaleString(primaryID, canonicalPrimaryID);
+  return new LocaleKey(*primaryID, canonicalPrimaryID, canonicalFallbackID, kind);
+}
+	    
+LocaleKey::LocaleKey(const UnicodeString& primaryID, 
+                     const UnicodeString& canonicalPrimaryID, 
+                     const UnicodeString* canonicalFallbackID, 
+                     int32_t kind) 
+  : Key(primaryID)
+  , _kind(kind)
+  , _primaryID(canonicalPrimaryID)
+  , _fallbackID()
+  , _currentID()
+{
+    _fallbackID.setToBogus();
+    if (_primaryID.length() != 0) {
+        if (canonicalFallbackID != NULL && _primaryID != *canonicalFallbackID) {
+            _fallbackID = *canonicalFallbackID;
+        }
+    }
+
+    _currentID = _primaryID;
+}
+
+UnicodeString& 
+LocaleKey::prefix(UnicodeString& result) const {
+  if (_kind != KIND_ANY) {
+    DigitList list;
+    list.set(_kind);
+    UnicodeString temp(list.fDigits, list.fCount);
+    result.append(temp);
+  }
+  return result;
+}
+
+int32_t 
+LocaleKey::kind() const {
+  return _kind;
+}
+
+UnicodeString& 
+LocaleKey::canonicalID(UnicodeString& result) const {
+  return result.append(_primaryID);
+}
+
+UnicodeString& 
+LocaleKey::currentID(UnicodeString& result) const {
+  if (!_currentID.isBogus()) {
+    result.append(_currentID);
+  }
+  return result;
+}
+
+UnicodeString& 
+LocaleKey::currentDescriptor(UnicodeString& result) const {
+  if (!_currentID.isBogus()) {
+    prefix(result).append(PREFIX_DELIMITER).append(_currentID);
+  } else {
+    result.setToBogus();
+  }
+  return result;
+}
+
+Locale& 
+LocaleKey::canonicalLocale(Locale& result) const {
+  return LocaleUtility::initLocaleFromName(_primaryID, result);
+}
+
+Locale& 
+LocaleKey::currentLocale(Locale& result) const {
+  return LocaleUtility::initLocaleFromName(_currentID, result);
+}
+
+UBool 
+LocaleKey::fallback() {
+  if (!_currentID.isBogus()) {
+    int x = _currentID.lastIndexOf(UNDERSCORE_CHAR);
+    if (x != -1) {
+      _currentID.remove(x); // truncate current or fallback, whichever we're pointing to
+      return TRUE;
+    }
+
+    if (!_fallbackID.isBogus()) {
+      _currentID = _fallbackID;
+      _fallbackID.setToBogus();
+      return TRUE;
+    }
+
+    if (_currentID.length() > 0) {
+      _currentID.remove(0); // completely truncate
+      return TRUE;
+    }
+          
+    _currentID.setToBogus();
+  }
+
+  return FALSE;
+}
+
+UBool 
+LocaleKey::isFallbackOf(const UnicodeString& id) const {
+  UnicodeString temp(id);
+  parseSuffix(temp);
+  return temp.indexOf(_primaryID) == 0 &&
+    (temp.length() == _primaryID.length() ||
+     temp.charAt(_primaryID.length()) == UNDERSCORE_CHAR);
+}
+
+UnicodeString& 
+LocaleKey::debug(UnicodeString& result) const 
+{
+    Key::debug(result);
+    result.append(" kind: ");
+    result.append(_kind);
+    result.append(" primaryID: ");
+    result.append(_primaryID);
+    result.append(" fallbackID: ");
+    result.append(_fallbackID);
+    result.append(" currentID: ");
+    result.append(_currentID);
+    return result;
+}
+
+UnicodeString& 
+LocaleKey::debugClass(UnicodeString& result) const 
+{
+    return result.append("LocaleKey ");
+}
+
+const char LocaleKey::fgClassID = 0;
+
+/*
+ ******************************************************************
+ */
+
+LocaleKeyFactory::LocaleKeyFactory(int32_t coverage) 
+  : _name()
+  , _coverage(coverage)
+{
+}
+
+LocaleKeyFactory::LocaleKeyFactory(int32_t coverage, const UnicodeString& name)
+  : _name(name)
+  , _coverage(coverage)
+{
+}
+
+LocaleKeyFactory::~LocaleKeyFactory() {
+}
+
+UObject* 
+LocaleKeyFactory::create(const Key& key, const ICUService* service, UErrorCode& status) const {
+  if (handlesKey(key, status)) {
+    const LocaleKey& lkey = (const LocaleKey&)key;
+    int32_t kind = lkey.kind();
+    Locale loc;
+    lkey.canonicalLocale(loc);
+
+    return handleCreate(loc, kind, service, status);
+  }
+  return NULL;
+}
+
+UBool 
+LocaleKeyFactory::handlesKey(const Key& key, UErrorCode& status) const {
+  const Hashtable* supported = getSupportedIDs(status);
+  if (supported) {
+    UnicodeString id;
+    key.currentID(id);
+    return supported->get(id) != NULL;
+  }
+  return FALSE;
+}
+
+void 
+LocaleKeyFactory::updateVisibleIDs(Hashtable& result, UErrorCode& status) const {
+  const Hashtable* supported = getSupportedIDs(status);
+  if (supported) {
+    UBool visible = (_coverage & 0x1) == 0;
+
+    const UHashElement* elem = NULL;
+    int32_t pos = 0;
+    while (elem = supported->nextElement(pos)) {
+      const UnicodeString& id = *((const UnicodeString*)elem->key.pointer);
+      if (!visible) {
+        result.remove(id);
+      } else {
+        result.put(id, (void*)this, status); // this is dummy non-void marker used for set semantics
+        if (U_FAILURE(status)) {
+          break;
+        }
+      }
+    }                    
+  }
+}
+
+UnicodeString& 
+LocaleKeyFactory::getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const {
+  Locale loc;
+  LocaleUtility::initLocaleFromName(id, loc);
+  return loc.getDisplayName(locale, result);
+}
+
+UObject* 
+LocaleKeyFactory::handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const {
+  return NULL;
+}
+
+const Hashtable* 
+LocaleKeyFactory::getSupportedIDs(UErrorCode& status) const {
+  return NULL;
+}
+
+UnicodeString& 
+LocaleKeyFactory::debug(UnicodeString& result) const 
+{
+  debugClass(result);
+  result.append(", name: ");
+  result.append(_name);
+  result.append(", coverage: ");
+  result.append(_coverage);
+  return result;
+}
+
+UnicodeString&
+LocaleKeyFactory::debugClass(UnicodeString& result) const
+{
+  return result.append("LocaleKeyFactory");
+}
+
+const char LocaleKeyFactory::fgClassID = 0;
+
+/*
+ ******************************************************************
+ */
+
+SimpleLocaleKeyFactory::SimpleLocaleKeyFactory(UObject* objToAdopt, 
+                                               const Locale& locale, 
+                                               int32_t kind, 
+                                               int32_t coverage)
+  : LocaleKeyFactory(coverage)
+  , _obj(objToAdopt)
+  , _id(locale.getName())
+  , _kind(kind)
+{
+}
+
+SimpleLocaleKeyFactory::SimpleLocaleKeyFactory(UObject* objToAdopt, 
+                                               const Locale& locale, 
+                                               int32_t kind, 
+                                               int32_t coverage, 
+                                               const UnicodeString& name) 
+  : LocaleKeyFactory(coverage, name)
+  , _obj(objToAdopt)
+  , _id(locale.getName())
+  , _kind(kind)
+{
+}
+
+UObject* 
+SimpleLocaleKeyFactory::create(const Key& key, const ICUService* service, UErrorCode& status) const 
+{
+  if (U_SUCCESS(status)) {
+    const LocaleKey& lkey = (const LocaleKey&)key;
+    if (_kind == LocaleKey::KIND_ANY || _kind == lkey.kind()) {
+      UnicodeString keyID;
+      lkey.currentID(keyID);
+      if (_id == keyID) {
+        return service->cloneInstance(_obj); 
+      }
+    }
+  }
+  return NULL;
+}
+
+void 
+SimpleLocaleKeyFactory::updateVisibleIDs(Hashtable& result, UErrorCode& status) const
+{
+  if (U_SUCCESS(status)) {
+    if (_coverage & 0x1) {
+      result.remove(_id);
+    } else {
+      result.put(_id, (void*)this, status);
+    }
+  }
+}
+
+UnicodeString& 
+SimpleLocaleKeyFactory::debug(UnicodeString& result) const 
+{
+  LocaleKeyFactory::debug(result);
+  result.append(", id: ");
+  result.append(_id);
+  result.append(", kind: ");
+  result.append(_kind);
+  return result;
+}
+
+UnicodeString& 
+SimpleLocaleKeyFactory::debugClass(UnicodeString& result) const
+{
+  return result.append("SimpleLocaleKeyFactory");
+}
+
+const char SimpleLocaleKeyFactory::fgClassID = 0;
+
+/*
+ ******************************************************************
+ */
+
+ICUResourceBundleFactory::ICUResourceBundleFactory() 
+  : LocaleKeyFactory(VISIBLE)
+  , _bundleName()
+{
+}
+
+ICUResourceBundleFactory::ICUResourceBundleFactory(const UnicodeString& bundleName) 
+  : LocaleKeyFactory(VISIBLE)
+  , _bundleName(bundleName)
+{
+}
+
+const Hashtable* 
+ICUResourceBundleFactory::getSupportedIDs(UErrorCode& status) const
+{
+  if (U_SUCCESS(status)) {
+    return LocaleUtility::getAvailableLocaleNames(_bundleName);
+  }
+  return NULL;
+}
+
+UObject* 
+ICUResourceBundleFactory::handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const
+{
+  if (U_SUCCESS(status)) {
+    return new ResourceBundle(_bundleName, loc, status);
+  }
+  return NULL;
+}
+
+UnicodeString& 
+ICUResourceBundleFactory::debug(UnicodeString& result) const
+{
+  LocaleKeyFactory::debug(result);
+  result.append(", bundle: ");
+  return result.append(_bundleName);
+}
+
+UnicodeString& 
+ICUResourceBundleFactory::debugClass(UnicodeString& result) const
+{
+  return result.append("ICUResourceBundleFactory");
+}
+
+const char ICUResourceBundleFactory::fgClassID = '\0';
+
+/*
+ ******************************************************************
+ */
+
+ICULocaleService::ICULocaleService()
+  : fallbackLocale(Locale::getDefault()) 
+{
+}
+
+ICULocaleService::ICULocaleService(const UnicodeString& name)
+  : ICUService(name)
+  , fallbackLocale(Locale::getDefault()) 
+{
+}
+
+ICULocaleService::~ICULocaleService() 
+{
+}
+
+UObject* 
+ICULocaleService::get(const Locale& locale, UErrorCode& status) const 
+{
+  return get(locale, LocaleKey::KIND_ANY, NULL, status);
+}
+
+UObject* 
+ICULocaleService::get(const Locale& locale, int32_t kind, UErrorCode& status) const 
+{
+  return get(locale, kind, NULL, status);
+}
+
+UObject* 
+ICULocaleService::get(const Locale& locale, Locale* actualReturn, UErrorCode& status) const 
+{
+  return get(locale, LocaleKey::KIND_ANY, actualReturn, status);
+}
+                   
+UObject* 
+ICULocaleService::get(const Locale& locale, int32_t kind, Locale* actualReturn, UErrorCode& status) const 
+{
+  UObject* result = NULL;
+
+  UnicodeString locName(locale.getName());
+  if (locName.isBogus()) {
+    status = U_MEMORY_ALLOCATION_ERROR;
+  } else {
+    Key* key = createKey(&locName, kind);
+    if (key) {
+      if (actualReturn == NULL) {
+        result = getKey(*key, status);
+      } else {
+        UnicodeString temp;
+        result = getKey(*key, &temp, status);
+
+        if (result != NULL) {
+          key->parseSuffix(temp);
+          LocaleUtility::initLocaleFromName(temp, *actualReturn);
+        }
+      }
+      delete key;
+    }
+  }
+  return result;
+}
+
+const Factory* 
+ICULocaleService::registerObject(UObject* objToAdopt, const Locale& locale) 
+{
+  return registerObject(objToAdopt, locale, LocaleKey::KIND_ANY, LocaleKeyFactory::VISIBLE);
+}
+
+const Factory* 
+ICULocaleService::registerObject(UObject* objToAdopt, const Locale& locale, int32_t kind) 
+{
+  return registerObject(objToAdopt, locale, kind, LocaleKeyFactory::VISIBLE);
+}
+
+const Factory* 
+ICULocaleService::registerObject(UObject* objToAdopt, const Locale& locale, int32_t kind, int32_t coverage) 
+{
+  Factory * factory = new SimpleLocaleKeyFactory(objToAdopt, locale, kind, coverage);
+  if (factory != NULL) {
+    return registerFactory(factory);
+  }
+  delete objToAdopt;
+  return NULL;
+}
+
+class ServiceEnumeration : public StringEnumeration {
+private:
+  const ICULocaleService* _service;
+  int32_t _timestamp;
+  UVector _ids;
+  int32_t _pos;
+  void* _bufp;
+  int32_t _buflen;
+
+private:
+  ServiceEnumeration(const ICULocaleService* service, UErrorCode status) 
+    : _service(service)
+    , _timestamp(service->getTimestamp())
+    , _ids(uhash_deleteUnicodeString, NULL, status)
+    , _pos(0)
+    , _bufp(NULL)
+    , _buflen(0)
+  {
+    _service->getVisibleIDs(_ids, status);
+  }
+
+public:
+  static ServiceEnumeration* create(const ICULocaleService* service) {
+    UErrorCode status = U_ZERO_ERROR;
+    ServiceEnumeration* result = new ServiceEnumeration(service, status);
+    if (U_SUCCESS(status)) {
+      return result;
+    }
+    delete result;
+    return NULL;
+  }
+
+  virtual ~ServiceEnumeration() {
+    uprv_free(_bufp);
+  }
+
+  virtual int32_t count(UErrorCode& status) const {
+    return upToDate(status) ? _ids.size() : 0;
+  }
+
+  const char* next(UErrorCode& status) {
+    const UnicodeString* us = snext(status);
+    if (us) {
+      int newlen;
+      for (newlen = us->extract((char*)_bufp, _buflen / sizeof(char), NULL, status);
+           status == U_STRING_NOT_TERMINATED_WARNING || status == U_BUFFER_OVERFLOW_ERROR;
+           resizeBuffer((newlen + 1) * sizeof(char)))
+        {
+          status = U_ZERO_ERROR;
+        }
+      
+      if (U_SUCCESS(status)) {
+        ((char*)_bufp)[newlen] = 0;
+        return (const char*)_bufp;
+      }
+    }
+    return NULL;
+  }
+
+  const UChar* unext(UErrorCode& status) {
+    const UnicodeString* us = snext(status);
+    if (us) {
+      int newlen;
+      for (newlen = us->extract((UChar*)_bufp, _buflen / sizeof(UChar), status);
+           status == U_STRING_NOT_TERMINATED_WARNING || status == U_BUFFER_OVERFLOW_ERROR;
+           resizeBuffer((newlen + 1) * sizeof(UChar)))
+        {
+          status = U_ZERO_ERROR;
+        }
+      
+      if (U_SUCCESS(status)) {
+        ((UChar*)_bufp)[newlen] = 0;
+        return (const UChar*)_bufp;
+      }
+    }
+    return NULL;
+  }
+
+  const UnicodeString* snext(UErrorCode& status) {
+    if (upToDate(status) && (_pos < _ids.size())) {
+      return (const UnicodeString*)_ids[_pos++];
+    }
+    return NULL;
+  }
+
+  void resizeBuffer(int32_t newlen) {
+    if (_bufp) {
+      _bufp = uprv_realloc(_bufp, newlen);
+    } else {
+      _bufp = uprv_malloc(newlen);
+    }
+  }
+
+  UBool upToDate(UErrorCode& status) const {
+    if (U_SUCCESS(status)) {
+      if (_timestamp == _service->getTimestamp()) {
+        return TRUE;
+      }
+      status = U_ENUM_OUT_OF_SYNC_ERROR;
+    }
+    return FALSE;
+  }
+
+  void reset(UErrorCode& status) {
+    if (U_SUCCESS(status)) {
+      _timestamp = _service->getTimestamp();
+      _pos = 0;
+      _service->getVisibleIDs(_ids, status);
+    }
+  }
+};
+
+StringEnumeration*
+ICULocaleService::getAvailableLocales(void) const 
+{
+	return ServiceEnumeration::create(this);
+}
+
+const UnicodeString& 
+ICULocaleService::validateFallbackLocale() const 
+{
+  const Locale& loc = Locale::getDefault();
+  if (loc != fallbackLocale) {
+    ICULocaleService* ncThis = (ICULocaleService*)this;
+    Mutex mutex(&ncThis->lock);
+    if (loc != fallbackLocale) {
+      ncThis->fallbackLocale = loc;
+      LocaleUtility::initNameFromLocale(loc, ncThis->fallbackLocaleName);
+      ncThis->clearServiceCache();
+    }
+  }
+  return fallbackLocaleName;
+}
+
+Key* 
+ICULocaleService::createKey(const UnicodeString* id) const 
+{
+  return LocaleKey::createWithCanonicalFallback(id, &validateFallbackLocale());
+}
+
+Key* 
+ICULocaleService::createKey(const UnicodeString* id, int32_t kind) const 
+{
+  return LocaleKey::createWithCanonicalFallback(id, &validateFallbackLocale(), kind);
+}
+
+U_NAMESPACE_END
+
+/* !UCONFIG_NO_SERVICE */
+#endif
+
+

icu4c/source/common/iculserv.h

@@ -0,0 +1,545 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2002, International Business Machines Corporation and    *
+ * others. All Rights Reserved.                                                *
+ *******************************************************************************
+ *
+ *******************************************************************************
+ */
+#ifndef ICULSERV_H
+#define ICULSERV_H
+
+#include "unicode/utypes.h"
+
+#if UCONFIG_NO_SERVICE
+
+U_NAMESPACE_BEGIN
+
+/*
+ * Allow the declaration of APIs with pointers to ICUService
+ * even when service is removed from the build.
+ */
+class ICULocaleService;
+
+U_NAMESPACE_END
+
+#else
+
+#include "unicode/uobject.h"
+#include "unicode/unistr.h"
+#include "unicode/chariter.h"
+#include "unicode/locid.h"
+#include "unicode/ubrk.h"
+#include "unicode/strenum.h"
+
+#include "hash.h"
+#include "uvector.h"
+#include "digitlst.h"
+
+#include "icuserv.h"
+
+U_NAMESPACE_BEGIN
+
+class ICULocaleService;
+
+class LocaleKey;
+class LocaleKeyFactory;
+class SimpleLocaleKeyFactory;
+class ServiceListener;
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * 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.  If a prefix is present, the currentDescriptor
+ * includes it before the locale proper, separated by "/".  This
+ * is the default key 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> 
+ */
+
+class U_COMMON_API LocaleKey : public Key {
+  private: 
+    int32_t _kind;
+    UnicodeString _primaryID;
+    UnicodeString _fallbackID;
+    UnicodeString _currentID;
+
+    static const UChar UNDERSCORE_CHAR; // '_'
+
+  public:
+    static const int32_t KIND_ANY; //  = -1;
+
+    /**
+     * Create a LocaleKey with canonical primary and fallback IDs.
+     */
+    static LocaleKey* createWithCanonicalFallback(const UnicodeString* primaryID, 
+                                                  const UnicodeString* canonicalFallbackID);
+	    
+    /**
+     * Create a LocaleKey with canonical primary and fallback IDs.
+     */
+    static LocaleKey* createWithCanonicalFallback(const UnicodeString* primaryID, 
+                                                  const UnicodeString* canonicalFallbackID, 
+                                                  int32_t kind);
+	    
+  protected:
+    /**
+     * 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.
+     */
+    LocaleKey(const UnicodeString& primaryID, 
+              const UnicodeString& canonicalPrimaryID, 
+              const UnicodeString* canonicalFallbackID, 
+              int32_t kind);
+
+ public:
+    /**
+     * Append the prefix associated with the kind, or nothing if the kind is KIND_ANY.
+     */
+    virtual UnicodeString& prefix(UnicodeString& result) const;
+
+    /**
+     * Return the kind code associated with this key.
+     */
+    virtual int32_t kind() const;
+
+    /**
+     * Return the canonicalID.
+     */
+    virtual UnicodeString& canonicalID(UnicodeString& result) const;
+
+    /**
+     * Return the currentID.
+     */
+    virtual UnicodeString& currentID(UnicodeString& result) const;
+
+    /**
+     * Return the (canonical) current descriptor, or null if no current id.
+     */
+    virtual UnicodeString& currentDescriptor(UnicodeString& result) const;
+
+    /**
+     * Convenience method to return the locale corresponding to the (canonical) original ID.
+     */
+    virtual Locale& canonicalLocale(Locale& result) const;
+
+    /**
+     * Convenience method to return the locale corresponding to the (canonical) current ID.
+     */
+    virtual Locale& currentLocale(Locale& result) const;
+
+    /**
+     * 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.  
+     */
+    virtual UBool fallback();
+
+    /**
+     * Return true if a key created from id matches, or would eventually
+     * fallback to match, the canonical ID of this key.  
+     */
+    virtual UBool isFallbackOf(const UnicodeString& id) const;
+    
+ public:
+    /**
+     * UObject boilerplate.
+     */
+    virtual UClassID getDynamicClassID() const {
+        return getStaticClassID();
+    }
+
+    static UClassID getStaticClassID() { 
+        return (UClassID)&fgClassID;
+    }
+
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+
+ private:
+    static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * A subclass of Factory that uses LocaleKeys, and is able to
+ * 'cover' more specific locales with more general locales that it
+ * supports.  
+ *
+ * <p>Coverage may be either of the values VISIBLE or INVISIBLE.
+ *
+ * <p>'Visible' indicates that the specific locale(s) supported by
+ * the factory are registered in getSupportedIDs, 'Invisible'
+ * indicates that they are not.
+ *
+ * <p>Localization of visible ids is handled
+ * by the handling factory, regardless of kind.
+ */
+class U_COMMON_API LocaleKeyFactory : public Factory {
+protected:
+    const UnicodeString _name;
+    const int32_t _coverage;
+
+public:
+    enum {
+        /**
+         * Coverage value indicating that the factory makes
+         * its locales visible, and does not cover more specific 
+         * locales.
+         */
+        VISIBLE = 0,
+
+        /**
+         * Coverage value indicating that the factory does not make
+         * its locales visible, and does not cover more specific
+         * locales.
+         */
+        INVISIBLE = 1
+    };
+
+protected:
+    /**
+     * Constructor used by subclasses.
+     */
+    LocaleKeyFactory(int32_t coverage);
+
+    /**
+     * Constructor used by subclasses.
+     */
+    LocaleKeyFactory(int32_t coverage, const UnicodeString& name);
+
+    /**
+     * Destructor.
+     */
+    virtual ~LocaleKeyFactory();
+
+    /**
+     * Implement superclass abstract method.  This checks the currentID of
+     * the key against the supported IDs, and passes the canonicalLocale and
+     * kind off to handleCreate (which subclasses must implement).
+     */
+public:
+    virtual UObject* create(const Key& key, const ICUService* service, UErrorCode& status) const;
+
+protected:
+    virtual UBool handlesKey(const Key& key, UErrorCode& status) const;
+
+public:
+    /**
+     * Override of superclass method.  This adjusts the result based
+     * on the coverage rule for this factory.
+     */
+    void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+
+    /**
+     * Return a localized name for the locale represented by id.
+     */
+    UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
+
+protected:
+    /**
+     * Utility method used by create(Key, ICUService).  Subclasses can implement
+     * this instead of create.  The default returns NULL.
+     */
+    virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const;
+
+    /**
+     * Return the set of ids that this factory supports (visible or 
+     * otherwise).  This can be called often and might need to be
+     * cached if it is expensive to create.
+     */
+    virtual const Hashtable* getSupportedIDs(UErrorCode& status) const;
+
+ public:
+    /**
+     * UObject boilerplate.
+     */
+    virtual UClassID getDynamicClassID() const {
+        return getStaticClassID();
+    }
+
+    static UClassID getStaticClassID() { 
+        return (UClassID)&fgClassID;
+    }
+
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+
+ private:
+    static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * A LocaleKeyFactory that just returns a single object for a kind/locale.
+ */
+
+class U_COMMON_API SimpleLocaleKeyFactory : public LocaleKeyFactory {
+ private:
+    UObject* _obj;
+    UnicodeString _id;
+    const int32_t _kind;
+
+ public:
+    SimpleLocaleKeyFactory(UObject* objToAdopt, 
+                           const Locale& locale, 
+                           int32_t kind, 
+                           int32_t coverage);
+
+    SimpleLocaleKeyFactory(UObject* objToAdopt, 
+                           const Locale& locale, 
+                           int32_t kind, 
+                           int32_t coverage, 
+                           const UnicodeString& name);
+
+    /**
+     * Override of superclass method.  Returns the service object if kind/locale match.  Service is not used.
+     */
+    UObject* create(const Key& key, const ICUService* service, UErrorCode& status) const;
+
+    /**
+     * Override of superclass method.  This adjusts the result based
+     * on the coverage rule for this factory.
+     */
+    void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+
+ public:
+    /**
+     * UObject boilerplate.
+     */
+    virtual UClassID getDynamicClassID() const {
+        return getStaticClassID();
+    }
+
+    static UClassID getStaticClassID() { 
+        return (UClassID)&fgClassID;
+    }
+
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+
+ private:
+    static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * A LocaleKeyFactory that creates a service based on the ICU locale data.
+ * This is a base class for most ICU factories.  Subclasses instantiate it
+ * with a constructor that takes a bundle name, which determines the supported
+ * IDs.  Subclasses then override handleCreate to create the actual service
+ * object.  The default implementation returns a resource bundle.
+ */
+class U_COMMON_API ICUResourceBundleFactory : public LocaleKeyFactory 
+{
+ protected:
+    UnicodeString _bundleName;
+
+ public:
+    /**
+     * Convenience constructor that uses the main ICU bundle name.
+     */
+    ICUResourceBundleFactory();
+
+    /**
+     * A service factory based on ICU resource data in resources
+     * with the given name.
+     */
+    ICUResourceBundleFactory(const UnicodeString& bundleName);
+
+protected:
+    /**
+     * Return the supported IDs.  This is the set of all locale names in ICULocaleData.
+     */
+    virtual const Hashtable* getSupportedIDs(UErrorCode& status) const;
+
+    /**
+     * Create the service.  The default implementation returns the resource bundle
+     * for the locale, ignoring kind, and service.
+     */
+    virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const;
+
+ public:
+    /**
+     * UObject boilerplate.
+     */
+    virtual UClassID getDynamicClassID() const {
+        return getStaticClassID();
+    }
+
+    static UClassID getStaticClassID() { 
+        return (UClassID)&fgClassID;
+    }
+
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+
+ private:
+    static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+class U_COMMON_API ICULocaleService : public ICUService 
+{
+ private:
+  Locale fallbackLocale;
+  UnicodeString fallbackLocaleName;
+
+ public:
+  /**
+   * Construct an ICULocaleService.
+   */
+  ICULocaleService();
+
+  /**
+   * Construct an ICULocaleService with a name (useful for debugging).
+   */
+  ICULocaleService(const UnicodeString& name);
+
+  /**
+   * Destructor.
+   */
+  ~ICULocaleService();
+
+#if 0
+  // redeclare because of overload resolution rules?
+  UObject* get(const UnicodeString& descriptor, UErrorCode& status) const {
+    return ICUService::get(descriptor, status);
+  }
+
+  UObject* get(const UnicodeString& descriptor, UnicodeString* actualReturn, UErrorCode& status) const {
+    return ICUService::get(descriptor, actualReturn, status);
+  }
+#endif
+
+  /**
+   * Convenience override for callers using locales.  This calls
+   * get(Locale, int, Locale[]) with KIND_ANY for kind and null for
+   * actualReturn.
+   */
+  UObject* get(const Locale& locale, UErrorCode& status) const;
+
+  /**
+   * Convenience override for callers using locales.  This calls
+   * get(Locale, int, Locale[]) with a null actualReturn.
+   */
+  UObject* get(const Locale& locale, int32_t kind, UErrorCode& status) const;
+
+  /**
+   * Convenience override for callers using locales. This calls
+   * get(Locale, String, Locale[]) with a null kind.
+   */
+  UObject* get(const Locale& locale, Locale* actualReturn, UErrorCode& status) const;
+                   
+  /**
+   * Convenience override for callers using locales.  This uses
+   * createKey(Locale.toString(), kind) to create a key, calls getKey, and then
+   * if actualReturn is not null, returns the actualResult from
+   * getKey (stripping any prefix) into a Locale.  
+   */
+  UObject* get(const Locale& locale, int32_t kind, Locale* actualReturn, UErrorCode& status) const;
+
+  /**
+   * Convenience override for callers using locales.  This calls
+   * registerObject(Object, Locale, int32_t kind, int coverage)
+   * passing KIND_ANY for the kind, and VISIBLE for the coverage.
+   */
+  const Factory* registerObject(UObject* objToAdopt, const Locale& locale);
+
+  /**
+   * Convenience function for callers using locales.  This calls
+   * registerObject(Object, Locale, int kind, int coverage)
+   * passing VISIBLE for the coverage.
+   */
+  const Factory* registerObject(UObject* objToAdopt, const Locale& locale, int32_t kind);
+
+  /**
+   * Convenience function for callers using locales.  This  instantiates
+   * a SimpleLocaleKeyFactory, and registers the factory.
+   */
+  virtual const Factory* registerObject(UObject* objToAdopt, const Locale& locale, int32_t kind, int32_t coverage);
+
+  /**
+   * Convenience method for callers using locales.  This returns the standard
+   * service ID enumeration.
+   */
+  virtual StringEnumeration* getAvailableLocales(void) const;
+
+  /**
+   * Return the name of the current fallback locale.  If it has changed since this was
+   * last accessed, the service cache is cleared.
+   */
+  const UnicodeString& validateFallbackLocale() const;
+
+  /**
+   * Override superclass createKey method.
+   */
+  virtual Key* createKey(const UnicodeString* id) const;
+
+  /**
+   * Additional createKey that takes a kind.
+   */
+  virtual Key* createKey(const UnicodeString* id, int32_t kind) const;
+
+  /*
+  virtual int32_t getTimestamp() const {
+    return ICUService::getTimestamp();
+  }
+  */
+
+  friend class ServiceEnumeration;
+};
+
+// temporary utility functions, till I know where to find them
+// in header so tests can also access them
+
+class U_COMMON_API LocaleUtility {
+  static Hashtable* cache;
+  static UMTX lock;
+  static const UChar UNDERSCORE_CHAR;
+
+public:
+  static UnicodeString& canonicalLocaleString(const UnicodeString* id, UnicodeString& result);
+  static Locale& initLocaleFromName(const UnicodeString& id, Locale& result);
+  static UnicodeString& initNameFromLocale(const Locale& locale, UnicodeString& result);
+  static const Hashtable* getAvailableLocaleNames(const UnicodeString& bundleID);
+  static UBool isFallbackOf(const UnicodeString& root, const UnicodeString& child);
+};
+
+U_NAMESPACE_END
+
+    /* UCONFIG_NO_SERVICE */
+#endif
+
+    /* ICULSERV_H */
+#endif
+

icu4c/source/common/icunotif.cpp

@@ -0,0 +1,97 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2002, International Business Machines Corporation and    *
+ * others. All Rights Reserved.                                                *
+ *******************************************************************************
+ */
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_SERVICE
+
+#include "icunotif.h"
+#include <stdio.h>
+
+U_NAMESPACE_BEGIN
+
+const char EventListener::fgClassID = '\0';
+
+void 
+ICUNotifier::addListener(const EventListener* l, UErrorCode& status) 
+{
+  if (U_SUCCESS(status)) {
+    if (l == NULL) {
+      status = U_ILLEGAL_ARGUMENT_ERROR;
+    }
+
+    if (acceptsListener(*l)) {
+      Mutex lmx(&notifyLock);
+      if (listeners == NULL) {
+        listeners = new UVector(5, status);
+      } else {
+        for (int i = 0, e = listeners->size(); i < e; ++i) {
+          const EventListener* el = (const EventListener*)(listeners->elementAt(i));
+          if (l == el) {
+            return;
+          }
+        }
+      }
+
+      listeners->addElement((void*)l, status); // cast away const
+    } else {
+#if DEBUG
+      fprintf(stderr, "Listener invalid for this notifier.");
+      exit(1);
+#endif
+    }
+  }
+}
+
+void 
+ICUNotifier::removeListener(const EventListener *l, UErrorCode& status) 
+{
+  if (U_SUCCESS(status)) {
+    if (l == NULL) {
+      status = U_ILLEGAL_ARGUMENT_ERROR;
+      return;
+    }
+
+    {
+      Mutex lmx(&notifyLock);
+      if (listeners != NULL) {
+        // identity equality check
+        for (int i = 0, e = listeners->size(); i < e; ++i) {
+          const EventListener* el = (const EventListener*)listeners->elementAt(i);
+          if (l == el) {
+            listeners->removeElementAt(i);
+            if (listeners->size() == 0) {
+              delete listeners;
+              listeners = NULL;
+            }
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+void 
+ICUNotifier::notifyChanged(void) 
+{
+  if (listeners != NULL) {
+    Mutex lmx(&notifyLock);
+    if (listeners != NULL) {
+      for (int i = 0, e = listeners->size(); i < e; ++i) {
+        EventListener* el = (EventListener*)listeners->elementAt(i);
+        notifyListener(*el);
+      }
+    }
+  }
+}
+
+U_NAMESPACE_END;
+
+/* UCONFIG_NO_SERVICE */
+#endif
+

icu4c/source/common/icunotif.h

@@ -0,0 +1,136 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2002, International Business Machines Corporation and    *
+ * others. All Rights Reserved.                                                *
+ *******************************************************************************
+ */
+#ifndef ICUNOTIF_H
+#define ICUNOTIF_H
+
+#include "unicode/utypes.h"
+
+#if UCONFIG_NO_SERVICE
+
+U_NAMESPACE_BEGIN
+
+/*
+ * Allow the declaration of APIs with pointers to BreakIterator
+ * even when break iteration is removed from the build.
+ */
+class ICUNotifier;
+
+U_NAMESPACE_END
+
+#else
+
+#include "unicode/uobject.h"
+#include "unicode/unistr.h"
+
+#include "mutex.h"
+#include "uvector.h"
+
+U_NAMESPACE_BEGIN
+
+class U_COMMON_API EventListener : public UObject {
+ public: 
+  virtual ~EventListener() {}
+
+ public:
+    virtual UClassID getDynamicClassID() const {
+        return getStaticClassID();
+    }
+
+    static UClassID getStaticClassID() { 
+        return (UClassID)&fgClassID;
+    }
+
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const {
+      return debugClass(result);
+    }
+
+    virtual UnicodeString& debugClass(UnicodeString& result) const {
+      return result.append("Key");
+    }
+
+ private:
+    static const char fgClassID;
+};
+
+/**
+ * <p>Abstract implementation of a notification facility.  Clients add
+ * EventListeners with addListener and remove them with removeListener.
+ * Notifiers call notifyChanged when they wish to notify listeners.
+ * This queues the listener list on the notification thread, which
+ * eventually dequeues the list and calls notifyListener on each
+ * listener in the list.</p>
+ *
+ * <p>Subclasses override acceptsListener and notifyListener 
+ * to add type-safe notification.  AcceptsListener should return
+ * true if the listener is of the appropriate type; ICUNotifier
+ * itself will ensure the listener is non-null and that the
+ * identical listener is not already registered with the Notifier.
+ * NotifyListener should cast the listener to the appropriate 
+ * type and call the appropriate method on the listener.
+ */
+
+class U_COMMON_API ICUNotifier : public UMemory  {
+ private: UMTX notifyLock;
+ private: UVector* listeners;
+
+ public: 
+ ICUNotifier(void) 
+   : notifyLock(0), listeners(NULL) 
+   {
+   }
+
+ virtual ~ICUNotifier(void) {
+   Mutex lmx(&notifyLock);
+   delete listeners;
+   listeners = NULL;
+ }
+
+ /**
+  * Add a listener to be notified when notifyChanged is called.
+  * The listener must not be null. AcceptsListener must return
+  * true for the listener.  Attempts to concurrently
+  * register the identical listener more than once will be
+  * silently ignored.  
+  */
+ virtual void addListener(const EventListener* l, UErrorCode& status);
+
+ /**
+  * Stop notifying this listener.  The listener must
+  * not be null.  Attemps to remove a listener that is
+  * not registered will be silently ignored.
+  */
+ virtual void removeListener(const EventListener* l, UErrorCode& status);
+
+ /**
+  * ICU doesn't spawn its own threads.  All listeners are notified in
+  * the thread of the caller.  Misbehaved listeners can therefore
+  * indefinitely block the calling thread.  Callers should beware of
+  * deadlock situations.  
+  */
+ virtual void notifyChanged(void);
+
+ protected: 
+ /**
+  * Subclasses implement this to return TRUE if the listener is
+  * of the appropriate type.
+  */
+ virtual UBool acceptsListener(const EventListener& l) const = 0;
+
+ /**
+  * Subclasses implement this to notify the listener.
+  */
+ virtual void notifyListener(EventListener& l) const = 0;
+};
+
+U_NAMESPACE_END
+
+/* UCONFIG_NO_SERVICE */
+#endif
+
+/* ICUNOTIF_H */
+#endif

icu4c/source/common/icuserv.h

@@ -0,0 +1,719 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2002, International Business Machines Corporation.       *
+ * All Rights Reserved.                                                        *
+ *******************************************************************************
+ */
+
+#ifndef ICUSERV_H
+#define ICUSERV_H
+
+#include "unicode/utypes.h"
+
+#if UCONFIG_NO_SERVICE
+
+U_NAMESPACE_BEGIN
+
+/*
+ * Allow the declaration of APIs with pointers to ICUService
+ * even when service is removed from the build.
+ */
+class ICUService;
+
+U_NAMESPACE_END
+
+#else
+
+#include "unicode/uobject.h"
+#include "unicode/unistr.h"
+#include "unicode/chariter.h"
+#include "unicode/locid.h"
+#include "unicode/ubrk.h"
+
+#include "hash.h"
+#include "uvector.h"
+#include "icunotif.h"
+
+U_NAMESPACE_BEGIN
+
+class Key;
+class Factory;
+class SimpleFactory;
+class ServiceListener;
+class ICUServiceEnumeration;
+class ICUService;
+class ICUServiceTest;
+
+class DNCache;
+
+/*
+ ******************************************************************
+ */
+
+ /**
+  * 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>
+  */
+class U_COMMON_API Key : public UObject {
+ private: 
+  const UnicodeString _id;
+
+ protected:
+  static const UChar PREFIX_DELIMITER;
+
+ public:
+
+ /**
+  * Construct a key from an id.
+  */
+  Key(const UnicodeString& id);
+
+  /**
+   * Virtual destructor.
+   */
+  virtual ~Key();
+
+ /**
+  * Return the original ID used to construct this key.
+  */
+  virtual const UnicodeString& getID() const;
+
+ /**
+  * Return the canonical version of the original ID.  This implementation
+  * appends the original ID to result.  It returns result as a convenience.
+  */
+  virtual UnicodeString& canonicalID(UnicodeString& result) const;
+
+ /**
+  * Return the (canonical) current ID.  This implementation
+  * appends the canonical ID to result.  It returns result as a convenience.
+  */
+  virtual UnicodeString& currentID(UnicodeString& result) const;
+
+ /**
+  * Return the current descriptor.  This implementation returns
+  * the current ID in result, ignoring any previous contents.
+  * Result is returned as a convenience.
+  *
+  * <p>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. 
+  */
+  virtual UnicodeString& currentDescriptor(UnicodeString& result) const;
+
+ /**
+  * 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 implmentation has no fallbacks
+  * and always returns false.
+  */
+  virtual UBool fallback();
+
+ /**
+  * Return true if a key created from id matches, or would eventually
+  * fallback to match, the canonical ID of this key.  
+  */
+  virtual UBool isFallbackOf(const UnicodeString& id) const;
+
+ /**
+  * Append the prefix to result
+  */
+  virtual UnicodeString& prefix(UnicodeString& result) const;
+
+ /**
+  * Parse the prefix out of a descriptor string.
+  */
+  static UnicodeString& parsePrefix(UnicodeString& result);
+
+  /**
+  * Parse the suffix out of a descriptor string.
+  */
+  static UnicodeString& parseSuffix(UnicodeString& result);
+
+ public:
+  /**
+   * UObject boilerplate.
+   */
+  virtual UClassID getDynamicClassID() const {
+    return getStaticClassID();
+  }
+
+  static UClassID getStaticClassID() { 
+    return (UClassID)&fgClassID;
+  }
+
+ public:
+  virtual UnicodeString& debug(UnicodeString& result) const;
+  virtual UnicodeString& debugClass(UnicodeString& result) const;
+
+ private:
+    static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+ /**
+  * 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.  
+  */
+class U_COMMON_API Factory : public UObject {
+ public:
+
+    /**
+     * 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
+     * defaultCreate(const Key& key, const ICUService*)
+     * 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.
+     */
+    virtual UObject* create(const Key& key, const ICUService* service, UErrorCode& status) const = 0;
+
+    /**
+     * 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.
+     */
+    virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const = 0;
+
+    /**
+     * 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.
+     */
+    virtual UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const = 0;
+};
+
+/*
+ ******************************************************************
+ */
+
+ /**
+  * 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.
+  */
+class U_COMMON_API SimpleFactory : public Factory {
+ protected:
+  UObject* _instance;
+  const UnicodeString _id;
+  const UBool _visible;
+
+ public:
+  /**
+   * Convenience constructor that calls SimpleFactory(Object, String, boolean)
+   * with visible true.
+   */
+  SimpleFactory(UObject* instanceToAdopt, const UnicodeString& id);
+
+  /**
+   * 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.
+   */
+  SimpleFactory(UObject* instanceToAdopt, const UnicodeString& id, UBool visible);
+
+  /**
+   * Virtual destructor.
+   */
+  virtual ~SimpleFactory();
+
+  /**
+   * Return the service instance if the factory's id is equal to
+   * the key's currentID.  Service is ignored.
+   */
+  UObject* create(const Key& key, const ICUService* service, UErrorCode& status) const;
+
+  /**
+   * If visible, adds a mapping from id -> this to the result, 
+   * otherwise removes id from result.
+   */
+  void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+
+  /**
+   * If this.id equals id, returns id regardless of locale,
+   * otherwise returns the empty string.  (This default implementation has
+   * no localized id information.)  
+   */
+  UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
+
+ public:
+
+ /**
+  * UObject boilerplate.
+  */
+  virtual UClassID getDynamicClassID() const {
+	  return getStaticClassID();
+  }
+
+  static UClassID getStaticClassID() { 
+	  return (UClassID)&fgClassID;
+  }
+
+ public:
+
+  /**
+   * For debugging.
+   */
+  virtual UnicodeString& debug(UnicodeString& toAppendTo) const;
+  virtual UnicodeString& debugClass(UnicodeString& toAppendTo) const;
+
+ private:
+  static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * ServiceListener is the listener that ICUService provides by default.
+ * ICUService will notifiy 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.
+ */
+class U_COMMON_API ServiceListener : public EventListener {
+ public:
+  virtual UClassID getDynamicClassID() const {
+    return getStaticClassID();
+  }
+
+  static UClassID getStaticClassID() {
+    return (UClassID)&fgClassID;
+  }
+
+  virtual void serviceChanged(const ICUService& service) const = 0;
+
+ private:
+  static const char fgClassID;
+};
+
+/*
+ ******************************************************************
+ */
+
+class U_COMMON_API StringPair : public UMemory {
+public:
+  const UnicodeString displayName;
+  const UnicodeString id;
+
+  static StringPair* create(const UnicodeString& displayName, 
+                            const UnicodeString& id,
+                            UErrorCode& status);
+
+  UBool isBogus() const;
+
+private:
+  StringPair(const UnicodeString& displayName, const UnicodeString& id);
+};
+
+/**
+ * Deleter for StringPairs
+ */
+U_CAPI void U_EXPORT2
+deleteStringPair(void *obj);
+
+/*
+ ******************************************************************
+ */
+
+ /**
+ * <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> 
+ */
+class U_COMMON_API ICUService : public ICUNotifier {
+ protected: 
+    /**
+     * Name useful for debugging.
+     */
+    const UnicodeString name;
+
+    /**
+     * single lock used by this service.
+     */
+    UMTX lock;
+
+ private:
+    /**
+     * Timestamp so iterators can be fail-fast.
+     */
+    uint32_t timestamp;
+
+    /**
+     * All the factories registered with this service.
+     */
+    UVector* factories;
+
+    /**
+     * The service cache.
+     */
+    Hashtable* serviceCache;
+
+    /**
+     * The id cache.
+     */
+    Hashtable* idCache;
+
+    /**
+     * The name cache.
+     */
+    DNCache* dnCache;
+
+    /**
+     * Constructor.
+     */
+ public:
+    ICUService();
+
+    /**
+     * Construct with a name (useful for debugging).
+     */
+    ICUService(const UnicodeString& name);
+
+    /**
+     * Destructor.
+     */
+    virtual ~ICUService();
+
+    /**
+     * Return the name of this service. This will be the empty string if none was assigned.
+     */
+    UnicodeString& getName(UnicodeString& result) const;
+
+    /**
+     * Convenience override for get(Key&, UnicodeString*). This uses
+     * createKey to create a key for the provided descriptor.
+     */
+    UObject* get(const UnicodeString& descriptor, UErrorCode& status) const;
+
+    /**
+     * Convenience override for get(Key&, UnicodeString*).  This uses
+     * createKey to create a key from the provided descriptor.
+     */
+    UObject* get(const UnicodeString& descriptor, UnicodeString* actualReturn, UErrorCode& status) const;
+
+    /**
+     * Convenience override for get(Key&, UnicodeString*).
+     */
+    UObject* getKey(Key& key, UErrorCode& status) const;
+
+    /**
+     * <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>
+     */
+    UObject* getKey(Key& key, UnicodeString* actualReturn, UErrorCode& status) const;
+
+    /**
+     * <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>
+     */
+    UObject* getKey(Key& key, UnicodeString* actualReturn, const Factory* factory, UErrorCode& status) const;
+
+    /**
+     * Convenience override for getVisibleIDs(String) that passes null
+     * as the fallback, thus returning all visible IDs.
+     */
+    UVector& getVisibleIDs(UVector& result, UErrorCode& status) const;
+
+    /**
+     * <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.
+     *
+     * <p>The IDs are returned as pointers to UnicodeStrings.  The
+     * caller owns the IDs.
+     */
+    UVector& getVisibleIDs(UVector& result, const UnicodeString* matchID, UErrorCode& status) const;
+
+    /**
+     * Convenience override for getDisplayName(String, Locale) that
+     * uses the current default locale.
+     */
+    UnicodeString& getDisplayName(const UnicodeString& id, UnicodeString& result) const;
+
+    /**
+     * Given a visible id, return the display name in the requested locale.
+     * If there is no directly supported id corresponding to this id, set
+     * result to bogus.
+     */
+    UnicodeString& getDisplayName(const UnicodeString& id, UnicodeString& result, const Locale& locale) const;
+
+    /**
+     * Convenience override of getDisplayNames(Locale, String) that 
+     * uses the current default Locale as the locale and NULL for
+     * the matchID.
+     */
+    UVector& getDisplayNames(UVector& result, UErrorCode& status) const;
+
+    /**
+     * Convenience override of getDisplayNames(Locale, String) that
+     */
+    UVector& getDisplayNames(UVector& result, const Locale& locale, UErrorCode& status) const;
+
+    /**
+     * 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.  This iterates over StringPair instances.
+     */
+    UVector& getDisplayNames(UVector& result,
+                             const Locale& locale, 
+                             const UnicodeString* matchID, 
+                             UErrorCode& status) const;
+
+    /**
+     * A convenience override of registerObject(Object, String, boolean)
+     * that defaults visible to true.  The service adopts the object.
+     */
+    const Factory* registerObject(UObject* objToAdopt, const UnicodeString& id);
+
+    /**
+     * Register an object with the provided id.  The id will be 
+     * canonicalized.  The canonicalized ID will be returned by
+     * getVisibleIDs if visible is true.  This wraps the object
+     * using createSimpleFactory and calls registerFactory.
+     */
+    virtual const Factory* registerObject(UObject* obj, const UnicodeString& id, UBool visible);
+
+    /**
+     * Register a Factory.  Returns the factory if the service accepts
+     * the factory, otherwise returns null.  The default implementation
+     * accepts all factories.  The service owns the factories. 
+     */
+    virtual const Factory* registerFactory(Factory* factoryToAdopt);
+
+    /**
+     * Unregister a factory.  The first matching registered factory will
+     * be deleted and removed from the list.  Returns true if a matching factory was
+     * found.  If not found, factory is not deleted, but this is typically an
+     * error.
+     */
+    virtual UBool unregisterFactory(Factory* factory);
+
+    /**
+     * Reset the service to the default factories.  The factory
+     * lock is acquired and then reInitializeFactories is called.
+     */
+    virtual void reset();
+
+    /**
+     * Return true if the service is in its default state.  The default
+     * implementation returns true if there are no factories registered.
+     */
+    virtual UBool isDefault() const;
+
+    /**
+     * 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.
+     */
+    virtual Key* createKey(const UnicodeString* id) const;
+
+    /**
+     * Clone object so that caller can own the copy.  UObject doesn't yet implement
+     * clone so we need an instance-aware method that knows how to do this.
+     * This is public so factories can call it, but should really be protected.
+     */
+    virtual UObject* cloneInstance(UObject* instance) const = 0;
+
+ protected:
+
+    /**
+     * Create a factory that wraps a singleton object.
+     * Default is an instance of SimpleFactory.
+     */
+    virtual Factory* createSimpleFactory(UObject* objToAdopt, const UnicodeString& id, UBool visible);
+
+    /**
+     * 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.  
+     */
+    virtual void reInitializeFactories();
+
+    /**
+     * Default handler for this service if no factory in the list
+     * handled the key.
+     */
+    virtual UObject* handleDefault(const Key& key, UnicodeString* actualIDReturn, UErrorCode& status) const;
+
+    /**
+     * 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.
+     */
+    virtual void clearCaches();
+
+    /**
+     * 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.
+     */
+    void clearServiceCache();
+
+    /**
+     * Return true if the listener is accepted; by default this
+     * requires a ServiceListener.  Subclasses can override to accept
+     * different listeners.  
+     */
+    virtual UBool acceptsListener(const EventListener& l) const;
+
+    /**
+     * Notify the listener, which by default is a ServiceListener.
+     * Subclasses can override to use a different listener.  
+     */
+    virtual void notifyListener(EventListener& l) const;
+
+    /**
+     * Return a map from visible ids to factories.  
+     * This should be only be called when the mutex is held.
+     */
+    const Hashtable* getVisibleIDMap(UErrorCode& status) const;
+
+    /**
+     * Allow subclasses to read the time stamp.
+     */
+    virtual int32_t getTimestamp() const;
+
+ private:
+
+    friend class ICUServiceTest;
+    /**
+     * Return the number of factories, used for testing.
+     */
+    int32_t countFactories() const;
+};
+
+U_NAMESPACE_END
+
+    /* UCONFIG_NO_SERVICE */
+#endif
+
+    /* ICUSERV_H */
+#endif
+

icu4c/source/common/unicode/strenum.h

@@ -0,0 +1,40 @@
+/*
+*******************************************************************************
+*
+*   Copyright (C) 2002, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*/
+
+#ifndef STRENUM_H
+#define STRENUM_H
+
+#include "uobject.h"
+
+U_NAMESPACE_BEGIN
+
+/**
+ * Base class for 'pure' C++ implementations.  Adds method that
+ * returns the next UnicodeString since in C++ this might be a
+ * common storage model for strings.
+ */
+class U_COMMON_API StringEnumeration : public UMemory {
+ public:
+  virtual ~StringEnumeration();
+  virtual int32_t count(UErrorCode& status) const = 0;
+
+  virtual const char* next(UErrorCode& status) = 0;
+  virtual const UChar* unext(UErrorCode& status) = 0;
+  virtual const UnicodeString* snext(UErrorCode& status) = 0;
+
+  virtual void reset(UErrorCode& status) = 0;
+};
+
+inline StringEnumeration::~StringEnumeration() {
+}
+
+U_NAMESPACE_END
+
+/* STRENUM_H */
+#endif

icu4c/source/test/intltest/icusvtst.h

@@ -0,0 +1,65 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2002, International Business Machines Corporation and    *
+ * others. All Rights Reserved.                                                *
+ *******************************************************************************
+ *
+ *******************************************************************************
+ */
+
+#ifndef ICUSVTST_H
+#define ICUSVTST_H
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_SERVICE
+
+#include "intltest.h"
+
+U_NAMESPACE_BEGIN
+
+class Integer;
+
+class ICUServiceTest : public IntlTest
+{    
+ public:
+  ICUServiceTest();
+  ~ICUServiceTest();
+
+  void runIndexedTest(int32_t index, UBool exec, const char* &name, char* par = NULL);
+
+  void testAPI_One(void);
+  void testAPI_Two(void);
+  void testRBF(void);
+  void testNotification(void);
+  void testLocale(void);
+  void testWrapFactory(void);
+  void testCoverage(void);
+
+ private:
+  UnicodeString& lrmsg(UnicodeString& result, const UnicodeString& message, const UObject* lhs, const UObject* rhs) const;
+  void confirmBoolean(const UnicodeString& message, UBool val);
+#if 0
+  void confirmEqual(const UnicodeString& message, const UObject* lhs, const UObject* rhs);
+#else
+  void confirmEqual(const UnicodeString& message, const Integer* lhs, const Integer* rhs);
+  void confirmEqual(const UnicodeString& message, const UnicodeString* lhs, const UnicodeString* rhs);
+  void confirmEqual(const UnicodeString& message, const Locale* lhs, const Locale* rhs);
+#endif
+  void confirmStringsEqual(const UnicodeString& message, const UnicodeString& lhs, const UnicodeString& rhs);
+  void confirmIdentical(const UnicodeString& message, const UObject* lhs, const UObject* rhs);
+  void confirmIdentical(const UnicodeString& message, int32_t lhs, int32_t rhs);
+
+  void msgstr(const UnicodeString& message, UObject* obj, UBool err = TRUE);
+  void logstr(const UnicodeString& message, UObject* obj) {
+		msgstr(message, obj, FALSE);
+  }
+};
+
+U_NAMESPACE_END
+
+/* UCONFIG_NO_SERVICE */
+#endif
+
+/* ICUSVTST_H */
+#endif

icu4c/source/test/intltest/intltest.cpp

@@ -1154,7 +1154,7 @@ main(int argc, char* argv[])
         /* Call it twice to make sure that the defaults were reset. */
         /* Call it before the OK message to verify proper cleanup. */
         u_cleanup();
-        u_cleanup();
+     u_cleanup();
 
         fprintf(stdout, "OK: All tests passed without error.\n");
     }else{

icu4c/source/test/intltest/intltest.dsp

@@ -270,6 +270,10 @@ SOURCE=.\hxuntrts.cpp
 # End Source File
 # Begin Source File
 
+SOURCE=.\icusvtst.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=.\intltest.cpp
 # End Source File
 # Begin Source File
@@ -647,6 +651,10 @@ SOURCE=.\hxuntrts.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\icusvtst.h
+# End Source File
+# Begin Source File
+
 SOURCE=.\intltest.h
 # End Source File
 # Begin Source File

icu4c/source/test/intltest/itmajor.cpp

@@ -29,6 +29,7 @@
 #include "regextst.h"
 #include "tstnorm.h"
 #include "canittst.h"
+#include "icusvtst.h"
 
 #define CASE_SUITE(id, suite) case id:                  \
                           name = #suite;                \
@@ -135,6 +136,15 @@ void MajorTestLevel::runIndexedTest( int32_t index, UBool exec, const char* &nam
 #endif /* ICU_UNICODECONVERTER_USE_DEPRECATES */
                 break;
 
+        case 10: name = "icuserv";
+#if !UCONFIG_NO_SERVICE
+                if (exec) {
+                    logln("TestSuite ICUService---"); logln();
+                    ICUServiceTest test;
+                    callTest(test, par);
+                }
+#endif
+                break;
         default: name = ""; break;
     }
 }