1 /*
2 * Copyright (c) 2000, 2011, 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.util.Locale;
27 import sun.util.calendar.CalendarDate;
28 import sun.util.calendar.CalendarSystem;
29 import sun.util.calendar.Gregorian;
30
31 /**
32 * Time class represents the "AT" field and other time related information.
33 *
34 * @since 1.4
35 */
36 class Time {
37
38 static final Gregorian gcal = CalendarSystem.getGregorianCalendar();
39
40 // type is wall clock time
41 private static final int WALL = 1;
42
43 // type is standard time
44 private static final int STD = 2;
45
46 // type is UTC
47 private static final int UTC = 3;
48
49 // type of representing time
50 private int type;
51
52 /**
53 * Time from the EPOCH in milliseconds
54 */
55 private long time;
56
57 /**
58 * Current time in milliseconds
59 */
60 private static final long currentTime = System.currentTimeMillis();
61
62 Time() {
63 time = 0L;
64 }
65
66 Time(long time) {
67 this.time = time;
68 }
69
70 void setType(int type) {
71 this.type = type;
72 }
73
74 long getTime() {
75 return time;
76 }
77
78 int getType() {
79 return type;
80 }
81
82 static long getCurrentTime() {
83 return currentTime;
84 }
85
86 /**
87 * @return true if the time is represented in wall-clock time.
88 */
89 boolean isWall() {
90 return type == WALL;
91 }
92
93 /**
94 * @return true if the time is represented in standard time.
95 */
96 boolean isSTD() {
97 return type == STD;
98 }
99
100 /**
101 * @return true if the time is represented in UTC time.
102 */
103 boolean isUTC() {
104 return type == UTC;
105 }
106
107 /**
108 * Converts the type to a string that represents the type in the
109 * SimpleTimeZone time mode. (e.g., "SimpleTimeZone.WALL_TIME").
110 * @return the converted string or null if the type is undefined.
111 */
112 String getTypeForSimpleTimeZone() {
113 String stz = "SimpleTimeZone.";
114 if (isWall()) {
115 return stz+"WALL_TIME";
116 }
117 else if (isSTD()) {
118 return stz+"STANDARD_TIME";
119 }
120 else if (isUTC()) {
121 return stz+"UTC_TIME";
122 }
123 else {
124 return null;
125 }
126 }
127
128 /**
129 * Converts the given Gregorian calendar field values to local time.
130 * Local time is represented by the amount of milliseconds from
131 * January 1, 1970 0:00 GMT.
132 * @param year the year value
133 * @param month the Month value
134 * @param day the day represented by {@link RuleDay}
135 * @param save the amount of daylight time in milliseconds
136 * @param gmtOffset the GMT offset in milliseconds
137 * @param time the time of the day represented by {@link Time}
138 * @return local time
139 */
140 static long getLocalTime(int year, Month month, RuleDay day, int save,
141 int gmtOffset, Time time) {
142 long t = time.getTime();
143
144 if (time.isSTD())
145 t = time.getTime() + save;
146 else if (time.isUTC())
147 t = time.getTime() + save + gmtOffset;
148
149 return getLocalTime(year, month, day, t);
150 }
151
152 /**
153 * Converts the given Gregorian calendar field values to local time.
154 * Local time is represented by the amount of milliseconds from
155 * January 1, 1970 0:00 GMT.
156 * @param year the year value
157 * @param month the Month value
158 * @param day the day value
159 * @param time the time of the day in milliseconds
160 * @return local time
161 */
162 static long getLocalTime(int year, Month month, int day, long time) {
163 CalendarDate date = gcal.newCalendarDate(null);
164 date.setDate(year, month.value(), day);
165 long millis = gcal.getTime(date);
166 return millis + time;
167 }
168
169 /**
170 * Equivalent to <code>getLocalTime(year, month, day, (long)time)</code>.
171 * @param year the year value
172 * @param month the Month value
173 * @param day the day value
174 * @param time the time of the day in milliseconds
175 * @return local time
176 */
177 static long getLocalTime(int year, Month month, int day, int time) {
178 return getLocalTime(year, month, day, (long)time);
179 }
180
181 /**
182 * Equivalent to {@link #getLocalTime(int, Month, RuleDay, int)
183 * getLocalTime(year, month, day, (int) time)}.
184 * @param year the year value
185 * @param month the Month value
186 * @param day the day represented by {@link RuleDay}
187 * @param time the time of the day represented by {@link Time}
188 * @return local time
189 */
190 static long getLocalTime(int year, Month month, RuleDay day, long time) {
191 return getLocalTime(year, month, day, (int) time);
192 }
193
194 /**
195 * Converts the given Gregorian calendar field values to local time.
196 * Local time is represented by the amount of milliseconds from
197 * January 1, 1970 0:00 GMT.
198 * @param year the year value
199 * @param month the Month value
200 * @param day the day represented by {@link RuleDay}
201 * @param time the time of the day represented by {@link Time}
202 * @return local time
203 */
204 static long getLocalTime(int year, Month month, RuleDay day, int time) {
205 CalendarDate cdate = gcal.newCalendarDate(null);
206 int monthValue = month.value();
207
208 if (day.isLast()) { // e.g., "lastSun"
209 cdate.setDate(year, monthValue, 1);
210 cdate.setDayOfMonth(gcal.getMonthLength(cdate));
211 cdate = gcal.getNthDayOfWeek(-1, day.getDayOfWeekNum(), cdate);
212 } else if (day.isLater()) { // e.g., "Sun>=1"
213 cdate.setDate(year, monthValue, day.getDay());
214 cdate = gcal.getNthDayOfWeek(1, day.getDayOfWeekNum(), cdate);
215 } else if (day.isExact()) {
216 cdate.setDate(year, monthValue, day.getDay());
217 } else if (day.isEarlier()) { // e.g., "Sun<=15"
218 cdate.setDate(year, monthValue, day.getDay());
219 cdate = gcal.getNthDayOfWeek(-1, day.getDayOfWeekNum(), cdate);
220 } else {
221 Main.panic("invalid day type: " + day);
222 }
223 return gcal.getTime(cdate) + time;
224 }
225
226 /**
227 * Parses the given "AT" field and constructs a Time object.
228 * @param the "AT" field string
229 * @return the Time object
230 */
231 static Time parse(String time) {
232 int sign;
233 int index = 0;
234 Time tm;
235
236 if (time.charAt(0) == '-') {
237 sign = -1;
238 index++;
239 } else {
240 sign = 1;
241 }
242 int val = 0;
243 int num = 0;
244 int countDelim = 0;
245 while (index < time.length()) {
246 char c = time.charAt(index++);
247 if (c == ':') {
248 val = val * 60 + num;
249 countDelim++;
250 num = 0;
251 continue;
252 }
253 int d = Character.digit(c, 10);
254 if (d == -1) {
255 --index;
256 break;
257 }
258 num = num * 10 + d;
259 }
260 val = val * 60 + num;
261 // convert val to second
262 for (; countDelim < 2; countDelim++) {
263 val *= 60;
264 }
265 tm = new Time((long)val * 1000 * sign);
266 if (index < time.length()) {
267 char c = time.charAt(index++);
268 if (c == 's') {
269 tm.setType(Time.STD);
270 } else if (c == 'u' || c == 'g' || c == 'z') {
271 tm.setType(Time.UTC);
272 } else if (c == 'w') {
273 tm.setType(Time.WALL);
274 } else {
275 Main.panic("unknown time mode: "+c);
276 }
277 } else {
278 tm.setType(Time.WALL);
279 }
280 return tm;
281 }
282
283 /**
284 * Converts the given milliseconds string to a "[+-]hh:mm" string.
285 * @param ms the milliseconds string
286 */
287 static String toGMTFormat(String ms) {
288 long sec = Long.parseLong(ms) / 1000;
289 char sign;
290 if (sec < 0) {
291 sign = '-';
292 sec = -sec;
293 } else {
294 sign = '+';
295 }
296 return String.format((Locale)null, "%c%02d:%02d",
297 sign, sec/3600, (sec%3600)/60);
298 }
299
300 /**
301 * Converts the given millisecond value to a string for a
302 * SimpleTimeZone parameter.
303 * @param ms the millisecond value
304 * @return the string in a human readable form
305 */
306 static String toFormedString(int ms) {
307 StringBuilder s = new StringBuilder();
308 boolean minus = false;
309
310 if (ms < 0) {
311 s.append("-");
312 minus = true;
313 ms = -ms;
314 } else if (ms == 0) {
315 return "0";
316 }
317
318 int hour = ms / (60 * 60 * 1000);
319 ms %= (60 * 60 * 1000);
320 int minute = ms / (60 * 1000);
321
322 if (hour != 0) {
323 if (minus && minute != 0) {
324 s.append("(");
325 }
326 s.append(Integer.toString(hour) + "*ONE_HOUR");
327 }
328
329 if (minute != 0) {
330 if (hour != 0) {
331 s.append("+");
332 }
333 s.append(Integer.toString(minute) + "*ONE_MINUTE");
334 if (minus && hour != 0) {
335 s.append(")");
336 }
337 }
338
339 return s.toString();
340 }
341 }