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