icuSources/i18n/uatimeunitformat.cpp

   1 /*
   2 *****************************************************************************************
   3 * Copyright (C) 2014-2015 Apple Inc. All Rights Reserved.
   4 *****************************************************************************************
   5 */
   6
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_FORMATTING
  10
  11 #include "unicode/uatimeunitformat.h"
  12 #include "unicode/fieldpos.h"
  13 #include "unicode/localpointer.h"
  14 #include "unicode/numfmt.h"
  15 #include "unicode/measunit.h"
  16 #include "unicode/measure.h"
  17 #include "unicode/measfmt.h"
  18 #include "unicode/unistr.h"
  19 #include "unicode/unum.h"
  20 #include "unicode/ures.h"
  21 #include "ureslocs.h"
  22 #include "uresimp.h"
  23 #include "ustr_imp.h"
  24
  25 U_NAMESPACE_USE
  26
  27
  28 U_CAPI UATimeUnitFormat* U_EXPORT2
  29 uatmufmt_open(const char*  locale,
  30               UATimeUnitStyle style,
  31               UErrorCode*  status)
  32 {
  33     return uatmufmt_openWithNumberFormat(locale, style, NULL, status);
  34 }
  35
  36
  37 U_CAPI UATimeUnitFormat* U_EXPORT2
  38 uatmufmt_openWithNumberFormat(const char*  locale,
  39                             UATimeUnitStyle style,
  40                             UNumberFormat*  nfToAdopt,
  41                             UErrorCode*  status)
  42 {
  43     if (U_FAILURE(*status)) {
  44         return NULL;
  45     }
  46     UMeasureFormatWidth mfWidth = UMEASFMT_WIDTH_WIDE;
  47     switch (style) {
  48         case UATIMEUNITSTYLE_FULL:
  49             break;
  50         case UATIMEUNITSTYLE_ABBREVIATED:
  51             mfWidth = UMEASFMT_WIDTH_SHORT; break;
  52         case UATIMEUNITSTYLE_NARROW:
  53             mfWidth = UMEASFMT_WIDTH_NARROW; break;
  54         case UATIMEUNITSTYLE_SHORTER:
  55             mfWidth = UMEASFMT_WIDTH_SHORTER; break;
  56         default:
  57             *status = U_ILLEGAL_ARGUMENT_ERROR; return NULL;
  58     }
  59     LocalPointer<MeasureFormat> mfmt( new MeasureFormat(Locale(locale), mfWidth, (NumberFormat*)nfToAdopt, *status) );
  60     if (U_FAILURE(*status)) {
  61         return NULL;
  62     }
  63     return (UATimeUnitFormat*)mfmt.orphan();
  64 }
  65
  66
  67 U_CAPI void U_EXPORT2
  68 uatmufmt_close(UATimeUnitFormat *mfmt)
  69 {
  70     delete (MeasureFormat*)mfmt;
  71 }
  72
  73
  74 U_CAPI void U_EXPORT2
  75 uatmufmt_setNumberFormat(UATimeUnitFormat* mfmt,
  76                         UNumberFormat*  numfmt,
  77                         UErrorCode*     status)
  78 {
  79     if (U_FAILURE(*status)) {
  80         return;
  81     }
  82     ((MeasureFormat*)mfmt)->adoptNumberFormat( (NumberFormat*)(((NumberFormat*)numfmt)->clone()), *status );
  83 }
  84
  85
  86 U_CAPI int32_t U_EXPORT2
  87 uatmufmt_format(const UATimeUnitFormat* mfmt,
  88                 double          value,
  89                 UATimeUnitField field,
  90                 UChar*          result,
  91                 int32_t         resultCapacity,
  92                 UErrorCode*     status)
  93 {
  94     if (U_FAILURE(*status)) {
  95         return 0;
  96     }
  97     if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) ) {
  98         *status = U_ILLEGAL_ARGUMENT_ERROR;
  99         return 0;
 100     }
 101     MeasureUnit * munit = NULL;
 102     switch (field) {
 103         case UATIMEUNITFIELD_YEAR:    munit = MeasureUnit::createYear(*status);    break;
 104         case UATIMEUNITFIELD_MONTH:   munit = MeasureUnit::createMonth(*status);   break;
 105         case UATIMEUNITFIELD_DAY:     munit = MeasureUnit::createDay(*status);     break;
 106         case UATIMEUNITFIELD_WEEK:    munit = MeasureUnit::createWeek(*status);    break;
 107         case UATIMEUNITFIELD_HOUR:    munit = MeasureUnit::createHour(*status);    break;
 108         case UATIMEUNITFIELD_MINUTE:  munit = MeasureUnit::createMinute(*status);  break;
 109         case UATIMEUNITFIELD_SECOND:  munit = MeasureUnit::createSecond(*status);  break;
 110         default: *status = U_ILLEGAL_ARGUMENT_ERROR; break;
 111     }
 112     if (U_FAILURE(*status)) {
 113         return 0;
 114     }
 115     LocalPointer<Measure> meas(new Measure(value, munit, *status));
 116     if (U_FAILURE(*status)) {
 117         return 0;
 118     }
 119     Formattable fmt;
 120     fmt.adoptObject(meas.orphan());
 121     UnicodeString res;
 122     res.setTo(result, 0, resultCapacity);
 123     FieldPosition pos(0);
 124     ((MeasureFormat*)mfmt)->format(fmt, res, pos, *status);
 125     return res.extract(result, resultCapacity, *status);
 126 }
 127
 128
 129 U_CAPI double U_EXPORT2
 130 uatmufmt_parse( const UATimeUnitFormat* mfmt,
 131                 const UChar*    text,
 132                 int32_t         textLength,
 133                 int32_t*        parsePos,
 134                 UATimeUnitField* field,
 135                 UErrorCode*     status)
 136 {
 137     double doubleVal = 0.0;
 138     if (U_FAILURE(*status)) {
 139         return doubleVal;
 140     }
 141     *status = U_UNSUPPORTED_ERROR;
 142     return doubleVal;
 143 }
 144
 145
 146 U_CAPI int32_t U_EXPORT2
 147 uatmufmt_getTimePattern(const char*     locale,
 148                         UATimeUnitTimePattern type,
 149                         UChar*          result,
 150                         int32_t         resultCapacity,
 151                         UErrorCode*     status)
 152 {
 153     if (U_FAILURE(*status)) {
 154         return 0;
 155     }
 156     if ( (result==NULL)? resultCapacity!=0: resultCapacity<0 ) {
 157         *status = U_ILLEGAL_ARGUMENT_ERROR;
 158         return 0;
 159     }
 160     const char* key = NULL;
 161     switch (type) {
 162         case UATIMEUNITTIMEPAT_HM:  { key = "hm"; break; }
 163         case UATIMEUNITTIMEPAT_HMS: { key = "hms"; break; }
 164         case UATIMEUNITTIMEPAT_MS:  { key = "ms"; break; }
 165         default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
 166     }
 167     int32_t resLen = 0;
 168     const UChar* resPtr = NULL;
 169     UResourceBundle* rb =  ures_open(U_ICUDATA_UNIT, locale, status);
 170     rb = ures_getByKeyWithFallback(rb, "durationUnits", rb, status);
 171     resPtr = ures_getStringByKeyWithFallback(rb, key, &resLen, status);
 172     if (U_SUCCESS(*status)) {
 173         u_strncpy(result, resPtr, resultCapacity);
 174     }
 175     ures_close(rb);
 176     return u_terminateUChars(result, resultCapacity, resLen, status);
 177 }
 178
 179
 180 U_CAPI int32_t U_EXPORT2
 181 uatmufmt_getListPattern(const char*     locale,
 182                         UATimeUnitStyle style,
 183                         UATimeUnitListPattern type,
 184                         UChar*          result,
 185                         int32_t         resultCapacity,
 186                         UErrorCode*     status)
 187 {
 188     if (U_FAILURE(*status)) {
 189         return 0;
 190     }
 191     if ( (result==NULL)? resultCapacity!=0: resultCapacity<0 ) {
 192         *status = U_ILLEGAL_ARGUMENT_ERROR;
 193         return 0;
 194     }
 195     const char* styleKey = NULL;
 196     switch (style) {
 197         case UATIMEUNITSTYLE_FULL:          { styleKey = "unit"; break; }
 198         case UATIMEUNITSTYLE_ABBREVIATED:   { styleKey = "unit-short"; break; }
 199         case UATIMEUNITSTYLE_NARROW:        { styleKey = "unit-narrow"; break; }
 200         case UATIMEUNITSTYLE_SHORTER:       { styleKey = "unit-narrow"; break; }
 201         default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
 202     }
 203     const char* typeKey = NULL;
 204     switch (type) {
 205         case UATIMEUNITLISTPAT_TWO_ONLY:        { typeKey = "2"; break; }
 206         case UATIMEUNITLISTPAT_END_PIECE:       { typeKey = "end"; break; }
 207         case UATIMEUNITLISTPAT_MIDDLE_PIECE:    { typeKey = "middle"; break; }
 208         case UATIMEUNITLISTPAT_START_PIECE:     { typeKey = "start"; break; }
 209         default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
 210     }
 211     int32_t resLen = 0;
 212     const UChar* resPtr = NULL;
 213     UResourceBundle* rb =  ures_open(NULL, locale, status);
 214     rb = ures_getByKeyWithFallback(rb, "listPattern", rb, status);
 215     rb = ures_getByKeyWithFallback(rb, styleKey, rb, status);
 216     resPtr = ures_getStringByKeyWithFallback(rb, typeKey, &resLen, status);
 217     if (U_SUCCESS(*status)) {
 218         u_strncpy(result, resPtr, resultCapacity);
 219     }
 220     ures_close(rb);
 221     return u_terminateUChars(result, resultCapacity, resLen, status);
 222 }
 223
 224
 225 #endif /* #if !UCONFIG_NO_FORMATTING */