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