Home | History | Annotate | Download | only in i18n
      1 /*
      2 *******************************************************************************
      3 *
      4 *   Copyright (C) 2009, 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_DRAFT 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_DRAFT UDateTimePatternGenerator * U_EXPORT2
     39 udatpg_openEmpty(UErrorCode *pErrorCode) {
     40     return (UDateTimePatternGenerator *)DateTimePatternGenerator::createEmptyInstance(*pErrorCode);
     41 }
     42 
     43 U_DRAFT void U_EXPORT2
     44 udatpg_close(UDateTimePatternGenerator *dtpg) {
     45     delete (DateTimePatternGenerator *)dtpg;
     46 }
     47 
     48 U_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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_DRAFT 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
    272