1 /* Calendar.java -- 2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 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 import gnu.java.lang.CPStringBuilder; 43 44 import java.io.IOException; 45 import java.io.ObjectInputStream; 46 import java.io.ObjectOutputStream; 47 import java.io.Serializable; 48 49 import java.lang.reflect.Constructor; 50 import java.lang.reflect.InvocationTargetException; 51 52 import java.text.DateFormatSymbols; 53 54 /** 55 * This class is an abstract base class for Calendars, which can be 56 * used to convert between <code>Date</code> objects and a set of 57 * integer fields which represent <code>YEAR</code>, 58 * <code>MONTH</code>, <code>DAY</code>, etc. The <code>Date</code> 59 * object represents a time in milliseconds since the Epoch. <br> 60 * 61 * This class is locale sensitive. To get the Object matching the 62 * current locale you can use <code>getInstance</code>. You can even provide 63 * a locale or a timezone. <code>getInstance</code> returns currently 64 * a <code>GregorianCalendar</code> for the current date. <br> 65 * 66 * If you want to convert a date from the Year, Month, Day, DayOfWeek, 67 * etc. Representation to a <code>Date</code>-Object, you can create 68 * a new Calendar with <code>getInstance()</code>, 69 * <code>clear()</code> all fields, <code>set(int,int)</code> the 70 * fields you need and convert it with <code>getTime()</code>. <br> 71 * 72 * If you want to convert a <code>Date</code>-object to the Calendar 73 * representation, create a new Calendar, assign the 74 * <code>Date</code>-Object with <code>setTime()</code>, and read the 75 * fields with <code>get(int)</code>. <br> 76 * 77 * When computing the date from time fields, it may happen, that there 78 * are either two few fields set, or some fields are inconsistent. This 79 * cases will handled in a calendar specific way. Missing fields are 80 * replaced by the fields of the epoch: 1970 January 1 00:00. <br> 81 * 82 * To understand, how the day of year is computed out of the fields 83 * look at the following table. It is traversed from top to bottom, 84 * and for the first line all fields are set, that line is used to 85 * compute the day. <br> 86 * 87 * 88 <pre>month + day_of_month 89 month + week_of_month + day_of_week 90 month + day_of_week_of_month + day_of_week 91 day_of_year 92 day_of_week + week_of_year</pre> 93 * 94 * The hour_of_day-field takes precedence over the ampm and 95 * hour_of_ampm fields. <br> 96 * 97 * <STRONG>Note:</STRONG> This can differ for non-Gregorian calendar. <br> 98 * 99 * To convert a calendar to a human readable form and vice versa, use 100 * the <code>java.text.DateFormat</code> class. <br> 101 * 102 * Other useful things you can do with an calendar, is 103 * <code>roll</code>ing fields (that means increase/decrease a 104 * specific field by one, propagating overflows), or 105 * <code>add</code>ing/substracting a fixed amount to a field. 106 * 107 * @author Aaron M. Renn (arenn@urbanophile.com) 108 * @author Jochen Hoenicke (Jochen.Hoenicke@Informatik.Uni-Oldenburg.de) 109 * @author Warren Levy (warrenl@cygnus.com) 110 * @author Jeff Sturm (jsturm@one-point.com) 111 * @author Tom Tromey (tromey@redhat.com) 112 * @author Bryce McKinlay (mckinlay@redhat.com) 113 * @author Ingo Proetel (proetel@aicas.com) 114 * @author Jerry Quinn (jlquinn@optonline.net) 115 * @author Jeroen Frijters (jeroen@frijters.net) 116 * @author Noa Resare (noa@resare.com) 117 * @author Sven de Marothy (sven@physto.se) 118 * @author David Gilbert (david.gilbert@object-refinery.com) 119 * @author Olivier Jolly (olivier.jolly@pcedev.com) 120 * @author Andrew John Hughes (gnu_andrew@member.fsf.org) 121 * @see Date 122 * @see GregorianCalendar 123 * @see TimeZone 124 * @see java.text.DateFormat 125 */ 126 public abstract class Calendar 127 implements Serializable, Cloneable, Comparable<Calendar> 128 { 129 /** 130 * Constant representing the era time field. 131 */ 132 public static final int ERA = 0; 133 134 /** 135 * Constant representing the year time field. 136 */ 137 public static final int YEAR = 1; 138 139 /** 140 * Constant representing the month time field. This field 141 * should contain one of the JANUARY,...,DECEMBER constants below. 142 */ 143 public static final int MONTH = 2; 144 145 /** 146 * Constant representing the week of the year field. 147 * @see #setFirstDayOfWeek(int) 148 */ 149 public static final int WEEK_OF_YEAR = 3; 150 151 /** 152 * Constant representing the week of the month time field. 153 * @see #setFirstDayOfWeek(int) 154 */ 155 public static final int WEEK_OF_MONTH = 4; 156 157 /** 158 * Constant representing the day time field, synonym for DAY_OF_MONTH. 159 */ 160 public static final int DATE = 5; 161 162 /** 163 * Constant representing the day time field. 164 */ 165 public static final int DAY_OF_MONTH = 5; 166 167 /** 168 * Constant representing the day of year time field. This is 169 * 1 for the first day in month. 170 */ 171 public static final int DAY_OF_YEAR = 6; 172 173 /** 174 * Constant representing the day of week time field. This field 175 * should contain one of the SUNDAY,...,SATURDAY constants below. 176 */ 177 public static final int DAY_OF_WEEK = 7; 178 179 /** 180 * Constant representing the day-of-week-in-month field. For 181 * instance this field contains 2 for the second thursday in a 182 * month. If you give a negative number here, the day will count 183 * from the end of the month. 184 */ 185 public static final int DAY_OF_WEEK_IN_MONTH = 8; 186 187 /** 188 * Constant representing the part of the day for 12-hour clock. This 189 * should be one of AM or PM. 190 */ 191 public static final int AM_PM = 9; 192 193 /** 194 * Constant representing the hour time field for 12-hour clock. 195 */ 196 public static final int HOUR = 10; 197 198 /** 199 * Constant representing the hour of day time field for 24-hour clock. 200 */ 201 public static final int HOUR_OF_DAY = 11; 202 203 /** 204 * Constant representing the minute of hour time field. 205 */ 206 public static final int MINUTE = 12; 207 208 /** 209 * Constant representing the second time field. 210 */ 211 public static final int SECOND = 13; 212 213 /** 214 * Constant representing the millisecond time field. 215 */ 216 public static final int MILLISECOND = 14; 217 218 /** 219 * Constant representing the time zone offset time field for the 220 * time given in the other fields. It is measured in 221 * milliseconds. The default is the offset of the time zone. 222 */ 223 public static final int ZONE_OFFSET = 15; 224 225 /** 226 * Constant representing the daylight saving time offset in 227 * milliseconds. The default is the value given by the time zone. 228 */ 229 public static final int DST_OFFSET = 16; 230 231 /** 232 * Number of time fields. 233 */ 234 public static final int FIELD_COUNT = 17; 235 236 /** 237 * Constant representing Sunday. 238 */ 239 public static final int SUNDAY = 1; 240 241 /** 242 * Constant representing Monday. 243 */ 244 public static final int MONDAY = 2; 245 246 /** 247 * Constant representing Tuesday. 248 */ 249 public static final int TUESDAY = 3; 250 251 /** 252 * Constant representing Wednesday. 253 */ 254 public static final int WEDNESDAY = 4; 255 256 /** 257 * Constant representing Thursday. 258 */ 259 public static final int THURSDAY = 5; 260 261 /** 262 * Constant representing Friday. 263 */ 264 public static final int FRIDAY = 6; 265 266 /** 267 * Constant representing Saturday. 268 */ 269 public static final int SATURDAY = 7; 270 271 /** 272 * Constant representing January. 273 */ 274 public static final int JANUARY = 0; 275 276 /** 277 * Constant representing February. 278 */ 279 public static final int FEBRUARY = 1; 280 281 /** 282 * Constant representing March. 283 */ 284 public static final int MARCH = 2; 285 286 /** 287 * Constant representing April. 288 */ 289 public static final int APRIL = 3; 290 291 /** 292 * Constant representing May. 293 */ 294 public static final int MAY = 4; 295 296 /** 297 * Constant representing June. 298 */ 299 public static final int JUNE = 5; 300 301 /** 302 * Constant representing July. 303 */ 304 public static final int JULY = 6; 305 306 /** 307 * Constant representing August. 308 */ 309 public static final int AUGUST = 7; 310 311 /** 312 * Constant representing September. 313 */ 314 public static final int SEPTEMBER = 8; 315 316 /** 317 * Constant representing October. 318 */ 319 public static final int OCTOBER = 9; 320 321 /** 322 * Constant representing November. 323 */ 324 public static final int NOVEMBER = 10; 325 326 /** 327 * Constant representing December. 328 */ 329 public static final int DECEMBER = 11; 330 331 /** 332 * Constant representing Undecimber. This is an artificial name useful 333 * for lunar calendars. 334 */ 335 public static final int UNDECIMBER = 12; 336 337 /** 338 * Useful constant for 12-hour clock. 339 */ 340 public static final int AM = 0; 341 342 /** 343 * Useful constant for 12-hour clock. 344 */ 345 public static final int PM = 1; 346 347 /** 348 * A style specifier for {@link #getDisplayNames(int,int,Locale)} 349 * stating that names should be returned in both long and short variants. 350 * 351 * @since 1.6 352 * @see #SHORT 353 * @see #LONG 354 */ 355 public static final int ALL_STYLES = 0; 356 357 /** 358 * A style specifier for {@link #getDisplayName(int,int,Locale)} 359 * and {@link #getDisplayNames(int,int,Locale)} stating that names 360 * should be returned in their short variant if applicable. 361 * 362 * @since 1.6 363 */ 364 public static final int SHORT = 1; 365 366 /** 367 * A style specifier for {@link #getDisplayName(int,int,Locale)} 368 * and {@link #getDisplayNames(int,int,Locale)} stating that names 369 * should be returned in their long variant if applicable. 370 * 371 * @since 1.6 372 */ 373 public static final int LONG = 2; 374 375 /** 376 * The time fields. The array is indexed by the constants YEAR to 377 * DST_OFFSET. 378 * @serial 379 */ 380 protected int[] fields = new int[FIELD_COUNT]; 381 382 /** 383 * The flags which tell if the fields above have a value. 384 * @serial 385 */ 386 protected boolean[] isSet = new boolean[FIELD_COUNT]; 387 388 /** 389 * The time in milliseconds since the epoch. 390 * @serial 391 */ 392 protected long time; 393 394 /** 395 * Tells if the above field has a valid value. 396 * @serial 397 */ 398 protected boolean isTimeSet; 399 400 /** 401 * Tells if the fields have a valid value. This superseeds the isSet 402 * array. 403 * @serial 404 */ 405 protected boolean areFieldsSet; 406 407 /** 408 * The time zone of this calendar. Used by sub classes to do UTC / local 409 * time conversion. Sub classes can access this field with getTimeZone(). 410 * @serial 411 */ 412 private TimeZone zone; 413 414 /** 415 * This is the default calendar class, that is returned on 416 * java.util.Calendar.getInstance(). 417 * XXX - this isn't localized anywhere, is it? 418 * @see java.util.Calendar#getInstance() 419 */ 420 private static final String calendarClassName = "java.util.GregorianCalendar"; 421 422 /** 423 * Specifies if the date/time interpretation should be lenient. 424 * If the flag is set, a date such as "February 30, 1996" will be 425 * treated as the 29th day after the February 1. If this flag 426 * is false, such dates will cause an exception. 427 * @serial 428 */ 429 private boolean lenient; 430 431 /** 432 * Sets what the first day of week is. This is used for 433 * WEEK_OF_MONTH and WEEK_OF_YEAR fields. 434 * @serial 435 */ 436 private int firstDayOfWeek; 437 438 /** 439 * Sets how many days are required in the first week of the year. 440 * If the first day of the year should be the first week you should 441 * set this value to 1. If the first week must be a full week, set 442 * it to 7. 443 * @serial 444 */ 445 private int minimalDaysInFirstWeek; 446 447 /** 448 * Is set to true if DST_OFFSET is explicitly set. In that case 449 * it's value overrides the value computed from the current 450 * time and the timezone. 451 */ 452 private boolean explicitDSTOffset = false; 453 454 /** 455 * The version of the serialized data on the stream. 456 * <dl><dt>0 or not present</dt> 457 * <dd> JDK 1.1.5 or later.</dd> 458 * <dt>1</dt> 459 * <dd>JDK 1.1.6 or later. This always writes a correct `time' value 460 * on the stream, as well as the other fields, to be compatible with 461 * earlier versions</dd></dl> 462 * @since JDK1.1.6 463 * @serial 464 */ 465 private int serialVersionOnStream = 1; 466 467 /** 468 * XXX - I have not checked the compatibility. The documentation of 469 * the serialized-form is quite hairy... 470 */ 471 static final long serialVersionUID = -1807547505821590642L; 472 473 /** 474 * The name of the resource bundle. Used only by getBundle() 475 */ 476 private static final String bundleName = "gnu.java.locale.LocaleInformation"; 477 478 /** 479 * get resource bundle: 480 * The resources should be loaded via this method only. Iff an application 481 * uses this method, the resourcebundle is required. 482 */ getBundle(Locale locale)483 private static ResourceBundle getBundle(Locale locale) 484 { 485 return ResourceBundle.getBundle(bundleName, locale, 486 ClassLoader.getSystemClassLoader()); 487 } 488 489 /** 490 * The set of properties for obtaining the minimum number of days in 491 * the first week. 492 */ 493 private static transient final Properties properties; 494 495 /** 496 * Reads in the properties. 497 */ 498 static 499 { 500 properties = new Properties(); 501 try 502 { 503 properties.load(Calendar.class.getResourceAsStream("weeks.properties")); 504 } 505 catch (IOException exception) 506 { 507 System.out.println("Failed to load weeks resource: " + exception); 508 } 509 } 510 511 /** 512 * Constructs a new Calendar with the default time zone and the default 513 * locale. 514 */ Calendar()515 protected Calendar() 516 { 517 this(TimeZone.getDefault(), Locale.getDefault()); 518 } 519 520 /** 521 * Constructs a new Calendar with the given time zone and the given 522 * locale. 523 * @param zone a time zone. 524 * @param locale a locale. 525 */ Calendar(TimeZone zone, Locale locale)526 protected Calendar(TimeZone zone, Locale locale) 527 { 528 this.zone = zone; 529 lenient = true; 530 String[] days = { "", "sun", "mon", "tue", "wed", "thu", "fri", "sat" }; 531 532 String country = locale.getCountry(); 533 String min = properties.getProperty("minDays." + country); 534 if (min == null) 535 min = properties.getProperty("minDays.DEFAULT"); 536 String first = properties.getProperty("firstDay." + country); 537 if (first == null) 538 first = properties.getProperty("firstDay.DEFAULT"); 539 try 540 { 541 if (min != null) 542 minimalDaysInFirstWeek = Integer.parseInt(min); 543 } 544 catch (NumberFormatException ex) 545 { 546 minimalDaysInFirstWeek = 1; 547 } 548 549 firstDayOfWeek = 1; 550 if (first != null) 551 for (int i = 0; i < 8; i++) 552 if (days[i].equals(first)) 553 firstDayOfWeek = i; 554 555 clear(); 556 } 557 558 /** 559 * Creates a calendar representing the actual time, using the default 560 * time zone and locale. 561 * 562 * @return The new calendar. 563 */ getInstance()564 public static synchronized Calendar getInstance() 565 { 566 return getInstance(TimeZone.getDefault(), Locale.getDefault()); 567 } 568 569 /** 570 * Creates a calendar representing the actual time, using the given 571 * time zone and the default locale. 572 * 573 * @param zone a time zone (<code>null</code> not permitted). 574 * 575 * @return The new calendar. 576 * 577 * @throws NullPointerException if <code>zone</code> is <code>null</code>. 578 */ getInstance(TimeZone zone)579 public static synchronized Calendar getInstance(TimeZone zone) 580 { 581 return getInstance(zone, Locale.getDefault()); 582 } 583 584 /** 585 * Creates a calendar representing the actual time, using the default 586 * time zone and the given locale. 587 * 588 * @param locale a locale (<code>null</code> not permitted). 589 * 590 * @return The new calendar. 591 * 592 * @throws NullPointerException if <code>locale</code> is <code>null</code>. 593 */ getInstance(Locale locale)594 public static synchronized Calendar getInstance(Locale locale) 595 { 596 return getInstance(TimeZone.getDefault(), locale); 597 } 598 599 /** 600 * Cache of locale->calendar-class mappings. This avoids having to do a ResourceBundle 601 * lookup for every getInstance call. 602 */ 603 private static final HashMap<Locale,Class> cache = new HashMap<Locale,Class>(); 604 605 /** Preset argument types for calendar-class constructor lookup. */ 606 private static Class[] ctorArgTypes = new Class[] 607 { 608 TimeZone.class, Locale.class 609 }; 610 611 /** 612 * Creates a calendar representing the actual time, using the given 613 * time zone and locale. 614 * 615 * @param zone a time zone (<code>null</code> not permitted). 616 * @param locale a locale (<code>null</code> not permitted). 617 * 618 * @return The new calendar. 619 * 620 * @throws NullPointerException if <code>zone</code> or <code>locale</code> 621 * is <code>null</code>. 622 */ getInstance(TimeZone zone, Locale locale)623 public static synchronized Calendar getInstance(TimeZone zone, Locale locale) 624 { 625 Class calendarClass = cache.get(locale); 626 Throwable exception = null; 627 628 try 629 { 630 if (calendarClass == null) 631 { 632 calendarClass = Class.forName(calendarClassName); 633 if (Calendar.class.isAssignableFrom(calendarClass)) 634 cache.put(locale, calendarClass); 635 } 636 637 // GregorianCalendar is by far the most common case. Optimize by 638 // avoiding reflection. 639 if (calendarClass == GregorianCalendar.class) 640 return new GregorianCalendar(zone, locale); 641 642 if (Calendar.class.isAssignableFrom(calendarClass)) 643 { 644 Constructor ctor = calendarClass.getConstructor(ctorArgTypes); 645 return (Calendar) ctor.newInstance(new Object[] { zone, locale }); 646 } 647 } 648 catch (ClassNotFoundException ex) 649 { 650 exception = ex; 651 } 652 catch (IllegalAccessException ex) 653 { 654 exception = ex; 655 } 656 catch (NoSuchMethodException ex) 657 { 658 exception = ex; 659 } 660 catch (InstantiationException ex) 661 { 662 exception = ex; 663 } 664 catch (InvocationTargetException ex) 665 { 666 exception = ex; 667 } 668 669 throw new RuntimeException("Error instantiating calendar for locale " 670 + locale, exception); 671 } 672 673 /** 674 * Gets the set of locales for which a Calendar is available. 675 * @exception MissingResourceException if locale data couldn't be found. 676 * @return the set of locales. 677 */ getAvailableLocales()678 public static synchronized Locale[] getAvailableLocales() 679 { 680 ResourceBundle rb = getBundle(new Locale("", "")); 681 return (Locale[]) rb.getObject("availableLocales"); 682 } 683 684 /** 685 * Converts the time field values (<code>fields</code>) to 686 * milliseconds since the epoch UTC (<code>time</code>). Override 687 * this method if you write your own Calendar. */ computeTime()688 protected abstract void computeTime(); 689 690 /** 691 * Converts the milliseconds since the epoch UTC 692 * (<code>time</code>) to time fields 693 * (<code>fields</code>). Override this method if you write your 694 * own Calendar. 695 */ computeFields()696 protected abstract void computeFields(); 697 698 /** 699 * Converts the time represented by this object to a 700 * <code>Date</code>-Object. 701 * @return the Date. 702 */ getTime()703 public final Date getTime() 704 { 705 if (! isTimeSet) 706 computeTime(); 707 return new Date(time); 708 } 709 710 /** 711 * Sets this Calendar's time to the given Date. All time fields 712 * are invalidated by this method. 713 * 714 * @param date the date (<code>null</code> not permitted). 715 * 716 * @throws NullPointerException if <code>date</code> is <code>null</code>. 717 */ setTime(Date date)718 public final void setTime(Date date) 719 { 720 setTimeInMillis(date.getTime()); 721 } 722 723 /** 724 * Returns the time represented by this Calendar. 725 * @return the time in milliseconds since the epoch. 726 * @specnote This was made public in 1.4. 727 */ getTimeInMillis()728 public long getTimeInMillis() 729 { 730 if (! isTimeSet) 731 computeTime(); 732 return time; 733 } 734 735 /** 736 * Sets this Calendar's time to the given Time. All time fields 737 * are invalidated by this method. 738 * @param time the time in milliseconds since the epoch 739 * @specnote This was made public in 1.4. 740 */ setTimeInMillis(long time)741 public void setTimeInMillis(long time) 742 { 743 clear(); 744 this.time = time; 745 isTimeSet = true; 746 computeFields(); 747 } 748 749 /** 750 * Gets the value of the specified field. They are recomputed 751 * if they are invalid. 752 * @param field the time field. One of the time field constants. 753 * @return the value of the specified field 754 * @throws ArrayIndexOutOfBoundsException if the field is outside 755 * the valid range. The value of field must be >= 0 and 756 * <= <code>FIELD_COUNT</code>. 757 * @specnote Not final since JDK 1.4 758 */ get(int field)759 public int get(int field) 760 { 761 // If the requested field is invalid, force all fields to be recomputed. 762 if (! isSet[field]) 763 areFieldsSet = false; 764 complete(); 765 return fields[field]; 766 } 767 768 /** 769 * Gets the value of the specified field. This method doesn't 770 * recompute the fields, if they are invalid. 771 * @param field the time field. One of the time field constants. 772 * @return the value of the specified field, undefined if 773 * <code>areFieldsSet</code> or <code>isSet[field]</code> is false. 774 * @throws ArrayIndexOutOfBoundsException if the field is outside 775 * the valid range. The value of field must be >= 0 and 776 * <= <code>FIELD_COUNT</code>. 777 */ internalGet(int field)778 protected final int internalGet(int field) 779 { 780 return fields[field]; 781 } 782 783 /** 784 * Sets the time field with the given value. This does invalidate 785 * the time in milliseconds. 786 * @param field the time field. One of the time field constants 787 * @param value the value to be set. 788 * @throws ArrayIndexOutOfBoundsException if field is outside 789 * the valid range. The value of field must be >= 0 and 790 * <= <code>FIELD_COUNT</code>. 791 * @specnote Not final since JDK 1.4 792 */ set(int field, int value)793 public void set(int field, int value) 794 { 795 if (isTimeSet) 796 for (int i = 0; i < FIELD_COUNT; i++) 797 isSet[i] = false; 798 isTimeSet = false; 799 fields[field] = value; 800 isSet[field] = true; 801 802 // The five valid date patterns, in order of priority 803 // 1 YEAR + MONTH + DAY_OF_MONTH 804 // 2 YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK 805 // 3 YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK 806 // 4 YEAR + DAY_OF_YEAR 807 // 5 YEAR + DAY_OF_WEEK + WEEK_OF_YEAR 808 switch (field) 809 { 810 case MONTH: // pattern 1,2 or 3 811 isSet[DAY_OF_YEAR] = false; 812 isSet[WEEK_OF_YEAR] = false; 813 break; 814 case DAY_OF_MONTH: // pattern 1 815 isSet[YEAR] = true; 816 isSet[MONTH] = true; 817 isSet[WEEK_OF_MONTH] = true; 818 isSet[DAY_OF_WEEK] = false; 819 isSet[DAY_OF_WEEK_IN_MONTH] = false; 820 isSet[DAY_OF_YEAR] = false; 821 isSet[WEEK_OF_YEAR] = false; 822 break; 823 case WEEK_OF_MONTH: // pattern 2 824 if (! isSet[DAY_OF_WEEK]) 825 fields[DAY_OF_WEEK] = getFirstDayOfWeek(); 826 isSet[YEAR] = true; 827 isSet[MONTH] = true; 828 isSet[DAY_OF_WEEK] = true; 829 isSet[DAY_OF_MONTH] = false; 830 isSet[DAY_OF_WEEK_IN_MONTH] = false; 831 isSet[DAY_OF_YEAR] = false; 832 isSet[WEEK_OF_YEAR] = false; 833 break; 834 case DAY_OF_WEEK_IN_MONTH: // pattern 3 835 if (! isSet[DAY_OF_WEEK]) 836 fields[DAY_OF_WEEK] = getFirstDayOfWeek(); 837 isSet[YEAR] = true; 838 isSet[MONTH] = true; 839 isSet[DAY_OF_WEEK] = true; 840 isSet[DAY_OF_YEAR] = false; 841 isSet[DAY_OF_MONTH] = false; 842 isSet[WEEK_OF_MONTH] = false; 843 isSet[WEEK_OF_YEAR] = false; 844 break; 845 case DAY_OF_YEAR: // pattern 4 846 isSet[YEAR] = true; 847 isSet[MONTH] = false; 848 isSet[WEEK_OF_MONTH] = false; 849 isSet[DAY_OF_MONTH] = false; 850 isSet[DAY_OF_WEEK] = false; 851 isSet[WEEK_OF_YEAR] = false; 852 isSet[DAY_OF_WEEK_IN_MONTH] = false; 853 break; 854 case WEEK_OF_YEAR: // pattern 5 855 if (! isSet[DAY_OF_WEEK]) 856 fields[DAY_OF_WEEK] = getFirstDayOfWeek(); 857 isSet[YEAR] = true; 858 isSet[DAY_OF_WEEK] = true; 859 isSet[MONTH] = false; 860 isSet[DAY_OF_MONTH] = false; 861 isSet[WEEK_OF_MONTH] = false; 862 isSet[DAY_OF_YEAR] = false; 863 isSet[DAY_OF_WEEK_IN_MONTH] = false; 864 break; 865 case AM_PM: 866 isSet[HOUR] = true; 867 isSet[HOUR_OF_DAY] = false; 868 break; 869 case HOUR_OF_DAY: 870 isSet[AM_PM] = false; 871 isSet[HOUR] = false; 872 break; 873 case HOUR: 874 isSet[AM_PM] = true; 875 isSet[HOUR_OF_DAY] = false; 876 break; 877 case DST_OFFSET: 878 explicitDSTOffset = true; 879 } 880 881 // May have crossed over a DST boundary. 882 if (! explicitDSTOffset && (field != DST_OFFSET && field != ZONE_OFFSET)) 883 isSet[DST_OFFSET] = false; 884 } 885 886 /** 887 * Sets the fields for year, month, and date 888 * @param year the year. 889 * @param month the month, one of the constants JANUARY..UNDICEMBER. 890 * @param date the day of the month 891 */ set(int year, int month, int date)892 public final void set(int year, int month, int date) 893 { 894 isTimeSet = false; 895 fields[YEAR] = year; 896 fields[MONTH] = month; 897 fields[DATE] = date; 898 isSet[YEAR] = isSet[MONTH] = isSet[DATE] = true; 899 isSet[WEEK_OF_YEAR] = false; 900 isSet[DAY_OF_YEAR] = false; 901 isSet[WEEK_OF_MONTH] = false; 902 isSet[DAY_OF_WEEK] = false; 903 isSet[DAY_OF_WEEK_IN_MONTH] = false; 904 isSet[ERA] = false; 905 906 if (! explicitDSTOffset) 907 isSet[DST_OFFSET] = false; // May have crossed a DST boundary. 908 } 909 910 /** 911 * Sets the fields for year, month, date, hour, and minute 912 * @param year the year. 913 * @param month the month, one of the constants JANUARY..UNDICEMBER. 914 * @param date the day of the month 915 * @param hour the hour of day. 916 * @param minute the minute. 917 */ set(int year, int month, int date, int hour, int minute)918 public final void set(int year, int month, int date, int hour, int minute) 919 { 920 set(year, month, date); 921 fields[HOUR_OF_DAY] = hour; 922 fields[MINUTE] = minute; 923 isSet[HOUR_OF_DAY] = isSet[MINUTE] = true; 924 isSet[AM_PM] = false; 925 isSet[HOUR] = false; 926 } 927 928 /** 929 * Sets the fields for year, month, date, hour, and minute 930 * @param year the year. 931 * @param month the month, one of the constants JANUARY..UNDICEMBER. 932 * @param date the day of the month 933 * @param hour the hour of day. 934 * @param minute the minute. 935 * @param second the second. 936 */ set(int year, int month, int date, int hour, int minute, int second)937 public final void set(int year, int month, int date, int hour, int minute, 938 int second) 939 { 940 set(year, month, date, hour, minute); 941 fields[SECOND] = second; 942 isSet[SECOND] = true; 943 } 944 945 /** 946 * Clears the values of all the time fields. 947 */ clear()948 public final void clear() 949 { 950 isTimeSet = false; 951 areFieldsSet = false; 952 int zoneOffs = zone.getRawOffset(); 953 int[] tempFields = 954 { 955 1, 1970, JANUARY, 1, 1, 1, 1, THURSDAY, 1, AM, 0, 0, 0, 956 0, 0, zoneOffs, 0 957 }; 958 fields = tempFields; 959 for (int i = 0; i < FIELD_COUNT; i++) 960 isSet[i] = false; 961 } 962 963 /** 964 * Clears the values of the specified time field. 965 * @param field the time field. One of the time field constants. 966 * @throws ArrayIndexOutOfBoundsException if field is outside 967 * the valid range. The value of field must be >= 0 and 968 * <= <code>FIELD_COUNT</code>. 969 */ clear(int field)970 public final void clear(int field) 971 { 972 int[] tempFields = 973 { 974 1, 1970, JANUARY, 1, 1, 1, 1, THURSDAY, 1, AM, 0, 0, 0, 975 0, 0, zone.getRawOffset(), 0 976 }; 977 complete(); 978 isTimeSet = false; 979 areFieldsSet = false; 980 isSet[field] = false; 981 fields[field] = tempFields[field]; 982 } 983 984 /** 985 * Determines if the specified field has a valid value. 986 * @return true if the specified field has a value. 987 * @throws ArrayIndexOutOfBoundsException if the field is outside 988 * the valid range. The value of field must be >= 0 and 989 * <= <code>FIELD_COUNT</code>. 990 */ isSet(int field)991 public final boolean isSet(int field) 992 { 993 return isSet[field]; 994 } 995 996 /** 997 * Fills any unset fields in the time field list 998 */ complete()999 protected void complete() 1000 { 1001 if (! isTimeSet) 1002 computeTime(); 1003 if (! areFieldsSet) 1004 computeFields(); 1005 } 1006 1007 /** 1008 * Compares the given calendar with this. 1009 * @param o the object to that we should compare. 1010 * @return true, if the given object is a calendar, that represents 1011 * the same time (but doesn't necessary have the same fields). 1012 */ equals(Object o)1013 public boolean equals(Object o) 1014 { 1015 if (! (o instanceof Calendar)) 1016 return false; 1017 Calendar cal = (Calendar) o; 1018 if (getTimeInMillis() == ((Calendar) o).getTimeInMillis() 1019 && cal.getFirstDayOfWeek() == getFirstDayOfWeek() 1020 && cal.isLenient() == isLenient() 1021 && cal.getMinimalDaysInFirstWeek() == getMinimalDaysInFirstWeek()) 1022 { 1023 TimeZone self = getTimeZone(); 1024 TimeZone oth = cal.getTimeZone(); 1025 return self == null ? oth == null : self.equals(oth); 1026 } 1027 return false; 1028 } 1029 1030 /** 1031 * Returns a hash code for this calendar. 1032 * @return a hash code, which fullfits the general contract of 1033 * <code>hashCode()</code> 1034 */ hashCode()1035 public int hashCode() 1036 { 1037 long time = getTimeInMillis(); 1038 int val = (int) ((time & 0xffffffffL) ^ (time >> 32)); 1039 val += (getFirstDayOfWeek() + (isLenient() ? 1230 : 1237) 1040 + getMinimalDaysInFirstWeek()); 1041 TimeZone self = getTimeZone(); 1042 if (self != null) 1043 val ^= self.hashCode(); 1044 return val; 1045 } 1046 1047 /** 1048 * Compares the given calendar with this. 1049 * @param o the object to that we should compare. 1050 * @return true, if the given object is a calendar, and this calendar 1051 * represents a smaller time than the calendar o. 1052 * @exception ClassCastException if o is not an calendar. 1053 * @since JDK1.2 you don't need to override this method 1054 */ before(Object o)1055 public boolean before(Object o) 1056 { 1057 return getTimeInMillis() < ((Calendar) o).getTimeInMillis(); 1058 } 1059 1060 /** 1061 * Compares the given calendar with this. 1062 * @param o the object to that we should compare. 1063 * @return true, if the given object is a calendar, and this calendar 1064 * represents a bigger time than the calendar o. 1065 * @exception ClassCastException if o is not an calendar. 1066 * @since JDK1.2 you don't need to override this method 1067 */ after(Object o)1068 public boolean after(Object o) 1069 { 1070 return getTimeInMillis() > ((Calendar) o).getTimeInMillis(); 1071 } 1072 1073 /** 1074 * Adds the specified amount of time to the given time field. The 1075 * amount may be negative to subtract the time. If the field overflows 1076 * it does what you expect: Jan, 25 + 10 Days is Feb, 4. 1077 * @param field the time field. One of the time field constants. 1078 * @param amount the amount of time. 1079 * @throws ArrayIndexOutOfBoundsException if the field is outside 1080 * the valid range. The value of field must be >= 0 and 1081 * <= <code>FIELD_COUNT</code>. 1082 */ add(int field, int amount)1083 public abstract void add(int field, int amount); 1084 1085 /** 1086 * Rolls the specified time field up or down. This means add one 1087 * to the specified field, but don't change the other fields. If 1088 * the maximum for this field is reached, start over with the 1089 * minimum value. <br> 1090 * 1091 * <strong>Note:</strong> There may be situation, where the other 1092 * fields must be changed, e.g rolling the month on May, 31. 1093 * The date June, 31 is automatically converted to July, 1. 1094 * @param field the time field. One of the time field constants. 1095 * @param up the direction, true for up, false for down. 1096 * @throws ArrayIndexOutOfBoundsException if the field is outside 1097 * the valid range. The value of field must be >= 0 and 1098 * <= <code>FIELD_COUNT</code>. 1099 */ roll(int field, boolean up)1100 public abstract void roll(int field, boolean up); 1101 1102 /** 1103 * Rolls up or down the specified time field by the given amount. 1104 * A negative amount rolls down. The default implementation is 1105 * call <code>roll(int, boolean)</code> for the specified amount. 1106 * 1107 * Subclasses should override this method to do more intuitiv things. 1108 * 1109 * @param field the time field. One of the time field constants. 1110 * @param amount the amount to roll by, positive for rolling up, 1111 * negative for rolling down. 1112 * @throws ArrayIndexOutOfBoundsException if the field is outside 1113 * the valid range. The value of field must be >= 0 and 1114 * <= <code>FIELD_COUNT</code>. 1115 * @since JDK1.2 1116 */ roll(int field, int amount)1117 public void roll(int field, int amount) 1118 { 1119 while (amount > 0) 1120 { 1121 roll(field, true); 1122 amount--; 1123 } 1124 while (amount < 0) 1125 { 1126 roll(field, false); 1127 amount++; 1128 } 1129 } 1130 1131 /** 1132 * Sets the time zone to the specified value. 1133 * @param zone the new time zone 1134 */ setTimeZone(TimeZone zone)1135 public void setTimeZone(TimeZone zone) 1136 { 1137 this.zone = zone; 1138 computeTime(); 1139 computeFields(); 1140 } 1141 1142 /** 1143 * Gets the time zone of this calendar 1144 * @return the current time zone. 1145 */ getTimeZone()1146 public TimeZone getTimeZone() 1147 { 1148 return zone; 1149 } 1150 1151 /** 1152 * Specifies if the date/time interpretation should be lenient. 1153 * If the flag is set, a date such as "February 30, 1996" will be 1154 * treated as the 29th day after the February 1. If this flag 1155 * is false, such dates will cause an exception. 1156 * @param lenient true, if the date should be interpreted linient, 1157 * false if it should be interpreted strict. 1158 */ setLenient(boolean lenient)1159 public void setLenient(boolean lenient) 1160 { 1161 this.lenient = lenient; 1162 } 1163 1164 /** 1165 * Tells if the date/time interpretation is lenient. 1166 * @return true, if the date should be interpreted linient, 1167 * false if it should be interpreted strict. 1168 */ isLenient()1169 public boolean isLenient() 1170 { 1171 return lenient; 1172 } 1173 1174 /** 1175 * Sets what the first day of week is. This is used for 1176 * WEEK_OF_MONTH and WEEK_OF_YEAR fields. 1177 * @param value the first day of week. One of SUNDAY to SATURDAY. 1178 */ setFirstDayOfWeek(int value)1179 public void setFirstDayOfWeek(int value) 1180 { 1181 firstDayOfWeek = value; 1182 } 1183 1184 /** 1185 * Gets what the first day of week is. This is used for 1186 * WEEK_OF_MONTH and WEEK_OF_YEAR fields. 1187 * @return the first day of week. One of SUNDAY to SATURDAY. 1188 */ getFirstDayOfWeek()1189 public int getFirstDayOfWeek() 1190 { 1191 return firstDayOfWeek; 1192 } 1193 1194 /** 1195 * Sets how many days are required in the first week of the year. 1196 * If the first day of the year should be the first week you should 1197 * set this value to 1. If the first week must be a full week, set 1198 * it to 7. 1199 * @param value the minimal days required in the first week. 1200 */ setMinimalDaysInFirstWeek(int value)1201 public void setMinimalDaysInFirstWeek(int value) 1202 { 1203 minimalDaysInFirstWeek = value; 1204 } 1205 1206 /** 1207 * Gets how many days are required in the first week of the year. 1208 * @return the minimal days required in the first week. 1209 * @see #setMinimalDaysInFirstWeek 1210 */ getMinimalDaysInFirstWeek()1211 public int getMinimalDaysInFirstWeek() 1212 { 1213 return minimalDaysInFirstWeek; 1214 } 1215 1216 /** 1217 * Gets the smallest value that is allowed for the specified field. 1218 * @param field the time field. One of the time field constants. 1219 * @return the smallest value. 1220 */ getMinimum(int field)1221 public abstract int getMinimum(int field); 1222 1223 /** 1224 * Gets the biggest value that is allowed for the specified field. 1225 * @param field the time field. One of the time field constants. 1226 * @return the biggest value. 1227 */ getMaximum(int field)1228 public abstract int getMaximum(int field); 1229 1230 /** 1231 * Gets the greatest minimum value that is allowed for the specified field. 1232 * @param field the time field. One of the time field constants. 1233 * @return the greatest minimum value. 1234 */ getGreatestMinimum(int field)1235 public abstract int getGreatestMinimum(int field); 1236 1237 /** 1238 * Gets the smallest maximum value that is allowed for the 1239 * specified field. For example this is 28 for DAY_OF_MONTH. 1240 * @param field the time field. One of the time field constants. 1241 * @return the least maximum value. 1242 */ getLeastMaximum(int field)1243 public abstract int getLeastMaximum(int field); 1244 1245 /** 1246 * Gets the actual minimum value that is allowed for the specified field. 1247 * This value is dependent on the values of the other fields. 1248 * @param field the time field. One of the time field constants. 1249 * @return the actual minimum value. 1250 * @throws ArrayIndexOutOfBoundsException if the field is outside 1251 * the valid range. The value of field must be >= 0 and 1252 * <= <code>FIELD_COUNT</code>. 1253 * @since jdk1.2 1254 */ getActualMinimum(int field)1255 public int getActualMinimum(int field) 1256 { 1257 Calendar tmp = (Calendar) clone(); // To avoid restoring state 1258 int min = tmp.getGreatestMinimum(field); 1259 int end = tmp.getMinimum(field); 1260 tmp.set(field, min); 1261 for (; min > end; min--) 1262 { 1263 tmp.add(field, -1); // Try to get smaller 1264 if (tmp.get(field) != min - 1) 1265 break; // Done if not successful 1266 } 1267 return min; 1268 } 1269 1270 /** 1271 * Gets the actual maximum value that is allowed for the specified field. 1272 * This value is dependent on the values of the other fields. 1273 * @param field the time field. One of the time field constants. 1274 * @return the actual maximum value. 1275 * @throws ArrayIndexOutOfBoundsException if the field is outside 1276 * the valid range. The value of field must be >= 0 and 1277 * <= <code>FIELD_COUNT</code>. 1278 * @since jdk1.2 1279 */ getActualMaximum(int field)1280 public int getActualMaximum(int field) 1281 { 1282 Calendar tmp = (Calendar) clone(); // To avoid restoring state 1283 int max = tmp.getLeastMaximum(field); 1284 int end = tmp.getMaximum(field); 1285 tmp.set(field, max); 1286 for (; max < end; max++) 1287 { 1288 tmp.add(field, 1); 1289 if (tmp.get(field) != max + 1) 1290 break; 1291 } 1292 return max; 1293 } 1294 1295 /** 1296 * Compares the time of two calendar instances. 1297 * @param cal the calendar to which the time should be compared. 1298 * @return 0 if the two calendars are set to the same time, 1299 * less than 0 if the time of this calendar is before that of 1300 * <code>cal</code>, or more than 0 if the time of this calendar is after 1301 * that of <code>cal</code>. 1302 * 1303 * @param cal the calendar to compare this instance with. 1304 * @throws NullPointerException if <code>cal</code> is null. 1305 * @throws IllegalArgumentException if either calendar has fields set to 1306 * invalid values. 1307 * @since 1.5 1308 */ compareTo(Calendar cal)1309 public int compareTo(Calendar cal) 1310 { 1311 long t1 = getTimeInMillis(); 1312 long t2 = cal.getTimeInMillis(); 1313 if(t1 == t2) 1314 return 0; 1315 if(t1 > t2) 1316 return 1; 1317 return -1; 1318 } 1319 1320 /** 1321 * Return a clone of this object. 1322 */ clone()1323 public Object clone() 1324 { 1325 try 1326 { 1327 Calendar cal = (Calendar) super.clone(); 1328 cal.fields = (int[]) fields.clone(); 1329 cal.isSet = (boolean[]) isSet.clone(); 1330 return cal; 1331 } 1332 catch (CloneNotSupportedException ex) 1333 { 1334 return null; 1335 } 1336 } 1337 1338 private static final String[] fieldNames = 1339 { 1340 ",ERA=", ",YEAR=", ",MONTH=", 1341 ",WEEK_OF_YEAR=", 1342 ",WEEK_OF_MONTH=", 1343 ",DAY_OF_MONTH=", 1344 ",DAY_OF_YEAR=", ",DAY_OF_WEEK=", 1345 ",DAY_OF_WEEK_IN_MONTH=", 1346 ",AM_PM=", ",HOUR=", 1347 ",HOUR_OF_DAY=", ",MINUTE=", 1348 ",SECOND=", ",MILLISECOND=", 1349 ",ZONE_OFFSET=", ",DST_OFFSET=" 1350 }; 1351 1352 /** 1353 * Returns a string representation of this object. It is mainly 1354 * for debugging purposes and its content is implementation 1355 * specific. 1356 */ toString()1357 public String toString() 1358 { 1359 CPStringBuilder sb = new CPStringBuilder(getClass().getName()); 1360 sb.append('['); 1361 sb.append("time="); 1362 if (isTimeSet) 1363 sb.append(time); 1364 else 1365 sb.append("?"); 1366 sb.append(",zone=" + zone); 1367 sb.append(",areFieldsSet=" + areFieldsSet); 1368 for (int i = 0; i < FIELD_COUNT; i++) 1369 { 1370 sb.append(fieldNames[i]); 1371 if (isSet[i]) 1372 sb.append(fields[i]); 1373 else 1374 sb.append("?"); 1375 } 1376 sb.append(",lenient=").append(lenient); 1377 sb.append(",firstDayOfWeek=").append(firstDayOfWeek); 1378 sb.append(",minimalDaysInFirstWeek=").append(minimalDaysInFirstWeek); 1379 sb.append("]"); 1380 return sb.toString(); 1381 } 1382 1383 /** 1384 * Saves the state of the object to the stream. Ideally we would 1385 * only write the time field, but we need to be compatible with 1386 * earlier versions. <br> 1387 * 1388 * This doesn't write the JDK1.1 field nextStamp to the stream, as 1389 * I don't know what it is good for, and because the documentation 1390 * says, that it could be omitted. */ writeObject(ObjectOutputStream stream)1391 private void writeObject(ObjectOutputStream stream) throws IOException 1392 { 1393 if (! isTimeSet) 1394 computeTime(); 1395 stream.defaultWriteObject(); 1396 } 1397 1398 /** 1399 * Reads the object back from stream (deserialization). 1400 */ readObject(ObjectInputStream stream)1401 private void readObject(ObjectInputStream stream) 1402 throws IOException, ClassNotFoundException 1403 { 1404 stream.defaultReadObject(); 1405 if (! isTimeSet) 1406 computeTime(); 1407 1408 if (serialVersionOnStream > 1) 1409 { 1410 // This is my interpretation of the serial number: 1411 // Sun wants to remove all fields from the stream someday 1412 // and will then increase the serialVersion number again. 1413 // We prepare to be compatible. 1414 fields = new int[FIELD_COUNT]; 1415 isSet = new boolean[FIELD_COUNT]; 1416 areFieldsSet = false; 1417 } 1418 } 1419 1420 /** 1421 * Returns a localised textual representation of the current value 1422 * of the given field using the specified style. If there is no 1423 * applicable textual representation (e.g. the field has a numeric 1424 * value), then <code>null</code> is returned. If one does exist, 1425 * then the value is obtained from {@link #get(int)} and converted 1426 * appropriately. For example, if the <code>MONTH</code> field is 1427 * requested, then <code>get(MONTH)</code> is called. This is then 1428 * converted to a textual representation based on its value and 1429 * the style requested; if the <code>LONG</code> style is requested 1430 * and the returned value is <code>11</code> from a 1431 * {@link GregorianCalendar} implementation, then <code>"December"</code> 1432 * is returned. By default, a textual representation is available 1433 * for all fields which have an applicable value obtainable from 1434 * {@link java.text.DateFormatSymbols}. 1435 * 1436 * @param field the calendar field whose textual representation should 1437 * be obtained. 1438 * @param style the style to use; either {@link #LONG} or {@link #SHORT}. 1439 * @param locale the locale to use for translation. 1440 * @return the textual representation of the given field in the specified 1441 * style, or <code>null</code> if none is applicable. 1442 * @throws IllegalArgumentException if <code>field</code> or <code>style</code> 1443 * or invalid, or the calendar is non-lenient 1444 * and has invalid values. 1445 * @throws NullPointerException if <code>locale</code> is <code>null</code>. 1446 * @since 1.6 1447 */ getDisplayName(int field, int style, Locale locale)1448 public String getDisplayName(int field, int style, Locale locale) 1449 { 1450 if (field < 0 || field >= FIELD_COUNT) 1451 throw new IllegalArgumentException("The field value, " + field + 1452 ", is invalid."); 1453 if (style != SHORT && style != LONG) 1454 throw new IllegalArgumentException("The style must be either " + 1455 "short or long."); 1456 if (field == YEAR || field == WEEK_OF_YEAR || 1457 field == WEEK_OF_MONTH || field == DAY_OF_MONTH || 1458 field == DAY_OF_YEAR || field == DAY_OF_WEEK_IN_MONTH || 1459 field == HOUR || field == HOUR_OF_DAY || field == MINUTE || 1460 field == SECOND || field == MILLISECOND) 1461 return null; 1462 1463 int value = get(field); 1464 DateFormatSymbols syms = DateFormatSymbols.getInstance(locale); 1465 if (field == ERA) 1466 return syms.getEras()[value]; 1467 if (field == MONTH) 1468 if (style == LONG) 1469 return syms.getMonths()[value]; 1470 else 1471 return syms.getShortMonths()[value]; 1472 if (field == DAY_OF_WEEK) 1473 if (style == LONG) 1474 return syms.getWeekdays()[value]; 1475 else 1476 return syms.getShortWeekdays()[value]; 1477 if (field == AM_PM) 1478 return syms.getAmPmStrings()[value]; 1479 if (field == ZONE_OFFSET) 1480 if (style == LONG) 1481 return syms.getZoneStrings()[value][1]; 1482 else 1483 return syms.getZoneStrings()[value][2]; 1484 if (field == DST_OFFSET) 1485 if (style == LONG) 1486 return syms.getZoneStrings()[value][3]; 1487 else 1488 return syms.getZoneStrings()[value][4]; 1489 1490 throw new InternalError("Failed to resolve field " + field + 1491 " with style " + style + " for locale " + 1492 locale); 1493 } 1494 1495 /** 1496 * Returns a map linking all specified textual representations 1497 * of the given field to their numerical values. The textual 1498 * representations included are determined by the specified 1499 * style and locale. For example, if the style <code>LONG</code> 1500 * is specified and the German locale, then the map will 1501 * contain "Montag" to {@link #MONDAY}, "Dienstag" to 1502 * {@link #TUESDAY}, "Mittwoch" to {@link #WEDNESDAY} and 1503 * so on. The default implementation uses the values returned 1504 * by {@link DateFormatSymbols} so, for example, the style 1505 * {@link #ALL_STYLES} and the field {@link #MONTH} will return 1506 * a map filled with the values returned from 1507 * {@link DateFormatSymbols#getMonths()} and 1508 * {@link DateFormatSymbols#getShortMonths()}. If there are 1509 * no textual representations for a given field (usually because 1510 * it is purely numeric, such as the year in the 1511 * {@link GregorianCalendar}), <code>null</code> is returned. 1512 * 1513 * @param field the calendar field whose textual representation should 1514 * be obtained. 1515 * @param style the style to use; either {@link #LONG}, {@link #SHORT} 1516 * or {@link ALL_STYLES}. 1517 * @param locale the locale to use for translation. 1518 * @return a map of the textual representations of the given field in the 1519 * specified style to their numeric values, or <code>null</code> 1520 * if none is applicable. 1521 * @throws IllegalArgumentException if <code>field</code> or <code>style</code> 1522 * or invalid, or the calendar is non-lenient 1523 * and has invalid values. 1524 * @throws NullPointerException if <code>locale</code> is <code>null</code>. 1525 * @since 1.6 1526 */ getDisplayNames(int field, int style, Locale locale)1527 public Map<String,Integer> getDisplayNames(int field, int style, Locale locale) 1528 { 1529 if (field < 0 || field >= FIELD_COUNT) 1530 throw new IllegalArgumentException("The field value, " + field + 1531 ", is invalid."); 1532 if (style != SHORT && style != LONG && style != ALL_STYLES) 1533 throw new IllegalArgumentException("The style must be either " + 1534 "short, long or all styles."); 1535 if (field == YEAR || field == WEEK_OF_YEAR || 1536 field == WEEK_OF_MONTH || field == DAY_OF_MONTH || 1537 field == DAY_OF_YEAR || field == DAY_OF_WEEK_IN_MONTH || 1538 field == HOUR || field == HOUR_OF_DAY || field == MINUTE || 1539 field == SECOND || field == MILLISECOND) 1540 return null; 1541 1542 DateFormatSymbols syms = DateFormatSymbols.getInstance(locale); 1543 Map<String,Integer> map = new HashMap<String,Integer>(); 1544 if (field == ERA) 1545 { 1546 String[] eras = syms.getEras(); 1547 for (int a = 0; a < eras.length; ++a) 1548 map.put(eras[a], a); 1549 return map; 1550 } 1551 if (field == MONTH) 1552 { 1553 if (style == LONG || style == ALL_STYLES) 1554 { 1555 String[] months = syms.getMonths(); 1556 for (int a = 0; a < months.length; ++a) 1557 map.put(months[a], a); 1558 } 1559 if (style == SHORT || style == ALL_STYLES) 1560 { 1561 String[] months = syms.getShortMonths(); 1562 for (int a = 0; a < months.length; ++a) 1563 map.put(months[a], a); 1564 } 1565 return map; 1566 } 1567 if (field == DAY_OF_WEEK) 1568 { 1569 if (style == LONG || style == ALL_STYLES) 1570 { 1571 String[] weekdays = syms.getWeekdays(); 1572 for (int a = SUNDAY; a < weekdays.length; ++a) 1573 map.put(weekdays[a], a); 1574 } 1575 if (style == SHORT || style == ALL_STYLES) 1576 { 1577 String[] weekdays = syms.getShortWeekdays(); 1578 for (int a = SUNDAY; a < weekdays.length; ++a) 1579 map.put(weekdays[a], a); 1580 } 1581 return map; 1582 } 1583 if (field == AM_PM) 1584 { 1585 String[] ampms = syms.getAmPmStrings(); 1586 for (int a = 0; a < ampms.length; ++a) 1587 map.put(ampms[a], a); 1588 return map; 1589 } 1590 if (field == ZONE_OFFSET) 1591 { 1592 String[][] zones = syms.getZoneStrings(); 1593 for (int a = 0; a < zones.length; ++a) 1594 { 1595 if (style == LONG || style == ALL_STYLES) 1596 map.put(zones[a][1], a); 1597 if (style == SHORT || style == ALL_STYLES) 1598 map.put(zones[a][2], a); 1599 } 1600 return map; 1601 } 1602 if (field == DST_OFFSET) 1603 { 1604 String[][] zones = syms.getZoneStrings(); 1605 for (int a = 0; a < zones.length; ++a) 1606 { 1607 if (style == LONG || style == ALL_STYLES) 1608 map.put(zones[a][3], a); 1609 if (style == SHORT || style == ALL_STYLES) 1610 map.put(zones[a][4], a); 1611 } 1612 return map; 1613 } 1614 1615 throw new InternalError("Failed to resolve field " + field + 1616 " with style " + style + " for locale " + 1617 locale); 1618 } 1619 1620 } 1621