/** * @return LocalDate */ private function toLocalDate() { if ($this->dayOfMonthIndicator < 0) { $monthLen = $this->month->length(IsoChronology::INSTANCE()->isLeapYear($this->year)); $date = LocalDate::ofMonth($this->year, $this->month, $monthLen + 1 + $this->dayOfMonthIndicator); if ($this->dayOfWeek !== null) { $date = $date->adjust(TemporalAdjusters::previousOrSame($this->dayOfWeek)); } } else { $date = LocalDate::ofMonth($this->year, $this->month, $this->dayOfMonthIndicator); if ($this->dayOfWeek != null) { $date = $date->adjust(TemporalAdjusters::nextOrSame($this->dayOfWeek)); } } if ($this->timeEndOfDay) { $date = $date->plusDays(1); } return $date; }
public function test_with_Month_noChange_equal() { $test = YearMonth::of(2008, 6); $this->assertEquals($test->adjust(Month::JUNE()), $test); }
function resolveYMD(FieldValues $fieldValues, ResolverStyle $resolverStyle) { $y = CF::YEAR()->checkValidIntValue($fieldValues->remove(CF::YEAR())); if ($resolverStyle == ResolverStyle::LENIENT()) { $months = Math::subtractExact($fieldValues->remove(CF::MONTH_OF_YEAR()), 1); $days = Math::subtractExact($fieldValues->remove(CF::DAY_OF_MONTH()), 1); return LocalDate::of($y, 1, 1)->plusMonths($months)->plusDays($days); } $moy = CF::MONTH_OF_YEAR()->checkValidIntValue($fieldValues->remove(CF::MONTH_OF_YEAR())); $dom = CF::DAY_OF_MONTH()->checkValidIntValue($fieldValues->remove(CF::DAY_OF_MONTH())); if ($resolverStyle == ResolverStyle::SMART()) { // previous valid if ($moy == 4 || $moy == 6 || $moy == 9 || $moy == 11) { $dom = Math::min($dom, 30); } else { if ($moy == 2) { $dom = Math::min($dom, Month::FEBRUARY()->length(Year::isLeapYear($y))); } } } return LocalDate::of($y, $moy, $dom); }
public function __construct() { $this->month = Month::JANUARY(); $this->time = LocalTime::MIDNIGHT(); $this->timeDefinition = TimeDefinition::WALL(); }
public function test_with_adjustment_Month() { $test = self::TEST_2008_6_30_11_30_59_000000500()->adjust(Month::DECEMBER()); $this->assertEquals($test, OffsetDateTime::ofDateAndTime(LocalDate::of(2008, 12, 30), LocalTime::of(11, 30, 59, 500), self::OFFSET_PONE())); }
public function test_getDayOfWeek() { $dow = DayOfWeek::MONDAY(); foreach (Month::values() as $month) { $length = $month->length(false); for ($i = 1; $i <= $length; $i++) { $d = LocalDate::ofMonth(2007, $month, $i); $this->assertSame($d->getDayOfWeek(), $dow); $dow = $dow->plus(1); } } }
public function test_enum() { $this->assertEquals(Month::valueOf("JANUARY"), Month::JANUARY()); $this->assertEquals(Month::values()[0], Month::JANUARY()); }
/** * Gets the month-of-year field using the {@code Month} enum. * <p> * This method returns the enum {@link Month} for the month. * This avoids confusion as to what {@code int} values mean. * If you need access to the primitive {@code int} value then the enum * provides the {@link Month#getValue() int value}. * * @return Month the month-of-year, not null * @see #getMonthValue() */ public function getMonth() { return Month::of($this->month); }
/** * Creates a transition instance for the specified year. * <p> * Calculations are performed using the ISO-8601 chronology. * * @param int $year the year to create a transition for, not null * @return ZoneOffsetTransition the transition instance, not null */ public function createTransition($year) { if ($this->dom < 0) { $date = LocalDate::ofMonth($year, $this->month, $this->month->length(IsoChronology::INSTANCE()->isLeapYear($year)) + 1 + $this->dom); if ($this->dow !== null) { $date = $date->adjust(TemporalAdjusters::previousOrSame($this->dow)); } } else { $date = LocalDate::ofMonth($year, $this->month, $this->dom); if ($this->dow !== null) { $date = $date->adjust(TemporalAdjusters::nextOrSame($this->dow)); } } if ($this->timeEndOfDay) { $date = $date->plusDays(1); } $localDT = LocalDateTime::ofDateAndTime($date, $this->time); $transition = $this->timeDefinition->createDateTime($localDT, $this->standardOffset, $this->offsetBefore); return ZoneOffsetTransition::of($transition, $this->offsetBefore, $this->offsetAfter); }
public function test_toString_fixedDate() { $test = ZoneOffsetTransitionRule::of(Month::MARCH(), 20, null, self::TIME_0100(), false, TimeDefinition::STANDARD(), self::OFFSET_0200(), self::OFFSET_0200(), self::OFFSET_0300()); $this->assertEquals($test->__toString(), "TransitionRule[Gap +02:00 to +03:00, MARCH 20 at 01:00 STANDARD, standard offset +02:00]"); }
private function parseMonth(\CachingIterator $s) { $s->next(); $month = $s->current(); if ($m = preg_match(self::$MONTH, $month, $mr)) { for ($moy = 1; $moy < 13 && $moy < count($mr); $moy++) { if ($mr[$moy] !== '') { return Month::of($moy); } } } throw new IllegalArgumentException("Unknown month: " . $month); }
/** * Returns a copy of this {@code MonthDay} with the month-of-year altered. * <p> * This returns a month-day with the specified month. * If the day-of-month is invalid for the specified month, the day will * be adjusted to the last valid day-of-month. * <p> * This instance is immutable and unaffected by this method call. * * @param Month $month the month-of-year to set in the returned month-day, not null * @return MonthDay a {@code MonthDay} based on this month-day with the requested month, not null */ public function with(Month $month) { if ($month->getValue() == $this->month) { return $this; } $day = Math::min($this->day, $month->maxLength()); return new MonthDay($month->getValue(), $day); }
* </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) { if (AbstractChronology::from($temporal)->equals(IsoChronology::INSTANCE()) == false) { throw new DateTimeException("Adjustment only supported on ISO date-time"); } return $temporal->with(ChronoField::MONTH_OF_YEAR(), $this->getValue()); } public function __toString() { return $this->name; } public function compareTo(Month $other) { return $this->val - $other->val; } public function name() { return $this->__toString(); } } Month::init();
public function test_atMonth() { $test = Year::of(2008); $this->assertEquals($test->atMonth(Month::JUNE()), YearMonth::of(2008, 6)); }
public function test_pattern_String() { $test = DateTimeFormatter::ofPattern("d MMM yyyy"); $fmtLocale = Locale::getDefault(); $this->assertEquals($test->format(LocalDate::of(2012, 6, 30)), "30 " . Month::JUNE()->getDisplayName(TextStyle::SHORT(), $fmtLocale) . " 2012"); $this->assertEquals($test->getLocale(), $fmtLocale, "Locale.Category.FORMAT"); }
function data_adjustInto() { return [[LocalDateTime::of(2012, 3, 4, 23, 5), LocalDateTime::of(2012, 3, 4, 1, 1, 1, 100), LocalDateTime::of(2012, 3, 4, 23, 5, 0, 0), null], [LocalDateTime::ofMonth(2012, Month::MARCH(), 4, 0, 0), LocalDateTime::of(2012, 3, 4, 1, 1, 1, 100), LocalDateTime::of(2012, 3, 4, 0, 0), null], [LocalDateTime::of(2012, 3, 4, 23, 5), LocalDateTime::MAX(), LocalDateTime::of(2012, 3, 4, 23, 5), null], [LocalDateTime::of(2012, 3, 4, 23, 5), LocalDateTime::MIN(), LocalDateTime::of(2012, 3, 4, 23, 5), null], [LocalDateTime::MAX(), LocalDateTime::of(2012, 3, 4, 23, 5), LocalDateTime::MAX(), null], [LocalDateTime::MIN(), LocalDateTime::of(2012, 3, 4, 23, 5), LocalDateTime::MIN(), null], [LocalDateTime::of(2012, 3, 4, 23, 5), OffsetDateTime::of(2210, 2, 2, 0, 0, 0, 0, ZoneOffset::UTC()), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, ZoneOffset::UTC()), null], [LocalDateTime::of(2012, 3, 4, 23, 5), OffsetDateTime::of(2210, 2, 2, 0, 0, 0, 0, self::OFFSET_PONE()), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), null], [LocalDateTime::of(2012, 3, 4, 23, 5), ZonedDateTime::of(2210, 2, 2, 0, 0, 0, 0, self::ZONE_PARIS()), ZonedDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::ZONE_PARIS()), null], [LocalDateTime::of(2012, 3, 4, 23, 5), LocalDate::of(2210, 2, 2), null, DateTimeException::class], [LocalDateTime::of(2012, 3, 4, 23, 5), LocalTime::of(22, 3, 0), null, DateTimeException::class], [LocalDateTime::of(2012, 3, 4, 23, 5), OffsetTime::of(22, 3, 0, 0, ZoneOffset::UTC()), null, DateTimeException::class]]; }
public function test_withMonth_Month_normal() { $base = ZonedDateTime::ofDateTime(self::TEST_LOCAL_2008_06_30_11_30_59_500(), self::ZONE_0100()); $test = $base->adjust(Month::JANUARY()); $this->assertEquals($test, ZonedDateTime::ofDateTime(self::TEST_LOCAL_2008_06_30_11_30_59_500()->withMonth(1), self::ZONE_0100())); }
public function test_with_Month_noChangeEqual() { $test = MonthDay::of(6, 30); $this->assertEquals($test->with(Month::JUNE()), $test); }
public function test_of() { //used for standard offset $stdOffset1 = ZoneOffset::UTC(); $stdOffset2 = ZoneOffset::ofHours(1); $time_of_stdOffsetTransition1 = LocalDateTime::of(2013, 1, 5, 1, 0); $stdOffsetTransition1 = ZoneOffsetTransition::of($time_of_stdOffsetTransition1, $stdOffset1, $stdOffset2); $stdOffsetTransition_list = []; $stdOffsetTransition_list[] = $stdOffsetTransition1; //used for wall offset $wallOffset1 = ZoneOffset::ofHours(2); $wallOffset2 = ZoneOffset::ofHours(4); $wallOffset3 = ZoneOffset::ofHours(7); $time_of_wallOffsetTransition1 = LocalDateTime::of(2013, 2, 5, 1, 0); $time_of_wallOffsetTransition2 = LocalDateTime::of(2013, 3, 5, 1, 0); $time_of_wallOffsetTransition3 = LocalDateTime::of(2013, 10, 5, 1, 0); $wallOffsetTransition1 = ZoneOffsetTransition::of($time_of_wallOffsetTransition1, $wallOffset1, $wallOffset2); $wallOffsetTransition2 = ZoneOffsetTransition::of($time_of_wallOffsetTransition2, $wallOffset2, $wallOffset3); $wallOffsetTransition3 = ZoneOffsetTransition::of($time_of_wallOffsetTransition3, $wallOffset3, $wallOffset1); $wallOffsetTransition_list = []; $wallOffsetTransition_list[] = $wallOffsetTransition1; $wallOffsetTransition_list[] = $wallOffsetTransition2; $wallOffsetTransition_list[] = $wallOffsetTransition3; //used for ZoneOffsetTransitionRule $ruleOffset = ZoneOffset::ofHours(3); $timeDefinition = TimeDefinition::WALL(); $rule1 = ZoneOffsetTransitionRule::of(Month::FEBRUARY(), 2, DayOfWeek::MONDAY(), LocalTime::of(1, 0), false, $timeDefinition, ZoneOffset::UTC(), ZoneOffset::UTC(), $ruleOffset); $rule_list = []; $rule_list[] = $rule1; //Begin verification $zoneRule = ZoneRules::of($stdOffset1, $wallOffset1, $stdOffsetTransition_list, $wallOffsetTransition_list, $rule_list); $before_time_of_stdOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_stdOffsetTransition1, $stdOffset1)->minusSeconds(1); $after_time_of_stdOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_stdOffsetTransition1, $stdOffset1)->plusSeconds(1); $this->assertEquals($zoneRule->getStandardOffset($before_time_of_stdOffsetTransition1->toInstant()), $stdOffset1); $this->assertEquals($zoneRule->getStandardOffset($after_time_of_stdOffsetTransition1->toInstant()), $stdOffset2); $before_time_of_wallOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition1, $wallOffset1)->minusSeconds(1); $after_time_of_wallOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition1, $wallOffset1)->plusSeconds(1); $this->assertEquals($zoneRule->nextTransition($before_time_of_wallOffsetTransition1->toInstant()), $wallOffsetTransition1); $this->assertEquals($zoneRule->nextTransition($after_time_of_wallOffsetTransition1->toInstant()), $wallOffsetTransition2); $before_time_of_wallOffsetTransition2 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition2, $wallOffset2)->minusSeconds(1); $after_time_of_wallOffsetTransition2 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition2, $wallOffset2)->plusSeconds(1); $this->assertEquals($zoneRule->nextTransition($before_time_of_wallOffsetTransition2->toInstant()), $wallOffsetTransition2); $this->assertEquals($zoneRule->nextTransition($after_time_of_wallOffsetTransition2->toInstant()), $wallOffsetTransition3); $before_time_of_wallOffsetTransition3 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition3, $wallOffset3)->minusSeconds(1); $after_time_of_wallOffsetTransition3 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition3, $wallOffset3)->plusSeconds(1); $this->assertEquals($zoneRule->nextTransition($before_time_of_wallOffsetTransition3->toInstant()), $wallOffsetTransition3); $this->assertEquals($zoneRule->nextTransition($after_time_of_wallOffsetTransition3->toInstant()), $rule1->createTransition(2014)); }
public function test_previousOrCurrent() { foreach (Month::values() as $month) { for ($i = 1; $i <= $month->length(false); $i++) { $date = self::date(2007, $month, $i); foreach (DayOfWeek::values() as $dow) { $test = TemporalAdjusters::previousOrSame($dow)->adjustInto($date); $this->assertSame($test->getDayOfWeek(), $dow); if ($test->getYear() == 2007) { $dayDiff = $test->getDayOfYear() - $date->getDayOfYear(); $this->assertTrue($dayDiff <= 0 && $dayDiff > -7); $this->assertEquals($date->equals($test), $date->getDayOfWeek() == $dow); } else { $this->assertFalse($date->getDayOfWeek() == $dow); $this->assertSame($month, Month::JANUARY()); $this->assertTrue($date->getDayOfMonth() < 7); $this->assertEquals($test->getYear(), 2006); $this->assertSame($test->getMonth(), Month::DECEMBER()); $this->assertTrue($test->getDayOfMonth() > 25); } } } } }