1/*
2******************************************************************************
3*                                                                            *
4* Copyright (C) 2003-2011, International Business Machines                   *
5*                Corporation and others. All Rights Reserved.                *
6*                                                                            *
7******************************************************************************
8*   file name:  ulocdata.c
9*   encoding:   US-ASCII
10*   tab size:   8 (not used)
11*   indentation:4
12*
13*   created on: 2003Oct21
14*   created by: Ram Viswanadha,John Emmons
15*/
16
17#include "cmemory.h"
18#include "unicode/ustring.h"
19#include "unicode/ulocdata.h"
20#include "umutex.h"
21#include "uresimp.h"
22#include "ureslocs.h"
23
24#define MEASUREMENT_SYSTEM  "MeasurementSystem"
25#define PAPER_SIZE          "PaperSize"
26
27/** A locale data object.
28 *  For usage in C programs.
29 *  @draft ICU 3.4
30 */
31struct ULocaleData {
32    /**
33     * Controls the "No Substitute" behavior of this locale data object
34     */
35    UBool noSubstitute;
36
37    /**
38     * Pointer to the resource bundle associated with this locale data object
39     */
40    UResourceBundle *bundle;
41
42    /**
43     * Pointer to the lang resource bundle associated with this locale data object
44     */
45    UResourceBundle *langBundle;
46};
47
48U_CAPI ULocaleData* U_EXPORT2
49ulocdata_open(const char *localeID, UErrorCode *status)
50{
51   ULocaleData *uld;
52
53   if (U_FAILURE(*status)) {
54       return NULL;
55   }
56
57   uld = (ULocaleData *)uprv_malloc(sizeof(ULocaleData));
58   if (uld == NULL) {
59      *status = U_MEMORY_ALLOCATION_ERROR;
60      return(NULL);
61   }
62
63   uld->langBundle = NULL;
64
65   uld->noSubstitute = FALSE;
66   uld->bundle = ures_open(NULL, localeID, status);
67   uld->langBundle = ures_open(U_ICUDATA_LANG, localeID, status);
68
69   if (U_FAILURE(*status)) {
70      uprv_free(uld);
71      return NULL;
72   }
73
74   return uld;
75}
76
77U_CAPI void U_EXPORT2
78ulocdata_close(ULocaleData *uld)
79{
80    if ( uld != NULL ) {
81       ures_close(uld->langBundle);
82       ures_close(uld->bundle);
83       uprv_free(uld);
84    }
85}
86
87U_CAPI void U_EXPORT2
88ulocdata_setNoSubstitute(ULocaleData *uld, UBool setting)
89{
90   uld->noSubstitute = setting;
91}
92
93U_CAPI UBool U_EXPORT2
94ulocdata_getNoSubstitute(ULocaleData *uld)
95{
96   return uld->noSubstitute;
97}
98
99U_CAPI USet* U_EXPORT2
100ulocdata_getExemplarSet(ULocaleData *uld, USet *fillIn,
101                        uint32_t options, ULocaleDataExemplarSetType extype, UErrorCode *status){
102
103    static const char* const exemplarSetTypes[] = { "ExemplarCharacters",
104                                                    "AuxExemplarCharacters",
105                                                    "ExemplarCharactersIndex"};
106    const UChar *exemplarChars = NULL;
107    int32_t len = 0;
108    UErrorCode localStatus = U_ZERO_ERROR;
109
110    if (U_FAILURE(*status))
111        return NULL;
112
113    exemplarChars = ures_getStringByKey(uld->bundle, exemplarSetTypes[extype], &len, &localStatus);
114    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
115        localStatus = U_MISSING_RESOURCE_ERROR;
116    }
117
118    if (localStatus != U_ZERO_ERROR) {
119        *status = localStatus;
120    }
121
122    if (U_FAILURE(*status))
123        return NULL;
124
125    if(fillIn != NULL)
126        uset_applyPattern(fillIn, exemplarChars, len,
127                          USET_IGNORE_SPACE | options, status);
128    else
129        fillIn = uset_openPatternOptions(exemplarChars, len,
130                                         USET_IGNORE_SPACE | options, status);
131
132    return fillIn;
133
134}
135
136U_CAPI int32_t U_EXPORT2
137ulocdata_getDelimiter(ULocaleData *uld, ULocaleDataDelimiterType type,
138                      UChar *result, int32_t resultLength, UErrorCode *status){
139
140    static const char* const delimiterKeys[] =  {
141        "quotationStart",
142        "quotationEnd",
143        "alternateQuotationStart",
144        "alternateQuotationEnd"
145    };
146
147    UResourceBundle *delimiterBundle;
148    int32_t len = 0;
149    const UChar *delimiter = NULL;
150    UErrorCode localStatus = U_ZERO_ERROR;
151
152    if (U_FAILURE(*status))
153        return 0;
154
155    delimiterBundle = ures_getByKey(uld->bundle, "delimiters", NULL, &localStatus);
156
157    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
158        localStatus = U_MISSING_RESOURCE_ERROR;
159    }
160
161    if (localStatus != U_ZERO_ERROR) {
162        *status = localStatus;
163    }
164
165    if (U_FAILURE(*status)){
166        ures_close(delimiterBundle);
167        return 0;
168    }
169
170    delimiter = ures_getStringByKey(delimiterBundle, delimiterKeys[type], &len, &localStatus);
171    ures_close(delimiterBundle);
172
173    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
174        localStatus = U_MISSING_RESOURCE_ERROR;
175    }
176
177    if (localStatus != U_ZERO_ERROR) {
178        *status = localStatus;
179    }
180
181    if (U_FAILURE(*status)){
182        return 0;
183    }
184
185    u_strncpy(result,delimiter, resultLength);
186    return len;
187}
188
189U_CAPI UMeasurementSystem U_EXPORT2
190ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status){
191
192    UResourceBundle* bundle=NULL;
193    UResourceBundle* measurement=NULL;
194    UMeasurementSystem system = UMS_LIMIT;
195
196    if(status == NULL || U_FAILURE(*status)){
197        return system;
198    }
199
200    bundle = ures_open(NULL, localeID, status);
201
202    measurement = ures_getByKeyWithFallback(bundle, MEASUREMENT_SYSTEM, NULL, status);
203
204    system = (UMeasurementSystem) ures_getInt(measurement, status);
205
206    ures_close(bundle);
207    ures_close(measurement);
208
209    return system;
210
211}
212
213U_CAPI void U_EXPORT2
214ulocdata_getPaperSize(const char* localeID, int32_t *height, int32_t *width, UErrorCode *status){
215    UResourceBundle* bundle=NULL;
216    UResourceBundle* paperSizeBundle = NULL;
217    const int32_t* paperSize=NULL;
218    int32_t len = 0;
219
220    if(status == NULL || U_FAILURE(*status)){
221        return;
222    }
223
224    bundle = ures_open(NULL, localeID, status);
225    paperSizeBundle = ures_getByKeyWithFallback(bundle, PAPER_SIZE, NULL, status);
226    paperSize = ures_getIntVector(paperSizeBundle, &len,  status);
227
228    if(U_SUCCESS(*status)){
229        if(len < 2){
230            *status = U_INTERNAL_PROGRAM_ERROR;
231        }else{
232            *height = paperSize[0];
233            *width  = paperSize[1];
234        }
235    }
236
237    ures_close(bundle);
238    ures_close(paperSizeBundle);
239
240}
241
242U_DRAFT void U_EXPORT2
243ulocdata_getCLDRVersion(UVersionInfo versionArray, UErrorCode *status) {
244    UResourceBundle *rb = NULL;
245    rb = ures_openDirect(NULL, "supplementalData", status);
246    ures_getVersionByKey(rb, "cldrVersion", versionArray, status);
247    ures_close(rb);
248}
249
250U_DRAFT int32_t U_EXPORT2
251ulocdata_getLocaleDisplayPattern(ULocaleData *uld,
252                                 UChar *result,
253                                 int32_t resultCapacity,
254                                 UErrorCode *status) {
255    UResourceBundle *patternBundle;
256    int32_t len = 0;
257    const UChar *pattern = NULL;
258    UErrorCode localStatus = U_ZERO_ERROR;
259
260    if (U_FAILURE(*status))
261        return 0;
262
263    patternBundle = ures_getByKey(uld->langBundle, "localeDisplayPattern", NULL, &localStatus);
264
265    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
266        localStatus = U_MISSING_RESOURCE_ERROR;
267    }
268
269    if (localStatus != U_ZERO_ERROR) {
270        *status = localStatus;
271    }
272
273    if (U_FAILURE(*status)){
274        ures_close(patternBundle);
275        return 0;
276    }
277
278    pattern = ures_getStringByKey(patternBundle, "pattern", &len, &localStatus);
279    ures_close(patternBundle);
280
281    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
282        localStatus = U_MISSING_RESOURCE_ERROR;
283    }
284
285    if (localStatus != U_ZERO_ERROR) {
286        *status = localStatus;
287    }
288
289    if (U_FAILURE(*status)){
290        return 0;
291    }
292
293    u_strncpy(result, pattern, resultCapacity);
294    return len;
295}
296
297
298U_DRAFT int32_t U_EXPORT2
299ulocdata_getLocaleSeparator(ULocaleData *uld,
300                            UChar *result,
301                            int32_t resultCapacity,
302                            UErrorCode *status)  {
303    UResourceBundle *separatorBundle;
304    int32_t len = 0;
305    const UChar *separator = NULL;
306    UErrorCode localStatus = U_ZERO_ERROR;
307
308    if (U_FAILURE(*status))
309        return 0;
310
311    separatorBundle = ures_getByKey(uld->langBundle, "localeDisplayPattern", NULL, &localStatus);
312
313    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
314        localStatus = U_MISSING_RESOURCE_ERROR;
315    }
316
317    if (localStatus != U_ZERO_ERROR) {
318        *status = localStatus;
319    }
320
321    if (U_FAILURE(*status)){
322        ures_close(separatorBundle);
323        return 0;
324    }
325
326    separator = ures_getStringByKey(separatorBundle, "separator", &len, &localStatus);
327    ures_close(separatorBundle);
328
329    if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
330        localStatus = U_MISSING_RESOURCE_ERROR;
331    }
332
333    if (localStatus != U_ZERO_ERROR) {
334        *status = localStatus;
335    }
336
337    if (U_FAILURE(*status)){
338        return 0;
339    }
340
341    u_strncpy(result, separator, resultCapacity);
342    return len;
343}
344