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