????
Your IP : 18.225.254.235
/*
* @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
* @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
* @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
*/
import { MathUtil } from './MathUtil';
import { requireNonNull, requireInstance } from './assert';
import { DateTimeException, UnsupportedTemporalTypeException, ArithmeticException, DateTimeParseException } from './errors';
import { IsoChronology } from './chrono/IsoChronology';
import { ChronoUnit } from './temporal/ChronoUnit';
import { TemporalAmount } from './temporal/TemporalAmount';
import { LocalDate } from './LocalDate';
/**
* The pattern for parsing.
*/
const PATTERN = /([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)W)?(?:([-+]?[0-9]+)D)?/;
/**
* A date-based amount of time, such as '2 years, 3 months and 4 days'.
*
* This class models a quantity or amount of time in terms of years, months and days.
* See {@link Duration} for the time-based equivalent to this class.
*
* Durations and period differ in their treatment of daylight savings time
* when added to {@link ZonedDateTime}. A {@link Duration} will add an exact
* number of seconds, thus a duration of one day is always exactly 24 hours.
* By contrast, a {@link Period} will add a conceptual day, trying to maintain
* the local time.
*
* For example, consider adding a period of one day and a duration of one day to
* 18:00 on the evening before a daylight savings gap. The {@link Period} will add
* the conceptual day and result in a {@link ZonedDateTime} at 18:00 the following day.
* By contrast, the {@link Duration} will add exactly 24 hours, resulting in a
* {@link ZonedDateTime} at 19:00 the following day (assuming a one hour DST gap).
*
* The supported units of a period are {@link ChronoUnit#YEARS},
* {@link ChronoUnit#MONTHS} and {@link ChronoUnit#DAYS}.
* All three fields are always present, but may be set to zero.
*
* The period may be used with any calendar system.
* The meaning of a 'year' or 'month' is only applied when the object is added to a date.
*
* The period is modeled as a directed amount of time, meaning that individual parts of the
* period may be negative.
*
* The months and years fields may be normalized (see {@link normalized}).
* The normalization assumes a 12 month year, so is not appropriate for all calendar systems.
*
* ### Static properties of Class {@link Period}
*
* Period.ZERO
*
* A constant for a period of zero.
*
*/
export class Period extends TemporalAmount /* extends ChronoPeriod */ {
/**
* do not call the constructor directly
* use a factory method instead
*
* @param {number} years
* @param {number} months
* @param {number} days
* @private
*/
constructor(years, months, days){
super();
const _years = MathUtil.safeToInt(years);
const _months = MathUtil.safeToInt(months);
const _days = MathUtil.safeToInt(days);
if( _years === 0 && _months === 0 && _days === 0 ){
if (!Period.ZERO) {
this._years = _years;
this._months = _months;
this._days = _days;
Period.ZERO = this;
}
return Period.ZERO;
}
/**
* The number of years.
*/
this._years = _years;
/**
* The number of months.
*/
this._months = _months;
/**
* The number of days.
*/
this._days = _days;
}
//-----------------------------------------------------------------------
/**
* Obtains a {@link Period} representing a number of years.
*
* The resulting period will have the specified years.
* The months and days units will be zero.
*
* @param {number} years - the number of years, positive or negative
* @return {Period} the period of years, not null
*/
static ofYears(years) {
return Period.create(years, 0, 0);
}
/**
* Obtains a {@link Period} representing a number of months.
*
* The resulting period will have the specified months.
* The years and days units will be zero.
*
* @param {number} months - the number of months, positive or negative
* @return {Period} the period of months, not null
*/
static ofMonths(months) {
return Period.create(0, months, 0);
}
/**
* Obtains a {@link Period} representing a number of weeks.
*
* The resulting period will have days equal to the weeks multiplied by seven.
* The years and months units will be zero.
*
* @param {number} weeks - the number of weeks, positive or negative
* @return {Period} the period of days, not null
*/
static ofWeeks(weeks) {
return Period.create(0, 0, MathUtil.safeMultiply(weeks, 7));
}
/**
* Obtains a {@link Period} representing a number of days.
*
* The resulting period will have the specified days.
* The years and months units will be zero.
*
* @param {number} days - the number of days, positive or negative
* @return {Period} the period of days, not null
*/
static ofDays(days) {
return Period.create(0, 0, days);
}
//-----------------------------------------------------------------------
/**
* Obtains a {@link Period} representing a number of years, months and days.
*
* This creates an instance based on years, months and days.
*
* @param {!number} years - the amount of years, may be negative
* @param {!number} months - the amount of months, may be negative
* @param {!number} days - the amount of days, may be negative
* @return {Period} the period of years, months and days, not null
*/
static of(years, months, days) {
return Period.create(years, months, days);
}
//-----------------------------------------------------------------------
/**
* Obtains an instance of {@link Period} from a temporal amount.
*
* This obtains a period based on the specified amount.
* A {@link TemporalAmount} represents an - amount of time, which may be
* date-based or time-based, which this factory extracts to a {@link Period}.
*
* The conversion loops around the set of units from the amount and uses
* the {@link ChronoUnit#YEARS}, {@link ChronoUnit#MONTHS}
* and {@link ChronoUnit#DAYS} units to create a period.
* If any other units are found then an exception is thrown.
*
* If the amount is a {@link ChronoPeriod} then it must use the ISO chronology.
*
* @param {TemporalAmount} amount - the temporal amount to convert, not null
* @return {Period} the equivalent period, not null
* @throws DateTimeException if unable to convert to a {@link Period}
* @throws ArithmeticException if the amount of years, months or days exceeds an int
*/
static from(amount) {
if (amount instanceof Period) {
return amount;
}
/*
if (amount instanceof ChronoPeriod) {
if (IsoChronology.INSTANCE !== amount.chronology()) {
throw new DateTimeException('Period requires ISO chronology: ' + amount);
}
}
*/
requireNonNull(amount, 'amount');
let years = 0;
let months = 0;
let days = 0;
const units = amount.units();
for (let i=0; i<units.length; i++) {
const unit = units[i];
const unitAmount = amount.get(unit);
if (unit === ChronoUnit.YEARS) {
years = MathUtil.safeToInt(unitAmount);
} else if (unit === ChronoUnit.MONTHS) {
months = MathUtil.safeToInt(unitAmount);
} else if (unit === ChronoUnit.DAYS) {
days = MathUtil.safeToInt(unitAmount);
} else {
throw new DateTimeException(`Unit must be Years, Months or Days, but was ${unit}`);
}
}
return Period.create(years, months, days);
}
//-----------------------------------------------------------------------
/**
* Obtains a {@link Period} consisting of the number of years, months,
* and days between two dates.
*
* The start date is included, but the end date is not.
* The period is calculated by removing complete months, then calculating
* the remaining number of days, adjusting to ensure that both have the same sign.
* The number of months is then split into years and months based on a 12 month year.
* A month is considered if the end day-of-month is greater than or equal to the start day-of-month.
* For example, from `2010-01-15` to `2011-03-18` is one year, two months and three days.
*
* The result of this method can be a negative period if the end is before the start.
* The negative sign will be the same in each of year, month and day.
* see {@link ChronoLocalDate.until}
*
* @param {LocalDate} startDate - the start date, inclusive, not null
* @param {LocalDate} endDate - the end date, exclusive, not null
* @return {Period} the period between this date and the end date, not null
*/
static between(startDate, endDate) {
requireNonNull(startDate, 'startDate');
requireNonNull(endDate, 'endDate');
requireInstance(startDate, LocalDate, 'startDate');
requireInstance(endDate, LocalDate, 'endDate');
return startDate.until(endDate);
}
//-----------------------------------------------------------------------
/**
* Obtains a {@link Period} from a text string such as {@link PnYnMnD}.
*
* This will parse the string produced by {@link toString} which is
* based on the ISO-8601 period formats {@link PnYnMnD} and {@link PnW}.
*
* The string starts with an optional sign, denoted by the ASCII negative
* or positive symbol. If negative, the whole period is negated.
* The ASCII letter 'P' is next in upper or lower case.
* There are then four sections, each consisting of a number and a suffix.
* At least one of the four sections must be present.
* The sections have suffixes in ASCII of 'Y', 'M', 'W' and 'D' for
* years, months, weeks and days, accepted in upper or lower case.
* The suffixes must occur in order.
* The number part of each section must consist of ASCII digits.
* The number may be prefixed by the ASCII negative or positive symbol.
* The number must parse to an `int`.
*
* The leading plus/minus sign, and negative values for other units are
* not part of the ISO-8601 standard. In addition, ISO-8601 does not
* permit mixing between the {@link PnYnMnD} and {@link PnW} formats.
* Any week-based input is multiplied by 7 and treated as a number of days.
*
* For example, the following are valid inputs:
* <pre>
* 'P2Y' -- Period.ofYears(2)
* 'P3M' -- Period.ofMonths(3)
* 'P4W' -- Period.ofWeeks(4)
* 'P5D' -- Period.ofDays(5)
* 'P1Y2M3D' -- Period.of(1, 2, 3)
* 'P1Y2M3W4D' -- Period.of(1, 2, 25)
* 'P-1Y2M' -- Period.of(-1, 2, 0)
* '-P1Y2M' -- Period.of(-1, -2, 0)
* </pre>
*
* @param {string} text - the text to parse, not null
* @return {Period} the parsed period, not null
* @throws DateTimeParseException if the text cannot be parsed to a period
*/
static parse(text) {
requireNonNull(text, 'text');
try {
return Period._parse(text);
} catch (ex){
if(ex instanceof ArithmeticException){
throw new DateTimeParseException('Text cannot be parsed to a Period', text, 0, ex);
} else {
throw ex;
}
}
}
/**
* because functions that containing a try/ catch block cant be optimized,
* we put the code in a sub function.
*/
static _parse(text){
const matches = PATTERN.exec(text);
if (matches != null) {
const negate = '-' === matches[1] ? -1 : 1;
const yearMatch = matches[2];
const monthMatch = matches[3];
const weekMatch = matches[4];
const dayMatch = matches[5];
if (yearMatch != null || monthMatch != null || weekMatch != null || dayMatch != null) {
const years = Period._parseNumber(text, yearMatch, negate);
const months = Period._parseNumber(text, monthMatch, negate);
const weeks = Period._parseNumber(text, weekMatch, negate);
let days = Period._parseNumber(text, dayMatch, negate);
days = MathUtil.safeAdd(days, MathUtil.safeMultiply(weeks, 7));
return Period.create(years, months, days);
}
}
throw new DateTimeParseException('Text cannot be parsed to a Period', text, 0);
}
static _parseNumber(text, str, negate) {
if (str == null) {
return 0;
}
const val = MathUtil.parseInt(str);
return MathUtil.safeMultiply(val, negate);
}
//-----------------------------------------------------------------------
/**
* Creates an instance.
*
* @param {number} years - the amount
* @param {number} months - the amount
* @param {number} days - the amount
* @return {Duration}
*/
static create(years, months, days) {
return new Period(years, months, days);
}
//-----------------------------------------------------------------------
/**
* Gets the list of units, from largest to smallest, that fully define this amount.
*
* @returns {ChronoUnit[]} list of units
*/
units() {
return [ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS];
}
/**
* Gets the chronology that defines the meaning of the supported units.
*
* The period is defined by the chronology.
* It controls the supported units and restricts addition/subtraction
* to {@link ChronoLocalDate} instances of the same chronology.
*
* @return {IsoChronology} the chronology defining the period, not null
*/
chronology() {
return IsoChronology.INSTANCE;
}
/**
* Gets the value of the requested unit.
*
* The supported units are chronology specific.
* They will typically be {@link ChronoUnit#YEARS},
* {@link ChronoUnit#MONTHS} and {@link ChronoUnit#DAYS}.
* Requesting an unsupported unit will throw an exception.
*
* @param {TemporalUnit} unit the {@link TemporalUnit} for which to return the value
* @return {number} the long value of the unit
* @throws DateTimeException if the unit is not supported
* @throws UnsupportedTemporalTypeException if the unit is not supported
*/
get(unit) {
if (unit === ChronoUnit.YEARS) {
return this._years;
}
if (unit === ChronoUnit.MONTHS) {
return this._months;
}
if (unit === ChronoUnit.DAYS) {
return this._days;
}
throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
}
//-----------------------------------------------------------------------
/**
* Checks if all three units of this period are zero.
*
* A zero period has the value zero for the years, months and days units.
*
* @return {boolean} true if this period is zero-length
*/
isZero() {
return (this === Period.ZERO);
}
/**
* Checks if any of the three units of this period are negative.
*
* This checks whether the years, months or days units are less than zero.
*
* @return {boolean} true if any unit of this period is negative
*/
isNegative() {
return this._years < 0 || this._months < 0 || this._days < 0;
}
//-----------------------------------------------------------------------
/**
* Gets the amount of years of this period.
*
* This returns the years unit.
*
* The months unit is not normalized with the years unit.
* This means that a period of '15 months' is different to a period
* of '1 year and 3 months'.
*
* @return {number} the amount of years of this period, may be negative
*/
years() {
return this._years;
}
/**
* Gets the amount of months of this period.
*
* This returns the months unit.
*
* The months unit is not normalized with the years unit.
* This means that a period of '15 months' is different to a period
* of '1 year and 3 months'.
*
* @return {number} the amount of months of this period, may be negative
*/
months() {
return this._months;
}
/**
* Gets the amount of days of this period.
*
* This returns the days unit.
*
* @return {number} the amount of days of this period, may be negative
*/
days() {
return this._days;
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this period with the specified amount of years.
*
* This sets the amount of the years unit in a copy of this period.
* The months and days units are unaffected.
*
* The months unit is not normalized with the years unit.
* This means that a period of '15 months' is different to a period
* of '1 year and 3 months'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} years - the years to represent, may be negative
* @return {Period} a {@link Period} based on this period with the requested years, not null
*/
withYears(years) {
if (years === this._years) {
return this;
}
return Period.create(years, this._months, this._days);
}
/**
* Returns a copy of this period with the specified amount of months.
*
* This sets the amount of the months unit in a copy of this period.
* The years and days units are unaffected.
*
* The months unit is not normalized with the years unit.
* This means that a period of '15 months' is different to a period
* of '1 year and 3 months'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} months - the months to represent, may be negative
* @return {Period} a {@link Period} based on this period with the requested months, not null
*/
withMonths(months) {
if (months === this._months) {
return this;
}
return Period.create(this._years, months, this._days);
}
/**
* Returns a copy of this period with the specified amount of days.
*
* This sets the amount of the days unit in a copy of this period.
* The years and months units are unaffected.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} days - the days to represent, may be negative
* @return {Period} a {@link Period} based on this period with the requested days, not null
*/
withDays(days) {
if (days === this._days) {
return this;
}
return Period.create(this._years, this._months, days);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this period with the specified amount added.
*
* This input amount is converted to a {@link Period} using {@link from}.
* This operates separately on the years, months and days.
*
* For example, '1 year, 6 months and 3 days' plus '2 years, 2 months and 2 days'
* returns '3 years, 8 months and 5 days'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {TemporalAmount} amountToAdd - the period to add, not null
* @return {Period} a {@link Period} based on this period with the requested period added, not null
* @throws ArithmeticException if numeric overflow occurs
*/
plus(amountToAdd) {
const amount = Period.from(amountToAdd);
return Period.create(
MathUtil.safeAdd(this._years, amount._years),
MathUtil.safeAdd(this._months, amount._months),
MathUtil.safeAdd(this._days, amount._days));
}
/**
* Returns a copy of this period with the specified years added.
*
* This adds the amount to the years unit in a copy of this period.
* The months and days units are unaffected.
* For example, '1 year, 6 months and 3 days' plus 2 years returns '3 years, 6 months and 3 days'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} yearsToAdd - the years to add, positive or negative
* @return {Period} a {@link Period} based on this period with the specified years added, not null
* @throws ArithmeticException if numeric overflow occurs
*/
plusYears(yearsToAdd) {
if (yearsToAdd === 0) {
return this;
}
return Period.create(MathUtil.safeToInt(MathUtil.safeAdd(this._years, yearsToAdd)), this._months, this._days);
}
/**
* Returns a copy of this period with the specified months added.
*
* This adds the amount to the months unit in a copy of this period.
* The years and days units are unaffected.
* For example, '1 year, 6 months and 3 days' plus 2 months returns '1 year, 8 months and 3 days'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} monthsToAdd - the months to add, positive or negative
* @return {Period} a {@link Period} based on this period with the specified months added, not null
* @throws ArithmeticException if numeric overflow occurs
*/
plusMonths(monthsToAdd) {
if (monthsToAdd === 0) {
return this;
}
return Period.create(this._years, MathUtil.safeToInt(MathUtil.safeAdd(this._months, monthsToAdd)), this._days);
}
/**
* Returns a copy of this period with the specified days added.
*
* This adds the amount to the days unit in a copy of this period.
* The years and months units are unaffected.
* For example, '1 year, 6 months and 3 days' plus 2 days returns '1 year, 6 months and 5 days'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} daysToAdd - the days to add, positive or negative
* @return {Period} a {@link Period} based on this period with the specified days added, not null
* @throws ArithmeticException if numeric overflow occurs
*/
plusDays(daysToAdd) {
if (daysToAdd === 0) {
return this;
}
return Period.create(this._years, this._months, MathUtil.safeToInt(MathUtil.safeAdd(this._days, daysToAdd)));
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this period with the specified amount subtracted.
*
* This input amount is converted to a {@link Period} using {@link from}.
* This operates separately on the years, months and days.
*
* For example, '1 year, 6 months and 3 days' minus '2 years, 2 months and 2 days'
* returns '-1 years, 4 months and 1 day'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {TemporalAmount} amountToSubtract - the period to subtract, not null
* @return {Period} a {@link Period} based on this period with the requested period subtracted, not null
* @throws ArithmeticException if numeric overflow occurs
*/
minus(amountToSubtract) {
const amount = Period.from(amountToSubtract);
return Period.create(
MathUtil.safeSubtract(this._years, amount._years),
MathUtil.safeSubtract(this._months, amount._months),
MathUtil.safeSubtract(this._days, amount._days));
}
/**
* Returns a copy of this period with the specified years subtracted.
*
* This subtracts the amount from the years unit in a copy of this period.
* The months and days units are unaffected.
* For example, '1 year, 6 months and 3 days' minus 2 years returns '-1 years, 6 months and 3 days'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} yearsToSubtract - the years to subtract, positive or negative
* @return {Period} a {@link Period} based on this period with the specified years subtracted, not null
* @throws ArithmeticException if numeric overflow occurs
*/
minusYears(yearsToSubtract) {
return this.plusYears(-1 * yearsToSubtract);
}
/**
* Returns a copy of this period with the specified months subtracted.
*
* This subtracts the amount from the months unit in a copy of this period.
* The years and days units are unaffected.
* For example, '1 year, 6 months and 3 days' minus 2 months returns '1 year, 4 months and 3 days'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} monthsToSubtract - the years to subtract, positive or negative
* @return {Period} a {@link Period} based on this period with the specified months subtracted, not null
* @throws ArithmeticException if numeric overflow occurs
*/
minusMonths(monthsToSubtract) {
return this.plusMonths(-1 * monthsToSubtract);
}
/**
* Returns a copy of this period with the specified days subtracted.
*
* This subtracts the amount from the days unit in a copy of this period.
* The years and months units are unaffected.
* For example, '1 year, 6 months and 3 days' minus 2 days returns '1 year, 6 months and 1 day'.
*
* This instance is immutable and unaffected by this method call.
*
* @param {number} daysToSubtract - the months to subtract, positive or negative
* @return {Period} a {@link Period} based on this period with the specified days subtracted, not null
* @throws ArithmeticException if numeric overflow occurs
*/
minusDays(daysToSubtract) {
return this.plusDays(-1 * daysToSubtract);
}
//-----------------------------------------------------------------------
/**
* Returns a new instance with each element in this period multiplied
* by the specified scalar.
*
* This simply multiplies each field, years, months, days and normalized time,
* by the scalar. No normalization is performed.
*
* @param {number} scalar - the scalar to multiply by, not null
* @return {Period} a {@link Period} based on this period with the amounts multiplied by the scalar, not null
* @throws ArithmeticException if numeric overflow occurs
*/
multipliedBy(scalar) {
if (this === Period.ZERO || scalar === 1) {
return this;
}
return Period.create(
MathUtil.safeMultiply(this._years, scalar),
MathUtil.safeMultiply(this._months, scalar),
MathUtil.safeMultiply(this._days, scalar));
}
/**
* Returns a new instance with each amount in this period negated.
*
* @return {Period} a {@link Period} based on this period with the amounts negated, not null
* @throws ArithmeticException if numeric overflow occurs
*/
negated() {
return this.multipliedBy(-1);
}
//-----------------------------------------------------------------------
/**
* Returns a copy of this period with the years and months normalized
* using a 12 month year.
*
* This normalizes the years and months units, leaving the days unit unchanged.
* The months unit is adjusted to have an absolute value less than 11,
* with the years unit being adjusted to compensate. For example, a period of
* '1 Year and 15 months' will be normalized to '2 years and 3 months'.
*
* The sign of the years and months units will be the same after normalization.
* For example, a period of '1 year and -25 months' will be normalized to
* '-1 year and -1 month'.
*
* This normalization uses a 12 month year which is not valid for all calendar systems.
*
* This instance is immutable and unaffected by this method call.
*
* @return {Period} a {@link Period} based on this period with excess months normalized to years, not null
* @throws ArithmeticException if numeric overflow occurs
*/
normalized() {
const totalMonths = this.toTotalMonths();
const splitYears = MathUtil.intDiv(totalMonths, 12);
const splitMonths = MathUtil.intMod(totalMonths, 12); // no overflow
if (splitYears === this._years && splitMonths === this._months) {
return this;
}
return Period.create(MathUtil.safeToInt(splitYears), splitMonths, this._days);
}
/**
* Gets the total number of months in this period using a 12 month year.
*
* This returns the total number of months in the period by multiplying the
* number of years by 12 and adding the number of months.
*
* This uses a 12 month year which is not valid for all calendar systems.
*
* This instance is immutable and unaffected by this method call.
*
* @return {number} the total number of months in the period, may be negative
*/
toTotalMonths() {
return this._years * 12 + this._months; // no overflow
}
//-------------------------------------------------------------------------
/**
* Adds this period to the specified temporal object.
*
* This returns a temporal object of the same observable type as the input
* with this period added.
*
* In most cases, it is clearer to reverse the calling pattern by using
* {@link Temporal#plus}.
* <pre>
* // these two lines are equivalent, but the second approach is recommended
* dateTime = thisPeriod.addTo(dateTime);
* dateTime = dateTime.plus(thisPeriod);
* </pre>
*
* The calculation will add the years, then months, then days.
* Only non-zero amounts will be added.
* If the date-time has a calendar system with a fixed number of months in a
* year, then the years and months will be combined before being added.
*
* This instance is immutable and unaffected by this method call.
*
* @param {Temporal} temporal - the temporal object to adjust, not null
* @return {Temporal} an object of the same type with the adjustment made, not null
* @throws DateTimeException if unable to add
* @throws ArithmeticException if numeric overflow occurs
*/
addTo(temporal) {
requireNonNull(temporal, 'temporal');
if (this._years !== 0) {
if (this._months !== 0) {
temporal = temporal.plus(this.toTotalMonths(), ChronoUnit.MONTHS);
} else {
temporal = temporal.plus(this._years, ChronoUnit.YEARS);
}
} else if (this._months !== 0) {
temporal = temporal.plus(this._months, ChronoUnit.MONTHS);
}
if (this._days !== 0) {
temporal = temporal.plus(this._days, ChronoUnit.DAYS);
}
return temporal;
}
/**
* Subtracts this period from the specified temporal object.
*
* This returns a temporal object of the same observable type as the input
* with this period subtracted.
*
* In most cases, it is clearer to reverse the calling pattern by using
* {@link Temporal#minus}.
* <pre>
* // these two lines are equivalent, but the second approach is recommended
* dateTime = thisPeriod.subtractFrom(dateTime);
* dateTime = dateTime.minus(thisPeriod);
* </pre>
*
* The calculation operates as follows.
* First, the chronology of the temporal is checked to ensure it is ISO chronology or null.
* Second, if the months are zero, the years are added if non-zero, otherwise
* the combination of years and months is added if non-zero.
* Finally, any days are added.
*
* The calculation will subtract the years, then months, then days.
* Only non-zero amounts will be subtracted.
* If the date-time has a calendar system with a fixed number of months in a
* year, then the years and months will be combined before being subtracted.
*
* This instance is immutable and unaffected by this method call.
*
* @param {Temporal} temporal - the temporal object to adjust, not null
* @return {Temporal} an object of the same type with the adjustment made, not null
* @throws DateTimeException if unable to subtract
* @throws ArithmeticException if numeric overflow occurs
*/
subtractFrom(temporal) {
requireNonNull(temporal, 'temporal');
if (this._years !== 0) {
if (this._months !== 0) {
temporal = temporal.minus(this.toTotalMonths(), ChronoUnit.MONTHS);
} else {
temporal = temporal.minus(this._years, ChronoUnit.YEARS);
}
} else if (this._months !== 0) {
temporal = temporal.minus(this._months, ChronoUnit.MONTHS);
}
if (this._days !== 0) {
temporal = temporal.minus(this._days, ChronoUnit.DAYS);
}
return temporal;
}
//-----------------------------------------------------------------------
/**
* Checks if this period is equal to another period.
*
* The comparison is based on the amounts held in the period.
* To be equal, the years, months and days units must be individually equal.
* Note that this means that a period of '15 Months' is not equal to a period
* of '1 Year and 3 Months'.
*
* @param {*} obj - the object to check, null returns false
* @return {boolean} true if this is equal to the other period
*/
equals(obj) {
if (this === obj) {
return true;
}
if (obj instanceof Period) {
const other = obj;
return this._years === other._years &&
this._months === other._months &&
this._days === other._days;
}
return false;
}
/**
* A hash code for this period.
*
* @return {number} a suitable hash code
*/
hashCode() {
return MathUtil.hashCode(this._years, this._months, this._days);
}
//-----------------------------------------------------------------------
/**
* Outputs this period as a string, such as {@link P6Y3M1D}.
*
* The output will be in the ISO-8601 period format.
* A zero period will be represented as zero days, 'P0D'.
*
* @return {string} a string representation of this period, not null
*/
toString() {
if (this === Period.ZERO) {
return 'P0D';
} else {
let buf = 'P';
if (this._years !== 0) {
buf += `${this._years}Y`;
}
if (this._months !== 0) {
buf += `${this._months}M`;
}
if (this._days !== 0) {
buf += `${this._days}D`;
}
return buf;
}
}
/**
*
* @return {string} same as {@link Period.toString}
*/
toJSON() {
return this.toString();
}
}
export function _init() {
/**
* A constant for a period of zero.
*/
Period.ofDays(0);
}