summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-xetex/i18n/olsontz.h
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/i18n/olsontz.h')
-rw-r--r--Build/source/libs/icu/icu-xetex/i18n/olsontz.h382
1 files changed, 382 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/i18n/olsontz.h b/Build/source/libs/icu/icu-xetex/i18n/olsontz.h
new file mode 100644
index 00000000000..64f8c0d774a
--- /dev/null
+++ b/Build/source/libs/icu/icu-xetex/i18n/olsontz.h
@@ -0,0 +1,382 @@
+/*
+**********************************************************************
+* 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