ICU 67.1 67.1

locid.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ******************************************************************************
5 *
6 * Copyright (C) 1996-2015, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 ******************************************************************************
10 *
11 * File locid.h
12 *
13 * Created by: Helena Shih
14 *
15 * Modification History:
16 *
17 * Date Name Description
18 * 02/11/97 aliu Changed gLocPath to fgLocPath and added methods to
19 * get and set it.
20 * 04/02/97 aliu Made operator!= inline; fixed return value of getName().
21 * 04/15/97 aliu Cleanup for AIX/Win32.
22 * 04/24/97 aliu Numerous changes per code review.
23 * 08/18/98 stephen Added tokenizeString(),changed getDisplayName()
24 * 09/08/98 stephen Moved definition of kEmptyString for Mac Port
25 * 11/09/99 weiv Added const char * getName() const;
26 * 04/12/00 srl removing unicodestring api's and cached hash code
27 * 08/10/01 grhoten Change the static Locales to accessor functions
28 ******************************************************************************
29 */
30
31 #ifndef LOCID_H
32 #define LOCID_H
33
34 #include "unicode/utypes.h"
35
36 #if U_SHOW_CPLUSPLUS_API
37
38 #include "unicode/bytestream.h"
39 #include "unicode/localpointer.h"
40 #include "unicode/strenum.h"
41 #include "unicode/stringpiece.h"
42 #include "unicode/uobject.h"
43 #include "unicode/putil.h"
44 #include "unicode/uloc.h"
45
51 U_NAMESPACE_BEGIN
52
53 // Forward Declarations
54 void U_CALLCONV locale_available_init();
56 class StringEnumeration;
57 class UnicodeString;
58
195 class U_COMMON_API Locale : public UObject {
196 public:
198 static const Locale &U_EXPORT2 getRoot(void);
200 static const Locale &U_EXPORT2 getEnglish(void);
202 static const Locale &U_EXPORT2 getFrench(void);
204 static const Locale &U_EXPORT2 getGerman(void);
206 static const Locale &U_EXPORT2 getItalian(void);
208 static const Locale &U_EXPORT2 getJapanese(void);
210 static const Locale &U_EXPORT2 getKorean(void);
212 static const Locale &U_EXPORT2 getChinese(void);
214 static const Locale &U_EXPORT2 getSimplifiedChinese(void);
216 static const Locale &U_EXPORT2 getTraditionalChinese(void);
217
219 static const Locale &U_EXPORT2 getFrance(void);
221 static const Locale &U_EXPORT2 getGermany(void);
223 static const Locale &U_EXPORT2 getItaly(void);
225 static const Locale &U_EXPORT2 getJapan(void);
227 static const Locale &U_EXPORT2 getKorea(void);
229 static const Locale &U_EXPORT2 getChina(void);
231 static const Locale &U_EXPORT2 getPRC(void);
233 static const Locale &U_EXPORT2 getTaiwan(void);
235 static const Locale &U_EXPORT2 getUK(void);
237 static const Locale &U_EXPORT2 getUS(void);
239 static const Locale &U_EXPORT2 getCanada(void);
241 static const Locale &U_EXPORT2 getCanadaFrench(void);
242
243
251 Locale();
252
277 Locale( const char * language,
278 const char * country = 0,
279 const char * variant = 0,
280 const char * keywordsAndValues = 0);
281
288 Locale(const Locale& other);
289
297 Locale(Locale&& other) U_NOEXCEPT;
298
303 virtual ~Locale() ;
304
312 Locale& operator=(const Locale& other);
313
323 Locale& operator=(Locale&& other) U_NOEXCEPT;
324
332 UBool operator==(const Locale& other) const;
333
342 inline UBool operator!=(const Locale& other) const;
343
355 Locale *clone() const;
356
357 #ifndef U_HIDE_SYSTEM_API
358
373 static const Locale& U_EXPORT2 getDefault(void);
374
387 static void U_EXPORT2 setDefault(const Locale& newLocale,
388 UErrorCode& success);
389 #endif /* U_HIDE_SYSTEM_API */
390
408 static Locale U_EXPORT2 forLanguageTag(StringPiece tag, UErrorCode& status);
409
423 void toLanguageTag(ByteSink& sink, UErrorCode& status) const;
424
435 template<typename StringClass>
436 inline StringClass toLanguageTag(UErrorCode& status) const;
437
447 static Locale U_EXPORT2 createFromName(const char *name);
448
457 static Locale U_EXPORT2 createCanonical(const char* name);
458
464 inline const char * getLanguage( ) const;
465
473 inline const char * getScript( ) const;
474
480 inline const char * getCountry( ) const;
481
487 inline const char * getVariant( ) const;
488
497 inline const char * getName() const;
498
506 const char * getBaseName() const;
507
537 void addLikelySubtags(UErrorCode& status);
538
568 void minimizeSubtags(UErrorCode& status);
569
570 #ifndef U_HIDE_DRAFT_API
571
577 void canonicalize(UErrorCode& status);
578 #endif // U_HIDE_DRAFT_API
579
589 StringEnumeration * createKeywords(UErrorCode &status) const;
590
600 StringEnumeration * createUnicodeKeywords(UErrorCode &status) const;
601
613 template<typename StringClass, typename OutputIterator>
614 inline void getKeywords(OutputIterator iterator, UErrorCode& status) const;
615
627 template<typename StringClass, typename OutputIterator>
628 inline void getUnicodeKeywords(OutputIterator iterator, UErrorCode& status) const;
629
646 int32_t getKeywordValue(const char* keywordName, char *buffer, int32_t bufferCapacity, UErrorCode &status) const;
647
661 void getKeywordValue(StringPiece keywordName, ByteSink& sink, UErrorCode& status) const;
662
676 template<typename StringClass>
677 inline StringClass getKeywordValue(StringPiece keywordName, UErrorCode& status) const;
678
692 void getUnicodeKeywordValue(StringPiece keywordName, ByteSink& sink, UErrorCode& status) const;
693
707 template<typename StringClass>
708 inline StringClass getUnicodeKeywordValue(StringPiece keywordName, UErrorCode& status) const;
709
729 void setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status);
730
749 void setKeywordValue(StringPiece keywordName, StringPiece keywordValue, UErrorCode& status);
750
769 void setUnicodeKeywordValue(StringPiece keywordName, StringPiece keywordValue, UErrorCode& status);
770
777 const char * getISO3Language() const;
778
784 const char * getISO3Country() const;
785
793 uint32_t getLCID(void) const;
794
808 UBool isRightToLeft() const;
809
819 UnicodeString& getDisplayLanguage(UnicodeString& dispLang) const;
820
834 UnicodeString& getDisplayLanguage( const Locale& displayLocale,
835 UnicodeString& dispLang) const;
836
846 UnicodeString& getDisplayScript( UnicodeString& dispScript) const;
847
862 UnicodeString& getDisplayScript( const Locale& displayLocale,
863 UnicodeString& dispScript) const;
864
874 UnicodeString& getDisplayCountry( UnicodeString& dispCountry) const;
875
890 UnicodeString& getDisplayCountry( const Locale& displayLocale,
891 UnicodeString& dispCountry) const;
892
900 UnicodeString& getDisplayVariant( UnicodeString& dispVar) const;
901
910 UnicodeString& getDisplayVariant( const Locale& displayLocale,
911 UnicodeString& dispVar) const;
912
924 UnicodeString& getDisplayName( UnicodeString& name) const;
925
938 UnicodeString& getDisplayName( const Locale& displayLocale,
939 UnicodeString& name) const;
940
945 int32_t hashCode(void) const;
946
955 void setToBogus();
956
962 inline UBool isBogus(void) const;
963
972 static const Locale* U_EXPORT2 getAvailableLocales(int32_t& count);
973
982 static const char* const* U_EXPORT2 getISOCountries();
983
992 static const char* const* U_EXPORT2 getISOLanguages();
993
999 static UClassID U_EXPORT2 getStaticClassID();
1000
1006 virtual UClassID getDynamicClassID() const;
1007
1008 #ifndef U_HIDE_DRAFT_API
1009
1013 class U_COMMON_API Iterator /* not : public UObject because this is an interface/mixin class */ {
1014 public:
1016 virtual ~Iterator();
1017
1022 virtual UBool hasNext() const = 0;
1023
1028 virtual const Locale &next() = 0;
1029 };
1030
1035 template<typename Iter>
1036 class RangeIterator : public Iterator, public UMemory {
1037 public:
1047 RangeIterator(Iter begin, Iter end) : it_(begin), end_(end) {}
1048
1053 UBool hasNext() const override { return it_ != end_; }
1054
1059 const Locale &next() override { return *it_++; }
1060
1061 private:
1062 Iter it_;
1063 const Iter end_;
1064 };
1065
1071 template<typename Iter, typename Conv>
1072 class ConvertingIterator : public Iterator, public UMemory {
1073 public:
1084 ConvertingIterator(Iter begin, Iter end, Conv converter) :
1085 it_(begin), end_(end), converter_(converter) {}
1086
1091 UBool hasNext() const override { return it_ != end_; }
1092
1097 const Locale &next() override { return converter_(*it_++); }
1098
1099 private:
1100 Iter it_;
1101 const Iter end_;
1102 Conv converter_;
1103 };
1104 #endif // U_HIDE_DRAFT_API
1105
1106 protected: /* only protected for testing purposes. DO NOT USE. */
1107 #ifndef U_HIDE_INTERNAL_API
1108
1112 void setFromPOSIXID(const char *posixID);
1113 #endif /* U_HIDE_INTERNAL_API */
1114
1115 private:
1123 Locale& init(const char* cLocaleID, UBool canonicalize);
1124
1125 /*
1126 * Internal constructor to allow construction of a locale object with
1127 * NO side effects. (Default constructor tries to get
1128 * the default locale.)
1129 */
1130 enum ELocaleType {
1131 eBOGUS
1132 };
1133 Locale(ELocaleType);
1134
1138 static Locale *getLocaleCache(void);
1139
1140 char language[ULOC_LANG_CAPACITY];
1141 char script[ULOC_SCRIPT_CAPACITY];
1142 char country[ULOC_COUNTRY_CAPACITY];
1143 int32_t variantBegin;
1144 char* fullName;
1145 char fullNameBuffer[ULOC_FULLNAME_CAPACITY];
1146 // name without keywords
1147 char* baseName;
1148 void initBaseName(UErrorCode& status);
1149
1150 UBool fIsBogus;
1151
1152 static const Locale &getLocale(int locid);
1153
1158 friend Locale *locale_set_default_internal(const char *, UErrorCode& status);
1159
1163 friend void U_CALLCONV locale_available_init();
1164 };
1165
1166 inline UBool
1167 Locale::operator!=(const Locale& other) const
1168 {
1169 return !operator==(other);
1170 }
1171
1172 template<typename StringClass> inline StringClass
1173 Locale::toLanguageTag(UErrorCode& status) const
1174 {
1175 StringClass result;
1176 StringByteSink<StringClass> sink(&result);
1177 toLanguageTag(sink, status);
1178 return result;
1179 }
1180
1181 inline const char *
1182 Locale::getCountry() const
1183 {
1184 return country;
1185 }
1186
1187 inline const char *
1188 Locale::getLanguage() const
1189 {
1190 return language;
1191 }
1192
1193 inline const char *
1194 Locale::getScript() const
1195 {
1196 return script;
1197 }
1198
1199 inline const char *
1200 Locale::getVariant() const
1201 {
1202 return &baseName[variantBegin];
1203 }
1204
1205 inline const char *
1206 Locale::getName() const
1207 {
1208 return fullName;
1209 }
1210
1211 template<typename StringClass, typename OutputIterator> inline void
1212 Locale::getKeywords(OutputIterator iterator, UErrorCode& status) const
1213 {
1214 LocalPointer<StringEnumeration> keys(createKeywords(status));
1215 if (U_FAILURE(status) || keys.isNull()) {
1216 return;
1217 }
1218 for (;;) {
1219 int32_t resultLength;
1220 const char* buffer = keys->next(&resultLength, status);
1221 if (U_FAILURE(status) || buffer == nullptr) {
1222 return;
1223 }
1224 *iterator++ = StringClass(buffer, resultLength);
1225 }
1226 }
1227
1228 template<typename StringClass, typename OutputIterator> inline void
1229 Locale::getUnicodeKeywords(OutputIterator iterator, UErrorCode& status) const
1230 {
1231 LocalPointer<StringEnumeration> keys(createUnicodeKeywords(status));
1232 if (U_FAILURE(status) || keys.isNull()) {
1233 return;
1234 }
1235 for (;;) {
1236 int32_t resultLength;
1237 const char* buffer = keys->next(&resultLength, status);
1238 if (U_FAILURE(status) || buffer == nullptr) {
1239 return;
1240 }
1241 *iterator++ = StringClass(buffer, resultLength);
1242 }
1243 }
1244
1245 template<typename StringClass> inline StringClass
1246 Locale::getKeywordValue(StringPiece keywordName, UErrorCode& status) const
1247 {
1248 StringClass result;
1249 StringByteSink<StringClass> sink(&result);
1250 getKeywordValue(keywordName, sink, status);
1251 return result;
1252 }
1253
1254 template<typename StringClass> inline StringClass
1255 Locale::getUnicodeKeywordValue(StringPiece keywordName, UErrorCode& status) const
1256 {
1257 StringClass result;
1258 StringByteSink<StringClass> sink(&result);
1259 getUnicodeKeywordValue(keywordName, sink, status);
1260 return result;
1261 }
1262
1263 inline UBool
1264 Locale::isBogus(void) const {
1265 return fIsBogus;
1266 }
1267
1268 U_NAMESPACE_END
1269
1270 #endif /* U_SHOW_CPLUSPLUS_API */
1271
1272 #endif
icu::Locale::ConvertingIterator::next
const Locale & next() override
Definition: locid.h:1097
U_FAILURE
#define U_FAILURE(x)
Does the error code indicate a failure?
Definition: utypes.h:709
ULOC_LANG_CAPACITY
#define ULOC_LANG_CAPACITY
Useful constant for the maximum size of the language part of a locale ID.
Definition: uloc.h:251
icu::LocalPointer
"Smart pointer" class, deletes objects via the standard C++ delete operator.
Definition: localpointer.h:191
icu::operator==
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
ULOC_COUNTRY_CAPACITY
#define ULOC_COUNTRY_CAPACITY
Useful constant for the maximum size of the country part of a locale ID (including the terminating NU...
Definition: uloc.h:258
U_CALLCONV
#define U_CALLCONV
Similar to U_CDECL_BEGIN/U_CDECL_END, this qualifier is necessary in callback function typedefs to ma...
Definition: platform.h:870
icu::Locale::RangeIterator::hasNext
UBool hasNext() const override
Definition: locid.h:1053
UClassID
void * UClassID
UClassID is used to identify classes without using the compiler&#39;s RTTI.
Definition: uobject.h:96
ULOC_FULLNAME_CAPACITY
#define ULOC_FULLNAME_CAPACITY
Useful constant for the maximum size of the whole locale ID (including the terminating NULL and all k...
Definition: uloc.h:264
icu::StringEnumeration
Base class for &#39;pure&#39; C++ implementations of uenum api.
Definition: strenum.h:61
ULOC_SCRIPT_CAPACITY
#define ULOC_SCRIPT_CAPACITY
Useful constant for the maximum size of the script part of a locale ID (including the terminating NUL...
Definition: uloc.h:271
icu::ByteSink
A ByteSink can be filled with bytes.
Definition: bytestream.h:53
icu::Locale::Iterator
A Locale iterator interface similar to a Java Iterator<Locale>.
Definition: locid.h:1013
icu::locale_available_init
void locale_available_init()
stringpiece.h
C++ API: StringPiece: Read-only byte string wrapper class.
bytestream.h
C++ API: Interface for writing bytes, and implementation classes.
icu::Locale::RangeIterator
A generic Locale iterator implementation over Locale input iterators.
Definition: locid.h:1036
icu::LocalPointerBase::isNull
UBool isNull() const
NULL check.
Definition: localpointer.h:94
localpointer.h
C++ API: "Smart pointers" for use with and in ICU4C C++ code.
icu::operator!=
UBool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:347
icu::UObject::getDynamicClassID
virtual UClassID getDynamicClassID() const
ICU4C "poor man&#39;s RTTI", returns a UClassID for the actual ICU class.
putil.h
C API: Platform Utilities.
icu::Locale::RangeIterator::RangeIterator
RangeIterator(Iter begin, Iter end)
Constructs an iterator from a begin/end range.
Definition: locid.h:1047
uobject.h
C++ API: Common ICU base class UObject.
U_NOEXCEPT
#define U_NOEXCEPT
"noexcept" if supported, otherwise empty.
Definition: platform.h:529
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:415
strenum.h
C++ API: String Enumeration.
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
icu::StringByteSink
Implementation of ByteSink that writes to a "string".
Definition: bytestream.h:269
U_COMMON_API
#define U_COMMON_API
Set to export library symbols from inside the common library, and to import them from outside...
Definition: utypes.h:300
icu::UnicodeString
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:294
icu::Locale::ConvertingIterator
A generic Locale iterator implementation over Locale input iterators.
Definition: locid.h:1072
icu::StringPiece
A string-like object that points to a sized piece of memory.
Definition: stringpiece.h:60
icu::UObject
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:223
icu::UMemory
UMemory is the common ICU base class.
Definition: uobject.h:115
icu::Locale::RangeIterator::next
const Locale & next() override
Definition: locid.h:1059
icu::Locale::ConvertingIterator::ConvertingIterator
ConvertingIterator(Iter begin, Iter end, Conv converter)
Constructs an iterator from a begin/end range.
Definition: locid.h:1084
icu::Locale::ConvertingIterator::hasNext
UBool hasNext() const override
Definition: locid.h:1091
UBool
int8_t UBool
The ICU boolean type.
Definition: umachine.h:261
uloc.h
C API: Locale.
icu::Locale
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:195