public function adjustInto(Temporal $temporal, $newValue) { // calls getFrom() to check if supported $this->range()->checkValidValue($newValue, $this); // lenient range return $temporal->plus(Math::subtractExact($newValue, $this->getFrom($temporal)), ChronoUnit::WEEKS()); }
/** * @inheritdoc */ public function query(TemporalQuery $query) { if ($query == TemporalQueries::precision()) { return ChronoUnit::ERAS(); } return parent::query($query); }
private function run($argv) { $ids = ZoneRulesProvider::getAvailableZoneIds(); $start = Instant::now(); foreach ($ids as $id) { TZDBZoneRulesProvider::getRules($id, false); } $end = Instant::now(); echo 'First run: ', ChronoUnit::MILLIS()->between($start, $end), "ms, count: ", count($ids), "\n"; }
/** * Rata Die field. * <p> * Rata Die counts whole days continuously starting day 1 at midnight at the beginning of 0001-01-01 (ISO). * The field always refers to the local date-time, ignoring the offset or zone. * <p> * For date-times, 'RATA_DIE.getFrom()' assumes the same value from * midnight until just before the next midnight. * When 'RATA_DIE.adjustInto()' is applied to a date-time, the time of day portion remains unaltered. * 'RATA_DIE.adjustInto()' and 'RATA_DIE.getFrom()' only apply to {@code Temporal} objects * that can be converted into {@link ChronoField#EPOCH_DAY}. * An {@link UnsupportedTemporalTypeException} is thrown for any other type of object. * <p> * In the resolving phase of parsing, a date can be created from a Rata Die field. * In {@linkplain ResolverStyle#STRICT strict mode} and {@linkplain ResolverStyle#SMART smart mode} * the Rata Die value is validated against the range of valid values. * In {@linkplain ResolverStyle#LENIENT lenient mode} no validation occurs. * @return TemporalField */ public static function RATA_DIE() { if (self::$RATA_DIE === null) { self::$RATA_DIE = new JulianField("RataDie", CU::DAYS(), CU::FOREVER(), 719163); } return self::$RATA_DIE; }
/** * Calculates the amount of time until another time in terms of the specified unit. * <p> * This calculates the amount of time between two {@code LocalTime} * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified time. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method is converted to a * {@code LocalTime} using {@link #from(TemporalAccessor)}. * For example, the amount in hours between two times can be calculated * using {@code startTime.until(endTime, HOURS)}. * <p> * The calculation returns a whole number, representing the number of * complete units between the two times. * For example, the amount in hours between 11:30 and 13:29 will only * be one hour as it is one minute short of two hours. * <p> * There are two equivalent ways of using this method. * The first is to invoke this method. * The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: * <pre> * // these two lines are equivalent * amount = start.until(end, MINUTES); * amount = MINUTES.between(start, end); * </pre> * The choice should be made based on which makes the code more readable. * <p> * The calculation is implemented in this method for {@link ChronoUnit}. * The units {@code NANOS}, {@code MICROS}, {@code MILLIS}, {@code SECONDS}, * {@code MINUTES}, {@code HOURS} and {@code HALF_DAYS} are supported. * Other {@code ChronoUnit} values will throw an exception. * <p> * If the unit is not a {@code ChronoUnit}, then the result of this method * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)} * passing {@code this} as the first argument and the converted input temporal * as the second argument. * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $endExclusive the end time, exclusive, which is converted to a {@code LocalTime}, not null * @param $unit $unit the unit to measure the amount in, not null * @return int the amount of time between this time and the end time * @throws DateTimeException if the amount cannot be calculated, or the end * temporal cannot be converted to a {@code LocalTime} * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ public function until(Temporal $endExclusive, TemporalUnit $unit) { $end = self::from($endExclusive); if ($unit instanceof ChronoUnit) { $nanosUntil = $end->toNanoOfDay() - $this->toNanoOfDay(); // no overflow switch ($unit) { case ChronoUnit::NANOS(): return $nanosUntil; case ChronoUnit::MICROS(): return Math::div($nanosUntil, 1000); case ChronoUnit::MILLIS(): return Math::div($nanosUntil, 1000000); case ChronoUnit::SECONDS(): return Math::div($nanosUntil, self::NANOS_PER_SECOND); case ChronoUnit::MINUTES(): return Math::div($nanosUntil, self::NANOS_PER_MINUTE); case ChronoUnit::HOURS(): return Math::div($nanosUntil, self::NANOS_PER_HOUR); case ChronoUnit::HALF_DAYS(): return Math::div($nanosUntil, 12 * self::NANOS_PER_HOUR); } throw new UnsupportedTemporalTypeException("Unsupported unit: " . $unit); } return $unit->between($this, $end); }
public function test_until_nullTemporal() { TestHelper::assertNullException($this, function () { $this->TEST_DATE_TIME_PARIS->until(null, CU::DAYS()); }); }
public function test_until_TemporalUnit_nullEnd() { TestHelper::assertNullException($this, function () { self::TEST_200707_15_12_30_40_987654321()->until(null, CU::HOURS()); }); }
public function until(Temporal $endExclusive, TemporalUnit $unit) { $end = $this->getChronology()->dateFrom($endExclusive); if ($unit instanceof ChronoUnit) { switch ($unit) { case CU::DAYS(): return $this->daysUntil($end); case CU::WEEKS(): return $this->daysUntil($end) / 7; case CU::MONTHS(): return $this->monthsUntil($end); case CU::YEARS(): return $this->monthsUntil($end) / 12; case CU::DECADES(): return $this->monthsUntil($end) / 120; case CU::CENTURIES(): return $this->monthsUntil($end) / 1200; case CU::MILLENNIA(): return $this->monthsUntil($end) / 12000; case CU::ERAS(): return $end->getLong(CF::ERA()) - $this->getLong(CF::ERA()); } throw new UnsupportedTemporalTypeException("Unsupported unit: " . $unit); } return $unit->between($this, $end); }
function provider_factory_of_badTemporalUnit() { return [[0, CU::MICROS()], [0, CU::MILLIS()], [0, CU::MINUTES()], [0, CU::HOURS()], [0, CU::HALF_DAYS()], [0, CU::DAYS()], [0, CU::MONTHS()], [0, CU::YEARS()], [0, CU::DECADES()], [0, CU::CENTURIES()], [0, CU::MILLENNIA()]]; }
/** * @dataProvider data_weekFields */ public function test_rangeWeekOfWeekBasedYear(DayOfWeek $firstDayOfWeek, $minDays) { $weekFields = WeekFields::of($firstDayOfWeek, $minDays); $dowField = $weekFields->dayOfWeek(); $wowByField = $weekFields->weekOfWeekBasedYear(); $day1 = LocalDate::of(2012, 1, $weekFields->getMinimalDaysInFirstWeek()); $day1 = $day1->with($wowByField, 1)->with($dowField, 1); $day2 = LocalDate::of(2013, 1, $weekFields->getMinimalDaysInFirstWeek()); $day2 = $day2->with($wowByField, 1)->with($dowField, 1); $expectedWeeks = ChronoUnit::DAYS()->between($day1, $day2) / 7; $range = $day1->range($wowByField); $this->assertEquals($range->getMaximum(), $expectedWeeks, "Range incorrect"); }
public function getRangeUnit() { return ChronoUnit::MONTHS(); }
public function with(TemporalField $field, $newValue) { if ($field instanceof ChronoField) { $f = $field; switch ($f) { case ChronoField::INSTANT_SECONDS(): return $this->plus($newValue - $this->toEpochSecond(), ChronoUnit::SECONDS()); case ChronoField::OFFSET_SECONDS(): $offset = ZoneOffset::ofTotalSeconds($f->checkValidIntValue($newValue)); return $this->create($this->dateTime->toInstant($offset), $this->zone); } return $this->ofBest($this->dateTime->with($field, $newValue), $this->zone, $this->offset); } return ChronoZonedDateTimeImpl::ensureValid($this->getChronology(), $field->adjustInto($this, $newValue)); }
function data_badTemporalUnit() { return [[CU::MICROS()], [CU::MILLIS()], [CU::HALF_DAYS()], [CU::DECADES()], [CU::CENTURIES()], [CU::MILLENNIA()]]; }
/** * Calculates the amount of time until another date-time in terms of the specified unit. * <p> * This calculates the amount of time between two {@code LocalDateTime} * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date-time. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method is converted to a * {@code LocalDateTime} using {@link #from(TemporalAccessor)}. * For example, the amount in days between two date-times can be calculated * using {@code startDateTime.until(endDateTime, DAYS)}. * <p> * The calculation returns a whole number, representing the number of * complete units between the two date-times. * For example, the amount in months between 2012-06-15T00:00 and 2012-08-14T23:59 * will only be one month as it is one minute short of two months. * <p> * There are two equivalent ways of using this method. * The first is to invoke this method. * The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: * <pre> * // these two lines are equivalent * amount = start.until(end, MONTHS); * amount = MONTHS.between(start, end); * </pre> * The choice should be made based on which makes the code more readable. * <p> * The calculation is implemented in this method for {@link ChronoUnit}. * The units {@code NANOS}, {@code MICROS}, {@code MILLIS}, {@code SECONDS}, * {@code MINUTES}, {@code HOURS} and {@code HALF_DAYS}, {@code DAYS}, * {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, * {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. * Other {@code ChronoUnit} values will throw an exception. * <p> * If the unit is not a {@code ChronoUnit}, then the result of this method * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)} * passing {@code this} as the first argument and the converted input temporal * as the second argument. * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $endExclusive the end date, exclusive, which is converted to a {@code LocalDateTime}, not null * @param TemporalUnit $unit the unit to measure the amount in, not null * @return int the amount of time between this date-time and the end date-time * @throws DateTimeException if the amount cannot be calculated, or the end * temporal cannot be converted to a {@code LocalDateTime} * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ public function until(Temporal $endExclusive, TemporalUnit $unit) { $end = LocalDateTime::from($endExclusive); if ($unit instanceof ChronoUnit) { if ($unit->isTimeBased()) { $amount = $this->date->daysUntil($end->date); if ($amount === 0) { return $this->time->until($end->time, $unit); } $timePart = $end->time->toNanoOfDay() - $this->time->toNanoOfDay(); if ($amount > 0) { $amount--; // safe $timePart += LocalTime::NANOS_PER_DAY; // safe } else { $amount++; // safe $timePart -= LocalTime::NANOS_PER_DAY; // safe } switch ($unit) { case ChronoUnit::NANOS(): $amount = Math::multiplyExact($amount, LocalTime::NANOS_PER_DAY); break; case ChronoUnit::MICROS(): $amount = Math::multiplyExact($amount, LocalTime::MICROS_PER_DAY); $timePart = Math::div($timePart, 1000); break; case ChronoUnit::MILLIS(): $amount = Math::multiplyExact($amount, LocalTime::MILLIS_PER_DAY); $timePart = Math::div($timePart, 1000000); break; case ChronoUnit::SECONDS(): $amount = Math::multiplyExact($amount, LocalTime::SECONDS_PER_DAY); $timePart = Math::div($timePart, LocalTime::NANOS_PER_SECOND); break; case ChronoUnit::MINUTES(): $amount = Math::multiplyExact($amount, LocalTime::MINUTES_PER_DAY); $timePart = Math::div($timePart, LocalTime::NANOS_PER_MINUTE); break; case ChronoUnit::HOURS(): $amount = Math::multiplyExact($amount, LocalTime::HOURS_PER_DAY); $timePart = Math::div($timePart, LocalTime::NANOS_PER_HOUR); break; case ChronoUnit::HALF_DAYS(): $amount = Math::multiplyExact($amount, 2); $timePart = Math::div($timePart, LocalTime::NANOS_PER_HOUR * 12); break; } return Math::addExact($amount, $timePart); } $endDate = $end->date; if ($endDate->isAfter($this->date) && $end->time->isBefore($this->time)) { $endDate = $endDate->minusDays(1); } else { if ($endDate->isBefore($this->date) && $end->time->isAfter($this->time)) { $endDate = $endDate->plusDays(1); } } return $this->date->until($endDate, $unit); } return $unit->between($this, $end); }
public function getRangeUnit() { return ChronoUnit::FOREVER(); }
public function getRangeUnit() { return ChronoUnit::YEARS(); }
/** * Calculates the amount of time until another year in terms of the specified unit. * <p> * This calculates the amount of time between two {@code Year} * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified year. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method is converted to a * {@code Year} using {@link #from(TemporalAccessor)}. * For example, the amount in decades between two year can be calculated * using {@code startYear.until(endYear, DECADES)}. * <p> * The calculation returns a whole number, representing the number of * complete units between the two years. * For example, the amount in decades between 2012 and 2031 * will only be one decade as it is one year short of two decades. * <p> * There are two equivalent ways of using this method. * The first is to invoke this method. * The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: * <pre> * // these two lines are equivalent * amount = start.until(end, YEARS); * amount = YEARS.between(start, end); * </pre> * The choice should be made based on which makes the code more readable. * <p> * The calculation is implemented in this method for {@link ChronoUnit}. * The units {@code YEARS}, {@code DECADES}, {@code CENTURIES}, * {@code MILLENNIA} and {@code ERAS} are supported. * Other {@code ChronoUnit} values will throw an exception. * <p> * If the unit is not a {@code ChronoUnit}, then the result of this method * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)} * passing {@code this} as the first argument and the converted input temporal * as the second argument. * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $endExclusive the end date, exclusive, which is converted to a {@code Year}, not null * @param TemporalUnit $unit the unit to measure the amount in, not null * @return int the amount of time between this year and the end year * @throws DateTimeException if the amount cannot be calculated, or the end * temporal cannot be converted to a {@code Year} * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ public function until(Temporal $endExclusive, TemporalUnit $unit) { $end = Year::from($endExclusive); if ($unit instanceof ChronoUnit) { $yearsUntil = $end->year - $this->year; // no overflow switch ($unit) { case ChronoUnit::YEARS(): return $yearsUntil; case ChronoUnit::DECADES(): return Math::div($yearsUntil, 10); case ChronoUnit::CENTURIES(): return Math::div($yearsUntil, 100); case ChronoUnit::MILLENNIA(): return Math::div($yearsUntil, 1000); case ChronoUnit::ERAS(): return $end->getLong(ChronoField::ERA()) - $this->getLong(ChronoField::ERA()); } throw new UnsupportedTemporalTypeException("Unsupported unit: " . $unit); } return $unit->between($this, $end); }
function data_query() { return [[DayOfWeek::FRIDAY(), TemporalQueries::chronology(), null], [DayOfWeek::FRIDAY(), TemporalQueries::zoneId(), null], [DayOfWeek::FRIDAY(), TemporalQueries::precision(), ChronoUnit::DAYS()], [DayOfWeek::FRIDAY(), TemporalQueries::zone(), null], [DayOfWeek::FRIDAY(), TemporalQueries::offset(), null], [DayOfWeek::FRIDAY(), TemporalQueries::localDate(), null], [DayOfWeek::FRIDAY(), TemporalQueries::localTime(), null]]; }
/** * Subtracts this duration from the specified temporal object. * <p> * This returns a temporal object of the same observable type as the input * with this duration subtracted. * <p> * In most cases, it is clearer to reverse the calling pattern by using * {@link Temporal#minus(TemporalAmount)}. * <pre> * // these two lines are equivalent, but the second approach is recommended * dateTime = thisDuration.subtractFrom(dateTime); * dateTime = dateTime.minus(thisDuration); * </pre> * <p> * The calculation will subtract the seconds, then nanos. * Only non-zero amounts will be added. * <p> * 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 */ public function subtractFrom(Temporal $temporal) { if ($this->seconds != 0) { $temporal = $temporal->minus($this->seconds, ChronoUnit::SECONDS()); } if ($this->nanos != 0) { $temporal = $temporal->minus($this->nanos, ChronoUnit::NANOS()); } return $temporal; }
public function getBaseUnit() { return ChronoUnit::DAYS(); }
public function test_until_TemporalUnit_nullEnd() { TestHelper::assertNullException($this, function () { self::TEST_2008_06()->until(null, CU::DAYS()); }); }
protected function resolveAligned(ChronoLocalDate $base, $months, $weeks, $dow) { $date = $base->plus($months, ChronoUnit::MONTHS())->plus($weeks, ChronoUnit::WEEKS()); if ($dow > 7) { $date = $date->plus(($dow - 1) / 7, ChronoUnit::WEEKS()); $dow = ($dow - 1) % 7 + 1; } else { if ($dow < 1) { $date = $date->plus(Math::subtractExact($dow, 7) / 7, ChronoUnit::WEEKS()); $dow = ($dow + 6) % 7 + 1; } } return $date->adjust(TemporalAdjusters::nextOrSame(DayOfWeek::of((int) $dow))); }
/** * Calculates the amount of time until another instant in terms of the specified unit. * <p> * This calculates the amount of time between two {@code Instant} * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified instant. * The result will be negative if the end is before the start. * The calculation returns a whole number, representing the number of * complete units between the two instants. * The {@code Temporal} passed to this method is converted to a * {@code Instant} using {@link #from(TemporalAccessor)}. * For example, the amount in days between two dates can be calculated * using {@code startInstant.until(endInstant, SECONDS)}. * <p> * There are two equivalent ways of using this method. * The first is to invoke this method. * The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: * <pre> * // these two lines are equivalent * amount = start.until(end, SECONDS); * amount = SECONDS.between(start, end); * </pre> * The choice should be made based on which makes the code more readable. * <p> * The calculation is implemented in this method for {@link ChronoUnit}. * The units {@code NANOS}, {@code MICROS}, {@code MILLIS}, {@code SECONDS}, * {@code MINUTES}, {@code HOURS}, {@code HALF_DAYS} and {@code DAYS} * are supported. Other {@code ChronoUnit} values will throw an exception. * <p> * If the unit is not a {@code ChronoUnit}, then the result of this method * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)} * passing {@code this} as the first argument and the converted input temporal * as the second argument. * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $endExclusive the end date, exclusive, which is converted to an Instant {@code Instant}, not null * @param TemporalUnit $unit the unit to measure the amount in, not null * @return int the amount of time between this instant and the end instant * @throws DateTimeException if the amount cannot be calculated, or the end * temporal cannot be converted to an Instant {@code Instant} * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ public function until(Temporal $endExclusive, TemporalUnit $unit) { $end = Instant::from($endExclusive); if ($unit instanceof ChronoUnit) { $f = $unit; switch ($f) { case ChronoUnit::NANOS(): return $this->nanosUntil($end); case ChronoUnit::MICROS(): return Math::div($this->nanosUntil($end), 1000); case ChronoUnit::MILLIS(): return Math::subtractExact($end->toEpochMilli(), $this->toEpochMilli()); case ChronoUnit::SECONDS(): return $this->secondsUntil($end); case ChronoUnit::MINUTES(): return Math::div($this->secondsUntil($end), LocalTime::SECONDS_PER_MINUTE); case ChronoUnit::HOURS(): return Math::div($this->secondsUntil($end), LocalTime::SECONDS_PER_HOUR); case ChronoUnit::HALF_DAYS(): return Math::div($this->secondsUntil($end), 12 * LocalTime::SECONDS_PER_HOUR); case ChronoUnit::DAYS(): return Math::div($this->secondsUntil($end), LocalTime::SECONDS_PER_DAY); } throw new UnsupportedTemporalTypeException("Unsupported unit: " . $unit); } return $unit->between($this, $end); }
private function __construct($amount, TemporalUnit $unit) { if ($unit == CU::FOREVER()) { throw new DateTimeException("Cannot create a period of the Forever unit"); } $this->amount = $amount; $this->unit = $unit; }
/** * Calculates the amount of time until another date in terms of the specified unit. * <p> * This calculates the amount of time between two {@code LocalDate} * objects in terms of a single {@code TemporalUnit}. * The start and end points are {@code this} and the specified date. * The result will be negative if the end is before the start. * The {@code Temporal} passed to this method is converted to a * {@code LocalDate} using {@link #from(TemporalAccessor)}. * For example, the amount in days between two dates can be calculated * using {@code startDate.until(endDate, DAYS)}. * <p> * The calculation returns a whole number, representing the number of * complete units between the two dates. * For example, the amount in months between 2012-06-15 and 2012-08-14 * will only be one month as it is one day short of two months. * <p> * There are two equivalent ways of using this method. * The first is to invoke this method. * The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: * <pre> * // these two lines are equivalent * amount = start.until(end, MONTHS); * amount = MONTHS.between(start, end); * </pre> * The choice should be made based on which makes the code more readable. * <p> * The calculation is implemented in this method for {@link ChronoUnit}. * The units {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, * {@code DECADES}, {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} * are supported. Other {@code ChronoUnit} values will throw an exception. * <p> * If the unit is not a {@code ChronoUnit}, then the result of this method * is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)} * passing {@code this} as the first argument and the converted input temporal * as the second argument. * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $endExclusive the end date, exclusive, which is converted to a {@code LocalDate}, not null * @param TemporalUnit $unit the unit to measure the amount in, not null * @return int the amount of time between this date and the end date * @throws DateTimeException if the amount cannot be calculated, or the end * temporal cannot be converted to a {@code LocalDate} * @throws UnsupportedTemporalTypeException if the unit is not supported * @throws ArithmeticException if numeric overflow occurs */ public function until(Temporal $endExclusive, TemporalUnit $unit) { $end = LocalDate::from($endExclusive); if ($unit instanceof ChronoUnit) { switch ($unit) { case ChronoUnit::DAYS(): return $this->daysUntil($end); case ChronoUnit::WEEKS(): return Math::div($this->daysUntil($end), 7); case ChronoUnit::MONTHS(): return $this->monthsUntil($end); case ChronoUnit::YEARS(): return Math::div($this->monthsUntil($end), 12); case ChronoUnit::DECADES(): return Math::div($this->monthsUntil($end), 120); case ChronoUnit::CENTURIES(): return Math::div($this->monthsUntil($end), 1200); case ChronoUnit::MILLENNIA(): return Math::div($this->monthsUntil($end), 12000); case ChronoUnit::ERAS(): return $end->getLong(ChronoField::ERA()) - $this->getLong(ChronoField::ERA()); } throw new UnsupportedTemporalTypeException("Unsupported unit: " . $unit); } return $unit->between($this, $end); }
function data_fieldUnit() { return [[CF::YEAR(), CU::YEARS(), CU::FOREVER()], [CF::MONTH_OF_YEAR(), CU::MONTHS(), CU::YEARS()], [CF::DAY_OF_MONTH(), CU::DAYS(), CU::MONTHS()], [CF::DAY_OF_WEEK(), CU::DAYS(), CU::WEEKS()], [CF::DAY_OF_YEAR(), CU::DAYS(), CU::YEARS()], [CF::HOUR_OF_DAY(), CU::HOURS(), CU::DAYS()], [CF::MINUTE_OF_DAY(), CU::MINUTES(), CU::DAYS()], [CF::MINUTE_OF_HOUR(), CU::MINUTES(), CU::HOURS()], [CF::SECOND_OF_DAY(), CU::SECONDS(), CU::DAYS()], [CF::SECOND_OF_MINUTE(), CU::SECONDS(), CU::MINUTES()], [CF::MILLI_OF_DAY(), CU::MILLIS(), CU::DAYS()], [CF::MILLI_OF_SECOND(), CU::MILLIS(), CU::SECONDS()], [CF::MICRO_OF_SECOND(), CU::MICROS(), CU::SECONDS()], [CF::MICRO_OF_DAY(), CU::MICROS(), CU::DAYS()], [CF::NANO_OF_SECOND(), CU::NANOS(), CU::SECONDS()], [CF::NANO_OF_DAY(), CU::NANOS(), CU::DAYS()]]; }
public static function init() { self::$NANO_OF_SECOND = new ChronoField(0, "NanoOfSecond", ChronoUnit::NANOS(), ChronoUnit::SECONDS(), ValueRange::of(0, 999999999)); self::$NANO_OF_DAY = new ChronoField(1, "NanoOfDay", ChronoUnit::NANOS(), ChronoUnit::DAYS(), ValueRange::of(0, 86400 * 1000000000 - 1)); self::$MICRO_OF_SECOND = new ChronoField(2, "MicroOfSecond", ChronoUnit::MICROS(), ChronoUnit::SECONDS(), ValueRange::of(0, 999999)); self::$MICRO_OF_DAY = new ChronoField(3, "MicroOfDay", ChronoUnit::MICROS(), ChronoUnit::DAYS(), ValueRange::of(0, 86400 * 1000000 - 1)); self::$MILLI_OF_SECOND = new ChronoField(4, "MilliOfSecond", ChronoUnit::MILLIS(), ChronoUnit::SECONDS(), ValueRange::of(0, 999)); self::$MILLI_OF_DAY = new ChronoField(5, "MilliOfDay", ChronoUnit::MILLIS(), ChronoUnit::DAYS(), ValueRange::of(0, 86400 * 1000 - 1)); self::$SECOND_OF_MINUTE = new ChronoField(6, "SecondOfMinute", ChronoUnit::SECONDS(), ChronoUnit::MINUTES(), ValueRange::of(0, 59), "second"); self::$SECOND_OF_DAY = new ChronoField(7, "SecondOfDay", ChronoUnit::SECONDS(), ChronoUnit::DAYS(), ValueRange::of(0, 86400 - 1)); self::$MINUTE_OF_HOUR = new ChronoField(8, "MinuteOfHour", ChronoUnit::MINUTES(), ChronoUnit::HOURS(), ValueRange::of(0, 59), "minute"); self::$MINUTE_OF_DAY = new ChronoField(9, "MinuteOfDay", ChronoUnit::MINUTES(), ChronoUnit::DAYS(), ValueRange::of(0, 24 * 60 - 1)); self::$HOUR_OF_AMPM = new ChronoField(10, "HourOfAmPm", ChronoUnit::HOURS(), ChronoUnit::HALF_DAYS(), ValueRange::of(0, 11)); self::$CLOCK_HOUR_OF_AMPM = new ChronoField(11, "ClockHourOfAmPm", ChronoUnit::HOURS(), ChronoUnit::HALF_DAYS(), ValueRange::of(1, 12)); self::$HOUR_OF_DAY = new ChronoField(12, "HourOfDay", ChronoUnit::HOURS(), ChronoUnit::DAYS(), ValueRange::of(0, 23), "hour"); self::$CLOCK_HOUR_OF_DAY = new ChronoField(13, "ClockHourOfDay", ChronoUnit::HOURS(), ChronoUnit::DAYS(), ValueRange::of(1, 24)); self::$AMPM_OF_DAY = new ChronoField(14, "AmPmOfDay", ChronoUnit::HALF_DAYS(), ChronoUnit::DAYS(), ValueRange::of(0, 1), "dayperiod"); self::$DAY_OF_WEEK = new ChronoField(15, "DayOfWeek", ChronoUnit::DAYS(), ChronoUnit::WEEKS(), ValueRange::of(1, 7), "weekday"); self::$ALIGNED_DAY_OF_WEEK_IN_MONTH = new ChronoField(16, "AlignedDayOfWeekInMonth", ChronoUnit::DAYS(), ChronoUnit::WEEKS(), ValueRange::of(1, 7)); self::$ALIGNED_DAY_OF_WEEK_IN_YEAR = new ChronoField(17, "AlignedDayOfWeekInYear", ChronoUnit::DAYS(), ChronoUnit::WEEKS(), ValueRange::of(1, 7)); self::$DAY_OF_MONTH = new ChronoField(18, "DayOfMonth", ChronoUnit::DAYS(), ChronoUnit::MONTHS(), ValueRange::ofVariable(1, 28, 31), "day"); self::$DAY_OF_YEAR = new ChronoField(19, "DayOfYear", ChronoUnit::DAYS(), ChronoUnit::YEARS(), ValueRange::ofVariable(1, 365, 366)); self::$EPOCH_DAY = new ChronoField(20, "EpochDay", ChronoUnit::DAYS(), ChronoUnit::FOREVER(), ValueRange::of(Year::MIN_VALUE * 365.25, Year::MAX_VALUE * 365.25)); self::$ALIGNED_WEEK_OF_MONTH = new ChronoField(21, "AlignedWeekOfMonth", ChronoUnit::WEEKS(), ChronoUnit::MONTHS(), ValueRange::ofVariable(1, 4, 5)); self::$ALIGNED_WEEK_OF_YEAR = new ChronoField(22, "AlignedWeekOfYear", ChronoUnit::WEEKS(), ChronoUnit::YEARS(), ValueRange::of(1, 53)); self::$MONTH_OF_YEAR = new ChronoField(23, "MonthOfYear", ChronoUnit::MONTHS(), ChronoUnit::YEARS(), ValueRange::of(1, 12), "month"); self::$PROLEPTIC_MONTH = new ChronoField(24, "ProlepticMonth", ChronoUnit::MONTHS(), ChronoUnit::FOREVER(), ValueRange::of(Year::MIN_VALUE * 12, Year::MAX_VALUE * 12 + 11)); self::$YEAR_OF_ERA = new ChronoField(25, "YearOfEra", ChronoUnit::YEARS(), ChronoUnit::FOREVER(), ValueRange::ofVariable(1, Year::MAX_VALUE, Year::MAX_VALUE + 1)); self::$YEAR = new ChronoField(26, "Year", ChronoUnit::YEARS(), ChronoUnit::FOREVER(), ValueRange::of(Year::MIN_VALUE, Year::MAX_VALUE), "year"); self::$ERA = new ChronoField(27, "Era", ChronoUnit::ERAS(), ChronoUnit::FOREVER(), ValueRange::of(0, 1), "era"); self::$INSTANT_SECONDS = new ChronoField(28, "InstantSeconds", ChronoUnit::SECONDS(), ChronoUnit::FOREVER(), ValueRange::of(Long::MIN_VALUE, Long::MAX_VALUE)); self::$OFFSET_SECONDS = new ChronoField(29, "OffsetSeconds", ChronoUnit::SECONDS(), ChronoUnit::FOREVER(), ValueRange::of(-18 * 3600, 18 * 3600)); }
/** * @expectedException \Celest\DateTimeException */ public function test_until_invalidTemporalUnit() { $odt1 = OffsetDateTime::of(2010, 6, 30, 1, 1, 1, 0, self::OFFSET_PONE()); $odt2 = OffsetDateTime::of(2010, 6, 30, 2, 1, 1, 0, self::OFFSET_PONE()); $odt1->until($odt2, CU::FOREVER()); }
/** * Queries this date-time using the specified query. * <p> * This queries this date-time using the specified query strategy object. * The {@code 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. * <p> * The result of this method is obtained by invoking the * {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the * specified query passing {@code this} as the argument. * * @param <R> the type of the result * @param TemporalQuery $query the query to invoke, not null * @return mixed the query result, null may be returned (defined by the query) * @throws DateTimeException if unable to query (defined by the query) * @throws ArithmeticException if numeric overflow occurs (defined by the query) */ public function query(TemporalQuery $query) { if ($query == TemporalQueries::offset() || $query == TemporalQueries::zone()) { return $this->getOffset(); } else { if ($query == TemporalQueries::zoneId()) { return null; } else { if ($query == TemporalQueries::localDate()) { return $this->toLocalDate(); } else { if ($query == TemporalQueries::localTime()) { return $this->toLocalTime(); } else { if ($query == TemporalQueries::chronology()) { return IsoChronology::INSTANCE(); } else { if ($query == TemporalQueries::precision()) { return ChronoUnit::NANOS(); } } } } } } // inline TemporalAccessor.super.query(query) as an optimization // non-JDK classes are not permitted to make this optimization return $query->queryFrom($this); }
*/ public function isTimeBased() { return $this->compareTo(self::$DAYS) < 0; } //----------------------------------------------------------------------- public function isSupportedBy(Temporal $temporal) { return $temporal->isUnitSupported($this); } public function addTo(Temporal $temporal, $amount) { return $temporal->plus($amount, $this); } //----------------------------------------------------------------------- public function between(Temporal $temporal1Inclusive, Temporal $temporal2Exclusive) { return $temporal1Inclusive->until($temporal2Exclusive, $this); } //----------------------------------------------------------------------- public function __toString() { return $this->name; } private function compareTo(ChronoUnit $other) { return $this->duration->compareTo($other->duration); } } ChronoUnit::init();