intl/icu/source/i18n/unicode/utmscale.h@6474c204b198
intl/icu/source/i18n/unicode/utmscale.h
Wed, 31 Dec 2014 06:09:35 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:09:35 +0100
- changeset 0
- 6474c204b198
- permissions
- -rw-r--r--
Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.
1 /*
2 *******************************************************************************
3 * Copyright (C) 2004 - 2008, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 *******************************************************************************
6 */
8 #ifndef UTMSCALE_H
9 #define UTMSCALE_H
11 #include "unicode/utypes.h"
13 #if !UCONFIG_NO_FORMATTING
15 /**
16 * \file
17 * \brief C API: Universal Time Scale
18 *
19 * There are quite a few different conventions for binary datetime, depending on different
20 * platforms and protocols. Some of these have severe drawbacks. For example, people using
21 * Unix time (seconds since Jan 1, 1970) think that they are safe until near the year 2038.
22 * But cases can and do arise where arithmetic manipulations causes serious problems. Consider
23 * the computation of the average of two datetimes, for example: if one calculates them with
24 * <code>averageTime = (time1 + time2)/2</code>, there will be overflow even with dates
25 * around the present. Moreover, even if these problems don't occur, there is the issue of
26 * conversion back and forth between different systems.
27 *
28 * <p>
29 * Binary datetimes differ in a number of ways: the datatype, the unit,
30 * and the epoch (origin). We'll refer to these as time scales. For example:
31 *
32 * <table border="1" cellspacing="0" cellpadding="4">
33 * <caption>Table 1: Binary Time Scales</caption>
34 * <tr>
35 * <th align="left">Source</th>
36 * <th align="left">Datatype</th>
37 * <th align="left">Unit</th>
38 * <th align="left">Epoch</th>
39 * </tr>
40 *
41 * <tr>
42 * <td>UDTS_JAVA_TIME</td>
43 * <td>int64_t</td>
44 * <td>milliseconds</td>
45 * <td>Jan 1, 1970</td>
46 * </tr>
47 * <tr>
48 *
49 * <td>UDTS_UNIX_TIME</td>
50 * <td>int32_t or int64_t</td>
51 * <td>seconds</td>
52 * <td>Jan 1, 1970</td>
53 * </tr>
54 * <tr>
55 * <td>UDTS_ICU4C_TIME</td>
56 *
57 * <td>double</td>
58 * <td>milliseconds</td>
59 * <td>Jan 1, 1970</td>
60 * </tr>
61 * <tr>
62 * <td>UDTS_WINDOWS_FILE_TIME</td>
63 * <td>int64_t</td>
64 *
65 * <td>ticks (100 nanoseconds)</td>
66 * <td>Jan 1, 1601</td>
67 * </tr>
68 * <tr>
69 * <td>UDTS_DOTNET_DATE_TIME</td>
70 * <td>int64_t</td>
71 * <td>ticks (100 nanoseconds)</td>
72 *
73 * <td>Jan 1, 0001</td>
74 * </tr>
75 * <tr>
76 * <td>UDTS_MAC_OLD_TIME</td>
77 * <td>int32_t or int64_t</td>
78 * <td>seconds</td>
79 * <td>Jan 1, 1904</td>
80 *
81 * </tr>
82 * <tr>
83 * <td>UDTS_MAC_TIME</td>
84 * <td>double</td>
85 * <td>seconds</td>
86 * <td>Jan 1, 2001</td>
87 * </tr>
88 *
89 * <tr>
90 * <td>UDTS_EXCEL_TIME</td>
91 * <td>?</td>
92 * <td>days</td>
93 * <td>Dec 31, 1899</td>
94 * </tr>
95 * <tr>
96 *
97 * <td>UDTS_DB2_TIME</td>
98 * <td>?</td>
99 * <td>days</td>
100 * <td>Dec 31, 1899</td>
101 * </tr>
102 *
103 * <tr>
104 * <td>UDTS_UNIX_MICROSECONDS_TIME</td>
105 * <td>int64_t</td>
106 * <td>microseconds</td>
107 * <td>Jan 1, 1970</td>
108 * </tr>
109 * </table>
110 *
111 * <p>
112 * All of the epochs start at 00:00 am (the earliest possible time on the day in question),
113 * and are assumed to be UTC.
114 *
115 * <p>
116 * The ranges for different datatypes are given in the following table (all values in years).
117 * The range of years includes the entire range expressible with positive and negative
118 * values of the datatype. The range of years for double is the range that would be allowed
119 * without losing precision to the corresponding unit.
120 *
121 * <table border="1" cellspacing="0" cellpadding="4">
122 * <tr>
123 * <th align="left">Units</th>
124 * <th align="left">int64_t</th>
125 * <th align="left">double</th>
126 * <th align="left">int32_t</th>
127 * </tr>
128 *
129 * <tr>
130 * <td>1 sec</td>
131 * <td align="right">5.84542x10<sup>11</sup></td>
132 * <td align="right">285,420,920.94</td>
133 * <td align="right">136.10</td>
134 * </tr>
135 * <tr>
136 *
137 * <td>1 millisecond</td>
138 * <td align="right">584,542,046.09</td>
139 * <td align="right">285,420.92</td>
140 * <td align="right">0.14</td>
141 * </tr>
142 * <tr>
143 * <td>1 microsecond</td>
144 *
145 * <td align="right">584,542.05</td>
146 * <td align="right">285.42</td>
147 * <td align="right">0.00</td>
148 * </tr>
149 * <tr>
150 * <td>100 nanoseconds (tick)</td>
151 * <td align="right">58,454.20</td>
152 * <td align="right">28.54</td>
153 * <td align="right">0.00</td>
154 * </tr>
155 * <tr>
156 * <td>1 nanosecond</td>
157 * <td align="right">584.5420461</td>
158 * <td align="right">0.2854</td>
159 * <td align="right">0.00</td>
160 * </tr>
161 * </table>
162 *
163 * <p>
164 * These functions implement a universal time scale which can be used as a 'pivot',
165 * and provide conversion functions to and from all other major time scales.
166 * This datetimes to be converted to the pivot time, safely manipulated,
167 * and converted back to any other datetime time scale.
168 *
169 *<p>
170 * So what to use for this pivot? Java time has plenty of range, but cannot represent
171 * .NET <code>System.DateTime</code> values without severe loss of precision. ICU4C time addresses this by using a
172 * <code>double</code> that is otherwise equivalent to the Java time. However, there are disadvantages
173 * with <code>doubles</code>. They provide for much more graceful degradation in arithmetic operations.
174 * But they only have 53 bits of accuracy, which means that they will lose precision when
175 * converting back and forth to ticks. What would really be nice would be a
176 * <code>long double</code> (80 bits -- 64 bit mantissa), but that is not supported on most systems.
177 *
178 *<p>
179 * The Unix extended time uses a structure with two components: time in seconds and a
180 * fractional field (microseconds). However, this is clumsy, slow, and
181 * prone to error (you always have to keep track of overflow and underflow in the
182 * fractional field). <code>BigDecimal</code> would allow for arbitrary precision and arbitrary range,
183 * but we do not want to use this as the normal type, because it is slow and does not
184 * have a fixed size.
185 *
186 *<p>
187 * Because of these issues, we ended up concluding that the .NET framework's
188 * <code>System.DateTime</code> would be the best pivot. However, we use the full range
189 * allowed by the datatype, allowing for datetimes back to 29,000 BC and up to 29,000 AD.
190 * This time scale is very fine grained, does not lose precision, and covers a range that
191 * will meet almost all requirements. It will not handle the range that Java times do,
192 * but frankly, being able to handle dates before 29,000 BC or after 29,000 AD is of very limited interest.
193 *
194 */
196 /**
197 * <code>UDateTimeScale</code> values are used to specify the time scale used for
198 * conversion into or out if the universal time scale.
199 *
200 * @stable ICU 3.2
201 */
202 typedef enum UDateTimeScale {
203 /**
204 * Used in the JDK. Data is a Java <code>long</code> (<code>int64_t</code>). Value
205 * is milliseconds since January 1, 1970.
206 *
207 * @stable ICU 3.2
208 */
209 UDTS_JAVA_TIME = 0,
211 /**
212 * Used on Unix systems. Data is <code>int32_t</code> or <code>int64_t</code>. Value
213 * is seconds since January 1, 1970.
214 *
215 * @stable ICU 3.2
216 */
217 UDTS_UNIX_TIME,
219 /**
220 * Used in IUC4C. Data is a <code>double</code>. Value
221 * is milliseconds since January 1, 1970.
222 *
223 * @stable ICU 3.2
224 */
225 UDTS_ICU4C_TIME,
227 /**
228 * Used in Windows for file times. Data is an <code>int64_t</code>. Value
229 * is ticks (1 tick == 100 nanoseconds) since January 1, 1601.
230 *
231 * @stable ICU 3.2
232 */
233 UDTS_WINDOWS_FILE_TIME,
235 /**
236 * Used in the .NET framework's <code>System.DateTime</code> structure. Data is an <code>int64_t</code>. Value
237 * is ticks (1 tick == 100 nanoseconds) since January 1, 0001.
238 *
239 * @stable ICU 3.2
240 */
241 UDTS_DOTNET_DATE_TIME,
243 /**
244 * Used in older Macintosh systems. Data is <code>int32_t</code> or <code>int64_t</code>. Value
245 * is seconds since January 1, 1904.
246 *
247 * @stable ICU 3.2
248 */
249 UDTS_MAC_OLD_TIME,
251 /**
252 * Used in newer Macintosh systems. Data is a <code>double</code>. Value
253 * is seconds since January 1, 2001.
254 *
255 * @stable ICU 3.2
256 */
257 UDTS_MAC_TIME,
259 /**
260 * Used in Excel. Data is an <code>?unknown?</code>. Value
261 * is days since December 31, 1899.
262 *
263 * @stable ICU 3.2
264 */
265 UDTS_EXCEL_TIME,
267 /**
268 * Used in DB2. Data is an <code>?unknown?</code>. Value
269 * is days since December 31, 1899.
270 *
271 * @stable ICU 3.2
272 */
273 UDTS_DB2_TIME,
275 /**
276 * Data is a <code>long</code>. Value is microseconds since January 1, 1970.
277 * Similar to Unix time (linear value from 1970) and struct timeval
278 * (microseconds resolution).
279 *
280 * @stable ICU 3.8
281 */
282 UDTS_UNIX_MICROSECONDS_TIME,
284 /**
285 * The first unused time scale value. The limit of this enum
286 */
287 UDTS_MAX_SCALE
288 } UDateTimeScale;
290 /**
291 * <code>UTimeScaleValue</code> values are used to specify the time scale values
292 * to <code>utmscale_getTimeScaleValue</code>.
293 *
294 * @see utmscale_getTimeScaleValue
295 *
296 * @stable ICU 3.2
297 */
298 typedef enum UTimeScaleValue {
299 /**
300 * The constant used to select the units vale
301 * for a time scale.
302 *
303 * @see utmscale_getTimeScaleValue
304 *
305 * @stable ICU 3.2
306 */
307 UTSV_UNITS_VALUE = 0,
309 /**
310 * The constant used to select the epoch offset value
311 * for a time scale.
312 *
313 * @see utmscale_getTimeScaleValue
314 *
315 * @stable ICU 3.2
316 */
317 UTSV_EPOCH_OFFSET_VALUE=1,
319 /**
320 * The constant used to select the minimum from value
321 * for a time scale.
322 *
323 * @see utmscale_getTimeScaleValue
324 *
325 * @stable ICU 3.2
326 */
327 UTSV_FROM_MIN_VALUE=2,
329 /**
330 * The constant used to select the maximum from value
331 * for a time scale.
332 *
333 * @see utmscale_getTimeScaleValue
334 *
335 * @stable ICU 3.2
336 */
337 UTSV_FROM_MAX_VALUE=3,
339 /**
340 * The constant used to select the minimum to value
341 * for a time scale.
342 *
343 * @see utmscale_getTimeScaleValue
344 *
345 * @stable ICU 3.2
346 */
347 UTSV_TO_MIN_VALUE=4,
349 /**
350 * The constant used to select the maximum to value
351 * for a time scale.
352 *
353 * @see utmscale_getTimeScaleValue
354 *
355 * @stable ICU 3.2
356 */
357 UTSV_TO_MAX_VALUE=5,
359 #ifndef U_HIDE_INTERNAL_API
360 /**
361 * The constant used to select the epoch plus one value
362 * for a time scale.
363 *
364 * NOTE: This is an internal value. DO NOT USE IT. May not
365 * actually be equal to the epoch offset value plus one.
366 *
367 * @see utmscale_getTimeScaleValue
368 *
369 * @internal ICU 3.2
370 */
371 UTSV_EPOCH_OFFSET_PLUS_1_VALUE=6,
373 /**
374 * The constant used to select the epoch plus one value
375 * for a time scale.
376 *
377 * NOTE: This is an internal value. DO NOT USE IT. May not
378 * actually be equal to the epoch offset value plus one.
379 *
380 * @see utmscale_getTimeScaleValue
381 *
382 * @internal ICU 3.2
383 */
384 UTSV_EPOCH_OFFSET_MINUS_1_VALUE=7,
386 /**
387 * The constant used to select the units round value
388 * for a time scale.
389 *
390 * NOTE: This is an internal value. DO NOT USE IT.
391 *
392 * @see utmscale_getTimeScaleValue
393 *
394 * @internal ICU 3.2
395 */
396 UTSV_UNITS_ROUND_VALUE=8,
398 /**
399 * The constant used to select the minimum safe rounding value
400 * for a time scale.
401 *
402 * NOTE: This is an internal value. DO NOT USE IT.
403 *
404 * @see utmscale_getTimeScaleValue
405 *
406 * @internal ICU 3.2
407 */
408 UTSV_MIN_ROUND_VALUE=9,
410 /**
411 * The constant used to select the maximum safe rounding value
412 * for a time scale.
413 *
414 * NOTE: This is an internal value. DO NOT USE IT.
415 *
416 * @see utmscale_getTimeScaleValue
417 *
418 * @internal ICU 3.2
419 */
420 UTSV_MAX_ROUND_VALUE=10,
422 #endif /* U_HIDE_INTERNAL_API */
424 /**
425 * The number of time scale values, in other words limit of this enum.
426 *
427 * @see utmscale_getTimeScaleValue
428 */
429 UTSV_MAX_SCALE_VALUE=11
431 } UTimeScaleValue;
433 /**
434 * Get a value associated with a particular time scale.
435 *
436 * @param timeScale The time scale
437 * @param value A constant representing the value to get
438 * @param status The status code. Set to <code>U_ILLEGAL_ARGUMENT_ERROR</code> if arguments are invalid.
439 * @return - the value.
440 *
441 * @stable ICU 3.2
442 */
443 U_STABLE int64_t U_EXPORT2
444 utmscale_getTimeScaleValue(UDateTimeScale timeScale, UTimeScaleValue value, UErrorCode *status);
446 /* Conversion to 'universal time scale' */
448 /**
449 * Convert a <code>int64_t</code> datetime from the given time scale to the universal time scale.
450 *
451 * @param otherTime The <code>int64_t</code> datetime
452 * @param timeScale The time scale to convert from
453 * @param status The status code. Set to <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the conversion is out of range.
454 *
455 * @return The datetime converted to the universal time scale
456 *
457 * @stable ICU 3.2
458 */
459 U_STABLE int64_t U_EXPORT2
460 utmscale_fromInt64(int64_t otherTime, UDateTimeScale timeScale, UErrorCode *status);
462 /* Conversion from 'universal time scale' */
464 /**
465 * Convert a datetime from the universal time scale to a <code>int64_t</code> in the given time scale.
466 *
467 * @param universalTime The datetime in the universal time scale
468 * @param timeScale The time scale to convert to
469 * @param status The status code. Set to <code>U_ILLEGAL_ARGUMENT_ERROR</code> if the conversion is out of range.
470 *
471 * @return The datetime converted to the given time scale
472 *
473 * @stable ICU 3.2
474 */
475 U_STABLE int64_t U_EXPORT2
476 utmscale_toInt64(int64_t universalTime, UDateTimeScale timeScale, UErrorCode *status);
478 #endif /* #if !UCONFIG_NO_FORMATTING */
480 #endif
