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 "É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 "É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 (États-Unis)", and no_NO_NY's
593 : * display name would be "norvégien (Norvè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 :
|
