MeasureUnit MeasureUnit::resolveUnitPerUnit(
const MeasureUnit &unit, const MeasureUnit &perUnit, bool* isResolved) {
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.
*isResolved = true;
return MeasureUnit(midRow[2], midRow[3]);
}
}
*isResolved = false;
return MeasureUnit();
}
MeasureUnit MeasureUnit::getPercent() {
return MeasureUnit(3, 5);
}
MeasureUnit MeasureUnit::getNanosecond() {
return MeasureUnit(7, 9);
}
MeasureUnit MeasureUnit::getMonth() {
return MeasureUnit(7, 7);
}
MeasureUnit MeasureUnit::getMillisecond() {
return MeasureUnit(7, 5);
}
MeasureUnit MeasureUnit::getHour() {
return MeasureUnit(7, 3);
}
MeasureUnit MeasureUnit::getDay() {
return MeasureUnit(7, 1);
}
MeasureUnit MeasureUnit::getTerabyte() {
return MeasureUnit(6, 10);
}
MeasureUnit MeasureUnit::getBit() {
return MeasureUnit(6, 0);
}
MeasureUnit MeasureUnit::getMilePerGallonImperial() {
return MeasureUnit(4, 3);
}
MeasureUnit MeasureUnit::getMilePerGallon() {
return MeasureUnit(4, 2);
}
MeasureUnit MeasureUnit::getLiterPerKilometer() {
return MeasureUnit(4, 1);
}
MeasureUnit MeasureUnit::getLiterPer100Kilometers() {
return MeasureUnit(4, 0);
}
MeasureUnit MeasureUnit::getPermyriad() {
return MeasureUnit(3, 7);
}
MeasureUnit MeasureUnit::getPermille() {
return MeasureUnit(3, 6);
}
MeasureUnit MeasureUnit::getPetabyte() {
return MeasureUnit(6, 8);
}
MeasureUnit MeasureUnit::getTerabit() {
return MeasureUnit(6, 9);
}
MeasureUnit MeasureUnit::getByte() {
return MeasureUnit(6, 1);
}
MeasureUnit MeasureUnit::getCentury() {
return MeasureUnit(7, 0);
}
MeasureUnit MeasureUnit::getGigabit() {
return MeasureUnit(6, 2);
}
MeasureUnit MeasureUnit::getDayPerson() {
return MeasureUnit(7, 2);
}
MeasureUnit MeasureUnit::getGigabyte() {
return MeasureUnit(6, 3);
}
MeasureUnit MeasureUnit::getMicrosecond() {
return MeasureUnit(7, 4);
}
MeasureUnit MeasureUnit::getKilobit() {
return MeasureUnit(6, 4);
}
MeasureUnit MeasureUnit::getMinute() {
return MeasureUnit(7, 6);
}
MeasureUnit MeasureUnit::getKilobyte() {
return MeasureUnit(6, 5);
}
MeasureUnit MeasureUnit::getMonthPerson() {
return MeasureUnit(7, 8);
}
MeasureUnit MeasureUnit::getMegabit() {
return MeasureUnit(6, 6);
}
void TimeUnitTest::testAPI() {
//================= TimeUnit =================
UErrorCode status = U_ZERO_ERROR;
TimeUnit* tmunit = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_YEAR, status);
if (!assertSuccess("TimeUnit::createInstance", status)) return;
TimeUnit* another = (TimeUnit*)tmunit->clone();
TimeUnit third(*tmunit);
TimeUnit fourth = third;
assertTrue("orig and clone are equal", (*tmunit == *another));
assertTrue("copied and assigned are equal", (third == fourth));
TimeUnit* tmunit_m = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_MONTH, status);
assertTrue("year != month", (*tmunit != *tmunit_m));
TimeUnit::UTimeUnitFields field = tmunit_m->getTimeUnitField();
assertTrue("field of month time unit is month", (field == TimeUnit::UTIMEUNIT_MONTH));
//===== Interoperability with MeasureUnit ======
MeasureUnit **ptrs = new MeasureUnit *[TimeUnit::UTIMEUNIT_FIELD_COUNT];
ptrs[TimeUnit::UTIMEUNIT_YEAR] = MeasureUnit::createYear(status);
ptrs[TimeUnit::UTIMEUNIT_MONTH] = MeasureUnit::createMonth(status);
ptrs[TimeUnit::UTIMEUNIT_DAY] = MeasureUnit::createDay(status);
ptrs[TimeUnit::UTIMEUNIT_WEEK] = MeasureUnit::createWeek(status);
ptrs[TimeUnit::UTIMEUNIT_HOUR] = MeasureUnit::createHour(status);
ptrs[TimeUnit::UTIMEUNIT_MINUTE] = MeasureUnit::createMinute(status);
ptrs[TimeUnit::UTIMEUNIT_SECOND] = MeasureUnit::createSecond(status);
if (!assertSuccess("TimeUnit::createInstance", status)) return;
for (TimeUnit::UTimeUnitFields j = TimeUnit::UTIMEUNIT_YEAR;
j < TimeUnit::UTIMEUNIT_FIELD_COUNT;
j = (TimeUnit::UTimeUnitFields)(j+1)) {
MeasureUnit *ptr = TimeUnit::createInstance(j, status);
if (!assertSuccess("TimeUnit::createInstance", status)) return;
// We have to convert *ptr to a MeasureUnit or else == will fail over
// differing types (TimeUnit vs. MeasureUnit).
assertTrue(
"Time unit should be equal to corresponding MeasureUnit",
MeasureUnit(*ptr) == *ptrs[j]);
delete ptr;
}
delete tmunit;
delete another;
delete tmunit_m;
for (int i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
delete ptrs[i];
}
delete [] ptrs;
//
//================= TimeUnitAmount =================
Formattable formattable((int32_t)2);
TimeUnitAmount tma_long(formattable, TimeUnit::UTIMEUNIT_DAY, status);
if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
formattable.setDouble(2);
TimeUnitAmount tma_double(formattable, TimeUnit::UTIMEUNIT_DAY, status);
if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
formattable.setDouble(3);
TimeUnitAmount tma_double_3(formattable, TimeUnit::UTIMEUNIT_DAY, status);
if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
TimeUnitAmount tma(2, TimeUnit::UTIMEUNIT_DAY, status);
if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
TimeUnitAmount tma_h(2, TimeUnit::UTIMEUNIT_HOUR, status);
if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
TimeUnitAmount second(tma);
TimeUnitAmount third_tma = tma;
TimeUnitAmount* fourth_tma = (TimeUnitAmount*)tma.clone();
assertTrue("orig and copy are equal", (second == tma));
assertTrue("clone and assigned are equal", (third_tma == *fourth_tma));
assertTrue("different if number diff", (tma_double != tma_double_3));
assertTrue("different if number type diff", (tma_double != tma_long));
assertTrue("different if time unit diff", (tma != tma_h));
assertTrue("same even different constructor", (tma_double == tma));
assertTrue("getTimeUnitField", (tma.getTimeUnitField() == TimeUnit::UTIMEUNIT_DAY));
delete fourth_tma;
//
//================= TimeUnitFormat =================
//
TimeUnitFormat* tmf_en = new TimeUnitFormat(Locale("en"), status);
if (!assertSuccess("TimeUnitFormat(en...)", status, TRUE)) return;
TimeUnitFormat tmf_fr(Locale("fr"), status);
if (!assertSuccess("TimeUnitFormat(fr...)", status)) return;
assertTrue("TimeUnitFormat: en and fr diff", (*tmf_en != tmf_fr));
TimeUnitFormat tmf_assign = *tmf_en;
assertTrue("TimeUnitFormat: orig and assign are equal", (*tmf_en == tmf_assign));
TimeUnitFormat tmf_copy(tmf_fr);
assertTrue("TimeUnitFormat: orig and copy are equal", (tmf_fr == tmf_copy));
TimeUnitFormat* tmf_clone = (TimeUnitFormat*)tmf_en->clone();
assertTrue("TimeUnitFormat: orig and clone are equal", (*tmf_en == *tmf_clone));
delete tmf_clone;
tmf_en->setLocale(Locale("fr"), status);
if (!assertSuccess("setLocale(fr...)", status)) return;
NumberFormat* numberFmt = NumberFormat::createInstance(
Locale("fr"), status);
if (!assertSuccess("NumberFormat::createInstance()", status)) return;
tmf_en->setNumberFormat(*numberFmt, status);
if (!assertSuccess("setNumberFormat(en...)", status)) return;
assertTrue("TimeUnitFormat: setLocale", (*tmf_en == tmf_fr));
delete tmf_en;
TimeUnitFormat* en_long = new TimeUnitFormat(Locale("en"), UTMUTFMT_FULL_STYLE, status);
if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
delete en_long;
TimeUnitFormat* en_short = new TimeUnitFormat(Locale("en"), UTMUTFMT_ABBREVIATED_STYLE, status);
if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
delete en_short;
TimeUnitFormat* format = new TimeUnitFormat(status);
format->setLocale(Locale("zh"), status);
format->setNumberFormat(*numberFmt, status);
if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
delete numberFmt;
delete format;
}
MeasureUnit MeasureUnit::getMegabyte() {
return MeasureUnit(6, 7);
}
