The Tor Browser / file revision

 /*

 **********************************************************************

 * Copyright (c) 2003-2013, International Business Machines

 * Corporation and others.  All Rights Reserved.

 **********************************************************************

 * Author: Alan Liu

 * Created: July 21 2003

 * Since: ICU 2.8

 **********************************************************************

 */

 #ifndef OLSONTZ_H

 #define OLSONTZ_H

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_FORMATTING

 #include "unicode/basictz.h"

 #include "umutex.h"

 struct UResourceBundle;

 U_NAMESPACE_BEGIN

 class SimpleTimeZone;

 /**

  * A time zone based on the Olson tz database.  Olson time zones change

  * behavior over time.  The raw offset, rules, presence or absence of

  * daylight savings time, and even the daylight savings amount can all

  * vary.

  *

  * This class uses a resource bundle named "zoneinfo".  Zoneinfo is a

  * table containing different kinds of resources.  In several places,

  * zones are referred to using integers.  A zone's integer is a number

  * from 0..n-1, where n is the number of zones, with the zones sorted

  * in lexicographic order.

  *

  * 1. Zones.  These have keys corresponding to the Olson IDs, e.g.,

  * "Asia/Shanghai".  Each resource describes the behavior of the given

  * zone.  Zones come in two different formats.

  *

  *   a. Zone (table).  A zone is a table resource contains several

  *   type of resources below:

  *  

  *   - typeOffsets:intvector (Required)

  *  

  *   Sets of UTC raw/dst offset pairs in seconds.  Entries at

  *   2n represents raw offset and 2n+1 represents dst offset

  *   paired with the raw offset at 2n.  The very first pair represents

  *   the initial zone offset (before the first transition) always.

  *

  *   - trans:intvector (Optional) 

  *  

  *   List of transition times represented by 32bit seconds from the

  *   epoch (1970-01-01T00:00Z) in ascending order.

  *  

  *   - transPre32/transPost32:intvector (Optional)

  *  

  *   List of transition times before/after 32bit minimum seconds.

  *   Each time is represented by a pair of 32bit integer.

  * 

  *   - typeMap:bin (Optional)

  *  

  *   Array of bytes representing the mapping between each transition

  *   time (transPre32/trans/transPost32) and its corresponding offset

  *   data (typeOffsets).

  *  

  *   - finalRule:string (Optional)

  *  

  *   If a recurrent transition rule is applicable to a zone forever

  *   after the final transition time, finalRule represents the rule

  *   in Rules data.

  *  

  *   - finalRaw:int (Optional)

  *   

  *   When finalRule is available, finalRaw is required and specifies

  *   the raw (base) offset of the rule.

  *   

  *   - finalYear:int (Optional)

  *   

  *   When finalRule is available, finalYear is required and specifies

  *   the start year of the rule.

  *   

  *   - links:intvector (Optional)

  *   

  *   When this zone data is shared with other zones, links specifies

  *   all zones including the zone itself.  Each zone is referenced by

  *   integer index.

  * 

  *  b. Link (int, length 1).  A link zone is an int resource.  The

  *  integer is the zone number of the target zone.  The key of this

  *  resource is an alternate name for the target zone.  This data

  *  is corresponding to Link data in the tz database.

  *

  *

  * 2. Rules.  These have keys corresponding to the Olson rule IDs,

  * with an underscore prepended, e.g., "_EU".  Each resource describes

  * the behavior of the given rule using an intvector, containing the

  * onset list, the cessation list, and the DST savings.  The onset and

  * cessation lists consist of the month, dowim, dow, time, and time

  * mode.  The end result is that the 11 integers describing the rule

  * can be passed directly into the SimpleTimeZone 13-argument

  * constructor (the other two arguments will be the raw offset, taken

  * from the complex zone element 5, and the ID string, which is not

  * used), with the times and the DST savings multiplied by 1000 to

  * scale from seconds to milliseconds.

  *

  * 3. Regions.  An array specifies mapping between zones and regions.

  * Each item is either a 2-letter ISO country code or "001"

  * (UN M.49 - World).  This data is generated from "zone.tab"

  * in the tz database.

  */

 class U_I18N_API OlsonTimeZone: public BasicTimeZone {

  public:

     /**

      * Construct from a resource bundle.

      * @param top the top-level zoneinfo resource bundle.  This is used

      * to lookup the rule that `res' may refer to, if there is one.

      * @param res the resource bundle of the zone to be constructed

      * @param tzid the time zone ID

      * @param ec input-output error code

      */

     OlsonTimeZone(const UResourceBundle* top,

                   const UResourceBundle* res,

                   const UnicodeString& tzid,

                   UErrorCode& ec);

     /**

      * Copy constructor

      */

     OlsonTimeZone(const OlsonTimeZone& other);

     /**

      * Destructor

      */

     virtual ~OlsonTimeZone();

     /**

      * Assignment operator

      */

     OlsonTimeZone& operator=(const OlsonTimeZone& other);

     /**

      * Returns true if the two TimeZone objects are equal.

      */

     virtual UBool operator==(const TimeZone& other) const;

     /**

      * TimeZone API.

      */

     virtual TimeZone* clone() const;

     /**

      * TimeZone API.

      */

     static UClassID U_EXPORT2 getStaticClassID();

     /**

      * TimeZone API.

      */

     virtual UClassID getDynamicClassID() const;

     /**

      * TimeZone API.  Do not call this; prefer getOffset(UDate,...).

      */

     virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month,

                               int32_t day, uint8_t dayOfWeek,

                               int32_t millis, UErrorCode& ec) const;

     /**

      * TimeZone API.  Do not call this; prefer getOffset(UDate,...).

      */

     virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month,

                               int32_t day, uint8_t dayOfWeek,

                               int32_t millis, int32_t monthLength,

                               UErrorCode& ec) const;

     /**

      * TimeZone API.

      */

     virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,

                    int32_t& dstOffset, UErrorCode& ec) const;

     /**

      * BasicTimeZone API.

      */

     virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,

         int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) const;

     /**

      * TimeZone API.  This method has no effect since objects of this

      * class are quasi-immutable (the base class allows the ID to be

      * changed).

      */

     virtual void setRawOffset(int32_t offsetMillis);

     /**

      * TimeZone API.  For a historical zone, the raw offset can change

      * over time, so this API is not useful.  In order to approximate

      * expected behavior, this method returns the raw offset for the

      * current moment in time.

      */

     virtual int32_t getRawOffset() const;

     /**

      * TimeZone API.  For a historical zone, whether DST is used or

      * not varies over time.  In order to approximate expected

      * behavior, this method returns TRUE if DST is observed at any

      * point in the current year.

      */

     virtual UBool useDaylightTime() const;

     /**

      * TimeZone API.

      */

     virtual UBool inDaylightTime(UDate date, UErrorCode& ec) const;

     /**

      * TimeZone API.

      */

     virtual int32_t getDSTSavings() const;

     /**

      * TimeZone API.  Also comare historic transitions.

      */

     virtual UBool hasSameRules(const TimeZone& other) const;

     /**

      * BasicTimeZone API.

      * Gets the first time zone transition after the base time.

      * @param base      The base time.

      * @param inclusive Whether the base time is inclusive or not.

      * @param result    Receives the first transition after the base time.

      * @return  TRUE if the transition is found.

      */

     virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;

     /**

      * BasicTimeZone API.

      * Gets the most recent time zone transition before the base time.

      * @param base      The base time.

      * @param inclusive Whether the base time is inclusive or not.

      * @param result    Receives the most recent transition before the base time.

      * @return  TRUE if the transition is found.

      */

     virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;

     /**

      * BasicTimeZone API.

      * Returns the number of <code>TimeZoneRule</code>s which represents time transitions,

      * for this time zone, that is, all <code>TimeZoneRule</code>s for this time zone except

      * <code>InitialTimeZoneRule</code>.  The return value range is 0 or any positive value.

      * @param status    Receives error status code.

      * @return The number of <code>TimeZoneRule</code>s representing time transitions.

      */

     virtual int32_t countTransitionRules(UErrorCode& status) const;

     /**

      * Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>

      * which represent time transitions for this time zone.  On successful return,

      * the argument initial points to non-NULL <code>InitialTimeZoneRule</code> and

      * the array trsrules is filled with 0 or multiple <code>TimeZoneRule</code>

      * instances up to the size specified by trscount.  The results are referencing the

      * rule instance held by this time zone instance.  Therefore, after this time zone

      * is destructed, they are no longer available.

      * @param initial       Receives the initial timezone rule

      * @param trsrules      Receives the timezone transition rules

      * @param trscount      On input, specify the size of the array 'transitions' receiving

      *                      the timezone transition rules.  On output, actual number of

      *                      rules filled in the array will be set.

      * @param status        Receives error status code.

      */

     virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,

         const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;

     /**

      * Internal API returning the canonical ID of this zone.

      * This ID won't be affected by setID().

      */

     const UChar *getCanonicalID() const;

 private:

     /**

      * Default constructor.  Creates a time zone with an empty ID and

      * a fixed GMT offset of zero.

      */

     OlsonTimeZone();

 private:

     void constructEmpty();

     void getHistoricalOffset(UDate date, UBool local,

         int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,

         int32_t& rawoff, int32_t& dstoff) const;

     int16_t transitionCount() const;

     int64_t transitionTimeInSeconds(int16_t transIdx) const;

     double transitionTime(int16_t transIdx) const;

     /*

      * Following 3 methods return an offset at the given transition time index.

      * When the index is negative, return the initial offset.

      */

     int32_t zoneOffsetAt(int16_t transIdx) const;

     int32_t rawOffsetAt(int16_t transIdx) const;

     int32_t dstOffsetAt(int16_t transIdx) const;

     /*

      * Following methods return the initial offset.

      */

     int32_t initialRawOffset() const;

     int32_t initialDstOffset() const;

     /**

      * Number of transitions in each time range

      */

     int16_t transitionCountPre32;

     int16_t transitionCount32;

     int16_t transitionCountPost32;

     /**

      * Time of each transition in seconds from 1970 epoch before 32bit second range (<= 1900).

      * Each transition in this range is represented by a pair of int32_t.

      * Length is transitionCount int32_t's.  NULL if no transitions in this range.

      */

     const int32_t *transitionTimesPre32; // alias into res; do not delete

     /**

      * Time of each transition in seconds from 1970 epoch in 32bit second range.

      * Length is transitionCount int32_t's.  NULL if no transitions in this range.

      */

     const int32_t *transitionTimes32; // alias into res; do not delete

     /**

      * Time of each transition in seconds from 1970 epoch after 32bit second range (>= 2038).

      * Each transition in this range is represented by a pair of int32_t.

      * Length is transitionCount int32_t's.  NULL if no transitions in this range.

      */

     const int32_t *transitionTimesPost32; // alias into res; do not delete

     /**

      * Number of types, 1..255

      */

     int16_t typeCount;

     /**

      * Offset from GMT in seconds for each type.

      * Length is typeCount int32_t's.  At least one type (a pair of int32_t)

      * is required.

      */

     const int32_t *typeOffsets; // alias into res; do not delete

     /**

      * Type description data, consisting of transitionCount uint8_t

      * type indices (from 0..typeCount-1).

      * Length is transitionCount int16_t's.  NULL if no transitions.

      */

     const uint8_t *typeMapData; // alias into res; do not delete

     /**

      * A SimpleTimeZone that governs the behavior for date >= finalMillis.

      */

     SimpleTimeZone *finalZone; // owned, may be NULL

     /**

      * For date >= finalMillis, the finalZone will be used.

      */

     double finalStartMillis;

     /**

      * For year >= finalYear, the finalZone will be used.

      */

     int32_t finalStartYear;

     /*

      * Canonical (CLDR) ID of this zone

      */

     const UChar *canonicalID;

     /* BasicTimeZone support */

     void clearTransitionRules(void);

     void deleteTransitionRules(void);

     void checkTransitionRules(UErrorCode& status) const;

   public:    // Internal, for access from plain C code

     void initTransitionRules(UErrorCode& status);

   private:

     InitialTimeZoneRule *initialRule;

     TimeZoneTransition  *firstTZTransition;

     int16_t             firstTZTransitionIdx;

     TimeZoneTransition  *firstFinalTZTransition;

     TimeArrayTimeZoneRule   **historicRules;

     int16_t             historicRuleCount;

     SimpleTimeZone      *finalZoneWithStartYear; // hack

     UInitOnce           transitionRulesInitOnce;

 };

 inline int16_t

 OlsonTimeZone::transitionCount() const {

     return transitionCountPre32 + transitionCount32 + transitionCountPost32;

 }

 inline double

 OlsonTimeZone::transitionTime(int16_t transIdx) const {

     return (double)transitionTimeInSeconds(transIdx) * U_MILLIS_PER_SECOND;

 }

 inline int32_t

 OlsonTimeZone::zoneOffsetAt(int16_t transIdx) const {

     int16_t typeIdx = (transIdx >= 0 ? typeMapData[transIdx] : 0) << 1;

     return typeOffsets[typeIdx] + typeOffsets[typeIdx + 1];

 }

 inline int32_t

 OlsonTimeZone::rawOffsetAt(int16_t transIdx) const {

     int16_t typeIdx = (transIdx >= 0 ? typeMapData[transIdx] : 0) << 1;

     return typeOffsets[typeIdx];

 }

 inline int32_t

 OlsonTimeZone::dstOffsetAt(int16_t transIdx) const {

     int16_t typeIdx = (transIdx >= 0 ? typeMapData[transIdx] : 0) << 1;

     return typeOffsets[typeIdx + 1];

 }

 inline int32_t

 OlsonTimeZone::initialRawOffset() const {

     return typeOffsets[0];

 }

 inline int32_t

 OlsonTimeZone::initialDstOffset() const {

     return typeOffsets[1];

 }

 inline const UChar*

 OlsonTimeZone::getCanonicalID() const {

     return canonicalID;

 }

 U_NAMESPACE_END

 #endif // !UCONFIG_NO_FORMATTING

 #endif // OLSONTZ_H

 //eof