← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/i18n/unicode/rbtz.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/i18n/unicode/rbtz.h
1
 
/*
2
 
*******************************************************************************
3
 
* Copyright (C) 2007-2008, International Business Machines Corporation and    *
4
 
* others. All Rights Reserved.                                                *
5
 
*******************************************************************************
6
 
*/
7
 
#ifndef RBTZ_H
8
 
#define RBTZ_H
9
 
 
10
 
#include "unicode/utypes.h"
11
 
 
12
 
/**
13
 
 * \file 
14
 
 * \brief C++ API: Rule based customizable time zone
15
 
 */
16
 
 
17
 
#if !UCONFIG_NO_FORMATTING
18
 
 
19
 
#include "unicode/basictz.h"
20
 
#include "unicode/unistr.h"
21
 
 
22
 
U_NAMESPACE_BEGIN
23
 
 
24
 
// forward declaration
25
 
class UVector;
26
 
struct Transition;
27
 
 
28
 
/**
29
 
 * a BasicTimeZone subclass implemented in terms of InitialTimeZoneRule and TimeZoneRule instances
30
 
 * @see BasicTimeZone
31
 
 * @see InitialTimeZoneRule
32
 
 * @see TimeZoneRule
33
 
 */
34
 
class U_I18N_API RuleBasedTimeZone : public BasicTimeZone {
35
 
public:
36
 
    /**
37
 
     * Constructs a <code>RuleBasedTimeZone</code> object with the ID and the
38
 
     * <code>InitialTimeZoneRule</code>.  The input <code>InitialTimeZoneRule</code>
39
 
     * is adopted by this <code>RuleBasedTimeZone</code>, thus the caller must not
40
 
     * delete it.
41
 
     * @param id                The time zone ID.
42
 
     * @param initialRule       The initial time zone rule.
43
 
     * @stable ICU 3.8
44
 
     */
45
 
    RuleBasedTimeZone(const UnicodeString& id, InitialTimeZoneRule* initialRule);
46
 
 
47
 
    /**
48
 
     * Copy constructor.
49
 
     * @param source    The RuleBasedTimeZone object to be copied.
50
 
     * @stable ICU 3.8
51
 
     */
52
 
    RuleBasedTimeZone(const RuleBasedTimeZone& source);
53
 
 
54
 
    /**
55
 
     * Destructor.
56
 
     * @stable ICU 3.8
57
 
     */
58
 
    virtual ~RuleBasedTimeZone();
59
 
 
60
 
    /**
61
 
     * Assignment operator.
62
 
     * @param right The object to be copied.
63
 
     * @stable ICU 3.8
64
 
     */
65
 
    RuleBasedTimeZone& operator=(const RuleBasedTimeZone& right);
66
 
 
67
 
    /**
68
 
     * Return true if the given <code>TimeZone</code> objects are
69
 
     * semantically equal. Objects of different subclasses are considered unequal.
70
 
     * @param that  The object to be compared with.
71
 
     * @return  true if the given <code>TimeZone</code> objects are
72
 
      *semantically equal.
73
 
     * @stable ICU 3.8
74
 
     */
75
 
    virtual UBool operator==(const TimeZone& that) const;
76
 
 
77
 
    /**
78
 
     * Return true if the given <code>TimeZone</code> objects are
79
 
     * semantically unequal. Objects of different subclasses are considered unequal.
80
 
     * @param that  The object to be compared with.
81
 
     * @return  true if the given <code>TimeZone</code> objects are
82
 
     * semantically unequal.
83
 
     * @stable ICU 3.8
84
 
     */
85
 
    virtual UBool operator!=(const TimeZone& that) const;
86
 
 
87
 
    /**
88
 
     * Adds the <code>TimeZoneRule</code> which represents time transitions.
89
 
     * The <code>TimeZoneRule</code> must have start times, that is, the result
90
 
     * of isTransitionRule() must be true. Otherwise, U_ILLEGAL_ARGUMENT_ERROR
91
 
     * is set to the error code.
92
 
     * The input <code>TimeZoneRule</code> is adopted by this
93
 
     * <code>RuleBasedTimeZone</code> on successful completion of this method,
94
 
     * thus, the caller must not delete it when no error is returned.
95
 
     * After all rules are added, the caller must call complete() method to
96
 
     * make this <code>RuleBasedTimeZone</code> ready to handle common time
97
 
     * zone functions.
98
 
     * @param rule The <code>TimeZoneRule</code>.
99
 
     * @param status Output param to filled in with a success or an error.
100
 
     * @stable ICU 3.8
101
 
     */
102
 
    void addTransitionRule(TimeZoneRule* rule, UErrorCode& status);
103
 
 
104
 
    /**
105
 
     * Makes the <code>TimeZoneRule</code> ready to handle actual timezone
106
 
     * calcuation APIs.  This method collects time zone rules specified
107
 
     * by the caller via the constructor and addTransitionRule() and
108
 
     * builds internal structure for making the object ready to support
109
 
     * time zone APIs such as getOffset(), getNextTransition() and others.
110
 
     * @param status Output param to filled in with a success or an error.
111
 
     * @stable ICU 3.8
112
 
     */
113
 
    void complete(UErrorCode& status);
114
 
 
115
 
    /**
116
 
     * Clones TimeZone objects polymorphically. Clients are responsible for deleting
117
 
     * the TimeZone object cloned.
118
 
     *
119
 
     * @return   A new copy of this TimeZone object.
120
 
     * @stable ICU 3.8
121
 
     */
122
 
    virtual TimeZone* clone(void) const;
123
 
 
124
 
    /**
125
 
     * Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseconds to add
126
 
     * to GMT to get local time in this time zone, taking daylight savings time into
127
 
     * account) as of a particular reference date.  The reference date is used to determine
128
 
     * whether daylight savings time is in effect and needs to be figured into the offset
129
 
     * that is returned (in other words, what is the adjusted GMT offset in this time zone
130
 
     * at this particular date and time?).  For the time zones produced by createTimeZone(),
131
 
     * the reference data is specified according to the Gregorian calendar, and the date
132
 
     * and time fields are local standard time.
133
 
     *
134
 
     * <p>Note: Don't call this method. Instead, call the getOffset(UDate...) overload,
135
 
     * which returns both the raw and the DST offset for a given time. This method
136
 
     * is retained only for backward compatibility.
137
 
     *
138
 
     * @param era        The reference date's era
139
 
     * @param year       The reference date's year
140
 
     * @param month      The reference date's month (0-based; 0 is January)
141
 
     * @param day        The reference date's day-in-month (1-based)
142
 
     * @param dayOfWeek  The reference date's day-of-week (1-based; 1 is Sunday)
143
 
     * @param millis     The reference date's milliseconds in day, local standard time
144
 
     * @param status     Output param to filled in with a success or an error.
145
 
     * @return           The offset in milliseconds to add to GMT to get local time.
146
 
     * @stable ICU 3.8
147
 
     */
148
 
    virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
149
 
                              uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const;
150
 
 
151
 
    /**
152
 
     * Gets the time zone offset, for current date, modified in case of
153
 
     * daylight savings. This is the offset to add *to* UTC to get local time.
154
 
     *
155
 
     * <p>Note: Don't call this method. Instead, call the getOffset(UDate...) overload,
156
 
     * which returns both the raw and the DST offset for a given time. This method
157
 
     * is retained only for backward compatibility.
158
 
     *
159
 
     * @param era        The reference date's era
160
 
     * @param year       The reference date's year
161
 
     * @param month      The reference date's month (0-based; 0 is January)
162
 
     * @param day        The reference date's day-in-month (1-based)
163
 
     * @param dayOfWeek  The reference date's day-of-week (1-based; 1 is Sunday)
164
 
     * @param millis     The reference date's milliseconds in day, local standard time
165
 
     * @param monthLength The length of the given month in days.
166
 
     * @param status     Output param to filled in with a success or an error.
167
 
     * @return           The offset in milliseconds to add to GMT to get local time.
168
 
     * @stable ICU 3.8
169
 
     */
170
 
    virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
171
 
                           uint8_t dayOfWeek, int32_t millis,
172
 
                           int32_t monthLength, UErrorCode& status) const;
173
 
 
174
 
    /**
175
 
     * Returns the time zone raw and GMT offset for the given moment
176
 
     * in time.  Upon return, local-millis = GMT-millis + rawOffset +
177
 
     * dstOffset.  All computations are performed in the proleptic
178
 
     * Gregorian calendar.  The default implementation in the TimeZone
179
 
     * class delegates to the 8-argument getOffset().
180
 
     *
181
 
     * @param date moment in time for which to return offsets, in
182
 
     * units of milliseconds from January 1, 1970 0:00 GMT, either GMT
183
 
     * time or local wall time, depending on `local'.
184
 
     * @param local if true, `date' is local wall time; otherwise it
185
 
     * is in GMT time.
186
 
     * @param rawOffset output parameter to receive the raw offset, that
187
 
     * is, the offset not including DST adjustments
188
 
     * @param dstOffset output parameter to receive the DST offset,
189
 
     * that is, the offset to be added to `rawOffset' to obtain the
190
 
     * total offset between local and GMT time. If DST is not in
191
 
     * effect, this value is zero; otherwise it is a positive value,
192
 
     * typically one hour.
193
 
     * @param ec input-output error code
194
 
     * @stable ICU 3.8
195
 
     */
196
 
    virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
197
 
                           int32_t& dstOffset, UErrorCode& ec) const;
198
 
 
199
 
    /**
200
 
     * Sets the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
201
 
     * to GMT to get local time, before taking daylight savings time into account).
202
 
     *
203
 
     * @param offsetMillis  The new raw GMT offset for this time zone.
204
 
     * @stable ICU 3.8
205
 
     */
206
 
    virtual void setRawOffset(int32_t offsetMillis);
207
 
 
208
 
    /**
209
 
     * Returns the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
210
 
     * to GMT to get local time, before taking daylight savings time into account).
211
 
     *
212
 
     * @return   The TimeZone's raw GMT offset.
213
 
     * @stable ICU 3.8
214
 
     */
215
 
    virtual int32_t getRawOffset(void) const;
216
 
 
217
 
    /**
218
 
     * Queries if this time zone uses daylight savings time.
219
 
     * @return true if this time zone uses daylight savings time,
220
 
     * false, otherwise.
221
 
     * @stable ICU 3.8
222
 
     */
223
 
    virtual UBool useDaylightTime(void) const;
224
 
 
225
 
    /**
226
 
     * Queries if the given date is in daylight savings time in
227
 
     * this time zone.
228
 
     * This method is wasteful since it creates a new GregorianCalendar and
229
 
     * deletes it each time it is called. This is a deprecated method
230
 
     * and provided only for Java compatibility.
231
 
     *
232
 
     * @param date the given UDate.
233
 
     * @param status Output param filled in with success/error code.
234
 
     * @return true if the given date is in daylight savings time,
235
 
     * false, otherwise.
236
 
     * @deprecated ICU 2.4. Use Calendar::inDaylightTime() instead.
237
 
     */
238
 
    virtual UBool inDaylightTime(UDate date, UErrorCode& status) const;
239
 
 
240
 
    /**
241
 
     * Returns true if this zone has the same rule and offset as another zone.
242
 
     * That is, if this zone differs only in ID, if at all.
243
 
     * @param other the <code>TimeZone</code> object to be compared with
244
 
     * @return true if the given zone is the same as this one,
245
 
     * with the possible exception of the ID
246
 
     * @stable ICU 3.8
247
 
     */
248
 
    virtual UBool hasSameRules(const TimeZone& other) const;
249
 
 
250
 
    /**
251
 
     * Gets the first time zone transition after the base time.
252
 
     * @param base      The base time.
253
 
     * @param inclusive Whether the base time is inclusive or not.
254
 
     * @param result    Receives the first transition after the base time.
255
 
     * @return  TRUE if the transition is found.
256
 
     * @stable ICU 3.8
257
 
     */
258
 
    virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) /*const*/;
259
 
 
260
 
    /**
261
 
     * Gets the most recent time zone transition before the base time.
262
 
     * @param base      The base time.
263
 
     * @param inclusive Whether the base time is inclusive or not.
264
 
     * @param result    Receives the most recent transition before the base time.
265
 
     * @return  TRUE if the transition is found.
266
 
     * @stable ICU 3.8
267
 
     */
268
 
    virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) /*const*/;
269
 
 
270
 
    /**
271
 
     * Returns the number of <code>TimeZoneRule</code>s which represents time transitions,
272
 
     * for this time zone, that is, all <code>TimeZoneRule</code>s for this time zone except
273
 
     * <code>InitialTimeZoneRule</code>.  The return value range is 0 or any positive value.
274
 
     * @param status    Receives error status code.
275
 
     * @return The number of <code>TimeZoneRule</code>s representing time transitions.
276
 
     * @stable ICU 3.8
277
 
     */
278
 
    virtual int32_t countTransitionRules(UErrorCode& status) /*const*/;
279
 
 
280
 
    /**
281
 
     * Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
282
 
     * which represent time transitions for this time zone.  On successful return,
283
 
     * the argument initial points to non-NULL <code>InitialTimeZoneRule</code> and
284
 
     * the array trsrules is filled with 0 or multiple <code>TimeZoneRule</code>
285
 
     * instances up to the size specified by trscount.  The results are referencing the
286
 
     * rule instance held by this time zone instance.  Therefore, after this time zone
287
 
     * is destructed, they are no longer available.
288
 
     * @param initial       Receives the initial timezone rule
289
 
     * @param trsrules      Receives the timezone transition rules
290
 
     * @param trscount      On input, specify the size of the array 'transitions' receiving
291
 
     *                      the timezone transition rules.  On output, actual number of
292
 
     *                      rules filled in the array will be set.
293
 
     * @param status        Receives error status code.
294
 
     * @stable ICU 3.8
295
 
     */
296
 
    virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
297
 
        const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) /*const*/;
298
 
 
299
 
    /**
300
 
     * Get time zone offsets from local wall time.
301
 
     * @internal
302
 
     */
303
 
    virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
304
 
        int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) /*const*/;
305
 
 
306
 
private:
307
 
    void deleteRules(void);
308
 
    void deleteTransitions(void);
309
 
    UVector* copyRules(UVector* source);
310
 
    TimeZoneRule* findRuleInFinal(UDate date, UBool local,
311
 
        int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const;
312
 
    UBool findNext(UDate base, UBool inclusive, UDate& time, TimeZoneRule*& from, TimeZoneRule*& to) const;
313
 
    UBool findPrev(UDate base, UBool inclusive, UDate& time, TimeZoneRule*& from, TimeZoneRule*& to) const;
314
 
    int32_t getLocalDelta(int32_t rawBefore, int32_t dstBefore, int32_t rawAfter, int32_t dstAfter,
315
 
        int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const;
316
 
    UDate getTransitionTime(Transition* transition, UBool local,
317
 
        int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const;
318
 
    void getOffsetInternal(UDate date, UBool local, int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
319
 
        int32_t& rawOffset, int32_t& dstOffset, UErrorCode& ec) const;
320
 
 
321
 
    InitialTimeZoneRule *fInitialRule;
322
 
    UVector             *fHistoricRules;
323
 
    UVector             *fFinalRules;
324
 
    UVector             *fHistoricTransitions;
325
 
    UBool               fUpToDate;
326
 
 
327
 
public:
328
 
    /**
329
 
     * Return the class ID for this class. This is useful only for comparing to
330
 
     * a return value from getDynamicClassID(). For example:
331
 
     * <pre>
332
 
     * .   Base* polymorphic_pointer = createPolymorphicObject();
333
 
     * .   if (polymorphic_pointer->getDynamicClassID() ==
334
 
     * .       erived::getStaticClassID()) ...
335
 
     * </pre>
336
 
     * @return          The class ID for all objects of this class.
337
 
     * @stable ICU 3.8
338
 
     */
339
 
    static UClassID U_EXPORT2 getStaticClassID(void);
340
 
 
341
 
    /**
342
 
     * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
343
 
     * method is to implement a simple version of RTTI, since not all C++
344
 
     * compilers support genuine RTTI. Polymorphic operator==() and clone()
345
 
     * methods call this method.
346
 
     *
347
 
     * @return          The class ID for this object. All objects of a
348
 
     *                  given class have the same class ID.  Objects of
349
 
     *                  other classes have different class IDs.
350
 
     * @stable ICU 3.8
351
 
     */
352
 
    virtual UClassID getDynamicClassID(void) const;
353
 
};
354
 
 
355
 
U_NAMESPACE_END
356
 
 
357
 
#endif /* #if !UCONFIG_NO_FORMATTING */
358
 
 
359
 
#endif // RBTZ_H
360
 
 
361
 
//eof