/* ********************************************************************** * Copyright (c) 2003-2007, 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" struct UResourceBundle; U_NAMESPACE_BEGIN class SimpleTimeZone; /** * A time zone based on the Olson 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 several formats, which are differentiated * based on length. * * a. Alias (int, length 1). An alias 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. Aliases * represent Olson links and ICU compatibility IDs. * * b. Simple zone (array, length 3). The three subelements are: * * i. An intvector of transitions. These are given in epoch * seconds. This may be an empty invector (length 0). If the * transtions list is empty, then the zone's behavior is fixed and * given by the offset list, which will contain exactly one pair. * Otherwise each transtion indicates a time after which (inclusive) * the associated offset pair is in effect. * * ii. An intvector of offsets. These are in pairs of raw offset / * DST offset, in units of seconds. There will be at least one pair * (length >= 2 && length % 2 == 0). * * iii. A binary resource. This is of the same length as the * transitions vector, so length may be zero. Each unsigned byte * corresponds to one transition, and has a value of 0..n-1, where n * is the number of pairs in the offset vector. This forms a map * between transitions and offset pairs. * * c. Simple zone with aliases (array, length 4). This is like a * simple zone, but also contains a fourth element: * * iv. An intvector of aliases. This list includes this zone * itself, and lists all aliases of this zone. * * d. Complex zone (array, length 5). This is like a simple zone, * but contains two more elements: * * iv. A string, giving the name of a rule. This is the "final * rule", which governs the zone's behavior beginning in the "final * year". The rule ID is given without leading underscore, e.g., * "EU". * * v. An intvector of length 2, containing the raw offset for the * final rule (in seconds), and the final year. The final rule * takes effect for years >= the final year. * * e. Complex zone with aliases (array, length 6). This is like a * complex zone, but also contains a sixth element: * * vi. An intvector of aliases. This list includes this zone * itself, and lists all aliases of this zone. * * 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. Countries. These have keys corresponding to the 2-letter ISO * country codes, with a percent sign prepended, e.g., "%US". Each * resource is an intvector listing the zones associated with the * given country. The special entry "%" corresponds to "no country", * that is, the category of zones assigned to no country in the Olson * DB. * * 4. Metadata. Metadata is stored under the key "_". It is an * intvector of length three containing the number of zones resources, * rule resources, and country resources. For the purposes of this * count, the metadata entry itself is considered a rule resource, * since its key begins with an underscore. */ class 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 ec input-output error code */ OlsonTimeZone(const UResourceBundle* top, const UResourceBundle* res, 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. */ U_I18N_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. * @draft ICU 3.8 */ virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial, const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) /*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; int32_t zoneOffset(int16_t index) const; int32_t rawOffset(int16_t index) const; int32_t dstOffset(int16_t index) const; /** * Number of transitions, 0..~370 */ int16_t transitionCount; /** * Number of types, 1..255 */ int16_t typeCount; /** * Time of each transition in seconds from 1970 epoch. * Length is transitionCount int32_t's. */ const int32_t *transitionTimes; // alias into res; do not delete /** * Offset from GMT in seconds for each type. * Length is typeCount int32_t's. */ 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 int8_t's. */ const uint8_t *typeData; // alias into res; do not delete /** * The last year for which the transitions data are to be used * rather than the finalZone. If there is no finalZone, then this * is set to INT32_MAX. NOTE: This corresponds to the year _before_ * the one indicated by finalMillis. */ int32_t finalYear; /** * The millis for the start of the first year for which finalZone * is to be used, or DBL_MAX if finalZone is 0. NOTE: This is * 0:00 GMT Jan 1, <finalYear + 1> (not <finalMillis>). */ double finalMillis; /** * A SimpleTimeZone that governs the behavior for years > finalYear. * If and only if finalYear == INT32_MAX then finalZone == 0. */ SimpleTimeZone *finalZone; // owned, may be NULL /* BasicTimeZone support */ void clearTransitionRules(void); void deleteTransitionRules(void); void initTransitionRules(UErrorCode& status); InitialTimeZoneRule *initialRule; TimeZoneTransition *firstTZTransition; int16_t firstTZTransitionIdx; TimeZoneTransition *firstFinalTZTransition; TimeArrayTimeZoneRule **historicRules; int16_t historicRuleCount; SimpleTimeZone *finalZoneWithStartYear; // hack UBool transitionRulesInitialized; }; inline int32_t OlsonTimeZone::zoneOffset(int16_t index) const { index <<= 1; return typeOffsets[index] + typeOffsets[index+1]; } inline int32_t OlsonTimeZone::rawOffset(int16_t index) const { return typeOffsets[(uint32_t)(index << 1)]; } inline int32_t OlsonTimeZone::dstOffset(int16_t index) const { return typeOffsets[(uint32_t)((index << 1) + 1)]; } U_NAMESPACE_END #endif // !UCONFIG_NO_FORMATTING #endif // OLSONTZ_H //eof