Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/unicode/utmscale.h @ 69:33d812a61356

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