• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 **********************************************************************
3 * Copyright (c) 2004-2014, International Business Machines
4 * Corporation and others.  All Rights Reserved.
5 **********************************************************************
6 * Author: Alan Liu
7 * Created: April 26, 2004
8 * Since: ICU 3.0
9 **********************************************************************
10 */
11 #ifndef __MEASUREUNIT_H__
12 #define __MEASUREUNIT_H__
13 
14 #include "unicode/utypes.h"
15 
16 #if !UCONFIG_NO_FORMATTING
17 
18 #include "unicode/unistr.h"
19 
20 /**
21  * \file
22  * \brief C++ API: A unit for measuring a quantity.
23  */
24 
25 U_NAMESPACE_BEGIN
26 
27 class StringEnumeration;
28 
29 /**
30  * A unit such as length, mass, volume, currency, etc.  A unit is
31  * coupled with a numeric amount to produce a Measure.
32  *
33  * @author Alan Liu
34  * @stable ICU 3.0
35  */
36 class U_I18N_API MeasureUnit: public UObject {
37  public:
38 
39     /**
40      * Default constructor.
41      * @stable ICU 3.0
42      */
MeasureUnit()43     MeasureUnit() : fTypeId(0), fSubTypeId(0) {
44         fCurrency[0] = 0;
45     }
46 
47     /**
48      * Copy constructor.
49      * @draft ICU 53
50      */
51     MeasureUnit(const MeasureUnit &other);
52 
53     /**
54      * Assignment operator.
55      * @draft ICU 53
56      */
57     MeasureUnit &operator=(const MeasureUnit &other);
58 
59     /**
60      * Returns a polymorphic clone of this object.  The result will
61      * have the same class as returned by getDynamicClassID().
62      * @stable ICU 3.0
63      */
64     virtual UObject* clone() const;
65 
66     /**
67      * Destructor
68      * @stable ICU 3.0
69      */
70     virtual ~MeasureUnit();
71 
72     /**
73      * Equality operator.  Return true if this object is equal
74      * to the given object.
75      * @stable ICU 3.0
76      */
77     virtual UBool operator==(const UObject& other) const;
78 
79 #ifndef U_HIDE_DRAFT_API
80     /**
81      * Inequality operator.  Return true if this object is not equal
82      * to the given object.
83      * @draft ICU 53
84      */
85     UBool operator!=(const UObject& other) const {
86         return !(*this == other);
87     }
88 
89     /**
90      * Get the type.
91      * @draft ICU 53
92      */
93     const char *getType() const;
94 
95     /**
96      * Get the sub type.
97      * @draft ICU 53
98      */
99     const char *getSubtype() const;
100 
101     /**
102      * getAvailable gets all of the available units.
103      * If there are too many units to fit into destCapacity then the
104      * error code is set to U_BUFFER_OVERFLOW_ERROR.
105      *
106      * @param destArray destination buffer.
107      * @param destCapacity number of MeasureUnit instances available at dest.
108      * @param errorCode ICU error code.
109      * @return number of available units.
110      * @draft ICU 53
111      */
112     static int32_t getAvailable(
113             MeasureUnit *destArray,
114             int32_t destCapacity,
115             UErrorCode &errorCode);
116 
117     /**
118      * getAvailable gets all of the available units for a specific type.
119      * If there are too many units to fit into destCapacity then the
120      * error code is set to U_BUFFER_OVERFLOW_ERROR.
121      *
122      * @param type the type
123      * @param destArray destination buffer.
124      * @param destCapacity number of MeasureUnit instances available at dest.
125      * @param errorCode ICU error code.
126      * @return number of available units for type.
127      * @draft ICU 53
128      */
129     static int32_t getAvailable(
130             const char *type,
131             MeasureUnit *destArray,
132             int32_t destCapacity,
133             UErrorCode &errorCode);
134 
135     /**
136      * getAvailableTypes gets all of the available types. Caller owns the
137      * returned StringEnumeration and must delete it when finished using it.
138      *
139      * @param errorCode ICU error code.
140      * @return the types.
141      * @draft ICU 53
142      */
143     static StringEnumeration* getAvailableTypes(UErrorCode &errorCode);
144 #endif /* U_HIDE_DRAFT_API */
145 
146     /**
147      * Return the class ID for this class. This is useful only for comparing to
148      * a return value from getDynamicClassID(). For example:
149      * <pre>
150      * .   Base* polymorphic_pointer = createPolymorphicObject();
151      * .   if (polymorphic_pointer->getDynamicClassID() ==
152      * .       erived::getStaticClassID()) ...
153      * </pre>
154      * @return          The class ID for all objects of this class.
155      * @draft ICU 53
156      */
157     static UClassID U_EXPORT2 getStaticClassID(void);
158 
159     /**
160      * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
161      * method is to implement a simple version of RTTI, since not all C++
162      * compilers support genuine RTTI. Polymorphic operator==() and clone()
163      * methods call this method.
164      *
165      * @return          The class ID for this object. All objects of a
166      *                  given class have the same class ID.  Objects of
167      *                  other classes have different class IDs.
168      * @draft ICU 53
169      */
170     virtual UClassID getDynamicClassID(void) const;
171 
172 #ifndef U_HIDE_INTERNAL_API
173     /**
174      * ICU use only.
175      * Returns associated array index for this measure unit. Only valid for
176      * non-currency measure units.
177      * @internal
178      */
179     int32_t getIndex() const;
180 
181     /**
182      * ICU use only.
183      * Returns maximum value from getIndex plus 1.
184      * @internal
185      */
186     static int32_t getIndexCount();
187 #endif /* U_HIDE_INTERNAL_API */
188 
189 // Start generated createXXX methods
190 
191 #ifndef U_HIDE_DRAFT_API
192     /**
193      * Creates a unit of acceleration: g-force.
194      * Caller owns returned value and must free it.
195      * @param status ICU error code.
196      * @draft ICU 53
197      */
198     static MeasureUnit *createGForce(UErrorCode &status);
199 
200     /**
201      * Creates a unit of angle: arc-minute.
202      * Caller owns returned value and must free it.
203      * @param status ICU error code.
204      * @draft ICU 53
205      */
206     static MeasureUnit *createArcMinute(UErrorCode &status);
207 
208     /**
209      * Creates a unit of angle: arc-second.
210      * Caller owns returned value and must free it.
211      * @param status ICU error code.
212      * @draft ICU 53
213      */
214     static MeasureUnit *createArcSecond(UErrorCode &status);
215 
216     /**
217      * Creates a unit of angle: degree.
218      * Caller owns returned value and must free it.
219      * @param status ICU error code.
220      * @draft ICU 53
221      */
222     static MeasureUnit *createDegree(UErrorCode &status);
223 
224     /**
225      * Creates a unit of area: acre.
226      * Caller owns returned value and must free it.
227      * @param status ICU error code.
228      * @draft ICU 53
229      */
230     static MeasureUnit *createAcre(UErrorCode &status);
231 
232     /**
233      * Creates a unit of area: hectare.
234      * Caller owns returned value and must free it.
235      * @param status ICU error code.
236      * @draft ICU 53
237      */
238     static MeasureUnit *createHectare(UErrorCode &status);
239 
240     /**
241      * Creates a unit of area: square-foot.
242      * Caller owns returned value and must free it.
243      * @param status ICU error code.
244      * @draft ICU 53
245      */
246     static MeasureUnit *createSquareFoot(UErrorCode &status);
247 
248     /**
249      * Creates a unit of area: square-kilometer.
250      * Caller owns returned value and must free it.
251      * @param status ICU error code.
252      * @draft ICU 53
253      */
254     static MeasureUnit *createSquareKilometer(UErrorCode &status);
255 
256     /**
257      * Creates a unit of area: square-meter.
258      * Caller owns returned value and must free it.
259      * @param status ICU error code.
260      * @draft ICU 53
261      */
262     static MeasureUnit *createSquareMeter(UErrorCode &status);
263 
264     /**
265      * Creates a unit of area: square-mile.
266      * Caller owns returned value and must free it.
267      * @param status ICU error code.
268      * @draft ICU 53
269      */
270     static MeasureUnit *createSquareMile(UErrorCode &status);
271 
272     /**
273      * Creates a unit of duration: day.
274      * Caller owns returned value and must free it.
275      * @param status ICU error code.
276      * @draft ICU 53
277      */
278     static MeasureUnit *createDay(UErrorCode &status);
279 
280     /**
281      * Creates a unit of duration: hour.
282      * Caller owns returned value and must free it.
283      * @param status ICU error code.
284      * @draft ICU 53
285      */
286     static MeasureUnit *createHour(UErrorCode &status);
287 
288     /**
289      * Creates a unit of duration: millisecond.
290      * Caller owns returned value and must free it.
291      * @param status ICU error code.
292      * @draft ICU 53
293      */
294     static MeasureUnit *createMillisecond(UErrorCode &status);
295 
296     /**
297      * Creates a unit of duration: minute.
298      * Caller owns returned value and must free it.
299      * @param status ICU error code.
300      * @draft ICU 53
301      */
302     static MeasureUnit *createMinute(UErrorCode &status);
303 
304     /**
305      * Creates a unit of duration: month.
306      * Caller owns returned value and must free it.
307      * @param status ICU error code.
308      * @draft ICU 53
309      */
310     static MeasureUnit *createMonth(UErrorCode &status);
311 
312     /**
313      * Creates a unit of duration: second.
314      * Caller owns returned value and must free it.
315      * @param status ICU error code.
316      * @draft ICU 53
317      */
318     static MeasureUnit *createSecond(UErrorCode &status);
319 
320     /**
321      * Creates a unit of duration: week.
322      * Caller owns returned value and must free it.
323      * @param status ICU error code.
324      * @draft ICU 53
325      */
326     static MeasureUnit *createWeek(UErrorCode &status);
327 
328     /**
329      * Creates a unit of duration: year.
330      * Caller owns returned value and must free it.
331      * @param status ICU error code.
332      * @draft ICU 53
333      */
334     static MeasureUnit *createYear(UErrorCode &status);
335 
336     /**
337      * Creates a unit of length: centimeter.
338      * Caller owns returned value and must free it.
339      * @param status ICU error code.
340      * @draft ICU 53
341      */
342     static MeasureUnit *createCentimeter(UErrorCode &status);
343 
344     /**
345      * Creates a unit of length: foot.
346      * Caller owns returned value and must free it.
347      * @param status ICU error code.
348      * @draft ICU 53
349      */
350     static MeasureUnit *createFoot(UErrorCode &status);
351 
352     /**
353      * Creates a unit of length: inch.
354      * Caller owns returned value and must free it.
355      * @param status ICU error code.
356      * @draft ICU 53
357      */
358     static MeasureUnit *createInch(UErrorCode &status);
359 
360     /**
361      * Creates a unit of length: kilometer.
362      * Caller owns returned value and must free it.
363      * @param status ICU error code.
364      * @draft ICU 53
365      */
366     static MeasureUnit *createKilometer(UErrorCode &status);
367 
368     /**
369      * Creates a unit of length: light-year.
370      * Caller owns returned value and must free it.
371      * @param status ICU error code.
372      * @draft ICU 53
373      */
374     static MeasureUnit *createLightYear(UErrorCode &status);
375 
376     /**
377      * Creates a unit of length: meter.
378      * Caller owns returned value and must free it.
379      * @param status ICU error code.
380      * @draft ICU 53
381      */
382     static MeasureUnit *createMeter(UErrorCode &status);
383 
384     /**
385      * Creates a unit of length: mile.
386      * Caller owns returned value and must free it.
387      * @param status ICU error code.
388      * @draft ICU 53
389      */
390     static MeasureUnit *createMile(UErrorCode &status);
391 
392     /**
393      * Creates a unit of length: millimeter.
394      * Caller owns returned value and must free it.
395      * @param status ICU error code.
396      * @draft ICU 53
397      */
398     static MeasureUnit *createMillimeter(UErrorCode &status);
399 
400     /**
401      * Creates a unit of length: picometer.
402      * Caller owns returned value and must free it.
403      * @param status ICU error code.
404      * @draft ICU 53
405      */
406     static MeasureUnit *createPicometer(UErrorCode &status);
407 
408     /**
409      * Creates a unit of length: yard.
410      * Caller owns returned value and must free it.
411      * @param status ICU error code.
412      * @draft ICU 53
413      */
414     static MeasureUnit *createYard(UErrorCode &status);
415 
416     /**
417      * Creates a unit of mass: gram.
418      * Caller owns returned value and must free it.
419      * @param status ICU error code.
420      * @draft ICU 53
421      */
422     static MeasureUnit *createGram(UErrorCode &status);
423 
424     /**
425      * Creates a unit of mass: kilogram.
426      * Caller owns returned value and must free it.
427      * @param status ICU error code.
428      * @draft ICU 53
429      */
430     static MeasureUnit *createKilogram(UErrorCode &status);
431 
432     /**
433      * Creates a unit of mass: ounce.
434      * Caller owns returned value and must free it.
435      * @param status ICU error code.
436      * @draft ICU 53
437      */
438     static MeasureUnit *createOunce(UErrorCode &status);
439 
440     /**
441      * Creates a unit of mass: pound.
442      * Caller owns returned value and must free it.
443      * @param status ICU error code.
444      * @draft ICU 53
445      */
446     static MeasureUnit *createPound(UErrorCode &status);
447 
448     /**
449      * Creates a unit of power: horsepower.
450      * Caller owns returned value and must free it.
451      * @param status ICU error code.
452      * @draft ICU 53
453      */
454     static MeasureUnit *createHorsepower(UErrorCode &status);
455 
456     /**
457      * Creates a unit of power: kilowatt.
458      * Caller owns returned value and must free it.
459      * @param status ICU error code.
460      * @draft ICU 53
461      */
462     static MeasureUnit *createKilowatt(UErrorCode &status);
463 
464     /**
465      * Creates a unit of power: watt.
466      * Caller owns returned value and must free it.
467      * @param status ICU error code.
468      * @draft ICU 53
469      */
470     static MeasureUnit *createWatt(UErrorCode &status);
471 
472     /**
473      * Creates a unit of pressure: hectopascal.
474      * Caller owns returned value and must free it.
475      * @param status ICU error code.
476      * @draft ICU 53
477      */
478     static MeasureUnit *createHectopascal(UErrorCode &status);
479 
480     /**
481      * Creates a unit of pressure: inch-hg.
482      * Caller owns returned value and must free it.
483      * @param status ICU error code.
484      * @draft ICU 53
485      */
486     static MeasureUnit *createInchHg(UErrorCode &status);
487 
488     /**
489      * Creates a unit of pressure: millibar.
490      * Caller owns returned value and must free it.
491      * @param status ICU error code.
492      * @draft ICU 53
493      */
494     static MeasureUnit *createMillibar(UErrorCode &status);
495 
496     /**
497      * Creates a unit of speed: kilometer-per-hour.
498      * Caller owns returned value and must free it.
499      * @param status ICU error code.
500      * @draft ICU 53
501      */
502     static MeasureUnit *createKilometerPerHour(UErrorCode &status);
503 
504     /**
505      * Creates a unit of speed: meter-per-second.
506      * Caller owns returned value and must free it.
507      * @param status ICU error code.
508      * @draft ICU 53
509      */
510     static MeasureUnit *createMeterPerSecond(UErrorCode &status);
511 
512     /**
513      * Creates a unit of speed: mile-per-hour.
514      * Caller owns returned value and must free it.
515      * @param status ICU error code.
516      * @draft ICU 53
517      */
518     static MeasureUnit *createMilePerHour(UErrorCode &status);
519 
520     /**
521      * Creates a unit of temperature: celsius.
522      * Caller owns returned value and must free it.
523      * @param status ICU error code.
524      * @draft ICU 53
525      */
526     static MeasureUnit *createCelsius(UErrorCode &status);
527 
528     /**
529      * Creates a unit of temperature: fahrenheit.
530      * Caller owns returned value and must free it.
531      * @param status ICU error code.
532      * @draft ICU 53
533      */
534     static MeasureUnit *createFahrenheit(UErrorCode &status);
535 
536     /**
537      * Creates a unit of volume: cubic-kilometer.
538      * Caller owns returned value and must free it.
539      * @param status ICU error code.
540      * @draft ICU 53
541      */
542     static MeasureUnit *createCubicKilometer(UErrorCode &status);
543 
544     /**
545      * Creates a unit of volume: cubic-mile.
546      * Caller owns returned value and must free it.
547      * @param status ICU error code.
548      * @draft ICU 53
549      */
550     static MeasureUnit *createCubicMile(UErrorCode &status);
551 
552     /**
553      * Creates a unit of volume: liter.
554      * Caller owns returned value and must free it.
555      * @param status ICU error code.
556      * @draft ICU 53
557      */
558     static MeasureUnit *createLiter(UErrorCode &status);
559 #endif /* U_HIDE_DRAFT_API */
560 
561  protected:
562 
563 #ifndef U_HIDE_INTERNAL_API
564     /**
565      * For ICU use only.
566      * @internal
567      */
568     void initTime(const char *timeId);
569 
570     /**
571      * For ICU use only.
572      * @internal
573      */
574     void initCurrency(const char *isoCurrency);
575 
576 #endif
577 
578 private:
579     int32_t fTypeId;
580     int32_t fSubTypeId;
581     char fCurrency[4];
582 
MeasureUnit(int32_t typeId,int32_t subTypeId)583     MeasureUnit(int32_t typeId, int32_t subTypeId) : fTypeId(typeId), fSubTypeId(subTypeId) {
584         fCurrency[0] = 0;
585     }
586     void setTo(int32_t typeId, int32_t subTypeId);
587     int32_t getOffset() const;
588     static MeasureUnit *create(int typeId, int subTypeId, UErrorCode &status);
589 };
590 
591 U_NAMESPACE_END
592 
593 #endif // !UNCONFIG_NO_FORMATTING
594 #endif // __MEASUREUNIT_H__
595