PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - usr/include/unicode - locid.h (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 2 2 100.0 %
Date: 2014-11-22 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             : ******************************************************************************
       3             : *
       4             : *   Copyright (C) 1996-2006, International Business Machines
       5             : *   Corporation and others.  All Rights Reserved.
       6             : *
       7             : ******************************************************************************
       8             : *
       9             : * File locid.h
      10             : *
      11             : * Created by: Helena Shih
      12             : *
      13             : * Modification History:
      14             : *
      15             : *   Date        Name        Description
      16             : *   02/11/97    aliu        Changed gLocPath to fgLocPath and added methods to
      17             : *                           get and set it.
      18             : *   04/02/97    aliu        Made operator!= inline; fixed return value of getName().
      19             : *   04/15/97    aliu        Cleanup for AIX/Win32.
      20             : *   04/24/97    aliu        Numerous changes per code review.
      21             : *   08/18/98    stephen     Added tokenizeString(),changed getDisplayName()
      22             : *   09/08/98    stephen     Moved definition of kEmptyString for Mac Port
      23             : *   11/09/99    weiv        Added const char * getName() const;
      24             : *   04/12/00    srl         removing unicodestring api's and cached hash code
      25             : *   08/10/01    grhoten     Change the static Locales to accessor functions
      26             : ******************************************************************************
      27             : */
      28             : 
      29             : #ifndef LOCID_H
      30             : #define LOCID_H
      31             : 
      32             : #include "unicode/utypes.h"
      33             : #include "unicode/uobject.h"
      34             : #include "unicode/unistr.h"
      35             : #include "unicode/putil.h"
      36             : #include "unicode/uloc.h"
      37             : #include "unicode/strenum.h"
      38             : 
      39             : /**
      40             :  * \file
      41             :  * \brief C++ API: Locale ID object.
      42             :  */
      43             : 
      44             : /**
      45             :  * A <code>Locale</code> object represents a specific geographical, political,
      46             :  * or cultural region. An operation that requires a <code>Locale</code> to perform
      47             :  * its task is called <em>locale-sensitive</em> and uses the <code>Locale</code>
      48             :  * to tailor information for the user. For example, displaying a number
      49             :  * is a locale-sensitive operation--the number should be formatted
      50             :  * according to the customs/conventions of the user's native country,
      51             :  * region, or culture.
      52             :  *
      53             :  * The Locale class is not suitable for subclassing.
      54             :  *
      55             :  * <P>
      56             :  * You can create a <code>Locale</code> object using the constructor in
      57             :  * this class:
      58             :  * \htmlonly<blockquote>\endhtmlonly
      59             :  * <pre>
      60             :  *       Locale( const   char*  language,
      61             :  *               const   char*  country,
      62             :  *               const   char*  variant);
      63             :  * </pre>
      64             :  * \htmlonly</blockquote>\endhtmlonly
      65             :  * The first argument to the constructors is a valid <STRONG>ISO
      66             :  * Language Code.</STRONG> These codes are the lower-case two-letter
      67             :  * codes as defined by ISO-639.
      68             :  * You can find a full list of these codes at:
      69             :  * <BR><a href ="http://www.loc.gov/standards/iso639-2/">
      70             :  * http://www.loc.gov/standards/iso639-2/</a>
      71             :  *
      72             :  * <P>
      73             :  * The second argument to the constructors is a valid <STRONG>ISO Country
      74             :  * Code.</STRONG> These codes are the upper-case two-letter codes
      75             :  * as defined by ISO-3166.
      76             :  * You can find a full list of these codes at a number of sites, such as:
      77             :  * <BR><a href="http://www.iso.org/iso/en/prods-services/iso3166ma/index.html">
      78             :  * http://www.iso.org/iso/en/prods-services/iso3166ma/index.html</a>
      79             :  *
      80             :  * <P>
      81             :  * The third constructor requires a third argument--the <STRONG>Variant.</STRONG>
      82             :  * The Variant codes are vendor and browser-specific.
      83             :  * For example, use REVISED for a langauge's revised script orthography, and POSIX for POSIX.
      84             :  * Where there are two variants, separate them with an underscore, and
      85             :  * put the most important one first. For
      86             :  * example, a Traditional Spanish collation might be referenced, with
      87             :  * "ES", "ES", "Traditional_POSIX".
      88             :  *
      89             :  * <P>
      90             :  * Because a <code>Locale</code> object is just an identifier for a region,
      91             :  * no validity check is performed when you construct a <code>Locale</code>.
      92             :  * If you want to see whether particular resources are available for the
      93             :  * <code>Locale</code> you construct, you must query those resources. For
      94             :  * example, ask the <code>NumberFormat</code> for the locales it supports
      95             :  * using its <code>getAvailableLocales</code> method.
      96             :  * <BR><STRONG>Note:</STRONG> When you ask for a resource for a particular
      97             :  * locale, you get back the best available match, not necessarily
      98             :  * precisely what you asked for. For more information, look at
      99             :  * <code>ResourceBundle</code>.
     100             :  *
     101             :  * <P>
     102             :  * The <code>Locale</code> class provides a number of convenient constants
     103             :  * that you can use to create <code>Locale</code> objects for commonly used
     104             :  * locales. For example, the following refers to a <code>Locale</code> object
     105             :  * for the United States:
     106             :  * \htmlonly<blockquote>\endhtmlonly
     107             :  * <pre>
     108             :  *       Locale::getUS()
     109             :  * </pre>
     110             :  * \htmlonly</blockquote>\endhtmlonly
     111             :  *
     112             :  * <P>
     113             :  * Once you've created a <code>Locale</code> you can query it for information about
     114             :  * itself. Use <code>getCountry</code> to get the ISO Country Code and
     115             :  * <code>getLanguage</code> to get the ISO Language Code. You can
     116             :  * use <code>getDisplayCountry</code> to get the
     117             :  * name of the country suitable for displaying to the user. Similarly,
     118             :  * you can use <code>getDisplayLanguage</code> to get the name of
     119             :  * the language suitable for displaying to the user. Interestingly,
     120             :  * the <code>getDisplayXXX</code> methods are themselves locale-sensitive
     121             :  * and have two versions: one that uses the default locale and one
     122             :  * that takes a locale as an argument and displays the name or country in
     123             :  * a language appropriate to that locale.
     124             :  *
     125             :  * <P>
     126             :  * ICU provides a number of classes that perform locale-sensitive
     127             :  * operations. For example, the <code>NumberFormat</code> class formats
     128             :  * numbers, currency, or percentages in a locale-sensitive manner. Classes
     129             :  * such as <code>NumberFormat</code> have a number of convenience methods
     130             :  * for creating a default object of that type. For example, the
     131             :  * <code>NumberFormat</code> class provides these three convenience methods
     132             :  * for creating a default <code>NumberFormat</code> object:
     133             :  * \htmlonly<blockquote>\endhtmlonly
     134             :  * <pre>
     135             :  *     UErrorCode success = U_ZERO_ERROR;
     136             :  *     Locale myLocale;
     137             :  *     NumberFormat *nf;
     138             :  *
     139             :  *     nf = NumberFormat::createInstance( success );          delete nf;
     140             :  *     nf = NumberFormat::createCurrencyInstance( success );  delete nf;
     141             :  *     nf = NumberFormat::createPercentInstance( success );   delete nf;
     142             :  * </pre>
     143             :  * \htmlonly</blockquote>\endhtmlonly
     144             :  * Each of these methods has two variants; one with an explicit locale
     145             :  * and one without; the latter using the default locale.
     146             :  * \htmlonly<blockquote>\endhtmlonly
     147             :  * <pre>
     148             :  *     nf = NumberFormat::createInstance( myLocale, success );          delete nf;
     149             :  *     nf = NumberFormat::createCurrencyInstance( myLocale, success );  delete nf;
     150             :  *     nf = NumberFormat::createPercentInstance( myLocale, success );   delete nf;
     151             :  * </pre>
     152             :  * \htmlonly</blockquote>\endhtmlonly
     153             :  * A <code>Locale</code> is the mechanism for identifying the kind of object
     154             :  * (<code>NumberFormat</code>) that you would like to get. The locale is
     155             :  * <STRONG>just</STRONG> a mechanism for identifying objects,
     156             :  * <STRONG>not</STRONG> a container for the objects themselves.
     157             :  *
     158             :  * <P>
     159             :  * Each class that performs locale-sensitive operations allows you
     160             :  * to get all the available objects of that type. You can sift
     161             :  * through these objects by language, country, or variant,
     162             :  * and use the display names to present a menu to the user.
     163             :  * For example, you can create a menu of all the collation objects
     164             :  * suitable for a given language. Such classes implement these
     165             :  * three class methods:
     166             :  * \htmlonly<blockquote>\endhtmlonly
     167             :  * <pre>
     168             :  *       static Locale* getAvailableLocales(int32_t& numLocales)
     169             :  *       static UnicodeString& getDisplayName(const Locale&  objectLocale,
     170             :  *                                            const Locale&  displayLocale,
     171             :  *                                            UnicodeString& displayName)
     172             :  *       static UnicodeString& getDisplayName(const Locale&  objectLocale,
     173             :  *                                            UnicodeString& displayName)
     174             :  * </pre>
     175             :  * \htmlonly</blockquote>\endhtmlonly
     176             :  *
     177             :  * @stable ICU 2.0
     178             :  * @see ResourceBundle
     179             :  */
     180             : U_NAMESPACE_BEGIN
     181             : class U_COMMON_API Locale : public UObject {
     182             : public:
     183             :     /** Useful constant for this language. @stable ICU 2.0 */
     184             :     static const Locale &U_EXPORT2 getEnglish(void);
     185             :     /** Useful constant for this language. @stable ICU 2.0 */
     186             :     static const Locale &U_EXPORT2 getFrench(void);
     187             :     /** Useful constant for this language. @stable ICU 2.0 */
     188             :     static const Locale &U_EXPORT2 getGerman(void);
     189             :     /** Useful constant for this language. @stable ICU 2.0 */
     190             :     static const Locale &U_EXPORT2 getItalian(void);
     191             :     /** Useful constant for this language. @stable ICU 2.0 */
     192             :     static const Locale &U_EXPORT2 getJapanese(void);
     193             :     /** Useful constant for this language. @stable ICU 2.0 */
     194             :     static const Locale &U_EXPORT2 getKorean(void);
     195             :     /** Useful constant for this language. @stable ICU 2.0 */
     196             :     static const Locale &U_EXPORT2 getChinese(void);
     197             :     /** Useful constant for this language. @stable ICU 2.0 */
     198             :     static const Locale &U_EXPORT2 getSimplifiedChinese(void);
     199             :     /** Useful constant for this language. @stable ICU 2.0 */
     200             :     static const Locale &U_EXPORT2 getTraditionalChinese(void);
     201             : 
     202             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     203             :     static const Locale &U_EXPORT2 getFrance(void);
     204             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     205             :     static const Locale &U_EXPORT2 getGermany(void);
     206             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     207             :     static const Locale &U_EXPORT2 getItaly(void);
     208             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     209             :     static const Locale &U_EXPORT2 getJapan(void);
     210             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     211             :     static const Locale &U_EXPORT2 getKorea(void);
     212             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     213             :     static const Locale &U_EXPORT2 getChina(void);
     214             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     215             :     static const Locale &U_EXPORT2 getPRC(void);
     216             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     217             :     static const Locale &U_EXPORT2 getTaiwan(void);
     218             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     219             :     static const Locale &U_EXPORT2 getUK(void);
     220             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     221             :     static const Locale &U_EXPORT2 getUS(void);
     222             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     223             :     static const Locale &U_EXPORT2 getCanada(void);
     224             :     /** Useful constant for this country/region. @stable ICU 2.0 */
     225             :     static const Locale &U_EXPORT2 getCanadaFrench(void);
     226             : 
     227             : 
     228             :     /**
     229             :      * Construct a default locale object, a Locale for the default locale ID.
     230             :      *
     231             :      * @see getDefault
     232             :      * @see uloc_getDefault
     233             :      * @stable ICU 2.0
     234             :      */
     235             :     Locale();
     236             : 
     237             :     /**
     238             :      * Construct a locale from language, country, variant.
     239             :      * If an error occurs, then the constructed object will be "bogus"
     240             :      * (isBogus() will return TRUE).
     241             :      *
     242             :      * @param language Lowercase two-letter or three-letter ISO-639 code.
     243             :      *  This parameter can instead be an ICU style C locale (e.g. "en_US"),
     244             :      *  but the other parameters must not be used.
     245             :      *  This parameter can be NULL; if so,
     246             :      *  the locale is initialized to match the current default locale.
     247             :      *  (This is the same as using the default constructor.)
     248             :      *  Please note: The Java Locale class does NOT accept the form
     249             :      *  'new Locale("en_US")' but only 'new Locale("en","US")'
     250             :      *
     251             :      * @param country  Uppercase two-letter ISO-3166 code. (optional)
     252             :      * @param variant  Uppercase vendor and browser specific code. See class
     253             :      *                 description. (optional)
     254             :      * @param keywordsAndValues A string consisting of keyword/values pairs, such as
     255             :      *                 "collation=phonebook;currency=euro"
     256             :      *
     257             :      * @see getDefault
     258             :      * @see uloc_getDefault
     259             :      * @stable ICU 2.0
     260             :      */
     261             :     Locale( const   char * language,
     262             :             const   char * country  = 0,
     263             :             const   char * variant  = 0,
     264             :             const   char * keywordsAndValues = 0);
     265             : 
     266             :     /**
     267             :      * Initializes a Locale object from another Locale object.
     268             :      *
     269             :      * @param other The Locale object being copied in.
     270             :      * @stable ICU 2.0
     271             :      */
     272             :     Locale(const    Locale& other);
     273             : 
     274             : 
     275             :     /**
     276             :      * Destructor
     277             :      * @stable ICU 2.0
     278             :      */
     279             :     virtual ~Locale() ;
     280             : 
     281             :     /**
     282             :      * Replaces the entire contents of *this with the specified value.
     283             :      *
     284             :      * @param other The Locale object being copied in.
     285             :      * @return      *this
     286             :      * @stable ICU 2.0
     287             :      */
     288             :     Locale& operator=(const Locale& other);
     289             : 
     290             :     /**
     291             :      * Checks if two locale keys are the same.
     292             :      *
     293             :      * @param other The locale key object to be compared with this.
     294             :      * @return      True if the two locale keys are the same, false otherwise.
     295             :      * @stable ICU 2.0
     296             :      */
     297             :     UBool   operator==(const    Locale&     other) const;
     298             : 
     299             :     /**
     300             :      * Checks if two locale keys are not the same.
     301             :      *
     302             :      * @param other The locale key object to be compared with this.
     303             :      * @return      True if the two locale keys are not the same, false
     304             :      *              otherwise.
     305             :      * @stable ICU 2.0
     306             :      */
     307             :     UBool   operator!=(const    Locale&     other) const;
     308             : 
     309             :     /**
     310             :      * Clone this object.
     311             :      * Clones can be used concurrently in multiple threads.
     312             :      * If an error occurs, then NULL is returned.
     313             :      * The caller must delete the clone.
     314             :      *
     315             :      * @return a clone of this object
     316             :      *
     317             :      * @see getDynamicClassID
     318             :      * @stable ICU 2.8
     319             :      */
     320             :     Locale *clone() const;
     321             : 
     322             :     /**
     323             :      * Common methods of getting the current default Locale. Used for the
     324             :      * presentation: menus, dialogs, etc. Generally set once when your applet or
     325             :      * application is initialized, then never reset. (If you do reset the
     326             :      * default locale, you probably want to reload your GUI, so that the change
     327             :      * is reflected in your interface.)
     328             :      *
     329             :      * More advanced programs will allow users to use different locales for
     330             :      * different fields, e.g. in a spreadsheet.
     331             :      *
     332             :      * Note that the initial setting will match the host system.
     333             :      * @return a reference to the Locale object for the default locale ID
     334             :      * @system
     335             :      * @stable ICU 2.0
     336             :      */
     337             :     static const Locale& U_EXPORT2 getDefault(void);
     338             : 
     339             :     /**
     340             :      * Sets the default. Normally set once at the beginning of a process,
     341             :      * then never reset.
     342             :      * setDefault() only changes ICU's default locale ID, <strong>not</strong>
     343             :      * the default locale ID of the runtime environment.
     344             :      *
     345             :      * @param newLocale Locale to set to.  If NULL, set to the value obtained
     346             :      *                  from the runtime environement.
     347             :      * @param success The error code.
     348             :      * @system
     349             :      * @stable ICU 2.0
     350             :      */
     351             :     static void U_EXPORT2 setDefault(const Locale& newLocale,
     352             :                                      UErrorCode&   success);
     353             : 
     354             :     /**
     355             :      * Creates a locale which has had minimal canonicalization
     356             :      * as per uloc_getName().
     357             :      * @param name The name to create from.  If name is null,
     358             :      *  the default Locale is used.
     359             :      * @return new locale object
     360             :      * @stable ICU 2.0
     361             :      * @see uloc_getName
     362             :      */
     363             :     static Locale U_EXPORT2 createFromName(const char *name);
     364             : 
     365             :     /**
     366             :      * Creates a locale from the given string after canonicalizing
     367             :      * the string by calling uloc_canonicalize().
     368             :      * @param name the locale ID to create from.  Must not be NULL.
     369             :      * @return a new locale object corresponding to the given name
     370             :      * @stable ICU 3.0
     371             :      * @see uloc_canonicalize
     372             :      */
     373             :     static Locale U_EXPORT2 createCanonical(const char* name);
     374             : 
     375             :     /**
     376             :      * Returns the locale's ISO-639 language code.
     377             :      * @return      An alias to the code
     378             :      * @stable ICU 2.0
     379             :      */
     380             :     inline const char *  getLanguage( ) const;
     381             : 
     382             :     /**
     383             :      * Returns the locale's ISO-15924 abbreviation script code.
     384             :      * @return      An alias to the code
     385             :      * @see uscript_getShortName
     386             :      * @see uscript_getCode
     387             :      * @stable ICU 2.8
     388             :      */
     389             :     inline const char *  getScript( ) const;
     390             : 
     391             :     /**
     392             :      * Returns the locale's ISO-3166 country code.
     393             :      * @return      An alias to the code
     394             :      * @stable ICU 2.0
     395             :      */
     396             :     inline const char *  getCountry( ) const;
     397             : 
     398             :     /**
     399             :      * Returns the locale's variant code.
     400             :      * @return      An alias to the code
     401             :      * @stable ICU 2.0
     402             :      */
     403             :     inline const char *  getVariant( ) const;
     404             : 
     405             :     /**
     406             :      * Returns the programmatic name of the entire locale, with the language,
     407             :      * country and variant separated by underbars. If a field is missing, up
     408             :      * to two leading underbars will occur. Example: "en", "de_DE", "en_US_WIN",
     409             :      * "de__POSIX", "fr__MAC", "__MAC", "_MT", "_FR_EURO"
     410             :      * @return      A pointer to "name".
     411             :      * @stable ICU 2.0
     412             :      */
     413             :     inline const char * getName() const;
     414             : 
     415             :     /**
     416             :      * Returns the programmatic name of the entire locale as getName would return,
     417             :      * but without keywords.
     418             :      * @return      A pointer to "name".
     419             :      * @see getName
     420             :      * @stable ICU 2.8
     421             :      */
     422             :     const char * getBaseName() const;
     423             : 
     424             : 
     425             :     /**
     426             :      * Gets the list of keywords for the specified locale.
     427             :      *
     428             :      * @return pointer to StringEnumeration class. Client must dispose of it by calling delete.
     429             :      * @param status Returns any error information while performing this operation.
     430             :      * @stable ICU 2.8
     431             :      */
     432             :     StringEnumeration * createKeywords(UErrorCode &status) const;
     433             : 
     434             :     /**
     435             :      * Get the value for a keyword.
     436             :      *
     437             :      * @param keywordName name of the keyword for which we want the value. Case insensitive.
     438             :      * @param status Returns any error information while performing this operation.
     439             :      * @param buffer The buffer to receive the keyword value.
     440             :      * @param bufferCapacity The capacity of receiving buffer
     441             :      * @return the length of keyword value
     442             :      *
     443             :      * @stable ICU 2.8
     444             :      */
     445             :     int32_t getKeywordValue(const char* keywordName, char *buffer, int32_t bufferCapacity, UErrorCode &status) const;
     446             : 
     447             :     /**
     448             :      * returns the locale's three-letter language code, as specified
     449             :      * in ISO draft standard ISO-639-2.
     450             :      * @return      An alias to the code, or NULL
     451             :      * @stable ICU 2.0
     452             :      */
     453             :     const char * getISO3Language() const;
     454             : 
     455             :     /**
     456             :      * Fills in "name" with the locale's three-letter ISO-3166 country code.
     457             :      * @return      An alias to the code, or NULL
     458             :      * @stable ICU 2.0
     459             :      */
     460             :     const char * getISO3Country() const;
     461             : 
     462             :     /**
     463             :      * Returns the Windows LCID value corresponding to this locale.
     464             :      * This value is stored in the resource data for the locale as a one-to-four-digit
     465             :      * hexadecimal number.  If the resource is missing, in the wrong format, or
     466             :      * there is no Windows LCID value that corresponds to this locale, returns 0.
     467             :      * @stable ICU 2.0
     468             :      */
     469             :     uint32_t        getLCID(void) const;
     470             : 
     471             :     /**
     472             :      * Fills in "dispLang" with the name of this locale's language in a format suitable for
     473             :      * user display in the default locale.  For example, if the locale's language code is
     474             :      * "fr" and the default locale's language code is "en", this function would set
     475             :      * dispLang to "French".
     476             :      * @param dispLang  Receives the language's display name.
     477             :      * @return          A reference to "dispLang".
     478             :      * @stable ICU 2.0
     479             :      */
     480             :     UnicodeString&  getDisplayLanguage(UnicodeString&   dispLang) const;
     481             : 
     482             :     /**
     483             :      * Fills in "dispLang" with the name of this locale's language in a format suitable for
     484             :      * user display in the locale specified by "displayLocale".  For example, if the locale's
     485             :      * language code is "en" and displayLocale's language code is "fr", this function would set
     486             :      * dispLang to "Anglais".
     487             :      * @param displayLocale  Specifies the locale to be used to display the name.  In other words,
     488             :      *                  if the locale's language code is "en", passing Locale::getFrench() for
     489             :      *                  displayLocale would result in "Anglais", while passing Locale::getGerman()
     490             :      *                  for displayLocale would result in "Englisch".
     491             :      * @param dispLang  Receives the language's display name.
     492             :      * @return          A reference to "dispLang".
     493             :      * @stable ICU 2.0
     494             :      */
     495             :     UnicodeString&  getDisplayLanguage( const   Locale&         displayLocale,
     496             :                                                 UnicodeString&  dispLang) const;
     497             : 
     498             :     /**
     499             :      * Fills in "dispScript" with the name of this locale's script in a format suitable
     500             :      * for user display in the default locale.  For example, if the locale's script code
     501             :      * is "LATN" and the default locale's language code is "en", this function would set
     502             :      * dispScript to "Latin".
     503             :      * @param dispScript    Receives the scripts's display name.
     504             :      * @return              A reference to "dispScript".
     505             :      * @stable ICU 2.8
     506             :      */
     507             :     UnicodeString&  getDisplayScript(          UnicodeString& dispScript) const;
     508             : 
     509             :     /**
     510             :      * Fills in "dispScript" with the name of this locale's country in a format suitable
     511             :      * for user display in the locale specified by "displayLocale".  For example, if the locale's
     512             :      * script code is "LATN" and displayLocale's language code is "en", this function would set
     513             :      * dispScript to "Latin".
     514             :      * @param displayLocale      Specifies the locale to be used to display the name.  In other
     515             :      *                      words, if the locale's script code is "LATN", passing
     516             :      *                      Locale::getFrench() for displayLocale would result in "", while
     517             :      *                      passing Locale::getGerman() for displayLocale would result in
     518             :      *                      "".
     519             :      * @param dispScript    Receives the scripts's display name.
     520             :      * @return              A reference to "dispScript".
     521             :      * @stable ICU 2.8
     522             :      */
     523             :     UnicodeString&  getDisplayScript(  const   Locale&         displayLocale,
     524             :                                                UnicodeString&  dispScript) const;
     525             : 
     526             :     /**
     527             :      * Fills in "dispCountry" with the name of this locale's country in a format suitable
     528             :      * for user display in the default locale.  For example, if the locale's country code
     529             :      * is "FR" and the default locale's language code is "en", this function would set
     530             :      * dispCountry to "France".
     531             :      * @param dispCountry   Receives the country's display name.
     532             :      * @return              A reference to "dispCountry".
     533             :      * @stable ICU 2.0
     534             :      */
     535             :     UnicodeString&  getDisplayCountry(          UnicodeString& dispCountry) const;
     536             : 
     537             :     /**
     538             :      * Fills in "dispCountry" with the name of this locale's country in a format suitable
     539             :      * for user display in the locale specified by "displayLocale".  For example, if the locale's
     540             :      * country code is "US" and displayLocale's language code is "fr", this function would set
     541             :      * dispCountry to "&Eacute;tats-Unis".
     542             :      * @param displayLocale      Specifies the locale to be used to display the name.  In other
     543             :      *                      words, if the locale's country code is "US", passing
     544             :      *                      Locale::getFrench() for displayLocale would result in "&Eacute;tats-Unis", while
     545             :      *                      passing Locale::getGerman() for displayLocale would result in
     546             :      *                      "Vereinigte Staaten".
     547             :      * @param dispCountry   Receives the country's display name.
     548             :      * @return              A reference to "dispCountry".
     549             :      * @stable ICU 2.0
     550             :      */
     551             :     UnicodeString&  getDisplayCountry(  const   Locale&         displayLocale,
     552             :                                                 UnicodeString&  dispCountry) const;
     553             : 
     554             :     /**
     555             :      * Fills in "dispVar" with the name of this locale's variant code in a format suitable
     556             :      * for user display in the default locale.
     557             :      * @param dispVar   Receives the variant's name.
     558             :      * @return          A reference to "dispVar".
     559             :      * @stable ICU 2.0
     560             :      */
     561             :     UnicodeString&  getDisplayVariant(      UnicodeString& dispVar) const;
     562             : 
     563             :     /**
     564             :      * Fills in "dispVar" with the name of this locale's variant code in a format
     565             :      * suitable for user display in the locale specified by "displayLocale".
     566             :      * @param displayLocale  Specifies the locale to be used to display the name.
     567             :      * @param dispVar   Receives the variant's display name.
     568             :      * @return          A reference to "dispVar".
     569             :      * @stable ICU 2.0
     570             :      */
     571             :     UnicodeString&  getDisplayVariant(  const   Locale&         displayLocale,
     572             :                                                 UnicodeString&  dispVar) const;
     573             : 
     574             :     /**
     575             :      * Fills in "name" with the name of this locale in a format suitable for user display
     576             :      * in the default locale.  This function uses getDisplayLanguage(), getDisplayCountry(),
     577             :      * and getDisplayVariant() to do its work, and outputs the display name in the format
     578             :      * "language (country[,variant])".  For example, if the default locale is en_US, then
     579             :      * fr_FR's display name would be "French (France)", and es_MX_Traditional's display name
     580             :      * would be "Spanish (Mexico,Traditional)".
     581             :      * @param name  Receives the locale's display name.
     582             :      * @return      A reference to "name".
     583             :      * @stable ICU 2.0
     584             :      */
     585             :     UnicodeString&  getDisplayName(         UnicodeString&  name) const;
     586             : 
     587             :     /**
     588             :      * Fills in "name" with the name of this locale in a format suitable for user display
     589             :      * in the locale specfied by "displayLocale".  This function uses getDisplayLanguage(),
     590             :      * getDisplayCountry(), and getDisplayVariant() to do its work, and outputs the display
     591             :      * name in the format "language (country[,variant])".  For example, if displayLocale is
     592             :      * fr_FR, then en_US's display name would be "Anglais (&Eacute;tats-Unis)", and no_NO_NY's
     593             :      * display name would be "norv&eacute;gien (Norv&egrave;ge,NY)".
     594             :      * @param displayLocale  Specifies the locale to be used to display the name.
     595             :      * @param name      Receives the locale's display name.
     596             :      * @return          A reference to "name".
     597             :      * @stable ICU 2.0
     598             :      */
     599             :     UnicodeString&  getDisplayName( const   Locale&         displayLocale,
     600             :                                             UnicodeString&  name) const;
     601             : 
     602             :     /**
     603             :      * Generates a hash code for the locale.
     604             :      * @stable ICU 2.0
     605             :      */
     606             :     int32_t         hashCode(void) const;
     607             : 
     608             :     /**
     609             :      * Sets the locale to bogus
     610             :      * A bogus locale represents a non-existing locale associated
     611             :      * with services that can be instantiated from non-locale data
     612             :      * in addition to locale (for example, collation can be
     613             :      * instantiated from a locale and from a rule set).
     614             :      * @stable ICU 2.1
     615             :      */
     616             :     void setToBogus();
     617             : 
     618             :     /**
     619             :      * Gets the bogus state. Locale object can be bogus if it doesn't exist
     620             :      * @return FALSE if it is a real locale, TRUE if it is a bogus locale
     621             :      * @stable ICU 2.1
     622             :      */
     623             :     UBool isBogus(void) const;
     624             : 
     625             :     /**
     626             :      * Returns a list of all installed locales.
     627             :      * @param count Receives the number of locales in the list.
     628             :      * @return      A pointer to an array of Locale objects.  This array is the list
     629             :      *              of all locales with installed resource files.  The called does NOT
     630             :      *              get ownership of this list, and must NOT delete it.
     631             :      * @stable ICU 2.0
     632             :      */
     633             :     static const Locale* U_EXPORT2 getAvailableLocales(int32_t& count);
     634             : 
     635             :     /**
     636             :      * Gets a list of all available 2-letter country codes defined in ISO 639.  This is a
     637             :      * pointer to an array of pointers to arrays of char.  All of these pointers are
     638             :      * owned by ICU-- do not delete them, and do not write through them.  The array is
     639             :      * terminated with a null pointer.
     640             :      * @return a list of all available country codes
     641             :      * @stable ICU 2.0
     642             :      */
     643             :     static const char* const* U_EXPORT2 getISOCountries();
     644             : 
     645             :     /**
     646             :      * Gets a list of all available language codes defined in ISO 639.  This is a pointer
     647             :      * to an array of pointers to arrays of char.  All of these pointers are owned
     648             :      * by ICU-- do not delete them, and do not write through them.  The array is
     649             :      * terminated with a null pointer.
     650             :      * @return a list of all available language codes
     651             :      * @stable ICU 2.0
     652             :      */
     653             :     static const char* const* U_EXPORT2 getISOLanguages();
     654             : 
     655             :     /**
     656             :      * ICU "poor man's RTTI", returns a UClassID for this class.
     657             :      *
     658             :      * @stable ICU 2.2
     659             :      */
     660             :     static UClassID U_EXPORT2 getStaticClassID();
     661             : 
     662             :     /**
     663             :      * ICU "poor man's RTTI", returns a UClassID for the actual class.
     664             :      *
     665             :      * @stable ICU 2.2
     666             :      */
     667             :     virtual UClassID getDynamicClassID() const;
     668             : 
     669             : protected: /* only protected for testing purposes. DO NOT USE. */
     670             :     /**
     671             :      * Set this from a single POSIX style locale string.
     672             :      * @internal
     673             :      */
     674             :     void setFromPOSIXID(const char *posixID);
     675             : 
     676             : private:
     677             :     /**
     678             :      * Initialize the locale object with a new name.
     679             :      * Was deprecated - used in implementation - moved internal
     680             :      *
     681             :      * @param cLocaleID The new locale name.
     682             :      */
     683             :     Locale& init(const char* cLocaleID, UBool canonicalize);
     684             : 
     685             :     /*
     686             :      * Internal constructor to allow construction of a locale object with
     687             :      *   NO side effects.   (Default constructor tries to get
     688             :      *   the default locale.)
     689             :      */
     690             :     enum ELocaleType {
     691             :         eBOGUS
     692             :     };
     693             :     Locale(ELocaleType);
     694             : 
     695             :     /**
     696             :      * Initialize the locale cache for commonly used locales
     697             :      */
     698             :     static Locale *getLocaleCache(void);
     699             : 
     700             :     char language[ULOC_LANG_CAPACITY];
     701             :     char script[ULOC_SCRIPT_CAPACITY];
     702             :     char country[ULOC_COUNTRY_CAPACITY];
     703             :     int32_t variantBegin;
     704             :     char* fullName;
     705             :     char fullNameBuffer[ULOC_FULLNAME_CAPACITY];
     706             :     // name without keywords
     707             :     char* baseName;
     708             :     char baseNameBuffer[ULOC_FULLNAME_CAPACITY];
     709             : 
     710             :     UBool fIsBogus;
     711             : 
     712             :     static const Locale &getLocale(int locid);
     713             : 
     714             :     /**
     715             :      * A friend to allow the default locale to be set by either the C or C++ API.
     716             :      * @internal
     717             :      */
     718             :     friend void locale_set_default_internal(const char *);
     719             : };
     720             : 
     721             : inline UBool
     722             : Locale::operator!=(const    Locale&     other) const
     723             : {
     724             :     return !operator==(other);
     725             : }
     726             : 
     727             : inline const char *
     728             : Locale::getCountry() const
     729             : {
     730             :     return country;
     731             : }
     732             : 
     733             : inline const char *
     734             : Locale::getLanguage() const
     735             : {
     736             :     return language;
     737             : }
     738             : 
     739             : inline const char *
     740             : Locale::getScript() const
     741             : {
     742             :     return script;
     743             : }
     744             : 
     745             : inline const char *
     746             : Locale::getVariant() const
     747             : {
     748             :     return &fullName[variantBegin];
     749             : }
     750             : 
     751             : inline const char *
     752         588 : Locale::getName() const
     753             : {
     754         588 :     return fullName;
     755             : }
     756             : 
     757             : inline UBool
     758             : Locale::isBogus(void) const {
     759             :     return fIsBogus;
     760             : }
     761             : 
     762             : U_NAMESPACE_END
     763             : 
     764             : #endif
     765             : 

Generated by: LCOV version 1.10

Generated at Sat, 22 Nov 2014 23:01:08 +0000 (33 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.