/** * @inheritdoc */ public function getLong(TemporalField $field) { if ($field instanceof ChronoField) { switch ($field) { case ChronoField::INSTANT_SECONDS(): return $this->toEpochSecond(); case ChronoField::OFFSET_SECONDS(): return $this->getOffset()->getTotalSeconds(); } return $this->toLocalDateTime()->getLong($field); } return $field->getFrom($this); }
public function setUp() { // slight abuse of FieldValues $this->fieldMap = new FieldValues(); $this->fieldMap->put(ChronoField::ERA(), "era"); $this->fieldMap->put(ChronoField::YEAR(), "year"); $this->fieldMap->put(ChronoField::MONTH_OF_YEAR(), "month"); $this->fieldMap->put(ChronoField::DAY_OF_MONTH(), "day"); $this->fieldMap->put(ChronoField::AMPM_OF_DAY(), "dayperiod"); $this->fieldMap->put(ChronoField::ALIGNED_WEEK_OF_YEAR(), "week"); $this->fieldMap->put(ChronoField::DAY_OF_WEEK(), "weekday"); $this->fieldMap->put(ChronoField::HOUR_OF_DAY(), "hour"); $this->fieldMap->put(ChronoField::MINUTE_OF_HOUR(), "minute"); $this->fieldMap->put(ChronoField::SECOND_OF_MINUTE(), "second"); $this->fieldMap->put(ChronoField::OFFSET_SECONDS(), "zone"); }
function data_withFieldLong() { return [[self::TEST_2008_6_30_11_30_59_000000500(), CF::YEAR(), 2009, OffsetDateTime::of(2009, 6, 30, 11, 30, 59, 500, self::OFFSET_PONE())], [self::TEST_2008_6_30_11_30_59_000000500(), CF::MONTH_OF_YEAR(), 7, OffsetDateTime::of(2008, 7, 30, 11, 30, 59, 500, self::OFFSET_PONE())], [self::TEST_2008_6_30_11_30_59_000000500(), CF::DAY_OF_MONTH(), 15, OffsetDateTime::of(2008, 6, 15, 11, 30, 59, 500, self::OFFSET_PONE())], [self::TEST_2008_6_30_11_30_59_000000500(), CF::HOUR_OF_DAY(), 14, OffsetDateTime::of(2008, 6, 30, 14, 30, 59, 500, self::OFFSET_PONE())], [self::TEST_2008_6_30_11_30_59_000000500(), CF::OFFSET_SECONDS(), -3600, OffsetDateTime::of(2008, 6, 30, 11, 30, 59, 500, self::OFFSET_MONE())]]; }
private static function adjust(TemporalAccessor $temporal, DateTimeFormatter $formatter) { // normal case first (early return is an optimization) $overrideChrono = $formatter->getChronology(); $overrideZone = $formatter->getZone(); if ($overrideChrono == null && $overrideZone == null) { return $temporal; } // ensure minimal change (early return is an optimization) $temporalChrono = $temporal->query(TemporalQueries::chronology()); $temporalZone = $temporal->query(TemporalQueries::zoneId()); if ($temporalChrono !== null && $temporalChrono->equals($overrideChrono)) { $overrideChrono = null; } if ($temporalZone !== null && $temporalZone->equals($overrideZone)) { $overrideZone = null; } if ($overrideChrono === null && $overrideZone === null) { return $temporal; } // make adjustment $effectiveChrono = $overrideChrono != null ? $overrideChrono : $temporalChrono; if ($overrideZone != null) { // if have zone and instant, calculation is simple, defaulting chrono if necessary if ($temporal->isSupported(ChronoField::INSTANT_SECONDS())) { $chrono = $effectiveChrono != null ? $effectiveChrono : IsoChronology::INSTANCE(); return $chrono->zonedDateTime(Instant::from($temporal), $overrideZone); } // block changing zone on OffsetTime, and similar problem cases if ($overrideZone->normalized() instanceof ZoneOffset && $temporal->isSupported(ChronoField::OFFSET_SECONDS()) && $temporal->get(ChronoField::OFFSET_SECONDS()) != $overrideZone->getRules()->getOffset(Instant::EPOCH())->getTotalSeconds()) { throw new DateTimeException("Unable to apply override zone '" . $overrideZone . "' because the temporal object being formatted has a different offset but" . " does not represent an instant: " . $temporal); } } $effectiveZone = $overrideZone !== null ? $overrideZone : $temporalZone; $effectiveDate = null; if ($overrideChrono !== null) { if ($temporal->isSupported(ChronoField::EPOCH_DAY())) { $effectiveDate = $effectiveChrono->dateFrom($temporal); } else { // check for date fields other than epoch-day, ignoring case of converting null to ISO if (!($overrideChrono == IsoChronology::INSTANCE() && $temporalChrono === null)) { foreach (ChronoField::values() as $f) { if ($f->isDateBased() && $temporal->isSupported($f)) { throw new DateTimeException("Unable to apply override chronology '" . $overrideChrono . "' because the temporal object being formatted contains date fields but" . " does not represent a whole date: " . $temporal); } } } $effectiveDate = null; } } else { $effectiveDate = null; } // combine available data // this is a non-standard temporal that is almost a pure delegate // this better handles map-like underlying temporal instances return new Test($effectiveDate, $temporal, $effectiveZone, $effectiveChrono); }
/** * Parse an offset following a prefix and set the ZoneId if it is valid. * To matching the parsing of ZoneId.of the values are not normalized * to ZoneOffsets. * * @param DateTimeParseContext $context the parse context * @param string $text the input text * @param int $prefixPos start of the prefix * @param int $position start of text after the prefix * @param OffsetIdPrinterParser $parser parser for the value after the prefix * @return int the position after the parse */ private function parseOffsetBased(DateTimeParseContext $context, $text, $prefixPos, $position, OffsetIdPrinterParser $parser) { $prefix = strtoupper(substr($text, $prefixPos, $position - $prefixPos)); if ($position >= strlen($text)) { $context->setParsedZone(ZoneId::of($prefix)); return $position; } // '0' or 'Z' after prefix is not part of a valid ZoneId; use bare prefix if ($text[$position] === '0' || $context->charEquals($text[$position], 'Z')) { $context->setParsedZone(ZoneId::of($prefix)); return $position; } $newContext = $context->copy(); $endPos = $parser->parse($newContext, $text, $position); try { if ($endPos < 0) { if ($parser == OffsetIdPrinterParser::INSTANCE_ID_Z()) { return ~$prefixPos; } $context->setParsedZone(ZoneId::of($prefix)); return $position; } $offset = $newContext->getParsed(ChronoField::OFFSET_SECONDS()); $zoneOffset = ZoneOffset::ofTotalSeconds($offset); $context->setParsedZone(ZoneId::ofOffset($prefix, $zoneOffset)); return $endPos; } catch (DateTimeException $dte) { return ~$prefixPos; } }
function data_with_longTemporalField() { return [[Instant::ofEpochSecond(10, 200), CF::INSTANT_SECONDS(), 100, Instant::ofEpochSecond(100, 200), null], [Instant::ofEpochSecond(10, 200), CF::INSTANT_SECONDS(), 0, Instant::ofEpochSecond(0, 200), null], [Instant::ofEpochSecond(10, 200), CF::INSTANT_SECONDS(), -100, Instant::ofEpochSecond(-100, 200), null], [Instant::ofEpochSecond(10, 200), CF::NANO_OF_SECOND(), 100, Instant::ofEpochSecond(10, 100), null], [Instant::ofEpochSecond(10, 200), CF::NANO_OF_SECOND(), 0, Instant::ofEpochSecond(10), null], [Instant::ofEpochSecond(10, 200), CF::MICRO_OF_SECOND(), 100, Instant::ofEpochSecond(10, 100 * 1000), null], [Instant::ofEpochSecond(10, 200), CF::MICRO_OF_SECOND(), 0, Instant::ofEpochSecond(10), null], [Instant::ofEpochSecond(10, 200), CF::MILLI_OF_SECOND(), 100, Instant::ofEpochSecond(10, 100 * 1000 * 1000), null], [Instant::ofEpochSecond(10, 200), CF::MILLI_OF_SECOND(), 0, Instant::ofEpochSecond(10), null], [Instant::ofEpochSecond(10, 200), CF::NANO_OF_SECOND(), 1000000000, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::MICRO_OF_SECOND(), 1000000, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::MILLI_OF_SECOND(), 1000, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::SECOND_OF_MINUTE(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::SECOND_OF_DAY(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::OFFSET_SECONDS(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::NANO_OF_DAY(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::MINUTE_OF_HOUR(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::MINUTE_OF_DAY(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::MILLI_OF_DAY(), 1, null, DateTimeException::class], [Instant::ofEpochSecond(10, 200), CF::MICRO_OF_DAY(), 1, null, DateTimeException::class]]; }
/** * Adjusts the specified temporal object to have the same offset, date * and time as this object. * <p> * This returns a temporal object of the same observable type as the input * with the offset, date and time changed to be the same as this. * <p> * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} * three times, passing {@link ChronoField#EPOCH_DAY}, * {@link ChronoField#NANO_OF_DAY} and {@link ChronoField#OFFSET_SECONDS} as the fields. * <p> * In most cases, it is clearer to reverse the calling pattern by using * {@link Temporal#with(TemporalAdjuster)}: * <pre> * // these two lines are equivalent, but the second approach is recommended * temporal = thisOffsetDateTime.adjustInto(temporal); * temporal = temporal.with(thisOffsetDateTime); * </pre> * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $temporal the target object to be adjusted, not null * @return Temporal the adjusted object, not null * @throws DateTimeException if unable to make the adjustment * @throws ArithmeticException if numeric overflow occurs */ public function adjustInto(Temporal $temporal) { // OffsetDateTime is treated as three separate fields, not an instant // this produces the most consistent set of results overall // the offset is set after the date and time, as it is typically a small // tweak to the result, with ZonedDateTime frequently ignoring the offset return $temporal->with(ChronoField::EPOCH_DAY(), $this->toLocalDate()->toEpochDay())->with(ChronoField::NANO_OF_DAY(), $this->toLocalTime()->toNanoOfDay())->with(ChronoField::OFFSET_SECONDS(), $this->getOffset()->getTotalSeconds()); }
public function parse(DateTimeParseContext $context, $text, $position) { $pos = $position; $end = $pos + strlen($text); $gmtText = "GMT"; // TODO: get localized version of 'GMT' if ($gmtText !== null) { if (!$context->subSequenceEquals($text, $pos, $gmtText, 0, strlen($gmtText))) { return ~$position; } $pos += strlen($gmtText); } // parse normal plus/minus offset if ($pos == $end) { return $context->setParsedField(ChronoField::OFFSET_SECONDS(), 0, $position, $pos); } $sign = $text[$pos]; // IOOBE if invalid position if ($sign == '+') { $negative = 1; } else { if ($sign == '-') { $negative = -1; } else { return $context->setParsedField(ChronoField::OFFSET_SECONDS(), 0, $position, $pos); } } $pos++; $m = 0; $s = 0; if ($this->style == TextStyle::FULL()) { $h1 = $this->getDigit($text, $pos++); $h2 = $this->getDigit($text, $pos++); if ($h1 < 0 || $h2 < 0 || $text[$pos++] !== ':') { return ~$position; } $h = $h1 * 10 + $h2; $m1 = $this->getDigit($text, $pos++); $m2 = $this->getDigit($text, $pos++); if ($m1 < 0 || $m2 < 0) { return ~$position; } $m = $m1 * 10 + $m2; if ($pos + 2 < $end && $text[$pos] === ':') { $s1 = $this->getDigit($text, $pos + 1); $s2 = $this->getDigit($text, $pos + 2); if ($s1 >= 0 && $s2 >= 0) { $s = $s1 * 10 + $s2; $pos += 3; } } } else { $h = $this->getDigit($text, $pos++); if ($h < 0) { return ~$position; } if ($pos < $end) { $h2 = $this->getDigit($text, $pos); if ($h2 >= 0) { $h = $h * 10 + $h2; $pos++; } if ($pos + 2 < $end && $text[$pos] === ':') { if ($pos + 2 < $end && $text[$pos] === ':') { $m1 = $this->getDigit($text, $pos + 1); $m2 = $this->getDigit($text, $pos + 2); if ($m1 >= 0 && $m2 >= 0) { $m = $m1 * 10 + $m2; $pos += 3; if ($pos + 2 < $end && $text[$pos] === ':') { $s1 = $this->getDigit($text, $pos + 1); $s2 = $this->getDigit($text, $pos + 2); if ($s1 >= 0 && $s2 >= 0) { $s = $s1 * 10 + $s2; $pos += 3; } } } } } } } $offsetSecs = $negative * ($h * 3600 + $m * 60 + $s); return $context->setParsedField(ChronoField::OFFSET_SECONDS(), $offsetSecs, $position, $pos); }
/** * A query for {@code ZoneOffset} returning null if not found. * @param TemporalAccessor $temporal * @return null|ZoneOffset * @throws DateTimeException */ public static function _offset(TemporalAccessor $temporal) { if ($temporal->isSupported(ChronoField::OFFSET_SECONDS())) { return ZoneOffset::ofTotalSeconds($temporal->get(ChronoField::OFFSET_SECONDS())); } return null; }
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)); }
public function test_isSupported_TemporalField() { // TODO check //$this->assertEquals(TEST_2008.isSupported((TemporalField) null()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::NANO_OF_SECOND()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::NANO_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MICRO_OF_SECOND()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MICRO_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MILLI_OF_SECOND()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MILLI_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::SECOND_OF_MINUTE()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::SECOND_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MINUTE_OF_HOUR()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MINUTE_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::HOUR_OF_AMPM()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::CLOCK_HOUR_OF_AMPM()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::HOUR_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::CLOCK_HOUR_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::AMPM_OF_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::DAY_OF_WEEK()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::ALIGNED_DAY_OF_WEEK_IN_MONTH()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::ALIGNED_DAY_OF_WEEK_IN_YEAR()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::DAY_OF_MONTH()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::DAY_OF_YEAR()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::EPOCH_DAY()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::ALIGNED_WEEK_OF_MONTH()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::ALIGNED_WEEK_OF_YEAR()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::MONTH_OF_YEAR()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::PROLEPTIC_MONTH()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::YEAR()), true); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::YEAR_OF_ERA()), true); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::ERA()), true); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::INSTANT_SECONDS()), false); $this->assertEquals(self::$TEST_2008->isSupported(ChronoField::OFFSET_SECONDS()), false); }
/** * Returns a copy of this date-time with the specified field set to a new value. * <p> * This returns a {@code ZonedDateTime}, 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-time 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. * <p> * The {@code INSTANT_SECONDS} field will return a date-time with the specified instant. * The zone and nano-of-second are unchanged. * The result will have an offset derived from the new instant and original zone. * If the new instant value is outside the valid range then a {@code DateTimeException} will be thrown. * <p> * The {@code OFFSET_SECONDS} field will typically be ignored. * The offset of a {@code ZonedDateTime} is controlled primarily by the time-zone. * As such, changing the offset does not generally make sense, because there is only * one valid offset for the local date-time and zone. * If the zoned date-time is in a daylight savings overlap, then the offset is used * to switch between the two valid offsets. In all other cases, the offset is ignored. * If the new offset value is outside the valid range then a {@code DateTimeException} will be thrown. * <p> * The other {@link #isSupported(TemporalField) supported fields} will behave as per * the matching method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime}. * The zone is not part of the calculation and will be unchanged. * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, * then the offset will be retained if possible, otherwise the earlier offset will be used. * If in a gap, the local date-time will be adjusted forward by the length of the gap. * <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 ZonedDateTime a {@code ZonedDateTime} 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) { $f = $field; switch ($f) { case ChronoField::INSTANT_SECONDS(): return self::create($newValue, $this->getNano(), $this->zone); case ChronoField::OFFSET_SECONDS(): $offset = ZoneOffset::ofTotalSeconds($f->checkValidIntValue($newValue)); return $this->resolveOffset($offset); } return $this->resolveLocal($this->dateTime->with($field, $newValue)); } return $field->adjustInto($this, $newValue); }
public function setOffset($offsetId) { if ($offsetId !== null) { $this->fields->put(ChronoField::OFFSET_SECONDS(), ZoneOffset::of($offsetId)->getTotalSeconds()); } }
public function test_with_TemporalField() { $test = OffsetTime::of(12, 30, 40, 987654321, self::OFFSET_PONE()); $this->assertEquals($test->with(CF::HOUR_OF_DAY(), 15), OffsetTime::of(15, 30, 40, 987654321, self::OFFSET_PONE())); $this->assertEquals($test->with(CF::MINUTE_OF_HOUR(), 50), OffsetTime::of(12, 50, 40, 987654321, self::OFFSET_PONE())); $this->assertEquals($test->with(CF::SECOND_OF_MINUTE(), 50), OffsetTime::of(12, 30, 50, 987654321, self::OFFSET_PONE())); $this->assertEquals($test->with(CF::NANO_OF_SECOND(), 12345), OffsetTime::of(12, 30, 40, 12345, self::OFFSET_PONE())); $this->assertEquals($test->with(CF::HOUR_OF_AMPM(), 6), OffsetTime::of(18, 30, 40, 987654321, self::OFFSET_PONE())); $this->assertEquals($test->with(CF::AMPM_OF_DAY(), 0), OffsetTime::of(0, 30, 40, 987654321, self::OFFSET_PONE())); $this->assertEquals($test->with(CF::OFFSET_SECONDS(), 7205), OffsetTime::of(12, 30, 40, 987654321, ZoneOffset::ofHoursMinutesSeconds(2, 0, 5))); }
/** * Adjusts the specified temporal object to have the same offset and time * as this object. * <p> * This returns a temporal object of the same observable type as the input * with the offset and time changed to be the same as this. * <p> * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} * twice, passing {@link ChronoField#NANO_OF_DAY} and * {@link ChronoField#OFFSET_SECONDS} as the fields. * <p> * In most cases, it is clearer to reverse the calling pattern by using * {@link Temporal#with(TemporalAdjuster)}: * <pre> * // these two lines are equivalent, but the second approach is recommended * temporal = thisOffsetTime.adjustInto(temporal); * temporal = temporal.with(thisOffsetTime); * </pre> * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $temporal the target object to be adjusted, not null * @return Temporal the adjusted object, not null * @throws DateTimeException if unable to make the adjustment * @throws ArithmeticException if numeric overflow occurs */ public function adjustInto(Temporal $temporal) { return $temporal->with(ChronoField::NANO_OF_DAY(), $this->time->toNanoOfDay())->with(ChronoField::OFFSET_SECONDS(), $this->offset->getTotalSeconds()); }
private static function INSTANTSECONDS_OFFSETSECONDS() { return (new DateTimeFormatterBuilder())->appendValue(CF::INSTANT_SECONDS())->appendLiteral(' ')->appendValue(CF::OFFSET_SECONDS())->toFormatter(); }
public function test_isSupported_TemporalField() { //$this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(null), false); TODO $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::NANO_OF_SECOND()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::NANO_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MICRO_OF_SECOND()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MICRO_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MILLI_OF_SECOND()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MILLI_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::SECOND_OF_MINUTE()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::SECOND_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MINUTE_OF_HOUR()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MINUTE_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::HOUR_OF_AMPM()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::CLOCK_HOUR_OF_AMPM()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::HOUR_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::CLOCK_HOUR_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::AMPM_OF_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::DAY_OF_WEEK()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::ALIGNED_DAY_OF_WEEK_IN_MONTH()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::ALIGNED_DAY_OF_WEEK_IN_YEAR()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::DAY_OF_MONTH()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::DAY_OF_YEAR()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::EPOCH_DAY()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::ALIGNED_WEEK_OF_MONTH()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::ALIGNED_WEEK_OF_YEAR()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::MONTH_OF_YEAR()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::PROLEPTIC_MONTH()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::YEAR()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::YEAR_OF_ERA()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::ERA()), true); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::INSTANT_SECONDS()), false); $this->assertEquals(self::TEST_200707_15_12_30_40_987654321()->isSupported(CF::OFFSET_SECONDS()), false); }
private function resolveInstant() { // add instant seconds if we have date, time and zone if ($this->date !== null && $this->time !== null) { if ($this->zone !== null) { $instant = $this->date->atTime($this->time)->atZone($this->zone)->getLong(CF::INSTANT_SECONDS()); $this->fieldValues->put(CF::INSTANT_SECONDS(), $instant); } else { $offsetSecs = $this->fieldValues->get(CF::OFFSET_SECONDS()); if ($offsetSecs !== null) { $offset = ZoneOffset::ofTotalSeconds($offsetSecs); $instant = $this->date->atTime($this->time)->atZone($offset)->getLong(CF::INSTANT_SECONDS()); $this->fieldValues->put(CF::INSTANT_SECONDS(), $instant); } } } }
/** * @dataProvider data_withFieldLong */ public function test_with_adjuster_ensureOffsetDateTimeConsistent(ZonedDateTime $base, TemporalField $setField, $setValue, ZonedDateTime $expected) { if ($setField == CF::OFFSET_SECONDS()) { $odt = $base->toOffsetDateTime()->with($setField, $setValue); $this->assertEquals($base->adjust($odt), $expected); } }
/** * Adjusts the specified temporal object to have the same offset as this object. * <p> * This returns a temporal object of the same observable type as the input * with the offset changed to be the same as this. * <p> * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} * passing {@link ChronoField#OFFSET_SECONDS} as the field. * <p> * In most cases, it is clearer to reverse the calling pattern by using * {@link Temporal#with(TemporalAdjuster)}: * <pre> * // these two lines are equivalent, but the second approach is recommended * temporal = thisOffset.adjustInto(temporal); * temporal = temporal.with(thisOffset); * </pre> * <p> * This instance is immutable and unaffected by this method call. * * @param Temporal $temporal the target object to be adjusted, not null * @return Temporal the adjusted object, not null * @throws DateTimeException if unable to make the adjustment * @throws ArithmeticException if numeric overflow occurs */ public function adjustInto(Temporal $temporal) { return $temporal->with(ChronoField::OFFSET_SECONDS(), $this->totalSeconds); }
private function assertParsed(TemporalAccessor $parsed, ZoneOffset $expectedOffset) { if ($expectedOffset === null) { $this->assertEquals(null, $parsed); } else { $this->assertEquals(true, $parsed->isSupported(ChronoField::OFFSET_SECONDS()), true); $this->assertEquals($expectedOffset->getTotalSeconds(), $parsed->getLong(ChronoField::OFFSET_SECONDS())); } }
public function test_isSupported_TemporalField() { //$this->assertEquals(DayOfWeek::THURSDAY()->isSupported(null), false); TODO $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::NANO_OF_SECOND()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::NANO_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MICRO_OF_SECOND()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MICRO_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MILLI_OF_SECOND()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MILLI_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::SECOND_OF_MINUTE()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::SECOND_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MINUTE_OF_HOUR()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MINUTE_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::HOUR_OF_AMPM()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::CLOCK_HOUR_OF_AMPM()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::HOUR_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::CLOCK_HOUR_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::AMPM_OF_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::DAY_OF_WEEK()), true); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::ALIGNED_DAY_OF_WEEK_IN_MONTH()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::ALIGNED_DAY_OF_WEEK_IN_YEAR()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::DAY_OF_MONTH()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::DAY_OF_YEAR()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::EPOCH_DAY()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::ALIGNED_WEEK_OF_MONTH()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::ALIGNED_WEEK_OF_YEAR()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::MONTH_OF_YEAR()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::PROLEPTIC_MONTH()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::YEAR()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::YEAR_OF_ERA()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::ERA()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::INSTANT_SECONDS()), false); $this->assertEquals(DayOfWeek::THURSDAY()->isSupported(ChronoField::OFFSET_SECONDS()), false); }
public function test_getLong_TemporalField() { $this->assertEquals(ZoneOffset::UTC()->getLong(ChronoField::OFFSET_SECONDS()), 0); $this->assertEquals(ZoneOffset::ofHours(-2)->getLong(ChronoField::OFFSET_SECONDS()), -7200); $this->assertEquals(ZoneOffset::ofHoursMinutesSeconds(0, 1, 5)->getLong(ChronoField::OFFSET_SECONDS()), 65); }
public function parse(DateTimeParseContext $context, $text, $position) { $length = strlen($text); $noOffsetLen = strlen($this->noOffsetText); if ($noOffsetLen === 0) { if ($position === $length) { return $context->setParsedField(ChronoField::OFFSET_SECONDS(), 0, $position, $position); } } else { if ($position === $length) { return ~$position; } if ($context->subSequenceEquals($text, $position, $this->noOffsetText, 0, $noOffsetLen)) { return $context->setParsedField(ChronoField::OFFSET_SECONDS(), 0, $position, $position + $noOffsetLen); } } // parse normal plus/minus offset $sign = $text[$position]; // IOOBE if invalid position if ($sign === '+' || $sign === '-') { // starts $negative = $sign === '-' ? -1 : 1; $array = [0, 0, 0, 0]; $array[0] = $position + 1; if (($this->parseNumber($array, 1, $text, true) || $this->parseNumber($array, 2, $text, $this->type >= 3) || $this->parseNumber($array, 3, $text, false)) === false) { // success $offsetSecs = $negative * ($array[1] * 3600 + $array[2] * 60 + $array[3]); return $context->setParsedField(ChronoField::OFFSET_SECONDS(), $offsetSecs, $position, $array[0]); } } // handle special case of empty no offset text if ($noOffsetLen === 0) { return $context->setParsedField(ChronoField::OFFSET_SECONDS(), 0, $position, $position + $noOffsetLen); } return ~$position; }