| /* | |
| ********************************************************************** | |
| * Copyright (c) 2004-2015, 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 "starboard/client_porting/poem/assert_poem.h" | |
| #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, | |
| 19, | |
| 279, | |
| 289, | |
| 300, | |
| 304, | |
| 310, | |
| 314, | |
| 333, | |
| 334, | |
| 345, | |
| 351, | |
| 356, | |
| 357, | |
| 361, | |
| 365, | |
| 389 | |
| }; | |
| static const int32_t gIndexes[] = { | |
| 0, | |
| 2, | |
| 7, | |
| 16, | |
| 19, | |
| 19, | |
| 29, | |
| 40, | |
| 44, | |
| 50, | |
| 54, | |
| 73, | |
| 74, | |
| 85, | |
| 91, | |
| 96, | |
| 97, | |
| 101, | |
| 105, | |
| 129 | |
| }; | |
| // Must be sorted alphabetically. | |
| static const char * const gTypes[] = { | |
| "acceleration", | |
| "angle", | |
| "area", | |
| "consumption", | |
| "currency", | |
| "digital", | |
| "duration", | |
| "electric", | |
| "energy", | |
| "frequency", | |
| "length", | |
| "light", | |
| "mass", | |
| "power", | |
| "pressure", | |
| "proportion", | |
| "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", | |
| "liter-per-100kilometers", | |
| "liter-per-kilometer", | |
| "mile-per-gallon", | |
| "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", | |
| "karat", | |
| "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", | |
| "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] = { | |
| {321, 291, 16, 0}, | |
| {323, 297, 16, 2}, | |
| {325, 291, 16, 3}, | |
| {325, 379, 3, 2}, | |
| {342, 11, 14, 4}, | |
| {381, 321, 3, 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::createLiterPer100Kilometers(UErrorCode &status) { | |
| return MeasureUnit::create(3, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createLiterPerKilometer(UErrorCode &status) { | |
| return MeasureUnit::create(3, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMilePerGallon(UErrorCode &status) { | |
| return MeasureUnit::create(3, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createBit(UErrorCode &status) { | |
| return MeasureUnit::create(5, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createByte(UErrorCode &status) { | |
| return MeasureUnit::create(5, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGigabit(UErrorCode &status) { | |
| return MeasureUnit::create(5, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGigabyte(UErrorCode &status) { | |
| return MeasureUnit::create(5, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilobit(UErrorCode &status) { | |
| return MeasureUnit::create(5, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilobyte(UErrorCode &status) { | |
| return MeasureUnit::create(5, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMegabit(UErrorCode &status) { | |
| return MeasureUnit::create(5, 6, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMegabyte(UErrorCode &status) { | |
| return MeasureUnit::create(5, 7, status); | |
| } | |
| MeasureUnit *MeasureUnit::createTerabit(UErrorCode &status) { | |
| return MeasureUnit::create(5, 8, status); | |
| } | |
| MeasureUnit *MeasureUnit::createTerabyte(UErrorCode &status) { | |
| return MeasureUnit::create(5, 9, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCentury(UErrorCode &status) { | |
| return MeasureUnit::create(6, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createDay(UErrorCode &status) { | |
| return MeasureUnit::create(6, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createHour(UErrorCode &status) { | |
| return MeasureUnit::create(6, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMicrosecond(UErrorCode &status) { | |
| return MeasureUnit::create(6, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMillisecond(UErrorCode &status) { | |
| return MeasureUnit::create(6, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMinute(UErrorCode &status) { | |
| return MeasureUnit::create(6, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMonth(UErrorCode &status) { | |
| return MeasureUnit::create(6, 6, status); | |
| } | |
| MeasureUnit *MeasureUnit::createNanosecond(UErrorCode &status) { | |
| return MeasureUnit::create(6, 7, status); | |
| } | |
| MeasureUnit *MeasureUnit::createSecond(UErrorCode &status) { | |
| return MeasureUnit::create(6, 8, status); | |
| } | |
| MeasureUnit *MeasureUnit::createWeek(UErrorCode &status) { | |
| return MeasureUnit::create(6, 9, status); | |
| } | |
| MeasureUnit *MeasureUnit::createYear(UErrorCode &status) { | |
| return MeasureUnit::create(6, 10, status); | |
| } | |
| MeasureUnit *MeasureUnit::createAmpere(UErrorCode &status) { | |
| return MeasureUnit::create(7, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMilliampere(UErrorCode &status) { | |
| return MeasureUnit::create(7, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createOhm(UErrorCode &status) { | |
| return MeasureUnit::create(7, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createVolt(UErrorCode &status) { | |
| return MeasureUnit::create(7, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCalorie(UErrorCode &status) { | |
| return MeasureUnit::create(8, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createFoodcalorie(UErrorCode &status) { | |
| return MeasureUnit::create(8, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createJoule(UErrorCode &status) { | |
| return MeasureUnit::create(8, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilocalorie(UErrorCode &status) { | |
| return MeasureUnit::create(8, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilojoule(UErrorCode &status) { | |
| return MeasureUnit::create(8, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilowattHour(UErrorCode &status) { | |
| return MeasureUnit::create(8, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGigahertz(UErrorCode &status) { | |
| return MeasureUnit::create(9, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createHertz(UErrorCode &status) { | |
| return MeasureUnit::create(9, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilohertz(UErrorCode &status) { | |
| return MeasureUnit::create(9, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMegahertz(UErrorCode &status) { | |
| return MeasureUnit::create(9, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createAstronomicalUnit(UErrorCode &status) { | |
| return MeasureUnit::create(10, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCentimeter(UErrorCode &status) { | |
| return MeasureUnit::create(10, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createDecimeter(UErrorCode &status) { | |
| return MeasureUnit::create(10, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createFathom(UErrorCode &status) { | |
| return MeasureUnit::create(10, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) { | |
| return MeasureUnit::create(10, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createFurlong(UErrorCode &status) { | |
| return MeasureUnit::create(10, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createInch(UErrorCode &status) { | |
| return MeasureUnit::create(10, 6, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) { | |
| return MeasureUnit::create(10, 7, status); | |
| } | |
| MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) { | |
| return MeasureUnit::create(10, 8, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) { | |
| return MeasureUnit::create(10, 9, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMicrometer(UErrorCode &status) { | |
| return MeasureUnit::create(10, 10, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMile(UErrorCode &status) { | |
| return MeasureUnit::create(10, 11, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMileScandinavian(UErrorCode &status) { | |
| return MeasureUnit::create(10, 12, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) { | |
| return MeasureUnit::create(10, 13, status); | |
| } | |
| MeasureUnit *MeasureUnit::createNanometer(UErrorCode &status) { | |
| return MeasureUnit::create(10, 14, status); | |
| } | |
| MeasureUnit *MeasureUnit::createNauticalMile(UErrorCode &status) { | |
| return MeasureUnit::create(10, 15, status); | |
| } | |
| MeasureUnit *MeasureUnit::createParsec(UErrorCode &status) { | |
| return MeasureUnit::create(10, 16, status); | |
| } | |
| MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) { | |
| return MeasureUnit::create(10, 17, status); | |
| } | |
| MeasureUnit *MeasureUnit::createYard(UErrorCode &status) { | |
| return MeasureUnit::create(10, 18, status); | |
| } | |
| MeasureUnit *MeasureUnit::createLux(UErrorCode &status) { | |
| return MeasureUnit::create(11, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCarat(UErrorCode &status) { | |
| return MeasureUnit::create(12, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGram(UErrorCode &status) { | |
| return MeasureUnit::create(12, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) { | |
| return MeasureUnit::create(12, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMetricTon(UErrorCode &status) { | |
| return MeasureUnit::create(12, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMicrogram(UErrorCode &status) { | |
| return MeasureUnit::create(12, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMilligram(UErrorCode &status) { | |
| return MeasureUnit::create(12, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) { | |
| return MeasureUnit::create(12, 6, status); | |
| } | |
| MeasureUnit *MeasureUnit::createOunceTroy(UErrorCode &status) { | |
| return MeasureUnit::create(12, 7, status); | |
| } | |
| MeasureUnit *MeasureUnit::createPound(UErrorCode &status) { | |
| return MeasureUnit::create(12, 8, status); | |
| } | |
| MeasureUnit *MeasureUnit::createStone(UErrorCode &status) { | |
| return MeasureUnit::create(12, 9, status); | |
| } | |
| MeasureUnit *MeasureUnit::createTon(UErrorCode &status) { | |
| return MeasureUnit::create(12, 10, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGigawatt(UErrorCode &status) { | |
| return MeasureUnit::create(13, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createHorsepower(UErrorCode &status) { | |
| return MeasureUnit::create(13, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilowatt(UErrorCode &status) { | |
| return MeasureUnit::create(13, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMegawatt(UErrorCode &status) { | |
| return MeasureUnit::create(13, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMilliwatt(UErrorCode &status) { | |
| return MeasureUnit::create(13, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createWatt(UErrorCode &status) { | |
| return MeasureUnit::create(13, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createHectopascal(UErrorCode &status) { | |
| return MeasureUnit::create(14, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createInchHg(UErrorCode &status) { | |
| return MeasureUnit::create(14, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMillibar(UErrorCode &status) { | |
| return MeasureUnit::create(14, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMillimeterOfMercury(UErrorCode &status) { | |
| return MeasureUnit::create(14, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createPoundPerSquareInch(UErrorCode &status) { | |
| return MeasureUnit::create(14, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKarat(UErrorCode &status) { | |
| return MeasureUnit::create(15, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKilometerPerHour(UErrorCode &status) { | |
| return MeasureUnit::create(16, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKnot(UErrorCode &status) { | |
| return MeasureUnit::create(16, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMeterPerSecond(UErrorCode &status) { | |
| return MeasureUnit::create(16, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMilePerHour(UErrorCode &status) { | |
| return MeasureUnit::create(16, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCelsius(UErrorCode &status) { | |
| return MeasureUnit::create(17, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createFahrenheit(UErrorCode &status) { | |
| return MeasureUnit::create(17, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGenericTemperature(UErrorCode &status) { | |
| return MeasureUnit::create(17, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createKelvin(UErrorCode &status) { | |
| return MeasureUnit::create(17, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createAcreFoot(UErrorCode &status) { | |
| return MeasureUnit::create(18, 0, status); | |
| } | |
| MeasureUnit *MeasureUnit::createBushel(UErrorCode &status) { | |
| return MeasureUnit::create(18, 1, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCentiliter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 2, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicCentimeter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 3, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicFoot(UErrorCode &status) { | |
| return MeasureUnit::create(18, 4, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicInch(UErrorCode &status) { | |
| return MeasureUnit::create(18, 5, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicKilometer(UErrorCode &status) { | |
| return MeasureUnit::create(18, 6, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicMeter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 7, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicMile(UErrorCode &status) { | |
| return MeasureUnit::create(18, 8, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCubicYard(UErrorCode &status) { | |
| return MeasureUnit::create(18, 9, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCup(UErrorCode &status) { | |
| return MeasureUnit::create(18, 10, status); | |
| } | |
| MeasureUnit *MeasureUnit::createCupMetric(UErrorCode &status) { | |
| return MeasureUnit::create(18, 11, status); | |
| } | |
| MeasureUnit *MeasureUnit::createDeciliter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 12, status); | |
| } | |
| MeasureUnit *MeasureUnit::createFluidOunce(UErrorCode &status) { | |
| return MeasureUnit::create(18, 13, status); | |
| } | |
| MeasureUnit *MeasureUnit::createGallon(UErrorCode &status) { | |
| return MeasureUnit::create(18, 14, status); | |
| } | |
| MeasureUnit *MeasureUnit::createHectoliter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 15, status); | |
| } | |
| MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 16, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMegaliter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 17, status); | |
| } | |
| MeasureUnit *MeasureUnit::createMilliliter(UErrorCode &status) { | |
| return MeasureUnit::create(18, 18, status); | |
| } | |
| MeasureUnit *MeasureUnit::createPint(UErrorCode &status) { | |
| return MeasureUnit::create(18, 19, status); | |
| } | |
| MeasureUnit *MeasureUnit::createPintMetric(UErrorCode &status) { | |
| return MeasureUnit::create(18, 20, status); | |
| } | |
| MeasureUnit *MeasureUnit::createQuart(UErrorCode &status) { | |
| return MeasureUnit::create(18, 21, status); | |
| } | |
| MeasureUnit *MeasureUnit::createTablespoon(UErrorCode &status) { | |
| return MeasureUnit::create(18, 22, status); | |
| } | |
| MeasureUnit *MeasureUnit::createTeaspoon(UErrorCode &status) { | |
| return MeasureUnit::create(18, 23, 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)); | |
| } | |
| } | |
| 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 */ |