src/third_party/icu/source/i18n/olsontz.h - cobalt - Git at Google

 /*
 **********************************************************************
 * 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
	/*
	**********************************************************************
	* 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