icuSources/i18n/measunit.cpp

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