The Tor Browser / file comparison

comparison: intl/icu/source/i18n/udatpg.cpp

intl/icu/source/i18n/udatpg.cpp

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:4f39b88d3af0
1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 2009-2012, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: udatpg.cpp
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2007jul30
14 * created by: Markus W. Scherer
15 */
16
17 #include "unicode/utypes.h"
18
19 #if !UCONFIG_NO_FORMATTING
20
21 #include "unicode/udatpg.h"
22 #include "unicode/uenum.h"
23 #include "unicode/strenum.h"
24 #include "unicode/dtptngen.h"
25 #include "ustrenum.h"
26
27 U_NAMESPACE_USE
28
29 U_CAPI UDateTimePatternGenerator * U_EXPORT2
30 udatpg_open(const char *locale, UErrorCode *pErrorCode) {
31 if(locale==NULL) {
32 return (UDateTimePatternGenerator *)DateTimePatternGenerator::createInstance(*pErrorCode);
33 } else {
34 return (UDateTimePatternGenerator *)DateTimePatternGenerator::createInstance(Locale(locale), *pErrorCode);
35 }
36 }
37
38 U_CAPI UDateTimePatternGenerator * U_EXPORT2
39 udatpg_openEmpty(UErrorCode *pErrorCode) {
40 return (UDateTimePatternGenerator *)DateTimePatternGenerator::createEmptyInstance(*pErrorCode);
41 }
42
43 U_CAPI void U_EXPORT2
44 udatpg_close(UDateTimePatternGenerator *dtpg) {
45 delete (DateTimePatternGenerator *)dtpg;
46 }
47
48 U_CAPI UDateTimePatternGenerator * U_EXPORT2
49 udatpg_clone(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode) {
50 if(U_FAILURE(*pErrorCode)) {
51 return NULL;
52 }
53 return (UDateTimePatternGenerator *)(((const DateTimePatternGenerator *)dtpg)->clone());
54 }
55
56 U_CAPI int32_t U_EXPORT2
57 udatpg_getBestPattern(UDateTimePatternGenerator *dtpg,
58 const UChar *skeleton, int32_t length,
59 UChar *bestPattern, int32_t capacity,
60 UErrorCode *pErrorCode) {
61 return udatpg_getBestPatternWithOptions(dtpg, skeleton, length,
62 UDATPG_MATCH_NO_OPTIONS,
63 bestPattern, capacity, pErrorCode);
64 }
65
66 U_CAPI int32_t U_EXPORT2
67 udatpg_getBestPatternWithOptions(UDateTimePatternGenerator *dtpg,
68 const UChar *skeleton, int32_t length,
69 UDateTimePatternMatchOptions options,
70 UChar *bestPattern, int32_t capacity,
71 UErrorCode *pErrorCode) {
72 if(U_FAILURE(*pErrorCode)) {
73 return 0;
74 }
75 if(skeleton==NULL && length!=0) {
76 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
77 return 0;
78 }
79 UnicodeString skeletonString((UBool)(length<0), skeleton, length);
80 UnicodeString result=((DateTimePatternGenerator *)dtpg)->getBestPattern(skeletonString, options, *pErrorCode);
81 return result.extract(bestPattern, capacity, *pErrorCode);
82 }
83
84 U_CAPI int32_t U_EXPORT2
85 udatpg_getSkeleton(UDateTimePatternGenerator *dtpg,
86 const UChar *pattern, int32_t length,
87 UChar *skeleton, int32_t capacity,
88 UErrorCode *pErrorCode) {
89 if(U_FAILURE(*pErrorCode)) {
90 return 0;
91 }
92 if(pattern==NULL && length!=0) {
93 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
94 return 0;
95 }
96 UnicodeString patternString((UBool)(length<0), pattern, length);
97 UnicodeString result=((DateTimePatternGenerator *)dtpg)->getSkeleton(patternString, *pErrorCode);
98 return result.extract(skeleton, capacity, *pErrorCode);
99 }
100
101 U_CAPI int32_t U_EXPORT2
102 udatpg_getBaseSkeleton(UDateTimePatternGenerator *dtpg,
103 const UChar *pattern, int32_t length,
104 UChar *skeleton, int32_t capacity,
105 UErrorCode *pErrorCode) {
106 if(U_FAILURE(*pErrorCode)) {
107 return 0;
108 }
109 if(pattern==NULL && length!=0) {
110 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
111 return 0;
112 }
113 UnicodeString patternString((UBool)(length<0), pattern, length);
114 UnicodeString result=((DateTimePatternGenerator *)dtpg)->getBaseSkeleton(patternString, *pErrorCode);
115 return result.extract(skeleton, capacity, *pErrorCode);
116 }
117
118 U_CAPI UDateTimePatternConflict U_EXPORT2
119 udatpg_addPattern(UDateTimePatternGenerator *dtpg,
120 const UChar *pattern, int32_t patternLength,
121 UBool override,
122 UChar *conflictingPattern, int32_t capacity, int32_t *pLength,
123 UErrorCode *pErrorCode) {
124 if(U_FAILURE(*pErrorCode)) {
125 return UDATPG_NO_CONFLICT;
126 }
127 if(pattern==NULL && patternLength!=0) {
128 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
129 return UDATPG_NO_CONFLICT;
130 }
131 UnicodeString patternString((UBool)(patternLength<0), pattern, patternLength);
132 UnicodeString conflictingPatternString;
133 UDateTimePatternConflict result=((DateTimePatternGenerator *)dtpg)->
134 addPattern(patternString, override, conflictingPatternString, *pErrorCode);
135 int32_t length=conflictingPatternString.extract(conflictingPattern, capacity, *pErrorCode);
136 if(pLength!=NULL) {
137 *pLength=length;
138 }
139 return result;
140 }
141
142 U_CAPI void U_EXPORT2
143 udatpg_setAppendItemFormat(UDateTimePatternGenerator *dtpg,
144 UDateTimePatternField field,
145 const UChar *value, int32_t length) {
146 UnicodeString valueString((UBool)(length<0), value, length);
147 ((DateTimePatternGenerator *)dtpg)->setAppendItemFormat(field, valueString);
148 }
149
150 U_CAPI const UChar * U_EXPORT2
151 udatpg_getAppendItemFormat(const UDateTimePatternGenerator *dtpg,
152 UDateTimePatternField field,
153 int32_t *pLength) {
154 const UnicodeString &result=((const DateTimePatternGenerator *)dtpg)->getAppendItemFormat(field);
155 if(pLength!=NULL) {
156 *pLength=result.length();
157 }
158 return result.getBuffer();
159 }
160
161 U_CAPI void U_EXPORT2
162 udatpg_setAppendItemName(UDateTimePatternGenerator *dtpg,
163 UDateTimePatternField field,
164 const UChar *value, int32_t length) {
165 UnicodeString valueString((UBool)(length<0), value, length);
166 ((DateTimePatternGenerator *)dtpg)->setAppendItemName(field, valueString);
167 }
168
169 U_CAPI const UChar * U_EXPORT2
170 udatpg_getAppendItemName(const UDateTimePatternGenerator *dtpg,
171 UDateTimePatternField field,
172 int32_t *pLength) {
173 const UnicodeString &result=((const DateTimePatternGenerator *)dtpg)->getAppendItemName(field);
174 if(pLength!=NULL) {
175 *pLength=result.length();
176 }
177 return result.getBuffer();
178 }
179
180 U_CAPI void U_EXPORT2
181 udatpg_setDateTimeFormat(const UDateTimePatternGenerator *dtpg,
182 const UChar *dtFormat, int32_t length) {
183 UnicodeString dtFormatString((UBool)(length<0), dtFormat, length);
184 ((DateTimePatternGenerator *)dtpg)->setDateTimeFormat(dtFormatString);
185 }
186
187 U_CAPI const UChar * U_EXPORT2
188 udatpg_getDateTimeFormat(const UDateTimePatternGenerator *dtpg,
189 int32_t *pLength) {
190 const UnicodeString &result=((const DateTimePatternGenerator *)dtpg)->getDateTimeFormat();
191 if(pLength!=NULL) {
192 *pLength=result.length();
193 }
194 return result.getBuffer();
195 }
196
197 U_CAPI void U_EXPORT2
198 udatpg_setDecimal(UDateTimePatternGenerator *dtpg,
199 const UChar *decimal, int32_t length) {
200 UnicodeString decimalString((UBool)(length<0), decimal, length);
201 ((DateTimePatternGenerator *)dtpg)->setDecimal(decimalString);
202 }
203
204 U_CAPI const UChar * U_EXPORT2
205 udatpg_getDecimal(const UDateTimePatternGenerator *dtpg,
206 int32_t *pLength) {
207 const UnicodeString &result=((const DateTimePatternGenerator *)dtpg)->getDecimal();
208 if(pLength!=NULL) {
209 *pLength=result.length();
210 }
211 return result.getBuffer();
212 }
213
214 U_CAPI int32_t U_EXPORT2
215 udatpg_replaceFieldTypes(UDateTimePatternGenerator *dtpg,
216 const UChar *pattern, int32_t patternLength,
217 const UChar *skeleton, int32_t skeletonLength,
218 UChar *dest, int32_t destCapacity,
219 UErrorCode *pErrorCode) {
220 return udatpg_replaceFieldTypesWithOptions(dtpg, pattern, patternLength, skeleton, skeletonLength,
221 UDATPG_MATCH_NO_OPTIONS,
222 dest, destCapacity, pErrorCode);
223 }
224
225 U_CAPI int32_t U_EXPORT2
226 udatpg_replaceFieldTypesWithOptions(UDateTimePatternGenerator *dtpg,
227 const UChar *pattern, int32_t patternLength,
228 const UChar *skeleton, int32_t skeletonLength,
229 UDateTimePatternMatchOptions options,
230 UChar *dest, int32_t destCapacity,
231 UErrorCode *pErrorCode) {
232 if(U_FAILURE(*pErrorCode)) {
233 return 0;
234 }
235 if((pattern==NULL && patternLength!=0) || (skeleton==NULL && skeletonLength!=0)) {
236 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
237 return 0;
238 }
239 UnicodeString patternString((UBool)(patternLength<0), pattern, patternLength);
240 UnicodeString skeletonString((UBool)(skeletonLength<0), skeleton, skeletonLength);
241 UnicodeString result=((DateTimePatternGenerator *)dtpg)->replaceFieldTypes(patternString, skeletonString, options, *pErrorCode);
242 return result.extract(dest, destCapacity, *pErrorCode);
243 }
244
245 U_CAPI UEnumeration * U_EXPORT2
246 udatpg_openSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode) {
247 return uenum_openFromStringEnumeration(
248 ((DateTimePatternGenerator *)dtpg)->getSkeletons(*pErrorCode),
249 pErrorCode);
250 }
251
252 U_CAPI UEnumeration * U_EXPORT2
253 udatpg_openBaseSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode) {
254 return uenum_openFromStringEnumeration(
255 ((DateTimePatternGenerator *)dtpg)->getBaseSkeletons(*pErrorCode),
256 pErrorCode);
257 }
258
259 U_CAPI const UChar * U_EXPORT2
260 udatpg_getPatternForSkeleton(const UDateTimePatternGenerator *dtpg,
261 const UChar *skeleton, int32_t skeletonLength,
262 int32_t *pLength) {
263 UnicodeString skeletonString((UBool)(skeletonLength<0), skeleton, skeletonLength);
264 const UnicodeString &result=((const DateTimePatternGenerator *)dtpg)->getPatternForSkeleton(skeletonString);
265 if(pLength!=NULL) {
266 *pLength=result.length();
267 }
268 return result.getBuffer();
269 }
270
271 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial