1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2009-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
#ifndef __ZRULE_H
#define __ZRULE_H
/**
* \file
* \brief C API: Time zone rule classes
*/
#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/uobject.h"
/**
* A TimeZoneRule. Use the zrule_* API to manipulate. Create with
* zrule_open*, and destroy with zrule_close.
*/
struct ZRule;
typedef struct ZRule ZRule;
/**
* An InitialTimeZoneRule. Use the izrule_* API to manipulate. Create with
* izrule_open*, and destroy with izrule_close.
*/
struct IZRule;
typedef struct IZRule IZRule;
/**
* An AnnualTimeZoneRule. Use the azrule_* API to manipulate. Create with
* azrule_open*, and destroy with azrule_close.
*/
struct AZRule;
typedef struct AZRule AZRule;
/*********************************************************************
* ZRule API
*********************************************************************/
/**
* Disposes of the storage used by a ZRule object. This function should
* be called exactly once for objects returned by zrule_open*.
* @param set the object to dispose of
*/
U_CAPI void U_EXPORT2
zrule_close(ZRule* rule);
/**
* Returns true if rule1 is identical to rule2
* and vis versa.
* @param rule1 to be checked for containment
* @param rule2 to be checked for containment
* @return true if the test condition is met
*/
U_CAPI UBool U_EXPORT2
zrule_equals(const ZRule* rule1, const ZRule* rule2);
/**
* Fills in "name" with the name of this time zone.
* @param rule, the Zrule to use
* @param name Receives the name of this time zone.
* @param nameLength, length of the returned name
*/
U_CAPI void U_EXPORT2
zrule_getName(ZRule* rule, UChar* name, int32_t nameLength);
/**
* Gets the standard time offset.
* @param rule, the Zrule to use
* @return The standard time offset from UTC in milliseconds.
*/
U_CAPI int32_t U_EXPORT2
zrule_getRawOffset(ZRule* rule);
/**
* Gets the amount of daylight saving delta time from the standard time.
* @param rule, the Zrule to use
* @return The amount of daylight saving offset used by this rule
* in milliseconds.
*/
U_CAPI int32_t U_EXPORT2
zrule_getDSTSavings(ZRule* rule);
/**
* Returns if this rule represents the same rule and offsets as another.
* When two ZRule objects differ only its names, this method
* returns true.
* @param rule1 to be checked for containment
* @param rule2 to be checked for containment
* @return true if the other <code>TimeZoneRule</code> is the same as this one.
*/
U_CAPI UBool U_EXPORT2
zrule_isEquivalentTo(ZRule* rule1, ZRule* rule2);
/*********************************************************************
* IZRule API
*********************************************************************/
/**
* Constructs an IZRule with the name, the GMT offset of its
* standard time and the amount of daylight saving offset adjustment.
* @param name The time zone name.
* @param nameLength The length of the time zone name.
* @param rawOffset The UTC offset of its standard time in milliseconds.
* @param dstSavings The amount of daylight saving offset adjustment in milliseconds.
* If this ia a rule for standard time, the value of this argument is 0.
*/
U_CAPI IZRule* U_EXPORT2
izrule_open(const UChar* name, int32_t nameLength, int32_t rawOffset, int32_t dstSavings);
/**
* Disposes of the storage used by a IZRule object. This function should
* be called exactly once for objects returned by izrule_open*.
* @param set the object to dispose of
*/
U_CAPI void U_EXPORT2
izrule_close(IZRule* rule);
/**
* Returns a copy of this object.
* @param rule the original IZRule
* @return the newly allocated copy of the IZRule
*/
U_CAPI IZRule* U_EXPORT2
izrule_clone(IZRule *rule);
/**
* Returns true if rule1 is identical to rule2
* and vis versa.
* @param rule1 to be checked for containment
* @param rule2 to be checked for containment
* @return true if the test condition is met
*/
U_CAPI UBool U_EXPORT2
izrule_equals(const IZRule* rule1, const IZRule* rule2);
/**
* Fills in "name" with the name of this time zone.
* @param rule, the IZrule to use
* @param name Receives the name of this time zone.
* @param nameLength, length of the returned name
*/
U_CAPI void U_EXPORT2
izrule_getName(IZRule* rule, UChar* & name, int32_t & nameLength);
/**
* Gets the standard time offset.
* @param rule, the IZrule to use
* @return The standard time offset from UTC in milliseconds.
*/
U_CAPI int32_t U_EXPORT2
izrule_getRawOffset(IZRule* rule);
/**
* Gets the amount of daylight saving delta time from the standard time.
* @param rule, the IZrule to use
* @return The amount of daylight saving offset used by this rule
* in milliseconds.
*/
U_CAPI int32_t U_EXPORT2
izrule_getDSTSavings(IZRule* rule);
/**
* Returns if this rule represents the same rule and offsets as another.
* When two IZRule objects differ only its names, this method
* returns true.
* @param rule1 to be checked for containment
* @param rule2 to be checked for containment
* @return true if the other <code>TimeZoneRule</code> is the same as this one.
*/
U_CAPI UBool U_EXPORT2
izrule_isEquivalentTo(IZRule* rule1, IZRule* rule2);
/**
* Gets the very first time when this rule takes effect.
* @param rule The IZrule to use
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
* @param result Receives the very first time when this rule takes effect.
* @return true if the start time is available. When false is returned, output parameter
* "result" is unchanged.
*/
U_CAPI UBool U_EXPORT2
izrule_getFirstStart(IZRule* rule, int32_t prevRawOffset, int32_t prevDSTSavings,
UDate& result);
/**
* Gets the final time when this rule takes effect.
* @param rule The IZrule to use
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
* @param result Receives the final time when this rule takes effect.
* @return true if the start time is available. When false is returned, output parameter
* "result" is unchanged.
*/
U_CAPI UBool U_EXPORT2
izrule_getFinalStart(IZRule* rule, int32_t prevRawOffset, int32_t prevDSTSavings,
UDate& result);
/**
* Gets the first time when this rule takes effect after the specified time.
* @param rule The IZrule to use
* @param base The first start time after this base time will be returned.
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
* @param inclusive Whether the base time is inclusive or not.
* @param result Receives The first time when this rule takes effect after
* the specified base time.
* @return true if the start time is available. When false is returned, output parameter
* "result" is unchanged.
*/
U_CAPI UBool U_EXPORT2
izrule_getNextStart(IZRule* rule, UDate base, int32_t prevRawOffset,
int32_t prevDSTSavings, UBool inclusive, UDate& result);
/**
* Gets the most recent time when this rule takes effect before the specified time.
* @param rule The IZrule to use
* @param base The most recent time before this base time will be returned.
* @param prevRawOffset The standard time offset from UTC before this rule
* takes effect in milliseconds.
* @param prevDSTSavings The amount of daylight saving offset from the
* standard time.
* @param inclusive Whether the base time is inclusive or not.
* @param result Receives The most recent time when this rule takes effect before
* the specified base time.
* @return true if the start time is available. When false is returned, output parameter
* "result" is unchanged.
*/
U_CAPI UBool U_EXPORT2
izrule_getPreviousStart(IZRule* rule, UDate base, int32_t prevRawOffset,
int32_t prevDSTSavings, UBool inclusive, UDate& result);
/**
* Return the class ID for this class. This is useful only for comparing to
* a return value from getDynamicClassID(). For example:
* <pre>
* . Base* polymorphic_pointer = createPolymorphicObject();
* . if (polymorphic_pointer->getDynamicClassID() ==
* . erived::getStaticClassID()) ...
* </pre>
* @param rule The IZrule to use
* @return The class ID for all objects of this class.
*/
U_CAPI UClassID U_EXPORT2
izrule_getStaticClassID(IZRule* rule);
/**
* Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
* method is to implement a simple version of RTTI, since not all C++
* compilers support genuine RTTI. Polymorphic operator==() and clone()
* methods call this method.
*
* @param rule The IZrule to use
* @return The class ID for this object. All objects of a
* given class have the same class ID. Objects of
* other classes have different class IDs.
*/
U_CAPI UClassID U_EXPORT2
izrule_getDynamicClassID(IZRule* rule);
#endif
#endif
|
