1 // © 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 U_SHOW_CPLUSPLUS_API 19 20 #if !UCONFIG_NO_FORMATTING 21 22 #include "unicode/unistr.h" 23 24 /** 25 * \file 26 * \brief C++ API: A unit for measuring a quantity. 27 */ 28 29 U_NAMESPACE_BEGIN 30 31 class StringEnumeration; 32 33 /** 34 * A unit such as length, mass, volume, currency, etc. A unit is 35 * coupled with a numeric amount to produce a Measure. 36 * 37 * @author Alan Liu 38 * @stable ICU 3.0 39 */ 40 class U_I18N_API MeasureUnit: public UObject { 41 public: 42 43 /** 44 * Default constructor. 45 * Populates the instance with the base dimensionless unit. 46 * @stable ICU 3.0 47 */ 48 MeasureUnit(); 49 50 /** 51 * Copy constructor. 52 * @stable ICU 3.0 53 */ 54 MeasureUnit(const MeasureUnit &other); 55 56 /** 57 * Assignment operator. 58 * @stable ICU 3.0 59 */ 60 MeasureUnit &operator=(const MeasureUnit &other); 61 62 /** 63 * Returns a polymorphic clone of this object. The result will 64 * have the same class as returned by getDynamicClassID(). 65 * @stable ICU 3.0 66 */ 67 virtual MeasureUnit* clone() const; 68 69 /** 70 * Destructor 71 * @stable ICU 3.0 72 */ 73 virtual ~MeasureUnit(); 74 75 /** 76 * Equality operator. Return true if this object is equal 77 * to the given object. 78 * @stable ICU 3.0 79 */ 80 virtual UBool operator==(const UObject& other) const; 81 82 /** 83 * Inequality operator. Return true if this object is not equal 84 * to the given object. 85 * @stable ICU 53 86 */ 87 UBool operator!=(const UObject& other) const { 88 return !(*this == other); 89 } 90 91 /** 92 * Get the type. 93 * @stable ICU 53 94 */ 95 const char *getType() const; 96 97 /** 98 * Get the sub type. 99 * @stable ICU 53 100 */ 101 const char *getSubtype() const; 102 103 /** 104 * getAvailable gets all of the available units. 105 * If there are too many units to fit into destCapacity then the 106 * error code is set to U_BUFFER_OVERFLOW_ERROR. 107 * 108 * @param destArray destination buffer. 109 * @param destCapacity number of MeasureUnit instances available at dest. 110 * @param errorCode ICU error code. 111 * @return number of available units. 112 * @stable ICU 53 113 */ 114 static int32_t getAvailable( 115 MeasureUnit *destArray, 116 int32_t destCapacity, 117 UErrorCode &errorCode); 118 119 /** 120 * getAvailable gets all of the available units for a specific type. 121 * If there are too many units to fit into destCapacity then the 122 * error code is set to U_BUFFER_OVERFLOW_ERROR. 123 * 124 * @param type the type 125 * @param destArray destination buffer. 126 * @param destCapacity number of MeasureUnit instances available at dest. 127 * @param errorCode ICU error code. 128 * @return number of available units for type. 129 * @stable ICU 53 130 */ 131 static int32_t getAvailable( 132 const char *type, 133 MeasureUnit *destArray, 134 int32_t destCapacity, 135 UErrorCode &errorCode); 136 137 /** 138 * getAvailableTypes gets all of the available types. Caller owns the 139 * returned StringEnumeration and must delete it when finished using it. 140 * 141 * @param errorCode ICU error code. 142 * @return the types. 143 * @stable ICU 53 144 */ 145 static StringEnumeration* getAvailableTypes(UErrorCode &errorCode); 146 147 /** 148 * Return the class ID for this class. This is useful only for comparing to 149 * a return value from getDynamicClassID(). For example: 150 * <pre> 151 * . Base* polymorphic_pointer = createPolymorphicObject(); 152 * . if (polymorphic_pointer->getDynamicClassID() == 153 * . Derived::getStaticClassID()) ... 154 * </pre> 155 * @return The class ID for all objects of this class. 156 * @stable ICU 53 157 */ 158 static UClassID U_EXPORT2 getStaticClassID(void); 159 160 /** 161 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This 162 * method is to implement a simple version of RTTI, since not all C++ 163 * compilers support genuine RTTI. Polymorphic operator==() and clone() 164 * methods call this method. 165 * 166 * @return The class ID for this object. All objects of a 167 * given class have the same class ID. Objects of 168 * other classes have different class IDs. 169 * @stable ICU 53 170 */ 171 virtual UClassID getDynamicClassID(void) const; 172 173 #ifndef U_HIDE_INTERNAL_API 174 /** 175 * ICU use only. 176 * Returns associated array index for this measure unit. Only valid for 177 * non-currency measure units. 178 * @internal 179 */ 180 int32_t getIndex() const; 181 182 /** 183 * ICU use only. 184 * Returns maximum value from getIndex plus 1. 185 * @internal 186 */ 187 static int32_t getIndexCount(); 188 189 /** 190 * ICU use only. 191 * @return the unit.getIndex() of the unit which has this unit.getType() and unit.getSubtype(), 192 * or a negative value if there is no such unit 193 * @internal 194 */ 195 static int32_t internalGetIndexForTypeAndSubtype(const char *type, const char *subtype); 196 197 /** 198 * ICU use only. 199 * @internal 200 */ 201 static MeasureUnit resolveUnitPerUnit( 202 const MeasureUnit &unit, const MeasureUnit &perUnit, bool* isResolved); 203 #endif /* U_HIDE_INTERNAL_API */ 204 205 // All code between the "Start generated createXXX methods" comment and 206 // the "End generated createXXX methods" comment is auto generated code 207 // and must not be edited manually. For instructions on how to correctly 208 // update this code, refer to: 209 // http://site.icu-project.org/design/formatting/measureformat/updating-measure-unit 210 // 211 // Start generated createXXX methods 212 213 /** 214 * Returns by pointer, unit of acceleration: g-force. 215 * Caller owns returned value and must free it. 216 * Also see {@link #getGForce()}. 217 * @param status ICU error code. 218 * @stable ICU 53 219 */ 220 static MeasureUnit *createGForce(UErrorCode &status); 221 222 #ifndef U_HIDE_DRAFT_API 223 /** 224 * Returns by value, unit of acceleration: g-force. 225 * Also see {@link #createGForce()}. 226 * @draft ICU 64 227 */ 228 static MeasureUnit getGForce(); 229 #endif /* U_HIDE_DRAFT_API */ 230 231 /** 232 * Returns by pointer, unit of acceleration: meter-per-second-squared. 233 * Caller owns returned value and must free it. 234 * Also see {@link #getMeterPerSecondSquared()}. 235 * @param status ICU error code. 236 * @stable ICU 54 237 */ 238 static MeasureUnit *createMeterPerSecondSquared(UErrorCode &status); 239 240 #ifndef U_HIDE_DRAFT_API 241 /** 242 * Returns by value, unit of acceleration: meter-per-second-squared. 243 * Also see {@link #createMeterPerSecondSquared()}. 244 * @draft ICU 64 245 */ 246 static MeasureUnit getMeterPerSecondSquared(); 247 #endif /* U_HIDE_DRAFT_API */ 248 249 /** 250 * Returns by pointer, unit of angle: arc-minute. 251 * Caller owns returned value and must free it. 252 * Also see {@link #getArcMinute()}. 253 * @param status ICU error code. 254 * @stable ICU 53 255 */ 256 static MeasureUnit *createArcMinute(UErrorCode &status); 257 258 #ifndef U_HIDE_DRAFT_API 259 /** 260 * Returns by value, unit of angle: arc-minute. 261 * Also see {@link #createArcMinute()}. 262 * @draft ICU 64 263 */ 264 static MeasureUnit getArcMinute(); 265 #endif /* U_HIDE_DRAFT_API */ 266 267 /** 268 * Returns by pointer, unit of angle: arc-second. 269 * Caller owns returned value and must free it. 270 * Also see {@link #getArcSecond()}. 271 * @param status ICU error code. 272 * @stable ICU 53 273 */ 274 static MeasureUnit *createArcSecond(UErrorCode &status); 275 276 #ifndef U_HIDE_DRAFT_API 277 /** 278 * Returns by value, unit of angle: arc-second. 279 * Also see {@link #createArcSecond()}. 280 * @draft ICU 64 281 */ 282 static MeasureUnit getArcSecond(); 283 #endif /* U_HIDE_DRAFT_API */ 284 285 /** 286 * Returns by pointer, unit of angle: degree. 287 * Caller owns returned value and must free it. 288 * Also see {@link #getDegree()}. 289 * @param status ICU error code. 290 * @stable ICU 53 291 */ 292 static MeasureUnit *createDegree(UErrorCode &status); 293 294 #ifndef U_HIDE_DRAFT_API 295 /** 296 * Returns by value, unit of angle: degree. 297 * Also see {@link #createDegree()}. 298 * @draft ICU 64 299 */ 300 static MeasureUnit getDegree(); 301 #endif /* U_HIDE_DRAFT_API */ 302 303 /** 304 * Returns by pointer, unit of angle: radian. 305 * Caller owns returned value and must free it. 306 * Also see {@link #getRadian()}. 307 * @param status ICU error code. 308 * @stable ICU 54 309 */ 310 static MeasureUnit *createRadian(UErrorCode &status); 311 312 #ifndef U_HIDE_DRAFT_API 313 /** 314 * Returns by value, unit of angle: radian. 315 * Also see {@link #createRadian()}. 316 * @draft ICU 64 317 */ 318 static MeasureUnit getRadian(); 319 #endif /* U_HIDE_DRAFT_API */ 320 321 /** 322 * Returns by pointer, unit of angle: revolution. 323 * Caller owns returned value and must free it. 324 * Also see {@link #getRevolutionAngle()}. 325 * @param status ICU error code. 326 * @stable ICU 56 327 */ 328 static MeasureUnit *createRevolutionAngle(UErrorCode &status); 329 330 #ifndef U_HIDE_DRAFT_API 331 /** 332 * Returns by value, unit of angle: revolution. 333 * Also see {@link #createRevolutionAngle()}. 334 * @draft ICU 64 335 */ 336 static MeasureUnit getRevolutionAngle(); 337 #endif /* U_HIDE_DRAFT_API */ 338 339 /** 340 * Returns by pointer, unit of area: acre. 341 * Caller owns returned value and must free it. 342 * Also see {@link #getAcre()}. 343 * @param status ICU error code. 344 * @stable ICU 53 345 */ 346 static MeasureUnit *createAcre(UErrorCode &status); 347 348 #ifndef U_HIDE_DRAFT_API 349 /** 350 * Returns by value, unit of area: acre. 351 * Also see {@link #createAcre()}. 352 * @draft ICU 64 353 */ 354 static MeasureUnit getAcre(); 355 #endif /* U_HIDE_DRAFT_API */ 356 357 #ifndef U_HIDE_DRAFT_API 358 /** 359 * Returns by pointer, unit of area: dunam. 360 * Caller owns returned value and must free it. 361 * Also see {@link #getDunam()}. 362 * @param status ICU error code. 363 * @draft ICU 64 364 */ 365 static MeasureUnit *createDunam(UErrorCode &status); 366 367 /** 368 * Returns by value, unit of area: dunam. 369 * Also see {@link #createDunam()}. 370 * @draft ICU 64 371 */ 372 static MeasureUnit getDunam(); 373 #endif /* U_HIDE_DRAFT_API */ 374 375 /** 376 * Returns by pointer, unit of area: hectare. 377 * Caller owns returned value and must free it. 378 * Also see {@link #getHectare()}. 379 * @param status ICU error code. 380 * @stable ICU 53 381 */ 382 static MeasureUnit *createHectare(UErrorCode &status); 383 384 #ifndef U_HIDE_DRAFT_API 385 /** 386 * Returns by value, unit of area: hectare. 387 * Also see {@link #createHectare()}. 388 * @draft ICU 64 389 */ 390 static MeasureUnit getHectare(); 391 #endif /* U_HIDE_DRAFT_API */ 392 393 /** 394 * Returns by pointer, unit of area: square-centimeter. 395 * Caller owns returned value and must free it. 396 * Also see {@link #getSquareCentimeter()}. 397 * @param status ICU error code. 398 * @stable ICU 54 399 */ 400 static MeasureUnit *createSquareCentimeter(UErrorCode &status); 401 402 #ifndef U_HIDE_DRAFT_API 403 /** 404 * Returns by value, unit of area: square-centimeter. 405 * Also see {@link #createSquareCentimeter()}. 406 * @draft ICU 64 407 */ 408 static MeasureUnit getSquareCentimeter(); 409 #endif /* U_HIDE_DRAFT_API */ 410 411 /** 412 * Returns by pointer, unit of area: square-foot. 413 * Caller owns returned value and must free it. 414 * Also see {@link #getSquareFoot()}. 415 * @param status ICU error code. 416 * @stable ICU 53 417 */ 418 static MeasureUnit *createSquareFoot(UErrorCode &status); 419 420 #ifndef U_HIDE_DRAFT_API 421 /** 422 * Returns by value, unit of area: square-foot. 423 * Also see {@link #createSquareFoot()}. 424 * @draft ICU 64 425 */ 426 static MeasureUnit getSquareFoot(); 427 #endif /* U_HIDE_DRAFT_API */ 428 429 /** 430 * Returns by pointer, unit of area: square-inch. 431 * Caller owns returned value and must free it. 432 * Also see {@link #getSquareInch()}. 433 * @param status ICU error code. 434 * @stable ICU 54 435 */ 436 static MeasureUnit *createSquareInch(UErrorCode &status); 437 438 #ifndef U_HIDE_DRAFT_API 439 /** 440 * Returns by value, unit of area: square-inch. 441 * Also see {@link #createSquareInch()}. 442 * @draft ICU 64 443 */ 444 static MeasureUnit getSquareInch(); 445 #endif /* U_HIDE_DRAFT_API */ 446 447 /** 448 * Returns by pointer, unit of area: square-kilometer. 449 * Caller owns returned value and must free it. 450 * Also see {@link #getSquareKilometer()}. 451 * @param status ICU error code. 452 * @stable ICU 53 453 */ 454 static MeasureUnit *createSquareKilometer(UErrorCode &status); 455 456 #ifndef U_HIDE_DRAFT_API 457 /** 458 * Returns by value, unit of area: square-kilometer. 459 * Also see {@link #createSquareKilometer()}. 460 * @draft ICU 64 461 */ 462 static MeasureUnit getSquareKilometer(); 463 #endif /* U_HIDE_DRAFT_API */ 464 465 /** 466 * Returns by pointer, unit of area: square-meter. 467 * Caller owns returned value and must free it. 468 * Also see {@link #getSquareMeter()}. 469 * @param status ICU error code. 470 * @stable ICU 53 471 */ 472 static MeasureUnit *createSquareMeter(UErrorCode &status); 473 474 #ifndef U_HIDE_DRAFT_API 475 /** 476 * Returns by value, unit of area: square-meter. 477 * Also see {@link #createSquareMeter()}. 478 * @draft ICU 64 479 */ 480 static MeasureUnit getSquareMeter(); 481 #endif /* U_HIDE_DRAFT_API */ 482 483 /** 484 * Returns by pointer, unit of area: square-mile. 485 * Caller owns returned value and must free it. 486 * Also see {@link #getSquareMile()}. 487 * @param status ICU error code. 488 * @stable ICU 53 489 */ 490 static MeasureUnit *createSquareMile(UErrorCode &status); 491 492 #ifndef U_HIDE_DRAFT_API 493 /** 494 * Returns by value, unit of area: square-mile. 495 * Also see {@link #createSquareMile()}. 496 * @draft ICU 64 497 */ 498 static MeasureUnit getSquareMile(); 499 #endif /* U_HIDE_DRAFT_API */ 500 501 /** 502 * Returns by pointer, unit of area: square-yard. 503 * Caller owns returned value and must free it. 504 * Also see {@link #getSquareYard()}. 505 * @param status ICU error code. 506 * @stable ICU 54 507 */ 508 static MeasureUnit *createSquareYard(UErrorCode &status); 509 510 #ifndef U_HIDE_DRAFT_API 511 /** 512 * Returns by value, unit of area: square-yard. 513 * Also see {@link #createSquareYard()}. 514 * @draft ICU 64 515 */ 516 static MeasureUnit getSquareYard(); 517 #endif /* U_HIDE_DRAFT_API */ 518 519 /** 520 * Returns by pointer, unit of concentr: karat. 521 * Caller owns returned value and must free it. 522 * Also see {@link #getKarat()}. 523 * @param status ICU error code. 524 * @stable ICU 54 525 */ 526 static MeasureUnit *createKarat(UErrorCode &status); 527 528 #ifndef U_HIDE_DRAFT_API 529 /** 530 * Returns by value, unit of concentr: karat. 531 * Also see {@link #createKarat()}. 532 * @draft ICU 64 533 */ 534 static MeasureUnit getKarat(); 535 #endif /* U_HIDE_DRAFT_API */ 536 537 /** 538 * Returns by pointer, unit of concentr: milligram-per-deciliter. 539 * Caller owns returned value and must free it. 540 * Also see {@link #getMilligramPerDeciliter()}. 541 * @param status ICU error code. 542 * @stable ICU 57 543 */ 544 static MeasureUnit *createMilligramPerDeciliter(UErrorCode &status); 545 546 #ifndef U_HIDE_DRAFT_API 547 /** 548 * Returns by value, unit of concentr: milligram-per-deciliter. 549 * Also see {@link #createMilligramPerDeciliter()}. 550 * @draft ICU 64 551 */ 552 static MeasureUnit getMilligramPerDeciliter(); 553 #endif /* U_HIDE_DRAFT_API */ 554 555 /** 556 * Returns by pointer, unit of concentr: millimole-per-liter. 557 * Caller owns returned value and must free it. 558 * Also see {@link #getMillimolePerLiter()}. 559 * @param status ICU error code. 560 * @stable ICU 57 561 */ 562 static MeasureUnit *createMillimolePerLiter(UErrorCode &status); 563 564 #ifndef U_HIDE_DRAFT_API 565 /** 566 * Returns by value, unit of concentr: millimole-per-liter. 567 * Also see {@link #createMillimolePerLiter()}. 568 * @draft ICU 64 569 */ 570 static MeasureUnit getMillimolePerLiter(); 571 #endif /* U_HIDE_DRAFT_API */ 572 573 #ifndef U_HIDE_DRAFT_API 574 /** 575 * Returns by pointer, unit of concentr: mole. 576 * Caller owns returned value and must free it. 577 * Also see {@link #getMole()}. 578 * @param status ICU error code. 579 * @draft ICU 64 580 */ 581 static MeasureUnit *createMole(UErrorCode &status); 582 583 /** 584 * Returns by value, unit of concentr: mole. 585 * Also see {@link #createMole()}. 586 * @draft ICU 64 587 */ 588 static MeasureUnit getMole(); 589 #endif /* U_HIDE_DRAFT_API */ 590 591 /** 592 * Returns by pointer, unit of concentr: part-per-million. 593 * Caller owns returned value and must free it. 594 * Also see {@link #getPartPerMillion()}. 595 * @param status ICU error code. 596 * @stable ICU 57 597 */ 598 static MeasureUnit *createPartPerMillion(UErrorCode &status); 599 600 #ifndef U_HIDE_DRAFT_API 601 /** 602 * Returns by value, unit of concentr: part-per-million. 603 * Also see {@link #createPartPerMillion()}. 604 * @draft ICU 64 605 */ 606 static MeasureUnit getPartPerMillion(); 607 #endif /* U_HIDE_DRAFT_API */ 608 609 /** 610 * Returns by pointer, unit of concentr: percent. 611 * Caller owns returned value and must free it. 612 * Also see {@link #getPercent()}. 613 * @param status ICU error code. 614 * @stable ICU 63 615 */ 616 static MeasureUnit *createPercent(UErrorCode &status); 617 618 #ifndef U_HIDE_DRAFT_API 619 /** 620 * Returns by value, unit of concentr: percent. 621 * Also see {@link #createPercent()}. 622 * @draft ICU 64 623 */ 624 static MeasureUnit getPercent(); 625 #endif /* U_HIDE_DRAFT_API */ 626 627 /** 628 * Returns by pointer, unit of concentr: permille. 629 * Caller owns returned value and must free it. 630 * Also see {@link #getPermille()}. 631 * @param status ICU error code. 632 * @stable ICU 63 633 */ 634 static MeasureUnit *createPermille(UErrorCode &status); 635 636 #ifndef U_HIDE_DRAFT_API 637 /** 638 * Returns by value, unit of concentr: permille. 639 * Also see {@link #createPermille()}. 640 * @draft ICU 64 641 */ 642 static MeasureUnit getPermille(); 643 #endif /* U_HIDE_DRAFT_API */ 644 645 #ifndef U_HIDE_DRAFT_API 646 /** 647 * Returns by pointer, unit of concentr: permyriad. 648 * Caller owns returned value and must free it. 649 * Also see {@link #getPermyriad()}. 650 * @param status ICU error code. 651 * @draft ICU 64 652 */ 653 static MeasureUnit *createPermyriad(UErrorCode &status); 654 655 /** 656 * Returns by value, unit of concentr: permyriad. 657 * Also see {@link #createPermyriad()}. 658 * @draft ICU 64 659 */ 660 static MeasureUnit getPermyriad(); 661 #endif /* U_HIDE_DRAFT_API */ 662 663 /** 664 * Returns by pointer, unit of consumption: liter-per-100kilometers. 665 * Caller owns returned value and must free it. 666 * Also see {@link #getLiterPer100Kilometers()}. 667 * @param status ICU error code. 668 * @stable ICU 56 669 */ 670 static MeasureUnit *createLiterPer100Kilometers(UErrorCode &status); 671 672 #ifndef U_HIDE_DRAFT_API 673 /** 674 * Returns by value, unit of consumption: liter-per-100kilometers. 675 * Also see {@link #createLiterPer100Kilometers()}. 676 * @draft ICU 64 677 */ 678 static MeasureUnit getLiterPer100Kilometers(); 679 #endif /* U_HIDE_DRAFT_API */ 680 681 /** 682 * Returns by pointer, unit of consumption: liter-per-kilometer. 683 * Caller owns returned value and must free it. 684 * Also see {@link #getLiterPerKilometer()}. 685 * @param status ICU error code. 686 * @stable ICU 54 687 */ 688 static MeasureUnit *createLiterPerKilometer(UErrorCode &status); 689 690 #ifndef U_HIDE_DRAFT_API 691 /** 692 * Returns by value, unit of consumption: liter-per-kilometer. 693 * Also see {@link #createLiterPerKilometer()}. 694 * @draft ICU 64 695 */ 696 static MeasureUnit getLiterPerKilometer(); 697 #endif /* U_HIDE_DRAFT_API */ 698 699 /** 700 * Returns by pointer, unit of consumption: mile-per-gallon. 701 * Caller owns returned value and must free it. 702 * Also see {@link #getMilePerGallon()}. 703 * @param status ICU error code. 704 * @stable ICU 54 705 */ 706 static MeasureUnit *createMilePerGallon(UErrorCode &status); 707 708 #ifndef U_HIDE_DRAFT_API 709 /** 710 * Returns by value, unit of consumption: mile-per-gallon. 711 * Also see {@link #createMilePerGallon()}. 712 * @draft ICU 64 713 */ 714 static MeasureUnit getMilePerGallon(); 715 #endif /* U_HIDE_DRAFT_API */ 716 717 /** 718 * Returns by pointer, unit of consumption: mile-per-gallon-imperial. 719 * Caller owns returned value and must free it. 720 * Also see {@link #getMilePerGallonImperial()}. 721 * @param status ICU error code. 722 * @stable ICU 57 723 */ 724 static MeasureUnit *createMilePerGallonImperial(UErrorCode &status); 725 726 #ifndef U_HIDE_DRAFT_API 727 /** 728 * Returns by value, unit of consumption: mile-per-gallon-imperial. 729 * Also see {@link #createMilePerGallonImperial()}. 730 * @draft ICU 64 731 */ 732 static MeasureUnit getMilePerGallonImperial(); 733 #endif /* U_HIDE_DRAFT_API */ 734 735 /** 736 * Returns by pointer, unit of digital: bit. 737 * Caller owns returned value and must free it. 738 * Also see {@link #getBit()}. 739 * @param status ICU error code. 740 * @stable ICU 54 741 */ 742 static MeasureUnit *createBit(UErrorCode &status); 743 744 #ifndef U_HIDE_DRAFT_API 745 /** 746 * Returns by value, unit of digital: bit. 747 * Also see {@link #createBit()}. 748 * @draft ICU 64 749 */ 750 static MeasureUnit getBit(); 751 #endif /* U_HIDE_DRAFT_API */ 752 753 /** 754 * Returns by pointer, unit of digital: byte. 755 * Caller owns returned value and must free it. 756 * Also see {@link #getByte()}. 757 * @param status ICU error code. 758 * @stable ICU 54 759 */ 760 static MeasureUnit *createByte(UErrorCode &status); 761 762 #ifndef U_HIDE_DRAFT_API 763 /** 764 * Returns by value, unit of digital: byte. 765 * Also see {@link #createByte()}. 766 * @draft ICU 64 767 */ 768 static MeasureUnit getByte(); 769 #endif /* U_HIDE_DRAFT_API */ 770 771 /** 772 * Returns by pointer, unit of digital: gigabit. 773 * Caller owns returned value and must free it. 774 * Also see {@link #getGigabit()}. 775 * @param status ICU error code. 776 * @stable ICU 54 777 */ 778 static MeasureUnit *createGigabit(UErrorCode &status); 779 780 #ifndef U_HIDE_DRAFT_API 781 /** 782 * Returns by value, unit of digital: gigabit. 783 * Also see {@link #createGigabit()}. 784 * @draft ICU 64 785 */ 786 static MeasureUnit getGigabit(); 787 #endif /* U_HIDE_DRAFT_API */ 788 789 /** 790 * Returns by pointer, unit of digital: gigabyte. 791 * Caller owns returned value and must free it. 792 * Also see {@link #getGigabyte()}. 793 * @param status ICU error code. 794 * @stable ICU 54 795 */ 796 static MeasureUnit *createGigabyte(UErrorCode &status); 797 798 #ifndef U_HIDE_DRAFT_API 799 /** 800 * Returns by value, unit of digital: gigabyte. 801 * Also see {@link #createGigabyte()}. 802 * @draft ICU 64 803 */ 804 static MeasureUnit getGigabyte(); 805 #endif /* U_HIDE_DRAFT_API */ 806 807 /** 808 * Returns by pointer, unit of digital: kilobit. 809 * Caller owns returned value and must free it. 810 * Also see {@link #getKilobit()}. 811 * @param status ICU error code. 812 * @stable ICU 54 813 */ 814 static MeasureUnit *createKilobit(UErrorCode &status); 815 816 #ifndef U_HIDE_DRAFT_API 817 /** 818 * Returns by value, unit of digital: kilobit. 819 * Also see {@link #createKilobit()}. 820 * @draft ICU 64 821 */ 822 static MeasureUnit getKilobit(); 823 #endif /* U_HIDE_DRAFT_API */ 824 825 /** 826 * Returns by pointer, unit of digital: kilobyte. 827 * Caller owns returned value and must free it. 828 * Also see {@link #getKilobyte()}. 829 * @param status ICU error code. 830 * @stable ICU 54 831 */ 832 static MeasureUnit *createKilobyte(UErrorCode &status); 833 834 #ifndef U_HIDE_DRAFT_API 835 /** 836 * Returns by value, unit of digital: kilobyte. 837 * Also see {@link #createKilobyte()}. 838 * @draft ICU 64 839 */ 840 static MeasureUnit getKilobyte(); 841 #endif /* U_HIDE_DRAFT_API */ 842 843 /** 844 * Returns by pointer, unit of digital: megabit. 845 * Caller owns returned value and must free it. 846 * Also see {@link #getMegabit()}. 847 * @param status ICU error code. 848 * @stable ICU 54 849 */ 850 static MeasureUnit *createMegabit(UErrorCode &status); 851 852 #ifndef U_HIDE_DRAFT_API 853 /** 854 * Returns by value, unit of digital: megabit. 855 * Also see {@link #createMegabit()}. 856 * @draft ICU 64 857 */ 858 static MeasureUnit getMegabit(); 859 #endif /* U_HIDE_DRAFT_API */ 860 861 /** 862 * Returns by pointer, unit of digital: megabyte. 863 * Caller owns returned value and must free it. 864 * Also see {@link #getMegabyte()}. 865 * @param status ICU error code. 866 * @stable ICU 54 867 */ 868 static MeasureUnit *createMegabyte(UErrorCode &status); 869 870 #ifndef U_HIDE_DRAFT_API 871 /** 872 * Returns by value, unit of digital: megabyte. 873 * Also see {@link #createMegabyte()}. 874 * @draft ICU 64 875 */ 876 static MeasureUnit getMegabyte(); 877 #endif /* U_HIDE_DRAFT_API */ 878 879 /** 880 * Returns by pointer, unit of digital: petabyte. 881 * Caller owns returned value and must free it. 882 * Also see {@link #getPetabyte()}. 883 * @param status ICU error code. 884 * @stable ICU 63 885 */ 886 static MeasureUnit *createPetabyte(UErrorCode &status); 887 888 #ifndef U_HIDE_DRAFT_API 889 /** 890 * Returns by value, unit of digital: petabyte. 891 * Also see {@link #createPetabyte()}. 892 * @draft ICU 64 893 */ 894 static MeasureUnit getPetabyte(); 895 #endif /* U_HIDE_DRAFT_API */ 896 897 /** 898 * Returns by pointer, unit of digital: terabit. 899 * Caller owns returned value and must free it. 900 * Also see {@link #getTerabit()}. 901 * @param status ICU error code. 902 * @stable ICU 54 903 */ 904 static MeasureUnit *createTerabit(UErrorCode &status); 905 906 #ifndef U_HIDE_DRAFT_API 907 /** 908 * Returns by value, unit of digital: terabit. 909 * Also see {@link #createTerabit()}. 910 * @draft ICU 64 911 */ 912 static MeasureUnit getTerabit(); 913 #endif /* U_HIDE_DRAFT_API */ 914 915 /** 916 * Returns by pointer, unit of digital: terabyte. 917 * Caller owns returned value and must free it. 918 * Also see {@link #getTerabyte()}. 919 * @param status ICU error code. 920 * @stable ICU 54 921 */ 922 static MeasureUnit *createTerabyte(UErrorCode &status); 923 924 #ifndef U_HIDE_DRAFT_API 925 /** 926 * Returns by value, unit of digital: terabyte. 927 * Also see {@link #createTerabyte()}. 928 * @draft ICU 64 929 */ 930 static MeasureUnit getTerabyte(); 931 #endif /* U_HIDE_DRAFT_API */ 932 933 /** 934 * Returns by pointer, unit of duration: century. 935 * Caller owns returned value and must free it. 936 * Also see {@link #getCentury()}. 937 * @param status ICU error code. 938 * @stable ICU 56 939 */ 940 static MeasureUnit *createCentury(UErrorCode &status); 941 942 #ifndef U_HIDE_DRAFT_API 943 /** 944 * Returns by value, unit of duration: century. 945 * Also see {@link #createCentury()}. 946 * @draft ICU 64 947 */ 948 static MeasureUnit getCentury(); 949 #endif /* U_HIDE_DRAFT_API */ 950 951 /** 952 * Returns by pointer, unit of duration: day. 953 * Caller owns returned value and must free it. 954 * Also see {@link #getDay()}. 955 * @param status ICU error code. 956 * @stable ICU 53 957 */ 958 static MeasureUnit *createDay(UErrorCode &status); 959 960 #ifndef U_HIDE_DRAFT_API 961 /** 962 * Returns by value, unit of duration: day. 963 * Also see {@link #createDay()}. 964 * @draft ICU 64 965 */ 966 static MeasureUnit getDay(); 967 #endif /* U_HIDE_DRAFT_API */ 968 969 #ifndef U_HIDE_DRAFT_API 970 /** 971 * Returns by pointer, unit of duration: day-person. 972 * Caller owns returned value and must free it. 973 * Also see {@link #getDayPerson()}. 974 * @param status ICU error code. 975 * @draft ICU 64 976 */ 977 static MeasureUnit *createDayPerson(UErrorCode &status); 978 979 /** 980 * Returns by value, unit of duration: day-person. 981 * Also see {@link #createDayPerson()}. 982 * @draft ICU 64 983 */ 984 static MeasureUnit getDayPerson(); 985 #endif /* U_HIDE_DRAFT_API */ 986 987 #ifndef U_HIDE_DRAFT_API 988 /** 989 * Returns by pointer, unit of duration: decade. 990 * Caller owns returned value and must free it. 991 * Also see {@link #getDecade()}. 992 * @param status ICU error code. 993 * @draft ICU 65 994 */ 995 static MeasureUnit *createDecade(UErrorCode &status); 996 997 /** 998 * Returns by value, unit of duration: decade. 999 * Also see {@link #createDecade()}. 1000 * @draft ICU 65 1001 */ 1002 static MeasureUnit getDecade(); 1003 #endif /* U_HIDE_DRAFT_API */ 1004 1005 /** 1006 * Returns by pointer, unit of duration: hour. 1007 * Caller owns returned value and must free it. 1008 * Also see {@link #getHour()}. 1009 * @param status ICU error code. 1010 * @stable ICU 53 1011 */ 1012 static MeasureUnit *createHour(UErrorCode &status); 1013 1014 #ifndef U_HIDE_DRAFT_API 1015 /** 1016 * Returns by value, unit of duration: hour. 1017 * Also see {@link #createHour()}. 1018 * @draft ICU 64 1019 */ 1020 static MeasureUnit getHour(); 1021 #endif /* U_HIDE_DRAFT_API */ 1022 1023 /** 1024 * Returns by pointer, unit of duration: microsecond. 1025 * Caller owns returned value and must free it. 1026 * Also see {@link #getMicrosecond()}. 1027 * @param status ICU error code. 1028 * @stable ICU 54 1029 */ 1030 static MeasureUnit *createMicrosecond(UErrorCode &status); 1031 1032 #ifndef U_HIDE_DRAFT_API 1033 /** 1034 * Returns by value, unit of duration: microsecond. 1035 * Also see {@link #createMicrosecond()}. 1036 * @draft ICU 64 1037 */ 1038 static MeasureUnit getMicrosecond(); 1039 #endif /* U_HIDE_DRAFT_API */ 1040 1041 /** 1042 * Returns by pointer, unit of duration: millisecond. 1043 * Caller owns returned value and must free it. 1044 * Also see {@link #getMillisecond()}. 1045 * @param status ICU error code. 1046 * @stable ICU 53 1047 */ 1048 static MeasureUnit *createMillisecond(UErrorCode &status); 1049 1050 #ifndef U_HIDE_DRAFT_API 1051 /** 1052 * Returns by value, unit of duration: millisecond. 1053 * Also see {@link #createMillisecond()}. 1054 * @draft ICU 64 1055 */ 1056 static MeasureUnit getMillisecond(); 1057 #endif /* U_HIDE_DRAFT_API */ 1058 1059 /** 1060 * Returns by pointer, unit of duration: minute. 1061 * Caller owns returned value and must free it. 1062 * Also see {@link #getMinute()}. 1063 * @param status ICU error code. 1064 * @stable ICU 53 1065 */ 1066 static MeasureUnit *createMinute(UErrorCode &status); 1067 1068 #ifndef U_HIDE_DRAFT_API 1069 /** 1070 * Returns by value, unit of duration: minute. 1071 * Also see {@link #createMinute()}. 1072 * @draft ICU 64 1073 */ 1074 static MeasureUnit getMinute(); 1075 #endif /* U_HIDE_DRAFT_API */ 1076 1077 /** 1078 * Returns by pointer, unit of duration: month. 1079 * Caller owns returned value and must free it. 1080 * Also see {@link #getMonth()}. 1081 * @param status ICU error code. 1082 * @stable ICU 53 1083 */ 1084 static MeasureUnit *createMonth(UErrorCode &status); 1085 1086 #ifndef U_HIDE_DRAFT_API 1087 /** 1088 * Returns by value, unit of duration: month. 1089 * Also see {@link #createMonth()}. 1090 * @draft ICU 64 1091 */ 1092 static MeasureUnit getMonth(); 1093 #endif /* U_HIDE_DRAFT_API */ 1094 1095 #ifndef U_HIDE_DRAFT_API 1096 /** 1097 * Returns by pointer, unit of duration: month-person. 1098 * Caller owns returned value and must free it. 1099 * Also see {@link #getMonthPerson()}. 1100 * @param status ICU error code. 1101 * @draft ICU 64 1102 */ 1103 static MeasureUnit *createMonthPerson(UErrorCode &status); 1104 1105 /** 1106 * Returns by value, unit of duration: month-person. 1107 * Also see {@link #createMonthPerson()}. 1108 * @draft ICU 64 1109 */ 1110 static MeasureUnit getMonthPerson(); 1111 #endif /* U_HIDE_DRAFT_API */ 1112 1113 /** 1114 * Returns by pointer, unit of duration: nanosecond. 1115 * Caller owns returned value and must free it. 1116 * Also see {@link #getNanosecond()}. 1117 * @param status ICU error code. 1118 * @stable ICU 54 1119 */ 1120 static MeasureUnit *createNanosecond(UErrorCode &status); 1121 1122 #ifndef U_HIDE_DRAFT_API 1123 /** 1124 * Returns by value, unit of duration: nanosecond. 1125 * Also see {@link #createNanosecond()}. 1126 * @draft ICU 64 1127 */ 1128 static MeasureUnit getNanosecond(); 1129 #endif /* U_HIDE_DRAFT_API */ 1130 1131 /** 1132 * Returns by pointer, unit of duration: second. 1133 * Caller owns returned value and must free it. 1134 * Also see {@link #getSecond()}. 1135 * @param status ICU error code. 1136 * @stable ICU 53 1137 */ 1138 static MeasureUnit *createSecond(UErrorCode &status); 1139 1140 #ifndef U_HIDE_DRAFT_API 1141 /** 1142 * Returns by value, unit of duration: second. 1143 * Also see {@link #createSecond()}. 1144 * @draft ICU 64 1145 */ 1146 static MeasureUnit getSecond(); 1147 #endif /* U_HIDE_DRAFT_API */ 1148 1149 /** 1150 * Returns by pointer, unit of duration: week. 1151 * Caller owns returned value and must free it. 1152 * Also see {@link #getWeek()}. 1153 * @param status ICU error code. 1154 * @stable ICU 53 1155 */ 1156 static MeasureUnit *createWeek(UErrorCode &status); 1157 1158 #ifndef U_HIDE_DRAFT_API 1159 /** 1160 * Returns by value, unit of duration: week. 1161 * Also see {@link #createWeek()}. 1162 * @draft ICU 64 1163 */ 1164 static MeasureUnit getWeek(); 1165 #endif /* U_HIDE_DRAFT_API */ 1166 1167 #ifndef U_HIDE_DRAFT_API 1168 /** 1169 * Returns by pointer, unit of duration: week-person. 1170 * Caller owns returned value and must free it. 1171 * Also see {@link #getWeekPerson()}. 1172 * @param status ICU error code. 1173 * @draft ICU 64 1174 */ 1175 static MeasureUnit *createWeekPerson(UErrorCode &status); 1176 1177 /** 1178 * Returns by value, unit of duration: week-person. 1179 * Also see {@link #createWeekPerson()}. 1180 * @draft ICU 64 1181 */ 1182 static MeasureUnit getWeekPerson(); 1183 #endif /* U_HIDE_DRAFT_API */ 1184 1185 /** 1186 * Returns by pointer, unit of duration: year. 1187 * Caller owns returned value and must free it. 1188 * Also see {@link #getYear()}. 1189 * @param status ICU error code. 1190 * @stable ICU 53 1191 */ 1192 static MeasureUnit *createYear(UErrorCode &status); 1193 1194 #ifndef U_HIDE_DRAFT_API 1195 /** 1196 * Returns by value, unit of duration: year. 1197 * Also see {@link #createYear()}. 1198 * @draft ICU 64 1199 */ 1200 static MeasureUnit getYear(); 1201 #endif /* U_HIDE_DRAFT_API */ 1202 1203 #ifndef U_HIDE_DRAFT_API 1204 /** 1205 * Returns by pointer, unit of duration: year-person. 1206 * Caller owns returned value and must free it. 1207 * Also see {@link #getYearPerson()}. 1208 * @param status ICU error code. 1209 * @draft ICU 64 1210 */ 1211 static MeasureUnit *createYearPerson(UErrorCode &status); 1212 1213 /** 1214 * Returns by value, unit of duration: year-person. 1215 * Also see {@link #createYearPerson()}. 1216 * @draft ICU 64 1217 */ 1218 static MeasureUnit getYearPerson(); 1219 #endif /* U_HIDE_DRAFT_API */ 1220 1221 /** 1222 * Returns by pointer, unit of electric: ampere. 1223 * Caller owns returned value and must free it. 1224 * Also see {@link #getAmpere()}. 1225 * @param status ICU error code. 1226 * @stable ICU 54 1227 */ 1228 static MeasureUnit *createAmpere(UErrorCode &status); 1229 1230 #ifndef U_HIDE_DRAFT_API 1231 /** 1232 * Returns by value, unit of electric: ampere. 1233 * Also see {@link #createAmpere()}. 1234 * @draft ICU 64 1235 */ 1236 static MeasureUnit getAmpere(); 1237 #endif /* U_HIDE_DRAFT_API */ 1238 1239 /** 1240 * Returns by pointer, unit of electric: milliampere. 1241 * Caller owns returned value and must free it. 1242 * Also see {@link #getMilliampere()}. 1243 * @param status ICU error code. 1244 * @stable ICU 54 1245 */ 1246 static MeasureUnit *createMilliampere(UErrorCode &status); 1247 1248 #ifndef U_HIDE_DRAFT_API 1249 /** 1250 * Returns by value, unit of electric: milliampere. 1251 * Also see {@link #createMilliampere()}. 1252 * @draft ICU 64 1253 */ 1254 static MeasureUnit getMilliampere(); 1255 #endif /* U_HIDE_DRAFT_API */ 1256 1257 /** 1258 * Returns by pointer, unit of electric: ohm. 1259 * Caller owns returned value and must free it. 1260 * Also see {@link #getOhm()}. 1261 * @param status ICU error code. 1262 * @stable ICU 54 1263 */ 1264 static MeasureUnit *createOhm(UErrorCode &status); 1265 1266 #ifndef U_HIDE_DRAFT_API 1267 /** 1268 * Returns by value, unit of electric: ohm. 1269 * Also see {@link #createOhm()}. 1270 * @draft ICU 64 1271 */ 1272 static MeasureUnit getOhm(); 1273 #endif /* U_HIDE_DRAFT_API */ 1274 1275 /** 1276 * Returns by pointer, unit of electric: volt. 1277 * Caller owns returned value and must free it. 1278 * Also see {@link #getVolt()}. 1279 * @param status ICU error code. 1280 * @stable ICU 54 1281 */ 1282 static MeasureUnit *createVolt(UErrorCode &status); 1283 1284 #ifndef U_HIDE_DRAFT_API 1285 /** 1286 * Returns by value, unit of electric: volt. 1287 * Also see {@link #createVolt()}. 1288 * @draft ICU 64 1289 */ 1290 static MeasureUnit getVolt(); 1291 #endif /* U_HIDE_DRAFT_API */ 1292 1293 #ifndef U_HIDE_DRAFT_API 1294 /** 1295 * Returns by pointer, unit of energy: british-thermal-unit. 1296 * Caller owns returned value and must free it. 1297 * Also see {@link #getBritishThermalUnit()}. 1298 * @param status ICU error code. 1299 * @draft ICU 64 1300 */ 1301 static MeasureUnit *createBritishThermalUnit(UErrorCode &status); 1302 1303 /** 1304 * Returns by value, unit of energy: british-thermal-unit. 1305 * Also see {@link #createBritishThermalUnit()}. 1306 * @draft ICU 64 1307 */ 1308 static MeasureUnit getBritishThermalUnit(); 1309 #endif /* U_HIDE_DRAFT_API */ 1310 1311 /** 1312 * Returns by pointer, unit of energy: calorie. 1313 * Caller owns returned value and must free it. 1314 * Also see {@link #getCalorie()}. 1315 * @param status ICU error code. 1316 * @stable ICU 54 1317 */ 1318 static MeasureUnit *createCalorie(UErrorCode &status); 1319 1320 #ifndef U_HIDE_DRAFT_API 1321 /** 1322 * Returns by value, unit of energy: calorie. 1323 * Also see {@link #createCalorie()}. 1324 * @draft ICU 64 1325 */ 1326 static MeasureUnit getCalorie(); 1327 #endif /* U_HIDE_DRAFT_API */ 1328 1329 #ifndef U_HIDE_DRAFT_API 1330 /** 1331 * Returns by pointer, unit of energy: electronvolt. 1332 * Caller owns returned value and must free it. 1333 * Also see {@link #getElectronvolt()}. 1334 * @param status ICU error code. 1335 * @draft ICU 64 1336 */ 1337 static MeasureUnit *createElectronvolt(UErrorCode &status); 1338 1339 /** 1340 * Returns by value, unit of energy: electronvolt. 1341 * Also see {@link #createElectronvolt()}. 1342 * @draft ICU 64 1343 */ 1344 static MeasureUnit getElectronvolt(); 1345 #endif /* U_HIDE_DRAFT_API */ 1346 1347 /** 1348 * Returns by pointer, unit of energy: foodcalorie. 1349 * Caller owns returned value and must free it. 1350 * Also see {@link #getFoodcalorie()}. 1351 * @param status ICU error code. 1352 * @stable ICU 54 1353 */ 1354 static MeasureUnit *createFoodcalorie(UErrorCode &status); 1355 1356 #ifndef U_HIDE_DRAFT_API 1357 /** 1358 * Returns by value, unit of energy: foodcalorie. 1359 * Also see {@link #createFoodcalorie()}. 1360 * @draft ICU 64 1361 */ 1362 static MeasureUnit getFoodcalorie(); 1363 #endif /* U_HIDE_DRAFT_API */ 1364 1365 /** 1366 * Returns by pointer, unit of energy: joule. 1367 * Caller owns returned value and must free it. 1368 * Also see {@link #getJoule()}. 1369 * @param status ICU error code. 1370 * @stable ICU 54 1371 */ 1372 static MeasureUnit *createJoule(UErrorCode &status); 1373 1374 #ifndef U_HIDE_DRAFT_API 1375 /** 1376 * Returns by value, unit of energy: joule. 1377 * Also see {@link #createJoule()}. 1378 * @draft ICU 64 1379 */ 1380 static MeasureUnit getJoule(); 1381 #endif /* U_HIDE_DRAFT_API */ 1382 1383 /** 1384 * Returns by pointer, unit of energy: kilocalorie. 1385 * Caller owns returned value and must free it. 1386 * Also see {@link #getKilocalorie()}. 1387 * @param status ICU error code. 1388 * @stable ICU 54 1389 */ 1390 static MeasureUnit *createKilocalorie(UErrorCode &status); 1391 1392 #ifndef U_HIDE_DRAFT_API 1393 /** 1394 * Returns by value, unit of energy: kilocalorie. 1395 * Also see {@link #createKilocalorie()}. 1396 * @draft ICU 64 1397 */ 1398 static MeasureUnit getKilocalorie(); 1399 #endif /* U_HIDE_DRAFT_API */ 1400 1401 /** 1402 * Returns by pointer, unit of energy: kilojoule. 1403 * Caller owns returned value and must free it. 1404 * Also see {@link #getKilojoule()}. 1405 * @param status ICU error code. 1406 * @stable ICU 54 1407 */ 1408 static MeasureUnit *createKilojoule(UErrorCode &status); 1409 1410 #ifndef U_HIDE_DRAFT_API 1411 /** 1412 * Returns by value, unit of energy: kilojoule. 1413 * Also see {@link #createKilojoule()}. 1414 * @draft ICU 64 1415 */ 1416 static MeasureUnit getKilojoule(); 1417 #endif /* U_HIDE_DRAFT_API */ 1418 1419 /** 1420 * Returns by pointer, unit of energy: kilowatt-hour. 1421 * Caller owns returned value and must free it. 1422 * Also see {@link #getKilowattHour()}. 1423 * @param status ICU error code. 1424 * @stable ICU 54 1425 */ 1426 static MeasureUnit *createKilowattHour(UErrorCode &status); 1427 1428 #ifndef U_HIDE_DRAFT_API 1429 /** 1430 * Returns by value, unit of energy: kilowatt-hour. 1431 * Also see {@link #createKilowattHour()}. 1432 * @draft ICU 64 1433 */ 1434 static MeasureUnit getKilowattHour(); 1435 #endif /* U_HIDE_DRAFT_API */ 1436 1437 #ifndef U_HIDE_DRAFT_API 1438 /** 1439 * Returns by pointer, unit of energy: therm-us. 1440 * Caller owns returned value and must free it. 1441 * Also see {@link #getThermUs()}. 1442 * @param status ICU error code. 1443 * @draft ICU 65 1444 */ 1445 static MeasureUnit *createThermUs(UErrorCode &status); 1446 1447 /** 1448 * Returns by value, unit of energy: therm-us. 1449 * Also see {@link #createThermUs()}. 1450 * @draft ICU 65 1451 */ 1452 static MeasureUnit getThermUs(); 1453 #endif /* U_HIDE_DRAFT_API */ 1454 1455 #ifndef U_HIDE_DRAFT_API 1456 /** 1457 * Returns by pointer, unit of force: newton. 1458 * Caller owns returned value and must free it. 1459 * Also see {@link #getNewton()}. 1460 * @param status ICU error code. 1461 * @draft ICU 64 1462 */ 1463 static MeasureUnit *createNewton(UErrorCode &status); 1464 1465 /** 1466 * Returns by value, unit of force: newton. 1467 * Also see {@link #createNewton()}. 1468 * @draft ICU 64 1469 */ 1470 static MeasureUnit getNewton(); 1471 #endif /* U_HIDE_DRAFT_API */ 1472 1473 #ifndef U_HIDE_DRAFT_API 1474 /** 1475 * Returns by pointer, unit of force: pound-force. 1476 * Caller owns returned value and must free it. 1477 * Also see {@link #getPoundForce()}. 1478 * @param status ICU error code. 1479 * @draft ICU 64 1480 */ 1481 static MeasureUnit *createPoundForce(UErrorCode &status); 1482 1483 /** 1484 * Returns by value, unit of force: pound-force. 1485 * Also see {@link #createPoundForce()}. 1486 * @draft ICU 64 1487 */ 1488 static MeasureUnit getPoundForce(); 1489 #endif /* U_HIDE_DRAFT_API */ 1490 1491 /** 1492 * Returns by pointer, unit of frequency: gigahertz. 1493 * Caller owns returned value and must free it. 1494 * Also see {@link #getGigahertz()}. 1495 * @param status ICU error code. 1496 * @stable ICU 54 1497 */ 1498 static MeasureUnit *createGigahertz(UErrorCode &status); 1499 1500 #ifndef U_HIDE_DRAFT_API 1501 /** 1502 * Returns by value, unit of frequency: gigahertz. 1503 * Also see {@link #createGigahertz()}. 1504 * @draft ICU 64 1505 */ 1506 static MeasureUnit getGigahertz(); 1507 #endif /* U_HIDE_DRAFT_API */ 1508 1509 /** 1510 * Returns by pointer, unit of frequency: hertz. 1511 * Caller owns returned value and must free it. 1512 * Also see {@link #getHertz()}. 1513 * @param status ICU error code. 1514 * @stable ICU 54 1515 */ 1516 static MeasureUnit *createHertz(UErrorCode &status); 1517 1518 #ifndef U_HIDE_DRAFT_API 1519 /** 1520 * Returns by value, unit of frequency: hertz. 1521 * Also see {@link #createHertz()}. 1522 * @draft ICU 64 1523 */ 1524 static MeasureUnit getHertz(); 1525 #endif /* U_HIDE_DRAFT_API */ 1526 1527 /** 1528 * Returns by pointer, unit of frequency: kilohertz. 1529 * Caller owns returned value and must free it. 1530 * Also see {@link #getKilohertz()}. 1531 * @param status ICU error code. 1532 * @stable ICU 54 1533 */ 1534 static MeasureUnit *createKilohertz(UErrorCode &status); 1535 1536 #ifndef U_HIDE_DRAFT_API 1537 /** 1538 * Returns by value, unit of frequency: kilohertz. 1539 * Also see {@link #createKilohertz()}. 1540 * @draft ICU 64 1541 */ 1542 static MeasureUnit getKilohertz(); 1543 #endif /* U_HIDE_DRAFT_API */ 1544 1545 /** 1546 * Returns by pointer, unit of frequency: megahertz. 1547 * Caller owns returned value and must free it. 1548 * Also see {@link #getMegahertz()}. 1549 * @param status ICU error code. 1550 * @stable ICU 54 1551 */ 1552 static MeasureUnit *createMegahertz(UErrorCode &status); 1553 1554 #ifndef U_HIDE_DRAFT_API 1555 /** 1556 * Returns by value, unit of frequency: megahertz. 1557 * Also see {@link #createMegahertz()}. 1558 * @draft ICU 64 1559 */ 1560 static MeasureUnit getMegahertz(); 1561 #endif /* U_HIDE_DRAFT_API */ 1562 1563 #ifndef U_HIDE_DRAFT_API 1564 /** 1565 * Returns by pointer, unit of graphics: dot-per-centimeter. 1566 * Caller owns returned value and must free it. 1567 * Also see {@link #getDotPerCentimeter()}. 1568 * @param status ICU error code. 1569 * @draft ICU 65 1570 */ 1571 static MeasureUnit *createDotPerCentimeter(UErrorCode &status); 1572 1573 /** 1574 * Returns by value, unit of graphics: dot-per-centimeter. 1575 * Also see {@link #createDotPerCentimeter()}. 1576 * @draft ICU 65 1577 */ 1578 static MeasureUnit getDotPerCentimeter(); 1579 #endif /* U_HIDE_DRAFT_API */ 1580 1581 #ifndef U_HIDE_DRAFT_API 1582 /** 1583 * Returns by pointer, unit of graphics: dot-per-inch. 1584 * Caller owns returned value and must free it. 1585 * Also see {@link #getDotPerInch()}. 1586 * @param status ICU error code. 1587 * @draft ICU 65 1588 */ 1589 static MeasureUnit *createDotPerInch(UErrorCode &status); 1590 1591 /** 1592 * Returns by value, unit of graphics: dot-per-inch. 1593 * Also see {@link #createDotPerInch()}. 1594 * @draft ICU 65 1595 */ 1596 static MeasureUnit getDotPerInch(); 1597 #endif /* U_HIDE_DRAFT_API */ 1598 1599 #ifndef U_HIDE_DRAFT_API 1600 /** 1601 * Returns by pointer, unit of graphics: em. 1602 * Caller owns returned value and must free it. 1603 * Also see {@link #getEm()}. 1604 * @param status ICU error code. 1605 * @draft ICU 65 1606 */ 1607 static MeasureUnit *createEm(UErrorCode &status); 1608 1609 /** 1610 * Returns by value, unit of graphics: em. 1611 * Also see {@link #createEm()}. 1612 * @draft ICU 65 1613 */ 1614 static MeasureUnit getEm(); 1615 #endif /* U_HIDE_DRAFT_API */ 1616 1617 #ifndef U_HIDE_DRAFT_API 1618 /** 1619 * Returns by pointer, unit of graphics: megapixel. 1620 * Caller owns returned value and must free it. 1621 * Also see {@link #getMegapixel()}. 1622 * @param status ICU error code. 1623 * @draft ICU 65 1624 */ 1625 static MeasureUnit *createMegapixel(UErrorCode &status); 1626 1627 /** 1628 * Returns by value, unit of graphics: megapixel. 1629 * Also see {@link #createMegapixel()}. 1630 * @draft ICU 65 1631 */ 1632 static MeasureUnit getMegapixel(); 1633 #endif /* U_HIDE_DRAFT_API */ 1634 1635 #ifndef U_HIDE_DRAFT_API 1636 /** 1637 * Returns by pointer, unit of graphics: pixel. 1638 * Caller owns returned value and must free it. 1639 * Also see {@link #getPixel()}. 1640 * @param status ICU error code. 1641 * @draft ICU 65 1642 */ 1643 static MeasureUnit *createPixel(UErrorCode &status); 1644 1645 /** 1646 * Returns by value, unit of graphics: pixel. 1647 * Also see {@link #createPixel()}. 1648 * @draft ICU 65 1649 */ 1650 static MeasureUnit getPixel(); 1651 #endif /* U_HIDE_DRAFT_API */ 1652 1653 #ifndef U_HIDE_DRAFT_API 1654 /** 1655 * Returns by pointer, unit of graphics: pixel-per-centimeter. 1656 * Caller owns returned value and must free it. 1657 * Also see {@link #getPixelPerCentimeter()}. 1658 * @param status ICU error code. 1659 * @draft ICU 65 1660 */ 1661 static MeasureUnit *createPixelPerCentimeter(UErrorCode &status); 1662 1663 /** 1664 * Returns by value, unit of graphics: pixel-per-centimeter. 1665 * Also see {@link #createPixelPerCentimeter()}. 1666 * @draft ICU 65 1667 */ 1668 static MeasureUnit getPixelPerCentimeter(); 1669 #endif /* U_HIDE_DRAFT_API */ 1670 1671 #ifndef U_HIDE_DRAFT_API 1672 /** 1673 * Returns by pointer, unit of graphics: pixel-per-inch. 1674 * Caller owns returned value and must free it. 1675 * Also see {@link #getPixelPerInch()}. 1676 * @param status ICU error code. 1677 * @draft ICU 65 1678 */ 1679 static MeasureUnit *createPixelPerInch(UErrorCode &status); 1680 1681 /** 1682 * Returns by value, unit of graphics: pixel-per-inch. 1683 * Also see {@link #createPixelPerInch()}. 1684 * @draft ICU 65 1685 */ 1686 static MeasureUnit getPixelPerInch(); 1687 #endif /* U_HIDE_DRAFT_API */ 1688 1689 /** 1690 * Returns by pointer, unit of length: astronomical-unit. 1691 * Caller owns returned value and must free it. 1692 * Also see {@link #getAstronomicalUnit()}. 1693 * @param status ICU error code. 1694 * @stable ICU 54 1695 */ 1696 static MeasureUnit *createAstronomicalUnit(UErrorCode &status); 1697 1698 #ifndef U_HIDE_DRAFT_API 1699 /** 1700 * Returns by value, unit of length: astronomical-unit. 1701 * Also see {@link #createAstronomicalUnit()}. 1702 * @draft ICU 64 1703 */ 1704 static MeasureUnit getAstronomicalUnit(); 1705 #endif /* U_HIDE_DRAFT_API */ 1706 1707 /** 1708 * Returns by pointer, unit of length: centimeter. 1709 * Caller owns returned value and must free it. 1710 * Also see {@link #getCentimeter()}. 1711 * @param status ICU error code. 1712 * @stable ICU 53 1713 */ 1714 static MeasureUnit *createCentimeter(UErrorCode &status); 1715 1716 #ifndef U_HIDE_DRAFT_API 1717 /** 1718 * Returns by value, unit of length: centimeter. 1719 * Also see {@link #createCentimeter()}. 1720 * @draft ICU 64 1721 */ 1722 static MeasureUnit getCentimeter(); 1723 #endif /* U_HIDE_DRAFT_API */ 1724 1725 /** 1726 * Returns by pointer, unit of length: decimeter. 1727 * Caller owns returned value and must free it. 1728 * Also see {@link #getDecimeter()}. 1729 * @param status ICU error code. 1730 * @stable ICU 54 1731 */ 1732 static MeasureUnit *createDecimeter(UErrorCode &status); 1733 1734 #ifndef U_HIDE_DRAFT_API 1735 /** 1736 * Returns by value, unit of length: decimeter. 1737 * Also see {@link #createDecimeter()}. 1738 * @draft ICU 64 1739 */ 1740 static MeasureUnit getDecimeter(); 1741 #endif /* U_HIDE_DRAFT_API */ 1742 1743 /** 1744 * Returns by pointer, unit of length: fathom. 1745 * Caller owns returned value and must free it. 1746 * Also see {@link #getFathom()}. 1747 * @param status ICU error code. 1748 * @stable ICU 54 1749 */ 1750 static MeasureUnit *createFathom(UErrorCode &status); 1751 1752 #ifndef U_HIDE_DRAFT_API 1753 /** 1754 * Returns by value, unit of length: fathom. 1755 * Also see {@link #createFathom()}. 1756 * @draft ICU 64 1757 */ 1758 static MeasureUnit getFathom(); 1759 #endif /* U_HIDE_DRAFT_API */ 1760 1761 /** 1762 * Returns by pointer, unit of length: foot. 1763 * Caller owns returned value and must free it. 1764 * Also see {@link #getFoot()}. 1765 * @param status ICU error code. 1766 * @stable ICU 53 1767 */ 1768 static MeasureUnit *createFoot(UErrorCode &status); 1769 1770 #ifndef U_HIDE_DRAFT_API 1771 /** 1772 * Returns by value, unit of length: foot. 1773 * Also see {@link #createFoot()}. 1774 * @draft ICU 64 1775 */ 1776 static MeasureUnit getFoot(); 1777 #endif /* U_HIDE_DRAFT_API */ 1778 1779 /** 1780 * Returns by pointer, unit of length: furlong. 1781 * Caller owns returned value and must free it. 1782 * Also see {@link #getFurlong()}. 1783 * @param status ICU error code. 1784 * @stable ICU 54 1785 */ 1786 static MeasureUnit *createFurlong(UErrorCode &status); 1787 1788 #ifndef U_HIDE_DRAFT_API 1789 /** 1790 * Returns by value, unit of length: furlong. 1791 * Also see {@link #createFurlong()}. 1792 * @draft ICU 64 1793 */ 1794 static MeasureUnit getFurlong(); 1795 #endif /* U_HIDE_DRAFT_API */ 1796 1797 /** 1798 * Returns by pointer, unit of length: inch. 1799 * Caller owns returned value and must free it. 1800 * Also see {@link #getInch()}. 1801 * @param status ICU error code. 1802 * @stable ICU 53 1803 */ 1804 static MeasureUnit *createInch(UErrorCode &status); 1805 1806 #ifndef U_HIDE_DRAFT_API 1807 /** 1808 * Returns by value, unit of length: inch. 1809 * Also see {@link #createInch()}. 1810 * @draft ICU 64 1811 */ 1812 static MeasureUnit getInch(); 1813 #endif /* U_HIDE_DRAFT_API */ 1814 1815 /** 1816 * Returns by pointer, unit of length: kilometer. 1817 * Caller owns returned value and must free it. 1818 * Also see {@link #getKilometer()}. 1819 * @param status ICU error code. 1820 * @stable ICU 53 1821 */ 1822 static MeasureUnit *createKilometer(UErrorCode &status); 1823 1824 #ifndef U_HIDE_DRAFT_API 1825 /** 1826 * Returns by value, unit of length: kilometer. 1827 * Also see {@link #createKilometer()}. 1828 * @draft ICU 64 1829 */ 1830 static MeasureUnit getKilometer(); 1831 #endif /* U_HIDE_DRAFT_API */ 1832 1833 /** 1834 * Returns by pointer, unit of length: light-year. 1835 * Caller owns returned value and must free it. 1836 * Also see {@link #getLightYear()}. 1837 * @param status ICU error code. 1838 * @stable ICU 53 1839 */ 1840 static MeasureUnit *createLightYear(UErrorCode &status); 1841 1842 #ifndef U_HIDE_DRAFT_API 1843 /** 1844 * Returns by value, unit of length: light-year. 1845 * Also see {@link #createLightYear()}. 1846 * @draft ICU 64 1847 */ 1848 static MeasureUnit getLightYear(); 1849 #endif /* U_HIDE_DRAFT_API */ 1850 1851 /** 1852 * Returns by pointer, unit of length: meter. 1853 * Caller owns returned value and must free it. 1854 * Also see {@link #getMeter()}. 1855 * @param status ICU error code. 1856 * @stable ICU 53 1857 */ 1858 static MeasureUnit *createMeter(UErrorCode &status); 1859 1860 #ifndef U_HIDE_DRAFT_API 1861 /** 1862 * Returns by value, unit of length: meter. 1863 * Also see {@link #createMeter()}. 1864 * @draft ICU 64 1865 */ 1866 static MeasureUnit getMeter(); 1867 #endif /* U_HIDE_DRAFT_API */ 1868 1869 /** 1870 * Returns by pointer, unit of length: micrometer. 1871 * Caller owns returned value and must free it. 1872 * Also see {@link #getMicrometer()}. 1873 * @param status ICU error code. 1874 * @stable ICU 54 1875 */ 1876 static MeasureUnit *createMicrometer(UErrorCode &status); 1877 1878 #ifndef U_HIDE_DRAFT_API 1879 /** 1880 * Returns by value, unit of length: micrometer. 1881 * Also see {@link #createMicrometer()}. 1882 * @draft ICU 64 1883 */ 1884 static MeasureUnit getMicrometer(); 1885 #endif /* U_HIDE_DRAFT_API */ 1886 1887 /** 1888 * Returns by pointer, unit of length: mile. 1889 * Caller owns returned value and must free it. 1890 * Also see {@link #getMile()}. 1891 * @param status ICU error code. 1892 * @stable ICU 53 1893 */ 1894 static MeasureUnit *createMile(UErrorCode &status); 1895 1896 #ifndef U_HIDE_DRAFT_API 1897 /** 1898 * Returns by value, unit of length: mile. 1899 * Also see {@link #createMile()}. 1900 * @draft ICU 64 1901 */ 1902 static MeasureUnit getMile(); 1903 #endif /* U_HIDE_DRAFT_API */ 1904 1905 /** 1906 * Returns by pointer, unit of length: mile-scandinavian. 1907 * Caller owns returned value and must free it. 1908 * Also see {@link #getMileScandinavian()}. 1909 * @param status ICU error code. 1910 * @stable ICU 56 1911 */ 1912 static MeasureUnit *createMileScandinavian(UErrorCode &status); 1913 1914 #ifndef U_HIDE_DRAFT_API 1915 /** 1916 * Returns by value, unit of length: mile-scandinavian. 1917 * Also see {@link #createMileScandinavian()}. 1918 * @draft ICU 64 1919 */ 1920 static MeasureUnit getMileScandinavian(); 1921 #endif /* U_HIDE_DRAFT_API */ 1922 1923 /** 1924 * Returns by pointer, unit of length: millimeter. 1925 * Caller owns returned value and must free it. 1926 * Also see {@link #getMillimeter()}. 1927 * @param status ICU error code. 1928 * @stable ICU 53 1929 */ 1930 static MeasureUnit *createMillimeter(UErrorCode &status); 1931 1932 #ifndef U_HIDE_DRAFT_API 1933 /** 1934 * Returns by value, unit of length: millimeter. 1935 * Also see {@link #createMillimeter()}. 1936 * @draft ICU 64 1937 */ 1938 static MeasureUnit getMillimeter(); 1939 #endif /* U_HIDE_DRAFT_API */ 1940 1941 /** 1942 * Returns by pointer, unit of length: nanometer. 1943 * Caller owns returned value and must free it. 1944 * Also see {@link #getNanometer()}. 1945 * @param status ICU error code. 1946 * @stable ICU 54 1947 */ 1948 static MeasureUnit *createNanometer(UErrorCode &status); 1949 1950 #ifndef U_HIDE_DRAFT_API 1951 /** 1952 * Returns by value, unit of length: nanometer. 1953 * Also see {@link #createNanometer()}. 1954 * @draft ICU 64 1955 */ 1956 static MeasureUnit getNanometer(); 1957 #endif /* U_HIDE_DRAFT_API */ 1958 1959 /** 1960 * Returns by pointer, unit of length: nautical-mile. 1961 * Caller owns returned value and must free it. 1962 * Also see {@link #getNauticalMile()}. 1963 * @param status ICU error code. 1964 * @stable ICU 54 1965 */ 1966 static MeasureUnit *createNauticalMile(UErrorCode &status); 1967 1968 #ifndef U_HIDE_DRAFT_API 1969 /** 1970 * Returns by value, unit of length: nautical-mile. 1971 * Also see {@link #createNauticalMile()}. 1972 * @draft ICU 64 1973 */ 1974 static MeasureUnit getNauticalMile(); 1975 #endif /* U_HIDE_DRAFT_API */ 1976 1977 /** 1978 * Returns by pointer, unit of length: parsec. 1979 * Caller owns returned value and must free it. 1980 * Also see {@link #getParsec()}. 1981 * @param status ICU error code. 1982 * @stable ICU 54 1983 */ 1984 static MeasureUnit *createParsec(UErrorCode &status); 1985 1986 #ifndef U_HIDE_DRAFT_API 1987 /** 1988 * Returns by value, unit of length: parsec. 1989 * Also see {@link #createParsec()}. 1990 * @draft ICU 64 1991 */ 1992 static MeasureUnit getParsec(); 1993 #endif /* U_HIDE_DRAFT_API */ 1994 1995 /** 1996 * Returns by pointer, unit of length: picometer. 1997 * Caller owns returned value and must free it. 1998 * Also see {@link #getPicometer()}. 1999 * @param status ICU error code. 2000 * @stable ICU 53 2001 */ 2002 static MeasureUnit *createPicometer(UErrorCode &status); 2003 2004 #ifndef U_HIDE_DRAFT_API 2005 /** 2006 * Returns by value, unit of length: picometer. 2007 * Also see {@link #createPicometer()}. 2008 * @draft ICU 64 2009 */ 2010 static MeasureUnit getPicometer(); 2011 #endif /* U_HIDE_DRAFT_API */ 2012 2013 /** 2014 * Returns by pointer, unit of length: point. 2015 * Caller owns returned value and must free it. 2016 * Also see {@link #getPoint()}. 2017 * @param status ICU error code. 2018 * @stable ICU 59 2019 */ 2020 static MeasureUnit *createPoint(UErrorCode &status); 2021 2022 #ifndef U_HIDE_DRAFT_API 2023 /** 2024 * Returns by value, unit of length: point. 2025 * Also see {@link #createPoint()}. 2026 * @draft ICU 64 2027 */ 2028 static MeasureUnit getPoint(); 2029 #endif /* U_HIDE_DRAFT_API */ 2030 2031 #ifndef U_HIDE_DRAFT_API 2032 /** 2033 * Returns by pointer, unit of length: solar-radius. 2034 * Caller owns returned value and must free it. 2035 * Also see {@link #getSolarRadius()}. 2036 * @param status ICU error code. 2037 * @draft ICU 64 2038 */ 2039 static MeasureUnit *createSolarRadius(UErrorCode &status); 2040 2041 /** 2042 * Returns by value, unit of length: solar-radius. 2043 * Also see {@link #createSolarRadius()}. 2044 * @draft ICU 64 2045 */ 2046 static MeasureUnit getSolarRadius(); 2047 #endif /* U_HIDE_DRAFT_API */ 2048 2049 /** 2050 * Returns by pointer, unit of length: yard. 2051 * Caller owns returned value and must free it. 2052 * Also see {@link #getYard()}. 2053 * @param status ICU error code. 2054 * @stable ICU 53 2055 */ 2056 static MeasureUnit *createYard(UErrorCode &status); 2057 2058 #ifndef U_HIDE_DRAFT_API 2059 /** 2060 * Returns by value, unit of length: yard. 2061 * Also see {@link #createYard()}. 2062 * @draft ICU 64 2063 */ 2064 static MeasureUnit getYard(); 2065 #endif /* U_HIDE_DRAFT_API */ 2066 2067 /** 2068 * Returns by pointer, unit of light: lux. 2069 * Caller owns returned value and must free it. 2070 * Also see {@link #getLux()}. 2071 * @param status ICU error code. 2072 * @stable ICU 54 2073 */ 2074 static MeasureUnit *createLux(UErrorCode &status); 2075 2076 #ifndef U_HIDE_DRAFT_API 2077 /** 2078 * Returns by value, unit of light: lux. 2079 * Also see {@link #createLux()}. 2080 * @draft ICU 64 2081 */ 2082 static MeasureUnit getLux(); 2083 #endif /* U_HIDE_DRAFT_API */ 2084 2085 #ifndef U_HIDE_DRAFT_API 2086 /** 2087 * Returns by pointer, unit of light: solar-luminosity. 2088 * Caller owns returned value and must free it. 2089 * Also see {@link #getSolarLuminosity()}. 2090 * @param status ICU error code. 2091 * @draft ICU 64 2092 */ 2093 static MeasureUnit *createSolarLuminosity(UErrorCode &status); 2094 2095 /** 2096 * Returns by value, unit of light: solar-luminosity. 2097 * Also see {@link #createSolarLuminosity()}. 2098 * @draft ICU 64 2099 */ 2100 static MeasureUnit getSolarLuminosity(); 2101 #endif /* U_HIDE_DRAFT_API */ 2102 2103 /** 2104 * Returns by pointer, unit of mass: carat. 2105 * Caller owns returned value and must free it. 2106 * Also see {@link #getCarat()}. 2107 * @param status ICU error code. 2108 * @stable ICU 54 2109 */ 2110 static MeasureUnit *createCarat(UErrorCode &status); 2111 2112 #ifndef U_HIDE_DRAFT_API 2113 /** 2114 * Returns by value, unit of mass: carat. 2115 * Also see {@link #createCarat()}. 2116 * @draft ICU 64 2117 */ 2118 static MeasureUnit getCarat(); 2119 #endif /* U_HIDE_DRAFT_API */ 2120 2121 #ifndef U_HIDE_DRAFT_API 2122 /** 2123 * Returns by pointer, unit of mass: dalton. 2124 * Caller owns returned value and must free it. 2125 * Also see {@link #getDalton()}. 2126 * @param status ICU error code. 2127 * @draft ICU 64 2128 */ 2129 static MeasureUnit *createDalton(UErrorCode &status); 2130 2131 /** 2132 * Returns by value, unit of mass: dalton. 2133 * Also see {@link #createDalton()}. 2134 * @draft ICU 64 2135 */ 2136 static MeasureUnit getDalton(); 2137 #endif /* U_HIDE_DRAFT_API */ 2138 2139 #ifndef U_HIDE_DRAFT_API 2140 /** 2141 * Returns by pointer, unit of mass: earth-mass. 2142 * Caller owns returned value and must free it. 2143 * Also see {@link #getEarthMass()}. 2144 * @param status ICU error code. 2145 * @draft ICU 64 2146 */ 2147 static MeasureUnit *createEarthMass(UErrorCode &status); 2148 2149 /** 2150 * Returns by value, unit of mass: earth-mass. 2151 * Also see {@link #createEarthMass()}. 2152 * @draft ICU 64 2153 */ 2154 static MeasureUnit getEarthMass(); 2155 #endif /* U_HIDE_DRAFT_API */ 2156 2157 /** 2158 * Returns by pointer, unit of mass: gram. 2159 * Caller owns returned value and must free it. 2160 * Also see {@link #getGram()}. 2161 * @param status ICU error code. 2162 * @stable ICU 53 2163 */ 2164 static MeasureUnit *createGram(UErrorCode &status); 2165 2166 #ifndef U_HIDE_DRAFT_API 2167 /** 2168 * Returns by value, unit of mass: gram. 2169 * Also see {@link #createGram()}. 2170 * @draft ICU 64 2171 */ 2172 static MeasureUnit getGram(); 2173 #endif /* U_HIDE_DRAFT_API */ 2174 2175 /** 2176 * Returns by pointer, unit of mass: kilogram. 2177 * Caller owns returned value and must free it. 2178 * Also see {@link #getKilogram()}. 2179 * @param status ICU error code. 2180 * @stable ICU 53 2181 */ 2182 static MeasureUnit *createKilogram(UErrorCode &status); 2183 2184 #ifndef U_HIDE_DRAFT_API 2185 /** 2186 * Returns by value, unit of mass: kilogram. 2187 * Also see {@link #createKilogram()}. 2188 * @draft ICU 64 2189 */ 2190 static MeasureUnit getKilogram(); 2191 #endif /* U_HIDE_DRAFT_API */ 2192 2193 /** 2194 * Returns by pointer, unit of mass: metric-ton. 2195 * Caller owns returned value and must free it. 2196 * Also see {@link #getMetricTon()}. 2197 * @param status ICU error code. 2198 * @stable ICU 54 2199 */ 2200 static MeasureUnit *createMetricTon(UErrorCode &status); 2201 2202 #ifndef U_HIDE_DRAFT_API 2203 /** 2204 * Returns by value, unit of mass: metric-ton. 2205 * Also see {@link #createMetricTon()}. 2206 * @draft ICU 64 2207 */ 2208 static MeasureUnit getMetricTon(); 2209 #endif /* U_HIDE_DRAFT_API */ 2210 2211 /** 2212 * Returns by pointer, unit of mass: microgram. 2213 * Caller owns returned value and must free it. 2214 * Also see {@link #getMicrogram()}. 2215 * @param status ICU error code. 2216 * @stable ICU 54 2217 */ 2218 static MeasureUnit *createMicrogram(UErrorCode &status); 2219 2220 #ifndef U_HIDE_DRAFT_API 2221 /** 2222 * Returns by value, unit of mass: microgram. 2223 * Also see {@link #createMicrogram()}. 2224 * @draft ICU 64 2225 */ 2226 static MeasureUnit getMicrogram(); 2227 #endif /* U_HIDE_DRAFT_API */ 2228 2229 /** 2230 * Returns by pointer, unit of mass: milligram. 2231 * Caller owns returned value and must free it. 2232 * Also see {@link #getMilligram()}. 2233 * @param status ICU error code. 2234 * @stable ICU 54 2235 */ 2236 static MeasureUnit *createMilligram(UErrorCode &status); 2237 2238 #ifndef U_HIDE_DRAFT_API 2239 /** 2240 * Returns by value, unit of mass: milligram. 2241 * Also see {@link #createMilligram()}. 2242 * @draft ICU 64 2243 */ 2244 static MeasureUnit getMilligram(); 2245 #endif /* U_HIDE_DRAFT_API */ 2246 2247 /** 2248 * Returns by pointer, unit of mass: ounce. 2249 * Caller owns returned value and must free it. 2250 * Also see {@link #getOunce()}. 2251 * @param status ICU error code. 2252 * @stable ICU 53 2253 */ 2254 static MeasureUnit *createOunce(UErrorCode &status); 2255 2256 #ifndef U_HIDE_DRAFT_API 2257 /** 2258 * Returns by value, unit of mass: ounce. 2259 * Also see {@link #createOunce()}. 2260 * @draft ICU 64 2261 */ 2262 static MeasureUnit getOunce(); 2263 #endif /* U_HIDE_DRAFT_API */ 2264 2265 /** 2266 * Returns by pointer, unit of mass: ounce-troy. 2267 * Caller owns returned value and must free it. 2268 * Also see {@link #getOunceTroy()}. 2269 * @param status ICU error code. 2270 * @stable ICU 54 2271 */ 2272 static MeasureUnit *createOunceTroy(UErrorCode &status); 2273 2274 #ifndef U_HIDE_DRAFT_API 2275 /** 2276 * Returns by value, unit of mass: ounce-troy. 2277 * Also see {@link #createOunceTroy()}. 2278 * @draft ICU 64 2279 */ 2280 static MeasureUnit getOunceTroy(); 2281 #endif /* U_HIDE_DRAFT_API */ 2282 2283 /** 2284 * Returns by pointer, unit of mass: pound. 2285 * Caller owns returned value and must free it. 2286 * Also see {@link #getPound()}. 2287 * @param status ICU error code. 2288 * @stable ICU 53 2289 */ 2290 static MeasureUnit *createPound(UErrorCode &status); 2291 2292 #ifndef U_HIDE_DRAFT_API 2293 /** 2294 * Returns by value, unit of mass: pound. 2295 * Also see {@link #createPound()}. 2296 * @draft ICU 64 2297 */ 2298 static MeasureUnit getPound(); 2299 #endif /* U_HIDE_DRAFT_API */ 2300 2301 #ifndef U_HIDE_DRAFT_API 2302 /** 2303 * Returns by pointer, unit of mass: solar-mass. 2304 * Caller owns returned value and must free it. 2305 * Also see {@link #getSolarMass()}. 2306 * @param status ICU error code. 2307 * @draft ICU 64 2308 */ 2309 static MeasureUnit *createSolarMass(UErrorCode &status); 2310 2311 /** 2312 * Returns by value, unit of mass: solar-mass. 2313 * Also see {@link #createSolarMass()}. 2314 * @draft ICU 64 2315 */ 2316 static MeasureUnit getSolarMass(); 2317 #endif /* U_HIDE_DRAFT_API */ 2318 2319 /** 2320 * Returns by pointer, unit of mass: stone. 2321 * Caller owns returned value and must free it. 2322 * Also see {@link #getStone()}. 2323 * @param status ICU error code. 2324 * @stable ICU 54 2325 */ 2326 static MeasureUnit *createStone(UErrorCode &status); 2327 2328 #ifndef U_HIDE_DRAFT_API 2329 /** 2330 * Returns by value, unit of mass: stone. 2331 * Also see {@link #createStone()}. 2332 * @draft ICU 64 2333 */ 2334 static MeasureUnit getStone(); 2335 #endif /* U_HIDE_DRAFT_API */ 2336 2337 /** 2338 * Returns by pointer, unit of mass: ton. 2339 * Caller owns returned value and must free it. 2340 * Also see {@link #getTon()}. 2341 * @param status ICU error code. 2342 * @stable ICU 54 2343 */ 2344 static MeasureUnit *createTon(UErrorCode &status); 2345 2346 #ifndef U_HIDE_DRAFT_API 2347 /** 2348 * Returns by value, unit of mass: ton. 2349 * Also see {@link #createTon()}. 2350 * @draft ICU 64 2351 */ 2352 static MeasureUnit getTon(); 2353 #endif /* U_HIDE_DRAFT_API */ 2354 2355 /** 2356 * Returns by pointer, unit of power: gigawatt. 2357 * Caller owns returned value and must free it. 2358 * Also see {@link #getGigawatt()}. 2359 * @param status ICU error code. 2360 * @stable ICU 54 2361 */ 2362 static MeasureUnit *createGigawatt(UErrorCode &status); 2363 2364 #ifndef U_HIDE_DRAFT_API 2365 /** 2366 * Returns by value, unit of power: gigawatt. 2367 * Also see {@link #createGigawatt()}. 2368 * @draft ICU 64 2369 */ 2370 static MeasureUnit getGigawatt(); 2371 #endif /* U_HIDE_DRAFT_API */ 2372 2373 /** 2374 * Returns by pointer, unit of power: horsepower. 2375 * Caller owns returned value and must free it. 2376 * Also see {@link #getHorsepower()}. 2377 * @param status ICU error code. 2378 * @stable ICU 53 2379 */ 2380 static MeasureUnit *createHorsepower(UErrorCode &status); 2381 2382 #ifndef U_HIDE_DRAFT_API 2383 /** 2384 * Returns by value, unit of power: horsepower. 2385 * Also see {@link #createHorsepower()}. 2386 * @draft ICU 64 2387 */ 2388 static MeasureUnit getHorsepower(); 2389 #endif /* U_HIDE_DRAFT_API */ 2390 2391 /** 2392 * Returns by pointer, unit of power: kilowatt. 2393 * Caller owns returned value and must free it. 2394 * Also see {@link #getKilowatt()}. 2395 * @param status ICU error code. 2396 * @stable ICU 53 2397 */ 2398 static MeasureUnit *createKilowatt(UErrorCode &status); 2399 2400 #ifndef U_HIDE_DRAFT_API 2401 /** 2402 * Returns by value, unit of power: kilowatt. 2403 * Also see {@link #createKilowatt()}. 2404 * @draft ICU 64 2405 */ 2406 static MeasureUnit getKilowatt(); 2407 #endif /* U_HIDE_DRAFT_API */ 2408 2409 /** 2410 * Returns by pointer, unit of power: megawatt. 2411 * Caller owns returned value and must free it. 2412 * Also see {@link #getMegawatt()}. 2413 * @param status ICU error code. 2414 * @stable ICU 54 2415 */ 2416 static MeasureUnit *createMegawatt(UErrorCode &status); 2417 2418 #ifndef U_HIDE_DRAFT_API 2419 /** 2420 * Returns by value, unit of power: megawatt. 2421 * Also see {@link #createMegawatt()}. 2422 * @draft ICU 64 2423 */ 2424 static MeasureUnit getMegawatt(); 2425 #endif /* U_HIDE_DRAFT_API */ 2426 2427 /** 2428 * Returns by pointer, unit of power: milliwatt. 2429 * Caller owns returned value and must free it. 2430 * Also see {@link #getMilliwatt()}. 2431 * @param status ICU error code. 2432 * @stable ICU 54 2433 */ 2434 static MeasureUnit *createMilliwatt(UErrorCode &status); 2435 2436 #ifndef U_HIDE_DRAFT_API 2437 /** 2438 * Returns by value, unit of power: milliwatt. 2439 * Also see {@link #createMilliwatt()}. 2440 * @draft ICU 64 2441 */ 2442 static MeasureUnit getMilliwatt(); 2443 #endif /* U_HIDE_DRAFT_API */ 2444 2445 /** 2446 * Returns by pointer, unit of power: watt. 2447 * Caller owns returned value and must free it. 2448 * Also see {@link #getWatt()}. 2449 * @param status ICU error code. 2450 * @stable ICU 53 2451 */ 2452 static MeasureUnit *createWatt(UErrorCode &status); 2453 2454 #ifndef U_HIDE_DRAFT_API 2455 /** 2456 * Returns by value, unit of power: watt. 2457 * Also see {@link #createWatt()}. 2458 * @draft ICU 64 2459 */ 2460 static MeasureUnit getWatt(); 2461 #endif /* U_HIDE_DRAFT_API */ 2462 2463 /** 2464 * Returns by pointer, unit of pressure: atmosphere. 2465 * Caller owns returned value and must free it. 2466 * Also see {@link #getAtmosphere()}. 2467 * @param status ICU error code. 2468 * @stable ICU 63 2469 */ 2470 static MeasureUnit *createAtmosphere(UErrorCode &status); 2471 2472 #ifndef U_HIDE_DRAFT_API 2473 /** 2474 * Returns by value, unit of pressure: atmosphere. 2475 * Also see {@link #createAtmosphere()}. 2476 * @draft ICU 64 2477 */ 2478 static MeasureUnit getAtmosphere(); 2479 #endif /* U_HIDE_DRAFT_API */ 2480 2481 #ifndef U_HIDE_DRAFT_API 2482 /** 2483 * Returns by pointer, unit of pressure: bar. 2484 * Caller owns returned value and must free it. 2485 * Also see {@link #getBar()}. 2486 * @param status ICU error code. 2487 * @draft ICU 65 2488 */ 2489 static MeasureUnit *createBar(UErrorCode &status); 2490 2491 /** 2492 * Returns by value, unit of pressure: bar. 2493 * Also see {@link #createBar()}. 2494 * @draft ICU 65 2495 */ 2496 static MeasureUnit getBar(); 2497 #endif /* U_HIDE_DRAFT_API */ 2498 2499 /** 2500 * Returns by pointer, unit of pressure: hectopascal. 2501 * Caller owns returned value and must free it. 2502 * Also see {@link #getHectopascal()}. 2503 * @param status ICU error code. 2504 * @stable ICU 53 2505 */ 2506 static MeasureUnit *createHectopascal(UErrorCode &status); 2507 2508 #ifndef U_HIDE_DRAFT_API 2509 /** 2510 * Returns by value, unit of pressure: hectopascal. 2511 * Also see {@link #createHectopascal()}. 2512 * @draft ICU 64 2513 */ 2514 static MeasureUnit getHectopascal(); 2515 #endif /* U_HIDE_DRAFT_API */ 2516 2517 /** 2518 * Returns by pointer, unit of pressure: inch-hg. 2519 * Caller owns returned value and must free it. 2520 * Also see {@link #getInchHg()}. 2521 * @param status ICU error code. 2522 * @stable ICU 53 2523 */ 2524 static MeasureUnit *createInchHg(UErrorCode &status); 2525 2526 #ifndef U_HIDE_DRAFT_API 2527 /** 2528 * Returns by value, unit of pressure: inch-hg. 2529 * Also see {@link #createInchHg()}. 2530 * @draft ICU 64 2531 */ 2532 static MeasureUnit getInchHg(); 2533 #endif /* U_HIDE_DRAFT_API */ 2534 2535 #ifndef U_HIDE_DRAFT_API 2536 /** 2537 * Returns by pointer, unit of pressure: kilopascal. 2538 * Caller owns returned value and must free it. 2539 * Also see {@link #getKilopascal()}. 2540 * @param status ICU error code. 2541 * @draft ICU 64 2542 */ 2543 static MeasureUnit *createKilopascal(UErrorCode &status); 2544 2545 /** 2546 * Returns by value, unit of pressure: kilopascal. 2547 * Also see {@link #createKilopascal()}. 2548 * @draft ICU 64 2549 */ 2550 static MeasureUnit getKilopascal(); 2551 #endif /* U_HIDE_DRAFT_API */ 2552 2553 #ifndef U_HIDE_DRAFT_API 2554 /** 2555 * Returns by pointer, unit of pressure: megapascal. 2556 * Caller owns returned value and must free it. 2557 * Also see {@link #getMegapascal()}. 2558 * @param status ICU error code. 2559 * @draft ICU 64 2560 */ 2561 static MeasureUnit *createMegapascal(UErrorCode &status); 2562 2563 /** 2564 * Returns by value, unit of pressure: megapascal. 2565 * Also see {@link #createMegapascal()}. 2566 * @draft ICU 64 2567 */ 2568 static MeasureUnit getMegapascal(); 2569 #endif /* U_HIDE_DRAFT_API */ 2570 2571 /** 2572 * Returns by pointer, unit of pressure: millibar. 2573 * Caller owns returned value and must free it. 2574 * Also see {@link #getMillibar()}. 2575 * @param status ICU error code. 2576 * @stable ICU 53 2577 */ 2578 static MeasureUnit *createMillibar(UErrorCode &status); 2579 2580 #ifndef U_HIDE_DRAFT_API 2581 /** 2582 * Returns by value, unit of pressure: millibar. 2583 * Also see {@link #createMillibar()}. 2584 * @draft ICU 64 2585 */ 2586 static MeasureUnit getMillibar(); 2587 #endif /* U_HIDE_DRAFT_API */ 2588 2589 /** 2590 * Returns by pointer, unit of pressure: millimeter-of-mercury. 2591 * Caller owns returned value and must free it. 2592 * Also see {@link #getMillimeterOfMercury()}. 2593 * @param status ICU error code. 2594 * @stable ICU 54 2595 */ 2596 static MeasureUnit *createMillimeterOfMercury(UErrorCode &status); 2597 2598 #ifndef U_HIDE_DRAFT_API 2599 /** 2600 * Returns by value, unit of pressure: millimeter-of-mercury. 2601 * Also see {@link #createMillimeterOfMercury()}. 2602 * @draft ICU 64 2603 */ 2604 static MeasureUnit getMillimeterOfMercury(); 2605 #endif /* U_HIDE_DRAFT_API */ 2606 2607 #ifndef U_HIDE_DRAFT_API 2608 /** 2609 * Returns by pointer, unit of pressure: pascal. 2610 * Caller owns returned value and must free it. 2611 * Also see {@link #getPascal()}. 2612 * @param status ICU error code. 2613 * @draft ICU 65 2614 */ 2615 static MeasureUnit *createPascal(UErrorCode &status); 2616 2617 /** 2618 * Returns by value, unit of pressure: pascal. 2619 * Also see {@link #createPascal()}. 2620 * @draft ICU 65 2621 */ 2622 static MeasureUnit getPascal(); 2623 #endif /* U_HIDE_DRAFT_API */ 2624 2625 /** 2626 * Returns by pointer, unit of pressure: pound-per-square-inch. 2627 * Caller owns returned value and must free it. 2628 * Also see {@link #getPoundPerSquareInch()}. 2629 * @param status ICU error code. 2630 * @stable ICU 54 2631 */ 2632 static MeasureUnit *createPoundPerSquareInch(UErrorCode &status); 2633 2634 #ifndef U_HIDE_DRAFT_API 2635 /** 2636 * Returns by value, unit of pressure: pound-per-square-inch. 2637 * Also see {@link #createPoundPerSquareInch()}. 2638 * @draft ICU 64 2639 */ 2640 static MeasureUnit getPoundPerSquareInch(); 2641 #endif /* U_HIDE_DRAFT_API */ 2642 2643 /** 2644 * Returns by pointer, unit of speed: kilometer-per-hour. 2645 * Caller owns returned value and must free it. 2646 * Also see {@link #getKilometerPerHour()}. 2647 * @param status ICU error code. 2648 * @stable ICU 53 2649 */ 2650 static MeasureUnit *createKilometerPerHour(UErrorCode &status); 2651 2652 #ifndef U_HIDE_DRAFT_API 2653 /** 2654 * Returns by value, unit of speed: kilometer-per-hour. 2655 * Also see {@link #createKilometerPerHour()}. 2656 * @draft ICU 64 2657 */ 2658 static MeasureUnit getKilometerPerHour(); 2659 #endif /* U_HIDE_DRAFT_API */ 2660 2661 /** 2662 * Returns by pointer, unit of speed: knot. 2663 * Caller owns returned value and must free it. 2664 * Also see {@link #getKnot()}. 2665 * @param status ICU error code. 2666 * @stable ICU 56 2667 */ 2668 static MeasureUnit *createKnot(UErrorCode &status); 2669 2670 #ifndef U_HIDE_DRAFT_API 2671 /** 2672 * Returns by value, unit of speed: knot. 2673 * Also see {@link #createKnot()}. 2674 * @draft ICU 64 2675 */ 2676 static MeasureUnit getKnot(); 2677 #endif /* U_HIDE_DRAFT_API */ 2678 2679 /** 2680 * Returns by pointer, unit of speed: meter-per-second. 2681 * Caller owns returned value and must free it. 2682 * Also see {@link #getMeterPerSecond()}. 2683 * @param status ICU error code. 2684 * @stable ICU 53 2685 */ 2686 static MeasureUnit *createMeterPerSecond(UErrorCode &status); 2687 2688 #ifndef U_HIDE_DRAFT_API 2689 /** 2690 * Returns by value, unit of speed: meter-per-second. 2691 * Also see {@link #createMeterPerSecond()}. 2692 * @draft ICU 64 2693 */ 2694 static MeasureUnit getMeterPerSecond(); 2695 #endif /* U_HIDE_DRAFT_API */ 2696 2697 /** 2698 * Returns by pointer, unit of speed: mile-per-hour. 2699 * Caller owns returned value and must free it. 2700 * Also see {@link #getMilePerHour()}. 2701 * @param status ICU error code. 2702 * @stable ICU 53 2703 */ 2704 static MeasureUnit *createMilePerHour(UErrorCode &status); 2705 2706 #ifndef U_HIDE_DRAFT_API 2707 /** 2708 * Returns by value, unit of speed: mile-per-hour. 2709 * Also see {@link #createMilePerHour()}. 2710 * @draft ICU 64 2711 */ 2712 static MeasureUnit getMilePerHour(); 2713 #endif /* U_HIDE_DRAFT_API */ 2714 2715 /** 2716 * Returns by pointer, unit of temperature: celsius. 2717 * Caller owns returned value and must free it. 2718 * Also see {@link #getCelsius()}. 2719 * @param status ICU error code. 2720 * @stable ICU 53 2721 */ 2722 static MeasureUnit *createCelsius(UErrorCode &status); 2723 2724 #ifndef U_HIDE_DRAFT_API 2725 /** 2726 * Returns by value, unit of temperature: celsius. 2727 * Also see {@link #createCelsius()}. 2728 * @draft ICU 64 2729 */ 2730 static MeasureUnit getCelsius(); 2731 #endif /* U_HIDE_DRAFT_API */ 2732 2733 /** 2734 * Returns by pointer, unit of temperature: fahrenheit. 2735 * Caller owns returned value and must free it. 2736 * Also see {@link #getFahrenheit()}. 2737 * @param status ICU error code. 2738 * @stable ICU 53 2739 */ 2740 static MeasureUnit *createFahrenheit(UErrorCode &status); 2741 2742 #ifndef U_HIDE_DRAFT_API 2743 /** 2744 * Returns by value, unit of temperature: fahrenheit. 2745 * Also see {@link #createFahrenheit()}. 2746 * @draft ICU 64 2747 */ 2748 static MeasureUnit getFahrenheit(); 2749 #endif /* U_HIDE_DRAFT_API */ 2750 2751 /** 2752 * Returns by pointer, unit of temperature: generic. 2753 * Caller owns returned value and must free it. 2754 * Also see {@link #getGenericTemperature()}. 2755 * @param status ICU error code. 2756 * @stable ICU 56 2757 */ 2758 static MeasureUnit *createGenericTemperature(UErrorCode &status); 2759 2760 #ifndef U_HIDE_DRAFT_API 2761 /** 2762 * Returns by value, unit of temperature: generic. 2763 * Also see {@link #createGenericTemperature()}. 2764 * @draft ICU 64 2765 */ 2766 static MeasureUnit getGenericTemperature(); 2767 #endif /* U_HIDE_DRAFT_API */ 2768 2769 /** 2770 * Returns by pointer, unit of temperature: kelvin. 2771 * Caller owns returned value and must free it. 2772 * Also see {@link #getKelvin()}. 2773 * @param status ICU error code. 2774 * @stable ICU 54 2775 */ 2776 static MeasureUnit *createKelvin(UErrorCode &status); 2777 2778 #ifndef U_HIDE_DRAFT_API 2779 /** 2780 * Returns by value, unit of temperature: kelvin. 2781 * Also see {@link #createKelvin()}. 2782 * @draft ICU 64 2783 */ 2784 static MeasureUnit getKelvin(); 2785 #endif /* U_HIDE_DRAFT_API */ 2786 2787 #ifndef U_HIDE_DRAFT_API 2788 /** 2789 * Returns by pointer, unit of torque: newton-meter. 2790 * Caller owns returned value and must free it. 2791 * Also see {@link #getNewtonMeter()}. 2792 * @param status ICU error code. 2793 * @draft ICU 64 2794 */ 2795 static MeasureUnit *createNewtonMeter(UErrorCode &status); 2796 2797 /** 2798 * Returns by value, unit of torque: newton-meter. 2799 * Also see {@link #createNewtonMeter()}. 2800 * @draft ICU 64 2801 */ 2802 static MeasureUnit getNewtonMeter(); 2803 #endif /* U_HIDE_DRAFT_API */ 2804 2805 #ifndef U_HIDE_DRAFT_API 2806 /** 2807 * Returns by pointer, unit of torque: pound-foot. 2808 * Caller owns returned value and must free it. 2809 * Also see {@link #getPoundFoot()}. 2810 * @param status ICU error code. 2811 * @draft ICU 64 2812 */ 2813 static MeasureUnit *createPoundFoot(UErrorCode &status); 2814 2815 /** 2816 * Returns by value, unit of torque: pound-foot. 2817 * Also see {@link #createPoundFoot()}. 2818 * @draft ICU 64 2819 */ 2820 static MeasureUnit getPoundFoot(); 2821 #endif /* U_HIDE_DRAFT_API */ 2822 2823 /** 2824 * Returns by pointer, unit of volume: acre-foot. 2825 * Caller owns returned value and must free it. 2826 * Also see {@link #getAcreFoot()}. 2827 * @param status ICU error code. 2828 * @stable ICU 54 2829 */ 2830 static MeasureUnit *createAcreFoot(UErrorCode &status); 2831 2832 #ifndef U_HIDE_DRAFT_API 2833 /** 2834 * Returns by value, unit of volume: acre-foot. 2835 * Also see {@link #createAcreFoot()}. 2836 * @draft ICU 64 2837 */ 2838 static MeasureUnit getAcreFoot(); 2839 #endif /* U_HIDE_DRAFT_API */ 2840 2841 #ifndef U_HIDE_DRAFT_API 2842 /** 2843 * Returns by pointer, unit of volume: barrel. 2844 * Caller owns returned value and must free it. 2845 * Also see {@link #getBarrel()}. 2846 * @param status ICU error code. 2847 * @draft ICU 64 2848 */ 2849 static MeasureUnit *createBarrel(UErrorCode &status); 2850 2851 /** 2852 * Returns by value, unit of volume: barrel. 2853 * Also see {@link #createBarrel()}. 2854 * @draft ICU 64 2855 */ 2856 static MeasureUnit getBarrel(); 2857 #endif /* U_HIDE_DRAFT_API */ 2858 2859 /** 2860 * Returns by pointer, unit of volume: bushel. 2861 * Caller owns returned value and must free it. 2862 * Also see {@link #getBushel()}. 2863 * @param status ICU error code. 2864 * @stable ICU 54 2865 */ 2866 static MeasureUnit *createBushel(UErrorCode &status); 2867 2868 #ifndef U_HIDE_DRAFT_API 2869 /** 2870 * Returns by value, unit of volume: bushel. 2871 * Also see {@link #createBushel()}. 2872 * @draft ICU 64 2873 */ 2874 static MeasureUnit getBushel(); 2875 #endif /* U_HIDE_DRAFT_API */ 2876 2877 /** 2878 * Returns by pointer, unit of volume: centiliter. 2879 * Caller owns returned value and must free it. 2880 * Also see {@link #getCentiliter()}. 2881 * @param status ICU error code. 2882 * @stable ICU 54 2883 */ 2884 static MeasureUnit *createCentiliter(UErrorCode &status); 2885 2886 #ifndef U_HIDE_DRAFT_API 2887 /** 2888 * Returns by value, unit of volume: centiliter. 2889 * Also see {@link #createCentiliter()}. 2890 * @draft ICU 64 2891 */ 2892 static MeasureUnit getCentiliter(); 2893 #endif /* U_HIDE_DRAFT_API */ 2894 2895 /** 2896 * Returns by pointer, unit of volume: cubic-centimeter. 2897 * Caller owns returned value and must free it. 2898 * Also see {@link #getCubicCentimeter()}. 2899 * @param status ICU error code. 2900 * @stable ICU 54 2901 */ 2902 static MeasureUnit *createCubicCentimeter(UErrorCode &status); 2903 2904 #ifndef U_HIDE_DRAFT_API 2905 /** 2906 * Returns by value, unit of volume: cubic-centimeter. 2907 * Also see {@link #createCubicCentimeter()}. 2908 * @draft ICU 64 2909 */ 2910 static MeasureUnit getCubicCentimeter(); 2911 #endif /* U_HIDE_DRAFT_API */ 2912 2913 /** 2914 * Returns by pointer, unit of volume: cubic-foot. 2915 * Caller owns returned value and must free it. 2916 * Also see {@link #getCubicFoot()}. 2917 * @param status ICU error code. 2918 * @stable ICU 54 2919 */ 2920 static MeasureUnit *createCubicFoot(UErrorCode &status); 2921 2922 #ifndef U_HIDE_DRAFT_API 2923 /** 2924 * Returns by value, unit of volume: cubic-foot. 2925 * Also see {@link #createCubicFoot()}. 2926 * @draft ICU 64 2927 */ 2928 static MeasureUnit getCubicFoot(); 2929 #endif /* U_HIDE_DRAFT_API */ 2930 2931 /** 2932 * Returns by pointer, unit of volume: cubic-inch. 2933 * Caller owns returned value and must free it. 2934 * Also see {@link #getCubicInch()}. 2935 * @param status ICU error code. 2936 * @stable ICU 54 2937 */ 2938 static MeasureUnit *createCubicInch(UErrorCode &status); 2939 2940 #ifndef U_HIDE_DRAFT_API 2941 /** 2942 * Returns by value, unit of volume: cubic-inch. 2943 * Also see {@link #createCubicInch()}. 2944 * @draft ICU 64 2945 */ 2946 static MeasureUnit getCubicInch(); 2947 #endif /* U_HIDE_DRAFT_API */ 2948 2949 /** 2950 * Returns by pointer, unit of volume: cubic-kilometer. 2951 * Caller owns returned value and must free it. 2952 * Also see {@link #getCubicKilometer()}. 2953 * @param status ICU error code. 2954 * @stable ICU 53 2955 */ 2956 static MeasureUnit *createCubicKilometer(UErrorCode &status); 2957 2958 #ifndef U_HIDE_DRAFT_API 2959 /** 2960 * Returns by value, unit of volume: cubic-kilometer. 2961 * Also see {@link #createCubicKilometer()}. 2962 * @draft ICU 64 2963 */ 2964 static MeasureUnit getCubicKilometer(); 2965 #endif /* U_HIDE_DRAFT_API */ 2966 2967 /** 2968 * Returns by pointer, unit of volume: cubic-meter. 2969 * Caller owns returned value and must free it. 2970 * Also see {@link #getCubicMeter()}. 2971 * @param status ICU error code. 2972 * @stable ICU 54 2973 */ 2974 static MeasureUnit *createCubicMeter(UErrorCode &status); 2975 2976 #ifndef U_HIDE_DRAFT_API 2977 /** 2978 * Returns by value, unit of volume: cubic-meter. 2979 * Also see {@link #createCubicMeter()}. 2980 * @draft ICU 64 2981 */ 2982 static MeasureUnit getCubicMeter(); 2983 #endif /* U_HIDE_DRAFT_API */ 2984 2985 /** 2986 * Returns by pointer, unit of volume: cubic-mile. 2987 * Caller owns returned value and must free it. 2988 * Also see {@link #getCubicMile()}. 2989 * @param status ICU error code. 2990 * @stable ICU 53 2991 */ 2992 static MeasureUnit *createCubicMile(UErrorCode &status); 2993 2994 #ifndef U_HIDE_DRAFT_API 2995 /** 2996 * Returns by value, unit of volume: cubic-mile. 2997 * Also see {@link #createCubicMile()}. 2998 * @draft ICU 64 2999 */ 3000 static MeasureUnit getCubicMile(); 3001 #endif /* U_HIDE_DRAFT_API */ 3002 3003 /** 3004 * Returns by pointer, unit of volume: cubic-yard. 3005 * Caller owns returned value and must free it. 3006 * Also see {@link #getCubicYard()}. 3007 * @param status ICU error code. 3008 * @stable ICU 54 3009 */ 3010 static MeasureUnit *createCubicYard(UErrorCode &status); 3011 3012 #ifndef U_HIDE_DRAFT_API 3013 /** 3014 * Returns by value, unit of volume: cubic-yard. 3015 * Also see {@link #createCubicYard()}. 3016 * @draft ICU 64 3017 */ 3018 static MeasureUnit getCubicYard(); 3019 #endif /* U_HIDE_DRAFT_API */ 3020 3021 /** 3022 * Returns by pointer, unit of volume: cup. 3023 * Caller owns returned value and must free it. 3024 * Also see {@link #getCup()}. 3025 * @param status ICU error code. 3026 * @stable ICU 54 3027 */ 3028 static MeasureUnit *createCup(UErrorCode &status); 3029 3030 #ifndef U_HIDE_DRAFT_API 3031 /** 3032 * Returns by value, unit of volume: cup. 3033 * Also see {@link #createCup()}. 3034 * @draft ICU 64 3035 */ 3036 static MeasureUnit getCup(); 3037 #endif /* U_HIDE_DRAFT_API */ 3038 3039 /** 3040 * Returns by pointer, unit of volume: cup-metric. 3041 * Caller owns returned value and must free it. 3042 * Also see {@link #getCupMetric()}. 3043 * @param status ICU error code. 3044 * @stable ICU 56 3045 */ 3046 static MeasureUnit *createCupMetric(UErrorCode &status); 3047 3048 #ifndef U_HIDE_DRAFT_API 3049 /** 3050 * Returns by value, unit of volume: cup-metric. 3051 * Also see {@link #createCupMetric()}. 3052 * @draft ICU 64 3053 */ 3054 static MeasureUnit getCupMetric(); 3055 #endif /* U_HIDE_DRAFT_API */ 3056 3057 /** 3058 * Returns by pointer, unit of volume: deciliter. 3059 * Caller owns returned value and must free it. 3060 * Also see {@link #getDeciliter()}. 3061 * @param status ICU error code. 3062 * @stable ICU 54 3063 */ 3064 static MeasureUnit *createDeciliter(UErrorCode &status); 3065 3066 #ifndef U_HIDE_DRAFT_API 3067 /** 3068 * Returns by value, unit of volume: deciliter. 3069 * Also see {@link #createDeciliter()}. 3070 * @draft ICU 64 3071 */ 3072 static MeasureUnit getDeciliter(); 3073 #endif /* U_HIDE_DRAFT_API */ 3074 3075 /** 3076 * Returns by pointer, unit of volume: fluid-ounce. 3077 * Caller owns returned value and must free it. 3078 * Also see {@link #getFluidOunce()}. 3079 * @param status ICU error code. 3080 * @stable ICU 54 3081 */ 3082 static MeasureUnit *createFluidOunce(UErrorCode &status); 3083 3084 #ifndef U_HIDE_DRAFT_API 3085 /** 3086 * Returns by value, unit of volume: fluid-ounce. 3087 * Also see {@link #createFluidOunce()}. 3088 * @draft ICU 64 3089 */ 3090 static MeasureUnit getFluidOunce(); 3091 #endif /* U_HIDE_DRAFT_API */ 3092 3093 #ifndef U_HIDE_DRAFT_API 3094 /** 3095 * Returns by pointer, unit of volume: fluid-ounce-imperial. 3096 * Caller owns returned value and must free it. 3097 * Also see {@link #getFluidOunceImperial()}. 3098 * @param status ICU error code. 3099 * @draft ICU 64 3100 */ 3101 static MeasureUnit *createFluidOunceImperial(UErrorCode &status); 3102 3103 /** 3104 * Returns by value, unit of volume: fluid-ounce-imperial. 3105 * Also see {@link #createFluidOunceImperial()}. 3106 * @draft ICU 64 3107 */ 3108 static MeasureUnit getFluidOunceImperial(); 3109 #endif /* U_HIDE_DRAFT_API */ 3110 3111 /** 3112 * Returns by pointer, unit of volume: gallon. 3113 * Caller owns returned value and must free it. 3114 * Also see {@link #getGallon()}. 3115 * @param status ICU error code. 3116 * @stable ICU 54 3117 */ 3118 static MeasureUnit *createGallon(UErrorCode &status); 3119 3120 #ifndef U_HIDE_DRAFT_API 3121 /** 3122 * Returns by value, unit of volume: gallon. 3123 * Also see {@link #createGallon()}. 3124 * @draft ICU 64 3125 */ 3126 static MeasureUnit getGallon(); 3127 #endif /* U_HIDE_DRAFT_API */ 3128 3129 /** 3130 * Returns by pointer, unit of volume: gallon-imperial. 3131 * Caller owns returned value and must free it. 3132 * Also see {@link #getGallonImperial()}. 3133 * @param status ICU error code. 3134 * @stable ICU 57 3135 */ 3136 static MeasureUnit *createGallonImperial(UErrorCode &status); 3137 3138 #ifndef U_HIDE_DRAFT_API 3139 /** 3140 * Returns by value, unit of volume: gallon-imperial. 3141 * Also see {@link #createGallonImperial()}. 3142 * @draft ICU 64 3143 */ 3144 static MeasureUnit getGallonImperial(); 3145 #endif /* U_HIDE_DRAFT_API */ 3146 3147 /** 3148 * Returns by pointer, unit of volume: hectoliter. 3149 * Caller owns returned value and must free it. 3150 * Also see {@link #getHectoliter()}. 3151 * @param status ICU error code. 3152 * @stable ICU 54 3153 */ 3154 static MeasureUnit *createHectoliter(UErrorCode &status); 3155 3156 #ifndef U_HIDE_DRAFT_API 3157 /** 3158 * Returns by value, unit of volume: hectoliter. 3159 * Also see {@link #createHectoliter()}. 3160 * @draft ICU 64 3161 */ 3162 static MeasureUnit getHectoliter(); 3163 #endif /* U_HIDE_DRAFT_API */ 3164 3165 /** 3166 * Returns by pointer, unit of volume: liter. 3167 * Caller owns returned value and must free it. 3168 * Also see {@link #getLiter()}. 3169 * @param status ICU error code. 3170 * @stable ICU 53 3171 */ 3172 static MeasureUnit *createLiter(UErrorCode &status); 3173 3174 #ifndef U_HIDE_DRAFT_API 3175 /** 3176 * Returns by value, unit of volume: liter. 3177 * Also see {@link #createLiter()}. 3178 * @draft ICU 64 3179 */ 3180 static MeasureUnit getLiter(); 3181 #endif /* U_HIDE_DRAFT_API */ 3182 3183 /** 3184 * Returns by pointer, unit of volume: megaliter. 3185 * Caller owns returned value and must free it. 3186 * Also see {@link #getMegaliter()}. 3187 * @param status ICU error code. 3188 * @stable ICU 54 3189 */ 3190 static MeasureUnit *createMegaliter(UErrorCode &status); 3191 3192 #ifndef U_HIDE_DRAFT_API 3193 /** 3194 * Returns by value, unit of volume: megaliter. 3195 * Also see {@link #createMegaliter()}. 3196 * @draft ICU 64 3197 */ 3198 static MeasureUnit getMegaliter(); 3199 #endif /* U_HIDE_DRAFT_API */ 3200 3201 /** 3202 * Returns by pointer, unit of volume: milliliter. 3203 * Caller owns returned value and must free it. 3204 * Also see {@link #getMilliliter()}. 3205 * @param status ICU error code. 3206 * @stable ICU 54 3207 */ 3208 static MeasureUnit *createMilliliter(UErrorCode &status); 3209 3210 #ifndef U_HIDE_DRAFT_API 3211 /** 3212 * Returns by value, unit of volume: milliliter. 3213 * Also see {@link #createMilliliter()}. 3214 * @draft ICU 64 3215 */ 3216 static MeasureUnit getMilliliter(); 3217 #endif /* U_HIDE_DRAFT_API */ 3218 3219 /** 3220 * Returns by pointer, unit of volume: pint. 3221 * Caller owns returned value and must free it. 3222 * Also see {@link #getPint()}. 3223 * @param status ICU error code. 3224 * @stable ICU 54 3225 */ 3226 static MeasureUnit *createPint(UErrorCode &status); 3227 3228 #ifndef U_HIDE_DRAFT_API 3229 /** 3230 * Returns by value, unit of volume: pint. 3231 * Also see {@link #createPint()}. 3232 * @draft ICU 64 3233 */ 3234 static MeasureUnit getPint(); 3235 #endif /* U_HIDE_DRAFT_API */ 3236 3237 /** 3238 * Returns by pointer, unit of volume: pint-metric. 3239 * Caller owns returned value and must free it. 3240 * Also see {@link #getPintMetric()}. 3241 * @param status ICU error code. 3242 * @stable ICU 56 3243 */ 3244 static MeasureUnit *createPintMetric(UErrorCode &status); 3245 3246 #ifndef U_HIDE_DRAFT_API 3247 /** 3248 * Returns by value, unit of volume: pint-metric. 3249 * Also see {@link #createPintMetric()}. 3250 * @draft ICU 64 3251 */ 3252 static MeasureUnit getPintMetric(); 3253 #endif /* U_HIDE_DRAFT_API */ 3254 3255 /** 3256 * Returns by pointer, unit of volume: quart. 3257 * Caller owns returned value and must free it. 3258 * Also see {@link #getQuart()}. 3259 * @param status ICU error code. 3260 * @stable ICU 54 3261 */ 3262 static MeasureUnit *createQuart(UErrorCode &status); 3263 3264 #ifndef U_HIDE_DRAFT_API 3265 /** 3266 * Returns by value, unit of volume: quart. 3267 * Also see {@link #createQuart()}. 3268 * @draft ICU 64 3269 */ 3270 static MeasureUnit getQuart(); 3271 #endif /* U_HIDE_DRAFT_API */ 3272 3273 /** 3274 * Returns by pointer, unit of volume: tablespoon. 3275 * Caller owns returned value and must free it. 3276 * Also see {@link #getTablespoon()}. 3277 * @param status ICU error code. 3278 * @stable ICU 54 3279 */ 3280 static MeasureUnit *createTablespoon(UErrorCode &status); 3281 3282 #ifndef U_HIDE_DRAFT_API 3283 /** 3284 * Returns by value, unit of volume: tablespoon. 3285 * Also see {@link #createTablespoon()}. 3286 * @draft ICU 64 3287 */ 3288 static MeasureUnit getTablespoon(); 3289 #endif /* U_HIDE_DRAFT_API */ 3290 3291 /** 3292 * Returns by pointer, unit of volume: teaspoon. 3293 * Caller owns returned value and must free it. 3294 * Also see {@link #getTeaspoon()}. 3295 * @param status ICU error code. 3296 * @stable ICU 54 3297 */ 3298 static MeasureUnit *createTeaspoon(UErrorCode &status); 3299 3300 #ifndef U_HIDE_DRAFT_API 3301 /** 3302 * Returns by value, unit of volume: teaspoon. 3303 * Also see {@link #createTeaspoon()}. 3304 * @draft ICU 64 3305 */ 3306 static MeasureUnit getTeaspoon(); 3307 #endif /* U_HIDE_DRAFT_API */ 3308 3309 3310 // End generated createXXX methods 3311 3312 protected: 3313 3314 #ifndef U_HIDE_INTERNAL_API 3315 /** 3316 * For ICU use only. 3317 * @internal 3318 */ 3319 void initTime(const char *timeId); 3320 3321 /** 3322 * For ICU use only. 3323 * @internal 3324 */ 3325 void initCurrency(const char *isoCurrency); 3326 3327 /** 3328 * For ICU use only. 3329 * @internal 3330 */ 3331 void initNoUnit(const char *subtype); 3332 3333 #endif /* U_HIDE_INTERNAL_API */ 3334 3335 private: 3336 int32_t fTypeId; 3337 int32_t fSubTypeId; 3338 char fCurrency[4]; 3339 MeasureUnit(int32_t typeId,int32_t subTypeId)3340 MeasureUnit(int32_t typeId, int32_t subTypeId) : fTypeId(typeId), fSubTypeId(subTypeId) { 3341 fCurrency[0] = 0; 3342 } 3343 void setTo(int32_t typeId, int32_t subTypeId); 3344 int32_t getOffset() const; 3345 static MeasureUnit *create(int typeId, int subTypeId, UErrorCode &status); 3346 }; 3347 3348 U_NAMESPACE_END 3349 3350 #endif // !UNCONFIG_NO_FORMATTING 3351 3352 #endif /* U_SHOW_CPLUSPLUS_API */ 3353 3354 #endif // __MEASUREUNIT_H__ 3355