1 Clazz.declarePackage ("java.util");
\r
2 Clazz.load (["java.util.Calendar", "jssun.util.calendar.CalendarSystem", "$.Gregorian"], "java.util.GregorianCalendar", ["java.lang.ArrayIndexOutOfBoundsException", "$.IllegalArgumentException", "java.util.Date", "java.util.Locale", "$.TimeZone", "jssun.util.calendar.AbstractCalendar", "$.CalendarUtils", "$.ZoneInfo"], function () {
\r
3 c$ = Clazz.decorateAsClass (function () {
\r
4 this.gregorianCutover = -12219292800000;
\r
5 this.gregorianCutoverDate = 577736;
\r
6 this.gregorianCutoverYear = 1582;
\r
7 this.gregorianCutoverYearJulian = 1582;
\r
11 this.zoneOffsets = null;
\r
12 this.originalFields = null;
\r
13 this.cachedFixedDate = -9223372036854775808;
\r
14 Clazz.instantialize (this, arguments);
\r
15 }, java.util, "GregorianCalendar", java.util.Calendar);
\r
16 Clazz.makeConstructor (c$,
\r
18 this.construct (java.util.TimeZone.getDefaultRef (), java.util.Locale.getDefault ());
\r
19 this.setZoneShared (true);
\r
21 Clazz.makeConstructor (c$,
\r
23 this.construct (zone, java.util.Locale.getDefault ());
\r
24 }, "java.util.TimeZone");
\r
25 Clazz.makeConstructor (c$,
\r
26 function (aLocale) {
\r
27 this.construct (java.util.TimeZone.getDefaultRef (), aLocale);
\r
28 this.setZoneShared (true);
\r
29 }, "java.util.Locale");
\r
30 Clazz.makeConstructor (c$,
\r
31 function (zone, aLocale) {
\r
32 Clazz.superConstructor (this, java.util.GregorianCalendar, [zone, aLocale]);
\r
33 this.gdate = java.util.GregorianCalendar.gcal.newCalendarDate (zone);
\r
34 this.setTimeInMillis (System.currentTimeMillis ());
\r
35 }, "java.util.TimeZone,java.util.Locale");
\r
36 Clazz.makeConstructor (c$,
\r
37 function (year, month, dayOfMonth) {
\r
38 this.construct (year, month, dayOfMonth, 0, 0, 0, 0);
\r
40 Clazz.makeConstructor (c$,
\r
41 function (year, month, dayOfMonth, hourOfDay, minute) {
\r
42 this.construct (year, month, dayOfMonth, hourOfDay, minute, 0, 0);
\r
43 }, "~N,~N,~N,~N,~N");
\r
44 Clazz.makeConstructor (c$,
\r
45 function (year, month, dayOfMonth, hourOfDay, minute, second) {
\r
46 this.construct (year, month, dayOfMonth, hourOfDay, minute, second, 0);
\r
47 }, "~N,~N,~N,~N,~N,~N");
\r
48 Clazz.makeConstructor (c$,
\r
49 function (year, month, dayOfMonth, hourOfDay, minute, second, millis) {
\r
50 Clazz.superConstructor (this, java.util.GregorianCalendar);
\r
51 this.gdate = java.util.GregorianCalendar.gcal.newCalendarDate (this.getZone ());
\r
53 this.set (2, month);
\r
54 this.set (5, dayOfMonth);
\r
55 if (hourOfDay >= 12 && hourOfDay <= 23) {
\r
56 this.internalSet (9, 1);
\r
57 this.internalSet (10, hourOfDay - 12);
\r
59 this.internalSet (10, hourOfDay);
\r
60 }this.setFieldsComputed (1536);
\r
61 this.set (11, hourOfDay);
\r
62 this.set (12, minute);
\r
63 this.set (13, second);
\r
64 this.internalSet (14, millis);
\r
65 }, "~N,~N,~N,~N,~N,~N,~N");
\r
66 Clazz.defineMethod (c$, "getGregorianChange",
\r
68 return new java.util.Date (this.gregorianCutover);
\r
70 Clazz.defineMethod (c$, "isLeapYear",
\r
72 if ((year & 3) != 0) {
\r
74 }if (year > this.gregorianCutoverYear) {
\r
75 return (year % 100 != 0) || (year % 400 == 0);
\r
76 }if (year < this.gregorianCutoverYearJulian) {
\r
79 if (this.gregorianCutoverYear == this.gregorianCutoverYearJulian) {
\r
80 var d = this.getCalendarDate (this.gregorianCutoverDate);
\r
81 gregorian = d.getMonth () < 3;
\r
83 gregorian = year == this.gregorianCutoverYear;
\r
84 }return gregorian ? (year % 100 != 0) || (year % 400 == 0) : true;
\r
86 Clazz.defineMethod (c$, "equals",
\r
88 return Clazz.instanceOf (obj, java.util.GregorianCalendar) && Clazz.superCall (this, java.util.GregorianCalendar, "equals", [obj]) && this.gregorianCutover == (obj).gregorianCutover;
\r
90 Clazz.defineMethod (c$, "hashCode",
\r
92 return Clazz.superCall (this, java.util.GregorianCalendar, "hashCode", []) ^ this.gregorianCutoverDate;
\r
94 Clazz.overrideMethod (c$, "add",
\r
95 function (field, amount) {
\r
98 }if (field < 0 || field >= 15) {
\r
99 throw new IllegalArgumentException ();
\r
102 var year = this.internalGet (1);
\r
103 if (this.internalGetEra () == 1) {
\r
106 this.set (1, year);
\r
108 this.set (1, 1 - year);
\r
113 this.set (1, year);
\r
115 this.set (1, 1 - year);
\r
117 }}this.pinDayOfMonth ();
\r
118 } else if (field == 2) {
\r
119 var month = this.internalGet (2) + amount;
\r
120 var year = this.internalGet (1);
\r
123 y_amount = Clazz.doubleToInt (month / 12);
\r
125 y_amount = Clazz.doubleToInt ((month + 1) / 12) - 1;
\r
126 }if (y_amount != 0) {
\r
127 if (this.internalGetEra () == 1) {
\r
130 this.set (1, year);
\r
132 this.set (1, 1 - year);
\r
137 this.set (1, year);
\r
139 this.set (1, 1 - year);
\r
141 }}}if (month >= 0) {
\r
142 this.set (2, (month % 12));
\r
147 }this.set (2, 0 + month);
\r
148 }this.pinDayOfMonth ();
\r
149 } else if (field == 0) {
\r
150 var era = this.internalGet (0) + amount;
\r
155 }this.set (0, era);
\r
157 var delta = amount;
\r
182 delta = Clazz.doubleToInt (amount / 2);
\r
183 timeOfDay = 12 * (amount % 2);
\r
187 this.setTimeInMillis (this.time + delta);
\r
189 }var fd = this.getCurrentFixedDate ();
\r
190 timeOfDay += this.internalGet (11);
\r
192 timeOfDay += this.internalGet (12);
\r
194 timeOfDay += this.internalGet (13);
\r
196 timeOfDay += this.internalGet (14);
\r
197 if (timeOfDay >= 86400000) {
\r
199 timeOfDay -= 86400000;
\r
200 } else if (timeOfDay < 0) {
\r
202 timeOfDay += 86400000;
\r
204 var zoneOffset = this.internalGet (15) + this.internalGet (16);
\r
205 this.setTimeInMillis ((fd - 719163) * 86400000 + timeOfDay - zoneOffset);
\r
206 zoneOffset -= this.internalGet (15) + this.internalGet (16);
\r
207 if (zoneOffset != 0) {
\r
208 this.setTimeInMillis (this.time + zoneOffset);
\r
209 var fd2 = this.getCurrentFixedDate ();
\r
211 this.setTimeInMillis (this.time - zoneOffset);
\r
213 Clazz.defineMethod (c$, "roll",
\r
214 function (field, up) {
\r
215 this.roll (field, up ? 1 : -1);
\r
217 Clazz.defineMethod (c$, "roll",
\r
218 function (field, amount) {
\r
221 }if (field < 0 || field >= 15) {
\r
222 throw new IllegalArgumentException ();
\r
224 var min = this.getMinimum (field);
\r
225 var max = this.getMaximum (field);
\r
237 var unit = max + 1;
\r
238 var h = this.internalGet (field);
\r
239 var nh = (h + amount) % unit;
\r
242 }this.time += 3600000 * (nh - h);
\r
243 var d = this.calsys.getCalendarDate (this.time, this.getZone ());
\r
244 if (this.internalGet (5) != d.getDayOfMonth ()) {
\r
245 d.setDate (this.internalGet (1), this.internalGet (2) + 1, this.internalGet (5));
\r
248 }this.time = this.calsys.getTime (d);
\r
249 }var hourOfDay = d.getHours ();
\r
250 this.internalSet (field, hourOfDay % unit);
\r
252 this.internalSet (11, hourOfDay);
\r
254 this.internalSet (9, Clazz.doubleToInt (hourOfDay / 12));
\r
255 this.internalSet (10, hourOfDay % 12);
\r
256 }var zoneOffset = d.getZoneOffset ();
\r
257 var saving = d.getDaylightSaving ();
\r
258 this.internalSet (15, zoneOffset - saving);
\r
259 this.internalSet (16, saving);
\r
263 var mon = (this.internalGet (2) + amount) % 12;
\r
266 }this.set (2, mon);
\r
267 var monthLen = this.monthLength (mon);
\r
268 if (this.internalGet (5) > monthLen) {
\r
269 this.set (5, monthLen);
\r
273 var y = this.cdate.getNormalizedYear ();
\r
274 max = this.getActualMaximum (3);
\r
275 this.set (7, this.internalGet (7));
\r
276 var woy = this.internalGet (3);
\r
277 var value = woy + amount;
\r
278 if (value > min && value < max) {
\r
279 this.set (3, value);
\r
281 }var fd = this.getCurrentFixedDate ();
\r
282 var day1 = fd - (7 * (woy - min));
\r
283 if (this.calsys.getYearFromFixedDate (day1) != y) {
\r
285 }fd += 7 * (max - this.internalGet (3));
\r
286 if (this.calsys.getYearFromFixedDate (fd) != y) {
\r
291 var dow = this.internalGet (7) - this.getFirstDayOfWeek ();
\r
294 }var fd = this.getCurrentFixedDate ();
\r
297 month1 = fd - this.internalGet (5) + 1;
\r
298 monthLength = this.calsys.getMonthLength (this.cdate);
\r
299 var monthDay1st = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (month1 + 6, this.getFirstDayOfWeek ());
\r
300 if ((monthDay1st - month1) >= this.getMinimalDaysInFirstWeek ()) {
\r
302 }max = this.getActualMaximum (field);
\r
303 var value = java.util.GregorianCalendar.getRolledValue (this.internalGet (field), amount, 1, max) - 1;
\r
304 var nfd = monthDay1st + value * 7 + dow;
\r
305 if (nfd < month1) {
\r
307 } else if (nfd >= (month1 + monthLength)) {
\r
308 nfd = month1 + monthLength - 1;
\r
310 dayOfMonth = (nfd - month1) + 1;
\r
311 this.set (5, dayOfMonth);
\r
315 max = this.calsys.getMonthLength (this.cdate);
\r
319 max = this.getActualMaximum (field);
\r
323 var weekOfYear = this.internalGet (3);
\r
324 this.set (3, weekOfYear);
\r
330 var dom = this.internalGet (5);
\r
331 var monthLength = this.calsys.getMonthLength (this.cdate);
\r
332 var lastDays = monthLength % 7;
\r
333 max = Clazz.doubleToInt (monthLength / 7);
\r
334 var x = (dom - 1) % 7;
\r
335 if (x < lastDays) {
\r
337 }this.set (7, this.internalGet (7));
\r
340 this.set (field, java.util.GregorianCalendar.getRolledValue (this.internalGet (field), amount, min, max));
\r
342 Clazz.overrideMethod (c$, "getMinimum",
\r
344 return java.util.GregorianCalendar.MIN_VALUES[field];
\r
346 Clazz.overrideMethod (c$, "getMaximum",
\r
357 if (this.gregorianCutoverYear > 200) {
\r
359 }var gc = this.clone ();
\r
360 gc.setLenient (true);
\r
361 gc.setTimeInMillis (this.gregorianCutover);
\r
362 var v1 = gc.getActualMaximum (field);
\r
363 gc.setTimeInMillis (this.gregorianCutover - 1);
\r
364 var v2 = gc.getActualMaximum (field);
\r
365 return Math.max (java.util.GregorianCalendar.MAX_VALUES[field], Math.max (v1, v2));
\r
367 return java.util.GregorianCalendar.MAX_VALUES[field];
\r
369 Clazz.overrideMethod (c$, "getGreatestMinimum",
\r
371 return java.util.GregorianCalendar.MIN_VALUES[field];
\r
373 Clazz.overrideMethod (c$, "getLeastMaximum",
\r
384 var gc = this.clone ();
\r
385 gc.setLenient (true);
\r
386 gc.setTimeInMillis (this.gregorianCutover);
\r
387 var v1 = gc.getActualMaximum (field);
\r
388 gc.setTimeInMillis (this.gregorianCutover - 1);
\r
389 var v2 = gc.getActualMaximum (field);
\r
390 return Math.min (java.util.GregorianCalendar.LEAST_MAX_VALUES[field], Math.min (v1, v2));
\r
392 return java.util.GregorianCalendar.LEAST_MAX_VALUES[field];
\r
394 Clazz.overrideMethod (c$, "getActualMinimum",
\r
397 }return this.getMinimum (field);
\r
399 Clazz.overrideMethod (c$, "getActualMaximum",
\r
401 var fieldsForFixedMax = 130689;
\r
402 if ((130689 & (1 << field)) != 0) {
\r
403 return this.getMaximum (field);
\r
404 }var gc = this.getNormalizedCalendar ();
\r
405 var date = gc.cdate;
\r
406 var cal = gc.calsys;
\r
415 value = cal.getMonthLength (date);
\r
418 value = cal.getYearLength (date);
\r
422 dd = cal.newCalendarDate (java.util.TimeZone.NO_TIMEZONE);
\r
423 dd.setDate (date.getYear (), 1, 1);
\r
424 var dayOfWeek = cal.getDayOfWeek (dd);
\r
425 dayOfWeek -= this.getFirstDayOfWeek ();
\r
426 if (dayOfWeek < 0) {
\r
429 var magic = dayOfWeek + this.getMinimalDaysInFirstWeek () - 1;
\r
430 if ((magic == 6) || (date.isLeapYear () && (magic == 5 || magic == 12))) {
\r
434 dd = cal.newCalendarDate (null);
\r
435 dd.setDate (date.getYear (), date.getMonth (), 1);
\r
436 var dayOfWeek = cal.getDayOfWeek (dd);
\r
437 var monthLength = cal.getMonthLength (dd);
\r
438 dayOfWeek -= this.getFirstDayOfWeek ();
\r
439 if (dayOfWeek < 0) {
\r
441 }var nDaysFirstWeek = 7 - dayOfWeek;
\r
443 if (nDaysFirstWeek >= this.getMinimalDaysInFirstWeek ()) {
\r
445 }monthLength -= nDaysFirstWeek + 21;
\r
446 if (monthLength > 0) {
\r
448 if (monthLength > 7) {
\r
455 var dow = date.getDayOfWeek ();
\r
457 ndays = cal.getMonthLength (d);
\r
458 d.setDayOfMonth (1);
\r
460 dow1 = d.getDayOfWeek ();
\r
461 var x = dow - dow1;
\r
465 value = Clazz.doubleToInt ((ndays + 6) / 7);
\r
470 gc = this.clone ();
\r
471 }var current = gc.getYearOffsetInMillis ();
\r
472 if (gc.internalGetEra () == 1) {
\r
473 gc.setTimeInMillis (9223372036854775807);
\r
474 value = gc.get (1);
\r
475 var maxEnd = gc.getYearOffsetInMillis ();
\r
476 if (current > maxEnd) {
\r
479 var mincal = java.util.GregorianCalendar.gcal;
\r
480 dd = mincal.getCalendarDate (-9223372036854775808, this.getZone ());
\r
481 var maxEnd = (cal.getDayOfYear (dd) - 1) * 24 + dd.getHours ();
\r
483 maxEnd += dd.getMinutes ();
\r
485 maxEnd += dd.getSeconds ();
\r
487 maxEnd += dd.getMillis ();
\r
488 value = dd.getYear ();
\r
491 }if (current < maxEnd) {
\r
495 throw new ArrayIndexOutOfBoundsException (field);
\r
499 Clazz.defineMethod (c$, "getYearOffsetInMillis",
\r
501 var t = (this.internalGet (6) - 1) * 24;
\r
502 t += this.internalGet (11);
\r
504 t += this.internalGet (12);
\r
506 t += this.internalGet (13);
\r
508 return t + this.internalGet (14) - (this.internalGet (15) + this.internalGet (16));
\r
510 Clazz.defineMethod (c$, "clone",
\r
512 var other = Clazz.superCall (this, java.util.GregorianCalendar, "clone", []);
\r
513 other.gdate = this.gdate.clone ();
\r
514 if (this.cdate != null) {
\r
515 if (this.cdate !== this.gdate) {
\r
516 other.cdate = this.cdate.clone ();
\r
518 other.cdate = other.gdate;
\r
519 }}other.originalFields = null;
\r
520 other.zoneOffsets = null;
\r
523 Clazz.defineMethod (c$, "getTimeZone",
\r
525 var zone = Clazz.superCall (this, java.util.GregorianCalendar, "getTimeZone", []);
\r
526 this.gdate.setZone (zone);
\r
527 if (this.cdate != null && this.cdate !== this.gdate) {
\r
528 this.cdate.setZone (zone);
\r
531 Clazz.defineMethod (c$, "setTimeZone",
\r
533 Clazz.superCall (this, java.util.GregorianCalendar, "setTimeZone", [zone]);
\r
534 this.gdate.setZone (zone);
\r
535 if (this.cdate != null && this.cdate !== this.gdate) {
\r
536 this.cdate.setZone (zone);
\r
537 }}, "java.util.TimeZone");
\r
538 Clazz.defineMethod (c$, "computeFields",
\r
541 if (this.isPartiallyNormalized ()) {
\r
542 mask = this.getSetStateFields ();
\r
543 var fieldMask = ~mask & 131071;
\r
544 if (fieldMask != 0 || this.calsys == null) {
\r
545 mask |= this.computeFields (fieldMask, mask & (98304));
\r
548 this.computeFields (mask, 0);
\r
549 }this.setFieldsComputed (mask);
\r
551 Clazz.defineMethod (c$, "computeFields",
\r
552 function (fieldMask, tzMask) {
\r
553 var zoneOffset = 0;
\r
554 var tz = this.getZone ();
\r
555 if (this.zoneOffsets == null) {
\r
556 this.zoneOffsets = Clazz.newIntArray (2, 0);
\r
557 }if (tzMask != (98304)) {
\r
558 if (Clazz.instanceOf (tz, jssun.util.calendar.ZoneInfo)) {
\r
559 zoneOffset = (tz).getOffsets (this.time, this.zoneOffsets);
\r
561 zoneOffset = tz.getOffset (this.time);
\r
562 this.zoneOffsets[0] = tz.getRawOffset ();
\r
563 this.zoneOffsets[1] = zoneOffset - this.zoneOffsets[0];
\r
564 }}if (tzMask != 0) {
\r
565 if (java.util.Calendar.isFieldSet (tzMask, 15)) {
\r
566 this.zoneOffsets[0] = this.internalGet (15);
\r
567 }if (java.util.Calendar.isFieldSet (tzMask, 16)) {
\r
568 this.zoneOffsets[1] = this.internalGet (16);
\r
569 }zoneOffset = this.zoneOffsets[0] + this.zoneOffsets[1];
\r
570 }var fixedDate = Clazz.doubleToInt (zoneOffset / 86400000);
\r
571 var timeOfDay = zoneOffset % 86400000;
\r
572 fixedDate += Clazz.doubleToInt (this.time / 86400000);
\r
573 timeOfDay += (this.time % 86400000);
\r
574 if (timeOfDay >= 86400000) {
\r
575 timeOfDay -= 86400000;
\r
578 while (timeOfDay < 0) {
\r
579 timeOfDay += 86400000;
\r
582 }fixedDate += 719163;
\r
585 if (fixedDate != this.cachedFixedDate) {
\r
586 java.util.GregorianCalendar.gcal.getCalendarDateFromFixedDate (this.gdate, fixedDate);
\r
587 this.cachedFixedDate = fixedDate;
\r
588 }year = this.gdate.getYear ();
\r
592 }this.calsys = java.util.GregorianCalendar.gcal;
\r
593 this.cdate = this.gdate;
\r
594 this.internalSet (0, era);
\r
595 this.internalSet (1, year);
\r
596 var mask = fieldMask | (3);
\r
597 var month = this.cdate.getMonth () - 1;
\r
598 var dayOfMonth = this.cdate.getDayOfMonth ();
\r
599 if ((fieldMask & (164)) != 0) {
\r
600 this.internalSet (2, month);
\r
601 this.internalSet (5, dayOfMonth);
\r
602 this.internalSet (7, this.cdate.getDayOfWeek ());
\r
604 }if ((fieldMask & (32256)) != 0) {
\r
605 if (timeOfDay != 0) {
\r
606 var hours = Clazz.doubleToInt (timeOfDay / 3600000);
\r
607 this.internalSet (11, hours);
\r
608 this.internalSet (9, Clazz.doubleToInt (hours / 12));
\r
609 this.internalSet (10, hours % 12);
\r
610 var r = timeOfDay % 3600000;
\r
611 this.internalSet (12, Clazz.doubleToInt (r / 60000));
\r
613 this.internalSet (13, Clazz.doubleToInt (r / 1000));
\r
614 this.internalSet (14, r % 1000);
\r
616 this.internalSet (11, 0);
\r
617 this.internalSet (9, 0);
\r
618 this.internalSet (10, 0);
\r
619 this.internalSet (12, 0);
\r
620 this.internalSet (13, 0);
\r
621 this.internalSet (14, 0);
\r
623 }if ((fieldMask & (98304)) != 0) {
\r
624 this.internalSet (15, this.zoneOffsets[0]);
\r
625 this.internalSet (16, this.zoneOffsets[1]);
\r
627 }if ((fieldMask & (344)) != 0) {
\r
628 var normalizedYear = this.cdate.getNormalizedYear ();
\r
629 var fixedDateJan1 = this.calsys.getFixedDate (normalizedYear, 1, 1, this.cdate);
\r
630 var dayOfYear = (fixedDate - fixedDateJan1) + 1;
\r
631 var fixedDateMonth1 = fixedDate - dayOfMonth + 1;
\r
632 var cutoverYear = (this.calsys === java.util.GregorianCalendar.gcal) ? this.gregorianCutoverYear : this.gregorianCutoverYearJulian;
\r
633 var relativeDayOfMonth = dayOfMonth - 1;
\r
634 if (normalizedYear == cutoverYear) {
\r
635 var realDayOfYear = (fixedDate - fixedDateJan1) + 1;
\r
636 dayOfYear = realDayOfYear;
\r
637 relativeDayOfMonth = (fixedDate - fixedDateMonth1);
\r
638 }this.internalSet (6, dayOfYear);
\r
639 this.internalSet (8, Clazz.doubleToInt (relativeDayOfMonth / 7) + 1);
\r
640 var weekOfYear = this.getWeekNumber (fixedDateJan1, fixedDate);
\r
641 if (weekOfYear == 0) {
\r
642 var fixedDec31 = fixedDateJan1 - 1;
\r
644 prevJan1 = fixedDateJan1 - 365;
\r
645 if (jssun.util.calendar.CalendarUtils.isGregorianLeapYear (normalizedYear - 1)) {
\r
647 }weekOfYear = this.getWeekNumber (prevJan1, fixedDec31);
\r
649 if (normalizedYear > this.gregorianCutoverYear || normalizedYear < (this.gregorianCutoverYearJulian - 1)) {
\r
650 if (weekOfYear >= 52) {
\r
651 var nextJan1 = fixedDateJan1 + 365;
\r
652 if (this.cdate.isLeapYear ()) {
\r
654 }var nextJan1st = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (nextJan1 + 6, this.getFirstDayOfWeek ());
\r
655 var ndays = (nextJan1st - nextJan1);
\r
656 if (ndays >= this.getMinimalDaysInFirstWeek () && fixedDate >= (nextJan1st - 7)) {
\r
659 var calForJan1 = this.calsys;
\r
660 var nextYear = normalizedYear + 1;
\r
661 var nextJan1 = calForJan1.getFixedDate (nextYear, 1, 1, null);
\r
662 if (nextJan1 < fixedDate) {
\r
663 nextJan1 = this.gregorianCutoverDate;
\r
664 calForJan1 = java.util.GregorianCalendar.gcal;
\r
665 }var nextJan1st = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (nextJan1 + 6, this.getFirstDayOfWeek ());
\r
666 var ndays = (nextJan1st - nextJan1);
\r
667 if (ndays >= this.getMinimalDaysInFirstWeek () && fixedDate >= (nextJan1st - 7)) {
\r
669 }}}this.internalSet (3, weekOfYear);
\r
670 this.internalSet (4, this.getWeekNumber (fixedDateMonth1, fixedDate));
\r
674 Clazz.defineMethod (c$, "getWeekNumber",
\r
675 function (fixedDay1, fixedDate) {
\r
676 var fixedDay1st = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (fixedDay1 + 6, this.getFirstDayOfWeek ());
\r
677 var ndays = (fixedDay1st - fixedDay1);
\r
678 if (ndays >= this.getMinimalDaysInFirstWeek ()) {
\r
680 }var normalizedDayOfPeriod = (fixedDate - fixedDay1st);
\r
681 if (normalizedDayOfPeriod >= 0) {
\r
682 return Clazz.doubleToInt (normalizedDayOfPeriod / 7) + 1;
\r
683 }return jssun.util.calendar.CalendarUtils.floorDivide (normalizedDayOfPeriod, 7) + 1;
\r
685 Clazz.overrideMethod (c$, "computeTime",
\r
687 if (!this.isLenient ()) {
\r
688 if (this.originalFields == null) {
\r
689 this.originalFields = Clazz.newIntArray (17, 0);
\r
690 }for (var field = 0; field < 17; field++) {
\r
691 var value = this.internalGet (field);
\r
692 if (this.isExternallySet (field)) {
\r
693 if (value < this.getMinimum (field) || value > this.getMaximum (field)) {
\r
694 throw new IllegalArgumentException (java.util.Calendar.getFieldName (field));
\r
695 }}this.originalFields[field] = value;
\r
697 }var fieldMask = this.selectFields ();
\r
698 var year = this.isSet (1) ? this.internalGet (1) : 1970;
\r
699 var era = this.internalGetEra ();
\r
702 } else if (era != 1) {
\r
703 throw new IllegalArgumentException ("Invalid era");
\r
704 }if (year <= 0 && !this.isSet (0)) {
\r
706 this.setFieldsComputed (1);
\r
707 }var timeOfDay = 0;
\r
708 if (java.util.Calendar.isFieldSet (fieldMask, 11)) {
\r
709 timeOfDay += this.internalGet (11);
\r
711 timeOfDay += this.internalGet (10);
\r
712 if (java.util.Calendar.isFieldSet (fieldMask, 9)) {
\r
713 timeOfDay += 12 * this.internalGet (9);
\r
715 timeOfDay += this.internalGet (12);
\r
717 timeOfDay += this.internalGet (13);
\r
719 timeOfDay += this.internalGet (14);
\r
720 var fixedDate = Clazz.doubleToInt (timeOfDay / 86400000);
\r
721 timeOfDay %= 86400000;
\r
722 while (timeOfDay < 0) {
\r
723 timeOfDay += 86400000;
\r
726 calculateFixedDate : {
\r
728 gfd = fixedDate + this.getFixedDate (java.util.GregorianCalendar.gcal, year, fieldMask);
\r
730 break calculateFixedDate;
\r
731 }var millis = (fixedDate - 719163) * 86400000 + timeOfDay;
\r
732 var zone = this.getZone ();
\r
733 if (this.zoneOffsets == null) {
\r
734 this.zoneOffsets = Clazz.newIntArray (2, 0);
\r
735 }var tzMask = fieldMask & (98304);
\r
736 if (tzMask != (98304)) {
\r
737 if (Clazz.instanceOf (zone, jssun.util.calendar.ZoneInfo)) {
\r
738 (zone).getOffsetsByWall (millis, this.zoneOffsets);
\r
740 var gmtOffset = java.util.Calendar.isFieldSet (fieldMask, 15) ? this.internalGet (15) : zone.getRawOffset ();
\r
741 zone.getOffsets (millis - gmtOffset, this.zoneOffsets);
\r
742 }}if (tzMask != 0) {
\r
743 if (java.util.Calendar.isFieldSet (tzMask, 15)) {
\r
744 this.zoneOffsets[0] = this.internalGet (15);
\r
745 }if (java.util.Calendar.isFieldSet (tzMask, 16)) {
\r
746 this.zoneOffsets[1] = this.internalGet (16);
\r
747 }}millis -= this.zoneOffsets[0] + this.zoneOffsets[1];
\r
748 this.time = millis;
\r
749 var mask = this.computeFields (fieldMask | this.getSetStateFields (), tzMask);
\r
750 if (!this.isLenient ()) {
\r
751 for (var field = 0; field < 17; field++) {
\r
752 if (!this.isExternallySet (field)) {
\r
754 }if (this.originalFields[field] != this.internalGet (field)) {
\r
755 System.arraycopy (this.originalFields, 0, this.fields, 0, this.fields.length);
\r
756 throw new IllegalArgumentException (java.util.Calendar.getFieldName (field));
\r
758 }this.setFieldsNormalized (mask);
\r
760 Clazz.defineMethod (c$, "getFixedDate",
\r
761 function (cal, year, fieldMask) {
\r
763 if (java.util.Calendar.isFieldSet (fieldMask, 2)) {
\r
764 month = this.internalGet (2);
\r
766 year += Clazz.doubleToInt (month / 12);
\r
768 } else if (month < 0) {
\r
769 var rem = Clazz.newIntArray (1, 0);
\r
770 year += jssun.util.calendar.CalendarUtils.floorDivide (month, 12, rem);
\r
772 }}var fixedDate = cal.getFixedDate (year, month + 1, 1, cal === java.util.GregorianCalendar.gcal ? this.gdate : null);
\r
773 if (java.util.Calendar.isFieldSet (fieldMask, 2)) {
\r
774 if (java.util.Calendar.isFieldSet (fieldMask, 5)) {
\r
775 if (this.isSet (5)) {
\r
776 fixedDate += this.internalGet (5);
\r
779 if (java.util.Calendar.isFieldSet (fieldMask, 4)) {
\r
780 var firstDayOfWeek = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (fixedDate + 6, this.getFirstDayOfWeek ());
\r
781 if ((firstDayOfWeek - fixedDate) >= this.getMinimalDaysInFirstWeek ()) {
\r
782 firstDayOfWeek -= 7;
\r
783 }if (java.util.Calendar.isFieldSet (fieldMask, 7)) {
\r
784 firstDayOfWeek = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (firstDayOfWeek + 6, this.internalGet (7));
\r
785 }fixedDate = firstDayOfWeek + 7 * (this.internalGet (4) - 1);
\r
788 if (java.util.Calendar.isFieldSet (fieldMask, 7)) {
\r
789 dayOfWeek = this.internalGet (7);
\r
791 dayOfWeek = this.getFirstDayOfWeek ();
\r
793 if (java.util.Calendar.isFieldSet (fieldMask, 8)) {
\r
794 dowim = this.internalGet (8);
\r
798 fixedDate = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (fixedDate + (7 * dowim) - 1, dayOfWeek);
\r
800 var lastDate = this.monthLength (month, year) + (7 * (dowim + 1));
\r
801 fixedDate = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (fixedDate + lastDate - 1, dayOfWeek);
\r
803 if (year == this.gregorianCutoverYear && cal === java.util.GregorianCalendar.gcal && fixedDate < this.gregorianCutoverDate && this.gregorianCutoverYear != this.gregorianCutoverYearJulian) {
\r
804 fixedDate = this.gregorianCutoverDate;
\r
805 }if (java.util.Calendar.isFieldSet (fieldMask, 6)) {
\r
806 fixedDate += this.internalGet (6);
\r
809 var firstDayOfWeek = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (fixedDate + 6, this.getFirstDayOfWeek ());
\r
810 if ((firstDayOfWeek - fixedDate) >= this.getMinimalDaysInFirstWeek ()) {
\r
811 firstDayOfWeek -= 7;
\r
812 }if (java.util.Calendar.isFieldSet (fieldMask, 7)) {
\r
813 var dayOfWeek = this.internalGet (7);
\r
814 if (dayOfWeek != this.getFirstDayOfWeek ()) {
\r
815 firstDayOfWeek = jssun.util.calendar.AbstractCalendar.getDayOfWeekDateOnOrBefore (firstDayOfWeek + 6, dayOfWeek);
\r
816 }}fixedDate = firstDayOfWeek + 7 * (this.internalGet (3) - 1);
\r
817 }}return fixedDate;
\r
818 }, "jssun.util.calendar.BaseCalendar,~N,~N");
\r
819 Clazz.defineMethod (c$, "getNormalizedCalendar",
\r
822 if (this.isFullyNormalized ()) {
\r
825 gc = this.clone ();
\r
826 gc.setLenient (true);
\r
830 Clazz.defineMethod (c$, "getCalendarDate",
\r
832 var cal = java.util.GregorianCalendar.gcal;
\r
833 var d = cal.newCalendarDate (java.util.TimeZone.NO_TIMEZONE);
\r
834 cal.getCalendarDateFromFixedDate (d, fd);
\r
837 Clazz.defineMethod (c$, "monthLength",
\r
838 function (month, year) {
\r
839 return this.isLeapYear (year) ? java.util.GregorianCalendar.LEAP_MONTH_LENGTH[month] : java.util.GregorianCalendar.MONTH_LENGTH[month];
\r
841 Clazz.defineMethod (c$, "monthLength",
\r
843 var year = this.internalGet (1);
\r
844 if (this.internalGetEra () == 0) {
\r
846 }return this.monthLength (month, year);
\r
848 Clazz.defineMethod (c$, "pinDayOfMonth",
\r
850 var year = this.internalGet (1);
\r
852 if (year > this.gregorianCutoverYear || year < this.gregorianCutoverYearJulian) {
\r
853 monthLen = this.monthLength (this.internalGet (2));
\r
855 var gc = this.getNormalizedCalendar ();
\r
856 monthLen = gc.getActualMaximum (5);
\r
857 }var dom = this.internalGet (5);
\r
858 if (dom > monthLen) {
\r
859 this.set (5, monthLen);
\r
861 Clazz.defineMethod (c$, "getCurrentFixedDate",
\r
863 return (this.calsys === java.util.GregorianCalendar.gcal) ? this.cachedFixedDate : this.calsys.getFixedDate (this.cdate);
\r
865 c$.getRolledValue = Clazz.defineMethod (c$, "getRolledValue",
\r
866 function (value, amount, min, max) {
\r
867 var range = max - min + 1;
\r
869 var n = value + amount;
\r
872 } else if (n < min) {
\r
876 Clazz.defineMethod (c$, "internalGetEra",
\r
878 return this.isSet (0) ? this.internalGet (0) : 1;
\r
880 Clazz.defineStatics (c$,
\r
885 "EPOCH_OFFSET", 719163,
\r
886 "EPOCH_YEAR", 1970,
\r
887 "MONTH_LENGTH", Clazz.newIntArray (-1, [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]),
\r
888 "LEAP_MONTH_LENGTH", Clazz.newIntArray (-1, [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]),
\r
889 "ONE_SECOND", 1000,
\r
890 "ONE_MINUTE", 60000,
\r
891 "ONE_HOUR", 3600000,
\r
892 "ONE_DAY", 86400000,
\r
893 "MIN_VALUES", Clazz.newIntArray (-1, [0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, -46800000, 0]),
\r
894 "LEAST_MAX_VALUES", Clazz.newIntArray (-1, [1, 292269054, 11, 52, 4, 28, 365, 7, 4, 1, 11, 23, 59, 59, 999, 50400000, 1200000]),
\r
895 "MAX_VALUES", Clazz.newIntArray (-1, [1, 292278994, 11, 53, 6, 31, 366, 7, 6, 1, 11, 23, 59, 59, 999, 50400000, 7200000]));
\r
896 c$.gcal = c$.prototype.gcal = jssun.util.calendar.CalendarSystem.getGregorianCalendar ();
\r
897 Clazz.defineStatics (c$,
\r
898 "DEFAULT_GREGORIAN_CUTOVER", -12219292800000);
\r