/src/mozilla-central/intl/icu/source/i18n/olsontz.h

Source (jump to first uncovered line)
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
* 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

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		// © 2016 and later: Unicode, Inc. and others.
2		// License & terms of use: http://www.unicode.org/copyright.html
3		/*
4		**********************************************************************
5		* Copyright (c) 2003-2013, International Business Machines
6		* Corporation and others. All Rights Reserved.
7		**********************************************************************
8		* Author: Alan Liu
9		* Created: July 21 2003
10		* Since: ICU 2.8
11		**********************************************************************
12		*/
13		#ifndef OLSONTZ_H
14		#define OLSONTZ_H
15
16		#include "unicode/utypes.h"
17
18		#if !UCONFIG_NO_FORMATTING
19
20		#include "unicode/basictz.h"
21		#include "umutex.h"
22
23		struct UResourceBundle;
24
25		U_NAMESPACE_BEGIN
26
27		class SimpleTimeZone;
28
29		/**
30		* A time zone based on the Olson tz database. Olson time zones change
31		* behavior over time. The raw offset, rules, presence or absence of
32		* daylight savings time, and even the daylight savings amount can all
33		* vary.
34		*
35		* This class uses a resource bundle named "zoneinfo". Zoneinfo is a
36		* table containing different kinds of resources. In several places,
37		* zones are referred to using integers. A zone's integer is a number
38		* from 0..n-1, where n is the number of zones, with the zones sorted
39		* in lexicographic order.
40		*
41		* 1. Zones. These have keys corresponding to the Olson IDs, e.g.,
42		* "Asia/Shanghai". Each resource describes the behavior of the given
43		* zone. Zones come in two different formats.
44		*
45		* a. Zone (table). A zone is a table resource contains several
46		* type of resources below:
47		*
48		* - typeOffsets:intvector (Required)
49		*
50		* Sets of UTC raw/dst offset pairs in seconds. Entries at
51		* 2n represents raw offset and 2n+1 represents dst offset
52		* paired with the raw offset at 2n. The very first pair represents
53		* the initial zone offset (before the first transition) always.
54		*
55		* - trans:intvector (Optional)
56		*
57		* List of transition times represented by 32bit seconds from the
58		* epoch (1970-01-01T00:00Z) in ascending order.
59		*
60		* - transPre32/transPost32:intvector (Optional)
61		*
62		* List of transition times before/after 32bit minimum seconds.
63		* Each time is represented by a pair of 32bit integer.
64		*
65		* - typeMap:bin (Optional)
66		*
67		* Array of bytes representing the mapping between each transition
68		* time (transPre32/trans/transPost32) and its corresponding offset
69		* data (typeOffsets).
70		*
71		* - finalRule:string (Optional)
72		*
73		* If a recurrent transition rule is applicable to a zone forever
74		* after the final transition time, finalRule represents the rule
75		* in Rules data.
76		*
77		* - finalRaw:int (Optional)
78		*
79		* When finalRule is available, finalRaw is required and specifies
80		* the raw (base) offset of the rule.
81		*
82		* - finalYear:int (Optional)
83		*
84		* When finalRule is available, finalYear is required and specifies
85		* the start year of the rule.
86		*
87		* - links:intvector (Optional)
88		*
89		* When this zone data is shared with other zones, links specifies
90		* all zones including the zone itself. Each zone is referenced by
91		* integer index.
92		*
93		* b. Link (int, length 1). A link zone is an int resource. The
94		* integer is the zone number of the target zone. The key of this
95		* resource is an alternate name for the target zone. This data
96		* is corresponding to Link data in the tz database.
97		*
98		*
99		* 2. Rules. These have keys corresponding to the Olson rule IDs,
100		* with an underscore prepended, e.g., "_EU". Each resource describes
101		* the behavior of the given rule using an intvector, containing the
102		* onset list, the cessation list, and the DST savings. The onset and
103		* cessation lists consist of the month, dowim, dow, time, and time
104		* mode. The end result is that the 11 integers describing the rule
105		* can be passed directly into the SimpleTimeZone 13-argument
106		* constructor (the other two arguments will be the raw offset, taken
107		* from the complex zone element 5, and the ID string, which is not
108		* used), with the times and the DST savings multiplied by 1000 to
109		* scale from seconds to milliseconds.
110		*
111		* 3. Regions. An array specifies mapping between zones and regions.
112		* Each item is either a 2-letter ISO country code or "001"
113		* (UN M.49 - World). This data is generated from "zone.tab"
114		* in the tz database.
115		*/
116		class U_I18N_API OlsonTimeZone: public BasicTimeZone {
117		public:
118		/**
119		* Construct from a resource bundle.
120		* @param top the top-level zoneinfo resource bundle. This is used
121		* to lookup the rule that `res' may refer to, if there is one.
122		* @param res the resource bundle of the zone to be constructed
123		* @param tzid the time zone ID
124		* @param ec input-output error code
125		*/
126		OlsonTimeZone(const UResourceBundle* top,
127		const UResourceBundle* res,
128		const UnicodeString& tzid,
129		UErrorCode& ec);
130
131		/**
132		* Copy constructor
133		*/
134		OlsonTimeZone(const OlsonTimeZone& other);
135
136		/**
137		* Destructor
138		*/
139		virtual ~OlsonTimeZone();
140
141		/**
142		* Assignment operator
143		*/
144		OlsonTimeZone& operator=(const OlsonTimeZone& other);
145
146		/**
147		* Returns true if the two TimeZone objects are equal.
148		*/
149		virtual UBool operator==(const TimeZone& other) const;
150
151		/**
152		* TimeZone API.
153		*/
154		virtual TimeZone* clone() const;
155
156		/**
157		* TimeZone API.
158		*/
159		static UClassID U_EXPORT2 getStaticClassID();
160
161		/**
162		* TimeZone API.
163		*/
164		virtual UClassID getDynamicClassID() const;
165
166		/**
167		* TimeZone API. Do not call this; prefer getOffset(UDate,...).
168		*/
169		virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month,
170		int32_t day, uint8_t dayOfWeek,
171		int32_t millis, UErrorCode& ec) const;
172
173		/**
174		* TimeZone API. Do not call this; prefer getOffset(UDate,...).
175		*/
176		virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month,
177		int32_t day, uint8_t dayOfWeek,
178		int32_t millis, int32_t monthLength,
179		UErrorCode& ec) const;
180
181		/**
182		* TimeZone API.
183		*/
184		virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
185		int32_t& dstOffset, UErrorCode& ec) const;
186
187		/**
188		* BasicTimeZone API.
189		*/
190		virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
191		int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) const;
192
193		/**
194		* TimeZone API. This method has no effect since objects of this
195		* class are quasi-immutable (the base class allows the ID to be
196		* changed).
197		*/
198		virtual void setRawOffset(int32_t offsetMillis);
199
200		/**
201		* TimeZone API. For a historical zone, the raw offset can change
202		* over time, so this API is not useful. In order to approximate
203		* expected behavior, this method returns the raw offset for the
204		* current moment in time.
205		*/
206		virtual int32_t getRawOffset() const;
207
208		/**
209		* TimeZone API. For a historical zone, whether DST is used or
210		* not varies over time. In order to approximate expected
211		* behavior, this method returns TRUE if DST is observed at any
212		* point in the current year.
213		*/
214		virtual UBool useDaylightTime() const;
215
216		/**
217		* TimeZone API.
218		*/
219		virtual UBool inDaylightTime(UDate date, UErrorCode& ec) const;
220
221		/**
222		* TimeZone API.
223		*/
224		virtual int32_t getDSTSavings() const;
225
226		/**
227		* TimeZone API. Also comare historic transitions.
228		*/
229		virtual UBool hasSameRules(const TimeZone& other) const;
230
231		/**
232		* BasicTimeZone API.
233		* Gets the first time zone transition after the base time.
234		* @param base The base time.
235		* @param inclusive Whether the base time is inclusive or not.
236		* @param result Receives the first transition after the base time.
237		* @return TRUE if the transition is found.
238		*/
239		virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
240
241		/**
242		* BasicTimeZone API.
243		* Gets the most recent time zone transition before the base time.
244		* @param base The base time.
245		* @param inclusive Whether the base time is inclusive or not.
246		* @param result Receives the most recent transition before the base time.
247		* @return TRUE if the transition is found.
248		*/
249		virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
250
251		/**
252		* BasicTimeZone API.
253		* Returns the number of <code>TimeZoneRule</code>s which represents time transitions,
254		* for this time zone, that is, all <code>TimeZoneRule</code>s for this time zone except
255		* <code>InitialTimeZoneRule</code>. The return value range is 0 or any positive value.
256		* @param status Receives error status code.
257		* @return The number of <code>TimeZoneRule</code>s representing time transitions.
258		*/
259		virtual int32_t countTransitionRules(UErrorCode& status) const;
260
261		/**
262		* Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
263		* which represent time transitions for this time zone. On successful return,
264		* the argument initial points to non-NULL <code>InitialTimeZoneRule</code> and
265		* the array trsrules is filled with 0 or multiple <code>TimeZoneRule</code>
266		* instances up to the size specified by trscount. The results are referencing the
267		* rule instance held by this time zone instance. Therefore, after this time zone
268		* is destructed, they are no longer available.
269		* @param initial Receives the initial timezone rule
270		* @param trsrules Receives the timezone transition rules
271		* @param trscount On input, specify the size of the array 'transitions' receiving
272		* the timezone transition rules. On output, actual number of
273		* rules filled in the array will be set.
274		* @param status Receives error status code.
275		*/
276		virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
277		const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;
278
279		/**
280		* Internal API returning the canonical ID of this zone.
281		* This ID won't be affected by setID().
282		*/
283		const UChar *getCanonicalID() const;
284
285		private:
286		/**
287		* Default constructor. Creates a time zone with an empty ID and
288		* a fixed GMT offset of zero.
289		*/
290		OlsonTimeZone();
291
292		private:
293
294		void constructEmpty();
295
296		void getHistoricalOffset(UDate date, UBool local,
297		int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
298		int32_t& rawoff, int32_t& dstoff) const;
299
300		int16_t transitionCount() const;
301
302		int64_t transitionTimeInSeconds(int16_t transIdx) const;
303		double transitionTime(int16_t transIdx) const;
304
305		/*
306		* Following 3 methods return an offset at the given transition time index.
307		* When the index is negative, return the initial offset.
308		*/
309		int32_t zoneOffsetAt(int16_t transIdx) const;
310		int32_t rawOffsetAt(int16_t transIdx) const;
311		int32_t dstOffsetAt(int16_t transIdx) const;
312
313		/*
314		* Following methods return the initial offset.
315		*/
316		int32_t initialRawOffset() const;
317		int32_t initialDstOffset() const;
318
319		/**
320		* Number of transitions in each time range
321		*/
322		int16_t transitionCountPre32;
323		int16_t transitionCount32;
324		int16_t transitionCountPost32;
325
326		/**
327		* Time of each transition in seconds from 1970 epoch before 32bit second range (<= 1900).
328		* Each transition in this range is represented by a pair of int32_t.
329		* Length is transitionCount int32_t's. NULL if no transitions in this range.
330		*/
331		const int32_t *transitionTimesPre32; // alias into res; do not delete
332
333		/**
334		* Time of each transition in seconds from 1970 epoch in 32bit second range.
335		* Length is transitionCount int32_t's. NULL if no transitions in this range.
336		*/
337		const int32_t *transitionTimes32; // alias into res; do not delete
338
339		/**
340		* Time of each transition in seconds from 1970 epoch after 32bit second range (>= 2038).
341		* Each transition in this range is represented by a pair of int32_t.
342		* Length is transitionCount int32_t's. NULL if no transitions in this range.
343		*/
344		const int32_t *transitionTimesPost32; // alias into res; do not delete
345
346		/**
347		* Number of types, 1..255
348		*/
349		int16_t typeCount;
350
351		/**
352		* Offset from GMT in seconds for each type.
353		* Length is typeCount int32_t's. At least one type (a pair of int32_t)
354		* is required.
355		*/
356		const int32_t *typeOffsets; // alias into res; do not delete
357
358		/**
359		* Type description data, consisting of transitionCount uint8_t
360		* type indices (from 0..typeCount-1).
361		* Length is transitionCount int16_t's. NULL if no transitions.
362		*/
363		const uint8_t *typeMapData; // alias into res; do not delete
364
365		/**
366		* A SimpleTimeZone that governs the behavior for date >= finalMillis.
367		*/
368		SimpleTimeZone *finalZone; // owned, may be NULL
369
370		/**
371		* For date >= finalMillis, the finalZone will be used.
372		*/
373		double finalStartMillis;
374
375		/**
376		* For year >= finalYear, the finalZone will be used.
377		*/
378		int32_t finalStartYear;
379
380		/*
381		* Canonical (CLDR) ID of this zone
382		*/
383		const UChar *canonicalID;
384
385		/* BasicTimeZone support */
386		void clearTransitionRules(void);
387		void deleteTransitionRules(void);
388		void checkTransitionRules(UErrorCode& status) const;
389
390		public: // Internal, for access from plain C code
391		void initTransitionRules(UErrorCode& status);
392		private:
393
394		InitialTimeZoneRule *initialRule;
395		TimeZoneTransition *firstTZTransition;
396		int16_t firstTZTransitionIdx;
397		TimeZoneTransition *firstFinalTZTransition;
398		TimeArrayTimeZoneRule **historicRules;
399		int16_t historicRuleCount;
400		SimpleTimeZone *finalZoneWithStartYear; // hack
401		UInitOnce transitionRulesInitOnce;
402		};
403
404		inline int16_t
405	0	OlsonTimeZone::transitionCount() const {
406	0	return transitionCountPre32 + transitionCount32 + transitionCountPost32;
407	0	}
408
409		inline double
410	0	OlsonTimeZone::transitionTime(int16_t transIdx) const {
411	0	return (double)transitionTimeInSeconds(transIdx) * U_MILLIS_PER_SECOND;
412	0	}
413
414		inline int32_t
415	0	OlsonTimeZone::zoneOffsetAt(int16_t transIdx) const {
416	0	int16_t typeIdx = (transIdx >= 0 ? typeMapData[transIdx] : 0) << 1;
417	0	return typeOffsets[typeIdx] + typeOffsets[typeIdx + 1];
418	0	}
419
420		inline int32_t
421	0	OlsonTimeZone::rawOffsetAt(int16_t transIdx) const {
422	0	int16_t typeIdx = (transIdx >= 0 ? typeMapData[transIdx] : 0) << 1;
423	0	return typeOffsets[typeIdx];
424	0	}
425
426		inline int32_t
427	0	OlsonTimeZone::dstOffsetAt(int16_t transIdx) const {
428	0	int16_t typeIdx = (transIdx >= 0 ? typeMapData[transIdx] : 0) << 1;
429	0	return typeOffsets[typeIdx + 1];
430	0	}
431
432		inline int32_t
433	0	OlsonTimeZone::initialRawOffset() const {
434	0	return typeOffsets[0];
435	0	}
436
437		inline int32_t
438	0	OlsonTimeZone::initialDstOffset() const {
439	0	return typeOffsets[1];
440	0	}
441
442		inline const UChar*
443	0	OlsonTimeZone::getCanonicalID() const {
444	0	return canonicalID;
445	0	}
446
447
448		U_NAMESPACE_END
449
450		#endif // !UCONFIG_NO_FORMATTING
451		#endif // OLSONTZ_H
452
453		//eof