452 lines
15 KiB
C++
452 lines
15 KiB
C++
/*
|
|
**********************************************************************
|
|
* 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
|