HistoricCalendar (Time4J-Base 5.8 API)

java.lang.Object
- net.time4j.engine.ChronoEntity<D>
- - net.time4j.engine.CalendarVariant<HistoricCalendar>
  - - net.time4j.calendar.HistoricCalendar

All Implemented Interfaces:: Serializable, Comparable<HistoricCalendar>, CalendarDate, ChronoDisplay, Temporal<CalendarDate>, VariantSource, LocalizedPatternSupport

@CalendarType(value="historic")
public final class HistoricCalendar
extends CalendarVariant<HistoricCalendar>
implements LocalizedPatternSupport

Represents the historic christian calendar used in most European countries.

Following elements which are declared as constants are registered by this class

Furthermore, all elements defined in EpochDays and CommonElements are supported.

Formatting example

      ChronoHistory history = ChronoHistory.of(Locale.UK);
      ChronoFormatter<HistoricCalendar> f =
          ChronoFormatter.ofStyle(DisplayMode.FULL, Locale.ENGLISH, HistoricCalendar.family()).with(history);
      HistoricCalendar cal = HistoricCalendar.of(history, HistoricEra.AD, 1603, 3, 24);
      String text = "Thursday, March 24, 1602/03 AD" // dual dating for the historic year
      assertThat(f.format(cal), is(text));
      assertThat(f.parse(text), is(cal));

Transformation from ISO-8601

Any gregorian date (ISO-8601) can be transformed to HistoricCalendar this simple way:

     ChronoHistory history = ChronoHistory.ofFirstGregorianReform();
     HistoricCalendar cal = PlainDate.of(1582, 10, 5).transform(HistoricCalendar.family(), history)
     System.out.println(cal); // AD-1582-09-25[...], ten days were cut off by pope Gregor

Support for unicode ca-extensions

     Locale locale = Locale.forLanguageTag("de-DE-PREUSSEN-u-ca-historic");
     ChronoFormatter<CalendarDate> f = ChronoFormatter.ofGenericCalendarStyle(DisplayMode.FULL, locale);
     assertThat(
          f.format(PlainDate.of(1610, 9, 1)),
          is("Mittwoch, 22. August 1610 n. Chr."));

The key word is "historic". The ca-extension finally evaluates ChronoHistory.of(Locale) for automatical conversions to HistoricCalendar before formatting (as shown above).

Since:: 3.36/4.31
Author:: Meno Hochschild
See Also:: Serialized Form
Concurrency:: This class is immutable and can be used by multiple threads in parallel.

Field Summary

Fields
Modifier and Type	Field and Description
`static ChronoElement<Integer>`	`CENTURY_OF_ERA` Represents the historic century.
`static StdCalendarElement<Integer,HistoricCalendar>`	`DAY_OF_MONTH` Represents the historic day of month.
`static StdCalendarElement<Weekday,HistoricCalendar>`	`DAY_OF_WEEK` Represents the historic day of week.
`static StdCalendarElement<Integer,HistoricCalendar>`	`DAY_OF_YEAR` Represents the historic day of year.
`static ChronoElement<HistoricEra>`	`ERA` Represents the historic era.
`static StdCalendarElement<Month,HistoricCalendar>`	`MONTH_OF_YEAR` Represents the historic month.
`static TextElement<Integer>`	`RELATED_STANDARD_YEAR` Represents the related standard year within current era which starts on first of January.
`static OrdinalWeekdayElement<HistoricCalendar>`	`WEEKDAY_IN_MONTH` Element with the ordinal day-of-week within given calendar month.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`GeneralTimestamp<HistoricCalendar>`	`at(PlainTime time)` Creates a new local timestamp with this date and given wall time.
`GeneralTimestamp<HistoricCalendar>`	`atTime(int hour, int minute)` Is equivalent to `at(PlainTime.of(hour, minute))`.
`boolean`	`equals(Object obj)` Compares the whole state of this instance with given object.
`static CalendarFamily<HistoricCalendar>`	`family()` Returns the associated calendar family.
`int`	`getCentury()` Obtains the century of era.
`int`	`getDayOfMonth()` Yields the historic day of month.
`Weekday`	`getDayOfWeek()` Determines the day of week.
`int`	`getDayOfYear()` Yields the historic day of year.
`static Weekmodel`	`getDefaultWeekmodel()` Obtains the standard week model of this calendar.
`HistoricEra`	`getEra()` Yields the historic era.
`ChronoHistory`	`getHistory()` Obtains the underlying calendar history.
`Month`	`getMonth()` Yields the historic month.
`String`	`getVariant()` Yields the variant name of a calendar system.
`int`	`getYear()` Obtains the true historic year as displayed in historic documents.
`int`	`hashCode()` Subclasses must redefine this method corresponding to the behaviour of `equals()`.
`int`	`lengthOfMonth()` Yields the length of current historic month in days.
`int`	`lengthOfYear()` Yields the length of current historic year in days.
`HistoricCalendar`	`nextDay()` Convenient short form for `with(DAY_OF_MONTH.incremented())` or `plus(CalendarDays.ONE)`.
`static HistoricCalendar`	`nowInSystemTime(ChronoHistory history)` Obtains the current historic calendar date in system time.
`static HistoricCalendar`	`of(ChronoHistory history, HistoricEra era, int relatedStandardYear, int historicMonth, int historicDayOfMonth)` Constructs a new historic calendar.
`static HistoricCalendar`	`of(ChronoHistory history, HistoricEra era, int yearOfEra, YearDefinition yearDefinition, int historicMonth, int historicDayOfMonth)` Constructs a new historic calendar.
`String`	`toString()` Provides a complete textual representation of the state of this calendar variant.
`HistoricCalendar`	`withNewYear()` Obtains the start of this year (which is often not the first of January).

Methods inherited from class net.time4j.engine.CalendarVariant
compareTo, getDaysSinceEpochUTC, isAfter, isBefore, isSimultaneous, minus, plus, withVariant, withVariant

Methods inherited from class net.time4j.engine.ChronoEntity
contains, get, get, getInt, getMaximum, getMinimum, getRegisteredElements, getTimezone, hasTimezone, isValid, isValid, isValid, matches, with, with, with, with

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.time4j.format.LocalizedPatternSupport
getFormatPattern, getFormatPattern, useDynamicFormatPattern

Methods inherited from interface net.time4j.engine.CalendarDate
from, from, from, transform, transform, transform, transform, transform, transform

Methods inherited from interface net.time4j.engine.Temporal
isAfterAll, isAfterOrEqual, isBeforeAll, isBeforeOrEqual

- Field Detail
  - ERA
```
@FormattableElement(format="G")
public static final ChronoElement<HistoricEra> ERA
```
    Represents the historic era.
    
    The era value cannot be changed in any way which makes sense so this element is like a display-only element.
  - CENTURY_OF_ERA
```
public static final ChronoElement<Integer> CENTURY_OF_ERA
```
    Represents the historic century.
  - RELATED_STANDARD_YEAR
```
@FormattableElement(format="y")
public static final TextElement<Integer> RELATED_STANDARD_YEAR
```
    Represents the related standard year within current era which starts on first of January.
    
    Note: Getting true historic years which take care of different new-year-rules is possible via the expression getYear(). This year definition is similar to CommonElements.RELATED_GREGORIAN_YEAR but takes into account the change from julian to gregorian calendar.
    
    When used in formatting of historic dates, Time4J will apply dual dating unless a special year definition has been set as format attribute.
  - MONTH_OF_YEAR
```
@FormattableElement(format="M",
                    alt="L")
public static final StdCalendarElement<Month,HistoricCalendar> MONTH_OF_YEAR
```
    Represents the historic month.
    
    The expression with(MONTH_OF_YEAR.incremented()) works in the following way:
    - If possible the current day of month will be kept.
    - If the new month has a shorter length than the current day of month then the day of month will be the maximum day of the new month.
    - If this date is the first day of month and is not valid on next month due to a gap on the date line then the new day of month will be corrected to be the first valid day of the new month.
    Example (AD-1610-09-01 is invalid!):
```
     ChronoHistory history = ChronoHistory.of(new Locale("de", "DE", "PREUSSEN"));
     HistoricCalendar cal = HistoricCalendar.of(history, HistoricEra.AD, 1610, 8, 1);
     System.out.println(cal.with(HistoricCalendar.MONTH_OF_YEAR.incremented()));
     // AD-1610-09-02[...]
 
```
  - DAY_OF_MONTH
```
@FormattableElement(format="d")
public static final StdCalendarElement<Integer,HistoricCalendar> DAY_OF_MONTH
```
    Represents the historic day of month.
  - DAY_OF_YEAR
```
@FormattableElement(format="D")
public static final StdCalendarElement<Integer,HistoricCalendar> DAY_OF_YEAR
```
    Represents the historic day of year.
  - DAY_OF_WEEK
```
@FormattableElement(format="E")
public static final StdCalendarElement<Weekday,HistoricCalendar> DAY_OF_WEEK
```
    Represents the historic day of week.
    
    If the day-of-week is set to a new value then Time4J handles the historic calendar week as starting on Sunday (usual in christian context).
    
    See Also:
    
    getDefaultWeekmodel(), CommonElements.localDayOfWeek(net.time4j.engine.Chronology, Weekmodel)
  - WEEKDAY_IN_MONTH
```
@FormattableElement(format="F")
public static final OrdinalWeekdayElement<HistoricCalendar> WEEKDAY_IN_MONTH
```
    Element with the ordinal day-of-week within given calendar month.
- Method Detail
  - of
```
public static HistoricCalendar of(ChronoHistory history,
                                  HistoricEra era,
                                  int relatedStandardYear,
                                  int historicMonth,
                                  int historicDayOfMonth)
```
    Constructs a new historic calendar.
    
    Equivalent to of(ChronoHistory, HistoricEra, int, YearDefinition, int, int) of(history, era, relatedStandardYear, historicMonth, historicDayOfMonth, YearDefinition.DUAL_DATING)}.
    
    Parameters:
    
    history - historization model
    
    era - historic era
    
    relatedStandardYear - the related standard year of era (>= 1) starting on January the first
    
    historicMonth - historic month (1-12)
    
    historicDayOfMonth - historic day of month (1-31)
    
    Returns:
    
    new historic calendar
    
    Throws:
    
    IllegalArgumentException - if any argument is out of required maximum range or invalid for other reasons
  - of
```
public static HistoricCalendar of(ChronoHistory history,
                                  HistoricEra era,
                                  int yearOfEra,
                                  YearDefinition yearDefinition,
                                  int historicMonth,
                                  int historicDayOfMonth)
```
    Constructs a new historic calendar.
    
    Parameters:
    
    history - historization model
    
    era - historic era
    
    yearOfEra - year of era which will be interpreted according to given year definition (>= 1)
    
    yearDefinition - defines a strategy how to interprete year of era
    
    historicMonth - historic month (1-12)
    
    historicDayOfMonth - historic day of month (1-31)
    
    Returns:
    
    new historic calendar
    
    Throws:
    
    IllegalArgumentException - if any argument is out of required maximum range or invalid for other reasons
  - nowInSystemTime
```
public static HistoricCalendar nowInSystemTime(ChronoHistory history)
```
    Obtains the current historic calendar date in system time.
    
    Convenient short-cut for: SystemClock.inLocalView().now(HistoricCalendar.family(), history, StartOfDay.MIDNIGHT).toDate()).
    
    Parameters:
    
    history - historization model
    
    Returns:
    
    current historic calendar in system time zone using the system clock
    
    See Also:
    
    SystemClock.inLocalView()
  - getHistory
```
public ChronoHistory getHistory()
```
    Obtains the underlying calendar history.
    
    Returns:
    
    ChronoHistory
  - getEra
```
public HistoricEra getEra()
```
    Yields the historic era.
    
    Returns:
    
    HistoricEra
  - getCentury
```
public int getCentury()
```
    Obtains the century of era.
    
    Returns:
    
    int
  - getYear
```
public int getYear()
```
    Obtains the true historic year as displayed in historic documents.
    
    Important: The begin of a historic year can deviate from first of January. Historic years are often not synchronized with month cycles. Users can apply the expression getInt(RELATED_STANDARD_YEAR) in order to obtain the year beginning on first of January.
    
    Returns:
    
    int
    
    See Also:
    
    HistoricDate.getYearOfEra(NewYearStrategy), ChronoHistory.getNewYearStrategy()
  - getMonth
```
public Month getMonth()
```
    Yields the historic month.
    
    Returns:
    
    enum
  - getDayOfMonth
```
public int getDayOfMonth()
```
    Yields the historic day of month.
    
    Returns:
    
    int
  - getDayOfWeek
```
public Weekday getDayOfWeek()
```
    Determines the day of week.
    
    The week model has never been subject to historical changes leaving aside radical calendar reforms like the Frenh revolutionary calendar.
    
    Returns:
    
    Weekday
  - getDayOfYear
```
public int getDayOfYear()
```
    Yields the historic day of year.
    
    Returns:
    
    int
  - getVariant
```
public String getVariant()
```
    Description copied from interface: VariantSource
    
    Yields the variant name of a calendar system.
    
    Specified by:
    
    getVariant in interface VariantSource
    
    Returns:
    
    String which is empty if there are no variants
  - lengthOfMonth
```
public int lengthOfMonth()
```
    Yields the length of current historic month in days.
    
    Returns:
    
    length of historic month in days or -1 if the length cannot be determined
  - lengthOfYear
```
public int lengthOfYear()
```
    Yields the length of current historic year in days.
    
    Returns:
    
    length of historic year in days or -1 if the length cannot be determined
  - withNewYear
```
public HistoricCalendar withNewYear()
```
    Obtains the start of this year (which is often not the first of January).
    
    Returns:
    
    new year
  - nextDay
```
public HistoricCalendar nextDay()
```
    Convenient short form for with(DAY_OF_MONTH.incremented()) or plus(CalendarDays.ONE).
    
    Returns:
    
    copy of this instance at next day
    
    See Also:
    
    CalendarVariant.plus(CalendarDays), CalendarDays.ONE
  - at
```
public GeneralTimestamp<HistoricCalendar> at(PlainTime time)
```
    Creates a new local timestamp with this date and given wall time.
    
    If the time T24:00 is used then the resulting timestamp will automatically be normalized such that the timestamp will contain the following day instead.
    
    Parameters:
    
    time - wall time
    
    Returns:
    
    general timestamp as composition of this date and given time
  - atTime
```
public GeneralTimestamp<HistoricCalendar> atTime(int hour,
                                                 int minute)
```
    Is equivalent to at(PlainTime.of(hour, minute)).
    
    Parameters:
    
    hour - hour of day in range (0-24)
    
    minute - minute of hour in range (0-59)
    
    Returns:
    
    general timestamp as composition of this date and given time
    
    Throws:
    
    IllegalArgumentException - if any argument is out of range
  - equals
```
public boolean equals(Object obj)
```
    Description copied from class: CalendarVariant
    
    Compares the whole state of this instance with given object.
    
    Implementations will usually define their state based on the temporal position and the variant name. Exceptions from this rule should be explicitly documented and reasoned.
    
    Specified by:
    
    equals in class CalendarVariant<HistoricCalendar>
    
    See Also:
    
    CalendarVariant.compareTo(CalendarVariant)
  - hashCode
```
public int hashCode()
```
    Description copied from class: CalendarVariant
    
    Subclasses must redefine this method corresponding to the behaviour of equals().
    
    Specified by:
    
    hashCode in class CalendarVariant<HistoricCalendar>
  - toString
```
public String toString()
```
    Description copied from class: CalendarVariant
    
    Provides a complete textual representation of the state of this calendar variant.
    
    Specified by:
    
    toString in class CalendarVariant<HistoricCalendar>
  - getDefaultWeekmodel
```
public static Weekmodel getDefaultWeekmodel()
```
    Obtains the standard week model of this calendar.
    
    Christian calendars usually starts on Sunday.
    
    Returns:
    
    Weekmodel
  - family
```
public static CalendarFamily<HistoricCalendar> family()
```
    Returns the associated calendar family.
    
    Returns:
    
    chronology as calendar family

Class HistoricCalendar

Following elements which are declared as constants are registered by this class

Formatting example

Transformation from ISO-8601

Support for unicode ca-extensions

Field Summary

Method Summary

Methods inherited from class net.time4j.engine.CalendarVariant

Methods inherited from class net.time4j.engine.ChronoEntity

Methods inherited from class java.lang.Object

Methods inherited from interface net.time4j.format.LocalizedPatternSupport

Methods inherited from interface net.time4j.engine.CalendarDate

Methods inherited from interface net.time4j.engine.Temporal

Field Detail

ERA

CENTURY_OF_ERA

RELATED_STANDARD_YEAR

MONTH_OF_YEAR

DAY_OF_MONTH

DAY_OF_YEAR

DAY_OF_WEEK

WEEKDAY_IN_MONTH

Method Detail

of

of

nowInSystemTime

getHistory

getEra

getCentury

getYear

getMonth

getDayOfMonth

getDayOfWeek

getDayOfYear

getVariant

lengthOfMonth

lengthOfYear

withNewYear

nextDay

at

atTime

equals

hashCode

toString

getDefaultWeekmodel

family