745 lines
15 KiB
C++
745 lines
15 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (c) 2004-2014, 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"
|
|
|
|
#define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MeasureUnit)
|
|
|
|
static const int32_t gOffsets[] = {
|
|
0,
|
|
1,
|
|
4,
|
|
10,
|
|
270,
|
|
278,
|
|
288,
|
|
292,
|
|
295,
|
|
298,
|
|
301,
|
|
303,
|
|
306
|
|
};
|
|
|
|
static const int32_t gIndexes[] = {
|
|
0,
|
|
1,
|
|
4,
|
|
10,
|
|
10,
|
|
18,
|
|
28,
|
|
32,
|
|
35,
|
|
38,
|
|
41,
|
|
43,
|
|
46
|
|
};
|
|
|
|
static const char * const gTypes[] = {
|
|
"acceleration",
|
|
"angle",
|
|
"area",
|
|
"currency",
|
|
"duration",
|
|
"length",
|
|
"mass",
|
|
"power",
|
|
"pressure",
|
|
"speed",
|
|
"temperature",
|
|
"volume"
|
|
};
|
|
|
|
static const char * const gSubTypes[] = {
|
|
"g-force",
|
|
"arc-minute",
|
|
"arc-second",
|
|
"degree",
|
|
"acre",
|
|
"hectare",
|
|
"square-foot",
|
|
"square-kilometer",
|
|
"square-meter",
|
|
"square-mile",
|
|
"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",
|
|
"day",
|
|
"hour",
|
|
"millisecond",
|
|
"minute",
|
|
"month",
|
|
"second",
|
|
"week",
|
|
"year",
|
|
"centimeter",
|
|
"foot",
|
|
"inch",
|
|
"kilometer",
|
|
"light-year",
|
|
"meter",
|
|
"mile",
|
|
"millimeter",
|
|
"picometer",
|
|
"yard",
|
|
"gram",
|
|
"kilogram",
|
|
"ounce",
|
|
"pound",
|
|
"horsepower",
|
|
"kilowatt",
|
|
"watt",
|
|
"hectopascal",
|
|
"inch-hg",
|
|
"millibar",
|
|
"kilometer-per-hour",
|
|
"meter-per-second",
|
|
"mile-per-hour",
|
|
"celsius",
|
|
"fahrenheit",
|
|
"cubic-kilometer",
|
|
"cubic-mile",
|
|
"liter"
|
|
};
|
|
|
|
MeasureUnit *MeasureUnit::createGForce(UErrorCode &status) {
|
|
return MeasureUnit::create(0, 0, 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::createAcre(UErrorCode &status) {
|
|
return MeasureUnit::create(2, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createHectare(UErrorCode &status) {
|
|
return MeasureUnit::create(2, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createSquareFoot(UErrorCode &status) {
|
|
return MeasureUnit::create(2, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createSquareKilometer(UErrorCode &status) {
|
|
return MeasureUnit::create(2, 3, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createSquareMeter(UErrorCode &status) {
|
|
return MeasureUnit::create(2, 4, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createSquareMile(UErrorCode &status) {
|
|
return MeasureUnit::create(2, 5, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createDay(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createHour(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMillisecond(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMinute(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 3, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMonth(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 4, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createSecond(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 5, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createWeek(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 6, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createYear(UErrorCode &status) {
|
|
return MeasureUnit::create(4, 7, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createCentimeter(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createInch(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 3, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 4, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 5, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMile(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 6, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 7, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 8, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createYard(UErrorCode &status) {
|
|
return MeasureUnit::create(5, 9, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createGram(UErrorCode &status) {
|
|
return MeasureUnit::create(6, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) {
|
|
return MeasureUnit::create(6, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) {
|
|
return MeasureUnit::create(6, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createPound(UErrorCode &status) {
|
|
return MeasureUnit::create(6, 3, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createHorsepower(UErrorCode &status) {
|
|
return MeasureUnit::create(7, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createKilowatt(UErrorCode &status) {
|
|
return MeasureUnit::create(7, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createWatt(UErrorCode &status) {
|
|
return MeasureUnit::create(7, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createHectopascal(UErrorCode &status) {
|
|
return MeasureUnit::create(8, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createInchHg(UErrorCode &status) {
|
|
return MeasureUnit::create(8, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMillibar(UErrorCode &status) {
|
|
return MeasureUnit::create(8, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createKilometerPerHour(UErrorCode &status) {
|
|
return MeasureUnit::create(9, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMeterPerSecond(UErrorCode &status) {
|
|
return MeasureUnit::create(9, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createMilePerHour(UErrorCode &status) {
|
|
return MeasureUnit::create(9, 2, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createCelsius(UErrorCode &status) {
|
|
return MeasureUnit::create(10, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createFahrenheit(UErrorCode &status) {
|
|
return MeasureUnit::create(10, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createCubicKilometer(UErrorCode &status) {
|
|
return MeasureUnit::create(11, 0, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createCubicMile(UErrorCode &status) {
|
|
return MeasureUnit::create(11, 1, status);
|
|
}
|
|
|
|
MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) {
|
|
return MeasureUnit::create(11, 2, status);
|
|
}
|
|
|
|
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 < LENGTHOF(gSubTypes)) {
|
|
errorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
return LENGTHOF(gSubTypes);
|
|
}
|
|
int32_t idx = 0;
|
|
for (int32_t typeIdx = 0; typeIdx < 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 == LENGTHOF(gSubTypes));
|
|
return 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, 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, 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[LENGTHOF(gIndexes) - 1];
|
|
}
|
|
|
|
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, 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, 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, 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 */
|