/**
  * Obtains a local date in the Thai Buddhist calendar system from the epoch-day.
  *
  * @param int $epochDay the epoch day
  * @return ThaiBuddhistDate the Thai Buddhist local date, not null
  * @throws DateTimeException if unable to create the date
  */
 public function dateEpochDay($epochDay)
 {
     return ThaiBuddhistDate::ofIsoDate(LocalDate::ofEpochDay($epochDay));
 }
 /**
  * A query for {@code LocalDate} returning null if not found.
  * @param TemporalAccessor $temporal
  * @return null|LocalDate
  */
 public static function _localDate(TemporalAccessor $temporal)
 {
     if ($temporal->isSupported(ChronoField::EPOCH_DAY())) {
         return LocalDate::ofEpochDay($temporal->getLong(ChronoField::EPOCH_DAY()));
     }
     return null;
 }
Beispiel #3
0
 /**
  * Returns a copy of this date with the specified field set to a new value.
  * <p>
  * This returns a {@code LocalDate}, based on this one, with the value
  * for the specified field changed.
  * This can be used to change any supported field, such as the year, month or day-of-month.
  * If it is not possible to set the value, because the field is not supported or for
  * some other reason, an exception is thrown.
  * <p>
  * In some cases, changing the specified field can cause the resulting date to become invalid,
  * such as changing the month from 31st January to February would make the day-of-month invalid.
  * In cases like this, the field is responsible for resolving the date. Typically it will choose
  * the previous valid date, which would be the last valid day of February in this example.
  * <p>
  * If the field is a {@link ChronoField} then the adjustment is implemented here.
  * The supported fields behave as follows:
  * <ul>
  * <li>{@code DAY_OF_WEEK} -
  *  Returns a {@code LocalDate} with the specified day-of-week.
  *  The date is adjusted up to 6 days forward or backward within the boundary
  *  of a Monday to Sunday week.
  * <li>{@code ALIGNED_DAY_OF_WEEK_IN_MONTH} -
  *  Returns a {@code LocalDate} with the specified aligned-day-of-week.
  *  The date is adjusted to the specified month-based aligned-day-of-week.
  *  Aligned weeks are counted such that the first week of a given month starts
  *  on the first day of that month.
  *  This may cause the date to be moved up to 6 days into the following month.
  * <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR} -
  *  Returns a {@code LocalDate} with the specified aligned-day-of-week.
  *  The date is adjusted to the specified year-based aligned-day-of-week.
  *  Aligned weeks are counted such that the first week of a given year starts
  *  on the first day of that year.
  *  This may cause the date to be moved up to 6 days into the following year.
  * <li>{@code DAY_OF_MONTH} -
  *  Returns a {@code LocalDate} with the specified day-of-month.
  *  The month and year will be unchanged. If the day-of-month is invalid for the
  *  year and month, then a {@code DateTimeException} is thrown.
  * <li>{@code DAY_OF_YEAR} -
  *  Returns a {@code LocalDate} with the specified day-of-year.
  *  The year will be unchanged. If the day-of-year is invalid for the
  *  year, then a {@code DateTimeException} is thrown.
  * <li>{@code EPOCH_DAY} -
  *  Returns a {@code LocalDate} with the specified epoch-day.
  *  This completely replaces the date and is equivalent to {@link #ofEpochDay(long)}.
  * <li>{@code ALIGNED_WEEK_OF_MONTH} -
  *  Returns a {@code LocalDate} with the specified aligned-week-of-month.
  *  Aligned weeks are counted such that the first week of a given month starts
  *  on the first day of that month.
  *  This adjustment moves the date in whole week chunks to match the specified week.
  *  The result will have the same day-of-week as this date.
  *  This may cause the date to be moved into the following month.
  * <li>{@code ALIGNED_WEEK_OF_YEAR} -
  *  Returns a {@code LocalDate} with the specified aligned-week-of-year.
  *  Aligned weeks are counted such that the first week of a given year starts
  *  on the first day of that year.
  *  This adjustment moves the date in whole week chunks to match the specified week.
  *  The result will have the same day-of-week as this date.
  *  This may cause the date to be moved into the following year.
  * <li>{@code MONTH_OF_YEAR} -
  *  Returns a {@code LocalDate} with the specified month-of-year.
  *  The year will be unchanged. The day-of-month will also be unchanged,
  *  unless it would be invalid for the new month and year. In that case, the
  *  day-of-month is adjusted to the maximum valid value for the new month and year.
  * <li>{@code PROLEPTIC_MONTH} -
  *  Returns a {@code LocalDate} with the specified proleptic-month.
  *  The day-of-month will be unchanged, unless it would be invalid for the new month
  *  and year. In that case, the day-of-month is adjusted to the maximum valid value
  *  for the new month and year.
  * <li>{@code YEAR_OF_ERA} -
  *  Returns a {@code LocalDate} with the specified year-of-era.
  *  The era and month will be unchanged. The day-of-month will also be unchanged,
  *  unless it would be invalid for the new month and year. In that case, the
  *  day-of-month is adjusted to the maximum valid value for the new month and year.
  * <li>{@code YEAR} -
  *  Returns a {@code LocalDate} with the specified year.
  *  The month will be unchanged. The day-of-month will also be unchanged,
  *  unless it would be invalid for the new month and year. In that case, the
  *  day-of-month is adjusted to the maximum valid value for the new month and year.
  * <li>{@code ERA} -
  *  Returns a {@code LocalDate} with the specified era.
  *  The year-of-era and month will be unchanged. The day-of-month will also be unchanged,
  *  unless it would be invalid for the new month and year. In that case, the
  *  day-of-month is adjusted to the maximum valid value for the new month and year.
  * </ul>
  * <p>
  * In all cases, if the new value is outside the valid range of values for the field
  * then a {@code DateTimeException} will be thrown.
  * <p>
  * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
  * <p>
  * If the field is not a {@code ChronoField}, then the result of this method
  * is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}
  * passing {@code this} as the argument. In this case, the field determines
  * whether and how to adjust the instant.
  * <p>
  * This instance is immutable and unaffected by this method call.
  *
  * @param TemporalField $field the field to set in the result, not null
  * @param int $newValue the new value of the field in the result
  * @return LocalDate a {@code LocalDate} based on {@code this} with the specified field set, not null
  * @throws DateTimeException if the field cannot be set
  * @throws UnsupportedTemporalTypeException if the field is not supported
  * @throws ArithmeticException if numeric overflow occurs
  */
 public function with(TemporalField $field, $newValue)
 {
     if ($field instanceof ChronoField) {
         /** @var Chronofield $f */
         $f = $field;
         $f->checkValidValue($newValue);
         switch ($f) {
             case ChronoField::DAY_OF_WEEK():
                 return $this->plusDays($newValue - $this->getDayOfWeek()->getValue());
             case ChronoField::ALIGNED_DAY_OF_WEEK_IN_MONTH():
                 return $this->plusDays($newValue - $this->getLong(ChronoField::ALIGNED_DAY_OF_WEEK_IN_MONTH()));
             case ChronoField::ALIGNED_DAY_OF_WEEK_IN_YEAR():
                 return $this->plusDays($newValue - $this->getLong(ChronoField::ALIGNED_DAY_OF_WEEK_IN_YEAR()));
             case ChronoField::DAY_OF_MONTH():
                 return $this->withDayOfMonth((int) $newValue);
             case ChronoField::DAY_OF_YEAR():
                 return $this->withDayOfYear((int) $newValue);
             case ChronoField::EPOCH_DAY():
                 return LocalDate::ofEpochDay($newValue);
             case ChronoField::ALIGNED_WEEK_OF_MONTH():
                 return $this->plusWeeks($newValue - $this->getLong(ChronoField::ALIGNED_WEEK_OF_MONTH()));
             case ChronoField::ALIGNED_WEEK_OF_YEAR():
                 return $this->plusWeeks($newValue - $this->getLong(ChronoField::ALIGNED_WEEK_OF_YEAR()));
             case ChronoField::MONTH_OF_YEAR():
                 return $this->withMonth((int) $newValue);
             case ChronoField::PROLEPTIC_MONTH():
                 return $this->plusMonths($newValue - $this->getProlepticMonth());
             case ChronoField::YEAR_OF_ERA():
                 return $this->withYear((int) ($this->year >= 1 ? $newValue : 1 - $newValue));
             case ChronoField::YEAR():
                 return $this->withYear((int) $newValue);
             case ChronoField::ERA():
                 return $this->getLong(ChronoField::ERA()) == $newValue ? $this : $this->withYear(1 - $this->year);
         }
         throw new UnsupportedTemporalTypeException("Unsupported field: " . $field);
     }
     return $field->adjustInto($this, $newValue);
 }
 /**
  * Obtains an ISO local date from the epoch-day.
  * <p>
  * This is equivalent to {@link LocalDate#ofEpochDay(long)}.
  *
  * @param int $epochDay the epoch day
  * @return LocalDate the ISO local date, not null
  * @throws DateTimeException if unable to create the date
  */
 public function dateEpochDay($epochDay)
 {
     return LocalDate::ofEpochDay($epochDay);
 }
 /**
  * @expectedException \Celest\DateTimeException
  */
 public function test_factory_ofEpochDay_belowMin()
 {
     LocalDate::ofEpochDay(self::MIN_VALID_EPOCHDAYS() - 1);
 }
 /**
  * Obtains a local date in the Minguo calendar system from the epoch-day.
  *
  * @param int $epochDay the epoch day
  * @return MinguoDate the Minguo local date, not null
  * @throws DateTimeException if unable to create the date
  */
 public function dateEpochDay($epochDay)
 {
     return MinguoDate::ofIsoDate(LocalDate::ofEpochDay($epochDay));
 }
Beispiel #7
0
 private function findYear($epochSecond, ZoneOffset $offset)
 {
     // inline for performance
     $localSecond = $epochSecond + $offset->getTotalSeconds();
     $localEpochDay = Math::floorDiv($localSecond, 86400);
     return LocalDate::ofEpochDay($localEpochDay)->getYear();
 }
 /**
  * Obtains an instance of {@code LocalDateTime} using seconds from the
  * epoch of 1970-01-01T00:00:00Z.
  * <p>
  * This allows the {@link ChronoField#INSTANT_SECONDS epoch-second} field
  * to be converted to a local date-time. This is primarily intended for
  * low-level conversions rather than general application usage.
  *
  * @param int $epochSecond the number of seconds from the epoch of 1970-01-01T00:00:00Z
  * @param int $nanoOfSecond the nanosecond within the second, from 0 to 999,999,999
  * @param ZoneOffset $offset the zone offset, not null
  * @return LocalDateTime the local date-time, not null
  * @throws DateTimeException if the result exceeds the supported range,
  *  or if the nano-of-second is invalid
  */
 public static function ofEpochSecond($epochSecond, $nanoOfSecond, ZoneOffset $offset)
 {
     try {
         ChronoField::NANO_OF_SECOND()->checkValidValue($nanoOfSecond);
         $localSecond = Math::addExact($epochSecond, $offset->getTotalSeconds());
         $localEpochDay = Math::floorDiv($localSecond, LocalTime::SECONDS_PER_DAY);
         $secsOfDay = Math::floorMod($localSecond, LocalTime::SECONDS_PER_DAY);
         $date = LocalDate::ofEpochDay($localEpochDay);
         $time = LocalTime::ofNanoOfDay($secsOfDay * LocalTime::NANOS_PER_SECOND + $nanoOfSecond);
         return new LocalDateTime($date, $time);
     } catch (ArithmeticException $ex) {
         throw new DateTimeException("Value out of bounds", $ex);
     }
 }