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 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 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 57 static 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. 81 static 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. 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 "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. 489 static 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 498 MeasureUnit *MeasureUnit::createGForce(UErrorCode &status) { 499 return MeasureUnit::create(0, 0, status); 500 } 501 502 MeasureUnit *MeasureUnit::createMeterPerSecondSquared(UErrorCode &status) { 503 return MeasureUnit::create(0, 1, status); 504 } 505 506 MeasureUnit *MeasureUnit::createArcMinute(UErrorCode &status) { 507 return MeasureUnit::create(1, 0, status); 508 } 509 510 MeasureUnit *MeasureUnit::createArcSecond(UErrorCode &status) { 511 return MeasureUnit::create(1, 1, status); 512 } 513 514 MeasureUnit *MeasureUnit::createDegree(UErrorCode &status) { 515 return MeasureUnit::create(1, 2, status); 516 } 517 518 MeasureUnit *MeasureUnit::createRadian(UErrorCode &status) { 519 return MeasureUnit::create(1, 3, status); 520 } 521 522 MeasureUnit *MeasureUnit::createAcre(UErrorCode &status) { 523 return MeasureUnit::create(2, 0, status); 524 } 525 526 MeasureUnit *MeasureUnit::createHectare(UErrorCode &status) { 527 return MeasureUnit::create(2, 1, status); 528 } 529 530 MeasureUnit *MeasureUnit::createSquareCentimeter(UErrorCode &status) { 531 return MeasureUnit::create(2, 2, status); 532 } 533 534 MeasureUnit *MeasureUnit::createSquareFoot(UErrorCode &status) { 535 return MeasureUnit::create(2, 3, status); 536 } 537 538 MeasureUnit *MeasureUnit::createSquareInch(UErrorCode &status) { 539 return MeasureUnit::create(2, 4, status); 540 } 541 542 MeasureUnit *MeasureUnit::createSquareKilometer(UErrorCode &status) { 543 return MeasureUnit::create(2, 5, status); 544 } 545 546 MeasureUnit *MeasureUnit::createSquareMeter(UErrorCode &status) { 547 return MeasureUnit::create(2, 6, status); 548 } 549 550 MeasureUnit *MeasureUnit::createSquareMile(UErrorCode &status) { 551 return MeasureUnit::create(2, 7, status); 552 } 553 554 MeasureUnit *MeasureUnit::createSquareYard(UErrorCode &status) { 555 return MeasureUnit::create(2, 8, status); 556 } 557 558 MeasureUnit *MeasureUnit::createLiterPerKilometer(UErrorCode &status) { 559 return MeasureUnit::create(3, 0, status); 560 } 561 562 MeasureUnit *MeasureUnit::createMilePerGallon(UErrorCode &status) { 563 return MeasureUnit::create(3, 1, status); 564 } 565 566 MeasureUnit *MeasureUnit::createBit(UErrorCode &status) { 567 return MeasureUnit::create(5, 0, status); 568 } 569 570 MeasureUnit *MeasureUnit::createByte(UErrorCode &status) { 571 return MeasureUnit::create(5, 1, status); 572 } 573 574 MeasureUnit *MeasureUnit::createGigabit(UErrorCode &status) { 575 return MeasureUnit::create(5, 2, status); 576 } 577 578 MeasureUnit *MeasureUnit::createGigabyte(UErrorCode &status) { 579 return MeasureUnit::create(5, 3, status); 580 } 581 582 MeasureUnit *MeasureUnit::createKilobit(UErrorCode &status) { 583 return MeasureUnit::create(5, 4, status); 584 } 585 586 MeasureUnit *MeasureUnit::createKilobyte(UErrorCode &status) { 587 return MeasureUnit::create(5, 5, status); 588 } 589 590 MeasureUnit *MeasureUnit::createMegabit(UErrorCode &status) { 591 return MeasureUnit::create(5, 6, status); 592 } 593 594 MeasureUnit *MeasureUnit::createMegabyte(UErrorCode &status) { 595 return MeasureUnit::create(5, 7, status); 596 } 597 598 MeasureUnit *MeasureUnit::createTerabit(UErrorCode &status) { 599 return MeasureUnit::create(5, 8, status); 600 } 601 602 MeasureUnit *MeasureUnit::createTerabyte(UErrorCode &status) { 603 return MeasureUnit::create(5, 9, status); 604 } 605 606 MeasureUnit *MeasureUnit::createDay(UErrorCode &status) { 607 return MeasureUnit::create(6, 0, status); 608 } 609 610 MeasureUnit *MeasureUnit::createHour(UErrorCode &status) { 611 return MeasureUnit::create(6, 1, status); 612 } 613 614 MeasureUnit *MeasureUnit::createMicrosecond(UErrorCode &status) { 615 return MeasureUnit::create(6, 2, status); 616 } 617 618 MeasureUnit *MeasureUnit::createMillisecond(UErrorCode &status) { 619 return MeasureUnit::create(6, 3, status); 620 } 621 622 MeasureUnit *MeasureUnit::createMinute(UErrorCode &status) { 623 return MeasureUnit::create(6, 4, status); 624 } 625 626 MeasureUnit *MeasureUnit::createMonth(UErrorCode &status) { 627 return MeasureUnit::create(6, 5, status); 628 } 629 630 MeasureUnit *MeasureUnit::createNanosecond(UErrorCode &status) { 631 return MeasureUnit::create(6, 6, status); 632 } 633 634 MeasureUnit *MeasureUnit::createSecond(UErrorCode &status) { 635 return MeasureUnit::create(6, 7, status); 636 } 637 638 MeasureUnit *MeasureUnit::createWeek(UErrorCode &status) { 639 return MeasureUnit::create(6, 8, status); 640 } 641 642 MeasureUnit *MeasureUnit::createYear(UErrorCode &status) { 643 return MeasureUnit::create(6, 9, status); 644 } 645 646 MeasureUnit *MeasureUnit::createAmpere(UErrorCode &status) { 647 return MeasureUnit::create(7, 0, status); 648 } 649 650 MeasureUnit *MeasureUnit::createMilliampere(UErrorCode &status) { 651 return MeasureUnit::create(7, 1, status); 652 } 653 654 MeasureUnit *MeasureUnit::createOhm(UErrorCode &status) { 655 return MeasureUnit::create(7, 2, status); 656 } 657 658 MeasureUnit *MeasureUnit::createVolt(UErrorCode &status) { 659 return MeasureUnit::create(7, 3, status); 660 } 661 662 MeasureUnit *MeasureUnit::createCalorie(UErrorCode &status) { 663 return MeasureUnit::create(8, 0, status); 664 } 665 666 MeasureUnit *MeasureUnit::createFoodcalorie(UErrorCode &status) { 667 return MeasureUnit::create(8, 1, status); 668 } 669 670 MeasureUnit *MeasureUnit::createJoule(UErrorCode &status) { 671 return MeasureUnit::create(8, 2, status); 672 } 673 674 MeasureUnit *MeasureUnit::createKilocalorie(UErrorCode &status) { 675 return MeasureUnit::create(8, 3, status); 676 } 677 678 MeasureUnit *MeasureUnit::createKilojoule(UErrorCode &status) { 679 return MeasureUnit::create(8, 4, status); 680 } 681 682 MeasureUnit *MeasureUnit::createKilowattHour(UErrorCode &status) { 683 return MeasureUnit::create(8, 5, status); 684 } 685 686 MeasureUnit *MeasureUnit::createGigahertz(UErrorCode &status) { 687 return MeasureUnit::create(9, 0, status); 688 } 689 690 MeasureUnit *MeasureUnit::createHertz(UErrorCode &status) { 691 return MeasureUnit::create(9, 1, status); 692 } 693 694 MeasureUnit *MeasureUnit::createKilohertz(UErrorCode &status) { 695 return MeasureUnit::create(9, 2, status); 696 } 697 698 MeasureUnit *MeasureUnit::createMegahertz(UErrorCode &status) { 699 return MeasureUnit::create(9, 3, status); 700 } 701 702 MeasureUnit *MeasureUnit::createAstronomicalUnit(UErrorCode &status) { 703 return MeasureUnit::create(10, 0, status); 704 } 705 706 MeasureUnit *MeasureUnit::createCentimeter(UErrorCode &status) { 707 return MeasureUnit::create(10, 1, status); 708 } 709 710 MeasureUnit *MeasureUnit::createDecimeter(UErrorCode &status) { 711 return MeasureUnit::create(10, 2, status); 712 } 713 714 MeasureUnit *MeasureUnit::createFathom(UErrorCode &status) { 715 return MeasureUnit::create(10, 3, status); 716 } 717 718 MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) { 719 return MeasureUnit::create(10, 4, status); 720 } 721 722 MeasureUnit *MeasureUnit::createFurlong(UErrorCode &status) { 723 return MeasureUnit::create(10, 5, status); 724 } 725 726 MeasureUnit *MeasureUnit::createInch(UErrorCode &status) { 727 return MeasureUnit::create(10, 6, status); 728 } 729 730 MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) { 731 return MeasureUnit::create(10, 7, status); 732 } 733 734 MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) { 735 return MeasureUnit::create(10, 8, status); 736 } 737 738 MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) { 739 return MeasureUnit::create(10, 9, status); 740 } 741 742 MeasureUnit *MeasureUnit::createMicrometer(UErrorCode &status) { 743 return MeasureUnit::create(10, 10, status); 744 } 745 746 MeasureUnit *MeasureUnit::createMile(UErrorCode &status) { 747 return MeasureUnit::create(10, 11, status); 748 } 749 750 MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) { 751 return MeasureUnit::create(10, 12, status); 752 } 753 754 MeasureUnit *MeasureUnit::createNanometer(UErrorCode &status) { 755 return MeasureUnit::create(10, 13, status); 756 } 757 758 MeasureUnit *MeasureUnit::createNauticalMile(UErrorCode &status) { 759 return MeasureUnit::create(10, 14, status); 760 } 761 762 MeasureUnit *MeasureUnit::createParsec(UErrorCode &status) { 763 return MeasureUnit::create(10, 15, status); 764 } 765 766 MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) { 767 return MeasureUnit::create(10, 16, status); 768 } 769 770 MeasureUnit *MeasureUnit::createYard(UErrorCode &status) { 771 return MeasureUnit::create(10, 17, status); 772 } 773 774 MeasureUnit *MeasureUnit::createLux(UErrorCode &status) { 775 return MeasureUnit::create(11, 0, status); 776 } 777 778 MeasureUnit *MeasureUnit::createCarat(UErrorCode &status) { 779 return MeasureUnit::create(12, 0, status); 780 } 781 782 MeasureUnit *MeasureUnit::createGram(UErrorCode &status) { 783 return MeasureUnit::create(12, 1, status); 784 } 785 786 MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) { 787 return MeasureUnit::create(12, 2, status); 788 } 789 790 MeasureUnit *MeasureUnit::createMetricTon(UErrorCode &status) { 791 return MeasureUnit::create(12, 3, status); 792 } 793 794 MeasureUnit *MeasureUnit::createMicrogram(UErrorCode &status) { 795 return MeasureUnit::create(12, 4, status); 796 } 797 798 MeasureUnit *MeasureUnit::createMilligram(UErrorCode &status) { 799 return MeasureUnit::create(12, 5, status); 800 } 801 802 MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) { 803 return MeasureUnit::create(12, 6, status); 804 } 805 806 MeasureUnit *MeasureUnit::createOunceTroy(UErrorCode &status) { 807 return MeasureUnit::create(12, 7, status); 808 } 809 810 MeasureUnit *MeasureUnit::createPound(UErrorCode &status) { 811 return MeasureUnit::create(12, 8, status); 812 } 813 814 MeasureUnit *MeasureUnit::createStone(UErrorCode &status) { 815 return MeasureUnit::create(12, 9, status); 816 } 817 818 MeasureUnit *MeasureUnit::createTon(UErrorCode &status) { 819 return MeasureUnit::create(12, 10, status); 820 } 821 822 MeasureUnit *MeasureUnit::createGigawatt(UErrorCode &status) { 823 return MeasureUnit::create(13, 0, status); 824 } 825 826 MeasureUnit *MeasureUnit::createHorsepower(UErrorCode &status) { 827 return MeasureUnit::create(13, 1, status); 828 } 829 830 MeasureUnit *MeasureUnit::createKilowatt(UErrorCode &status) { 831 return MeasureUnit::create(13, 2, status); 832 } 833 834 MeasureUnit *MeasureUnit::createMegawatt(UErrorCode &status) { 835 return MeasureUnit::create(13, 3, status); 836 } 837 838 MeasureUnit *MeasureUnit::createMilliwatt(UErrorCode &status) { 839 return MeasureUnit::create(13, 4, status); 840 } 841 842 MeasureUnit *MeasureUnit::createWatt(UErrorCode &status) { 843 return MeasureUnit::create(13, 5, status); 844 } 845 846 MeasureUnit *MeasureUnit::createHectopascal(UErrorCode &status) { 847 return MeasureUnit::create(14, 0, status); 848 } 849 850 MeasureUnit *MeasureUnit::createInchHg(UErrorCode &status) { 851 return MeasureUnit::create(14, 1, status); 852 } 853 854 MeasureUnit *MeasureUnit::createMillibar(UErrorCode &status) { 855 return MeasureUnit::create(14, 2, status); 856 } 857 858 MeasureUnit *MeasureUnit::createMillimeterOfMercury(UErrorCode &status) { 859 return MeasureUnit::create(14, 3, status); 860 } 861 862 MeasureUnit *MeasureUnit::createPoundPerSquareInch(UErrorCode &status) { 863 return MeasureUnit::create(14, 4, status); 864 } 865 866 MeasureUnit *MeasureUnit::createKarat(UErrorCode &status) { 867 return MeasureUnit::create(15, 0, status); 868 } 869 870 MeasureUnit *MeasureUnit::createKilometerPerHour(UErrorCode &status) { 871 return MeasureUnit::create(16, 0, status); 872 } 873 874 MeasureUnit *MeasureUnit::createMeterPerSecond(UErrorCode &status) { 875 return MeasureUnit::create(16, 1, status); 876 } 877 878 MeasureUnit *MeasureUnit::createMilePerHour(UErrorCode &status) { 879 return MeasureUnit::create(16, 2, status); 880 } 881 882 MeasureUnit *MeasureUnit::createCelsius(UErrorCode &status) { 883 return MeasureUnit::create(17, 0, status); 884 } 885 886 MeasureUnit *MeasureUnit::createFahrenheit(UErrorCode &status) { 887 return MeasureUnit::create(17, 1, status); 888 } 889 890 MeasureUnit *MeasureUnit::createKelvin(UErrorCode &status) { 891 return MeasureUnit::create(17, 2, status); 892 } 893 894 MeasureUnit *MeasureUnit::createAcreFoot(UErrorCode &status) { 895 return MeasureUnit::create(18, 0, status); 896 } 897 898 MeasureUnit *MeasureUnit::createBushel(UErrorCode &status) { 899 return MeasureUnit::create(18, 1, status); 900 } 901 902 MeasureUnit *MeasureUnit::createCentiliter(UErrorCode &status) { 903 return MeasureUnit::create(18, 2, status); 904 } 905 906 MeasureUnit *MeasureUnit::createCubicCentimeter(UErrorCode &status) { 907 return MeasureUnit::create(18, 3, status); 908 } 909 910 MeasureUnit *MeasureUnit::createCubicFoot(UErrorCode &status) { 911 return MeasureUnit::create(18, 4, status); 912 } 913 914 MeasureUnit *MeasureUnit::createCubicInch(UErrorCode &status) { 915 return MeasureUnit::create(18, 5, status); 916 } 917 918 MeasureUnit *MeasureUnit::createCubicKilometer(UErrorCode &status) { 919 return MeasureUnit::create(18, 6, status); 920 } 921 922 MeasureUnit *MeasureUnit::createCubicMeter(UErrorCode &status) { 923 return MeasureUnit::create(18, 7, status); 924 } 925 926 MeasureUnit *MeasureUnit::createCubicMile(UErrorCode &status) { 927 return MeasureUnit::create(18, 8, status); 928 } 929 930 MeasureUnit *MeasureUnit::createCubicYard(UErrorCode &status) { 931 return MeasureUnit::create(18, 9, status); 932 } 933 934 MeasureUnit *MeasureUnit::createCup(UErrorCode &status) { 935 return MeasureUnit::create(18, 10, status); 936 } 937 938 MeasureUnit *MeasureUnit::createDeciliter(UErrorCode &status) { 939 return MeasureUnit::create(18, 11, status); 940 } 941 942 MeasureUnit *MeasureUnit::createFluidOunce(UErrorCode &status) { 943 return MeasureUnit::create(18, 12, status); 944 } 945 946 MeasureUnit *MeasureUnit::createGallon(UErrorCode &status) { 947 return MeasureUnit::create(18, 13, status); 948 } 949 950 MeasureUnit *MeasureUnit::createHectoliter(UErrorCode &status) { 951 return MeasureUnit::create(18, 14, status); 952 } 953 954 MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) { 955 return MeasureUnit::create(18, 15, status); 956 } 957 958 MeasureUnit *MeasureUnit::createMegaliter(UErrorCode &status) { 959 return MeasureUnit::create(18, 16, status); 960 } 961 962 MeasureUnit *MeasureUnit::createMilliliter(UErrorCode &status) { 963 return MeasureUnit::create(18, 17, status); 964 } 965 966 MeasureUnit *MeasureUnit::createPint(UErrorCode &status) { 967 return MeasureUnit::create(18, 18, status); 968 } 969 970 MeasureUnit *MeasureUnit::createQuart(UErrorCode &status) { 971 return MeasureUnit::create(18, 19, status); 972 } 973 974 MeasureUnit *MeasureUnit::createTablespoon(UErrorCode &status) { 975 return MeasureUnit::create(18, 20, status); 976 } 977 978 MeasureUnit *MeasureUnit::createTeaspoon(UErrorCode &status) { 979 return MeasureUnit::create(18, 21, status); 980 } 981 982 // End generated code 983 984 static 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 1001 MeasureUnit::MeasureUnit(const MeasureUnit &other) 1002 : fTypeId(other.fTypeId), fSubTypeId(other.fSubTypeId) { 1003 uprv_strcpy(fCurrency, other.fCurrency); 1004 } 1005 1006 MeasureUnit &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 1016 UObject *MeasureUnit::clone() const { 1017 return new MeasureUnit(*this); 1018 } 1019 1020 MeasureUnit::~MeasureUnit() { 1021 } 1022 1023 const char *MeasureUnit::getType() const { 1024 return gTypes[fTypeId]; 1025 } 1026 1027 const char *MeasureUnit::getSubtype() const { 1028 return fCurrency[0] == 0 ? gSubTypes[getOffset()] : fCurrency; 1029 } 1030 1031 UBool 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 1045 int32_t MeasureUnit::getIndex() const { 1046 return gIndexes[fTypeId] + fSubTypeId; 1047 } 1048 1049 int32_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 1072 int32_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 1095 StringEnumeration* 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 1111 int32_t MeasureUnit::getIndexCount() { 1112 return gIndexes[UPRV_LENGTHOF(gIndexes) - 1]; 1113 } 1114 1115 MeasureUnit *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 1143 MeasureUnit *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 1154 void 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 1163 void 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 1176 void MeasureUnit::setTo(int32_t typeId, int32_t subTypeId) { 1177 fTypeId = typeId; 1178 fSubTypeId = subTypeId; 1179 fCurrency[0] = 0; 1180 } 1181 1182 int32_t MeasureUnit::getOffset() const { 1183 return gOffsets[fTypeId] + fSubTypeId; 1184 } 1185 1186 U_NAMESPACE_END 1187 1188 #endif /* !UNCONFIG_NO_FORMATTING */ 1189
