1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 * Copyright (c) 2004-2016, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 **********************************************************************
8 * Author: Alan Liu
9 * Created: April 26, 2004
10 * Since: ICU 3.0
11 **********************************************************************
12 */
13 #include "utypeinfo.h" // for 'typeid' to work
14
15 #include "unicode/measunit.h"
16
17 #if !UCONFIG_NO_FORMATTING
18
19 #include "unicode/uenum.h"
20 #include "ustrenum.h"
21 #include "cstring.h"
22 #include "uassert.h"
23
24 U_NAMESPACE_BEGIN
25
26 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MeasureUnit)
27
28 // All code between the "Start generated code" comment and
29 // the "End generated code" comment is auto generated code
30 // and must not be edited manually. For instructions on how to correctly
31 // update this code, refer to:
32 // http://site.icu-project.org/design/formatting/measureformat/updating-measure-unit
33 //
34 // Start generated code
35
36 static const int32_t gOffsets[] = {
37 0,
38 2,
39 7,
40 16,
41 20,
42 24,
43 28,
44 288,
45 298,
46 309,
47 313,
48 319,
49 323,
50 342,
51 343,
52 354,
53 360,
54 365,
55 369,
56 373,
57 398
58 };
59
60 static const int32_t gIndexes[] = {
61 0,
62 2,
63 7,
64 16,
65 20,
66 24,
67 28,
68 28,
69 38,
70 49,
71 53,
72 59,
73 63,
74 82,
75 83,
76 94,
77 100,
78 105,
79 109,
80 113,
81 138
82 };
83
84 // Must be sorted alphabetically.
85 static const char * const gTypes[] = {
86 "acceleration",
87 "angle",
88 "area",
89 "concentr",
90 "consumption",
91 "coordinate",
92 "currency",
93 "digital",
94 "duration",
95 "electric",
96 "energy",
97 "frequency",
98 "length",
99 "light",
100 "mass",
101 "power",
102 "pressure",
103 "speed",
104 "temperature",
105 "volume"
106 };
107
108 // Must be grouped by type and sorted alphabetically within each type.
109 static const char * const gSubTypes[] = {
110 "g-force",
111 "meter-per-second-squared",
112 "arc-minute",
113 "arc-second",
114 "degree",
115 "radian",
116 "revolution",
117 "acre",
118 "hectare",
119 "square-centimeter",
120 "square-foot",
121 "square-inch",
122 "square-kilometer",
123 "square-meter",
124 "square-mile",
125 "square-yard",
126 "karat",
127 "milligram-per-deciliter",
128 "millimole-per-liter",
129 "part-per-million",
130 "liter-per-100kilometers",
131 "liter-per-kilometer",
132 "mile-per-gallon",
133 "mile-per-gallon-imperial",
134 "east",
135 "north",
136 "south",
137 "west",
138 "ADP",
139 "AED",
140 "AFA",
141 "AFN",
142 "ALL",
143 "AMD",
144 "ANG",
145 "AOA",
146 "AON",
147 "AOR",
148 "ARA",
149 "ARP",
150 "ARS",
151 "ATS",
152 "AUD",
153 "AWG",
154 "AYM",
155 "AZM",
156 "AZN",
157 "BAD",
158 "BAM",
159 "BBD",
160 "BDT",
161 "BEC",
162 "BEF",
163 "BEL",
164 "BGL",
165 "BGN",
166 "BHD",
167 "BIF",
168 "BMD",
169 "BND",
170 "BOB",
171 "BOV",
172 "BRC",
173 "BRE",
174 "BRL",
175 "BRN",
176 "BRR",
177 "BSD",
178 "BTN",
179 "BWP",
180 "BYB",
181 "BYR",
182 "BZD",
183 "CAD",
184 "CDF",
185 "CHC",
186 "CHE",
187 "CHF",
188 "CHW",
189 "CLF",
190 "CLP",
191 "CNY",
192 "COP",
193 "COU",
194 "CRC",
195 "CSD",
196 "CSK",
197 "CUC",
198 "CUP",
199 "CVE",
200 "CYP",
201 "CZK",
202 "DDM",
203 "DEM",
204 "DJF",
205 "DKK",
206 "DOP",
207 "DZD",
208 "ECS",
209 "ECV",
210 "EEK",
211 "EGP",
212 "ERN",
213 "ESA",
214 "ESB",
215 "ESP",
216 "ETB",
217 "EUR",
218 "FIM",
219 "FJD",
220 "FKP",
221 "FRF",
222 "GBP",
223 "GEK",
224 "GEL",
225 "GHC",
226 "GHP",
227 "GHS",
228 "GIP",
229 "GMD",
230 "GNF",
231 "GQE",
232 "GRD",
233 "GTQ",
234 "GWP",
235 "GYD",
236 "HKD",
237 "HNL",
238 "HRD",
239 "HRK",
240 "HTG",
241 "HUF",
242 "IDR",
243 "IEP",
244 "ILS",
245 "INR",
246 "IQD",
247 "IRR",
248 "ISK",
249 "ITL",
250 "JMD",
251 "JOD",
252 "JPY",
253 "KES",
254 "KGS",
255 "KHR",
256 "KMF",
257 "KPW",
258 "KRW",
259 "KWD",
260 "KYD",
261 "KZT",
262 "LAK",
263 "LBP",
264 "LKR",
265 "LRD",
266 "LSL",
267 "LTL",
268 "LTT",
269 "LUC",
270 "LUF",
271 "LUL",
272 "LVL",
273 "LVR",
274 "LYD",
275 "MAD",
276 "MDL",
277 "MGA",
278 "MGF",
279 "MKD",
280 "MLF",
281 "MMK",
282 "MNT",
283 "MOP",
284 "MRO",
285 "MTL",
286 "MUR",
287 "MVR",
288 "MWK",
289 "MXN",
290 "MXV",
291 "MYR",
292 "MZM",
293 "MZN",
294 "NAD",
295 "NGN",
296 "NIO",
297 "NLG",
298 "NOK",
299 "NPR",
300 "NZD",
301 "OMR",
302 "PAB",
303 "PEI",
304 "PEN",
305 "PES",
306 "PGK",
307 "PHP",
308 "PKR",
309 "PLN",
310 "PLZ",
311 "PTE",
312 "PYG",
313 "QAR",
314 "ROL",
315 "RON",
316 "RSD",
317 "RUB",
318 "RUR",
319 "RWF",
320 "SAR",
321 "SBD",
322 "SCR",
323 "SDD",
324 "SDG",
325 "SEK",
326 "SGD",
327 "SHP",
328 "SIT",
329 "SKK",
330 "SLL",
331 "SOS",
332 "SRD",
333 "SRG",
334 "SSP",
335 "STD",
336 "SVC",
337 "SYP",
338 "SZL",
339 "THB",
340 "TJR",
341 "TJS",
342 "TMM",
343 "TMT",
344 "TND",
345 "TOP",
346 "TPE",
347 "TRL",
348 "TRY",
349 "TTD",
350 "TWD",
351 "TZS",
352 "UAH",
353 "UAK",
354 "UGX",
355 "USD",
356 "USN",
357 "USS",
358 "UYI",
359 "UYU",
360 "UZS",
361 "VEB",
362 "VEF",
363 "VND",
364 "VUV",
365 "WST",
366 "XAF",
367 "XAG",
368 "XAU",
369 "XBA",
370 "XBB",
371 "XBC",
372 "XBD",
373 "XCD",
374 "XDR",
375 "XEU",
376 "XOF",
377 "XPD",
378 "XPF",
379 "XPT",
380 "XSU",
381 "XTS",
382 "XUA",
383 "XXX",
384 "YDD",
385 "YER",
386 "YUM",
387 "YUN",
388 "ZAL",
389 "ZAR",
390 "ZMK",
391 "ZMW",
392 "ZRN",
393 "ZRZ",
394 "ZWD",
395 "ZWL",
396 "ZWN",
397 "ZWR",
398 "bit",
399 "byte",
400 "gigabit",
401 "gigabyte",
402 "kilobit",
403 "kilobyte",
404 "megabit",
405 "megabyte",
406 "terabit",
407 "terabyte",
408 "century",
409 "day",
410 "hour",
411 "microsecond",
412 "millisecond",
413 "minute",
414 "month",
415 "nanosecond",
416 "second",
417 "week",
418 "year",
419 "ampere",
420 "milliampere",
421 "ohm",
422 "volt",
423 "calorie",
424 "foodcalorie",
425 "joule",
426 "kilocalorie",
427 "kilojoule",
428 "kilowatt-hour",
429 "gigahertz",
430 "hertz",
431 "kilohertz",
432 "megahertz",
433 "astronomical-unit",
434 "centimeter",
435 "decimeter",
436 "fathom",
437 "foot",
438 "furlong",
439 "inch",
440 "kilometer",
441 "light-year",
442 "meter",
443 "micrometer",
444 "mile",
445 "mile-scandinavian",
446 "millimeter",
447 "nanometer",
448 "nautical-mile",
449 "parsec",
450 "picometer",
451 "yard",
452 "lux",
453 "carat",
454 "gram",
455 "kilogram",
456 "metric-ton",
457 "microgram",
458 "milligram",
459 "ounce",
460 "ounce-troy",
461 "pound",
462 "stone",
463 "ton",
464 "gigawatt",
465 "horsepower",
466 "kilowatt",
467 "megawatt",
468 "milliwatt",
469 "watt",
470 "hectopascal",
471 "inch-hg",
472 "millibar",
473 "millimeter-of-mercury",
474 "pound-per-square-inch",
475 "kilometer-per-hour",
476 "knot",
477 "meter-per-second",
478 "mile-per-hour",
479 "celsius",
480 "fahrenheit",
481 "generic",
482 "kelvin",
483 "acre-foot",
484 "bushel",
485 "centiliter",
486 "cubic-centimeter",
487 "cubic-foot",
488 "cubic-inch",
489 "cubic-kilometer",
490 "cubic-meter",
491 "cubic-mile",
492 "cubic-yard",
493 "cup",
494 "cup-metric",
495 "deciliter",
496 "fluid-ounce",
497 "gallon",
498 "gallon-imperial",
499 "hectoliter",
500 "liter",
501 "megaliter",
502 "milliliter",
503 "pint",
504 "pint-metric",
505 "quart",
506 "tablespoon",
507 "teaspoon"
508 };
509
510 // Must be sorted by first value and then second value.
511 static int32_t unitPerUnitToSingleUnit[][4] = {
512 {330, 300, 17, 0},
513 {332, 306, 17, 2},
514 {334, 300, 17, 3},
515 {334, 387, 4, 2},
516 {334, 388, 4, 3},
517 {348, 385, 3, 1},
518 {351, 11, 16, 4},
519 {390, 330, 4, 1}
520 };
521
createGForce(UErrorCode & status)522 MeasureUnit *MeasureUnit::createGForce(UErrorCode &status) {
523 return MeasureUnit::create(0, 0, status);
524 }
525
createMeterPerSecondSquared(UErrorCode & status)526 MeasureUnit *MeasureUnit::createMeterPerSecondSquared(UErrorCode &status) {
527 return MeasureUnit::create(0, 1, status);
528 }
529
createArcMinute(UErrorCode & status)530 MeasureUnit *MeasureUnit::createArcMinute(UErrorCode &status) {
531 return MeasureUnit::create(1, 0, status);
532 }
533
createArcSecond(UErrorCode & status)534 MeasureUnit *MeasureUnit::createArcSecond(UErrorCode &status) {
535 return MeasureUnit::create(1, 1, status);
536 }
537
createDegree(UErrorCode & status)538 MeasureUnit *MeasureUnit::createDegree(UErrorCode &status) {
539 return MeasureUnit::create(1, 2, status);
540 }
541
createRadian(UErrorCode & status)542 MeasureUnit *MeasureUnit::createRadian(UErrorCode &status) {
543 return MeasureUnit::create(1, 3, status);
544 }
545
createRevolutionAngle(UErrorCode & status)546 MeasureUnit *MeasureUnit::createRevolutionAngle(UErrorCode &status) {
547 return MeasureUnit::create(1, 4, status);
548 }
549
createAcre(UErrorCode & status)550 MeasureUnit *MeasureUnit::createAcre(UErrorCode &status) {
551 return MeasureUnit::create(2, 0, status);
552 }
553
createHectare(UErrorCode & status)554 MeasureUnit *MeasureUnit::createHectare(UErrorCode &status) {
555 return MeasureUnit::create(2, 1, status);
556 }
557
createSquareCentimeter(UErrorCode & status)558 MeasureUnit *MeasureUnit::createSquareCentimeter(UErrorCode &status) {
559 return MeasureUnit::create(2, 2, status);
560 }
561
createSquareFoot(UErrorCode & status)562 MeasureUnit *MeasureUnit::createSquareFoot(UErrorCode &status) {
563 return MeasureUnit::create(2, 3, status);
564 }
565
createSquareInch(UErrorCode & status)566 MeasureUnit *MeasureUnit::createSquareInch(UErrorCode &status) {
567 return MeasureUnit::create(2, 4, status);
568 }
569
createSquareKilometer(UErrorCode & status)570 MeasureUnit *MeasureUnit::createSquareKilometer(UErrorCode &status) {
571 return MeasureUnit::create(2, 5, status);
572 }
573
createSquareMeter(UErrorCode & status)574 MeasureUnit *MeasureUnit::createSquareMeter(UErrorCode &status) {
575 return MeasureUnit::create(2, 6, status);
576 }
577
createSquareMile(UErrorCode & status)578 MeasureUnit *MeasureUnit::createSquareMile(UErrorCode &status) {
579 return MeasureUnit::create(2, 7, status);
580 }
581
createSquareYard(UErrorCode & status)582 MeasureUnit *MeasureUnit::createSquareYard(UErrorCode &status) {
583 return MeasureUnit::create(2, 8, status);
584 }
585
createKarat(UErrorCode & status)586 MeasureUnit *MeasureUnit::createKarat(UErrorCode &status) {
587 return MeasureUnit::create(3, 0, status);
588 }
589
createMilligramPerDeciliter(UErrorCode & status)590 MeasureUnit *MeasureUnit::createMilligramPerDeciliter(UErrorCode &status) {
591 return MeasureUnit::create(3, 1, status);
592 }
593
createMillimolePerLiter(UErrorCode & status)594 MeasureUnit *MeasureUnit::createMillimolePerLiter(UErrorCode &status) {
595 return MeasureUnit::create(3, 2, status);
596 }
597
createPartPerMillion(UErrorCode & status)598 MeasureUnit *MeasureUnit::createPartPerMillion(UErrorCode &status) {
599 return MeasureUnit::create(3, 3, status);
600 }
601
createLiterPer100Kilometers(UErrorCode & status)602 MeasureUnit *MeasureUnit::createLiterPer100Kilometers(UErrorCode &status) {
603 return MeasureUnit::create(4, 0, status);
604 }
605
createLiterPerKilometer(UErrorCode & status)606 MeasureUnit *MeasureUnit::createLiterPerKilometer(UErrorCode &status) {
607 return MeasureUnit::create(4, 1, status);
608 }
609
createMilePerGallon(UErrorCode & status)610 MeasureUnit *MeasureUnit::createMilePerGallon(UErrorCode &status) {
611 return MeasureUnit::create(4, 2, status);
612 }
613
createMilePerGallonImperial(UErrorCode & status)614 MeasureUnit *MeasureUnit::createMilePerGallonImperial(UErrorCode &status) {
615 return MeasureUnit::create(4, 3, status);
616 }
617
createEast(UErrorCode & status)618 MeasureUnit *MeasureUnit::createEast(UErrorCode &status) {
619 return MeasureUnit::create(5, 0, status);
620 }
621
createNorth(UErrorCode & status)622 MeasureUnit *MeasureUnit::createNorth(UErrorCode &status) {
623 return MeasureUnit::create(5, 1, status);
624 }
625
createSouth(UErrorCode & status)626 MeasureUnit *MeasureUnit::createSouth(UErrorCode &status) {
627 return MeasureUnit::create(5, 2, status);
628 }
629
createWest(UErrorCode & status)630 MeasureUnit *MeasureUnit::createWest(UErrorCode &status) {
631 return MeasureUnit::create(5, 3, status);
632 }
633
createBit(UErrorCode & status)634 MeasureUnit *MeasureUnit::createBit(UErrorCode &status) {
635 return MeasureUnit::create(7, 0, status);
636 }
637
createByte(UErrorCode & status)638 MeasureUnit *MeasureUnit::createByte(UErrorCode &status) {
639 return MeasureUnit::create(7, 1, status);
640 }
641
createGigabit(UErrorCode & status)642 MeasureUnit *MeasureUnit::createGigabit(UErrorCode &status) {
643 return MeasureUnit::create(7, 2, status);
644 }
645
createGigabyte(UErrorCode & status)646 MeasureUnit *MeasureUnit::createGigabyte(UErrorCode &status) {
647 return MeasureUnit::create(7, 3, status);
648 }
649
createKilobit(UErrorCode & status)650 MeasureUnit *MeasureUnit::createKilobit(UErrorCode &status) {
651 return MeasureUnit::create(7, 4, status);
652 }
653
createKilobyte(UErrorCode & status)654 MeasureUnit *MeasureUnit::createKilobyte(UErrorCode &status) {
655 return MeasureUnit::create(7, 5, status);
656 }
657
createMegabit(UErrorCode & status)658 MeasureUnit *MeasureUnit::createMegabit(UErrorCode &status) {
659 return MeasureUnit::create(7, 6, status);
660 }
661
createMegabyte(UErrorCode & status)662 MeasureUnit *MeasureUnit::createMegabyte(UErrorCode &status) {
663 return MeasureUnit::create(7, 7, status);
664 }
665
createTerabit(UErrorCode & status)666 MeasureUnit *MeasureUnit::createTerabit(UErrorCode &status) {
667 return MeasureUnit::create(7, 8, status);
668 }
669
createTerabyte(UErrorCode & status)670 MeasureUnit *MeasureUnit::createTerabyte(UErrorCode &status) {
671 return MeasureUnit::create(7, 9, status);
672 }
673
createCentury(UErrorCode & status)674 MeasureUnit *MeasureUnit::createCentury(UErrorCode &status) {
675 return MeasureUnit::create(8, 0, status);
676 }
677
createDay(UErrorCode & status)678 MeasureUnit *MeasureUnit::createDay(UErrorCode &status) {
679 return MeasureUnit::create(8, 1, status);
680 }
681
createHour(UErrorCode & status)682 MeasureUnit *MeasureUnit::createHour(UErrorCode &status) {
683 return MeasureUnit::create(8, 2, status);
684 }
685
createMicrosecond(UErrorCode & status)686 MeasureUnit *MeasureUnit::createMicrosecond(UErrorCode &status) {
687 return MeasureUnit::create(8, 3, status);
688 }
689
createMillisecond(UErrorCode & status)690 MeasureUnit *MeasureUnit::createMillisecond(UErrorCode &status) {
691 return MeasureUnit::create(8, 4, status);
692 }
693
createMinute(UErrorCode & status)694 MeasureUnit *MeasureUnit::createMinute(UErrorCode &status) {
695 return MeasureUnit::create(8, 5, status);
696 }
697
createMonth(UErrorCode & status)698 MeasureUnit *MeasureUnit::createMonth(UErrorCode &status) {
699 return MeasureUnit::create(8, 6, status);
700 }
701
createNanosecond(UErrorCode & status)702 MeasureUnit *MeasureUnit::createNanosecond(UErrorCode &status) {
703 return MeasureUnit::create(8, 7, status);
704 }
705
createSecond(UErrorCode & status)706 MeasureUnit *MeasureUnit::createSecond(UErrorCode &status) {
707 return MeasureUnit::create(8, 8, status);
708 }
709
createWeek(UErrorCode & status)710 MeasureUnit *MeasureUnit::createWeek(UErrorCode &status) {
711 return MeasureUnit::create(8, 9, status);
712 }
713
createYear(UErrorCode & status)714 MeasureUnit *MeasureUnit::createYear(UErrorCode &status) {
715 return MeasureUnit::create(8, 10, status);
716 }
717
createAmpere(UErrorCode & status)718 MeasureUnit *MeasureUnit::createAmpere(UErrorCode &status) {
719 return MeasureUnit::create(9, 0, status);
720 }
721
createMilliampere(UErrorCode & status)722 MeasureUnit *MeasureUnit::createMilliampere(UErrorCode &status) {
723 return MeasureUnit::create(9, 1, status);
724 }
725
createOhm(UErrorCode & status)726 MeasureUnit *MeasureUnit::createOhm(UErrorCode &status) {
727 return MeasureUnit::create(9, 2, status);
728 }
729
createVolt(UErrorCode & status)730 MeasureUnit *MeasureUnit::createVolt(UErrorCode &status) {
731 return MeasureUnit::create(9, 3, status);
732 }
733
createCalorie(UErrorCode & status)734 MeasureUnit *MeasureUnit::createCalorie(UErrorCode &status) {
735 return MeasureUnit::create(10, 0, status);
736 }
737
createFoodcalorie(UErrorCode & status)738 MeasureUnit *MeasureUnit::createFoodcalorie(UErrorCode &status) {
739 return MeasureUnit::create(10, 1, status);
740 }
741
createJoule(UErrorCode & status)742 MeasureUnit *MeasureUnit::createJoule(UErrorCode &status) {
743 return MeasureUnit::create(10, 2, status);
744 }
745
createKilocalorie(UErrorCode & status)746 MeasureUnit *MeasureUnit::createKilocalorie(UErrorCode &status) {
747 return MeasureUnit::create(10, 3, status);
748 }
749
createKilojoule(UErrorCode & status)750 MeasureUnit *MeasureUnit::createKilojoule(UErrorCode &status) {
751 return MeasureUnit::create(10, 4, status);
752 }
753
createKilowattHour(UErrorCode & status)754 MeasureUnit *MeasureUnit::createKilowattHour(UErrorCode &status) {
755 return MeasureUnit::create(10, 5, status);
756 }
757
createGigahertz(UErrorCode & status)758 MeasureUnit *MeasureUnit::createGigahertz(UErrorCode &status) {
759 return MeasureUnit::create(11, 0, status);
760 }
761
createHertz(UErrorCode & status)762 MeasureUnit *MeasureUnit::createHertz(UErrorCode &status) {
763 return MeasureUnit::create(11, 1, status);
764 }
765
createKilohertz(UErrorCode & status)766 MeasureUnit *MeasureUnit::createKilohertz(UErrorCode &status) {
767 return MeasureUnit::create(11, 2, status);
768 }
769
createMegahertz(UErrorCode & status)770 MeasureUnit *MeasureUnit::createMegahertz(UErrorCode &status) {
771 return MeasureUnit::create(11, 3, status);
772 }
773
createAstronomicalUnit(UErrorCode & status)774 MeasureUnit *MeasureUnit::createAstronomicalUnit(UErrorCode &status) {
775 return MeasureUnit::create(12, 0, status);
776 }
777
createCentimeter(UErrorCode & status)778 MeasureUnit *MeasureUnit::createCentimeter(UErrorCode &status) {
779 return MeasureUnit::create(12, 1, status);
780 }
781
createDecimeter(UErrorCode & status)782 MeasureUnit *MeasureUnit::createDecimeter(UErrorCode &status) {
783 return MeasureUnit::create(12, 2, status);
784 }
785
createFathom(UErrorCode & status)786 MeasureUnit *MeasureUnit::createFathom(UErrorCode &status) {
787 return MeasureUnit::create(12, 3, status);
788 }
789
createFoot(UErrorCode & status)790 MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) {
791 return MeasureUnit::create(12, 4, status);
792 }
793
createFurlong(UErrorCode & status)794 MeasureUnit *MeasureUnit::createFurlong(UErrorCode &status) {
795 return MeasureUnit::create(12, 5, status);
796 }
797
createInch(UErrorCode & status)798 MeasureUnit *MeasureUnit::createInch(UErrorCode &status) {
799 return MeasureUnit::create(12, 6, status);
800 }
801
createKilometer(UErrorCode & status)802 MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) {
803 return MeasureUnit::create(12, 7, status);
804 }
805
createLightYear(UErrorCode & status)806 MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) {
807 return MeasureUnit::create(12, 8, status);
808 }
809
createMeter(UErrorCode & status)810 MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) {
811 return MeasureUnit::create(12, 9, status);
812 }
813
createMicrometer(UErrorCode & status)814 MeasureUnit *MeasureUnit::createMicrometer(UErrorCode &status) {
815 return MeasureUnit::create(12, 10, status);
816 }
817
createMile(UErrorCode & status)818 MeasureUnit *MeasureUnit::createMile(UErrorCode &status) {
819 return MeasureUnit::create(12, 11, status);
820 }
821
createMileScandinavian(UErrorCode & status)822 MeasureUnit *MeasureUnit::createMileScandinavian(UErrorCode &status) {
823 return MeasureUnit::create(12, 12, status);
824 }
825
createMillimeter(UErrorCode & status)826 MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) {
827 return MeasureUnit::create(12, 13, status);
828 }
829
createNanometer(UErrorCode & status)830 MeasureUnit *MeasureUnit::createNanometer(UErrorCode &status) {
831 return MeasureUnit::create(12, 14, status);
832 }
833
createNauticalMile(UErrorCode & status)834 MeasureUnit *MeasureUnit::createNauticalMile(UErrorCode &status) {
835 return MeasureUnit::create(12, 15, status);
836 }
837
createParsec(UErrorCode & status)838 MeasureUnit *MeasureUnit::createParsec(UErrorCode &status) {
839 return MeasureUnit::create(12, 16, status);
840 }
841
createPicometer(UErrorCode & status)842 MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) {
843 return MeasureUnit::create(12, 17, status);
844 }
845
createYard(UErrorCode & status)846 MeasureUnit *MeasureUnit::createYard(UErrorCode &status) {
847 return MeasureUnit::create(12, 18, status);
848 }
849
createLux(UErrorCode & status)850 MeasureUnit *MeasureUnit::createLux(UErrorCode &status) {
851 return MeasureUnit::create(13, 0, status);
852 }
853
createCarat(UErrorCode & status)854 MeasureUnit *MeasureUnit::createCarat(UErrorCode &status) {
855 return MeasureUnit::create(14, 0, status);
856 }
857
createGram(UErrorCode & status)858 MeasureUnit *MeasureUnit::createGram(UErrorCode &status) {
859 return MeasureUnit::create(14, 1, status);
860 }
861
createKilogram(UErrorCode & status)862 MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) {
863 return MeasureUnit::create(14, 2, status);
864 }
865
createMetricTon(UErrorCode & status)866 MeasureUnit *MeasureUnit::createMetricTon(UErrorCode &status) {
867 return MeasureUnit::create(14, 3, status);
868 }
869
createMicrogram(UErrorCode & status)870 MeasureUnit *MeasureUnit::createMicrogram(UErrorCode &status) {
871 return MeasureUnit::create(14, 4, status);
872 }
873
createMilligram(UErrorCode & status)874 MeasureUnit *MeasureUnit::createMilligram(UErrorCode &status) {
875 return MeasureUnit::create(14, 5, status);
876 }
877
createOunce(UErrorCode & status)878 MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) {
879 return MeasureUnit::create(14, 6, status);
880 }
881
createOunceTroy(UErrorCode & status)882 MeasureUnit *MeasureUnit::createOunceTroy(UErrorCode &status) {
883 return MeasureUnit::create(14, 7, status);
884 }
885
createPound(UErrorCode & status)886 MeasureUnit *MeasureUnit::createPound(UErrorCode &status) {
887 return MeasureUnit::create(14, 8, status);
888 }
889
createStone(UErrorCode & status)890 MeasureUnit *MeasureUnit::createStone(UErrorCode &status) {
891 return MeasureUnit::create(14, 9, status);
892 }
893
createTon(UErrorCode & status)894 MeasureUnit *MeasureUnit::createTon(UErrorCode &status) {
895 return MeasureUnit::create(14, 10, status);
896 }
897
createGigawatt(UErrorCode & status)898 MeasureUnit *MeasureUnit::createGigawatt(UErrorCode &status) {
899 return MeasureUnit::create(15, 0, status);
900 }
901
createHorsepower(UErrorCode & status)902 MeasureUnit *MeasureUnit::createHorsepower(UErrorCode &status) {
903 return MeasureUnit::create(15, 1, status);
904 }
905
createKilowatt(UErrorCode & status)906 MeasureUnit *MeasureUnit::createKilowatt(UErrorCode &status) {
907 return MeasureUnit::create(15, 2, status);
908 }
909
createMegawatt(UErrorCode & status)910 MeasureUnit *MeasureUnit::createMegawatt(UErrorCode &status) {
911 return MeasureUnit::create(15, 3, status);
912 }
913
createMilliwatt(UErrorCode & status)914 MeasureUnit *MeasureUnit::createMilliwatt(UErrorCode &status) {
915 return MeasureUnit::create(15, 4, status);
916 }
917
createWatt(UErrorCode & status)918 MeasureUnit *MeasureUnit::createWatt(UErrorCode &status) {
919 return MeasureUnit::create(15, 5, status);
920 }
921
createHectopascal(UErrorCode & status)922 MeasureUnit *MeasureUnit::createHectopascal(UErrorCode &status) {
923 return MeasureUnit::create(16, 0, status);
924 }
925
createInchHg(UErrorCode & status)926 MeasureUnit *MeasureUnit::createInchHg(UErrorCode &status) {
927 return MeasureUnit::create(16, 1, status);
928 }
929
createMillibar(UErrorCode & status)930 MeasureUnit *MeasureUnit::createMillibar(UErrorCode &status) {
931 return MeasureUnit::create(16, 2, status);
932 }
933
createMillimeterOfMercury(UErrorCode & status)934 MeasureUnit *MeasureUnit::createMillimeterOfMercury(UErrorCode &status) {
935 return MeasureUnit::create(16, 3, status);
936 }
937
createPoundPerSquareInch(UErrorCode & status)938 MeasureUnit *MeasureUnit::createPoundPerSquareInch(UErrorCode &status) {
939 return MeasureUnit::create(16, 4, status);
940 }
941
createKilometerPerHour(UErrorCode & status)942 MeasureUnit *MeasureUnit::createKilometerPerHour(UErrorCode &status) {
943 return MeasureUnit::create(17, 0, status);
944 }
945
createKnot(UErrorCode & status)946 MeasureUnit *MeasureUnit::createKnot(UErrorCode &status) {
947 return MeasureUnit::create(17, 1, status);
948 }
949
createMeterPerSecond(UErrorCode & status)950 MeasureUnit *MeasureUnit::createMeterPerSecond(UErrorCode &status) {
951 return MeasureUnit::create(17, 2, status);
952 }
953
createMilePerHour(UErrorCode & status)954 MeasureUnit *MeasureUnit::createMilePerHour(UErrorCode &status) {
955 return MeasureUnit::create(17, 3, status);
956 }
957
createCelsius(UErrorCode & status)958 MeasureUnit *MeasureUnit::createCelsius(UErrorCode &status) {
959 return MeasureUnit::create(18, 0, status);
960 }
961
createFahrenheit(UErrorCode & status)962 MeasureUnit *MeasureUnit::createFahrenheit(UErrorCode &status) {
963 return MeasureUnit::create(18, 1, status);
964 }
965
createGenericTemperature(UErrorCode & status)966 MeasureUnit *MeasureUnit::createGenericTemperature(UErrorCode &status) {
967 return MeasureUnit::create(18, 2, status);
968 }
969
createKelvin(UErrorCode & status)970 MeasureUnit *MeasureUnit::createKelvin(UErrorCode &status) {
971 return MeasureUnit::create(18, 3, status);
972 }
973
createAcreFoot(UErrorCode & status)974 MeasureUnit *MeasureUnit::createAcreFoot(UErrorCode &status) {
975 return MeasureUnit::create(19, 0, status);
976 }
977
createBushel(UErrorCode & status)978 MeasureUnit *MeasureUnit::createBushel(UErrorCode &status) {
979 return MeasureUnit::create(19, 1, status);
980 }
981
createCentiliter(UErrorCode & status)982 MeasureUnit *MeasureUnit::createCentiliter(UErrorCode &status) {
983 return MeasureUnit::create(19, 2, status);
984 }
985
createCubicCentimeter(UErrorCode & status)986 MeasureUnit *MeasureUnit::createCubicCentimeter(UErrorCode &status) {
987 return MeasureUnit::create(19, 3, status);
988 }
989
createCubicFoot(UErrorCode & status)990 MeasureUnit *MeasureUnit::createCubicFoot(UErrorCode &status) {
991 return MeasureUnit::create(19, 4, status);
992 }
993
createCubicInch(UErrorCode & status)994 MeasureUnit *MeasureUnit::createCubicInch(UErrorCode &status) {
995 return MeasureUnit::create(19, 5, status);
996 }
997
createCubicKilometer(UErrorCode & status)998 MeasureUnit *MeasureUnit::createCubicKilometer(UErrorCode &status) {
999 return MeasureUnit::create(19, 6, status);
1000 }
1001
createCubicMeter(UErrorCode & status)1002 MeasureUnit *MeasureUnit::createCubicMeter(UErrorCode &status) {
1003 return MeasureUnit::create(19, 7, status);
1004 }
1005
createCubicMile(UErrorCode & status)1006 MeasureUnit *MeasureUnit::createCubicMile(UErrorCode &status) {
1007 return MeasureUnit::create(19, 8, status);
1008 }
1009
createCubicYard(UErrorCode & status)1010 MeasureUnit *MeasureUnit::createCubicYard(UErrorCode &status) {
1011 return MeasureUnit::create(19, 9, status);
1012 }
1013
createCup(UErrorCode & status)1014 MeasureUnit *MeasureUnit::createCup(UErrorCode &status) {
1015 return MeasureUnit::create(19, 10, status);
1016 }
1017
createCupMetric(UErrorCode & status)1018 MeasureUnit *MeasureUnit::createCupMetric(UErrorCode &status) {
1019 return MeasureUnit::create(19, 11, status);
1020 }
1021
createDeciliter(UErrorCode & status)1022 MeasureUnit *MeasureUnit::createDeciliter(UErrorCode &status) {
1023 return MeasureUnit::create(19, 12, status);
1024 }
1025
createFluidOunce(UErrorCode & status)1026 MeasureUnit *MeasureUnit::createFluidOunce(UErrorCode &status) {
1027 return MeasureUnit::create(19, 13, status);
1028 }
1029
createGallon(UErrorCode & status)1030 MeasureUnit *MeasureUnit::createGallon(UErrorCode &status) {
1031 return MeasureUnit::create(19, 14, status);
1032 }
1033
createGallonImperial(UErrorCode & status)1034 MeasureUnit *MeasureUnit::createGallonImperial(UErrorCode &status) {
1035 return MeasureUnit::create(19, 15, status);
1036 }
1037
createHectoliter(UErrorCode & status)1038 MeasureUnit *MeasureUnit::createHectoliter(UErrorCode &status) {
1039 return MeasureUnit::create(19, 16, status);
1040 }
1041
createLiter(UErrorCode & status)1042 MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) {
1043 return MeasureUnit::create(19, 17, status);
1044 }
1045
createMegaliter(UErrorCode & status)1046 MeasureUnit *MeasureUnit::createMegaliter(UErrorCode &status) {
1047 return MeasureUnit::create(19, 18, status);
1048 }
1049
createMilliliter(UErrorCode & status)1050 MeasureUnit *MeasureUnit::createMilliliter(UErrorCode &status) {
1051 return MeasureUnit::create(19, 19, status);
1052 }
1053
createPint(UErrorCode & status)1054 MeasureUnit *MeasureUnit::createPint(UErrorCode &status) {
1055 return MeasureUnit::create(19, 20, status);
1056 }
1057
createPintMetric(UErrorCode & status)1058 MeasureUnit *MeasureUnit::createPintMetric(UErrorCode &status) {
1059 return MeasureUnit::create(19, 21, status);
1060 }
1061
createQuart(UErrorCode & status)1062 MeasureUnit *MeasureUnit::createQuart(UErrorCode &status) {
1063 return MeasureUnit::create(19, 22, status);
1064 }
1065
createTablespoon(UErrorCode & status)1066 MeasureUnit *MeasureUnit::createTablespoon(UErrorCode &status) {
1067 return MeasureUnit::create(19, 23, status);
1068 }
1069
createTeaspoon(UErrorCode & status)1070 MeasureUnit *MeasureUnit::createTeaspoon(UErrorCode &status) {
1071 return MeasureUnit::create(19, 24, status);
1072 }
1073
1074 // End generated code
1075
binarySearch(const char * const * array,int32_t start,int32_t end,const char * key)1076 static int32_t binarySearch(
1077 const char * const * array, int32_t start, int32_t end, const char * key) {
1078 while (start < end) {
1079 int32_t mid = (start + end) / 2;
1080 int32_t cmp = uprv_strcmp(array[mid], key);
1081 if (cmp < 0) {
1082 start = mid + 1;
1083 continue;
1084 }
1085 if (cmp == 0) {
1086 return mid;
1087 }
1088 end = mid;
1089 }
1090 return -1;
1091 }
1092
MeasureUnit(const MeasureUnit & other)1093 MeasureUnit::MeasureUnit(const MeasureUnit &other)
1094 : fTypeId(other.fTypeId), fSubTypeId(other.fSubTypeId) {
1095 uprv_strcpy(fCurrency, other.fCurrency);
1096 }
1097
operator =(const MeasureUnit & other)1098 MeasureUnit &MeasureUnit::operator=(const MeasureUnit &other) {
1099 if (this == &other) {
1100 return *this;
1101 }
1102 fTypeId = other.fTypeId;
1103 fSubTypeId = other.fSubTypeId;
1104 uprv_strcpy(fCurrency, other.fCurrency);
1105 return *this;
1106 }
1107
clone() const1108 UObject *MeasureUnit::clone() const {
1109 return new MeasureUnit(*this);
1110 }
1111
~MeasureUnit()1112 MeasureUnit::~MeasureUnit() {
1113 }
1114
getType() const1115 const char *MeasureUnit::getType() const {
1116 return gTypes[fTypeId];
1117 }
1118
getSubtype() const1119 const char *MeasureUnit::getSubtype() const {
1120 return fCurrency[0] == 0 ? gSubTypes[getOffset()] : fCurrency;
1121 }
1122
operator ==(const UObject & other) const1123 UBool MeasureUnit::operator==(const UObject& other) const {
1124 if (this == &other) { // Same object, equal
1125 return TRUE;
1126 }
1127 if (typeid(*this) != typeid(other)) { // Different types, not equal
1128 return FALSE;
1129 }
1130 const MeasureUnit &rhs = static_cast<const MeasureUnit&>(other);
1131 return (
1132 fTypeId == rhs.fTypeId
1133 && fSubTypeId == rhs.fSubTypeId
1134 && uprv_strcmp(fCurrency, rhs.fCurrency) == 0);
1135 }
1136
getIndex() const1137 int32_t MeasureUnit::getIndex() const {
1138 return gIndexes[fTypeId] + fSubTypeId;
1139 }
1140
getAvailable(MeasureUnit * dest,int32_t destCapacity,UErrorCode & errorCode)1141 int32_t MeasureUnit::getAvailable(
1142 MeasureUnit *dest,
1143 int32_t destCapacity,
1144 UErrorCode &errorCode) {
1145 if (U_FAILURE(errorCode)) {
1146 return 0;
1147 }
1148 if (destCapacity < UPRV_LENGTHOF(gSubTypes)) {
1149 errorCode = U_BUFFER_OVERFLOW_ERROR;
1150 return UPRV_LENGTHOF(gSubTypes);
1151 }
1152 int32_t idx = 0;
1153 for (int32_t typeIdx = 0; typeIdx < UPRV_LENGTHOF(gTypes); ++typeIdx) {
1154 int32_t len = gOffsets[typeIdx + 1] - gOffsets[typeIdx];
1155 for (int32_t subTypeIdx = 0; subTypeIdx < len; ++subTypeIdx) {
1156 dest[idx].setTo(typeIdx, subTypeIdx);
1157 ++idx;
1158 }
1159 }
1160 U_ASSERT(idx == UPRV_LENGTHOF(gSubTypes));
1161 return UPRV_LENGTHOF(gSubTypes);
1162 }
1163
getAvailable(const char * type,MeasureUnit * dest,int32_t destCapacity,UErrorCode & errorCode)1164 int32_t MeasureUnit::getAvailable(
1165 const char *type,
1166 MeasureUnit *dest,
1167 int32_t destCapacity,
1168 UErrorCode &errorCode) {
1169 if (U_FAILURE(errorCode)) {
1170 return 0;
1171 }
1172 int32_t typeIdx = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), type);
1173 if (typeIdx == -1) {
1174 return 0;
1175 }
1176 int32_t len = gOffsets[typeIdx + 1] - gOffsets[typeIdx];
1177 if (destCapacity < len) {
1178 errorCode = U_BUFFER_OVERFLOW_ERROR;
1179 return len;
1180 }
1181 for (int subTypeIdx = 0; subTypeIdx < len; ++subTypeIdx) {
1182 dest[subTypeIdx].setTo(typeIdx, subTypeIdx);
1183 }
1184 return len;
1185 }
1186
getAvailableTypes(UErrorCode & errorCode)1187 StringEnumeration* MeasureUnit::getAvailableTypes(UErrorCode &errorCode) {
1188 UEnumeration *uenum = uenum_openCharStringsEnumeration(
1189 gTypes, UPRV_LENGTHOF(gTypes), &errorCode);
1190 if (U_FAILURE(errorCode)) {
1191 uenum_close(uenum);
1192 return NULL;
1193 }
1194 StringEnumeration *result = new UStringEnumeration(uenum);
1195 if (result == NULL) {
1196 errorCode = U_MEMORY_ALLOCATION_ERROR;
1197 uenum_close(uenum);
1198 return NULL;
1199 }
1200 return result;
1201 }
1202
getIndexCount()1203 int32_t MeasureUnit::getIndexCount() {
1204 return gIndexes[UPRV_LENGTHOF(gIndexes) - 1];
1205 }
1206
internalGetIndexForTypeAndSubtype(const char * type,const char * subtype)1207 int32_t MeasureUnit::internalGetIndexForTypeAndSubtype(const char *type, const char *subtype) {
1208 int32_t t = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), type);
1209 if (t < 0) {
1210 return t;
1211 }
1212 int32_t st = binarySearch(gSubTypes, gOffsets[t], gOffsets[t + 1], subtype);
1213 if (st < 0) {
1214 return st;
1215 }
1216 return gIndexes[t] + st - gOffsets[t];
1217 }
1218
resolveUnitPerUnit(const MeasureUnit & unit,const MeasureUnit & perUnit)1219 MeasureUnit *MeasureUnit::resolveUnitPerUnit(
1220 const MeasureUnit &unit, const MeasureUnit &perUnit) {
1221 int32_t unitOffset = unit.getOffset();
1222 int32_t perUnitOffset = perUnit.getOffset();
1223
1224 // binary search for (unitOffset, perUnitOffset)
1225 int32_t start = 0;
1226 int32_t end = UPRV_LENGTHOF(unitPerUnitToSingleUnit);
1227 while (start < end) {
1228 int32_t mid = (start + end) / 2;
1229 int32_t *midRow = unitPerUnitToSingleUnit[mid];
1230 if (unitOffset < midRow[0]) {
1231 end = mid;
1232 } else if (unitOffset > midRow[0]) {
1233 start = mid + 1;
1234 } else if (perUnitOffset < midRow[1]) {
1235 end = mid;
1236 } else if (perUnitOffset > midRow[1]) {
1237 start = mid + 1;
1238 } else {
1239 // We found a resolution for our unit / per-unit combo
1240 // return it.
1241 return new MeasureUnit(midRow[2], midRow[3]);
1242 }
1243 }
1244 return NULL;
1245 }
1246
create(int typeId,int subTypeId,UErrorCode & status)1247 MeasureUnit *MeasureUnit::create(int typeId, int subTypeId, UErrorCode &status) {
1248 if (U_FAILURE(status)) {
1249 return NULL;
1250 }
1251 MeasureUnit *result = new MeasureUnit(typeId, subTypeId);
1252 if (result == NULL) {
1253 status = U_MEMORY_ALLOCATION_ERROR;
1254 }
1255 return result;
1256 }
1257
initTime(const char * timeId)1258 void MeasureUnit::initTime(const char *timeId) {
1259 int32_t result = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), "duration");
1260 U_ASSERT(result != -1);
1261 fTypeId = result;
1262 result = binarySearch(gSubTypes, gOffsets[fTypeId], gOffsets[fTypeId + 1], timeId);
1263 U_ASSERT(result != -1);
1264 fSubTypeId = result - gOffsets[fTypeId];
1265 }
1266
initCurrency(const char * isoCurrency)1267 void MeasureUnit::initCurrency(const char *isoCurrency) {
1268 int32_t result = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), "currency");
1269 U_ASSERT(result != -1);
1270 fTypeId = result;
1271 result = binarySearch(
1272 gSubTypes, gOffsets[fTypeId], gOffsets[fTypeId + 1], isoCurrency);
1273 if (result != -1) {
1274 fSubTypeId = result - gOffsets[fTypeId];
1275 } else {
1276 uprv_strncpy(fCurrency, isoCurrency, UPRV_LENGTHOF(fCurrency));
1277 fCurrency[3] = 0;
1278 }
1279 }
1280
setTo(int32_t typeId,int32_t subTypeId)1281 void MeasureUnit::setTo(int32_t typeId, int32_t subTypeId) {
1282 fTypeId = typeId;
1283 fSubTypeId = subTypeId;
1284 fCurrency[0] = 0;
1285 }
1286
getOffset() const1287 int32_t MeasureUnit::getOffset() const {
1288 return gOffsets[fTypeId] + fSubTypeId;
1289 }
1290
1291 U_NAMESPACE_END
1292
1293 #endif /* !UNCONFIG_NO_FORMATTING */
1294