1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ********************************************************************** 5 * Copyright (c) 2004-2016, International Business Machines 6 * Corporation and others. All Rights Reserved. 7 ********************************************************************** 8 * Author: Alan Liu 9 * Created: April 26, 2004 10 * Since: ICU 3.0 11 ********************************************************************** 12 */ 13 #ifndef __MEASUREUNIT_H__ 14 #define __MEASUREUNIT_H__ 15 16 #include "unicode/utypes.h" 17 18 #if !UCONFIG_NO_FORMATTING 19 20 #include "unicode/unistr.h" 21 22 /** 23 * \file 24 * \brief C++ API: A unit for measuring a quantity. 25 */ 26 27 U_NAMESPACE_BEGIN 28 29 class StringEnumeration; 30 31 /** 32 * A unit such as length, mass, volume, currency, etc. A unit is 33 * coupled with a numeric amount to produce a Measure. 34 * 35 * @author Alan Liu 36 * @stable ICU 3.0 37 */ 38 class U_I18N_API MeasureUnit: public UObject { 39 public: 40 41 /** 42 * Default constructor. 43 * @stable ICU 3.0 44 */ 45 MeasureUnit() : fTypeId(0), fSubTypeId(0) { 46 fCurrency[0] = 0; 47 } 48 49 /** 50 * Copy constructor. 51 * @stable ICU 3.0 52 */ 53 MeasureUnit(const MeasureUnit &other); 54 55 /** 56 * Assignment operator. 57 * @stable ICU 3.0 58 */ 59 MeasureUnit &operator=(const MeasureUnit &other); 60 61 /** 62 * Returns a polymorphic clone of this object. The result will 63 * have the same class as returned by getDynamicClassID(). 64 * @stable ICU 3.0 65 */ 66 virtual UObject* clone() const; 67 68 /** 69 * Destructor 70 * @stable ICU 3.0 71 */ 72 virtual ~MeasureUnit(); 73 74 /** 75 * Equality operator. Return true if this object is equal 76 * to the given object. 77 * @stable ICU 3.0 78 */ 79 virtual UBool operator==(const UObject& other) const; 80 81 /** 82 * Inequality operator. Return true if this object is not equal 83 * to the given object. 84 * @stable ICU 53 85 */ 86 UBool operator!=(const UObject& other) const { 87 return !(*this == other); 88 } 89 90 /** 91 * Get the type. 92 * @stable ICU 53 93 */ 94 const char *getType() const; 95 96 /** 97 * Get the sub type. 98 * @stable ICU 53 99 */ 100 const char *getSubtype() const; 101 102 /** 103 * getAvailable gets all of the available units. 104 * If there are too many units to fit into destCapacity then the 105 * error code is set to U_BUFFER_OVERFLOW_ERROR. 106 * 107 * @param destArray destination buffer. 108 * @param destCapacity number of MeasureUnit instances available at dest. 109 * @param errorCode ICU error code. 110 * @return number of available units. 111 * @stable ICU 53 112 */ 113 static int32_t getAvailable( 114 MeasureUnit *destArray, 115 int32_t destCapacity, 116 UErrorCode &errorCode); 117 118 /** 119 * getAvailable gets all of the available units for a specific type. 120 * If there are too many units to fit into destCapacity then the 121 * error code is set to U_BUFFER_OVERFLOW_ERROR. 122 * 123 * @param type the type 124 * @param destArray destination buffer. 125 * @param destCapacity number of MeasureUnit instances available at dest. 126 * @param errorCode ICU error code. 127 * @return number of available units for type. 128 * @stable ICU 53 129 */ 130 static int32_t getAvailable( 131 const char *type, 132 MeasureUnit *destArray, 133 int32_t destCapacity, 134 UErrorCode &errorCode); 135 136 /** 137 * getAvailableTypes gets all of the available types. Caller owns the 138 * returned StringEnumeration and must delete it when finished using it. 139 * 140 * @param errorCode ICU error code. 141 * @return the types. 142 * @stable ICU 53 143 */ 144 static StringEnumeration* getAvailableTypes(UErrorCode &errorCode); 145 146 /** 147 * Return the class ID for this class. This is useful only for comparing to 148 * a return value from getDynamicClassID(). For example: 149 * <pre> 150 * . Base* polymorphic_pointer = createPolymorphicObject(); 151 * . if (polymorphic_pointer->getDynamicClassID() == 152 * . erived::getStaticClassID()) ... 153 * </pre> 154 * @return The class ID for all objects of this class. 155 * @stable ICU 53 156 */ 157 static UClassID U_EXPORT2 getStaticClassID(void); 158 159 /** 160 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This 161 * method is to implement a simple version of RTTI, since not all C++ 162 * compilers support genuine RTTI. Polymorphic operator==() and clone() 163 * methods call this method. 164 * 165 * @return The class ID for this object. All objects of a 166 * given class have the same class ID. Objects of 167 * other classes have different class IDs. 168 * @stable ICU 53 169 */ 170 virtual UClassID getDynamicClassID(void) const; 171 172 #ifndef U_HIDE_INTERNAL_API 173 /** 174 * ICU use only. 175 * Returns associated array index for this measure unit. Only valid for 176 * non-currency measure units. 177 * @internal 178 */ 179 int32_t getIndex() const; 180 181 /** 182 * ICU use only. 183 * Returns maximum value from getIndex plus 1. 184 * @internal 185 */ 186 static int32_t getIndexCount(); 187 188 /** 189 * ICU use only. 190 * @return the unit.getIndex() of the unit which has this unit.getType() and unit.getSubtype(), 191 * or a negative value if there is no such unit 192 * @internal 193 */ 194 static int32_t internalGetIndexForTypeAndSubtype(const char *type, const char *subtype); 195 196 /** 197 * ICU use only. 198 * @internal 199 */ 200 static MeasureUnit *resolveUnitPerUnit( 201 const MeasureUnit &unit, const MeasureUnit &perUnit); 202 #endif /* U_HIDE_INTERNAL_API */ 203 204 // All code between the "Start generated createXXX methods" comment and 205 // the "End generated createXXX methods" comment is auto generated code 206 // and must not be edited manually. For instructions on how to correctly 207 // update this code, refer to: 208 // http://site.icu-project.org/design/formatting/measureformat/updating-measure-unit 209 // 210 // Start generated createXXX methods 211 212 /** 213 * Returns unit of acceleration: g-force. 214 * Caller owns returned value and must free it. 215 * @param status ICU error code. 216 * @stable ICU 53 217 */ 218 static MeasureUnit *createGForce(UErrorCode &status); 219 220 /** 221 * Returns unit of acceleration: meter-per-second-squared. 222 * Caller owns returned value and must free it. 223 * @param status ICU error code. 224 * @stable ICU 54 225 */ 226 static MeasureUnit *createMeterPerSecondSquared(UErrorCode &status); 227 228 /** 229 * Returns unit of angle: arc-minute. 230 * Caller owns returned value and must free it. 231 * @param status ICU error code. 232 * @stable ICU 53 233 */ 234 static MeasureUnit *createArcMinute(UErrorCode &status); 235 236 /** 237 * Returns unit of angle: arc-second. 238 * Caller owns returned value and must free it. 239 * @param status ICU error code. 240 * @stable ICU 53 241 */ 242 static MeasureUnit *createArcSecond(UErrorCode &status); 243 244 /** 245 * Returns unit of angle: degree. 246 * Caller owns returned value and must free it. 247 * @param status ICU error code. 248 * @stable ICU 53 249 */ 250 static MeasureUnit *createDegree(UErrorCode &status); 251 252 /** 253 * Returns unit of angle: radian. 254 * Caller owns returned value and must free it. 255 * @param status ICU error code. 256 * @stable ICU 54 257 */ 258 static MeasureUnit *createRadian(UErrorCode &status); 259 260 /** 261 * Returns unit of angle: revolution. 262 * Caller owns returned value and must free it. 263 * @param status ICU error code. 264 * @stable ICU 56 265 */ 266 static MeasureUnit *createRevolutionAngle(UErrorCode &status); 267 268 /** 269 * Returns unit of area: acre. 270 * Caller owns returned value and must free it. 271 * @param status ICU error code. 272 * @stable ICU 53 273 */ 274 static MeasureUnit *createAcre(UErrorCode &status); 275 276 /** 277 * Returns unit of area: hectare. 278 * Caller owns returned value and must free it. 279 * @param status ICU error code. 280 * @stable ICU 53 281 */ 282 static MeasureUnit *createHectare(UErrorCode &status); 283 284 /** 285 * Returns unit of area: square-centimeter. 286 * Caller owns returned value and must free it. 287 * @param status ICU error code. 288 * @stable ICU 54 289 */ 290 static MeasureUnit *createSquareCentimeter(UErrorCode &status); 291 292 /** 293 * Returns unit of area: square-foot. 294 * Caller owns returned value and must free it. 295 * @param status ICU error code. 296 * @stable ICU 53 297 */ 298 static MeasureUnit *createSquareFoot(UErrorCode &status); 299 300 /** 301 * Returns unit of area: square-inch. 302 * Caller owns returned value and must free it. 303 * @param status ICU error code. 304 * @stable ICU 54 305 */ 306 static MeasureUnit *createSquareInch(UErrorCode &status); 307 308 /** 309 * Returns unit of area: square-kilometer. 310 * Caller owns returned value and must free it. 311 * @param status ICU error code. 312 * @stable ICU 53 313 */ 314 static MeasureUnit *createSquareKilometer(UErrorCode &status); 315 316 /** 317 * Returns unit of area: square-meter. 318 * Caller owns returned value and must free it. 319 * @param status ICU error code. 320 * @stable ICU 53 321 */ 322 static MeasureUnit *createSquareMeter(UErrorCode &status); 323 324 /** 325 * Returns unit of area: square-mile. 326 * Caller owns returned value and must free it. 327 * @param status ICU error code. 328 * @stable ICU 53 329 */ 330 static MeasureUnit *createSquareMile(UErrorCode &status); 331 332 /** 333 * Returns unit of area: square-yard. 334 * Caller owns returned value and must free it. 335 * @param status ICU error code. 336 * @stable ICU 54 337 */ 338 static MeasureUnit *createSquareYard(UErrorCode &status); 339 340 /** 341 * Returns unit of concentr: karat. 342 * Caller owns returned value and must free it. 343 * @param status ICU error code. 344 * @stable ICU 54 345 */ 346 static MeasureUnit *createKarat(UErrorCode &status); 347 348 #ifndef U_HIDE_DRAFT_API 349 /** 350 * Returns unit of concentr: milligram-per-deciliter. 351 * Caller owns returned value and must free it. 352 * @param status ICU error code. 353 * @draft ICU 57 354 */ 355 static MeasureUnit *createMilligramPerDeciliter(UErrorCode &status); 356 #endif /* U_HIDE_DRAFT_API */ 357 358 #ifndef U_HIDE_DRAFT_API 359 /** 360 * Returns unit of concentr: millimole-per-liter. 361 * Caller owns returned value and must free it. 362 * @param status ICU error code. 363 * @draft ICU 57 364 */ 365 static MeasureUnit *createMillimolePerLiter(UErrorCode &status); 366 #endif /* U_HIDE_DRAFT_API */ 367 368 #ifndef U_HIDE_DRAFT_API 369 /** 370 * Returns unit of concentr: part-per-million. 371 * Caller owns returned value and must free it. 372 * @param status ICU error code. 373 * @draft ICU 57 374 */ 375 static MeasureUnit *createPartPerMillion(UErrorCode &status); 376 #endif /* U_HIDE_DRAFT_API */ 377 378 /** 379 * Returns unit of consumption: liter-per-100kilometers. 380 * Caller owns returned value and must free it. 381 * @param status ICU error code. 382 * @stable ICU 56 383 */ 384 static MeasureUnit *createLiterPer100Kilometers(UErrorCode &status); 385 386 /** 387 * Returns unit of consumption: liter-per-kilometer. 388 * Caller owns returned value and must free it. 389 * @param status ICU error code. 390 * @stable ICU 54 391 */ 392 static MeasureUnit *createLiterPerKilometer(UErrorCode &status); 393 394 /** 395 * Returns unit of consumption: mile-per-gallon. 396 * Caller owns returned value and must free it. 397 * @param status ICU error code. 398 * @stable ICU 54 399 */ 400 static MeasureUnit *createMilePerGallon(UErrorCode &status); 401 402 #ifndef U_HIDE_DRAFT_API 403 /** 404 * Returns unit of consumption: mile-per-gallon-imperial. 405 * Caller owns returned value and must free it. 406 * @param status ICU error code. 407 * @draft ICU 57 408 */ 409 static MeasureUnit *createMilePerGallonImperial(UErrorCode &status); 410 #endif /* U_HIDE_DRAFT_API */ 411 412 #ifndef U_HIDE_DRAFT_API 413 /** 414 * Returns unit of coordinate: east. 415 * Caller owns returned value and must free it. 416 * @param status ICU error code. 417 * @draft ICU 58 418 */ 419 static MeasureUnit *createEast(UErrorCode &status); 420 #endif /* U_HIDE_DRAFT_API */ 421 422 #ifndef U_HIDE_DRAFT_API 423 /** 424 * Returns unit of coordinate: north. 425 * Caller owns returned value and must free it. 426 * @param status ICU error code. 427 * @draft ICU 58 428 */ 429 static MeasureUnit *createNorth(UErrorCode &status); 430 #endif /* U_HIDE_DRAFT_API */ 431 432 #ifndef U_HIDE_DRAFT_API 433 /** 434 * Returns unit of coordinate: south. 435 * Caller owns returned value and must free it. 436 * @param status ICU error code. 437 * @draft ICU 58 438 */ 439 static MeasureUnit *createSouth(UErrorCode &status); 440 #endif /* U_HIDE_DRAFT_API */ 441 442 #ifndef U_HIDE_DRAFT_API 443 /** 444 * Returns unit of coordinate: west. 445 * Caller owns returned value and must free it. 446 * @param status ICU error code. 447 * @draft ICU 58 448 */ 449 static MeasureUnit *createWest(UErrorCode &status); 450 #endif /* U_HIDE_DRAFT_API */ 451 452 /** 453 * Returns unit of digital: bit. 454 * Caller owns returned value and must free it. 455 * @param status ICU error code. 456 * @stable ICU 54 457 */ 458 static MeasureUnit *createBit(UErrorCode &status); 459 460 /** 461 * Returns unit of digital: byte. 462 * Caller owns returned value and must free it. 463 * @param status ICU error code. 464 * @stable ICU 54 465 */ 466 static MeasureUnit *createByte(UErrorCode &status); 467 468 /** 469 * Returns unit of digital: gigabit. 470 * Caller owns returned value and must free it. 471 * @param status ICU error code. 472 * @stable ICU 54 473 */ 474 static MeasureUnit *createGigabit(UErrorCode &status); 475 476 /** 477 * Returns unit of digital: gigabyte. 478 * Caller owns returned value and must free it. 479 * @param status ICU error code. 480 * @stable ICU 54 481 */ 482 static MeasureUnit *createGigabyte(UErrorCode &status); 483 484 /** 485 * Returns unit of digital: kilobit. 486 * Caller owns returned value and must free it. 487 * @param status ICU error code. 488 * @stable ICU 54 489 */ 490 static MeasureUnit *createKilobit(UErrorCode &status); 491 492 /** 493 * Returns unit of digital: kilobyte. 494 * Caller owns returned value and must free it. 495 * @param status ICU error code. 496 * @stable ICU 54 497 */ 498 static MeasureUnit *createKilobyte(UErrorCode &status); 499 500 /** 501 * Returns unit of digital: megabit. 502 * Caller owns returned value and must free it. 503 * @param status ICU error code. 504 * @stable ICU 54 505 */ 506 static MeasureUnit *createMegabit(UErrorCode &status); 507 508 /** 509 * Returns unit of digital: megabyte. 510 * Caller owns returned value and must free it. 511 * @param status ICU error code. 512 * @stable ICU 54 513 */ 514 static MeasureUnit *createMegabyte(UErrorCode &status); 515 516 /** 517 * Returns unit of digital: terabit. 518 * Caller owns returned value and must free it. 519 * @param status ICU error code. 520 * @stable ICU 54 521 */ 522 static MeasureUnit *createTerabit(UErrorCode &status); 523 524 /** 525 * Returns unit of digital: terabyte. 526 * Caller owns returned value and must free it. 527 * @param status ICU error code. 528 * @stable ICU 54 529 */ 530 static MeasureUnit *createTerabyte(UErrorCode &status); 531 532 /** 533 * Returns unit of duration: century. 534 * Caller owns returned value and must free it. 535 * @param status ICU error code. 536 * @stable ICU 56 537 */ 538 static MeasureUnit *createCentury(UErrorCode &status); 539 540 /** 541 * Returns unit of duration: day. 542 * Caller owns returned value and must free it. 543 * @param status ICU error code. 544 * @stable ICU 53 545 */ 546 static MeasureUnit *createDay(UErrorCode &status); 547 548 /** 549 * Returns unit of duration: hour. 550 * Caller owns returned value and must free it. 551 * @param status ICU error code. 552 * @stable ICU 53 553 */ 554 static MeasureUnit *createHour(UErrorCode &status); 555 556 /** 557 * Returns unit of duration: microsecond. 558 * Caller owns returned value and must free it. 559 * @param status ICU error code. 560 * @stable ICU 54 561 */ 562 static MeasureUnit *createMicrosecond(UErrorCode &status); 563 564 /** 565 * Returns unit of duration: millisecond. 566 * Caller owns returned value and must free it. 567 * @param status ICU error code. 568 * @stable ICU 53 569 */ 570 static MeasureUnit *createMillisecond(UErrorCode &status); 571 572 /** 573 * Returns unit of duration: minute. 574 * Caller owns returned value and must free it. 575 * @param status ICU error code. 576 * @stable ICU 53 577 */ 578 static MeasureUnit *createMinute(UErrorCode &status); 579 580 /** 581 * Returns unit of duration: month. 582 * Caller owns returned value and must free it. 583 * @param status ICU error code. 584 * @stable ICU 53 585 */ 586 static MeasureUnit *createMonth(UErrorCode &status); 587 588 /** 589 * Returns unit of duration: nanosecond. 590 * Caller owns returned value and must free it. 591 * @param status ICU error code. 592 * @stable ICU 54 593 */ 594 static MeasureUnit *createNanosecond(UErrorCode &status); 595 596 /** 597 * Returns unit of duration: second. 598 * Caller owns returned value and must free it. 599 * @param status ICU error code. 600 * @stable ICU 53 601 */ 602 static MeasureUnit *createSecond(UErrorCode &status); 603 604 /** 605 * Returns unit of duration: week. 606 * Caller owns returned value and must free it. 607 * @param status ICU error code. 608 * @stable ICU 53 609 */ 610 static MeasureUnit *createWeek(UErrorCode &status); 611 612 /** 613 * Returns unit of duration: year. 614 * Caller owns returned value and must free it. 615 * @param status ICU error code. 616 * @stable ICU 53 617 */ 618 static MeasureUnit *createYear(UErrorCode &status); 619 620 /** 621 * Returns unit of electric: ampere. 622 * Caller owns returned value and must free it. 623 * @param status ICU error code. 624 * @stable ICU 54 625 */ 626 static MeasureUnit *createAmpere(UErrorCode &status); 627 628 /** 629 * Returns unit of electric: milliampere. 630 * Caller owns returned value and must free it. 631 * @param status ICU error code. 632 * @stable ICU 54 633 */ 634 static MeasureUnit *createMilliampere(UErrorCode &status); 635 636 /** 637 * Returns unit of electric: ohm. 638 * Caller owns returned value and must free it. 639 * @param status ICU error code. 640 * @stable ICU 54 641 */ 642 static MeasureUnit *createOhm(UErrorCode &status); 643 644 /** 645 * Returns unit of electric: volt. 646 * Caller owns returned value and must free it. 647 * @param status ICU error code. 648 * @stable ICU 54 649 */ 650 static MeasureUnit *createVolt(UErrorCode &status); 651 652 /** 653 * Returns unit of energy: calorie. 654 * Caller owns returned value and must free it. 655 * @param status ICU error code. 656 * @stable ICU 54 657 */ 658 static MeasureUnit *createCalorie(UErrorCode &status); 659 660 /** 661 * Returns unit of energy: foodcalorie. 662 * Caller owns returned value and must free it. 663 * @param status ICU error code. 664 * @stable ICU 54 665 */ 666 static MeasureUnit *createFoodcalorie(UErrorCode &status); 667 668 /** 669 * Returns unit of energy: joule. 670 * Caller owns returned value and must free it. 671 * @param status ICU error code. 672 * @stable ICU 54 673 */ 674 static MeasureUnit *createJoule(UErrorCode &status); 675 676 /** 677 * Returns unit of energy: kilocalorie. 678 * Caller owns returned value and must free it. 679 * @param status ICU error code. 680 * @stable ICU 54 681 */ 682 static MeasureUnit *createKilocalorie(UErrorCode &status); 683 684 /** 685 * Returns unit of energy: kilojoule. 686 * Caller owns returned value and must free it. 687 * @param status ICU error code. 688 * @stable ICU 54 689 */ 690 static MeasureUnit *createKilojoule(UErrorCode &status); 691 692 /** 693 * Returns unit of energy: kilowatt-hour. 694 * Caller owns returned value and must free it. 695 * @param status ICU error code. 696 * @stable ICU 54 697 */ 698 static MeasureUnit *createKilowattHour(UErrorCode &status); 699 700 /** 701 * Returns unit of frequency: gigahertz. 702 * Caller owns returned value and must free it. 703 * @param status ICU error code. 704 * @stable ICU 54 705 */ 706 static MeasureUnit *createGigahertz(UErrorCode &status); 707 708 /** 709 * Returns unit of frequency: hertz. 710 * Caller owns returned value and must free it. 711 * @param status ICU error code. 712 * @stable ICU 54 713 */ 714 static MeasureUnit *createHertz(UErrorCode &status); 715 716 /** 717 * Returns unit of frequency: kilohertz. 718 * Caller owns returned value and must free it. 719 * @param status ICU error code. 720 * @stable ICU 54 721 */ 722 static MeasureUnit *createKilohertz(UErrorCode &status); 723 724 /** 725 * Returns unit of frequency: megahertz. 726 * Caller owns returned value and must free it. 727 * @param status ICU error code. 728 * @stable ICU 54 729 */ 730 static MeasureUnit *createMegahertz(UErrorCode &status); 731 732 /** 733 * Returns unit of length: astronomical-unit. 734 * Caller owns returned value and must free it. 735 * @param status ICU error code. 736 * @stable ICU 54 737 */ 738 static MeasureUnit *createAstronomicalUnit(UErrorCode &status); 739 740 /** 741 * Returns unit of length: centimeter. 742 * Caller owns returned value and must free it. 743 * @param status ICU error code. 744 * @stable ICU 53 745 */ 746 static MeasureUnit *createCentimeter(UErrorCode &status); 747 748 /** 749 * Returns unit of length: decimeter. 750 * Caller owns returned value and must free it. 751 * @param status ICU error code. 752 * @stable ICU 54 753 */ 754 static MeasureUnit *createDecimeter(UErrorCode &status); 755 756 /** 757 * Returns unit of length: fathom. 758 * Caller owns returned value and must free it. 759 * @param status ICU error code. 760 * @stable ICU 54 761 */ 762 static MeasureUnit *createFathom(UErrorCode &status); 763 764 /** 765 * Returns unit of length: foot. 766 * Caller owns returned value and must free it. 767 * @param status ICU error code. 768 * @stable ICU 53 769 */ 770 static MeasureUnit *createFoot(UErrorCode &status); 771 772 /** 773 * Returns unit of length: furlong. 774 * Caller owns returned value and must free it. 775 * @param status ICU error code. 776 * @stable ICU 54 777 */ 778 static MeasureUnit *createFurlong(UErrorCode &status); 779 780 /** 781 * Returns unit of length: inch. 782 * Caller owns returned value and must free it. 783 * @param status ICU error code. 784 * @stable ICU 53 785 */ 786 static MeasureUnit *createInch(UErrorCode &status); 787 788 /** 789 * Returns unit of length: kilometer. 790 * Caller owns returned value and must free it. 791 * @param status ICU error code. 792 * @stable ICU 53 793 */ 794 static MeasureUnit *createKilometer(UErrorCode &status); 795 796 /** 797 * Returns unit of length: light-year. 798 * Caller owns returned value and must free it. 799 * @param status ICU error code. 800 * @stable ICU 53 801 */ 802 static MeasureUnit *createLightYear(UErrorCode &status); 803 804 /** 805 * Returns unit of length: meter. 806 * Caller owns returned value and must free it. 807 * @param status ICU error code. 808 * @stable ICU 53 809 */ 810 static MeasureUnit *createMeter(UErrorCode &status); 811 812 /** 813 * Returns unit of length: micrometer. 814 * Caller owns returned value and must free it. 815 * @param status ICU error code. 816 * @stable ICU 54 817 */ 818 static MeasureUnit *createMicrometer(UErrorCode &status); 819 820 /** 821 * Returns unit of length: mile. 822 * Caller owns returned value and must free it. 823 * @param status ICU error code. 824 * @stable ICU 53 825 */ 826 static MeasureUnit *createMile(UErrorCode &status); 827 828 /** 829 * Returns unit of length: mile-scandinavian. 830 * Caller owns returned value and must free it. 831 * @param status ICU error code. 832 * @stable ICU 56 833 */ 834 static MeasureUnit *createMileScandinavian(UErrorCode &status); 835 836 /** 837 * Returns unit of length: millimeter. 838 * Caller owns returned value and must free it. 839 * @param status ICU error code. 840 * @stable ICU 53 841 */ 842 static MeasureUnit *createMillimeter(UErrorCode &status); 843 844 /** 845 * Returns unit of length: nanometer. 846 * Caller owns returned value and must free it. 847 * @param status ICU error code. 848 * @stable ICU 54 849 */ 850 static MeasureUnit *createNanometer(UErrorCode &status); 851 852 /** 853 * Returns unit of length: nautical-mile. 854 * Caller owns returned value and must free it. 855 * @param status ICU error code. 856 * @stable ICU 54 857 */ 858 static MeasureUnit *createNauticalMile(UErrorCode &status); 859 860 /** 861 * Returns unit of length: parsec. 862 * Caller owns returned value and must free it. 863 * @param status ICU error code. 864 * @stable ICU 54 865 */ 866 static MeasureUnit *createParsec(UErrorCode &status); 867 868 /** 869 * Returns unit of length: picometer. 870 * Caller owns returned value and must free it. 871 * @param status ICU error code. 872 * @stable ICU 53 873 */ 874 static MeasureUnit *createPicometer(UErrorCode &status); 875 876 /** 877 * Returns unit of length: yard. 878 * Caller owns returned value and must free it. 879 * @param status ICU error code. 880 * @stable ICU 53 881 */ 882 static MeasureUnit *createYard(UErrorCode &status); 883 884 /** 885 * Returns unit of light: lux. 886 * Caller owns returned value and must free it. 887 * @param status ICU error code. 888 * @stable ICU 54 889 */ 890 static MeasureUnit *createLux(UErrorCode &status); 891 892 /** 893 * Returns unit of mass: carat. 894 * Caller owns returned value and must free it. 895 * @param status ICU error code. 896 * @stable ICU 54 897 */ 898 static MeasureUnit *createCarat(UErrorCode &status); 899 900 /** 901 * Returns unit of mass: gram. 902 * Caller owns returned value and must free it. 903 * @param status ICU error code. 904 * @stable ICU 53 905 */ 906 static MeasureUnit *createGram(UErrorCode &status); 907 908 /** 909 * Returns unit of mass: kilogram. 910 * Caller owns returned value and must free it. 911 * @param status ICU error code. 912 * @stable ICU 53 913 */ 914 static MeasureUnit *createKilogram(UErrorCode &status); 915 916 /** 917 * Returns unit of mass: metric-ton. 918 * Caller owns returned value and must free it. 919 * @param status ICU error code. 920 * @stable ICU 54 921 */ 922 static MeasureUnit *createMetricTon(UErrorCode &status); 923 924 /** 925 * Returns unit of mass: microgram. 926 * Caller owns returned value and must free it. 927 * @param status ICU error code. 928 * @stable ICU 54 929 */ 930 static MeasureUnit *createMicrogram(UErrorCode &status); 931 932 /** 933 * Returns unit of mass: milligram. 934 * Caller owns returned value and must free it. 935 * @param status ICU error code. 936 * @stable ICU 54 937 */ 938 static MeasureUnit *createMilligram(UErrorCode &status); 939 940 /** 941 * Returns unit of mass: ounce. 942 * Caller owns returned value and must free it. 943 * @param status ICU error code. 944 * @stable ICU 53 945 */ 946 static MeasureUnit *createOunce(UErrorCode &status); 947 948 /** 949 * Returns unit of mass: ounce-troy. 950 * Caller owns returned value and must free it. 951 * @param status ICU error code. 952 * @stable ICU 54 953 */ 954 static MeasureUnit *createOunceTroy(UErrorCode &status); 955 956 /** 957 * Returns unit of mass: pound. 958 * Caller owns returned value and must free it. 959 * @param status ICU error code. 960 * @stable ICU 53 961 */ 962 static MeasureUnit *createPound(UErrorCode &status); 963 964 /** 965 * Returns unit of mass: stone. 966 * Caller owns returned value and must free it. 967 * @param status ICU error code. 968 * @stable ICU 54 969 */ 970 static MeasureUnit *createStone(UErrorCode &status); 971 972 /** 973 * Returns unit of mass: ton. 974 * Caller owns returned value and must free it. 975 * @param status ICU error code. 976 * @stable ICU 54 977 */ 978 static MeasureUnit *createTon(UErrorCode &status); 979 980 /** 981 * Returns unit of power: gigawatt. 982 * Caller owns returned value and must free it. 983 * @param status ICU error code. 984 * @stable ICU 54 985 */ 986 static MeasureUnit *createGigawatt(UErrorCode &status); 987 988 /** 989 * Returns unit of power: horsepower. 990 * Caller owns returned value and must free it. 991 * @param status ICU error code. 992 * @stable ICU 53 993 */ 994 static MeasureUnit *createHorsepower(UErrorCode &status); 995 996 /** 997 * Returns unit of power: kilowatt. 998 * Caller owns returned value and must free it. 999 * @param status ICU error code. 1000 * @stable ICU 53 1001 */ 1002 static MeasureUnit *createKilowatt(UErrorCode &status); 1003 1004 /** 1005 * Returns unit of power: megawatt. 1006 * Caller owns returned value and must free it. 1007 * @param status ICU error code. 1008 * @stable ICU 54 1009 */ 1010 static MeasureUnit *createMegawatt(UErrorCode &status); 1011 1012 /** 1013 * Returns unit of power: milliwatt. 1014 * Caller owns returned value and must free it. 1015 * @param status ICU error code. 1016 * @stable ICU 54 1017 */ 1018 static MeasureUnit *createMilliwatt(UErrorCode &status); 1019 1020 /** 1021 * Returns unit of power: watt. 1022 * Caller owns returned value and must free it. 1023 * @param status ICU error code. 1024 * @stable ICU 53 1025 */ 1026 static MeasureUnit *createWatt(UErrorCode &status); 1027 1028 /** 1029 * Returns unit of pressure: hectopascal. 1030 * Caller owns returned value and must free it. 1031 * @param status ICU error code. 1032 * @stable ICU 53 1033 */ 1034 static MeasureUnit *createHectopascal(UErrorCode &status); 1035 1036 /** 1037 * Returns unit of pressure: inch-hg. 1038 * Caller owns returned value and must free it. 1039 * @param status ICU error code. 1040 * @stable ICU 53 1041 */ 1042 static MeasureUnit *createInchHg(UErrorCode &status); 1043 1044 /** 1045 * Returns unit of pressure: millibar. 1046 * Caller owns returned value and must free it. 1047 * @param status ICU error code. 1048 * @stable ICU 53 1049 */ 1050 static MeasureUnit *createMillibar(UErrorCode &status); 1051 1052 /** 1053 * Returns unit of pressure: millimeter-of-mercury. 1054 * Caller owns returned value and must free it. 1055 * @param status ICU error code. 1056 * @stable ICU 54 1057 */ 1058 static MeasureUnit *createMillimeterOfMercury(UErrorCode &status); 1059 1060 /** 1061 * Returns unit of pressure: pound-per-square-inch. 1062 * Caller owns returned value and must free it. 1063 * @param status ICU error code. 1064 * @stable ICU 54 1065 */ 1066 static MeasureUnit *createPoundPerSquareInch(UErrorCode &status); 1067 1068 /** 1069 * Returns unit of speed: kilometer-per-hour. 1070 * Caller owns returned value and must free it. 1071 * @param status ICU error code. 1072 * @stable ICU 53 1073 */ 1074 static MeasureUnit *createKilometerPerHour(UErrorCode &status); 1075 1076 /** 1077 * Returns unit of speed: knot. 1078 * Caller owns returned value and must free it. 1079 * @param status ICU error code. 1080 * @stable ICU 56 1081 */ 1082 static MeasureUnit *createKnot(UErrorCode &status); 1083 1084 /** 1085 * Returns unit of speed: meter-per-second. 1086 * Caller owns returned value and must free it. 1087 * @param status ICU error code. 1088 * @stable ICU 53 1089 */ 1090 static MeasureUnit *createMeterPerSecond(UErrorCode &status); 1091 1092 /** 1093 * Returns unit of speed: mile-per-hour. 1094 * Caller owns returned value and must free it. 1095 * @param status ICU error code. 1096 * @stable ICU 53 1097 */ 1098 static MeasureUnit *createMilePerHour(UErrorCode &status); 1099 1100 /** 1101 * Returns unit of temperature: celsius. 1102 * Caller owns returned value and must free it. 1103 * @param status ICU error code. 1104 * @stable ICU 53 1105 */ 1106 static MeasureUnit *createCelsius(UErrorCode &status); 1107 1108 /** 1109 * Returns unit of temperature: fahrenheit. 1110 * Caller owns returned value and must free it. 1111 * @param status ICU error code. 1112 * @stable ICU 53 1113 */ 1114 static MeasureUnit *createFahrenheit(UErrorCode &status); 1115 1116 /** 1117 * Returns unit of temperature: generic. 1118 * Caller owns returned value and must free it. 1119 * @param status ICU error code. 1120 * @stable ICU 56 1121 */ 1122 static MeasureUnit *createGenericTemperature(UErrorCode &status); 1123 1124 /** 1125 * Returns unit of temperature: kelvin. 1126 * Caller owns returned value and must free it. 1127 * @param status ICU error code. 1128 * @stable ICU 54 1129 */ 1130 static MeasureUnit *createKelvin(UErrorCode &status); 1131 1132 /** 1133 * Returns unit of volume: acre-foot. 1134 * Caller owns returned value and must free it. 1135 * @param status ICU error code. 1136 * @stable ICU 54 1137 */ 1138 static MeasureUnit *createAcreFoot(UErrorCode &status); 1139 1140 /** 1141 * Returns unit of volume: bushel. 1142 * Caller owns returned value and must free it. 1143 * @param status ICU error code. 1144 * @stable ICU 54 1145 */ 1146 static MeasureUnit *createBushel(UErrorCode &status); 1147 1148 /** 1149 * Returns unit of volume: centiliter. 1150 * Caller owns returned value and must free it. 1151 * @param status ICU error code. 1152 * @stable ICU 54 1153 */ 1154 static MeasureUnit *createCentiliter(UErrorCode &status); 1155 1156 /** 1157 * Returns unit of volume: cubic-centimeter. 1158 * Caller owns returned value and must free it. 1159 * @param status ICU error code. 1160 * @stable ICU 54 1161 */ 1162 static MeasureUnit *createCubicCentimeter(UErrorCode &status); 1163 1164 /** 1165 * Returns unit of volume: cubic-foot. 1166 * Caller owns returned value and must free it. 1167 * @param status ICU error code. 1168 * @stable ICU 54 1169 */ 1170 static MeasureUnit *createCubicFoot(UErrorCode &status); 1171 1172 /** 1173 * Returns unit of volume: cubic-inch. 1174 * Caller owns returned value and must free it. 1175 * @param status ICU error code. 1176 * @stable ICU 54 1177 */ 1178 static MeasureUnit *createCubicInch(UErrorCode &status); 1179 1180 /** 1181 * Returns unit of volume: cubic-kilometer. 1182 * Caller owns returned value and must free it. 1183 * @param status ICU error code. 1184 * @stable ICU 53 1185 */ 1186 static MeasureUnit *createCubicKilometer(UErrorCode &status); 1187 1188 /** 1189 * Returns unit of volume: cubic-meter. 1190 * Caller owns returned value and must free it. 1191 * @param status ICU error code. 1192 * @stable ICU 54 1193 */ 1194 static MeasureUnit *createCubicMeter(UErrorCode &status); 1195 1196 /** 1197 * Returns unit of volume: cubic-mile. 1198 * Caller owns returned value and must free it. 1199 * @param status ICU error code. 1200 * @stable ICU 53 1201 */ 1202 static MeasureUnit *createCubicMile(UErrorCode &status); 1203 1204 /** 1205 * Returns unit of volume: cubic-yard. 1206 * Caller owns returned value and must free it. 1207 * @param status ICU error code. 1208 * @stable ICU 54 1209 */ 1210 static MeasureUnit *createCubicYard(UErrorCode &status); 1211 1212 /** 1213 * Returns unit of volume: cup. 1214 * Caller owns returned value and must free it. 1215 * @param status ICU error code. 1216 * @stable ICU 54 1217 */ 1218 static MeasureUnit *createCup(UErrorCode &status); 1219 1220 /** 1221 * Returns unit of volume: cup-metric. 1222 * Caller owns returned value and must free it. 1223 * @param status ICU error code. 1224 * @stable ICU 56 1225 */ 1226 static MeasureUnit *createCupMetric(UErrorCode &status); 1227 1228 /** 1229 * Returns unit of volume: deciliter. 1230 * Caller owns returned value and must free it. 1231 * @param status ICU error code. 1232 * @stable ICU 54 1233 */ 1234 static MeasureUnit *createDeciliter(UErrorCode &status); 1235 1236 /** 1237 * Returns unit of volume: fluid-ounce. 1238 * Caller owns returned value and must free it. 1239 * @param status ICU error code. 1240 * @stable ICU 54 1241 */ 1242 static MeasureUnit *createFluidOunce(UErrorCode &status); 1243 1244 /** 1245 * Returns unit of volume: gallon. 1246 * Caller owns returned value and must free it. 1247 * @param status ICU error code. 1248 * @stable ICU 54 1249 */ 1250 static MeasureUnit *createGallon(UErrorCode &status); 1251 1252 #ifndef U_HIDE_DRAFT_API 1253 /** 1254 * Returns unit of volume: gallon-imperial. 1255 * Caller owns returned value and must free it. 1256 * @param status ICU error code. 1257 * @draft ICU 57 1258 */ 1259 static MeasureUnit *createGallonImperial(UErrorCode &status); 1260 #endif /* U_HIDE_DRAFT_API */ 1261 1262 /** 1263 * Returns unit of volume: hectoliter. 1264 * Caller owns returned value and must free it. 1265 * @param status ICU error code. 1266 * @stable ICU 54 1267 */ 1268 static MeasureUnit *createHectoliter(UErrorCode &status); 1269 1270 /** 1271 * Returns unit of volume: liter. 1272 * Caller owns returned value and must free it. 1273 * @param status ICU error code. 1274 * @stable ICU 53 1275 */ 1276 static MeasureUnit *createLiter(UErrorCode &status); 1277 1278 /** 1279 * Returns unit of volume: megaliter. 1280 * Caller owns returned value and must free it. 1281 * @param status ICU error code. 1282 * @stable ICU 54 1283 */ 1284 static MeasureUnit *createMegaliter(UErrorCode &status); 1285 1286 /** 1287 * Returns unit of volume: milliliter. 1288 * Caller owns returned value and must free it. 1289 * @param status ICU error code. 1290 * @stable ICU 54 1291 */ 1292 static MeasureUnit *createMilliliter(UErrorCode &status); 1293 1294 /** 1295 * Returns unit of volume: pint. 1296 * Caller owns returned value and must free it. 1297 * @param status ICU error code. 1298 * @stable ICU 54 1299 */ 1300 static MeasureUnit *createPint(UErrorCode &status); 1301 1302 /** 1303 * Returns unit of volume: pint-metric. 1304 * Caller owns returned value and must free it. 1305 * @param status ICU error code. 1306 * @stable ICU 56 1307 */ 1308 static MeasureUnit *createPintMetric(UErrorCode &status); 1309 1310 /** 1311 * Returns unit of volume: quart. 1312 * Caller owns returned value and must free it. 1313 * @param status ICU error code. 1314 * @stable ICU 54 1315 */ 1316 static MeasureUnit *createQuart(UErrorCode &status); 1317 1318 /** 1319 * Returns unit of volume: tablespoon. 1320 * Caller owns returned value and must free it. 1321 * @param status ICU error code. 1322 * @stable ICU 54 1323 */ 1324 static MeasureUnit *createTablespoon(UErrorCode &status); 1325 1326 /** 1327 * Returns unit of volume: teaspoon. 1328 * Caller owns returned value and must free it. 1329 * @param status ICU error code. 1330 * @stable ICU 54 1331 */ 1332 static MeasureUnit *createTeaspoon(UErrorCode &status); 1333 1334 1335 // End generated createXXX methods 1336 1337 protected: 1338 1339 #ifndef U_HIDE_INTERNAL_API 1340 /** 1341 * For ICU use only. 1342 * @internal 1343 */ 1344 void initTime(const char *timeId); 1345 1346 /** 1347 * For ICU use only. 1348 * @internal 1349 */ 1350 void initCurrency(const char *isoCurrency); 1351 1352 #endif /* U_HIDE_INTERNAL_API */ 1353 1354 private: 1355 int32_t fTypeId; 1356 int32_t fSubTypeId; 1357 char fCurrency[4]; 1358 1359 MeasureUnit(int32_t typeId, int32_t subTypeId) : fTypeId(typeId), fSubTypeId(subTypeId) { 1360 fCurrency[0] = 0; 1361 } 1362 void setTo(int32_t typeId, int32_t subTypeId); 1363 int32_t getOffset() const; 1364 static MeasureUnit *create(int typeId, int subTypeId, UErrorCode &status); 1365 }; 1366 1367 U_NAMESPACE_END 1368 1369 #endif // !UNCONFIG_NO_FORMATTING 1370 #endif // __MEASUREUNIT_H__ 1371
