001 /*
002 * Copyright 2001-2005 Stephen Colebourne
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.joda.time;
017
018 import org.joda.time.chrono.BuddhistChronology;
019 import org.joda.time.chrono.CopticChronology;
020 import org.joda.time.chrono.GJChronology;
021 import org.joda.time.chrono.GregorianChronology;
022 import org.joda.time.chrono.ISOChronology;
023 import org.joda.time.chrono.JulianChronology;
024
025 /**
026 * Chronology provides access to the individual date time fields for a
027 * chronological calendar system.
028 * <p>
029 * Various chronologies are supported by subclasses including ISO
030 * and GregorianJulian. To construct a Chronology you should use the
031 * factory methods on the chronology subclass in the chrono package.
032 * <p>
033 * For example, to obtain the current time in the coptic calendar system:
034 * <pre>
035 * DateTime dt = new DateTime(CopticChronology.getInstance());
036 * </pre>
037 * <p>
038 * The provided chronology implementations are:
039 * <ul>
040 * <li>ISO - Based on the ISO8601 standard and suitable for use after about 1600
041 * <li>GJ - Historically accurate calendar with Julian followed by Gregorian
042 * <li>Gregorian - The Gregorian calendar system used for all time (proleptic)
043 * <li>Julian - The Julian calendar system used for all time (proleptic)
044 * <li>Buddhist - The Buddhist calendar system which is an offset in years from GJ
045 * <li>Coptic - The Coptic calendar system which defines 30 day months
046 * <li>Ethiopic - The Ethiopic calendar system which defines 30 day months
047 * </ul>
048 * Hopefully future releases will contain more chronologies.
049 * <p>
050 * This class defines a number of fields with names from the ISO8601 standard.
051 * It does not 'strongly' define these fields however, thus implementations
052 * are free to interpret the field names as they wish.
053 * For example, a week could be defined as 10 days and a month as 40 days in a
054 * special WeirdChronology implementation. Clearly the GJ and ISO
055 * implementations provided use the field names as you would expect.
056 *
057 * @see org.joda.time.chrono.ISOChronology
058 * @see org.joda.time.chrono.GJChronology
059 * @see org.joda.time.chrono.GregorianChronology
060 * @see org.joda.time.chrono.JulianChronology
061 * @see org.joda.time.chrono.CopticChronology
062 * @see org.joda.time.chrono.BuddhistChronology
063 * @see org.joda.time.chrono.EthiopicChronology
064 *
065 * @author Stephen Colebourne
066 * @author Brian S O'Neill
067 * @since 1.0
068 */
069 public abstract class Chronology {
070
071 /**
072 * Gets an instance of the ISOChronology in the default zone.
073 * <p>
074 * {@link ISOChronology} defines all fields in line with the ISO8601 standard.
075 * This chronology is the default, and is suitable for all normal datetime processing.
076 * It is <i>unsuitable</i> for historical datetimes before October 15, 1582
077 * as it applies the modern Gregorian calendar rules before that date.
078 *
079 * @return the ISO chronology
080 * @deprecated Use ISOChronology.getInstance()
081 */
082 public static Chronology getISO() {
083 return ISOChronology.getInstance();
084 }
085
086 /**
087 * Gets an instance of the ISOChronology in the UTC zone.
088 * <p>
089 * {@link ISOChronology} defines all fields in line with the ISO8601 standard.
090 * This chronology is the default, and is suitable for all normal datetime processing.
091 * It is <i>unsuitable</i> for historical datetimes before October 15, 1582
092 * as it applies the modern Gregorian calendar rules before that date.
093 *
094 * @return the ISO chronology
095 * @deprecated Use ISOChronology.getInstanceUTC()
096 */
097 public static Chronology getISOUTC() {
098 return ISOChronology.getInstanceUTC();
099 }
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 toString();
842
843 }