KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > joda > time > Chronology


1 /*
2  * Copyright 2001-2005 Stephen Colebourne
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 package org.joda.time;
17
18 import org.joda.time.chrono.BuddhistChronology;
19 import org.joda.time.chrono.CopticChronology;
20 import org.joda.time.chrono.GJChronology;
21 import org.joda.time.chrono.GregorianChronology;
22 import org.joda.time.chrono.ISOChronology;
23 import org.joda.time.chrono.JulianChronology;
24
25 /**
26  * Chronology provides access to the individual date time fields for a
27  * chronological calendar system.
28  * <p>
29  * Various chronologies are supported by subclasses including ISO
30  * and GregorianJulian. To construct a Chronology you should use the
31  * factory methods on the chronology subclass in the chrono package.
32  * <p>
33  * For example, to obtain the current time in the coptic calendar system:
34  * <pre>
35  * DateTime dt = new DateTime(CopticChronology.getInstance());
36  * </pre>
37  * <p>
38  * The provided chronology implementations are:
39  * <ul>
40  * <li>ISO - Based on the ISO8601 standard and suitable for use after about 1600
41  * <li>GJ - Historically accurate calendar with Julian followed by Gregorian
42  * <li>Gregorian - The Gregorian calendar system used for all time (proleptic)
43  * <li>Julian - The Julian calendar system used for all time (proleptic)
44  * <li>Buddhist - The Buddhist calendar system which is an offset in years from GJ
45  * <li>Coptic - The Coptic calendar system which defines 30 day months
46  * <li>Ethiopic - The Ethiopic calendar system which defines 30 day months
47  * </ul>
48  * Hopefully future releases will contain more chronologies.
49  * <p>
50  * This class defines a number of fields with names from the ISO8601 standard.
51  * It does not 'strongly' define these fields however, thus implementations
52  * are free to interpret the field names as they wish.
53  * For example, a week could be defined as 10 days and a month as 40 days in a
54  * special WeirdChronology implementation. Clearly the GJ and ISO
55  * implementations provided use the field names as you would expect.
56  *
57  * @see org.joda.time.chrono.ISOChronology
58  * @see org.joda.time.chrono.GJChronology
59  * @see org.joda.time.chrono.GregorianChronology
60  * @see org.joda.time.chrono.JulianChronology
61  * @see org.joda.time.chrono.CopticChronology
62  * @see org.joda.time.chrono.BuddhistChronology
63  * @see org.joda.time.chrono.EthiopicChronology
64  *
65  * @author Stephen Colebourne
66  * @author Brian S O'Neill
67  * @since 1.0
68  */

69 public abstract class Chronology {
70
71     /**
72      * Gets an instance of the ISOChronology in the default zone.
73      * <p>
74      * {@link ISOChronology} defines all fields in line with the ISO8601 standard.
75      * This chronology is the default, and is suitable for all normal datetime processing.
76      * It is <i>unsuitable</i> for historical datetimes before October 15, 1582
77      * as it applies the modern Gregorian calendar rules before that date.
78      *
79      * @return the ISO chronology
80      * @deprecated Use ISOChronology.getInstance()
81      */

82     public static Chronology getISO() {
83         return ISOChronology.getInstance();
84     }
85
86     /**
87      * Gets an instance of the ISOChronology in the UTC zone.
88      * <p>
89      * {@link ISOChronology} defines all fields in line with the ISO8601 standard.
90      * This chronology is the default, and is suitable for all normal datetime processing.
91      * It is <i>unsuitable</i> for historical datetimes before October 15, 1582
92      * as it applies the modern Gregorian calendar rules before that date.
93      *
94      * @return the ISO chronology
95      * @deprecated Use ISOChronology.getInstanceUTC()
96      */

97     public static Chronology getISOUTC() {
98         return ISOChronology.getInstanceUTC();
99     }
100
101     /**
102      * Gets an instance of the ISOChronology in the specified zone.
103      * <p>
104      * {@link ISOChronology} defines all fields in line with the ISO8601 standard.
105      * This chronology is the default, and is suitable for all normal datetime processing.
106      * It is <i>unsuitable</i> for historical datetimes before October 15, 1582
107      * as it applies the modern Gregorian calendar rules before that date.
108      *
109      * @param zone the zone to use, null means default zone
110      * @return the ISO chronology
111      * @deprecated Use ISOChronology.getInstance(zone)
112      */

113     public static Chronology getISO(DateTimeZone zone) {
114         return ISOChronology.getInstance(zone);
115     }
116
117     //-----------------------------------------------------------------------
118
/**
119      * Gets an instance of the GJChronology in the default zone.
120      * <p>
121      * {@link GJChronology} defines all fields using standard meanings.
122      * This chronology is intended to be used as a replacement for <code>GregorianCalendar</code>.
123      * The Gregorian calendar system is used after October 15, 1582, while the
124      * Julian calendar system is used before.
125      * <p>
126      * Unlike <code>GregorianCalendar</code>, this chronology returns a year of -1
127      * for 1 BCE, -2 for 2 BCE and so on. Thus there is no year zero.
128      * <p>
129      * This method uses the standard Julian to Gregorian cutover date of
130      * October 15th 1582. If you require a cutover on a different date, then use
131      * the factories on <code>GJChronology</code> itself.
132      * <p>
133      * When dealing solely with dates in the modern era, from 1600 onwards,
134      * we recommend using ISOChronology, which is the default.
135      *
136      * @return the GJ chronology
137      * @deprecated Use GJChronology.getInstance()
138      */

139     public static Chronology getGJ() {
140         return GJChronology.getInstance();
141     }
142
143     /**
144      * Gets an instance of the GJChronology in the UTC zone.
145      * <p>
146      * {@link GJChronology} defines all fields using standard meanings.
147      * This chronology is intended to be used as a replacement for <code>GregorianCalendar</code>.
148      * The Gregorian calendar system is used after October 15, 1582, while the
149      * Julian calendar system is used before.
150      * <p>
151      * Unlike <code>GregorianCalendar</code>, this chronology returns a year of -1
152      * for 1 BCE, -2 for 2 BCE and so on. Thus there is no year zero.
153      * <p>
154      * This method uses the standard Julian to Gregorian cutover date of
155      * October 15th 1582. If you require a cutover on a different date, then use
156      * the factories on <code>GJChronology</code> itself.
157      * <p>
158      * When dealing solely with dates in the modern era, from 1600 onwards,
159      * we recommend using ISOChronology, which is the default.
160      *
161      * @return the GJ chronology
162      * @deprecated Use GJChronology.getInstanceUTC()
163      */

164     public static Chronology getGJUTC() {
165         return GJChronology.getInstanceUTC();
166     }
167
168     /**
169      * Gets an instance of the GJChronology in the specified zone.
170      * <p>
171      * {@link GJChronology} defines all fields using standard meanings.
172      * This chronology is intended to be used as a replacement for <code>GregorianCalendar</code>.
173      * The Gregorian calendar system is used after October 15, 1582, while the
174      * Julian calendar system is used before.
175      * <p>
176      * Unlike <code>GregorianCalendar</code>, this chronology returns a year of -1
177      * for 1 BCE, -2 for 2 BCE and so on. Thus there is no year zero.
178      * <p>
179      * This method uses the standard Julian to Gregorian cutover date of
180      * October 15th 1582. If you require a cutover on a different date, then use
181      * the factories on <code>GJChronology</code> itself.
182      * <p>
183      * When dealing solely with dates in the modern era, from 1600 onwards,
184      * we recommend using ISOChronology, which is the default.
185      *
186      * @param zone the zone to use, null means default zone
187      * @return the GJ chronology
188      * @deprecated Use GJChronology.getInstance(zone)
189      */

190     public static Chronology getGJ(DateTimeZone zone) {
191         return GJChronology.getInstance(zone);
192     }
193
194     //-----------------------------------------------------------------------
195
/**
196      * Gets an instance of the GregorianChronology in the default zone.
197      * <p>
198      * {@link GregorianChronology} defines all fields using standard meanings.
199      * It uses the Gregorian calendar rules <i>for all time</i> (proleptic)
200      * thus it is NOT a replacement for <code>GregorianCalendar</code>.
201      * For that purpose, you should use {@link #getGJ()}.
202      * <p>
203      * The Gregorian calendar system defines a leap year every four years,
204      * except that every 100 years is not leap, but every 400 is leap.
205      * <p>
206      * Technically, this chronology is almost identical to the ISO chronology,
207      * thus we recommend using ISOChronology instead, which is the default.
208      *
209      * @return the Gregorian chronology
210      * @deprecated Use GregorianChronology.getInstance()
211      */

212     public static Chronology getGregorian() {
213         return GregorianChronology.getInstance();
214     }
215
216     /**
217      * Gets an instance of the GregorianChronology in the UTC zone.
218      * <p>
219      * {@link GregorianChronology} defines all fields using standard meanings.
220      * It uses the Gregorian calendar rules <i>for all time</i> (proleptic)
221      * thus it is NOT a replacement for <code>GregorianCalendar</code>.
222      * For that purpose, you should use {@link #getGJ()}.
223      * <p>
224      * The Gregorian calendar system defines a leap year every four years,
225      * except that every 100 years is not leap, but every 400 is leap.
226      * <p>
227      * Technically, this chronology is almost identical to the ISO chronology,
228      * thus we recommend using ISOChronology instead, which is the default.
229      *
230      * @return the Gregorian chronology
231      * @deprecated Use GregorianChronology.getInstanceUTC()
232      */

233     public static Chronology getGregorianUTC() {
234         return GregorianChronology.getInstanceUTC();
235     }
236
237     /**
238      * Gets an instance of the GregorianChronology in the specified zone.
239      * <p>
240      * {@link GregorianChronology} defines all fields using standard meanings.
241      * It uses the Gregorian calendar rules <i>for all time</i> (proleptic)
242      * thus it is NOT a replacement for <code>GregorianCalendar</code>.
243      * For that purpose, you should use {@link #getGJ()}.
244      * <p>
245      * The Gregorian calendar system defines a leap year every four years,
246      * except that every 100 years is not leap, but every 400 is leap.
247      * <p>
248      * Technically, this chronology is almost identical to the ISO chronology,
249      * thus we recommend using ISOChronology instead, which is the default.
250      *
251      * @param zone the zone to use, null means default zone
252      * @return the Gregorian chronology
253      * @deprecated Use GregorianChronology.getInstance(zone)
254      */

255     public static Chronology getGregorian(DateTimeZone zone) {
256         return GregorianChronology.getInstance(zone);
257     }
258
259     //-----------------------------------------------------------------------
260
/**
261      * Gets an instance of the JulianChronology in the default zone.
262      * <p>
263      * {@link JulianChronology} defines all fields using standard meanings.
264      * It uses the Julian calendar rules <i>for all time</i> (proleptic).
265      * The Julian calendar system defines a leap year every four years.
266      *
267      * @return the Julian chronology
268      * @deprecated Use JulianChronology.getInstance()
269      */

270     public static Chronology getJulian() {
271         return JulianChronology.getInstance();
272     }
273
274     /**
275      * Gets an instance of the JulianChronology in the UTC zone.
276      * <p>
277      * {@link JulianChronology} defines all fields using standard meanings.
278      * It uses the Julian calendar rules <i>for all time</i> (proleptic).
279      * The Julian calendar system defines a leap year every four years.
280      *
281      * @return the Julian chronology
282      * @deprecated Use JulianChronology.getInstanceUTC()
283      */

284     public static Chronology getJulianUTC() {
285         return JulianChronology.getInstanceUTC();
286     }
287
288     /**
289      * Gets an instance of the JulianChronology in the specified zone.
290      * <p>
291      * {@link JulianChronology} defines all fields using standard meanings.
292      * It uses the Julian calendar rules <i>for all time</i> (proleptic).
293      * The Julian calendar system defines a leap year every four years.
294      *
295      * @param zone the zone to use, null means default zone
296      * @return the Julian chronology
297      * @deprecated Use JulianChronology.getInstance(zone)
298      */

299     public static Chronology getJulian(DateTimeZone zone) {
300         return JulianChronology.getInstance(zone);
301     }
302
303     //-----------------------------------------------------------------------
304
/**
305      * Gets an instance of the BuddhistChronology in the default zone.
306      * <p>
307      * {@link BuddhistChronology} defines all fields using standard meanings,
308      * however the year is offset by 543. The chronology cannot be used before
309      * year 1 in the Buddhist calendar.
310      *
311      * @return the Buddhist chronology
312      * @deprecated Use BuddhistChronology.getInstance()
313      */

314     public static Chronology getBuddhist() {
315         return BuddhistChronology.getInstance();
316     }
317
318     /**
319      * Gets an instance of the BuddhistChronology in the UTC zone.
320      * <p>
321      * {@link BuddhistChronology} defines all fields using standard meanings,
322      * however the year is offset by 543. The chronology cannot be used before
323      * year 1 in the Buddhist calendar.
324      *
325      * @return the Buddhist chronology
326      * @deprecated Use BuddhistChronology.getInstanceUTC()
327      */

328     public static Chronology getBuddhistUTC() {
329         return BuddhistChronology.getInstanceUTC();
330     }
331
332     /**
333      * Gets an instance of the BuddhistChronology in the specified zone.
334      * <p>
335      * {@link BuddhistChronology} defines all fields using standard meanings,
336      * however the year is offset by 543. The chronology cannot be used before
337      * year 1 in the Buddhist calendar.
338      *
339      * @param zone the zone to use, null means default zone
340      * @return the Buddhist chronology
341      * @deprecated Use BuddhistChronology.getInstance(zone)
342      */

343     public static Chronology getBuddhist(DateTimeZone zone) {
344         return BuddhistChronology.getInstance(zone);
345     }
346
347     //-----------------------------------------------------------------------
348
/**
349      * Gets an instance of the CopticChronology in the default zone.
350      * <p>
351      * {@link CopticChronology} defines fields sensibly for the Coptic calendar system.
352      * The Coptic calendar system defines every fourth year as leap.
353      * The year is broken down into 12 months, each 30 days in length.
354      * An extra period at the end of the year is either 5 or 6 days in length
355      * and is returned as a 13th month.
356      * Year 1 in the Coptic calendar began on August 29, 284 CE (Julian).
357      * The chronology cannot be used before the first Coptic year.
358      *
359      * @return the Coptic chronology
360      * @deprecated Use CopticChronology.getInstance()
361      */

362     public static Chronology getCoptic() {
363         return CopticChronology.getInstance();
364     }
365
366     /**
367      * Gets an instance of the CopticChronology in the UTC zone.
368      * <p>
369      * {@link CopticChronology} defines fields sensibly for the Coptic calendar system.
370      * The Coptic calendar system defines every fourth year as leap.
371      * The year is broken down into 12 months, each 30 days in length.
372      * An extra period at the end of the year is either 5 or 6 days in length
373      * and is returned as a 13th month.
374      * Year 1 in the Coptic calendar began on August 29, 284 CE (Julian).
375      * The chronology cannot be used before the first Coptic year.
376      *
377      * @return the Coptic chronology
378      * @deprecated Use CopticChronology.getInstanceUTC()
379      */

380     public static Chronology getCopticUTC() {
381         return CopticChronology.getInstanceUTC();
382     }
383
384     /**
385      * Gets an instance of the CopticChronology in the specified zone.
386      * <p>
387      * {@link CopticChronology} defines fields sensibly for the Coptic calendar system.
388      * The Coptic calendar system defines every fourth year as leap.
389      * The year is broken down into 12 months, each 30 days in length.
390      * An extra period at the end of the year is either 5 or 6 days in length
391      * and is returned as a 13th month.
392      * Year 1 in the Coptic calendar began on August 29, 284 CE (Julian).
393      * The chronology cannot be used before the first Coptic year.
394      *
395      * @param zone the zone to use, null means default zone
396      * @return the Coptic chronology
397      * @deprecated Use CopticChronology.getInstance(zone)
398      */

399     public static Chronology getCoptic(DateTimeZone zone) {
400         return CopticChronology.getInstance(zone);
401     }
402
403     //-----------------------------------------------------------------------
404
/**
405      * Returns the DateTimeZone that this Chronology operates in, or null if
406      * unspecified.
407      *
408      * @return the DateTimeZone, null if unspecified
409      */

410     public abstract DateTimeZone getZone();
411
412     /**
413      * Returns an instance of this Chronology that operates in the UTC time
414      * zone. Chronologies that do not operate in a time zone or are already
415      * UTC must return themself.
416      *
417      * @return a version of this chronology that ignores time zones
418      */

419     public abstract Chronology withUTC();
420     
421     /**
422      * Returns an instance of this Chronology that operates in any time zone.
423      *
424      * @return a version of this chronology with a specific time zone
425      * @param zone to use, or default if null
426      * @see org.joda.time.chrono.ZonedChronology
427      */

428     public abstract Chronology withZone(DateTimeZone zone);
429
430     /**
431      * Returns a datetime millisecond instant, formed from the given year,
432      * month, day, and millisecond values. The set of given values must refer
433      * to a valid datetime, or else an IllegalArgumentException is thrown.
434      * <p>
435      * The default implementation calls upon separate DateTimeFields to
436      * determine the result. Subclasses are encouraged to provide a more
437      * efficient implementation.
438      *
439      * @param year year to use
440      * @param monthOfYear month to use
441      * @param dayOfMonth day of month to use
442      * @param millisOfDay millisecond to use
443      * @return millisecond instant from 1970-01-01T00:00:00Z
444      * @throws IllegalArgumentException if the values are invalid
445      */

446     public abstract long getDateTimeMillis(int year, int monthOfYear, int dayOfMonth, int millisOfDay);
447
448     /**
449      * Returns a datetime millisecond instant, formed from the given year,
450      * month, day, hour, minute, second, and millisecond values. The set of
451      * given values must refer to a valid datetime, or else an
452      * IllegalArgumentException is thrown.
453      * <p>
454      * The default implementation calls upon separate DateTimeFields to
455      * determine the result. Subclasses are encouraged to provide a more
456      * efficient implementation.
457      *
458      * @param year year to use
459      * @param monthOfYear month to use
460      * @param dayOfMonth day of month to use
461      * @param hourOfDay hour to use
462      * @param minuteOfHour minute to use
463      * @param secondOfMinute second to use
464      * @param millisOfSecond millisecond to use
465      * @return millisecond instant from 1970-01-01T00:00:00Z
466      * @throws IllegalArgumentException if the values are invalid
467      */

468     public abstract long getDateTimeMillis(int year, int monthOfYear, int dayOfMonth,
469                            int hourOfDay, int minuteOfHour,
470                            int secondOfMinute, int millisOfSecond);
471
472     /**
473      * Returns a datetime millisecond instant, from from the given instant,
474      * hour, minute, second, and millisecond values. The set of given values
475      * must refer to a valid datetime, or else an IllegalArgumentException is
476      * thrown.
477      * <p>
478      * The default implementation calls upon separate DateTimeFields to
479      * determine the result. Subclasses are encouraged to provide a more
480      * efficient implementation.
481      *
482      * @param instant instant to start from
483      * @param hourOfDay hour to use
484      * @param minuteOfHour minute to use
485      * @param secondOfMinute second to use
486      * @param millisOfSecond millisecond to use
487      * @return millisecond instant from 1970-01-01T00:00:00Z
488      * @throws IllegalArgumentException if the values are invalid
489      */

490     public abstract long getDateTimeMillis(long instant,
491                            int hourOfDay, int minuteOfHour,
492                            int secondOfMinute, int millisOfSecond);
493
494     //-----------------------------------------------------------------------
495
/**
496      * Validates whether the values are valid for the fields of a partial instant.
497      *
498      * @param partial the partial instant to validate
499      * @param values the values to validate, not null, match fields in partial
500      * @throws IllegalArgumentException if the instant is invalid
501      */

502     public abstract void validate(ReadablePartial partial, int[] values);
503
504     /**
505      * Gets the values of a partial from an instant.
506      *
507      * @param partial the partial instant to use
508      * @param instant the instant to query
509      * @return the values of this partial extracted from the instant
510      */

511     public abstract int[] get(ReadablePartial partial, long instant);
512
513     /**
514      * Sets the partial into the instant.
515      *
516      * @param partial the partial instant to use
517      * @param instant the instant to update
518      * @return the updated instant
519      */

520     public abstract long set(ReadablePartial partial, long instant);
521
522     //-----------------------------------------------------------------------
523
/**
524      * Gets the values of a period from an interval.
525      *
526      * @param period the period instant to use
527      * @param startInstant the start instant of an interval to query
528      * @param endInstant the start instant of an interval to query
529      * @return the values of the period extracted from the interval
530      */

531     public abstract int[] get(ReadablePeriod period, long startInstant, long endInstant);
532
533     /**
534      * Gets the values of a period from an interval.
535      *
536      * @param period the period instant to use
537      * @param duration the duration to query
538      * @return the values of the period extracted from the duration
539      */

540     public abstract int[] get(ReadablePeriod period, long duration);
541
542     /**
543      * Adds the period to the instant, specifying the number of times to add.
544      *
545      * @param period the period to add, null means add nothing
546      * @param instant the instant to add to
547      * @param scalar the number of times to add
548      * @return the updated instant
549      */

550     public abstract long add(ReadablePeriod period, long instant, int scalar);
551
552     //-----------------------------------------------------------------------
553
/**
554      * Adds the duration to the instant, specifying the number of times to add.
555      *
556      * @param instant the instant to add to
557      * @param duration the duration to add
558      * @param scalar the number of times to add
559      * @return the updated instant
560      */

561     public abstract long add(long instant, long duration, int scalar);
562
563     // Millis
564
//-----------------------------------------------------------------------
565
/**
566      * Get the millis duration field for this chronology.
567      *
568      * @return DurationField or UnsupportedDurationField if unsupported
569      */

570     public abstract DurationField millis();
571
572     /**
573      * Get the millis of second field for this chronology.
574      *
575      * @return DateTimeField or UnsupportedDateTimeField if unsupported
576      */

577     public abstract DateTimeField millisOfSecond();
578
579     /**
580      * Get the millis of day field for this chronology.
581      *
582      * @return DateTimeField or UnsupportedDateTimeField if unsupported
583      */

584     public abstract DateTimeField millisOfDay();
585
586     // Second
587
//-----------------------------------------------------------------------
588
/**
589      * Get the seconds duration field for this chronology.
590      *
591      * @return DurationField or UnsupportedDurationField if unsupported
592      */

593     public abstract DurationField seconds();
594
595     /**
596      * Get the second of minute field for this chronology.
597      *
598      * @return DateTimeField or UnsupportedDateTimeField if unsupported
599      */

600     public abstract DateTimeField secondOfMinute();
601
602     /**
603      * Get the second of day field for this chronology.
604      *
605      * @return DateTimeField or UnsupportedDateTimeField if unsupported
606      */

607     public abstract DateTimeField secondOfDay();
608
609     // Minute
610
//-----------------------------------------------------------------------
611
/**
612      * Get the minutes duration field for this chronology.
613      *
614      * @return DurationField or UnsupportedDurationField if unsupported
615      */

616     public abstract DurationField minutes();
617
618     /**
619      * Get the minute of hour field for this chronology.
620      *
621      * @return DateTimeField or UnsupportedDateTimeField if unsupported
622      */

623     public abstract DateTimeField minuteOfHour();
624
625     /**
626      * Get the minute of day field for this chronology.
627      *
628      * @return DateTimeField or UnsupportedDateTimeField if unsupported
629      */

630     public abstract DateTimeField minuteOfDay();
631
632     // Hour
633
//-----------------------------------------------------------------------
634
/**
635      * Get the hours duration field for this chronology.
636      *
637      * @return DurationField or UnsupportedDurationField if unsupported
638      */

639     public abstract DurationField hours();
640
641     /**
642      * Get the hour of day (0-23) field for this chronology.
643      *
644      * @return DateTimeField or UnsupportedDateTimeField if unsupported
645      */

646     public abstract DateTimeField hourOfDay();
647
648     /**
649      * Get the hour of day (offset to 1-24) field for this chronology.
650      *
651      * @return DateTimeField or UnsupportedDateTimeField if unsupported
652      */

653     public abstract DateTimeField clockhourOfDay();
654
655     // Halfday
656
//-----------------------------------------------------------------------
657
/**
658      * Get the halfdays duration field for this chronology.
659      *
660      * @return DurationField or UnsupportedDurationField if unsupported
661      */

662     public abstract DurationField halfdays();
663
664     /**
665      * Get the hour of am/pm (0-11) field for this chronology.
666      *
667      * @return DateTimeField or UnsupportedDateTimeField if unsupported
668      */

669     public abstract DateTimeField hourOfHalfday();
670
671     /**
672      * Get the hour of am/pm (offset to 1-12) field for this chronology.
673      *
674      * @return DateTimeField or UnsupportedDateTimeField if unsupported
675      */

676     public abstract DateTimeField clockhourOfHalfday();
677
678     /**
679      * Get the AM(0) PM(1) field for this chronology.
680      *
681      * @return DateTimeField or UnsupportedDateTimeField if unsupported
682      */

683     public abstract DateTimeField halfdayOfDay();
684
685     // Day
686
//-----------------------------------------------------------------------
687
/**
688      * Get the days duration field for this chronology.
689      *
690      * @return DurationField or UnsupportedDurationField if unsupported
691      */

692     public abstract DurationField days();
693
694     /**
695      * Get the day of week field for this chronology.
696      *
697      * <p>DayOfWeek values are defined in {@link DateTimeConstants}.
698      * They use the ISO definitions, where 1 is Monday and 7 is Sunday.
699      *
700      * @return DateTimeField or UnsupportedDateTimeField if unsupported
701      */

702     public abstract DateTimeField dayOfWeek();
703
704     /**
705      * Get the day of month field for this chronology.
706      *
707      * @return DateTimeField or UnsupportedDateTimeField if unsupported
708      */

709     public abstract DateTimeField dayOfMonth();
710
711     /**
712      * Get the day of year field for this chronology.
713      *
714      * @return DateTimeField or UnsupportedDateTimeField if unsupported
715      */

716     public abstract DateTimeField dayOfYear();
717
718     // Week
719
//-----------------------------------------------------------------------
720
/**
721      * Get the weeks duration field for this chronology.
722      *
723      * @return DurationField or UnsupportedDurationField if unsupported
724      */

725     public abstract DurationField weeks();
726
727     /**
728      * Get the week of a week based year field for this chronology.
729      *
730      * @return DateTimeField or UnsupportedDateTimeField if unsupported
731      */

732     public abstract DateTimeField weekOfWeekyear();
733
734     // Weekyear
735
//-----------------------------------------------------------------------
736
/**
737      * Get the weekyears duration field for this chronology.
738      *
739      * @return DurationField or UnsupportedDurationField if unsupported
740      */

741     public abstract DurationField weekyears();
742
743     /**
744      * Get the year of a week based year field for this chronology.
745      *
746      * @return DateTimeField or UnsupportedDateTimeField if unsupported
747      */

748     public abstract DateTimeField weekyear();
749
750     /**
751      * Get the year of a week based year in a century field for this chronology.
752      *
753      * @return DateTimeField or UnsupportedDateTimeField if unsupported
754      */

755     public abstract DateTimeField weekyearOfCentury();
756
757     // Month
758
//-----------------------------------------------------------------------
759
/**
760      * Get the months duration field for this chronology.
761      *
762      * @return DurationField or UnsupportedDurationField if unsupported
763      */

764     public abstract DurationField months();
765
766     /**
767      * Get the month of year field for this chronology.
768      *
769      * @return DateTimeField or UnsupportedDateTimeField if unsupported
770      */

771     public abstract DateTimeField monthOfYear();
772
773     // Year
774
//-----------------------------------------------------------------------
775
/**
776      * Get the years duration field for this chronology.
777      *
778      * @return DurationField or UnsupportedDurationField if unsupported
779      */

780     public abstract DurationField years();
781
782     /**
783      * Get the year field for this chronology.
784      *
785      * @return DateTimeField or UnsupportedDateTimeField if unsupported
786      */

787     public abstract DateTimeField year();
788
789     /**
790      * Get the year of era field for this chronology.
791      *
792      * @return DateTimeField or UnsupportedDateTimeField if unsupported
793      */

794     public abstract DateTimeField yearOfEra();
795
796     /**
797      * Get the year of century field for this chronology.
798      *
799      * @return DateTimeField or UnsupportedDateTimeField if unsupported
800      */

801     public abstract DateTimeField yearOfCentury();
802
803     // Century
804
//-----------------------------------------------------------------------
805
/**
806      * Get the centuries duration field for this chronology.
807      *
808      * @return DurationField or UnsupportedDurationField if unsupported
809      */

810     public abstract DurationField centuries();
811
812     /**
813      * Get the century of era field for this chronology.
814      *
815      * @return DateTimeField or UnsupportedDateTimeField if unsupported
816      */

817     public abstract DateTimeField centuryOfEra();
818
819     // Era
820
//-----------------------------------------------------------------------
821
/**
822      * Get the eras duration field for this chronology.
823      *
824      * @return DurationField or UnsupportedDurationField if unsupported
825      */

826     public abstract DurationField eras();
827
828     /**
829      * Get the era field for this chronology.
830      *
831      * @return DateTimeField or UnsupportedDateTimeField if unsupported
832      */

833     public abstract DateTimeField era();
834
835     //-----------------------------------------------------------------------
836
/**
837      * Gets a debugging toString.
838      *
839      * @return a debugging string
840      */

841     public abstract String JavaDoc toString();
842
843 }
844
Popular Tags