1 /* java.util.GregorianCalendar 2 Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004, 2007 3 Free Software Foundation, Inc. 4 5 This file is part of GNU Classpath. 6 7 GNU Classpath is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GNU Classpath is distributed in the hope that it will be useful, but 13 WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GNU Classpath; see the file COPYING. If not, write to the 19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20 02110-1301 USA. 21 22 Linking this library statically or dynamically with other modules is 23 making a combined work based on this library. Thus, the terms and 24 conditions of the GNU General Public License cover the whole 25 combination. 26 27 As a special exception, the copyright holders of this library give you 28 permission to link this library with independent modules to produce an 29 executable, regardless of the license terms of these independent 30 modules, and to copy and distribute the resulting executable under 31 terms of your choice, provided that you also meet, for each linked 32 independent module, the terms and conditions of the license of that 33 module. An independent module is a module which is not derived from 34 or based on this library. If you modify this library, you may extend 35 this exception to your version of the library, but you are not 36 obligated to do so. If you do not wish to do so, delete this 37 exception statement from your version. */ 38 39 40 package java.util; 41 42 43 /** 44 * <p> 45 * This class represents the Gregorian calendar, that is used in most 46 * countries all over the world. It does also handle the Julian calendar 47 * for dates smaller than the date of the change to the Gregorian calendar. 48 * The Gregorian calendar differs from the Julian calendar by a different 49 * leap year rule (no leap year every 100 years, except if year is divisible 50 * by 400). 51 * </p> 52 * <p> 53 * This change date is different from country to country, and can be changed with 54 * <code>setGregorianChange</code>. The first countries to adopt the Gregorian 55 * calendar did so on the 15th of October, 1582. This date followed October 56 * the 4th, 1582 in the Julian calendar system. The non-existant days that were 57 * omitted when the change took place are interpreted as Gregorian dates. 58 * </p> 59 * <p> 60 * Prior to the changeover date, New Year's Day occurred on the 25th of March. 61 * However, this class always takes New Year's Day as being the 1st of January. 62 * Client code should manually adapt the year value, if required, for dates 63 * between January the 1st and March the 24th in years prior to the changeover. 64 * </p> 65 * <p> 66 * Any date infinitely forwards or backwards in time can be represented by 67 * this class. A <em>proleptic</em> calendar system is used, which allows 68 * future dates to be created via the existing rules. This allows meaningful 69 * and consistent dates to be produced for all years. However, dates are only 70 * historically accurate following March the 1st, 4AD when the Julian calendar 71 * system was adopted. Prior to this, leap year rules were applied erraticly. 72 * </p> 73 * <p> 74 * There are two eras available for the Gregorian calendar, namely BC and AD. 75 * </p> 76 * <p> 77 * Weeks are defined as a period of seven days, beginning on the first day 78 * of the week, as returned by <code>getFirstDayOfWeek()</code>, and ending 79 * on the day prior to this. 80 * </p> 81 * <p> 82 * The weeks of the year are numbered from 1 to a possible 53. The first week 83 * of the year is defined as the first week that contains at least the minimum 84 * number of days of the first week in the new year (retrieved via 85 * <code>getMinimalDaysInFirstWeek()</code>). All weeks after this are numbered 86 * from 2 onwards. 87 * </p> 88 * <p> 89 * For example, take the year 2004. It began on a Thursday. The first week 90 * of 2004 depends both on where a week begins and how long it must minimally 91 * last. Let's say that the week begins on a Monday and must have a minimum 92 * of 5 days. In this case, the first week begins on Monday, the 5th of January. 93 * The first 4 days (Thursday to Sunday) are not eligible, as they are too few 94 * to make up the minimum number of days of the first week which must be in 95 * the new year. If the minimum was lowered to 4 days, then the first week 96 * would instead begin on Monday, the 29th of December, 2003. This first week 97 * has 4 of its days in the new year, and is now eligible. 98 * </p> 99 * <p> 100 * The weeks of the month are numbered from 0 to a possible 6. The first week 101 * of the month (numbered 1) is a set of days, prior to the first day of the week, 102 * which number at least the minimum number of days in a week. Unlike the first 103 * week of the year, the first week of the month only uses days from that particular 104 * month. As a consequence, it may have a variable number of days (from the minimum 105 * number required up to a full week of 7) and it need not start on the first day of 106 * the week. It must, however, be following by the first day of the week, as this 107 * marks the beginning of week 2. Any days of the month which occur prior to the 108 * first week (because the first day of the week occurs before the minimum number 109 * of days is met) are seen as week 0. 110 * </p> 111 * <p> 112 * Again, we will take the example of the year 2004 to demonstrate this. September 113 * 2004 begins on a Wednesday. Taking our first day of the week as Monday, and the 114 * minimum length of the first week as 6, we find that week 1 runs from Monday, 115 * the 6th of September to Sunday the 12th. Prior to the 6th, there are only 116 * 5 days (Wednesday through to Sunday). This is too small a number to meet the 117 * minimum, so these are classed as being days in week 0. Week 2 begins on the 118 * 13th, and so on. This changes if we reduce the minimum to 5. In this case, 119 * week 1 is a truncated week from Wednesday the 1st to Sunday the 5th, and week 120 * 0 doesn't exist. The first seven day week is week 2, starting on the 6th. 121 * </p> 122 * <p> 123 * On using the <code>clear()</code> method, the Gregorian calendar returns 124 * to its default value of the 1st of January, 1970 AD 00:00:00 (the epoch). 125 * The day of the week is set to the correct day for that particular time. 126 * The day is also the first of the month, and the date is in week 0. 127 * </p> 128 * 129 * @see Calendar 130 * @see TimeZone 131 * @see Calendar#getFirstDayOfWeek() 132 * @see Calendar#getMinimalDaysInFirstWeek() 133 */ 134 public class GregorianCalendar extends Calendar 135 { 136 /** 137 * Constant representing the era BC (Before Christ). 138 */ 139 public static final int BC = 0; 140 141 /** 142 * Constant representing the era AD (Anno Domini). 143 */ 144 public static final int AD = 1; 145 146 /** 147 * The point at which the Gregorian calendar rules were used. 148 * This may be changed by using setGregorianChange; 149 * The default is midnight (UTC) on October 5, 1582 (Julian), 150 * or October 15, 1582 (Gregorian). 151 * 152 * @serial the changeover point from the Julian calendar 153 * system to the Gregorian. 154 */ 155 private long gregorianCutover = (new Date((24 * 60 * 60 * 1000L) * (((1582 * (365 * 4 156 + 1)) / 4 157 + (java.util.Calendar.OCTOBER * (31 158 + 30 + 31 + 30 + 31) - 9) / 5 + 5) 159 - ((1970 * (365 * 4 + 1)) / 4 + 1 160 - 13)))).getTime(); 161 162 /** 163 * For compatability with Sun's JDK. 164 */ 165 static final long serialVersionUID = -8125100834729963327L; 166 167 /** 168 * Days in the epoch. Relative Jan 1, year '0' which is not a leap year. 169 * (although there is no year zero, this does not matter.) 170 * This is consistent with the formula: 171 * = (year-1)*365L + ((year-1) >> 2) 172 * 173 * Plus the gregorian correction: 174 * Math.floor((year-1) / 400.) - Math.floor((year-1) / 100.); 175 * For a correct julian date, the correction is -2 instead. 176 * 177 * The gregorian cutover in 1582 was 10 days, so by calculating the 178 * correction from year zero, we have 15 non-leap days (even centuries) 179 * minus 3 leap days (year 400,800,1200) = 12. Subtracting two corrects 180 * this to the correct number 10. 181 */ 182 private static final int EPOCH_DAYS = 719162; 183 184 /** 185 * Constructs a new GregorianCalender representing the current 186 * time, using the default time zone and the default locale. 187 */ GregorianCalendar()188 public GregorianCalendar() 189 { 190 this(TimeZone.getDefault(), Locale.getDefault()); 191 } 192 193 /** 194 * Constructs a new GregorianCalender representing the current 195 * time, using the specified time zone and the default locale. 196 * 197 * @param zone a time zone. 198 */ GregorianCalendar(TimeZone zone)199 public GregorianCalendar(TimeZone zone) 200 { 201 this(zone, Locale.getDefault()); 202 } 203 204 /** 205 * Constructs a new GregorianCalender representing the current 206 * time, using the default time zone and the specified locale. 207 * 208 * @param locale a locale. 209 */ GregorianCalendar(Locale locale)210 public GregorianCalendar(Locale locale) 211 { 212 this(TimeZone.getDefault(), locale); 213 } 214 215 /** 216 * Constructs a new GregorianCalender representing the current 217 * time with the given time zone and the given locale. 218 * 219 * @param zone a time zone. 220 * @param locale a locale. 221 */ GregorianCalendar(TimeZone zone, Locale locale)222 public GregorianCalendar(TimeZone zone, Locale locale) 223 { 224 this(zone, locale, false); 225 setTimeInMillis(System.currentTimeMillis()); 226 } 227 228 /** 229 * Common constructor that all constructors should call. 230 * @param zone a time zone. 231 * @param locale a locale. 232 * @param unused unused parameter to make the signature differ from 233 * the public constructor (TimeZone, Locale). 234 */ GregorianCalendar(TimeZone zone, Locale locale, boolean unused)235 private GregorianCalendar(TimeZone zone, Locale locale, boolean unused) 236 { 237 super(zone, locale); 238 } 239 240 /** 241 * Constructs a new GregorianCalendar representing midnight on the 242 * given date with the default time zone and locale. 243 * 244 * @param year corresponds to the YEAR time field. 245 * @param month corresponds to the MONTH time field. 246 * @param day corresponds to the DAY time field. 247 */ GregorianCalendar(int year, int month, int day)248 public GregorianCalendar(int year, int month, int day) 249 { 250 this(TimeZone.getDefault(), Locale.getDefault(), false); 251 set(year, month, day); 252 } 253 254 /** 255 * Constructs a new GregorianCalendar representing midnight on the 256 * given date with the default time zone and locale. 257 * 258 * @param year corresponds to the YEAR time field. 259 * @param month corresponds to the MONTH time field. 260 * @param day corresponds to the DAY time field. 261 * @param hour corresponds to the HOUR_OF_DAY time field. 262 * @param minute corresponds to the MINUTE time field. 263 */ GregorianCalendar(int year, int month, int day, int hour, int minute)264 public GregorianCalendar(int year, int month, int day, int hour, int minute) 265 { 266 this(TimeZone.getDefault(), Locale.getDefault(), false); 267 set(year, month, day, hour, minute); 268 } 269 270 /** 271 * Constructs a new GregorianCalendar representing midnight on the 272 * given date with the default time zone and locale. 273 * 274 * @param year corresponds to the YEAR time field. 275 * @param month corresponds to the MONTH time field. 276 * @param day corresponds to the DAY time field. 277 * @param hour corresponds to the HOUR_OF_DAY time field. 278 * @param minute corresponds to the MINUTE time field. 279 * @param second corresponds to the SECOND time field. 280 */ GregorianCalendar(int year, int month, int day, int hour, int minute, int second)281 public GregorianCalendar(int year, int month, int day, int hour, int minute, 282 int second) 283 { 284 this(TimeZone.getDefault(), Locale.getDefault(), false); 285 set(year, month, day, hour, minute, second); 286 } 287 288 /** 289 * Sets the date of the switch from Julian dates to Gregorian dates. 290 * You can use <code>new Date(Long.MAX_VALUE)</code> to use a pure 291 * Julian calendar, or <code>Long.MIN_VALUE</code> for a pure Gregorian 292 * calendar. 293 * 294 * @param date the date of the change. 295 */ setGregorianChange(Date date)296 public void setGregorianChange(Date date) 297 { 298 gregorianCutover = date.getTime(); 299 } 300 301 /** 302 * Gets the date of the switch from Julian dates to Gregorian dates. 303 * 304 * @return the date of the change. 305 */ getGregorianChange()306 public final Date getGregorianChange() 307 { 308 return new Date(gregorianCutover); 309 } 310 311 /** 312 * <p> 313 * Determines if the given year is a leap year. The result is 314 * undefined if the Gregorian change took place in 1800, so that 315 * the end of February is skipped, and that year is specified. 316 * (well...). 317 * </p> 318 * <p> 319 * To specify a year in the BC era, use a negative value calculated 320 * as 1 - y, where y is the required year in BC. So, 1 BC is 0, 321 * 2 BC is -1, 3 BC is -2, etc. 322 * </p> 323 * 324 * @param year a year (use a negative value for BC). 325 * @return true, if the given year is a leap year, false otherwise. 326 */ isLeapYear(int year)327 public boolean isLeapYear(int year) 328 { 329 // Only years divisible by 4 can be leap years 330 if ((year & 3) != 0) 331 return false; 332 333 // Is the leap-day a Julian date? Then it's a leap year 334 if (! isGregorian(year, 31 + 29 - 1)) 335 return true; 336 337 // Apply gregorian rules otherwise 338 return ((year % 100) != 0 || (year % 400) == 0); 339 } 340 341 /** 342 * Retrieves the day of the week corresponding to the specified 343 * day of the specified year. 344 * 345 * @param year the year in which the dayOfYear occurs. 346 * @param dayOfYear the day of the year (an integer between 0 and 347 * and 366) 348 */ getWeekDay(int year, int dayOfYear)349 private int getWeekDay(int year, int dayOfYear) 350 { 351 boolean greg = isGregorian(year, dayOfYear); 352 int day = (int) getLinearDay(year, dayOfYear, greg); 353 354 // The epoch was a thursday. 355 int weekday = (day + THURSDAY) % 7; 356 if (weekday <= 0) 357 weekday += 7; 358 return weekday; 359 } 360 361 /** 362 * Returns the day of the week for the first day of a given month (0..11) 363 */ getFirstDayOfMonth(int year, int month)364 private int getFirstDayOfMonth(int year, int month) 365 { 366 int[] dayCount = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; 367 368 if (month > 11) 369 { 370 year += (month / 12); 371 month = month % 12; 372 } 373 374 if (month < 0) 375 { 376 year += (int) month / 12; 377 month = month % 12; 378 if (month < 0) 379 { 380 month += 12; 381 year--; 382 } 383 } 384 385 int dayOfYear = dayCount[month] + 1; 386 if (month > 1) 387 if (isLeapYear(year)) 388 dayOfYear++; 389 390 boolean greg = isGregorian(year, dayOfYear); 391 int day = (int) getLinearDay(year, dayOfYear, greg); 392 393 // The epoch was a thursday. 394 int weekday = (day + THURSDAY) % 7; 395 if (weekday <= 0) 396 weekday += 7; 397 return weekday; 398 } 399 400 /** 401 * Takes a year, and a (zero based) day of year and determines 402 * if it is gregorian or not. 403 */ isGregorian(int year, int dayOfYear)404 private boolean isGregorian(int year, int dayOfYear) 405 { 406 int relativeDay = (year - 1) * 365 + ((year - 1) >> 2) + dayOfYear 407 - EPOCH_DAYS; // gregorian days from 1 to epoch. 408 int gregFactor = (int) Math.floor((double) (year - 1) / 400.) 409 - (int) Math.floor((double) (year - 1) / 100.); 410 411 return ((relativeDay + gregFactor) * 60L * 60L * 24L * 1000L >= gregorianCutover); 412 } 413 414 /** 415 * Check set fields for validity, without leniency. 416 * 417 * @throws IllegalArgumentException if a field is invalid 418 */ nonLeniencyCheck()419 private void nonLeniencyCheck() throws IllegalArgumentException 420 { 421 int[] month_days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 422 int year = fields[YEAR]; 423 int month = fields[MONTH]; 424 int leap = isLeapYear(year) ? 1 : 0; 425 426 if (isSet[ERA] && fields[ERA] != AD && fields[ERA] != BC) 427 throw new IllegalArgumentException("Illegal ERA."); 428 if (isSet[YEAR] && fields[YEAR] < 1) 429 throw new IllegalArgumentException("Illegal YEAR."); 430 if (isSet[MONTH] && (month < 0 || month > 11)) 431 throw new IllegalArgumentException("Illegal MONTH."); 432 if (isSet[WEEK_OF_YEAR]) 433 { 434 int daysInYear = 365 + leap; 435 daysInYear += (getFirstDayOfMonth(year, 0) - 1); // pad first week 436 int last = getFirstDayOfMonth(year, 11) + 4; 437 if (last > 7) 438 last -= 7; 439 daysInYear += 7 - last; 440 int weeks = daysInYear / 7; 441 if (fields[WEEK_OF_YEAR] < 1 || fields[WEEK_OF_YEAR] > weeks) 442 throw new IllegalArgumentException("Illegal WEEK_OF_YEAR."); 443 } 444 445 if (isSet[WEEK_OF_MONTH]) 446 { 447 int weeks = (month == 1 && leap == 0) ? 5 : 6; 448 if (fields[WEEK_OF_MONTH] < 1 || fields[WEEK_OF_MONTH] > weeks) 449 throw new IllegalArgumentException("Illegal WEEK_OF_MONTH."); 450 } 451 452 if (isSet[DAY_OF_MONTH]) 453 if (fields[DAY_OF_MONTH] < 1 454 || fields[DAY_OF_MONTH] > month_days[month] 455 + ((month == 1) ? leap : 0)) 456 throw new IllegalArgumentException("Illegal DAY_OF_MONTH."); 457 458 if (isSet[DAY_OF_YEAR] 459 && (fields[DAY_OF_YEAR] < 1 || fields[DAY_OF_YEAR] > 365 + leap)) 460 throw new IllegalArgumentException("Illegal DAY_OF_YEAR."); 461 462 if (isSet[DAY_OF_WEEK] 463 && (fields[DAY_OF_WEEK] < 1 || fields[DAY_OF_WEEK] > 7)) 464 throw new IllegalArgumentException("Illegal DAY_OF_WEEK."); 465 466 if (isSet[DAY_OF_WEEK_IN_MONTH]) 467 { 468 int weeks = (month == 1 && leap == 0) ? 4 : 5; 469 if (fields[DAY_OF_WEEK_IN_MONTH] < -weeks 470 || fields[DAY_OF_WEEK_IN_MONTH] > weeks) 471 throw new IllegalArgumentException("Illegal DAY_OF_WEEK_IN_MONTH."); 472 } 473 474 if (isSet[AM_PM] && fields[AM_PM] != AM && fields[AM_PM] != PM) 475 throw new IllegalArgumentException("Illegal AM_PM."); 476 if (isSet[HOUR] && (fields[HOUR] < 0 || fields[HOUR] > 11)) 477 throw new IllegalArgumentException("Illegal HOUR."); 478 if (isSet[HOUR_OF_DAY] 479 && (fields[HOUR_OF_DAY] < 0 || fields[HOUR_OF_DAY] > 23)) 480 throw new IllegalArgumentException("Illegal HOUR_OF_DAY."); 481 if (isSet[MINUTE] && (fields[MINUTE] < 0 || fields[MINUTE] > 59)) 482 throw new IllegalArgumentException("Illegal MINUTE."); 483 if (isSet[SECOND] && (fields[SECOND] < 0 || fields[SECOND] > 59)) 484 throw new IllegalArgumentException("Illegal SECOND."); 485 if (isSet[MILLISECOND] 486 && (fields[MILLISECOND] < 0 || fields[MILLISECOND] > 999)) 487 throw new IllegalArgumentException("Illegal MILLISECOND."); 488 if (isSet[ZONE_OFFSET] 489 && (fields[ZONE_OFFSET] < -12 * 60 * 60 * 1000L 490 || fields[ZONE_OFFSET] > 12 * 60 * 60 * 1000L)) 491 throw new IllegalArgumentException("Illegal ZONE_OFFSET."); 492 if (isSet[DST_OFFSET] 493 && (fields[DST_OFFSET] < -12 * 60 * 60 * 1000L 494 || fields[DST_OFFSET] > 12 * 60 * 60 * 1000L)) 495 throw new IllegalArgumentException("Illegal DST_OFFSET."); 496 } 497 498 /** 499 * Converts the time field values (<code>fields</code>) to 500 * milliseconds since the epoch UTC (<code>time</code>). 501 * 502 * @throws IllegalArgumentException if any calendar fields 503 * are invalid. 504 */ computeTime()505 protected synchronized void computeTime() 506 { 507 int millisInDay = 0; 508 int era = fields[ERA]; 509 int year = fields[YEAR]; 510 int month = fields[MONTH]; 511 int day = fields[DAY_OF_MONTH]; 512 513 int minute = fields[MINUTE]; 514 int second = fields[SECOND]; 515 int millis = fields[MILLISECOND]; 516 int[] month_days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 517 int[] dayCount = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; 518 int hour = 0; 519 520 if (! isLenient()) 521 nonLeniencyCheck(); 522 523 if (! isSet[MONTH] && (! isSet[DAY_OF_WEEK] || isSet[WEEK_OF_YEAR])) 524 { 525 // 5: YEAR + DAY_OF_WEEK + WEEK_OF_YEAR 526 if (isSet[WEEK_OF_YEAR]) 527 { 528 int first = getFirstDayOfMonth(year, 0); 529 int offs = 1; 530 int daysInFirstWeek = getFirstDayOfWeek() - first; 531 if (daysInFirstWeek <= 0) 532 daysInFirstWeek += 7; 533 534 if (daysInFirstWeek < getMinimalDaysInFirstWeek()) 535 offs += daysInFirstWeek; 536 else 537 offs -= 7 - daysInFirstWeek; 538 month = 0; 539 day = offs + 7 * (fields[WEEK_OF_YEAR] - 1); 540 offs = fields[DAY_OF_WEEK] - getFirstDayOfWeek(); 541 542 if (offs < 0) 543 offs += 7; 544 day += offs; 545 } 546 else 547 { 548 // 4: YEAR + DAY_OF_YEAR 549 month = 0; 550 day = fields[DAY_OF_YEAR]; 551 } 552 } 553 else 554 { 555 if (isSet[DAY_OF_WEEK]) 556 { 557 int first = getFirstDayOfMonth(year, month); 558 559 // 3: YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK 560 if (isSet[DAY_OF_WEEK_IN_MONTH]) 561 { 562 if (fields[DAY_OF_WEEK_IN_MONTH] < 0) 563 { 564 month++; 565 first = getFirstDayOfMonth(year, month); 566 day = 1 + 7 * (fields[DAY_OF_WEEK_IN_MONTH]); 567 } 568 else 569 day = 1 + 7 * (fields[DAY_OF_WEEK_IN_MONTH] - 1); 570 571 int offs = fields[DAY_OF_WEEK] - first; 572 if (offs < 0) 573 offs += 7; 574 day += offs; 575 } 576 else 577 { // 2: YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK 578 int offs = 1; 579 int daysInFirstWeek = getFirstDayOfWeek() - first; 580 if (daysInFirstWeek <= 0) 581 daysInFirstWeek += 7; 582 583 if (daysInFirstWeek < getMinimalDaysInFirstWeek()) 584 offs += daysInFirstWeek; 585 else 586 offs -= 7 - daysInFirstWeek; 587 588 day = offs + 7 * (fields[WEEK_OF_MONTH] - 1); 589 offs = fields[DAY_OF_WEEK] - getFirstDayOfWeek(); 590 if (offs < 0) 591 offs += 7; 592 day += offs; 593 } 594 } 595 596 // 1: YEAR + MONTH + DAY_OF_MONTH 597 } 598 if (era == BC && year > 0) 599 year = 1 - year; 600 601 // rest of code assumes day/month/year set 602 // should negative BC years be AD? 603 // get the hour (but no check for validity) 604 if (isSet[HOUR]) 605 { 606 hour = fields[HOUR]; 607 if (fields[AM_PM] == PM) 608 hour += 12; 609 } 610 else 611 hour = fields[HOUR_OF_DAY]; 612 613 // Read the era,year,month,day fields and convert as appropriate. 614 // Calculate number of milliseconds into the day 615 // This takes care of both h, m, s, ms over/underflows. 616 long allMillis = (((hour * 60L) + minute) * 60L + second) * 1000L + millis; 617 day += allMillis / (24 * 60 * 60 * 1000L); 618 millisInDay = (int) (allMillis % (24 * 60 * 60 * 1000L)); 619 620 if (month < 0) 621 { 622 year += (int) month / 12; 623 month = month % 12; 624 if (month < 0) 625 { 626 month += 12; 627 year--; 628 } 629 } 630 if (month > 11) 631 { 632 year += (month / 12); 633 month = month % 12; 634 } 635 636 month_days[1] = isLeapYear(year) ? 29 : 28; 637 638 while (day <= 0) 639 { 640 if (month == 0) 641 { 642 year--; 643 month_days[1] = isLeapYear(year) ? 29 : 28; 644 } 645 month = (month + 11) % 12; 646 day += month_days[month]; 647 } 648 while (day > month_days[month]) 649 { 650 day -= (month_days[month]); 651 month = (month + 1) % 12; 652 if (month == 0) 653 { 654 year++; 655 month_days[1] = isLeapYear(year) ? 29 : 28; 656 } 657 } 658 659 // ok, by here we have valid day,month,year,era and millisinday 660 int dayOfYear = dayCount[month] + day - 1; // (day starts on 1) 661 if (isLeapYear(year) && month > 1) 662 dayOfYear++; 663 664 int relativeDay = (year - 1) * 365 + ((year - 1) >> 2) + dayOfYear 665 - EPOCH_DAYS; // gregorian days from 1 to epoch. 666 int gregFactor = (int) Math.floor((double) (year - 1) / 400.) 667 - (int) Math.floor((double) (year - 1) / 100.); 668 669 if ((relativeDay + gregFactor) * 60L * 60L * 24L * 1000L >= gregorianCutover) 670 relativeDay += gregFactor; 671 else 672 relativeDay -= 2; 673 674 time = relativeDay * (24 * 60 * 60 * 1000L) + millisInDay; 675 676 // the epoch was a Thursday. 677 int weekday = (int) (relativeDay + THURSDAY) % 7; 678 if (weekday <= 0) 679 weekday += 7; 680 fields[DAY_OF_WEEK] = weekday; 681 682 // Time zone corrections. 683 TimeZone zone = getTimeZone(); 684 int rawOffset = isSet[ZONE_OFFSET] ? fields[ZONE_OFFSET] 685 : zone.getRawOffset(); 686 687 int dstOffset = isSet[DST_OFFSET] ? fields[DST_OFFSET] 688 : (zone.getOffset((year < 0) ? BC : AD, 689 (year < 0) ? 1 - year 690 : year, 691 month, day, weekday, 692 millisInDay) 693 - zone.getRawOffset()); 694 695 time -= rawOffset + dstOffset; 696 697 isTimeSet = true; 698 } 699 700 /** 701 * Get the linear day in days since the epoch, using the 702 * Julian or Gregorian calendar as specified. If you specify a 703 * nonpositive year it is interpreted as BC as following: 0 is 1 704 * BC, -1 is 2 BC and so on. 705 * 706 * @param year the year of the date. 707 * @param dayOfYear the day of year of the date; 1 based. 708 * @param gregorian <code>true</code>, if we should use the Gregorian rules. 709 * @return the days since the epoch, may be negative. 710 */ getLinearDay(int year, int dayOfYear, boolean gregorian)711 private long getLinearDay(int year, int dayOfYear, boolean gregorian) 712 { 713 // The 13 is the number of days, that were omitted in the Gregorian 714 // Calender until the epoch. 715 // We shift right by 2 instead of dividing by 4, to get correct 716 // results for negative years (and this is even more efficient). 717 long julianDay = (year - 1) * 365L + ((year - 1) >> 2) + (dayOfYear - 1) 718 - EPOCH_DAYS; // gregorian days from 1 to epoch. 719 720 if (gregorian) 721 { 722 // subtract the days that are missing in gregorian calendar 723 // with respect to julian calendar. 724 // 725 // Okay, here we rely on the fact that the gregorian 726 // calendar was introduced in the AD era. This doesn't work 727 // with negative years. 728 // 729 // The additional leap year factor accounts for the fact that 730 // a leap day is not seen on Jan 1 of the leap year. 731 int gregOffset = (int) Math.floor((double) (year - 1) / 400.) 732 - (int) Math.floor((double) (year - 1) / 100.); 733 734 return julianDay + gregOffset; 735 } 736 else 737 julianDay -= 2; 738 return julianDay; 739 } 740 741 /** 742 * Converts the given linear day into era, year, month, 743 * day_of_year, day_of_month, day_of_week, and writes the result 744 * into the fields array. 745 * 746 * @param day the linear day. 747 * @param gregorian true, if we should use Gregorian rules. 748 */ calculateDay(int[] fields, long day, boolean gregorian)749 private void calculateDay(int[] fields, long day, boolean gregorian) 750 { 751 // the epoch was a Thursday. 752 int weekday = (int) (day + THURSDAY) % 7; 753 if (weekday <= 0) 754 weekday += 7; 755 fields[DAY_OF_WEEK] = weekday; 756 757 // get a first approximation of the year. This may be one 758 // year too big. 759 int year = 1970 760 + (int) (gregorian 761 ? ((day - 100L) * 400L) / (365L * 400L + 100L - 4L 762 + 1L) : ((day - 100L) * 4L) / (365L * 4L + 1L)); 763 if (day >= 0) 764 year++; 765 766 long firstDayOfYear = getLinearDay(year, 1, gregorian); 767 768 // Now look in which year day really lies. 769 if (day < firstDayOfYear) 770 { 771 year--; 772 firstDayOfYear = getLinearDay(year, 1, gregorian); 773 } 774 775 day -= firstDayOfYear - 1; // day of year, one based. 776 777 fields[DAY_OF_YEAR] = (int) day; 778 if (year <= 0) 779 { 780 fields[ERA] = BC; 781 fields[YEAR] = 1 - year; 782 } 783 else 784 { 785 fields[ERA] = AD; 786 fields[YEAR] = year; 787 } 788 789 int leapday = isLeapYear(year) ? 1 : 0; 790 if (day <= 31 + 28 + leapday) 791 { 792 fields[MONTH] = (int) day / 32; // 31->JANUARY, 32->FEBRUARY 793 fields[DAY_OF_MONTH] = (int) day - 31 * fields[MONTH]; 794 } 795 else 796 { 797 // A few more magic formulas 798 int scaledDay = ((int) day - leapday) * 5 + 8; 799 fields[MONTH] = scaledDay / (31 + 30 + 31 + 30 + 31); 800 fields[DAY_OF_MONTH] = (scaledDay % (31 + 30 + 31 + 30 + 31)) / 5 + 1; 801 } 802 } 803 804 /** 805 * Converts the milliseconds since the epoch UTC 806 * (<code>time</code>) to time fields 807 * (<code>fields</code>). 808 */ computeFields()809 protected synchronized void computeFields() 810 { 811 boolean gregorian = (time >= gregorianCutover); 812 813 TimeZone zone = getTimeZone(); 814 fields[ZONE_OFFSET] = zone.getRawOffset(); 815 long localTime = time + fields[ZONE_OFFSET]; 816 817 long day = localTime / (24 * 60 * 60 * 1000L); 818 int millisInDay = (int) (localTime % (24 * 60 * 60 * 1000L)); 819 820 if (millisInDay < 0) 821 { 822 millisInDay += (24 * 60 * 60 * 1000); 823 day--; 824 } 825 826 calculateDay(fields, day, gregorian); 827 fields[DST_OFFSET] = zone.getOffset(fields[ERA], fields[YEAR], 828 fields[MONTH], fields[DAY_OF_MONTH], 829 fields[DAY_OF_WEEK], millisInDay) 830 - fields[ZONE_OFFSET]; 831 832 millisInDay += fields[DST_OFFSET]; 833 if (millisInDay >= 24 * 60 * 60 * 1000) 834 { 835 millisInDay -= 24 * 60 * 60 * 1000; 836 calculateDay(fields, ++day, gregorian); 837 } 838 839 fields[DAY_OF_WEEK_IN_MONTH] = (fields[DAY_OF_MONTH] + 6) / 7; 840 841 // which day of the week are we (0..6), relative to getFirstDayOfWeek 842 int relativeWeekday = (7 + fields[DAY_OF_WEEK] - getFirstDayOfWeek()) % 7; 843 844 // which day of the week is the first of this month? 845 // nb 35 is the smallest multiple of 7 that ensures that 846 // the left hand side of the modulo operator is positive. 847 int relativeWeekdayOfFirst = (relativeWeekday - fields[DAY_OF_MONTH] 848 + 1 + 35) % 7; 849 850 // which week of the month is the first of this month in? 851 int minDays = getMinimalDaysInFirstWeek(); 852 int weekOfFirst = ((7 - relativeWeekdayOfFirst) >= minDays) ? 1 : 0; 853 854 // which week of the month is this day in? 855 fields[WEEK_OF_MONTH] = (fields[DAY_OF_MONTH] 856 + relativeWeekdayOfFirst - 1) / 7 + weekOfFirst; 857 858 int weekOfYear = (fields[DAY_OF_YEAR] - relativeWeekday + 6) / 7; 859 860 // Do the Correction: getMinimalDaysInFirstWeek() is always in the 861 // first week. 862 int firstWeekday = (7 + getWeekDay(fields[YEAR], minDays) 863 - getFirstDayOfWeek()) % 7; 864 if (minDays - firstWeekday < 1) 865 weekOfYear++; 866 fields[WEEK_OF_YEAR] = weekOfYear; 867 868 int hourOfDay = millisInDay / (60 * 60 * 1000); 869 fields[AM_PM] = (hourOfDay < 12) ? AM : PM; 870 int hour = hourOfDay % 12; 871 fields[HOUR] = hour; 872 fields[HOUR_OF_DAY] = hourOfDay; 873 millisInDay %= (60 * 60 * 1000); 874 fields[MINUTE] = millisInDay / (60 * 1000); 875 millisInDay %= (60 * 1000); 876 fields[SECOND] = millisInDay / (1000); 877 fields[MILLISECOND] = millisInDay % 1000; 878 879 areFieldsSet = isSet[ERA] = isSet[YEAR] = isSet[MONTH] = isSet[WEEK_OF_YEAR] = isSet[WEEK_OF_MONTH] = isSet[DAY_OF_MONTH] = isSet[DAY_OF_YEAR] = isSet[DAY_OF_WEEK] = isSet[DAY_OF_WEEK_IN_MONTH] = isSet[AM_PM] = isSet[HOUR] = isSet[HOUR_OF_DAY] = isSet[MINUTE] = isSet[SECOND] = isSet[MILLISECOND] = isSet[ZONE_OFFSET] = isSet[DST_OFFSET] = true; 880 } 881 882 /** 883 * Return a hash code for this object, following the general contract 884 * specified by {@link Object#hashCode()}. 885 * @return the hash code 886 */ hashCode()887 public int hashCode() 888 { 889 int val = (int) ((gregorianCutover >>> 32) ^ (gregorianCutover & 0xffffffff)); 890 return super.hashCode() ^ val; 891 } 892 893 /** 894 * Compares the given calendar with this. An object, o, is 895 * equivalent to this if it is also a <code>GregorianCalendar</code> 896 * with the same time since the epoch under the same conditions 897 * (same change date and same time zone). 898 * 899 * @param o the object to that we should compare. 900 * @return true, if the given object is a calendar, that represents 901 * the same time (but doesn't necessarily have the same fields). 902 * @throws IllegalArgumentException if one of the fields 903 * <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is 904 * specified, if an unknown field is specified or if one 905 * of the calendar fields receives an illegal value when 906 * leniancy is not enabled. 907 */ equals(Object o)908 public boolean equals(Object o) 909 { 910 if (! (o instanceof GregorianCalendar)) 911 return false; 912 913 GregorianCalendar cal = (GregorianCalendar) o; 914 return (cal.gregorianCutover == gregorianCutover 915 && super.equals(o)); 916 } 917 918 /** 919 * Adds the specified amount of time to the given time field. The 920 * amount may be negative to subtract the time. If the field overflows 921 * it does what you expect: Jan, 25 + 10 Days is Feb, 4. 922 * @param field one of the time field constants. 923 * @param amount the amount of time to add. 924 * @exception IllegalArgumentException if <code>field</code> is 925 * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or invalid; or 926 * if <code>amount</code> contains an out-of-range value and the calendar 927 * is not in lenient mode. 928 */ add(int field, int amount)929 public void add(int field, int amount) 930 { 931 switch (field) 932 { 933 case YEAR: 934 complete(); 935 fields[YEAR] += amount; 936 isTimeSet = false; 937 break; 938 case MONTH: 939 complete(); 940 int months = fields[MONTH] + amount; 941 fields[YEAR] += months / 12; 942 fields[MONTH] = months % 12; 943 if (fields[MONTH] < 0) 944 { 945 fields[MONTH] += 12; 946 fields[YEAR]--; 947 } 948 int maxDay = getActualMaximum(DAY_OF_MONTH); 949 if (fields[DAY_OF_MONTH] > maxDay) 950 fields[DAY_OF_MONTH] = maxDay; 951 set(YEAR, fields[YEAR]); 952 set(MONTH, fields[MONTH]); 953 break; 954 case DAY_OF_MONTH: 955 case DAY_OF_YEAR: 956 case DAY_OF_WEEK: 957 if (! isTimeSet) 958 computeTime(); 959 time += amount * (24 * 60 * 60 * 1000L); 960 areFieldsSet = false; 961 break; 962 case WEEK_OF_YEAR: 963 case WEEK_OF_MONTH: 964 case DAY_OF_WEEK_IN_MONTH: 965 if (! isTimeSet) 966 computeTime(); 967 time += amount * (7 * 24 * 60 * 60 * 1000L); 968 areFieldsSet = false; 969 break; 970 case AM_PM: 971 if (! isTimeSet) 972 computeTime(); 973 time += amount * (12 * 60 * 60 * 1000L); 974 areFieldsSet = false; 975 break; 976 case HOUR: 977 case HOUR_OF_DAY: 978 if (! isTimeSet) 979 computeTime(); 980 time += amount * (60 * 60 * 1000L); 981 areFieldsSet = false; 982 break; 983 case MINUTE: 984 if (! isTimeSet) 985 computeTime(); 986 time += amount * (60 * 1000L); 987 areFieldsSet = false; 988 break; 989 case SECOND: 990 if (! isTimeSet) 991 computeTime(); 992 time += amount * (1000L); 993 areFieldsSet = false; 994 break; 995 case MILLISECOND: 996 if (! isTimeSet) 997 computeTime(); 998 time += amount; 999 areFieldsSet = false; 1000 break; 1001 case ZONE_OFFSET: 1002 case DST_OFFSET:default: 1003 throw new IllegalArgumentException("Invalid or unknown field"); 1004 } 1005 } 1006 1007 /** 1008 * Rolls the specified time field up or down. This means add one 1009 * to the specified field, but don't change the other fields. If 1010 * the maximum for this field is reached, start over with the 1011 * minimum value. 1012 * 1013 * <strong>Note:</strong> There may be situation, where the other 1014 * fields must be changed, e.g rolling the month on May, 31. 1015 * The date June, 31 is automatically converted to July, 1. 1016 * This requires lenient settings. 1017 * 1018 * @param field the time field. One of the time field constants. 1019 * @param up the direction, true for up, false for down. 1020 * @throws IllegalArgumentException if one of the fields 1021 * <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is 1022 * specified, if an unknown field is specified or if one 1023 * of the calendar fields receives an illegal value when 1024 * leniancy is not enabled. 1025 */ roll(int field, boolean up)1026 public void roll(int field, boolean up) 1027 { 1028 roll(field, up ? 1 : -1); 1029 } 1030 1031 /** 1032 * Checks that the fields are still within their legal bounds, 1033 * following use of the <code>roll()</code> method. 1034 * 1035 * @param field the field to check. 1036 * @param delta multipler for alterations to the <code>time</code>. 1037 * @see #roll(int, boolean) 1038 * @see #roll(int, int) 1039 */ cleanUpAfterRoll(int field, int delta)1040 private void cleanUpAfterRoll(int field, int delta) 1041 { 1042 switch (field) 1043 { 1044 case ERA: 1045 case YEAR: 1046 case MONTH: 1047 // check that day of month is still in correct range 1048 if (fields[DAY_OF_MONTH] > getActualMaximum(DAY_OF_MONTH)) 1049 fields[DAY_OF_MONTH] = getActualMaximum(DAY_OF_MONTH); 1050 isTimeSet = false; 1051 isSet[WEEK_OF_MONTH] = false; 1052 isSet[DAY_OF_WEEK] = false; 1053 isSet[DAY_OF_WEEK_IN_MONTH] = false; 1054 isSet[DAY_OF_YEAR] = false; 1055 isSet[WEEK_OF_YEAR] = false; 1056 break; 1057 case DAY_OF_MONTH: 1058 isSet[WEEK_OF_MONTH] = false; 1059 isSet[DAY_OF_WEEK] = false; 1060 isSet[DAY_OF_WEEK_IN_MONTH] = false; 1061 isSet[DAY_OF_YEAR] = false; 1062 isSet[WEEK_OF_YEAR] = false; 1063 time += delta * (24 * 60 * 60 * 1000L); 1064 break; 1065 case WEEK_OF_MONTH: 1066 isSet[DAY_OF_MONTH] = false; 1067 isSet[DAY_OF_WEEK_IN_MONTH] = false; 1068 isSet[DAY_OF_YEAR] = false; 1069 isSet[WEEK_OF_YEAR] = false; 1070 time += delta * (7 * 24 * 60 * 60 * 1000L); 1071 break; 1072 case DAY_OF_WEEK_IN_MONTH: 1073 isSet[DAY_OF_MONTH] = false; 1074 isSet[WEEK_OF_MONTH] = false; 1075 isSet[DAY_OF_YEAR] = false; 1076 isSet[WEEK_OF_YEAR] = false; 1077 time += delta * (7 * 24 * 60 * 60 * 1000L); 1078 break; 1079 case DAY_OF_YEAR: 1080 isSet[MONTH] = false; 1081 isSet[DAY_OF_MONTH] = false; 1082 isSet[WEEK_OF_MONTH] = false; 1083 isSet[DAY_OF_WEEK_IN_MONTH] = false; 1084 isSet[DAY_OF_WEEK] = false; 1085 isSet[WEEK_OF_YEAR] = false; 1086 time += delta * (24 * 60 * 60 * 1000L); 1087 break; 1088 case WEEK_OF_YEAR: 1089 isSet[MONTH] = false; 1090 isSet[DAY_OF_MONTH] = false; 1091 isSet[WEEK_OF_MONTH] = false; 1092 isSet[DAY_OF_WEEK_IN_MONTH] = false; 1093 isSet[DAY_OF_YEAR] = false; 1094 time += delta * (7 * 24 * 60 * 60 * 1000L); 1095 break; 1096 case AM_PM: 1097 isSet[HOUR_OF_DAY] = false; 1098 time += delta * (12 * 60 * 60 * 1000L); 1099 break; 1100 case HOUR: 1101 isSet[HOUR_OF_DAY] = false; 1102 time += delta * (60 * 60 * 1000L); 1103 break; 1104 case HOUR_OF_DAY: 1105 isSet[HOUR] = false; 1106 isSet[AM_PM] = false; 1107 time += delta * (60 * 60 * 1000L); 1108 break; 1109 case MINUTE: 1110 time += delta * (60 * 1000L); 1111 break; 1112 case SECOND: 1113 time += delta * (1000L); 1114 break; 1115 case MILLISECOND: 1116 time += delta; 1117 break; 1118 } 1119 } 1120 1121 /** 1122 * Rolls the specified time field by the given amount. This means 1123 * add amount to the specified field, but don't change the other 1124 * fields. If the maximum for this field is reached, start over 1125 * with the minimum value and vice versa for negative amounts. 1126 * 1127 * <strong>Note:</strong> There may be situation, where the other 1128 * fields must be changed, e.g rolling the month on May, 31. 1129 * The date June, 31 is automatically corrected to June, 30. 1130 * 1131 * @param field the time field. One of the time field constants. 1132 * @param amount the amount by which we should roll. 1133 * @throws IllegalArgumentException if one of the fields 1134 * <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is 1135 * specified, if an unknown field is specified or if one 1136 * of the calendar fields receives an illegal value when 1137 * leniancy is not enabled. 1138 */ roll(int field, int amount)1139 public void roll(int field, int amount) 1140 { 1141 switch (field) 1142 { 1143 case DAY_OF_WEEK: 1144 // day of week is special: it rolls automatically 1145 add(field, amount); 1146 return; 1147 case ZONE_OFFSET: 1148 case DST_OFFSET: 1149 throw new IllegalArgumentException("Can't roll time zone"); 1150 } 1151 complete(); 1152 int min = getActualMinimum(field); 1153 int range = getActualMaximum(field) - min + 1; 1154 int oldval = fields[field]; 1155 int newval = (oldval - min + range + amount) % range + min; 1156 if (newval < min) 1157 newval += range; 1158 fields[field] = newval; 1159 cleanUpAfterRoll(field, newval - oldval); 1160 } 1161 1162 /** 1163 * The minimum values for the calendar fields. 1164 */ 1165 private static final int[] minimums = 1166 { 1167 BC, 1, 0, 0, 1, 1, 1, SUNDAY, 1, AM, 1168 1, 0, 0, 0, 0, -(12 * 60 * 60 * 1000), 1169 0 1170 }; 1171 1172 /** 1173 * The maximum values for the calendar fields. 1174 */ 1175 private static final int[] maximums = 1176 { 1177 AD, 5000000, 11, 53, 6, 31, 366, 1178 SATURDAY, 5, PM, 12, 23, 59, 59, 999, 1179 +(12 * 60 * 60 * 1000), 1180 (12 * 60 * 60 * 1000) 1181 }; 1182 1183 /** 1184 * Gets the smallest value that is allowed for the specified field. 1185 * 1186 * @param field one of the time field constants. 1187 * @return the smallest value for the specified field. 1188 */ getMinimum(int field)1189 public int getMinimum(int field) 1190 { 1191 return minimums[field]; 1192 } 1193 1194 /** 1195 * Gets the biggest value that is allowed for the specified field. 1196 * 1197 * @param field one of the time field constants. 1198 * @return the biggest value. 1199 */ getMaximum(int field)1200 public int getMaximum(int field) 1201 { 1202 return maximums[field]; 1203 } 1204 1205 /** 1206 * Gets the greatest minimum value that is allowed for the specified field. 1207 * This is the largest value returned by the <code>getActualMinimum(int)</code> 1208 * method. 1209 * 1210 * @param field the time field. One of the time field constants. 1211 * @return the greatest minimum value. 1212 * @see #getActualMinimum(int) 1213 */ getGreatestMinimum(int field)1214 public int getGreatestMinimum(int field) 1215 { 1216 if (field == WEEK_OF_YEAR) 1217 return 1; 1218 return minimums[field]; 1219 } 1220 1221 /** 1222 * Gets the smallest maximum value that is allowed for the 1223 * specified field. This is the smallest value returned 1224 * by the <code>getActualMaximum(int)</code>. For example, 1225 * this is 28 for DAY_OF_MONTH (as all months have at least 1226 * 28 days). 1227 * 1228 * @param field the time field. One of the time field constants. 1229 * @return the least maximum value. 1230 * @see #getActualMaximum(int) 1231 * @since 1.2 1232 */ getLeastMaximum(int field)1233 public int getLeastMaximum(int field) 1234 { 1235 switch (field) 1236 { 1237 case WEEK_OF_YEAR: 1238 return 52; 1239 case DAY_OF_MONTH: 1240 return 28; 1241 case DAY_OF_YEAR: 1242 return 365; 1243 case DAY_OF_WEEK_IN_MONTH: 1244 case WEEK_OF_MONTH: 1245 return 4; 1246 default: 1247 return maximums[field]; 1248 } 1249 } 1250 1251 /** 1252 * Gets the actual minimum value that is allowed for the specified field. 1253 * This value is dependent on the values of the other fields. Note that 1254 * this calls <code>complete()</code> if not enough fields are set. This 1255 * can have ugly side effects. The value given depends on the current 1256 * time used by this instance. 1257 * 1258 * @param field the time field. One of the time field constants. 1259 * @return the actual minimum value. 1260 * @since 1.2 1261 */ getActualMinimum(int field)1262 public int getActualMinimum(int field) 1263 { 1264 if (field == WEEK_OF_YEAR) 1265 { 1266 int min = getMinimalDaysInFirstWeek(); 1267 if (min == 0) 1268 return 1; 1269 if (! areFieldsSet || ! isSet[ERA] || ! isSet[YEAR]) 1270 complete(); 1271 1272 int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR]; 1273 int weekday = getWeekDay(year, min); 1274 if ((7 + weekday - getFirstDayOfWeek()) % 7 >= min - 1) 1275 return 1; 1276 return 0; 1277 } 1278 return minimums[field]; 1279 } 1280 1281 /** 1282 * Gets the actual maximum value that is allowed for the specified field. 1283 * This value is dependent on the values of the other fields. Note that 1284 * this calls <code>complete()</code> if not enough fields are set. This 1285 * can have ugly side effects. The value given depends on the current time 1286 * used by this instance; thus, leap years have a maximum day of month value of 1287 * 29, rather than 28. 1288 * 1289 * @param field the time field. One of the time field constants. 1290 * @return the actual maximum value. 1291 */ getActualMaximum(int field)1292 public int getActualMaximum(int field) 1293 { 1294 switch (field) 1295 { 1296 case WEEK_OF_YEAR: 1297 { 1298 if (! areFieldsSet || ! isSet[ERA] || ! isSet[YEAR]) 1299 complete(); 1300 1301 // This is wrong for the year that contains the gregorian change. 1302 // I.e it gives the weeks in the julian year or in the gregorian 1303 // year in that case. 1304 int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR]; 1305 int lastDay = isLeapYear(year) ? 366 : 365; 1306 int weekday = getWeekDay(year, lastDay); 1307 int week = (lastDay + 6 - (7 + weekday - getFirstDayOfWeek()) % 7) / 7; 1308 1309 int minimalDays = getMinimalDaysInFirstWeek(); 1310 int firstWeekday = getWeekDay(year, minimalDays); 1311 /* 1312 * Is there a set of days at the beginning of the year, before the 1313 * first day of the week, equal to or greater than the minimum number 1314 * of days required in the first week? 1315 */ 1316 if (minimalDays - (7 + firstWeekday - getFirstDayOfWeek()) % 7 < 1) 1317 return week + 1; /* Add week 1: firstWeekday through to firstDayOfWeek */ 1318 } 1319 case DAY_OF_MONTH: 1320 { 1321 if (! areFieldsSet || ! isSet[MONTH]) 1322 complete(); 1323 int month = fields[MONTH]; 1324 1325 // If you change this, you should also change 1326 // SimpleTimeZone.getDaysInMonth(); 1327 if (month == FEBRUARY) 1328 { 1329 if (! isSet[YEAR] || ! isSet[ERA]) 1330 complete(); 1331 int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR]; 1332 return isLeapYear(year) ? 29 : 28; 1333 } 1334 else if (month < AUGUST) 1335 return 31 - (month & 1); 1336 else 1337 return 30 + (month & 1); 1338 } 1339 case DAY_OF_YEAR: 1340 { 1341 if (! areFieldsSet || ! isSet[ERA] || ! isSet[YEAR]) 1342 complete(); 1343 int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR]; 1344 return isLeapYear(year) ? 366 : 365; 1345 } 1346 case DAY_OF_WEEK_IN_MONTH: 1347 { 1348 // This is wrong for the month that contains the gregorian change. 1349 int daysInMonth = getActualMaximum(DAY_OF_MONTH); 1350 1351 // That's black magic, I know 1352 return (daysInMonth - (fields[DAY_OF_MONTH] - 1) % 7 + 6) / 7; 1353 } 1354 case WEEK_OF_MONTH: 1355 { 1356 int daysInMonth = getActualMaximum(DAY_OF_MONTH); 1357 int weekday = (daysInMonth - fields[DAY_OF_MONTH] 1358 + fields[DAY_OF_WEEK] - SUNDAY) % 7 + SUNDAY; 1359 return (daysInMonth + 6 - (7 + weekday - getFirstDayOfWeek()) % 7) / 7; 1360 } 1361 default: 1362 return maximums[field]; 1363 } 1364 } 1365 } 1366