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