MinguoDate
class MinguoDate : ChronoLocalDate, Temporal, TemporalAdjuster, Serializable
A date in the Minguo calendar system.
This date operates using the Minguo calendar. This calendar system is primarily used in the Republic of China, often known as Taiwan. Dates are aligned such that 0001-01-01 (Minguo) is 1912-01-01 (ISO).
Summary
| Public methods |
| ChronoLocalDateTime<MinguoDate!>! |
|
| Boolean |
Compares this date to another date, including the chronology.
|
| static MinguoDate! |
Obtains a MinguoDate from a temporal object.
|
| MinguoChronology! |
Gets the chronology of this date, which is the Minguo calendar system.
|
| MinguoEra! |
Gets the era applicable at this date.
|
| Long |
|
| Int |
A hash code for this date.
|
| Int |
Returns the length of the month represented by this date.
|
| MinguoDate! |
Returns an object of the same type as this object with an amount subtracted.
|
| MinguoDate! |
|
| static MinguoDate! |
Obtains the current MinguoDate from the system clock in the default time-zone.
|
| static MinguoDate! |
Obtains the current MinguoDate from the system clock in the specified time-zone.
|
| static MinguoDate! |
Obtains the current MinguoDate from the specified clock.
|
| static MinguoDate! |
Obtains a MinguoDate representing a date in the Minguo calendar system from the proleptic-year, month-of-year and day-of-month fields.
|
| MinguoDate! |
Returns an object of the same type as this object with an amount added.
|
| MinguoDate! |
|
| ValueRange! |
|
| Long |
|
| String |
|
| ChronoPeriod! |
|
| Long |
|
| MinguoDate! |
|
| MinguoDate! |
Returns an adjusted object of the same type as this object with the adjustment made.
|
| Inherited functions |
From class ChronoLocalDate
Temporal! |
adjustInto(temporal: Temporal!)
Adjusts the specified temporal object to have the same date as this object.
This returns a temporal object of the same observable type as the input with the date changed to be the same as this.
The adjustment is equivalent to using Temporal#with(TemporalField, long) passing ChronoField#EPOCH_DAY as the field.
In most cases, it is clearer to reverse the calling pattern by using Temporal#with(TemporalAdjuster):
// these two lines are equivalent, but the second approach is recommended
temporal = thisLocalDate.adjustInto(temporal);
temporal = temporal.with(thisLocalDate);
This instance is immutable and unaffected by this method call.
|
Int |
compareTo(other: ChronoLocalDate!)
Compares this date to another date, including the chronology.
The comparison is based first on the underlying time-line date, then on the chronology. It is "consistent with equals", as defined by Comparable.
For example, the following is the comparator order:
2012-12-03 (ISO)2012-12-04 (ISO)2555-12-04 (ThaiBuddhist)2012-12-05 (ISO)
Values #2 and #3 represent the same date on the time-line. When two values represent the same date, the chronology ID is compared to distinguish them. This step is needed to make the ordering "consistent with equals".
If all the date objects being compared are in the same chronology, then the additional chronology stage is not required and only the local date is used. To compare the dates of two TemporalAccessor instances, including dates in two different chronologies, use ChronoField#EPOCH_DAY as a comparator.
This default implementation performs the comparison defined above.
|
String! |
format(formatter: DateTimeFormatter!)
Formats this date using the specified formatter.
This date will be passed to the formatter to produce a string.
The default implementation must behave as follows:
return formatter.format(this);
|
Boolean |
isAfter(other: ChronoLocalDate!)
Checks if this date is after the specified date ignoring the chronology.
This method differs from the comparison in compareTo in that it only compares the underlying date and not the chronology. This allows dates in different calendar systems to be compared based on the time-line position. This is equivalent to using date1.toEpochDay() > date2.toEpochDay().
This default implementation performs the comparison based on the epoch-day.
|
Boolean |
isBefore(other: ChronoLocalDate!)
Checks if this date is before the specified date ignoring the chronology.
This method differs from the comparison in compareTo in that it only compares the underlying date and not the chronology. This allows dates in different calendar systems to be compared based on the time-line position. This is equivalent to using date1.toEpochDay() < date2.toEpochDay().
This default implementation performs the comparison based on the epoch-day.
|
Boolean |
isEqual(other: ChronoLocalDate!)
Checks if this date is equal to the specified date ignoring the chronology.
This method differs from the comparison in compareTo in that it only compares the underlying date and not the chronology. This allows dates in different calendar systems to be compared based on the time-line position. This is equivalent to using date1.toEpochDay() == date2.toEpochDay().
This default implementation performs the comparison based on the epoch-day.
|
Boolean |
isLeapYear()
Checks if the year is a leap year, as defined by the calendar system.
A leap-year is a year of a longer length than normal. The exact meaning is determined by the chronology with the constraint that a leap-year must imply a year-length longer than a non leap-year.
This default implementation uses Chronology#isLeapYear(long).
|
Boolean |
isSupported(field: TemporalField!)
Checks if the specified field is supported.
This checks if the specified field can be queried on this date. If false, then calling the range, get and with(java.time.temporal.TemporalField,long) methods will throw an exception.
The set of supported fields is defined by the chronology and normally includes all ChronoField date fields.
If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.isSupportedBy(TemporalAccessor) passing this as the argument. Whether the field is supported is determined by the field.
|
Boolean |
isSupported(unit: TemporalUnit!)
Checks if the specified unit is supported.
This checks if the specified unit can be added to or subtracted from this date. If false, then calling the plus(long,java.time.temporal.TemporalUnit) and minus methods will throw an exception.
The set of supported units is defined by the chronology and normally includes all ChronoUnit date units except FOREVER.
If the unit is not a ChronoUnit, then the result of this method is obtained by invoking TemporalUnit.isSupportedBy(Temporal) passing this as the argument. Whether the unit is supported is determined by the unit.
|
Int |
lengthOfYear()
Returns the length of the year represented by this date, as defined by the calendar system.
This returns the length of the year in days.
The default implementation uses isLeapYear() and returns 365 or 366.
|
R |
query(query: TemporalQuery<R>!)
Queries this date using the specified query.
This queries this date using the specified query strategy object. The TemporalQuery object defines the logic to be used to obtain the result. Read the documentation of the query to understand what the result of this method will be.
The result of this method is obtained by invoking the TemporalQuery#queryFrom(TemporalAccessor) method on the specified query passing this as the argument.
|
|
Public methods
equals
fun equals(other: Any?): Boolean
Compares this date to another date, including the chronology.
Compares this MinguoDate with another ensuring that the date is the same.
Only objects of type MinguoDate are compared, other types return false. To compare the dates of two TemporalAccessor instances, including dates in two different chronologies, use ChronoField#EPOCH_DAY as a comparator.
| Parameters |
obj |
the object to check, null returns false |
| Return |
Boolean |
true if this is equal to the other date |
from
static fun from(temporal: TemporalAccessor!): MinguoDate!
Obtains a MinguoDate from a temporal object.
This obtains a date in the Minguo calendar system based on the specified temporal. A TemporalAccessor represents an arbitrary set of date and time information, which this factory converts to an instance of MinguoDate.
The conversion typically uses the EPOCH_DAY field, which is standardized across calendar systems.
This method matches the signature of the functional interface TemporalQuery allowing it to be used as a query via method reference, MinguoDate::from.
| Return |
MinguoDate! |
the date in Minguo calendar system, not null |
| Exceptions |
java.time.DateTimeException |
if unable to convert to a MinguoDate |
getChronology
fun getChronology(): MinguoChronology!
Gets the chronology of this date, which is the Minguo calendar system.
The Chronology represents the calendar system in use. The era and other fields in ChronoField are defined by the chronology.
getEra
fun getEra(): MinguoEra!
Gets the era applicable at this date.
The Minguo calendar system has two eras, 'ROC' and 'BEFORE_ROC', defined by MinguoEra.
| Return |
MinguoEra! |
the era applicable at this date, not null |
getLong
fun getLong(field: TemporalField!): Long
| Return |
Long |
the value for the field |
| Exceptions |
java.time.DateTimeException |
if a value for the field cannot be obtained |
java.time.temporal.UnsupportedTemporalTypeException |
if the field is not supported |
java.lang.ArithmeticException |
if numeric overflow occurs |
hashCode
fun hashCode(): Int
A hash code for this date.
| Return |
Int |
a suitable hash code based only on the Chronology and the date |
lengthOfMonth
fun lengthOfMonth(): Int
Returns the length of the month represented by this date.
This returns the length of the month in days. Month lengths match those of the ISO calendar system.
| Return |
Int |
the length of the month in days |
minus
fun minus(amount: TemporalAmount!): MinguoDate!
Returns an object of the same type as this object with an amount subtracted.
This adjusts this temporal, subtracting according to the rules of the specified amount. The amount is typically a java.time.Period but may be any other type implementing the TemporalAmount interface, such as java.time.Duration.
Some example code indicating how and why this method is used:
date = date.minus(period); // subtract a Period instance
date = date.minus(duration); // subtract a Duration instance
date = date.minus(workingDays(6)); // example user-written workingDays method
Note that calling plus followed by minus is not guaranteed to return the same date-time.
| Return |
MinguoDate! |
an object of the same type with the specified adjustment made, not null |
| Exceptions |
java.time.DateTimeException |
if the subtraction cannot be made |
java.lang.ArithmeticException |
if numeric overflow occurs |
minus
fun minus(
amountToAdd: Long,
unit: TemporalUnit!
): MinguoDate!
| Parameters |
amountToSubtract |
the amount of the specified unit to subtract, may be negative |
unit |
TemporalUnit!: the unit of the amount to subtract, not null |
| Return |
MinguoDate! |
an object of the same type with the specified period subtracted, not null |
| Exceptions |
java.time.DateTimeException |
if the unit cannot be subtracted |
java.time.temporal.UnsupportedTemporalTypeException |
if the unit is not supported |
java.lang.ArithmeticException |
if numeric overflow occurs |
now
static fun now(): MinguoDate!
Obtains the current MinguoDate from the system clock in the default time-zone.
This will query the system clock in the default time-zone to obtain the current date.
Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
| Return |
MinguoDate! |
the current date using the system clock and default time-zone, not null |
now
static fun now(zone: ZoneId!): MinguoDate!
Obtains the current MinguoDate from the system clock in the specified time-zone.
This will query the system clock to obtain the current date. Specifying the time-zone avoids dependence on the default time-zone.
Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
| Parameters |
zone |
ZoneId!: the zone ID to use, not null |
| Return |
MinguoDate! |
the current date using the system clock, not null |
now
static fun now(clock: Clock!): MinguoDate!
Obtains the current MinguoDate from the specified clock.
This will query the specified clock to obtain the current date - today. Using this method allows the use of an alternate clock for testing. The alternate clock may be introduced using dependency injection.
| Parameters |
clock |
Clock!: the clock to use, not null |
| Exceptions |
java.time.DateTimeException |
if the current date cannot be obtained |
of
static fun of(
prolepticYear: Int,
month: Int,
dayOfMonth: Int
): MinguoDate!
Obtains a MinguoDate representing a date in the Minguo calendar system from the proleptic-year, month-of-year and day-of-month fields.
This returns a MinguoDate with the specified fields. The day must be valid for the year and month, otherwise an exception will be thrown.
| Parameters |
prolepticYear |
Int: the Minguo proleptic-year |
month |
Int: the Minguo month-of-year, from 1 to 12 |
dayOfMonth |
Int: the Minguo day-of-month, from 1 to 31 |
| Return |
MinguoDate! |
the date in Minguo calendar system, not null |
| Exceptions |
java.time.DateTimeException |
if the value of any field is out of range, or if the day-of-month is invalid for the month-year |
plus
fun plus(amount: TemporalAmount!): MinguoDate!
Returns an object of the same type as this object with an amount added.
This adjusts this temporal, adding according to the rules of the specified amount. The amount is typically a java.time.Period but may be any other type implementing the TemporalAmount interface, such as java.time.Duration.
Some example code indicating how and why this method is used:
date = date.plus(period); // add a Period instance
date = date.plus(duration); // add a Duration instance
date = date.plus(workingDays(6)); // example user-written workingDays method
Note that calling plus followed by minus is not guaranteed to return the same date-time.
| Return |
MinguoDate! |
an object of the same type with the specified adjustment made, not null |
| Exceptions |
java.time.DateTimeException |
if the addition cannot be made |
java.lang.ArithmeticException |
if numeric overflow occurs |
plus
fun plus(
amountToAdd: Long,
unit: TemporalUnit!
): MinguoDate!
| Parameters |
amountToAdd |
Long: the amount of the specified unit to add, may be negative |
unit |
TemporalUnit!: the unit of the amount to add, not null |
| Return |
MinguoDate! |
an object of the same type with the specified period added, not null |
| Exceptions |
java.time.DateTimeException |
if the unit cannot be added |
java.time.temporal.UnsupportedTemporalTypeException |
if the unit is not supported |
java.lang.ArithmeticException |
if numeric overflow occurs |
range
fun range(field: TemporalField!): ValueRange!
| Parameters |
field |
TemporalField!: the field to query the range for, not null |
| Return |
ValueRange! |
the range of valid values for the field, not null |
| Exceptions |
java.time.DateTimeException |
if the range for the field cannot be obtained |
java.time.temporal.UnsupportedTemporalTypeException |
if the field is not supported |
toEpochDay
fun toEpochDay(): Long
| Return |
Long |
the Epoch Day equivalent to this date |
toString
fun toString(): String
| Return |
String |
the formatted date, not null |
until
fun until(endDate: ChronoLocalDate!): ChronoPeriod!
| Parameters |
endDateExclusive |
the end date, exclusive, which may be in any chronology, not null |
| Return |
ChronoPeriod! |
the period between this date and the end date, not null |
| Exceptions |
java.time.DateTimeException |
if the period cannot be calculated |
java.lang.ArithmeticException |
if numeric overflow occurs |
until
fun until(
endExclusive: Temporal!,
unit: TemporalUnit!
): Long
| Parameters |
endExclusive |
Temporal!: the end temporal, exclusive, converted to be of the same type as this object, not null |
unit |
TemporalUnit!: the unit to measure the amount in, not null |
| Return |
Long |
the amount of time between this temporal object and the specified one in terms of the unit; positive if the specified object is later than this one, negative if it is earlier than this one |
| Exceptions |
java.time.DateTimeException |
if the amount cannot be calculated, or the end temporal cannot be converted to the same type as this temporal |
java.time.temporal.UnsupportedTemporalTypeException |
if the unit is not supported |
java.lang.ArithmeticException |
if numeric overflow occurs |
with
fun with(
field: TemporalField!,
newValue: Long
): MinguoDate!
| Parameters |
field |
TemporalField!: the field to set in the result, not null |
newValue |
Long: the new value of the field in the result |
| Return |
MinguoDate! |
an object of the same type with the specified field set, not null |
| Exceptions |
java.time.DateTimeException |
if the field cannot be set |
java.time.temporal.UnsupportedTemporalTypeException |
if the field is not supported |
java.lang.ArithmeticException |
if numeric overflow occurs |
with
fun with(adjuster: TemporalAdjuster!): MinguoDate!
Returns an adjusted object of the same type as this object with the adjustment made.
This adjusts this date-time according to the rules of the specified adjuster. A simple adjuster might simply set the one of the fields, such as the year field. A more complex adjuster might set the date to the last day of the month. A selection of common adjustments is provided in TemporalAdjusters. These include finding the "last day of the month" and "next Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths of month and leap years.
Some example code indicating how and why this method is used:
date = date.with(Month.JULY); // most key classes implement TemporalAdjuster
date = date.with(lastDayOfMonth()); // static import from Adjusters
date = date.with(next(WEDNESDAY)); // static import from Adjusters and DayOfWeek
| Return |
MinguoDate! |
an object of the same type with the specified adjustment made, not null |
| Exceptions |
java.time.DateTimeException |
if unable to make the adjustment |
java.lang.ArithmeticException |
if numeric overflow occurs |
