<h2>Editing File: /opt/alt/libicu65/usr/include/unicode/utmscale.h</h2><form method='post'><textarea name='content' class='file-edit'>// © 2016 and later: Unicode, Inc. and others.
// License &amp; terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2004 - 2008, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/

#ifndef UTMSCALE_H
#define UTMSCALE_H

#include &quot;unicode/utypes.h&quot;

#if !UCONFIG_NO_FORMATTING

/** 
 * \file
 * \brief C API: Universal Time Scale
 *
 * There are quite a few different conventions for binary datetime, depending on different
 * platforms and protocols. Some of these have severe drawbacks. For example, people using
 * Unix time (seconds since Jan 1, 1970) think that they are safe until near the year 2038.
 * But cases can and do arise where arithmetic manipulations causes serious problems. Consider
 * the computation of the average of two datetimes, for example: if one calculates them with
 * &lt;code&gt;averageTime = (time1 + time2)/2&lt;/code&gt;, there will be overflow even with dates
 * around the present. Moreover, even if these problems don't occur, there is the issue of
 * conversion back and forth between different systems.
 *
 * &lt;p&gt;
 * Binary datetimes differ in a number of ways: the datatype, the unit,
 * and the epoch (origin). We'll refer to these as time scales. For example:
 *
 * &lt;table border=&quot;1&quot; cellspacing=&quot;0&quot; cellpadding=&quot;4&quot;&gt;
 *  &lt;caption&gt;Table 1: Binary Time Scales&lt;/caption&gt;
 *  &lt;tr&gt;
 *    &lt;th align=&quot;left&quot;&gt;Source&lt;/th&gt;
 *    &lt;th align=&quot;left&quot;&gt;Datatype&lt;/th&gt;
 *    &lt;th align=&quot;left&quot;&gt;Unit&lt;/th&gt;
 *    &lt;th align=&quot;left&quot;&gt;Epoch&lt;/th&gt;
 *  &lt;/tr&gt;
 *
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_JAVA_TIME&lt;/td&gt;
 *    &lt;td&gt;int64_t&lt;/td&gt;
 *    &lt;td&gt;milliseconds&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 1970&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *
 *    &lt;td&gt;UDTS_UNIX_TIME&lt;/td&gt;
 *    &lt;td&gt;int32_t or int64_t&lt;/td&gt;
 *    &lt;td&gt;seconds&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 1970&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_ICU4C_TIME&lt;/td&gt;
 *
 *    &lt;td&gt;double&lt;/td&gt;
 *    &lt;td&gt;milliseconds&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 1970&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_WINDOWS_FILE_TIME&lt;/td&gt;
 *    &lt;td&gt;int64_t&lt;/td&gt;
 *
 *    &lt;td&gt;ticks (100 nanoseconds)&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 1601&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_DOTNET_DATE_TIME&lt;/td&gt;
 *    &lt;td&gt;int64_t&lt;/td&gt;
 *    &lt;td&gt;ticks (100 nanoseconds)&lt;/td&gt;
 *
 *    &lt;td&gt;Jan 1, 0001&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_MAC_OLD_TIME&lt;/td&gt;
 *    &lt;td&gt;int32_t or int64_t&lt;/td&gt;
 *    &lt;td&gt;seconds&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 1904&lt;/td&gt;
 *
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_MAC_TIME&lt;/td&gt;
 *    &lt;td&gt;double&lt;/td&gt;
 *    &lt;td&gt;seconds&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 2001&lt;/td&gt;
 *  &lt;/tr&gt;
 *
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_EXCEL_TIME&lt;/td&gt;
 *    &lt;td&gt;?&lt;/td&gt;
 *    &lt;td&gt;days&lt;/td&gt;
 *    &lt;td&gt;Dec 31, 1899&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *
 *    &lt;td&gt;UDTS_DB2_TIME&lt;/td&gt;
 *    &lt;td&gt;?&lt;/td&gt;
 *    &lt;td&gt;days&lt;/td&gt;
 *    &lt;td&gt;Dec 31, 1899&lt;/td&gt;
 *  &lt;/tr&gt;
 *
 *  &lt;tr&gt;
 *    &lt;td&gt;UDTS_UNIX_MICROSECONDS_TIME&lt;/td&gt;
 *    &lt;td&gt;int64_t&lt;/td&gt;
 *    &lt;td&gt;microseconds&lt;/td&gt;
 *    &lt;td&gt;Jan 1, 1970&lt;/td&gt;
 *  &lt;/tr&gt;
 * &lt;/table&gt;
 *
 * &lt;p&gt;
 * All of the epochs start at 00:00 am (the earliest possible time on the day in question),
 * and are assumed to be UTC.
 *
 * &lt;p&gt;
 * The ranges for different datatypes are given in the following table (all values in years).
 * The range of years includes the entire range expressible with positive and negative
 * values of the datatype. The range of years for double is the range that would be allowed
 * without losing precision to the corresponding unit.
 *
 * &lt;table border=&quot;1&quot; cellspacing=&quot;0&quot; cellpadding=&quot;4&quot;&gt;
 *  &lt;tr&gt;
 *    &lt;th align=&quot;left&quot;&gt;Units&lt;/th&gt;
 *    &lt;th align=&quot;left&quot;&gt;int64_t&lt;/th&gt;
 *    &lt;th align=&quot;left&quot;&gt;double&lt;/th&gt;
 *    &lt;th align=&quot;left&quot;&gt;int32_t&lt;/th&gt;
 *  &lt;/tr&gt;
 *
 *  &lt;tr&gt;
 *    &lt;td&gt;1 sec&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;5.84542x10&lt;sup&gt;11&lt;/sup&gt;&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;285,420,920.94&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;136.10&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *
 *    &lt;td&gt;1 millisecond&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;584,542,046.09&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;285,420.92&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;0.14&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;1 microsecond&lt;/td&gt;
 *
 *    &lt;td align=&quot;right&quot;&gt;584,542.05&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;285.42&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;0.00&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;100 nanoseconds (tick)&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;58,454.20&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;28.54&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;0.00&lt;/td&gt;
 *  &lt;/tr&gt;
 *  &lt;tr&gt;
 *    &lt;td&gt;1 nanosecond&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;584.5420461&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;0.2854&lt;/td&gt;
 *    &lt;td align=&quot;right&quot;&gt;0.00&lt;/td&gt;
 *  &lt;/tr&gt;
 * &lt;/table&gt;
 *
 * &lt;p&gt;
 * These functions implement a universal time scale which can be used as a 'pivot',
 * and provide conversion functions to and from all other major time scales.
 * This datetimes to be converted to the pivot time, safely manipulated,
 * and converted back to any other datetime time scale.
 *
 *&lt;p&gt;
 * So what to use for this pivot? Java time has plenty of range, but cannot represent
 * .NET &lt;code&gt;System.DateTime&lt;/code&gt; values without severe loss of precision. ICU4C time addresses this by using a
 * &lt;code&gt;double&lt;/code&gt; that is otherwise equivalent to the Java time. However, there are disadvantages
 * with &lt;code&gt;doubles&lt;/code&gt;. They provide for much more graceful degradation in arithmetic operations.
 * But they only have 53 bits of accuracy, which means that they will lose precision when
 * converting back and forth to ticks. What would really be nice would be a
 * &lt;code&gt;long double&lt;/code&gt; (80 bits -- 64 bit mantissa), but that is not supported on most systems.
 *
 *&lt;p&gt;
 * The Unix extended time uses a structure with two components: time in seconds and a
 * fractional field (microseconds). However, this is clumsy, slow, and
 * prone to error (you always have to keep track of overflow and underflow in the
 * fractional field). &lt;code&gt;BigDecimal&lt;/code&gt; would allow for arbitrary precision and arbitrary range,
 * but we do not want to use this as the normal type, because it is slow and does not
 * have a fixed size.
 *
 *&lt;p&gt;
 * Because of these issues, we ended up concluding that the .NET framework's
 * &lt;code&gt;System.DateTime&lt;/code&gt; would be the best pivot. However, we use the full range
 * allowed by the datatype, allowing for datetimes back to 29,000 BC and up to 29,000 AD.
 * This time scale is very fine grained, does not lose precision, and covers a range that
 * will meet almost all requirements. It will not handle the range that Java times do,
 * but frankly, being able to handle dates before 29,000 BC or after 29,000 AD is of very limited interest.
 *
 */

/**
 * &lt;code&gt;UDateTimeScale&lt;/code&gt; values are used to specify the time scale used for
 * conversion into or out if the universal time scale.
 *
 * @stable ICU 3.2
 */
typedef enum UDateTimeScale {
    /**
     * Used in the JDK. Data is a Java &lt;code&gt;long&lt;/code&gt; (&lt;code&gt;int64_t&lt;/code&gt;). Value
     * is milliseconds since January 1, 1970.
     *
     * @stable ICU 3.2
     */
    UDTS_JAVA_TIME = 0,

    /**
     * Used on Unix systems. Data is &lt;code&gt;int32_t&lt;/code&gt; or &lt;code&gt;int64_t&lt;/code&gt;. Value
     * is seconds since January 1, 1970.
     *
     * @stable ICU 3.2
     */
    UDTS_UNIX_TIME,
    
    /**
     * Used in IUC4C. Data is a &lt;code&gt;double&lt;/code&gt;. Value
     * is milliseconds since January 1, 1970.
     *
     * @stable ICU 3.2
     */
    UDTS_ICU4C_TIME,
    
    /**
     * Used in Windows for file times. Data is an &lt;code&gt;int64_t&lt;/code&gt;. Value
     * is ticks (1 tick == 100 nanoseconds) since January 1, 1601.
     *
     * @stable ICU 3.2
     */
    UDTS_WINDOWS_FILE_TIME,
    
    /**
     * Used in the .NET framework's &lt;code&gt;System.DateTime&lt;/code&gt; structure. Data is an &lt;code&gt;int64_t&lt;/code&gt;. Value
     * is ticks (1 tick == 100 nanoseconds) since January 1, 0001.
     *
     * @stable ICU 3.2
     */
    UDTS_DOTNET_DATE_TIME,
    
    /**
     * Used in older Macintosh systems. Data is &lt;code&gt;int32_t&lt;/code&gt; or &lt;code&gt;int64_t&lt;/code&gt;. Value
     * is seconds since January 1, 1904.
     *
     * @stable ICU 3.2
     */
    UDTS_MAC_OLD_TIME,
    
    /**
     * Used in newer Macintosh systems. Data is a &lt;code&gt;double&lt;/code&gt;. Value
     * is seconds since January 1, 2001.
     *
     * @stable ICU 3.2
     */
    UDTS_MAC_TIME,
    
    /**
     * Used in Excel. Data is an &lt;code&gt;?unknown?&lt;/code&gt;. Value
     * is days since December 31, 1899.
     *
     * @stable ICU 3.2
     */
    UDTS_EXCEL_TIME,
    
    /**
     * Used in DB2. Data is an &lt;code&gt;?unknown?&lt;/code&gt;. Value
     * is days since December 31, 1899.
     *
     * @stable ICU 3.2
     */
    UDTS_DB2_TIME,

    /**
     * Data is a &lt;code&gt;long&lt;/code&gt;. Value is microseconds since January 1, 1970.
     * Similar to Unix time (linear value from 1970) and struct timeval
     * (microseconds resolution).
     *
     * @stable ICU 3.8
     */
    UDTS_UNIX_MICROSECONDS_TIME,

#ifndef U_HIDE_DEPRECATED_API
    /**
     * The first unused time scale value. The limit of this enum
     * @deprecated ICU 59 The numeric value may change over time, see ICU ticket #12420.
     */
    UDTS_MAX_SCALE
#endif  /* U_HIDE_DEPRECATED_API */

} UDateTimeScale;

/**
 * &lt;code&gt;UTimeScaleValue&lt;/code&gt; values are used to specify the time scale values
 * to &lt;code&gt;utmscale_getTimeScaleValue&lt;/code&gt;.
 *
 * @see utmscale_getTimeScaleValue
 *
 * @stable ICU 3.2
 */
typedef enum UTimeScaleValue {
    /**
     * The constant used to select the units vale
     * for a time scale.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @stable ICU 3.2
     */
    UTSV_UNITS_VALUE = 0,

    /**
     * The constant used to select the epoch offset value
     * for a time scale.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @stable ICU 3.2
     */
    UTSV_EPOCH_OFFSET_VALUE=1,

    /**
     * The constant used to select the minimum from value
     * for a time scale.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @stable ICU 3.2
     */
    UTSV_FROM_MIN_VALUE=2,

    /**
     * The constant used to select the maximum from value
     * for a time scale.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @stable ICU 3.2
     */
    UTSV_FROM_MAX_VALUE=3,

    /**
     * The constant used to select the minimum to value
     * for a time scale.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @stable ICU 3.2
     */
    UTSV_TO_MIN_VALUE=4,

    /**
     * The constant used to select the maximum to value
     * for a time scale.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @stable ICU 3.2
     */
    UTSV_TO_MAX_VALUE=5,

#ifndef U_HIDE_INTERNAL_API
    /**
     * The constant used to select the epoch plus one value
     * for a time scale.
     * 
     * NOTE: This is an internal value. DO NOT USE IT. May not
     * actually be equal to the epoch offset value plus one.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @internal ICU 3.2
     */
    UTSV_EPOCH_OFFSET_PLUS_1_VALUE=6,

    /**
     * The constant used to select the epoch plus one value
     * for a time scale.
     * 
     * NOTE: This is an internal value. DO NOT USE IT. May not
     * actually be equal to the epoch offset value plus one.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @internal ICU 3.2
     */
    UTSV_EPOCH_OFFSET_MINUS_1_VALUE=7,

    /**
     * The constant used to select the units round value
     * for a time scale.
     * 
     * NOTE: This is an internal value. DO NOT USE IT.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @internal ICU 3.2
     */
    UTSV_UNITS_ROUND_VALUE=8,

    /**
     * The constant used to select the minimum safe rounding value
     * for a time scale.
     * 
     * NOTE: This is an internal value. DO NOT USE IT.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @internal ICU 3.2
     */
    UTSV_MIN_ROUND_VALUE=9,

    /**
     * The constant used to select the maximum safe rounding value
     * for a time scale.
     * 
     * NOTE: This is an internal value. DO NOT USE IT.
     * 
     * @see utmscale_getTimeScaleValue
     *
     * @internal ICU 3.2
     */
    UTSV_MAX_ROUND_VALUE=10,

#endif /* U_HIDE_INTERNAL_API */

#ifndef U_HIDE_DEPRECATED_API
    /**
     * The number of time scale values, in other words limit of this enum.
     * 
     * @see utmscale_getTimeScaleValue
     * @deprecated ICU 59 The numeric value may change over time, see ICU ticket #12420.
     */
    UTSV_MAX_SCALE_VALUE=11
#endif  /* U_HIDE_DEPRECATED_API */

} UTimeScaleValue;

/**
 * Get a value associated with a particular time scale.
 * 
 * @param timeScale The time scale
 * @param value A constant representing the value to get
 * @param status The status code. Set to &lt;code&gt;U_ILLEGAL_ARGUMENT_ERROR&lt;/code&gt; if arguments are invalid.
 * @return - the value.
 * 
 * @stable ICU 3.2
 */
U_STABLE int64_t U_EXPORT2
    utmscale_getTimeScaleValue(UDateTimeScale timeScale, UTimeScaleValue value, UErrorCode *status);

/* Conversion to 'universal time scale' */

/**
 * Convert a &lt;code&gt;int64_t&lt;/code&gt; datetime from the given time scale to the universal time scale.
 *
 * @param otherTime The &lt;code&gt;int64_t&lt;/code&gt; datetime
 * @param timeScale The time scale to convert from
 * @param status The status code. Set to &lt;code&gt;U_ILLEGAL_ARGUMENT_ERROR&lt;/code&gt; if the conversion is out of range.
 * 
 * @return The datetime converted to the universal time scale
 *
 * @stable ICU 3.2
 */
U_STABLE int64_t U_EXPORT2
    utmscale_fromInt64(int64_t otherTime, UDateTimeScale timeScale, UErrorCode *status);

/* Conversion from 'universal time scale' */

/**
 * Convert a datetime from the universal time scale to a &lt;code&gt;int64_t&lt;/code&gt; in the given time scale.
 *
 * @param universalTime The datetime in the universal time scale
 * @param timeScale The time scale to convert to
 * @param status The status code. Set to &lt;code&gt;U_ILLEGAL_ARGUMENT_ERROR&lt;/code&gt; if the conversion is out of range.
 * 
 * @return The datetime converted to the given time scale
 *
 * @stable ICU 3.2
 */
U_STABLE int64_t U_EXPORT2
    utmscale_toInt64(int64_t universalTime, UDateTimeScale timeScale, UErrorCode *status);

#endif /* #if !UCONFIG_NO_FORMATTING */

#endif

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Flibicu65%2Fusr%2Finclude%2Funicode'>Back to Directory</a>