Check in the pristine copy of ICU 51.2

icu51/source/common/servloc.h

Index: icu51/source/common/servloc.h
===================================================================
--- icu51/source/common/servloc.h	(revision 0)
+++ icu51/source/common/servloc.h	(revision 0)
@@ -0,0 +1,549 @@
+/**
+ *******************************************************************************
+ * Copyright (C) 2001-2011, 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/unistr.h"
+#include "unicode/locid.h"
+#include "unicode/strenum.h"
+
+#include "hash.h"
+#include "uvector.h"
+
+#include "serv.h"
+#include "locutil.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 ICUServiceKey {
+  private: 
+    int32_t _kind;
+    UnicodeString _primaryID;
+    UnicodeString _fallbackID;
+    UnicodeString _currentID;
+
+  public:
+    enum {
+        KIND_ANY = -1
+    };
+
+    /**
+     * Create a LocaleKey with canonical primary and fallback IDs.
+     */
+    static LocaleKey* createWithCanonicalFallback(const UnicodeString* primaryID, 
+                                                  const UnicodeString* canonicalFallbackID,
+                                                  UErrorCode& status);
+
+    /**
+     * Create a LocaleKey with canonical primary and fallback IDs.
+     */
+    static LocaleKey* createWithCanonicalFallback(const UnicodeString* primaryID, 
+                                                  const UnicodeString* canonicalFallbackID, 
+                                                  int32_t kind,
+                                                  UErrorCode& status);
+
+  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.
+     */
+    static UClassID U_EXPORT2 getStaticClassID();
+
+    virtual UClassID getDynamicClassID() const;
+
+    /**
+     * Destructor.
+     */
+    virtual ~LocaleKey();
+
+#ifdef SERVICE_DEBUG
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+#endif
+
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * A subclass of ICUServiceFactory 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 ICUServiceFactory {
+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
+    };
+
+    /**
+     * Destructor.
+     */
+    virtual ~LocaleKeyFactory();
+
+protected:
+    /**
+     * Constructor used by subclasses.
+     */
+    LocaleKeyFactory(int32_t coverage);
+
+    /**
+     * Constructor used by subclasses.
+     */
+    LocaleKeyFactory(int32_t coverage, const UnicodeString& name);
+
+    /**
+     * 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 ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+
+protected:
+    virtual UBool handlesKey(const ICUServiceKey& key, UErrorCode& status) const;
+
+public:
+    /**
+     * Override of superclass method.  This adjusts the result based
+     * on the coverage rule for this factory.
+     */
+    virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+
+    /**
+     * Return a localized name for the locale represented by id.
+     */
+    virtual UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
+
+protected:
+    /**
+     * Utility method used by create(ICUServiceKey, 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 true if this id is one the factory supports (visible or 
+     * otherwise).
+     */
+ //   virtual UBool isSupportedID(const UnicodeString& id, 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.
+     */
+    static UClassID U_EXPORT2 getStaticClassID();
+
+    virtual UClassID getDynamicClassID() const;
+
+#ifdef SERVICE_DEBUG
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+#endif
+
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * 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 UnicodeString& locale, 
+                           int32_t kind, 
+                           int32_t coverage);
+
+    SimpleLocaleKeyFactory(UObject* objToAdopt, 
+                           const Locale& locale, 
+                           int32_t kind, 
+                           int32_t coverage);
+
+    /**
+     * Destructor.
+     */
+    virtual ~SimpleLocaleKeyFactory();
+
+    /**
+     * Override of superclass method.  Returns the service object if kind/locale match.  Service is not used.
+     */
+    virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+
+    /**
+     * Override of superclass method.  This adjusts the result based
+     * on the coverage rule for this factory.
+     */
+    virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+
+ protected:
+    /**
+     * Return true if this id is equal to the locale name.
+     */
+    //virtual UBool isSupportedID(const UnicodeString& id, UErrorCode& status) const;
+
+
+public:
+    /**
+     * UObject boilerplate.
+     */
+    static UClassID U_EXPORT2 getStaticClassID();
+
+    virtual UClassID getDynamicClassID() const;
+
+#ifdef SERVICE_DEBUG
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+#endif
+
+};
+
+/*
+ ******************************************************************
+ */
+
+/**
+ * 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.  This should be a 'path' that can be passed to
+     * ures_openAvailableLocales, such as U_ICUDATA or U_ICUDATA_COLL.
+     * The empty string is equivalent to U_ICUDATA.
+     */
+    ICUResourceBundleFactory(const UnicodeString& bundleName);
+
+    /**
+     * Destructor
+     */
+    virtual ~ICUResourceBundleFactory();
+
+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.
+     */
+    static UClassID U_EXPORT2 getStaticClassID();
+    virtual UClassID getDynamicClassID() const;
+
+
+#ifdef SERVICE_DEBUG
+ public:
+    virtual UnicodeString& debug(UnicodeString& result) const;
+    virtual UnicodeString& debugClass(UnicodeString& result) const;
+#endif
+
+};
+
+/*
+ ******************************************************************
+ */
+
+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.
+   */
+  virtual ~ICULocaleService();
+
+#if 0
+  // redeclare because of overload resolution rules?
+  // no, causes ambiguities since both UnicodeString and Locale have constructors that take a const char*
+  // need some compiler flag to remove warnings 
+  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.
+   */
+  virtual URegistryKey registerInstance(UObject* objToAdopt, const Locale& locale, UErrorCode& status);
+
+  /**
+   * Convenience function for callers using locales.  This calls
+   * registerObject(Object, Locale, int kind, int coverage)
+   * passing VISIBLE for the coverage.
+   */
+  virtual URegistryKey registerInstance(UObject* objToAdopt, const Locale& locale, int32_t kind, UErrorCode& status);
+
+  /**
+   * Convenience function for callers using locales.  This  instantiates
+   * a SimpleLocaleKeyFactory, and registers the factory.
+   */
+  virtual URegistryKey registerInstance(UObject* objToAdopt, const Locale& locale, int32_t kind, int32_t coverage, UErrorCode& status);
+
+
+  /**
+   * (Stop compiler from complaining about hidden overrides.)
+   * Since both UnicodeString and Locale have constructors that take const char*, adding a public
+   * method that takes UnicodeString causes ambiguity at call sites that use const char*.
+   * We really need a flag that is understood by all compilers that will suppress the warning about
+   * hidden overrides.
+   */
+  virtual URegistryKey registerInstance(UObject* objToAdopt, const UnicodeString& locale, UBool visible, UErrorCode& status);
+
+  /**
+   * Convenience method for callers using locales.  This returns the standard
+   * service ID enumeration.
+   */
+  virtual StringEnumeration* getAvailableLocales(void) const;
+
+ protected:
+
+  /**
+   * 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 ICUServiceKey* createKey(const UnicodeString* id, UErrorCode& status) const;
+
+  /**
+   * Additional createKey that takes a kind.
+   */
+  virtual ICUServiceKey* createKey(const UnicodeString* id, int32_t kind, UErrorCode& status) const;
+
+  friend class ServiceEnumeration;
+};
+
+U_NAMESPACE_END
+
+    /* UCONFIG_NO_SERVICE */
+#endif
+
+    /* ICULSERV_H */
+#endif
+
Property changes on: icu51/source/common/servloc.h
___________________________________________________________________
Added: svn:eol-style
   + LF