icuSources/i18n/uameasureformat.cpp

   1 /*
   2 *****************************************************************************************
   3 * Copyright (C) 2014-2016 Apple Inc. All Rights Reserved.
   4 *****************************************************************************************
   5 */
   6
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_FORMATTING
  10
  11 #include <stdlib.h>
  12 #include "unicode/uameasureformat.h"
  13 #include "unicode/fieldpos.h"
  14 #include "unicode/localpointer.h"
  15 #include "unicode/numfmt.h"
  16 #include "unicode/measunit.h"
  17 #include "unicode/measure.h"
  18 #include "unicode/measfmt.h"
  19 #include "unicode/unistr.h"
  20 #include "unicode/unum.h"
  21 #include "unicode/umisc.h"
  22 #include "unicode/ures.h"
  23 #include "uresimp.h"
  24 #include "ustr_imp.h"
  25 #include "cstring.h"
  26 #include "ulocimp.h"
  27
  28 U_NAMESPACE_USE
  29
  30
  31 U_CAPI UAMeasureFormat* U_EXPORT2
  32 uameasfmt_open( const char*          locale,
  33                 UAMeasureFormatWidth width,
  34                 UNumberFormat*       nfToAdopt,
  35                 UErrorCode*          status )
  36 {
  37     if (U_FAILURE(*status)) {
  38         return NULL;
  39     }
  40     UMeasureFormatWidth mfWidth = UMEASFMT_WIDTH_WIDE;
  41     switch (width) {
  42         case UAMEASFMT_WIDTH_WIDE:
  43             break;
  44         case UAMEASFMT_WIDTH_SHORT:
  45             mfWidth = UMEASFMT_WIDTH_SHORT; break;
  46         case UAMEASFMT_WIDTH_NARROW:
  47             mfWidth = UMEASFMT_WIDTH_NARROW; break;
  48         case UAMEASFMT_WIDTH_NUMERIC:
  49             mfWidth = UMEASFMT_WIDTH_NUMERIC; break;
  50         case UAMEASFMT_WIDTH_SHORTER:
  51             mfWidth = UMEASFMT_WIDTH_SHORTER; break;
  52         default:
  53             *status = U_ILLEGAL_ARGUMENT_ERROR; return NULL;
  54     }
  55     LocalPointer<MeasureFormat> measfmt( new MeasureFormat(Locale(locale), mfWidth, (NumberFormat*)nfToAdopt, *status) );
  56     if (U_FAILURE(*status)) {
  57         return NULL;
  58     }
  59     return (UAMeasureFormat*)measfmt.orphan();
  60 }
  61
  62
  63 U_CAPI void U_EXPORT2
  64 uameasfmt_close(UAMeasureFormat *measfmt)
  65 {
  66     delete (MeasureFormat*)measfmt;
  67 }
  68
  69 static MeasureUnit * createObjectForMeasureUnit(UAMeasureUnit unit, UErrorCode* status )
  70 {
  71     MeasureUnit * munit = NULL;
  72     switch (unit) {
  73         case UAMEASUNIT_ACCELERATION_G_FORCE:   munit = MeasureUnit::createGForce(*status);      break;
  74         case UAMEASUNIT_ACCELERATION_METER_PER_SECOND_SQUARED:  munit = MeasureUnit::createMeterPerSecondSquared(*status); break;
  75
  76         case UAMEASUNIT_ANGLE_DEGREE:           munit = MeasureUnit::createDegree(*status);      break;
  77         case UAMEASUNIT_ANGLE_ARC_MINUTE:       munit = MeasureUnit::createArcMinute(*status);   break;
  78         case UAMEASUNIT_ANGLE_ARC_SECOND:       munit = MeasureUnit::createArcSecond(*status);   break;
  79         case UAMEASUNIT_ANGLE_RADIAN:           munit = MeasureUnit::createRadian(*status);      break;
  80         case UAMEASUNIT_ANGLE_REVOLUTION:       munit = MeasureUnit::createRevolutionAngle(*status); break;
  81
  82         case UAMEASUNIT_AREA_SQUARE_METER:      munit = MeasureUnit::createSquareMeter(*status);     break;
  83         case UAMEASUNIT_AREA_SQUARE_KILOMETER:  munit = MeasureUnit::createSquareKilometer(*status); break;
  84         case UAMEASUNIT_AREA_SQUARE_FOOT:       munit = MeasureUnit::createSquareFoot(*status);      break;
  85         case UAMEASUNIT_AREA_SQUARE_MILE:       munit = MeasureUnit::createSquareMile(*status);      break;
  86         case UAMEASUNIT_AREA_ACRE:              munit = MeasureUnit::createAcre(*status);            break;
  87         case UAMEASUNIT_AREA_HECTARE:           munit = MeasureUnit::createHectare(*status);         break;
  88         case UAMEASUNIT_AREA_SQUARE_CENTIMETER: munit = MeasureUnit::createSquareCentimeter(*status); break;
  89         case UAMEASUNIT_AREA_SQUARE_INCH:       munit = MeasureUnit::createSquareInch(*status);      break;
  90         case UAMEASUNIT_AREA_SQUARE_YARD:       munit = MeasureUnit::createSquareYard(*status);      break;
  91
  92         case UAMEASUNIT_DURATION_YEAR:          munit = MeasureUnit::createYear(*status);        break;
  93         case UAMEASUNIT_DURATION_MONTH:         munit = MeasureUnit::createMonth(*status);       break;
  94         case UAMEASUNIT_DURATION_WEEK:          munit = MeasureUnit::createWeek(*status);        break;
  95         case UAMEASUNIT_DURATION_DAY:           munit = MeasureUnit::createDay(*status);         break;
  96         case UAMEASUNIT_DURATION_HOUR:          munit = MeasureUnit::createHour(*status);        break;
  97         case UAMEASUNIT_DURATION_MINUTE:        munit = MeasureUnit::createMinute(*status);      break;
  98         case UAMEASUNIT_DURATION_SECOND:        munit = MeasureUnit::createSecond(*status);      break;
  99         case UAMEASUNIT_DURATION_MILLISECOND:   munit = MeasureUnit::createMillisecond(*status); break;
 100         case UAMEASUNIT_DURATION_MICROSECOND:   munit = MeasureUnit::createMicrosecond(*status); break;
 101         case UAMEASUNIT_DURATION_NANOSECOND:    munit = MeasureUnit::createNanosecond(*status);  break;
 102         case UAMEASUNIT_DURATION_CENTURY:       munit = MeasureUnit::createCentury(*status);     break;
 103
 104         case UAMEASUNIT_LENGTH_METER:           munit = MeasureUnit::createMeter(*status);       break;
 105         case UAMEASUNIT_LENGTH_CENTIMETER:      munit = MeasureUnit::createCentimeter(*status);  break;
 106         case UAMEASUNIT_LENGTH_KILOMETER:       munit = MeasureUnit::createKilometer(*status);   break;
 107         case UAMEASUNIT_LENGTH_MILLIMETER:      munit = MeasureUnit::createMillimeter(*status);  break;
 108         case UAMEASUNIT_LENGTH_PICOMETER:       munit = MeasureUnit::createPicometer(*status);   break;
 109         case UAMEASUNIT_LENGTH_FOOT:            munit = MeasureUnit::createFoot(*status);        break;
 110         case UAMEASUNIT_LENGTH_INCH:            munit = MeasureUnit::createInch(*status);        break;
 111         case UAMEASUNIT_LENGTH_MILE:            munit = MeasureUnit::createMile(*status);        break;
 112         case UAMEASUNIT_LENGTH_YARD:            munit = MeasureUnit::createYard(*status);        break;
 113         case UAMEASUNIT_LENGTH_LIGHT_YEAR:      munit = MeasureUnit::createLightYear(*status);   break;
 114         case UAMEASUNIT_LENGTH_DECIMETER:       munit = MeasureUnit::createDecimeter(*status);   break;
 115         case UAMEASUNIT_LENGTH_MICROMETER:      munit = MeasureUnit::createMicrometer(*status);  break;
 116         case UAMEASUNIT_LENGTH_NANOMETER:       munit = MeasureUnit::createNanometer(*status);   break;
 117         case UAMEASUNIT_LENGTH_NAUTICAL_MILE:   munit = MeasureUnit::createNauticalMile(*status); break;
 118         case UAMEASUNIT_LENGTH_FATHOM:          munit = MeasureUnit::createFathom(*status);      break;
 119         case UAMEASUNIT_LENGTH_FURLONG:         munit = MeasureUnit::createFurlong(*status);     break;
 120         case UAMEASUNIT_LENGTH_ASTRONOMICAL_UNIT: munit = MeasureUnit::createAstronomicalUnit(*status); break;
 121         case UAMEASUNIT_LENGTH_PARSEC:          munit = MeasureUnit::createParsec(*status);      break;
 122         case UAMEASUNIT_LENGTH_MILE_SCANDINAVIAN: munit = MeasureUnit::createMileScandinavian(*status); break;
 123
 124         case UAMEASUNIT_MASS_GRAM:              munit = MeasureUnit::createGram(*status);        break;
 125         case UAMEASUNIT_MASS_KILOGRAM:          munit = MeasureUnit::createKilogram(*status);    break;
 126         case UAMEASUNIT_MASS_OUNCE:             munit = MeasureUnit::createOunce(*status);       break;
 127         case UAMEASUNIT_MASS_POUND:             munit = MeasureUnit::createPound(*status);       break;
 128         case UAMEASUNIT_MASS_STONE:             munit = MeasureUnit::createStone(*status);       break;
 129         case UAMEASUNIT_MASS_MICROGRAM:         munit = MeasureUnit::createMicrogram(*status);   break;
 130         case UAMEASUNIT_MASS_MILLIGRAM:         munit = MeasureUnit::createMilligram(*status);   break;
 131         case UAMEASUNIT_MASS_METRIC_TON:        munit = MeasureUnit::createMetricTon(*status);   break;
 132         case UAMEASUNIT_MASS_TON:               munit = MeasureUnit::createTon(*status);         break;
 133         case UAMEASUNIT_MASS_CARAT:             munit = MeasureUnit::createCarat(*status);       break;
 134         case UAMEASUNIT_MASS_OUNCE_TROY:        munit = MeasureUnit::createOunceTroy(*status);   break;
 135
 136         case UAMEASUNIT_POWER_WATT:             munit = MeasureUnit::createWatt(*status);        break;
 137         case UAMEASUNIT_POWER_KILOWATT:         munit = MeasureUnit::createKilowatt(*status);    break;
 138         case UAMEASUNIT_POWER_HORSEPOWER:       munit = MeasureUnit::createHorsepower(*status);  break;
 139         case UAMEASUNIT_POWER_MILLIWATT:        munit = MeasureUnit::createMilliwatt(*status);   break;
 140         case UAMEASUNIT_POWER_MEGAWATT:         munit = MeasureUnit::createMegawatt(*status);    break;
 141         case UAMEASUNIT_POWER_GIGAWATT:         munit = MeasureUnit::createGigawatt(*status);    break;
 142
 143         case UAMEASUNIT_PRESSURE_HECTOPASCAL:   munit = MeasureUnit::createHectopascal(*status); break;
 144         case UAMEASUNIT_PRESSURE_INCH_HG:       munit = MeasureUnit::createInchHg(*status);      break;
 145         case UAMEASUNIT_PRESSURE_MILLIBAR:      munit = MeasureUnit::createMillibar(*status);    break;
 146        case UAMEASUNIT_PRESSURE_MILLIMETER_OF_MERCURY:  munit = MeasureUnit::createMillimeterOfMercury(*status); break;
 147         case UAMEASUNIT_PRESSURE_POUND_PER_SQUARE_INCH: munit = MeasureUnit::createPoundPerSquareInch(*status);  break;
 148
 149         case UAMEASUNIT_SPEED_METER_PER_SECOND:   munit = MeasureUnit::createMeterPerSecond(*status);   break;
 150         case UAMEASUNIT_SPEED_KILOMETER_PER_HOUR: munit = MeasureUnit::createKilometerPerHour(*status); break;
 151         case UAMEASUNIT_SPEED_MILE_PER_HOUR:      munit = MeasureUnit::createMilePerHour(*status);      break;
 152         case UAMEASUNIT_SPEED_KNOT:               munit = MeasureUnit::createKnot(*status);      break;
 153
 154         case UAMEASUNIT_TEMPERATURE_CELSIUS:    munit = MeasureUnit::createCelsius(*status);     break;
 155         case UAMEASUNIT_TEMPERATURE_FAHRENHEIT: munit = MeasureUnit::createFahrenheit(*status);  break;
 156         case UAMEASUNIT_TEMPERATURE_KELVIN:     munit = MeasureUnit::createKelvin(*status);      break;
 157         case UAMEASUNIT_TEMPERATURE_GENERIC:    munit = MeasureUnit::createGenericTemperature(*status); break;
 158
 159         case UAMEASUNIT_VOLUME_LITER:           munit = MeasureUnit::createLiter(*status);          break;
 160         case UAMEASUNIT_VOLUME_CUBIC_KILOMETER: munit = MeasureUnit::createCubicKilometer(*status); break;
 161         case UAMEASUNIT_VOLUME_CUBIC_MILE:      munit = MeasureUnit::createCubicMile(*status);      break;
 162         case UAMEASUNIT_VOLUME_MILLILITER:      munit = MeasureUnit::createMilliliter(*status);     break;
 163         case UAMEASUNIT_VOLUME_CENTILITER:      munit = MeasureUnit::createCentiliter(*status);     break;
 164         case UAMEASUNIT_VOLUME_DECILITER:       munit = MeasureUnit::createDeciliter(*status);      break;
 165         case UAMEASUNIT_VOLUME_HECTOLITER:      munit = MeasureUnit::createHectoliter(*status);     break;
 166         case UAMEASUNIT_VOLUME_MEGALITER:       munit = MeasureUnit::createMegaliter(*status);      break;
 167         case UAMEASUNIT_VOLUME_CUBIC_CENTIMETER: munit = MeasureUnit::createCubicCentimeter(*status); break;
 168         case UAMEASUNIT_VOLUME_CUBIC_METER:     munit = MeasureUnit::createCubicMeter(*status);     break;
 169         case UAMEASUNIT_VOLUME_CUBIC_INCH:      munit = MeasureUnit::createCubicInch(*status);      break;
 170         case UAMEASUNIT_VOLUME_CUBIC_FOOT:      munit = MeasureUnit::createCubicFoot(*status);      break;
 171         case UAMEASUNIT_VOLUME_CUBIC_YARD:      munit = MeasureUnit::createCubicYard(*status);      break;
 172         case UAMEASUNIT_VOLUME_ACRE_FOOT:       munit = MeasureUnit::createAcreFoot(*status);       break;
 173         case UAMEASUNIT_VOLUME_BUSHEL:          munit = MeasureUnit::createBushel(*status);         break;
 174         case UAMEASUNIT_VOLUME_TEASPOON:        munit = MeasureUnit::createTeaspoon(*status);       break;
 175         case UAMEASUNIT_VOLUME_TABLESPOON:      munit = MeasureUnit::createTablespoon(*status);     break;
 176         case UAMEASUNIT_VOLUME_FLUID_OUNCE:     munit = MeasureUnit::createFluidOunce(*status);     break;
 177         case UAMEASUNIT_VOLUME_CUP:             munit = MeasureUnit::createCup(*status);            break;
 178         case UAMEASUNIT_VOLUME_PINT:            munit = MeasureUnit::createPint(*status);           break;
 179         case UAMEASUNIT_VOLUME_QUART:           munit = MeasureUnit::createQuart(*status);          break;
 180         case UAMEASUNIT_VOLUME_GALLON:          munit = MeasureUnit::createGallon(*status);         break;
 181         case UAMEASUNIT_VOLUME_CUP_METRIC:      munit = MeasureUnit::createCupMetric(*status);      break;
 182         case UAMEASUNIT_VOLUME_PINT_METRIC:     munit = MeasureUnit::createPintMetric(*status);     break;
 183         case UAMEASUNIT_VOLUME_GALLON_IMPERIAL: munit = MeasureUnit::createGallonImperial(*status); break;
 184
 185         case UAMEASUNIT_ENERGY_JOULE:           munit = MeasureUnit::createJoule(*status);          break;
 186         case UAMEASUNIT_ENERGY_KILOJOULE:       munit = MeasureUnit::createKilojoule(*status);      break;
 187         case UAMEASUNIT_ENERGY_CALORIE:         munit = MeasureUnit::createCalorie(*status);        break;
 188         case UAMEASUNIT_ENERGY_KILOCALORIE:     munit = MeasureUnit::createKilocalorie(*status);    break;
 189         case UAMEASUNIT_ENERGY_FOODCALORIE:     munit = MeasureUnit::createFoodcalorie(*status);    break;
 190         case UAMEASUNIT_ENERGY_KILOWATT_HOUR:   munit = MeasureUnit::createKilowattHour(*status);   break;
 191
 192         case UAMEASUNIT_CONSUMPTION_LITER_PER_KILOMETER: munit = MeasureUnit::createLiterPerKilometer(*status); break;
 193         case UAMEASUNIT_CONSUMPTION_MILE_PER_GALLON:     munit = MeasureUnit::createMilePerGallon(*status);     break;
 194         case UAMEASUNIT_CONSUMPTION_LITER_PER_100_KILOMETERs: munit = MeasureUnit::createLiterPer100Kilometers(*status); break;
 195         case UAMEASUNIT_CONSUMPTION_MILE_PER_GALLON_IMPERIAL: munit = MeasureUnit::createMilePerGallonImperial(*status); break;
 196
 197         case UAMEASUNIT_DIGITAL_BIT:            munit = MeasureUnit::createBit(*status);         break;
 198         case UAMEASUNIT_DIGITAL_BYTE:           munit = MeasureUnit::createByte(*status);        break;
 199         case UAMEASUNIT_DIGITAL_GIGABIT:        munit = MeasureUnit::createGigabit(*status);     break;
 200         case UAMEASUNIT_DIGITAL_GIGABYTE:       munit = MeasureUnit::createGigabyte(*status);    break;
 201         case UAMEASUNIT_DIGITAL_KILOBIT:        munit = MeasureUnit::createKilobit(*status);     break;
 202         case UAMEASUNIT_DIGITAL_KILOBYTE:       munit = MeasureUnit::createKilobyte(*status);    break;
 203         case UAMEASUNIT_DIGITAL_MEGABIT:        munit = MeasureUnit::createMegabit(*status);     break;
 204         case UAMEASUNIT_DIGITAL_MEGABYTE:       munit = MeasureUnit::createMegabyte(*status);    break;
 205         case UAMEASUNIT_DIGITAL_TERABIT:        munit = MeasureUnit::createTerabit(*status);     break;
 206         case UAMEASUNIT_DIGITAL_TERABYTE:       munit = MeasureUnit::createTerabyte(*status);    break;
 207
 208         case UAMEASUNIT_ELECTRIC_AMPERE:        munit = MeasureUnit::createAmpere(*status);      break;
 209         case UAMEASUNIT_ELECTRIC_MILLIAMPERE:   munit = MeasureUnit::createMilliampere(*status); break;
 210         case UAMEASUNIT_ELECTRIC_OHM:           munit = MeasureUnit::createOhm(*status);         break;
 211         case UAMEASUNIT_ELECTRIC_VOLT:          munit = MeasureUnit::createVolt(*status);        break;
 212
 213         case UAMEASUNIT_FREQUENCY_HERTZ:        munit = MeasureUnit::createHertz(*status);       break;
 214         case UAMEASUNIT_FREQUENCY_KILOHERTZ:    munit = MeasureUnit::createKilohertz(*status);   break;
 215         case UAMEASUNIT_FREQUENCY_MEGAHERTZ:    munit = MeasureUnit::createMegahertz(*status);   break;
 216         case UAMEASUNIT_FREQUENCY_GIGAHERTZ:    munit = MeasureUnit::createGigahertz(*status);   break;
 217
 218         case UAMEASUNIT_LIGHT_LUX:              munit = MeasureUnit::createLux(*status);         break;
 219
 220         case UAMEASUNIT_CONCENTRATION_KARAT:    munit = MeasureUnit::createKarat(*status);       break;
 221         case UAMEASUNIT_CONCENTRATION_MILLIGRAM_PER_DECILITER: munit = MeasureUnit::createMilligramPerDeciliter(*status); break;
 222         case UAMEASUNIT_CONCENTRATION_MILLIMOLE_PER_LITER:     munit = MeasureUnit::createMillimolePerLiter(*status);     break;
 223         case UAMEASUNIT_CONCENTRATION_PART_PER_MILLION:        munit = MeasureUnit::createPartPerMillion(*status);        break;
 224
 225         default: *status = U_ILLEGAL_ARGUMENT_ERROR; break;
 226     }
 227     return munit;
 228 }
 229
 230
 231 U_CAPI int32_t U_EXPORT2
 232 uameasfmt_format( const UAMeasureFormat* measfmt,
 233                   double            value,
 234                   UAMeasureUnit     unit,
 235                   UChar*            result,
 236                   int32_t           resultCapacity,
 237                   UErrorCode*       status )
 238 {
 239     return uameasfmt_formatGetPosition(measfmt, value, unit, result,
 240                                         resultCapacity, NULL, status);
 241 }
 242
 243 U_CAPI int32_t U_EXPORT2
 244 uameasfmt_formatGetPosition( const UAMeasureFormat* measfmt,
 245                             double            value,
 246                             UAMeasureUnit     unit,
 247                             UChar*            result,
 248                             int32_t           resultCapacity,
 249                             UFieldPosition*   pos,
 250                             UErrorCode*       status )
 251 {
 252     if (U_FAILURE(*status)) {
 253         return 0;
 254     }
 255     if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) ) {
 256         *status = U_ILLEGAL_ARGUMENT_ERROR;
 257         return 0;
 258     }
 259     if ( ((MeasureFormat*)measfmt)->getWidth() == UMEASFMT_WIDTH_NUMERIC &&
 260             (unit == UAMEASUNIT_TEMPERATURE_CELSIUS || unit == UAMEASUNIT_TEMPERATURE_FAHRENHEIT) ) {
 261         // Fix here until http://bugs.icu-project.org/trac/ticket/11593 is addressed
 262         unit = UAMEASUNIT_TEMPERATURE_GENERIC;
 263     }
 264     MeasureUnit * munit = createObjectForMeasureUnit(unit, status);
 265     if (U_FAILURE(*status)) {
 266         return 0;
 267     }
 268     LocalPointer<Measure> meas(new Measure(value, munit, *status));
 269     if (U_FAILURE(*status)) {
 270         return 0;
 271     }
 272     FieldPosition fp;
 273     if (pos != NULL) {
 274         int32_t field = pos->field;
 275         if (field < 0 || field >= UNUM_FIELD_COUNT) {
 276             *status = U_ILLEGAL_ARGUMENT_ERROR;
 277             return 0;
 278         }
 279         fp.setField(field);
 280     } else {
 281         fp.setField(FieldPosition::DONT_CARE);
 282     }
 283     Formattable fmt;
 284     fmt.adoptObject(meas.orphan());
 285     UnicodeString res;
 286     res.setTo(result, 0, resultCapacity);
 287     ((MeasureFormat*)measfmt)->format(fmt, res, fp, *status);
 288     if (pos != NULL) {
 289         pos->beginIndex = fp.getBeginIndex();
 290         pos->endIndex = fp.getEndIndex();
 291     }
 292     return res.extract(result, resultCapacity, *status);
 293 }
 294
 295 enum { kMeasuresMax = 8 }; // temporary limit, will add allocation later as necessary
 296
 297 U_CAPI int32_t U_EXPORT2
 298 uameasfmt_formatMultiple( const UAMeasureFormat* measfmt,
 299                           const UAMeasure*  measures,
 300                           int32_t           measureCount,
 301                           UChar*            result,
 302                           int32_t           resultCapacity,
 303                           UErrorCode*       status )
 304 {
 305     return uameasfmt_formatMultipleForFields(measfmt, measures, measureCount,
 306                                              result, resultCapacity, NULL, status);
 307 }
 308
 309 U_CAPI int32_t U_EXPORT2
 310 uameasfmt_formatMultipleForFields( const UAMeasureFormat* measfmt,
 311                                    const UAMeasure*  measures,
 312                                    int32_t           measureCount,
 313                                    UChar*            result,
 314                                    int32_t           resultCapacity,
 315                                    UFieldPositionIterator* fpositer,
 316                                    UErrorCode*       status )
 317 {
 318     if (U_FAILURE(*status)) {
 319         return 0;
 320     }
 321     if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) || measureCount <= 0 || measureCount > kMeasuresMax ) {
 322         *status = U_ILLEGAL_ARGUMENT_ERROR;
 323         return 0;
 324     }
 325     int32_t i;
 326     Measure * measurePtrs[kMeasuresMax];
 327     for (i = 0; i < kMeasuresMax && U_SUCCESS(*status); i++) {
 328         if (i < measureCount) {
 329             UAMeasureUnit unit = measures[i].unit;
 330             if ( ((MeasureFormat*)measfmt)->getWidth() == UMEASFMT_WIDTH_NUMERIC &&
 331                     (unit == UAMEASUNIT_TEMPERATURE_CELSIUS || unit == UAMEASUNIT_TEMPERATURE_FAHRENHEIT) ) {
 332                 // Fix here until http://bugs.icu-project.org/trac/ticket/11593 is addressed
 333                 unit = UAMEASUNIT_TEMPERATURE_GENERIC;
 334             }
 335             MeasureUnit * munit = createObjectForMeasureUnit(unit, status);
 336             measurePtrs[i] = new Measure(measures[i].value, munit, *status);
 337         } else {
 338             MeasureUnit * munit = MeasureUnit::createGForce(*status); // any unit will do
 339             measurePtrs[i] = new Measure(0, munit, *status);
 340         }
 341     }
 342     if (U_FAILURE(*status)) {
 343         while (i-- > 0) {
 344             delete measurePtrs[i];
 345         }
 346         return 0;
 347     }
 348     Measure measureObjs[kMeasuresMax] = { *measurePtrs[0], *measurePtrs[1], *measurePtrs[2], *measurePtrs[3],
 349                                           *measurePtrs[4], *measurePtrs[5], *measurePtrs[6], *measurePtrs[7] };
 350     UnicodeString res;
 351     res.setTo(result, 0, resultCapacity);
 352     ((MeasureFormat*)measfmt)->formatMeasures(measureObjs, measureCount, res, (FieldPositionIterator*)fpositer, *status);
 353     for (i = 0; i < kMeasuresMax; i++) {
 354         delete measurePtrs[i];
 355     }
 356     return res.extract(result, resultCapacity, *status);
 357 }
 358
 359 U_CAPI int32_t U_EXPORT2
 360 uameasfmt_getUnitName( const UAMeasureFormat* measfmt,
 361                        UAMeasureUnit unit,
 362                        UChar* result,
 363                        int32_t resultCapacity,
 364                        UErrorCode* status )
 365 {
 366     if (U_FAILURE(*status)) {
 367         return 0;
 368     }
 369     if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) ) {
 370         *status = U_ILLEGAL_ARGUMENT_ERROR;
 371         return 0;
 372     }
 373     LocalPointer<const MeasureUnit> munit(createObjectForMeasureUnit(unit, status));
 374     if (U_FAILURE(*status)) {
 375         return 0;
 376     }
 377     UnicodeString res;
 378     res.setTo(result, 0, resultCapacity);
 379     ((MeasureFormat*)measfmt)->getUnitName(munit.getAlias(), res);
 380     if (res.isBogus()) {
 381         *status = U_MISSING_RESOURCE_ERROR;
 382         return 0;
 383     }
 384     return res.extract(result, resultCapacity, *status);
 385 }
 386
 387 U_CAPI int32_t U_EXPORT2
 388 uameasfmt_getMultipleUnitNames( const UAMeasureFormat* measfmt,
 389                                 const UAMeasureUnit* units,
 390                                 int32_t unitCount,
 391                                 UAMeasureNameListStyle listStyle,
 392                                 UChar* result,
 393                                 int32_t resultCapacity,
 394                                 UErrorCode* status )
 395 {
 396     if (U_FAILURE(*status)) {
 397         return 0;
 398     }
 399     if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) || unitCount <= 0 || unitCount > kMeasuresMax ) {
 400         *status = U_ILLEGAL_ARGUMENT_ERROR;
 401         return 0;
 402     }
 403     int32_t i;
 404     const MeasureUnit * unitPtrs[kMeasuresMax];
 405     for (i = 0; i < unitCount && U_SUCCESS(*status); i++) {
 406         unitPtrs[i] = createObjectForMeasureUnit(units[i], status);
 407     }
 408     if (U_FAILURE(*status)) {
 409         while (i-- > 0) {
 410             delete unitPtrs[i];
 411         }
 412         return 0;
 413     }
 414     UnicodeString res;
 415     res.setTo(result, 0, resultCapacity);
 416     ((MeasureFormat*)measfmt)->getMultipleUnitNames(unitPtrs, unitCount, listStyle, res);
 417     for (i = 0; i < unitCount; i++) {
 418         delete unitPtrs[i];
 419     }
 420     if (res.isBogus()) {
 421         *status = U_MISSING_RESOURCE_ERROR;
 422         return 0;
 423     }
 424     return res.extract(result, resultCapacity, *status);
 425 }
 426
 427 // Temporary hack until we can use the forthcoming C++ MeasureUnitPreferences class for this
 428 typedef struct {
 429     const char*     key;
 430     int32_t         count;
 431     UAMeasureUnit   units[2];
 432 } KeyToUnits;
 433 static const KeyToUnits keyToUnits[] = {
 434     {   "acre",                     1,  { UAMEASUNIT_AREA_ACRE }   },
 435     {   "celsius",                  1,  { UAMEASUNIT_TEMPERATURE_CELSIUS }   },
 436     {   "centimeter",               1,  { UAMEASUNIT_LENGTH_CENTIMETER }   },
 437     {   "fahrenheit",               1,  { UAMEASUNIT_TEMPERATURE_FAHRENHEIT }   },
 438     {   "foodcalorie",              1,  { UAMEASUNIT_ENERGY_FOODCALORIE }   },
 439     {   "foot",                     1,  { UAMEASUNIT_LENGTH_FOOT }   },
 440     {   "foot inch",                2,  { UAMEASUNIT_LENGTH_FOOT, UAMEASUNIT_LENGTH_INCH }   },
 441     {   "gallon",                   1,  { UAMEASUNIT_VOLUME_GALLON }   },
 442     {   "gram",                     1,  { UAMEASUNIT_MASS_GRAM }   },
 443     {   "hectare",                  1,  { UAMEASUNIT_AREA_HECTARE }   },
 444     {   "hectopascal",              1,  { UAMEASUNIT_PRESSURE_HECTOPASCAL }   },
 445     {   "inch",                     1,  { UAMEASUNIT_LENGTH_INCH }   },
 446     {   "inch-hg",                  1,  { UAMEASUNIT_PRESSURE_INCH_HG }   },
 447     {   "kilocalorie",              1,  { UAMEASUNIT_ENERGY_KILOCALORIE }   },
 448     {   "kilogram",                 1,  { UAMEASUNIT_MASS_KILOGRAM }   },
 449     {   "kilogram gram",            2,  { UAMEASUNIT_MASS_KILOGRAM, UAMEASUNIT_MASS_GRAM }   },
 450     {   "kilometer",                1,  { UAMEASUNIT_LENGTH_KILOMETER }   },
 451     {   "kilometer-per-hour",       1,  { UAMEASUNIT_SPEED_KILOMETER_PER_HOUR }   },
 452     {   "liter-per-100kilometers",  1,  { UAMEASUNIT_CONSUMPTION_LITER_PER_100_KILOMETERs }   },
 453     {   "liter-per-kilometer",      1,  { UAMEASUNIT_CONSUMPTION_LITER_PER_KILOMETER }   },
 454     {   "liter",                    1,  { UAMEASUNIT_VOLUME_LITER }   },
 455     {   "meter",                    1,  { UAMEASUNIT_LENGTH_METER }   },
 456     {   "meter centimeter",         2,  { UAMEASUNIT_LENGTH_METER, UAMEASUNIT_LENGTH_CENTIMETER }   },
 457     {   "meter-per-second",         1,  { UAMEASUNIT_SPEED_METER_PER_SECOND }   },
 458     {   "mile",                     1,  { UAMEASUNIT_LENGTH_MILE }   },
 459     {   "mile-per-gallon",          1,  { UAMEASUNIT_CONSUMPTION_MILE_PER_GALLON }   },
 460     {   "mile-per-gallon-imperial", 1,  { UAMEASUNIT_CONSUMPTION_MILE_PER_GALLON_IMPERIAL }   },
 461     {   "mile-per-hour",            1,  { UAMEASUNIT_SPEED_MILE_PER_HOUR }   },
 462     {   "mile-scandinavian",        1,  { UAMEASUNIT_LENGTH_MILE_SCANDINAVIAN }   },
 463     {   "millibar",                 1,  { UAMEASUNIT_PRESSURE_MILLIBAR }   },
 464     {   "milligram-per-deciliter",  1,  { UAMEASUNIT_CONCENTRATION_MILLIGRAM_PER_DECILITER }   },
 465     {   "millimeter",               1,  { UAMEASUNIT_LENGTH_MILLIMETER }   },
 466     {   "millimeter-of-mercury",    1,  { UAMEASUNIT_PRESSURE_MILLIMETER_OF_MERCURY }   },
 467     {   "millimole-per-liter",      1,  { UAMEASUNIT_CONCENTRATION_MILLIMOLE_PER_LITER }   },
 468     {   "minute second",            2,  { UAMEASUNIT_DURATION_MINUTE, UAMEASUNIT_DURATION_SECOND }   },
 469     {   "pound",                    1,  { UAMEASUNIT_MASS_POUND }   },
 470     {   "pound ounce",              2,  { UAMEASUNIT_MASS_POUND, UAMEASUNIT_MASS_OUNCE }   },
 471     {   "stone pound",              2,  { UAMEASUNIT_MASS_STONE, UAMEASUNIT_MASS_POUND }   },
 472     {   "yard",                     1,  { UAMEASUNIT_LENGTH_YARD }   },
 473     {   "year-person month-person", 2,  { UAMEASUNIT_DURATION_YEAR, UAMEASUNIT_DURATION_MONTH }   },
 474 };
 475 enum { kKeyToUnitsCount = UPRV_LENGTHOF(keyToUnits) };
 476
 477 enum { kCombinedKeyMax = 64 };
 478
 479 static int compareKeyToUnits(const void* searchKey, const void* tableEntry) {
 480     return uprv_strncmp(((const KeyToUnits*)searchKey)->key, ((const KeyToUnits*)tableEntry)->key, kCombinedKeyMax);
 481 }
 482
 483 U_CAPI int32_t U_EXPORT2
 484 uameasfmt_getUnitsForUsage( const char*     locale,
 485                             const char*     category,
 486                             const char*     usage,
 487                             UAMeasureUnit*  units,
 488                             int32_t         unitsCapacity,
 489                             UErrorCode*     status )
 490 {
 491     if (U_FAILURE(*status)) {
 492         return 0;
 493     }
 494     if ( category==NULL || ((units==NULL)? unitsCapacity!=0: unitsCapacity<0) ) {
 495         *status = U_ILLEGAL_ARGUMENT_ERROR;
 496         return 0;
 497     }
 498     char combinedKey[kCombinedKeyMax+1] = "";
 499     char* combinedKeyPtr;
 500     uprv_strncat(combinedKey, category, kCombinedKeyMax);
 501     if (usage != NULL) {
 502         uprv_strncat(combinedKey, "-", kCombinedKeyMax-uprv_strlen(combinedKey));
 503         uprv_strncat(combinedKey, usage, kCombinedKeyMax-uprv_strlen(combinedKey));
 504     }
 505
 506     // get unitPreferenceData bundle
 507     UResourceBundle *prefb = ures_openDirect(NULL, "supplementalData", status);
 508     ures_getByKey(prefb, "unitPreferenceData", prefb, status);
 509     if (U_FAILURE(*status)) {
 510         return 0;
 511     }
 512
 513     // Get region to use
 514     char region[ULOC_COUNTRY_CAPACITY];
 515     (void)ulocimp_getRegionForSupplementalData(locale, TRUE, region, sizeof(region), status);
 516     if (U_FAILURE(*status)) {
 517         return 0;
 518     }
 519
 520     UResourceBundle *unitb = NULL;
 521     UErrorCode localStatus = U_ZERO_ERROR;
 522     int32_t retval = 0;
 523     UResourceBundle *regb = ures_getByKey(prefb, region, NULL, &localStatus);
 524     if (U_SUCCESS(localStatus)) {
 525         unitb = ures_getByKey(regb, combinedKey, unitb, &localStatus);
 526         if (U_FAILURE(localStatus)) {
 527             combinedKeyPtr = uprv_strstr(combinedKey, "-informal");
 528             if (combinedKeyPtr != NULL) {
 529                 *combinedKeyPtr = 0;
 530                 localStatus = U_ZERO_ERROR;
 531                 unitb = ures_getByKey(regb, combinedKey, unitb, &localStatus);
 532             }
 533         }
 534     } else {
 535         combinedKeyPtr = uprv_strstr(combinedKey, "-informal");
 536         if (combinedKeyPtr != NULL) {
 537             *combinedKeyPtr = 0;
 538         }
 539     }
 540     if (U_FAILURE(localStatus)) {
 541         localStatus = U_ZERO_ERROR;
 542         regb = ures_getByKey(prefb, "001", regb, &localStatus);
 543         if (U_SUCCESS(localStatus)) {
 544             unitb = ures_getByKey(regb, combinedKey, unitb, &localStatus);
 545             if (U_FAILURE(localStatus)) {
 546                 combinedKeyPtr = uprv_strstr(combinedKey, "-small");
 547                 if (combinedKeyPtr == NULL) {
 548                     combinedKeyPtr = uprv_strstr(combinedKey, "-large");
 549                 }
 550                 if (combinedKeyPtr != NULL) {
 551                     *combinedKeyPtr = 0;
 552                     localStatus = U_ZERO_ERROR;
 553                     unitb = ures_getByKey(regb, combinedKey, unitb, &localStatus);
 554                 }
 555             }
 556         }
 557     }
 558     if (U_FAILURE(localStatus)) {
 559         *status = localStatus;
 560     } else {
 561         int32_t keyLen = kCombinedKeyMax;
 562         const char* unitsKey = ures_getUTF8String(unitb, combinedKey, &keyLen, FALSE, status);
 563         if (U_SUCCESS(*status)) {
 564             KeyToUnits  searchKey = { unitsKey, 0, { (UAMeasureUnit)0 } };
 565             const KeyToUnits* keyToUnitsPtr = (const KeyToUnits*)bsearch(&searchKey, keyToUnits, kKeyToUnitsCount,
 566                                                                         sizeof(KeyToUnits), compareKeyToUnits);
 567             if (keyToUnitsPtr == NULL) {
 568                 *status = U_MISSING_RESOURCE_ERROR;
 569             } else {
 570                 retval = keyToUnitsPtr->count;
 571                 if (units != NULL) {
 572                     if (retval > unitsCapacity) {
 573                         *status = U_BUFFER_OVERFLOW_ERROR;
 574                     } else {
 575                         units[0] = keyToUnitsPtr->units[0];
 576                         if (retval > 1) {
 577                             units[1] = keyToUnitsPtr->units[1];
 578                         }
 579                     }
 580                 }
 581             }
 582         }
 583     }
 584
 585     ures_close(unitb);
 586     ures_close(regb);
 587     ures_close(prefb);
 588
 589     return retval;
 590 }
 591
 592 U_CAPI const char * U_EXPORT2
 593 uameasfmt_getUnitCategory(UAMeasureUnit unit,
 594                           UErrorCode* status )
 595 {
 596     if (U_FAILURE(*status)) {
 597         return NULL;
 598     }
 599     LocalPointer<const MeasureUnit> munit(createObjectForMeasureUnit(unit, status));
 600     if (U_FAILURE(*status)) {
 601         return NULL;
 602     }
 603     return munit->getType();
 604 }
 605
 606 #endif /* #if !UCONFIG_NO_FORMATTING */