diff options
Diffstat (limited to 'intl/icu/source/i18n/measunit.cpp')
| -rw-r--r-- | intl/icu/source/i18n/measunit.cpp | 1293 |
1 files changed, 1293 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/measunit.cpp b/intl/icu/source/i18n/measunit.cpp new file mode 100644 index 000000000..d780b80ce --- /dev/null +++ b/intl/icu/source/i18n/measunit.cpp @@ -0,0 +1,1293 @@ +// Copyright (C) 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* +********************************************************************** +* Copyright (c) 2004-2016, International Business Machines +* Corporation and others. All Rights Reserved. +********************************************************************** +* Author: Alan Liu +* Created: April 26, 2004 +* Since: ICU 3.0 +********************************************************************** +*/ +#include "utypeinfo.h" // for 'typeid' to work + +#include "unicode/measunit.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/uenum.h" +#include "ustrenum.h" +#include "cstring.h" +#include "uassert.h" + +U_NAMESPACE_BEGIN + +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MeasureUnit) + +// All code between the "Start generated code" comment and +// the "End generated code" comment is auto generated code +// and must not be edited manually. For instructions on how to correctly +// update this code, refer to: +// http://site.icu-project.org/design/formatting/measureformat/updating-measure-unit +// +// Start generated code + +static const int32_t gOffsets[] = { + 0, + 2, + 7, + 16, + 20, + 24, + 28, + 288, + 298, + 309, + 313, + 319, + 323, + 342, + 343, + 354, + 360, + 365, + 369, + 373, + 398 +}; + +static const int32_t gIndexes[] = { + 0, + 2, + 7, + 16, + 20, + 24, + 28, + 28, + 38, + 49, + 53, + 59, + 63, + 82, + 83, + 94, + 100, + 105, + 109, + 113, + 138 +}; + +// Must be sorted alphabetically. +static const char * const gTypes[] = { + "acceleration", + "angle", + "area", + "concentr", + "consumption", + "coordinate", + "currency", + "digital", + "duration", + "electric", + "energy", + "frequency", + "length", + "light", + "mass", + "power", + "pressure", + "speed", + "temperature", + "volume" +}; + +// Must be grouped by type and sorted alphabetically within each type. +static const char * const gSubTypes[] = { + "g-force", + "meter-per-second-squared", + "arc-minute", + "arc-second", + "degree", + "radian", + "revolution", + "acre", + "hectare", + "square-centimeter", + "square-foot", + "square-inch", + "square-kilometer", + "square-meter", + "square-mile", + "square-yard", + "karat", + "milligram-per-deciliter", + "millimole-per-liter", + "part-per-million", + "liter-per-100kilometers", + "liter-per-kilometer", + "mile-per-gallon", + "mile-per-gallon-imperial", + "east", + "north", + "south", + "west", + "ADP", + "AED", + "AFA", + "AFN", + "ALL", + "AMD", + "ANG", + "AOA", + "AON", + "AOR", + "ARA", + "ARP", + "ARS", + "ATS", + "AUD", + "AWG", + "AYM", + "AZM", + "AZN", + "BAD", + "BAM", + "BBD", + "BDT", + "BEC", + "BEF", + "BEL", + "BGL", + "BGN", + "BHD", + "BIF", + "BMD", + "BND", + "BOB", + "BOV", + "BRC", + "BRE", + "BRL", + "BRN", + "BRR", + "BSD", + "BTN", + "BWP", + "BYB", + "BYR", + "BZD", + "CAD", + "CDF", + "CHC", + "CHE", + "CHF", + "CHW", + "CLF", + "CLP", + "CNY", + "COP", + "COU", + "CRC", + "CSD", + "CSK", + "CUC", + "CUP", + "CVE", + "CYP", + "CZK", + "DDM", + "DEM", + "DJF", + "DKK", + "DOP", + "DZD", + "ECS", + "ECV", + "EEK", + "EGP", + "ERN", + "ESA", + "ESB", + "ESP", + "ETB", + "EUR", + "FIM", + "FJD", + "FKP", + "FRF", + "GBP", + "GEK", + "GEL", + "GHC", + "GHP", + "GHS", + "GIP", + "GMD", + "GNF", + "GQE", + "GRD", + "GTQ", + "GWP", + "GYD", + "HKD", + "HNL", + "HRD", + "HRK", + "HTG", + "HUF", + "IDR", + "IEP", + "ILS", + "INR", + "IQD", + "IRR", + "ISK", + "ITL", + "JMD", + "JOD", + "JPY", + "KES", + "KGS", + "KHR", + "KMF", + "KPW", + "KRW", + "KWD", + "KYD", + "KZT", + "LAK", + "LBP", + "LKR", + "LRD", + "LSL", + "LTL", + "LTT", + "LUC", + "LUF", + "LUL", + "LVL", + "LVR", + "LYD", + "MAD", + "MDL", + "MGA", + "MGF", + "MKD", + "MLF", + "MMK", + "MNT", + "MOP", + "MRO", + "MTL", + "MUR", + "MVR", + "MWK", + "MXN", + "MXV", + "MYR", + "MZM", + "MZN", + "NAD", + "NGN", + "NIO", + "NLG", + "NOK", + "NPR", + "NZD", + "OMR", + "PAB", + "PEI", + "PEN", + "PES", + "PGK", + "PHP", + "PKR", + "PLN", + "PLZ", + "PTE", + "PYG", + "QAR", + "ROL", + "RON", + "RSD", + "RUB", + "RUR", + "RWF", + "SAR", + "SBD", + "SCR", + "SDD", + "SDG", + "SEK", + "SGD", + "SHP", + "SIT", + "SKK", + "SLL", + "SOS", + "SRD", + "SRG", + "SSP", + "STD", + "SVC", + "SYP", + "SZL", + "THB", + "TJR", + "TJS", + "TMM", + "TMT", + "TND", + "TOP", + "TPE", + "TRL", + "TRY", + "TTD", + "TWD", + "TZS", + "UAH", + "UAK", + "UGX", + "USD", + "USN", + "USS", + "UYI", + "UYU", + "UZS", + "VEB", + "VEF", + "VND", + "VUV", + "WST", + "XAF", + "XAG", + "XAU", + "XBA", + "XBB", + "XBC", + "XBD", + "XCD", + "XDR", + "XEU", + "XOF", + "XPD", + "XPF", + "XPT", + "XSU", + "XTS", + "XUA", + "XXX", + "YDD", + "YER", + "YUM", + "YUN", + "ZAL", + "ZAR", + "ZMK", + "ZMW", + "ZRN", + "ZRZ", + "ZWD", + "ZWL", + "ZWN", + "ZWR", + "bit", + "byte", + "gigabit", + "gigabyte", + "kilobit", + "kilobyte", + "megabit", + "megabyte", + "terabit", + "terabyte", + "century", + "day", + "hour", + "microsecond", + "millisecond", + "minute", + "month", + "nanosecond", + "second", + "week", + "year", + "ampere", + "milliampere", + "ohm", + "volt", + "calorie", + "foodcalorie", + "joule", + "kilocalorie", + "kilojoule", + "kilowatt-hour", + "gigahertz", + "hertz", + "kilohertz", + "megahertz", + "astronomical-unit", + "centimeter", + "decimeter", + "fathom", + "foot", + "furlong", + "inch", + "kilometer", + "light-year", + "meter", + "micrometer", + "mile", + "mile-scandinavian", + "millimeter", + "nanometer", + "nautical-mile", + "parsec", + "picometer", + "yard", + "lux", + "carat", + "gram", + "kilogram", + "metric-ton", + "microgram", + "milligram", + "ounce", + "ounce-troy", + "pound", + "stone", + "ton", + "gigawatt", + "horsepower", + "kilowatt", + "megawatt", + "milliwatt", + "watt", + "hectopascal", + "inch-hg", + "millibar", + "millimeter-of-mercury", + "pound-per-square-inch", + "kilometer-per-hour", + "knot", + "meter-per-second", + "mile-per-hour", + "celsius", + "fahrenheit", + "generic", + "kelvin", + "acre-foot", + "bushel", + "centiliter", + "cubic-centimeter", + "cubic-foot", + "cubic-inch", + "cubic-kilometer", + "cubic-meter", + "cubic-mile", + "cubic-yard", + "cup", + "cup-metric", + "deciliter", + "fluid-ounce", + "gallon", + "gallon-imperial", + "hectoliter", + "liter", + "megaliter", + "milliliter", + "pint", + "pint-metric", + "quart", + "tablespoon", + "teaspoon" +}; + +// Must be sorted by first value and then second value. +static int32_t unitPerUnitToSingleUnit[][4] = { + {330, 300, 17, 0}, + {332, 306, 17, 2}, + {334, 300, 17, 3}, + {334, 387, 4, 2}, + {334, 388, 4, 3}, + {348, 385, 3, 1}, + {351, 11, 16, 4}, + {390, 330, 4, 1} +}; + +MeasureUnit *MeasureUnit::createGForce(UErrorCode &status) { + return MeasureUnit::create(0, 0, status); +} + +MeasureUnit *MeasureUnit::createMeterPerSecondSquared(UErrorCode &status) { + return MeasureUnit::create(0, 1, status); +} + +MeasureUnit *MeasureUnit::createArcMinute(UErrorCode &status) { + return MeasureUnit::create(1, 0, status); +} + +MeasureUnit *MeasureUnit::createArcSecond(UErrorCode &status) { + return MeasureUnit::create(1, 1, status); +} + +MeasureUnit *MeasureUnit::createDegree(UErrorCode &status) { + return MeasureUnit::create(1, 2, status); +} + +MeasureUnit *MeasureUnit::createRadian(UErrorCode &status) { + return MeasureUnit::create(1, 3, status); +} + +MeasureUnit *MeasureUnit::createRevolutionAngle(UErrorCode &status) { + return MeasureUnit::create(1, 4, status); +} + +MeasureUnit *MeasureUnit::createAcre(UErrorCode &status) { + return MeasureUnit::create(2, 0, status); +} + +MeasureUnit *MeasureUnit::createHectare(UErrorCode &status) { + return MeasureUnit::create(2, 1, status); +} + +MeasureUnit *MeasureUnit::createSquareCentimeter(UErrorCode &status) { + return MeasureUnit::create(2, 2, status); +} + +MeasureUnit *MeasureUnit::createSquareFoot(UErrorCode &status) { + return MeasureUnit::create(2, 3, status); +} + +MeasureUnit *MeasureUnit::createSquareInch(UErrorCode &status) { + return MeasureUnit::create(2, 4, status); +} + +MeasureUnit *MeasureUnit::createSquareKilometer(UErrorCode &status) { + return MeasureUnit::create(2, 5, status); +} + +MeasureUnit *MeasureUnit::createSquareMeter(UErrorCode &status) { + return MeasureUnit::create(2, 6, status); +} + +MeasureUnit *MeasureUnit::createSquareMile(UErrorCode &status) { + return MeasureUnit::create(2, 7, status); +} + +MeasureUnit *MeasureUnit::createSquareYard(UErrorCode &status) { + return MeasureUnit::create(2, 8, status); +} + +MeasureUnit *MeasureUnit::createKarat(UErrorCode &status) { + return MeasureUnit::create(3, 0, status); +} + +MeasureUnit *MeasureUnit::createMilligramPerDeciliter(UErrorCode &status) { + return MeasureUnit::create(3, 1, status); +} + +MeasureUnit *MeasureUnit::createMillimolePerLiter(UErrorCode &status) { + return MeasureUnit::create(3, 2, status); +} + +MeasureUnit *MeasureUnit::createPartPerMillion(UErrorCode &status) { + return MeasureUnit::create(3, 3, status); +} + +MeasureUnit *MeasureUnit::createLiterPer100Kilometers(UErrorCode &status) { + return MeasureUnit::create(4, 0, status); +} + +MeasureUnit *MeasureUnit::createLiterPerKilometer(UErrorCode &status) { + return MeasureUnit::create(4, 1, status); +} + +MeasureUnit *MeasureUnit::createMilePerGallon(UErrorCode &status) { + return MeasureUnit::create(4, 2, status); +} + +MeasureUnit *MeasureUnit::createMilePerGallonImperial(UErrorCode &status) { + return MeasureUnit::create(4, 3, status); +} + +MeasureUnit *MeasureUnit::createEast(UErrorCode &status) { + return MeasureUnit::create(5, 0, status); +} + +MeasureUnit *MeasureUnit::createNorth(UErrorCode &status) { + return MeasureUnit::create(5, 1, status); +} + +MeasureUnit *MeasureUnit::createSouth(UErrorCode &status) { + return MeasureUnit::create(5, 2, status); +} + +MeasureUnit *MeasureUnit::createWest(UErrorCode &status) { + return MeasureUnit::create(5, 3, status); +} + +MeasureUnit *MeasureUnit::createBit(UErrorCode &status) { + return MeasureUnit::create(7, 0, status); +} + +MeasureUnit *MeasureUnit::createByte(UErrorCode &status) { + return MeasureUnit::create(7, 1, status); +} + +MeasureUnit *MeasureUnit::createGigabit(UErrorCode &status) { + return MeasureUnit::create(7, 2, status); +} + +MeasureUnit *MeasureUnit::createGigabyte(UErrorCode &status) { + return MeasureUnit::create(7, 3, status); +} + +MeasureUnit *MeasureUnit::createKilobit(UErrorCode &status) { + return MeasureUnit::create(7, 4, status); +} + +MeasureUnit *MeasureUnit::createKilobyte(UErrorCode &status) { + return MeasureUnit::create(7, 5, status); +} + +MeasureUnit *MeasureUnit::createMegabit(UErrorCode &status) { + return MeasureUnit::create(7, 6, status); +} + +MeasureUnit *MeasureUnit::createMegabyte(UErrorCode &status) { + return MeasureUnit::create(7, 7, status); +} + +MeasureUnit *MeasureUnit::createTerabit(UErrorCode &status) { + return MeasureUnit::create(7, 8, status); +} + +MeasureUnit *MeasureUnit::createTerabyte(UErrorCode &status) { + return MeasureUnit::create(7, 9, status); +} + +MeasureUnit *MeasureUnit::createCentury(UErrorCode &status) { + return MeasureUnit::create(8, 0, status); +} + +MeasureUnit *MeasureUnit::createDay(UErrorCode &status) { + return MeasureUnit::create(8, 1, status); +} + +MeasureUnit *MeasureUnit::createHour(UErrorCode &status) { + return MeasureUnit::create(8, 2, status); +} + +MeasureUnit *MeasureUnit::createMicrosecond(UErrorCode &status) { + return MeasureUnit::create(8, 3, status); +} + +MeasureUnit *MeasureUnit::createMillisecond(UErrorCode &status) { + return MeasureUnit::create(8, 4, status); +} + +MeasureUnit *MeasureUnit::createMinute(UErrorCode &status) { + return MeasureUnit::create(8, 5, status); +} + +MeasureUnit *MeasureUnit::createMonth(UErrorCode &status) { + return MeasureUnit::create(8, 6, status); +} + +MeasureUnit *MeasureUnit::createNanosecond(UErrorCode &status) { + return MeasureUnit::create(8, 7, status); +} + +MeasureUnit *MeasureUnit::createSecond(UErrorCode &status) { + return MeasureUnit::create(8, 8, status); +} + +MeasureUnit *MeasureUnit::createWeek(UErrorCode &status) { + return MeasureUnit::create(8, 9, status); +} + +MeasureUnit *MeasureUnit::createYear(UErrorCode &status) { + return MeasureUnit::create(8, 10, status); +} + +MeasureUnit *MeasureUnit::createAmpere(UErrorCode &status) { + return MeasureUnit::create(9, 0, status); +} + +MeasureUnit *MeasureUnit::createMilliampere(UErrorCode &status) { + return MeasureUnit::create(9, 1, status); +} + +MeasureUnit *MeasureUnit::createOhm(UErrorCode &status) { + return MeasureUnit::create(9, 2, status); +} + +MeasureUnit *MeasureUnit::createVolt(UErrorCode &status) { + return MeasureUnit::create(9, 3, status); +} + +MeasureUnit *MeasureUnit::createCalorie(UErrorCode &status) { + return MeasureUnit::create(10, 0, status); +} + +MeasureUnit *MeasureUnit::createFoodcalorie(UErrorCode &status) { + return MeasureUnit::create(10, 1, status); +} + +MeasureUnit *MeasureUnit::createJoule(UErrorCode &status) { + return MeasureUnit::create(10, 2, status); +} + +MeasureUnit *MeasureUnit::createKilocalorie(UErrorCode &status) { + return MeasureUnit::create(10, 3, status); +} + +MeasureUnit *MeasureUnit::createKilojoule(UErrorCode &status) { + return MeasureUnit::create(10, 4, status); +} + +MeasureUnit *MeasureUnit::createKilowattHour(UErrorCode &status) { + return MeasureUnit::create(10, 5, status); +} + +MeasureUnit *MeasureUnit::createGigahertz(UErrorCode &status) { + return MeasureUnit::create(11, 0, status); +} + +MeasureUnit *MeasureUnit::createHertz(UErrorCode &status) { + return MeasureUnit::create(11, 1, status); +} + +MeasureUnit *MeasureUnit::createKilohertz(UErrorCode &status) { + return MeasureUnit::create(11, 2, status); +} + +MeasureUnit *MeasureUnit::createMegahertz(UErrorCode &status) { + return MeasureUnit::create(11, 3, status); +} + +MeasureUnit *MeasureUnit::createAstronomicalUnit(UErrorCode &status) { + return MeasureUnit::create(12, 0, status); +} + +MeasureUnit *MeasureUnit::createCentimeter(UErrorCode &status) { + return MeasureUnit::create(12, 1, status); +} + +MeasureUnit *MeasureUnit::createDecimeter(UErrorCode &status) { + return MeasureUnit::create(12, 2, status); +} + +MeasureUnit *MeasureUnit::createFathom(UErrorCode &status) { + return MeasureUnit::create(12, 3, status); +} + +MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) { + return MeasureUnit::create(12, 4, status); +} + +MeasureUnit *MeasureUnit::createFurlong(UErrorCode &status) { + return MeasureUnit::create(12, 5, status); +} + +MeasureUnit *MeasureUnit::createInch(UErrorCode &status) { + return MeasureUnit::create(12, 6, status); +} + +MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) { + return MeasureUnit::create(12, 7, status); +} + +MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) { + return MeasureUnit::create(12, 8, status); +} + +MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) { + return MeasureUnit::create(12, 9, status); +} + +MeasureUnit *MeasureUnit::createMicrometer(UErrorCode &status) { + return MeasureUnit::create(12, 10, status); +} + +MeasureUnit *MeasureUnit::createMile(UErrorCode &status) { + return MeasureUnit::create(12, 11, status); +} + +MeasureUnit *MeasureUnit::createMileScandinavian(UErrorCode &status) { + return MeasureUnit::create(12, 12, status); +} + +MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) { + return MeasureUnit::create(12, 13, status); +} + +MeasureUnit *MeasureUnit::createNanometer(UErrorCode &status) { + return MeasureUnit::create(12, 14, status); +} + +MeasureUnit *MeasureUnit::createNauticalMile(UErrorCode &status) { + return MeasureUnit::create(12, 15, status); +} + +MeasureUnit *MeasureUnit::createParsec(UErrorCode &status) { + return MeasureUnit::create(12, 16, status); +} + +MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) { + return MeasureUnit::create(12, 17, status); +} + +MeasureUnit *MeasureUnit::createYard(UErrorCode &status) { + return MeasureUnit::create(12, 18, status); +} + +MeasureUnit *MeasureUnit::createLux(UErrorCode &status) { + return MeasureUnit::create(13, 0, status); +} + +MeasureUnit *MeasureUnit::createCarat(UErrorCode &status) { + return MeasureUnit::create(14, 0, status); +} + +MeasureUnit *MeasureUnit::createGram(UErrorCode &status) { + return MeasureUnit::create(14, 1, status); +} + +MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) { + return MeasureUnit::create(14, 2, status); +} + +MeasureUnit *MeasureUnit::createMetricTon(UErrorCode &status) { + return MeasureUnit::create(14, 3, status); +} + +MeasureUnit *MeasureUnit::createMicrogram(UErrorCode &status) { + return MeasureUnit::create(14, 4, status); +} + +MeasureUnit *MeasureUnit::createMilligram(UErrorCode &status) { + return MeasureUnit::create(14, 5, status); +} + +MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) { + return MeasureUnit::create(14, 6, status); +} + +MeasureUnit *MeasureUnit::createOunceTroy(UErrorCode &status) { + return MeasureUnit::create(14, 7, status); +} + +MeasureUnit *MeasureUnit::createPound(UErrorCode &status) { + return MeasureUnit::create(14, 8, status); +} + +MeasureUnit *MeasureUnit::createStone(UErrorCode &status) { + return MeasureUnit::create(14, 9, status); +} + +MeasureUnit *MeasureUnit::createTon(UErrorCode &status) { + return MeasureUnit::create(14, 10, status); +} + +MeasureUnit *MeasureUnit::createGigawatt(UErrorCode &status) { + return MeasureUnit::create(15, 0, status); +} + +MeasureUnit *MeasureUnit::createHorsepower(UErrorCode &status) { + return MeasureUnit::create(15, 1, status); +} + +MeasureUnit *MeasureUnit::createKilowatt(UErrorCode &status) { + return MeasureUnit::create(15, 2, status); +} + +MeasureUnit *MeasureUnit::createMegawatt(UErrorCode &status) { + return MeasureUnit::create(15, 3, status); +} + +MeasureUnit *MeasureUnit::createMilliwatt(UErrorCode &status) { + return MeasureUnit::create(15, 4, status); +} + +MeasureUnit *MeasureUnit::createWatt(UErrorCode &status) { + return MeasureUnit::create(15, 5, status); +} + +MeasureUnit *MeasureUnit::createHectopascal(UErrorCode &status) { + return MeasureUnit::create(16, 0, status); +} + +MeasureUnit *MeasureUnit::createInchHg(UErrorCode &status) { + return MeasureUnit::create(16, 1, status); +} + +MeasureUnit *MeasureUnit::createMillibar(UErrorCode &status) { + return MeasureUnit::create(16, 2, status); +} + +MeasureUnit *MeasureUnit::createMillimeterOfMercury(UErrorCode &status) { + return MeasureUnit::create(16, 3, status); +} + +MeasureUnit *MeasureUnit::createPoundPerSquareInch(UErrorCode &status) { + return MeasureUnit::create(16, 4, status); +} + +MeasureUnit *MeasureUnit::createKilometerPerHour(UErrorCode &status) { + return MeasureUnit::create(17, 0, status); +} + +MeasureUnit *MeasureUnit::createKnot(UErrorCode &status) { + return MeasureUnit::create(17, 1, status); +} + +MeasureUnit *MeasureUnit::createMeterPerSecond(UErrorCode &status) { + return MeasureUnit::create(17, 2, status); +} + +MeasureUnit *MeasureUnit::createMilePerHour(UErrorCode &status) { + return MeasureUnit::create(17, 3, status); +} + +MeasureUnit *MeasureUnit::createCelsius(UErrorCode &status) { + return MeasureUnit::create(18, 0, status); +} + +MeasureUnit *MeasureUnit::createFahrenheit(UErrorCode &status) { + return MeasureUnit::create(18, 1, status); +} + +MeasureUnit *MeasureUnit::createGenericTemperature(UErrorCode &status) { + return MeasureUnit::create(18, 2, status); +} + +MeasureUnit *MeasureUnit::createKelvin(UErrorCode &status) { + return MeasureUnit::create(18, 3, status); +} + +MeasureUnit *MeasureUnit::createAcreFoot(UErrorCode &status) { + return MeasureUnit::create(19, 0, status); +} + +MeasureUnit *MeasureUnit::createBushel(UErrorCode &status) { + return MeasureUnit::create(19, 1, status); +} + +MeasureUnit *MeasureUnit::createCentiliter(UErrorCode &status) { + return MeasureUnit::create(19, 2, status); +} + +MeasureUnit *MeasureUnit::createCubicCentimeter(UErrorCode &status) { + return MeasureUnit::create(19, 3, status); +} + +MeasureUnit *MeasureUnit::createCubicFoot(UErrorCode &status) { + return MeasureUnit::create(19, 4, status); +} + +MeasureUnit *MeasureUnit::createCubicInch(UErrorCode &status) { + return MeasureUnit::create(19, 5, status); +} + +MeasureUnit *MeasureUnit::createCubicKilometer(UErrorCode &status) { + return MeasureUnit::create(19, 6, status); +} + +MeasureUnit *MeasureUnit::createCubicMeter(UErrorCode &status) { + return MeasureUnit::create(19, 7, status); +} + +MeasureUnit *MeasureUnit::createCubicMile(UErrorCode &status) { + return MeasureUnit::create(19, 8, status); +} + +MeasureUnit *MeasureUnit::createCubicYard(UErrorCode &status) { + return MeasureUnit::create(19, 9, status); +} + +MeasureUnit *MeasureUnit::createCup(UErrorCode &status) { + return MeasureUnit::create(19, 10, status); +} + +MeasureUnit *MeasureUnit::createCupMetric(UErrorCode &status) { + return MeasureUnit::create(19, 11, status); +} + +MeasureUnit *MeasureUnit::createDeciliter(UErrorCode &status) { + return MeasureUnit::create(19, 12, status); +} + +MeasureUnit *MeasureUnit::createFluidOunce(UErrorCode &status) { + return MeasureUnit::create(19, 13, status); +} + +MeasureUnit *MeasureUnit::createGallon(UErrorCode &status) { + return MeasureUnit::create(19, 14, status); +} + +MeasureUnit *MeasureUnit::createGallonImperial(UErrorCode &status) { + return MeasureUnit::create(19, 15, status); +} + +MeasureUnit *MeasureUnit::createHectoliter(UErrorCode &status) { + return MeasureUnit::create(19, 16, status); +} + +MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) { + return MeasureUnit::create(19, 17, status); +} + +MeasureUnit *MeasureUnit::createMegaliter(UErrorCode &status) { + return MeasureUnit::create(19, 18, status); +} + +MeasureUnit *MeasureUnit::createMilliliter(UErrorCode &status) { + return MeasureUnit::create(19, 19, status); +} + +MeasureUnit *MeasureUnit::createPint(UErrorCode &status) { + return MeasureUnit::create(19, 20, status); +} + +MeasureUnit *MeasureUnit::createPintMetric(UErrorCode &status) { + return MeasureUnit::create(19, 21, status); +} + +MeasureUnit *MeasureUnit::createQuart(UErrorCode &status) { + return MeasureUnit::create(19, 22, status); +} + +MeasureUnit *MeasureUnit::createTablespoon(UErrorCode &status) { + return MeasureUnit::create(19, 23, status); +} + +MeasureUnit *MeasureUnit::createTeaspoon(UErrorCode &status) { + return MeasureUnit::create(19, 24, status); +} + +// End generated code + +static int32_t binarySearch( + const char * const * array, int32_t start, int32_t end, const char * key) { + while (start < end) { + int32_t mid = (start + end) / 2; + int32_t cmp = uprv_strcmp(array[mid], key); + if (cmp < 0) { + start = mid + 1; + continue; + } + if (cmp == 0) { + return mid; + } + end = mid; + } + return -1; +} + +MeasureUnit::MeasureUnit(const MeasureUnit &other) + : fTypeId(other.fTypeId), fSubTypeId(other.fSubTypeId) { + uprv_strcpy(fCurrency, other.fCurrency); +} + +MeasureUnit &MeasureUnit::operator=(const MeasureUnit &other) { + if (this == &other) { + return *this; + } + fTypeId = other.fTypeId; + fSubTypeId = other.fSubTypeId; + uprv_strcpy(fCurrency, other.fCurrency); + return *this; +} + +UObject *MeasureUnit::clone() const { + return new MeasureUnit(*this); +} + +MeasureUnit::~MeasureUnit() { +} + +const char *MeasureUnit::getType() const { + return gTypes[fTypeId]; +} + +const char *MeasureUnit::getSubtype() const { + return fCurrency[0] == 0 ? gSubTypes[getOffset()] : fCurrency; +} + +UBool MeasureUnit::operator==(const UObject& other) const { + if (this == &other) { // Same object, equal + return TRUE; + } + if (typeid(*this) != typeid(other)) { // Different types, not equal + return FALSE; + } + const MeasureUnit &rhs = static_cast<const MeasureUnit&>(other); + return ( + fTypeId == rhs.fTypeId + && fSubTypeId == rhs.fSubTypeId + && uprv_strcmp(fCurrency, rhs.fCurrency) == 0); +} + +int32_t MeasureUnit::getIndex() const { + return gIndexes[fTypeId] + fSubTypeId; +} + +int32_t MeasureUnit::getAvailable( + MeasureUnit *dest, + int32_t destCapacity, + UErrorCode &errorCode) { + if (U_FAILURE(errorCode)) { + return 0; + } + if (destCapacity < UPRV_LENGTHOF(gSubTypes)) { + errorCode = U_BUFFER_OVERFLOW_ERROR; + return UPRV_LENGTHOF(gSubTypes); + } + int32_t idx = 0; + for (int32_t typeIdx = 0; typeIdx < UPRV_LENGTHOF(gTypes); ++typeIdx) { + int32_t len = gOffsets[typeIdx + 1] - gOffsets[typeIdx]; + for (int32_t subTypeIdx = 0; subTypeIdx < len; ++subTypeIdx) { + dest[idx].setTo(typeIdx, subTypeIdx); + ++idx; + } + } + U_ASSERT(idx == UPRV_LENGTHOF(gSubTypes)); + return UPRV_LENGTHOF(gSubTypes); +} + +int32_t MeasureUnit::getAvailable( + const char *type, + MeasureUnit *dest, + int32_t destCapacity, + UErrorCode &errorCode) { + if (U_FAILURE(errorCode)) { + return 0; + } + int32_t typeIdx = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), type); + if (typeIdx == -1) { + return 0; + } + int32_t len = gOffsets[typeIdx + 1] - gOffsets[typeIdx]; + if (destCapacity < len) { + errorCode = U_BUFFER_OVERFLOW_ERROR; + return len; + } + for (int subTypeIdx = 0; subTypeIdx < len; ++subTypeIdx) { + dest[subTypeIdx].setTo(typeIdx, subTypeIdx); + } + return len; +} + +StringEnumeration* MeasureUnit::getAvailableTypes(UErrorCode &errorCode) { + UEnumeration *uenum = uenum_openCharStringsEnumeration( + gTypes, UPRV_LENGTHOF(gTypes), &errorCode); + if (U_FAILURE(errorCode)) { + uenum_close(uenum); + return NULL; + } + StringEnumeration *result = new UStringEnumeration(uenum); + if (result == NULL) { + errorCode = U_MEMORY_ALLOCATION_ERROR; + uenum_close(uenum); + return NULL; + } + return result; +} + +int32_t MeasureUnit::getIndexCount() { + return gIndexes[UPRV_LENGTHOF(gIndexes) - 1]; +} + +int32_t MeasureUnit::internalGetIndexForTypeAndSubtype(const char *type, const char *subtype) { + int32_t t = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), type); + if (t < 0) { + return t; + } + int32_t st = binarySearch(gSubTypes, gOffsets[t], gOffsets[t + 1], subtype); + if (st < 0) { + return st; + } + return gIndexes[t] + st - gOffsets[t]; +} + +MeasureUnit *MeasureUnit::resolveUnitPerUnit( + const MeasureUnit &unit, const MeasureUnit &perUnit) { + int32_t unitOffset = unit.getOffset(); + int32_t perUnitOffset = perUnit.getOffset(); + + // binary search for (unitOffset, perUnitOffset) + int32_t start = 0; + int32_t end = UPRV_LENGTHOF(unitPerUnitToSingleUnit); + while (start < end) { + int32_t mid = (start + end) / 2; + int32_t *midRow = unitPerUnitToSingleUnit[mid]; + if (unitOffset < midRow[0]) { + end = mid; + } else if (unitOffset > midRow[0]) { + start = mid + 1; + } else if (perUnitOffset < midRow[1]) { + end = mid; + } else if (perUnitOffset > midRow[1]) { + start = mid + 1; + } else { + // We found a resolution for our unit / per-unit combo + // return it. + return new MeasureUnit(midRow[2], midRow[3]); + } + } + return NULL; +} + +MeasureUnit *MeasureUnit::create(int typeId, int subTypeId, UErrorCode &status) { + if (U_FAILURE(status)) { + return NULL; + } + MeasureUnit *result = new MeasureUnit(typeId, subTypeId); + if (result == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + } + return result; +} + +void MeasureUnit::initTime(const char *timeId) { + int32_t result = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), "duration"); + U_ASSERT(result != -1); + fTypeId = result; + result = binarySearch(gSubTypes, gOffsets[fTypeId], gOffsets[fTypeId + 1], timeId); + U_ASSERT(result != -1); + fSubTypeId = result - gOffsets[fTypeId]; +} + +void MeasureUnit::initCurrency(const char *isoCurrency) { + int32_t result = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), "currency"); + U_ASSERT(result != -1); + fTypeId = result; + result = binarySearch( + gSubTypes, gOffsets[fTypeId], gOffsets[fTypeId + 1], isoCurrency); + if (result != -1) { + fSubTypeId = result - gOffsets[fTypeId]; + } else { + uprv_strncpy(fCurrency, isoCurrency, UPRV_LENGTHOF(fCurrency)); + fCurrency[3] = 0; + } +} + +void MeasureUnit::setTo(int32_t typeId, int32_t subTypeId) { + fTypeId = typeId; + fSubTypeId = subTypeId; + fCurrency[0] = 0; +} + +int32_t MeasureUnit::getOffset() const { + return gOffsets[fTypeId] + fSubTypeId; +} + +U_NAMESPACE_END + +#endif /* !UNCONFIG_NO_FORMATTING */ |