1 /*
2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 import java.io.BufferedReader;
27 import java.io.FileReader;
28 import java.io.FileNotFoundException;
29 import java.io.IOException;
30 import java.util.ArrayList;
31 import java.util.HashMap;
32 import java.util.HashSet;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Set;
36 import java.util.StringTokenizer;
37
38 /**
39 * ZoneRec hold information of time zone corresponding to each text
40 * line of the "Zone" part.
41 *
42 * @since 1.4
43 */
44 class ZoneRec {
45 private int gmtOffset;
46 private String ruleName;
47 private int directSave;
48 private Rule ruleRef;
49 private String format;
50 private boolean hasUntil;
51 private int untilYear;
52 private Month untilMonth;
53 private RuleDay untilDay;
54 private Time untilTime;
55 private long untilInMillis;
56 private String line;
57
58 /**
59 * @return the "UNTIL" value in milliseconds
60 */
61 Time getUntilTime() {
62 return untilTime;
63 }
64
65 /**
66 * @return the GMT offset value in milliseconds
67 */
68 int getGmtOffset() {
69 return gmtOffset;
70 }
71
72 /**
73 * @return the rule name to which this zone record refers
74 */
75 String getRuleName() {
76 return ruleName;
77 }
78
79 /**
80 * @return the amount of saving time directly defined in the
81 * "RULES/SAVE" field.
82 */
83 int getDirectSave() {
84 return directSave;
85 }
86
87 /**
88 * @return true if this zone record has a reference to a rule
89 */
90 boolean hasRuleReference() {
91 return ruleRef != null;
92 }
93
94 /**
95 * Returns the "FORMAT" field string of this zone record. This
96 * @return the "FORMAT" field
97 */
98 String getFormat() {
99 return format;
100 }
101
102 /**
103 * @return the year in the "UNTIL" field
104 */
105 int getUntilYear() {
106 return untilYear;
107 }
108
109 /**
110 * Returns the "UNTIL" field value in milliseconds from Janurary
111 * 1, 1970 0:00 GMT.
112 * @param currentSave the amount of daylight saving in
113 * milliseconds that is used to adjust wall-clock time.
114 * @return the milliseconds value of the "UNTIL" field
115 */
116 long getUntilTime(int currentSave) {
117 if (untilTime.isWall()) {
118 return untilInMillis - currentSave;
119 }
120 return untilInMillis;
121 }
122
123 /**
124 * Returns the "UNTIL" time in milliseconds without adjusting GMT
125 * offsets or daylight saving.
126 * @return local "UNTIL" time in milliseconds
127 */
128 long getLocalUntilTime() {
129 return Time.getLocalTime(untilYear,
130 untilMonth,
131 untilDay,
132 untilTime.getTime());
133 }
134
135 /**
136 * Returns the "UNTIL" time in milliseconds with adjusting GMT offsets and daylight saving.
137 * @return the "UNTIL" time after the adjustment
138 */
139 long getLocalUntilTime(int save, int gmtOffset) {
140 return Time.getLocalTime(untilYear,
141 untilMonth,
142 untilDay,
143 save,
144 gmtOffset,
145 untilTime);
146 }
147
148 /**
149 * @return the text line of this zone record
150 */
151 String getLine() {
152 return line;
153 }
154
155 /**
156 * Sets the specified text line to this zone record
157 */
158 void setLine(String line) {
159 this.line = line;
160 }
161
162 /**
163 * @return true if this zone record has the "UNTIL" field
164 */
165 boolean hasUntil() {
166 return this.hasUntil;
167 }
168
169 /**
170 * Adjusts the "UNTIL" time to GMT offset if this zone record has
171 * it. <code>untilTime</code> is not adjusted to daylight saving
172 * in this method.
173 */
174 void adjustTime() {
175 if (!hasUntil()) {
176 return;
177 }
178 if (untilTime.isSTD() || untilTime.isWall()) {
179 // adjust to gmt offset only here. adjust to real
180 // wall-clock time when tracking rules
181 untilInMillis -= gmtOffset;
182 }
183 }
184
185 /**
186 * @return the reference to the Rule object
187 */
188 Rule getRuleRef() {
189 return ruleRef;
190 }
191
192 /**
193 * Resolves the reference to a Rule and adjusts its "UNTIL" time
194 * to GMT offset.
195 */
196 void resolve(Zoneinfo zi) {
197 if (ruleName != null && (!"-".equals(ruleName))) {
198 ruleRef = zi.getRule(ruleName);
199 }
200 adjustTime();
201 }
202
203 /**
204 * Parses a Zone text line that is described by a StringTokenizer.
205 * @param tokens represents tokens of a Zone text line
206 * @return the zone record produced by parsing the text
207 */
208 static ZoneRec parse(StringTokenizer tokens) {
209 ZoneRec rec = new ZoneRec();
210 try {
211 rec.gmtOffset = (int) Time.parse(tokens.nextToken()).getTime();
212 String token = tokens.nextToken();
213 char c = token.charAt(0);
214 if (c >= '0' && c <= '9') {
215 rec.directSave = (int) Time.parse(token).getTime();
216 } else {
217 rec.ruleName = token;
218 }
219 rec.format = tokens.nextToken();
220 if (tokens.hasMoreTokens()) {
221 rec.hasUntil = true;
222 rec.untilYear = Integer.parseInt(tokens.nextToken());
223 if (tokens.hasMoreTokens()) {
224 rec.untilMonth = Month.parse(tokens.nextToken());
225 } else {
226 rec.untilMonth = Month.JANUARY;
227 }
228 if (tokens.hasMoreTokens()) {
229 rec.untilDay = RuleDay.parse(tokens.nextToken());
230 } else {
231 rec.untilDay = new RuleDay(1);
232 }
233 if (tokens.hasMoreTokens()) {
234 rec.untilTime = Time.parse(tokens.nextToken());
235 } else {
236 rec.untilTime = Time.parse("0:00");
237 }
238 rec.untilInMillis = rec.getLocalUntilTime();
239 }
240 } catch (Exception e) {
241 // TODO: error reporting
242 e.printStackTrace();
243 }
244 return rec;
245 }
246
247 private static void panic(String msg) {
248 Main.panic(msg);
249 }
250 }