vendor/nesbot/carbon/src/Carbon/Carbon.php line 64

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Carbon package.
  5.  *
  6.  * (c) Brian Nesbitt <brian@nesbot.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Carbon;
  14. use Carbon\Exceptions\InvalidDateException;
  15. use Closure;
  16. use DateInterval;
  17. use DatePeriod;
  18. use DateTime;
  19. use DateTimeInterface;
  20. use DateTimeZone;
  21. use InvalidArgumentException;
  22. use JsonSerializable;
  23. use Symfony\Component\Translation\TranslatorInterface;
  25. /**
  26.  * A simple API extension for DateTime
  27.  *
  28.  * @property      int $year
  29.  * @property      int $yearIso
  30.  * @property      int $month
  31.  * @property      int $day
  32.  * @property      int $hour
  33.  * @property      int $minute
  34.  * @property      int $second
  35.  * @property      int $timestamp seconds since the Unix Epoch
  36.  * @property      \DateTimeZone $timezone the current timezone
  37.  * @property      \DateTimeZone $tz alias of timezone
  38.  * @property-read int $micro
  39.  * @property-read int $dayOfWeek 0 (for Sunday) through 6 (for Saturday)
  40.  * @property-read int $dayOfWeekIso 1 (for Monday) through 7 (for Sunday)
  41.  * @property-read int $dayOfYear 0 through 365
  42.  * @property-read int $weekOfMonth 1 through 5
  43.  * @property-read int $weekNumberInMonth 1 through 5
  44.  * @property-read int $weekOfYear ISO-8601 week number of year, weeks starting on Monday
  45.  * @property-read int $daysInMonth number of days in the given month
  46.  * @property-read int $age does a diffInYears() with default parameters
  47.  * @property-read int $quarter the quarter of this instance, 1 - 4
  48.  * @property-read int $offset the timezone offset in seconds from UTC
  49.  * @property-read int $offsetHours the timezone offset in hours from UTC
  50.  * @property-read bool $dst daylight savings time indicator, true if DST, false otherwise
  51.  * @property-read bool $local checks if the timezone is local, true if local, false otherwise
  52.  * @property-read bool $utc checks if the timezone is UTC, true if UTC, false otherwise
  53.  * @property-read string $timezoneName
  54.  * @property-read string $tzName
  55.  * @property-read string $englishDayOfWeek the day of week in English
  56.  * @property-read string $shortEnglishDayOfWeek the abbreviated day of week in English
  57.  * @property-read string $englishMonth the day of week in English
  58.  * @property-read string $shortEnglishMonth the abbreviated day of week in English
  59.  * @property-read string $localeDayOfWeek the day of week in current locale LC_TIME
  60.  * @property-read string $shortLocaleDayOfWeek the abbreviated day of week in current locale LC_TIME
  61.  * @property-read string $localeMonth the month in current locale LC_TIME
  62.  * @property-read string $shortLocaleMonth the abbreviated month in current locale LC_TIME
  63.  */
  64. class Carbon extends DateTime implements JsonSerializable
  65. {
  66.     const NO_ZERO_DIFF = 01;
  67.     const JUST_NOW = 02;
  68.     const ONE_DAY_WORDS = 04;
  69.     const TWO_DAY_WORDS = 010;
  71.     // Substitutes for Carbon 2 modes
  72.     const DIFF_RELATIVE_TO_NOW = 'relative-to-now';
  73.     const DIFF_RELATIVE_TO_OTHER = 'relative-to-other';
  75.     /**
  76.      * The day constants.
  77.      */
  78.     const SUNDAY = 0;
  79.     const MONDAY = 1;
  80.     const TUESDAY = 2;
  81.     const WEDNESDAY = 3;
  82.     const THURSDAY = 4;
  83.     const FRIDAY = 5;
  84.     const SATURDAY = 6;
  86.     /**
  87.      * Names of days of the week.
  88.      *
  89.      * @var array
  90.      */
  91.     protected static $days = array(
  92.         self::SUNDAY => 'Sunday',
  93.         self::MONDAY => 'Monday',
  94.         self::TUESDAY => 'Tuesday',
  95.         self::WEDNESDAY => 'Wednesday',
  96.         self::THURSDAY => 'Thursday',
  97.         self::FRIDAY => 'Friday',
  98.         self::SATURDAY => 'Saturday',
  99.     );
  101.     /**
  102.      * Number of X in Y.
  103.      */
  104.     const YEARS_PER_MILLENNIUM = 1000;
  105.     const YEARS_PER_CENTURY = 100;
  106.     const YEARS_PER_DECADE = 10;
  107.     const MONTHS_PER_YEAR = 12;
  108.     const MONTHS_PER_QUARTER = 3;
  109.     const WEEKS_PER_YEAR = 52;
  110.     const WEEKS_PER_MONTH = 4;
  111.     const DAYS_PER_WEEK = 7;
  112.     const HOURS_PER_DAY = 24;
  113.     const MINUTES_PER_HOUR = 60;
  114.     const SECONDS_PER_MINUTE = 60;
  115.     const MICROSECONDS_PER_MILLISECOND = 1000;
  116.     const MICROSECONDS_PER_SECOND = 1000000;
  118.     /**
  119.      * RFC7231 DateTime format.
  120.      *
  121.      * @var string
  122.      */
  123.     const RFC7231_FORMAT = 'D, d M Y H:i:s \G\M\T';
  125.     /**
  126.      * Default format to use for __toString method when type juggling occurs.
  127.      *
  128.      * @var string
  129.      */
  130.     const DEFAULT_TO_STRING_FORMAT = 'Y-m-d H:i:s';
  132.     /**
  133.      * Format for converting mocked time, includes microseconds.
  134.      *
  135.      * @var string
  136.      */
  137.     const MOCK_DATETIME_FORMAT = 'Y-m-d H:i:s.u';
  139.     /**
  140.      * Customizable PHP_INT_SIZE override.
  141.      *
  142.      * @var int
  143.      */
  144.     public static $PHPIntSize = PHP_INT_SIZE;
  146.     /**
  147.      * Format to use for __toString method when type juggling occurs.
  148.      *
  149.      * @var string
  150.      */
  151.     protected static $toStringFormat = self::DEFAULT_TO_STRING_FORMAT;
  153.     /**
  154.      * First day of week.
  155.      *
  156.      * @var int
  157.      */
  158.     protected static $weekStartsAt = self::MONDAY;
  160.     /**
  161.      * Last day of week.
  162.      *
  163.      * @var int
  164.      */
  165.     protected static $weekEndsAt = self::SUNDAY;
  167.     /**
  168.      * Days of weekend.
  169.      *
  170.      * @var array
  171.      */
  172.     protected static $weekendDays = array(
  173.         self::SATURDAY,
  174.         self::SUNDAY,
  175.     );
  177.     /**
  178.      * Midday/noon hour.
  179.      *
  180.      * @var int
  181.      */
  182.     protected static $midDayAt = 12;
  184.     /**
  185.      * Format regex patterns.
  186.      *
  187.      * @var array
  188.      */
  189.     protected static $regexFormats = array(
  190.         'd' => '(3[01]|[12][0-9]|0[1-9])',
  191.         'D' => '([a-zA-Z]{3})',
  192.         'j' => '([123][0-9]|[1-9])',
  193.         'l' => '([a-zA-Z]{2,})',
  194.         'N' => '([1-7])',
  195.         'S' => '([a-zA-Z]{2})',
  196.         'w' => '([0-6])',
  197.         'z' => '(36[0-5]|3[0-5][0-9]|[12][0-9]{2}|[1-9]?[0-9])',
  198.         'W' => '(5[012]|[1-4][0-9]|[1-9])',
  199.         'F' => '([a-zA-Z]{2,})',
  200.         'm' => '(1[012]|0[1-9])',
  201.         'M' => '([a-zA-Z]{3})',
  202.         'n' => '(1[012]|[1-9])',
  203.         't' => '(2[89]|3[01])',
  204.         'L' => '(0|1)',
  205.         'o' => '([1-9][0-9]{0,4})',
  206.         'Y' => '([1-9]?[0-9]{4})',
  207.         'y' => '([0-9]{2})',
  208.         'a' => '(am|pm)',
  209.         'A' => '(AM|PM)',
  210.         'B' => '([0-9]{3})',
  211.         'g' => '(1[012]|[1-9])',
  212.         'G' => '(2[0-3]|1?[0-9])',
  213.         'h' => '(1[012]|0[1-9])',
  214.         'H' => '(2[0-3]|[01][0-9])',
  215.         'i' => '([0-5][0-9])',
  216.         's' => '([0-5][0-9])',
  217.         'u' => '([0-9]{1,6})',
  218.         'v' => '([0-9]{1,3})',
  219.         'e' => '([a-zA-Z]{1,5})|([a-zA-Z]*\/[a-zA-Z]*)',
  220.         'I' => '(0|1)',
  221.         'O' => '([\+\-](1[012]|0[0-9])[0134][05])',
  222.         'P' => '([\+\-](1[012]|0[0-9]):[0134][05])',
  223.         'T' => '([a-zA-Z]{1,5})',
  224.         'Z' => '(-?[1-5]?[0-9]{1,4})',
  225.         'U' => '([0-9]*)',
  227.         // The formats below are combinations of the above formats.
  228.         'c' => '(([1-9]?[0-9]{4})\-(1[012]|0[1-9])\-(3[01]|[12][0-9]|0[1-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])[\+\-](1[012]|0[0-9]):([0134][05]))', // Y-m-dTH:i:sP
  229.         'r' => '(([a-zA-Z]{3}), ([123][0-9]|[1-9]) ([a-zA-Z]{3}) ([1-9]?[0-9]{4}) (2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9]) [\+\-](1[012]|0[0-9])([0134][05]))', // D, j M Y H:i:s O
  230.     );
  232.     /**
  233.      * A test Carbon instance to be returned when now instances are created.
  234.      *
  235.      * @var \Carbon\Carbon
  236.      */
  237.     protected static $testNow;
  239.     /**
  240.      * A translator to ... er ... translate stuff.
  241.      *
  242.      * @var \Symfony\Component\Translation\TranslatorInterface
  243.      */
  244.     protected static $translator;
  246.     /**
  247.      * The errors that can occur.
  248.      *
  249.      * @var array
  250.      */
  251.     protected static $lastErrors;
  253.     /**
  254.      * The custom Carbon JSON serializer.
  255.      *
  256.      * @var callable|null
  257.      */
  258.     protected static $serializer;
  260.     /**
  261.      * The registered string macros.
  262.      *
  263.      * @var array
  264.      */
  265.     protected static $localMacros = array();
  267.     /**
  268.      * Will UTF8 encoding be used to print localized date/time ?
  269.      *
  270.      * @var bool
  271.      */
  272.     protected static $utf8 = false;
  274.     /**
  275.      * Add microseconds to now on PHP < 7.1 and 7.1.3. true by default.
  276.      *
  277.      * @var bool
  278.      */
  279.     protected static $microsecondsFallback = true;
  281.     /**
  282.      * Indicates if months should be calculated with overflow.
  283.      *
  284.      * @var bool
  285.      */
  286.     protected static $monthsOverflow = true;
  288.     /**
  289.      * Indicates if years should be calculated with overflow.
  290.      *
  291.      * @var bool
  292.      */
  293.     protected static $yearsOverflow = true;
  295.     /**
  296.      * Indicates if years are compared with month by default so isSameMonth and isSameQuarter have $ofSameYear set
  297.      * to true by default.
  298.      *
  299.      * @var bool
  300.      */
  301.     protected static $compareYearWithMonth = false;
  303.     /**
  304.      * Options for diffForHumans().
  305.      *
  306.      * @var int
  307.      */
  308.     protected static $humanDiffOptions = self::NO_ZERO_DIFF;
  310.     /**
  311.      * @param int $humanDiffOptions
  312.      */
  313.     public static function setHumanDiffOptions($humanDiffOptions)
  314.     {
  315.         static::$humanDiffOptions = $humanDiffOptions;
  316.     }
  318.     /**
  319.      * @param int $humanDiffOption
  320.      */
  321.     public static function enableHumanDiffOption($humanDiffOption)
  322.     {
  323.         static::$humanDiffOptions = static::getHumanDiffOptions() | $humanDiffOption;
  324.     }
  326.     /**
  327.      * @param int $humanDiffOption
  328.      */
  329.     public static function disableHumanDiffOption($humanDiffOption)
  330.     {
  331.         static::$humanDiffOptions = static::getHumanDiffOptions() & ~$humanDiffOption;
  332.     }
  334.     /**
  335.      * @return int
  336.      */
  337.     public static function getHumanDiffOptions()
  338.     {
  339.         return static::$humanDiffOptions;
  340.     }
  342.     /**
  343.      * Add microseconds to now on PHP < 7.1 and 7.1.3 if set to true,
  344.      * let microseconds to 0 on those PHP versions if false.
  345.      *
  346.      * @param bool $microsecondsFallback
  347.      */
  348.     public static function useMicrosecondsFallback($microsecondsFallback = true)
  349.     {
  350.         static::$microsecondsFallback = $microsecondsFallback;
  351.     }
  353.     /**
  354.      * Return true if microseconds fallback on PHP < 7.1 and 7.1.3 is
  355.      * enabled. false if disabled.
  356.      *
  357.      * @return bool
  358.      */
  359.     public static function isMicrosecondsFallbackEnabled()
  360.     {
  361.         return static::$microsecondsFallback;
  362.     }
  364.     /**
  365.      * Indicates if months should be calculated with overflow.
  366.      *
  367.      * @param bool $monthsOverflow
  368.      *
  369.      * @return void
  370.      */
  371.     public static function useMonthsOverflow($monthsOverflow = true)
  372.     {
  373.         static::$monthsOverflow = $monthsOverflow;
  374.     }
  376.     /**
  377.      * Reset the month overflow behavior.
  378.      *
  379.      * @return void
  380.      */
  381.     public static function resetMonthsOverflow()
  382.     {
  383.         static::$monthsOverflow = true;
  384.     }
  386.     /**
  387.      * Get the month overflow behavior.
  388.      *
  389.      * @return bool
  390.      */
  391.     public static function shouldOverflowMonths()
  392.     {
  393.         return static::$monthsOverflow;
  394.     }
  396.     /**
  397.      * Indicates if years should be calculated with overflow.
  398.      *
  399.      * @param bool $yearsOverflow
  400.      *
  401.      * @return void
  402.      */
  403.     public static function useYearsOverflow($yearsOverflow = true)
  404.     {
  405.         static::$yearsOverflow = $yearsOverflow;
  406.     }
  408.     /**
  409.      * Reset the month overflow behavior.
  410.      *
  411.      * @return void
  412.      */
  413.     public static function resetYearsOverflow()
  414.     {
  415.         static::$yearsOverflow = true;
  416.     }
  418.     /**
  419.      * Get the month overflow behavior.
  420.      *
  421.      * @return bool
  422.      */
  423.     public static function shouldOverflowYears()
  424.     {
  425.         return static::$yearsOverflow;
  426.     }
  428.     /**
  429.      * Get the month comparison default behavior.
  430.      *
  431.      * @return bool
  432.      */
  433.     public static function compareYearWithMonth($compareYearWithMonth = true)
  434.     {
  435.         static::$compareYearWithMonth = $compareYearWithMonth;
  436.     }
  438.     /**
  439.      * Get the month comparison default behavior.
  440.      *
  441.      * @return bool
  442.      */
  443.     public static function shouldCompareYearWithMonth()
  444.     {
  445.         return static::$compareYearWithMonth;
  446.     }
  448.     /**
  449.      * Creates a DateTimeZone from a string, DateTimeZone or integer offset.
  450.      *
  451.      * @param \DateTimeZone|string|int|null $object
  452.      *
  453.      * @throws \InvalidArgumentException
  454.      *
  455.      * @return \DateTimeZone
  456.      */
  457.     protected static function safeCreateDateTimeZone($object)
  458.     {
  459.         if ($object === null) {
  460.             // Don't return null... avoid Bug #52063 in PHP <5.3.6
  461.             return new DateTimeZone(date_default_timezone_get());
  462.         }
  464.         if ($object instanceof DateTimeZone) {
  465.             return $object;
  466.         }
  468.         if (is_numeric($object)) {
  469.             $tzName = timezone_name_from_abbr(null, $object * 3600, true);
  471.             if ($tzName === false) {
  472.                 throw new InvalidArgumentException('Unknown or bad timezone ('.$object.')');
  473.             }
  475.             $object = $tzName;
  476.         }
  478.         $tz = @timezone_open($object = (string) $object);
  480.         if ($tz !== false) {
  481.             return $tz;
  482.         }
  484.         // Work-around for a bug fixed in PHP 5.5.10 https://bugs.php.net/bug.php?id=45528
  485.         // See: https://stackoverflow.com/q/14068594/2646927
  486.         // @codeCoverageIgnoreStart
  487.         if (strpos($object, ':') !== false) {
  488.             try {
  489.                 return static::createFromFormat('O', $object)->getTimezone();
  490.             } catch (InvalidArgumentException $e) {
  491.                 //
  492.             }
  493.         }
  494.         // @codeCoverageIgnoreEnd
  496.         throw new InvalidArgumentException('Unknown or bad timezone ('.$object.')');
  497.     }
  499.     ///////////////////////////////////////////////////////////////////
  500.     //////////////////////////// CONSTRUCTORS /////////////////////////
  501.     ///////////////////////////////////////////////////////////////////
  503.     /**
  504.      * Create a new Carbon instance.
  505.      *
  506.      * Please see the testing aids section (specifically static::setTestNow())
  507.      * for more on the possibility of this constructor returning a test instance.
  508.      *
  509.      * @param string|null               $time
  510.      * @param \DateTimeZone|string|null $tz
  511.      */
  512.     public function __construct($time = null, $tz = null)
  513.     {
  514.         // If the class has a test now set and we are trying to create a now()
  515.         // instance then override as required
  516.         $isNow = empty($time) || $time === 'now';
  517.         if (static::hasTestNow() && ($isNow || static::hasRelativeKeywords($time))) {
  518.             $testInstance = clone static::getTestNow();
  520.             //shift the time according to the given time zone
  521.             if ($tz !== null && $tz !== static::getTestNow()->getTimezone()) {
  522.                 $testInstance->setTimezone($tz);
  523.             } else {
  524.                 $tz = $testInstance->getTimezone();
  525.             }
  527.             if (static::hasRelativeKeywords($time)) {
  528.                 $testInstance->modify($time);
  529.             }
  531.             $time = $testInstance->format(static::MOCK_DATETIME_FORMAT);
  532.         }
  534.         $timezone = static::safeCreateDateTimeZone($tz);
  535.         // @codeCoverageIgnoreStart
  536.         if ($isNow && !isset($testInstance) && static::isMicrosecondsFallbackEnabled() && (
  537.                 version_compare(PHP_VERSION, '7.1.0-dev', '<')
  538.                 ||
  539.                 version_compare(PHP_VERSION, '7.1.3-dev', '>=') && version_compare(PHP_VERSION, '7.1.4-dev', '<')
  540.             )
  541.         ) {
  542.             // Get microseconds from microtime() if "now" asked and PHP < 7.1 and PHP 7.1.3 if fallback enabled.
  543.             list($microTime, $timeStamp) = explode(' ', microtime());
  544.             $dateTime = new DateTime('now', $timezone);
  545.             $dateTime->setTimestamp($timeStamp); // Use the timestamp returned by microtime as now can happen in the next second
  546.             $time = $dateTime->format(static::DEFAULT_TO_STRING_FORMAT).substr($microTime, 1, 7);
  547.         }
  548.         // @codeCoverageIgnoreEnd
  550.         // Work-around for PHP bug https://bugs.php.net/bug.php?id=67127
  551.         if (strpos((string) .1, '.') === false) {
  552.             $locale = setlocale(LC_NUMERIC, '0');
  553.             setlocale(LC_NUMERIC, 'C');
  554.         }
  555.         parent::__construct($time, $timezone);
  556.         if (isset($locale)) {
  557.             setlocale(LC_NUMERIC, $locale);
  558.         }
  559.         static::setLastErrors(parent::getLastErrors());
  560.     }
  562.     /**
  563.      * Create a Carbon instance from a DateTime one.
  564.      *
  565.      * @param \DateTime|\DateTimeInterface $date
  566.      *
  567.      * @return static
  568.      */
  569.     public static function instance($date)
  570.     {
  571.         if ($date instanceof static) {
  572.             return clone $date;
  573.         }
  575.         static::expectDateTime($date);
  577.         return new static($date->format('Y-m-d H:i:s.u'), $date->getTimezone());
  578.     }
  580.     /**
  581.      * Create a carbon instance from a string.
  582.      *
  583.      * This is an alias for the constructor that allows better fluent syntax
  584.      * as it allows you to do Carbon::parse('Monday next week')->fn() rather
  585.      * than (new Carbon('Monday next week'))->fn().
  586.      *
  587.      * @param string|null               $time
  588.      * @param \DateTimeZone|string|null $tz
  589.      *
  590.      * @return static
  591.      */
  592.     public static function parse($time = null, $tz = null)
  593.     {
  594.         return new static($time, $tz);
  595.     }
  597.     /**
  598.      * Get a Carbon instance for the current date and time.
  599.      *
  600.      * @param \DateTimeZone|string|null $tz
  601.      *
  602.      * @return static
  603.      */
  604.     public static function now($tz = null)
  605.     {
  606.         return new static(null, $tz);
  607.     }
  609.     /**
  610.      * Create a Carbon instance for today.
  611.      *
  612.      * @param \DateTimeZone|string|null $tz
  613.      *
  614.      * @return static
  615.      */
  616.     public static function today($tz = null)
  617.     {
  618.         return static::parse('today', $tz);
  619.     }
  621.     /**
  622.      * Create a Carbon instance for tomorrow.
  623.      *
  624.      * @param \DateTimeZone|string|null $tz
  625.      *
  626.      * @return static
  627.      */
  628.     public static function tomorrow($tz = null)
  629.     {
  630.         return static::parse('tomorrow', $tz);
  631.     }
  633.     /**
  634.      * Create a Carbon instance for yesterday.
  635.      *
  636.      * @param \DateTimeZone|string|null $tz
  637.      *
  638.      * @return static
  639.      */
  640.     public static function yesterday($tz = null)
  641.     {
  642.         return static::parse('yesterday', $tz);
  643.     }
  645.     /**
  646.      * Create a Carbon instance for the greatest supported date.
  647.      *
  648.      * @return static
  649.      */
  650.     public static function maxValue()
  651.     {
  652.         if (self::$PHPIntSize === 4) {
  653.             // 32 bit
  654.             return static::createFromTimestamp(PHP_INT_MAX); // @codeCoverageIgnore
  655.         }
  657.         // 64 bit
  658.         return static::create(9999, 12, 31, 23, 59, 59);
  659.     }
  661.     /**
  662.      * Create a Carbon instance for the lowest supported date.
  663.      *
  664.      * @return static
  665.      */
  666.     public static function minValue()
  667.     {
  668.         if (self::$PHPIntSize === 4) {
  669.             // 32 bit
  670.             return static::createFromTimestamp(~PHP_INT_MAX); // @codeCoverageIgnore
  671.         }
  673.         // 64 bit
  674.         return static::create(1, 1, 1, 0, 0, 0);
  675.     }
  677.     /**
  678.      * Create a new Carbon instance from a specific date and time.
  679.      *
  680.      * If any of $year, $month or $day are set to null their now() values will
  681.      * be used.
  682.      *
  683.      * If $hour is null it will be set to its now() value and the default
  684.      * values for $minute and $second will be their now() values.
  685.      *
  686.      * If $hour is not null then the default values for $minute and $second
  687.      * will be 0.
  688.      *
  689.      * @param int|null                  $year
  690.      * @param int|null                  $month
  691.      * @param int|null                  $day
  692.      * @param int|null                  $hour
  693.      * @param int|null                  $minute
  694.      * @param int|null                  $second
  695.      * @param \DateTimeZone|string|null $tz
  696.      *
  697.      * @throws \InvalidArgumentException
  698.      *
  699.      * @return static
  700.      */
  701.     public static function create($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null)
  702.     {
  703.         $now = static::hasTestNow() ? static::getTestNow() : static::now($tz);
  705.         $defaults = array_combine(array(
  706.             'year',
  707.             'month',
  708.             'day',
  709.             'hour',
  710.             'minute',
  711.             'second',
  712.         ), explode('-', $now->format('Y-n-j-G-i-s')));
  714.         $year = $year === null ? $defaults['year'] : $year;
  715.         $month = $month === null ? $defaults['month'] : $month;
  716.         $day = $day === null ? $defaults['day'] : $day;
  718.         if ($hour === null) {
  719.             $hour = $defaults['hour'];
  720.             $minute = $minute === null ? $defaults['minute'] : $minute;
  721.             $second = $second === null ? $defaults['second'] : $second;
  722.         } else {
  723.             $minute = $minute === null ? 0 : $minute;
  724.             $second = $second === null ? 0 : $second;
  725.         }
  727.         $fixYear = null;
  729.         if ($year < 0) {
  730.             $fixYear = $year;
  731.             $year = 0;
  732.         } elseif ($year > 9999) {
  733.             $fixYear = $year - 9999;
  734.             $year = 9999;
  735.         }
  737.         $instance = static::createFromFormat('!Y-n-j G:i:s', sprintf('%s-%s-%s %s:%02s:%02s', $year, $month, $day, $hour, $minute, $second), $tz);
  739.         if ($fixYear !== null) {
  740.             $instance->addYears($fixYear);
  741.         }
  743.         return $instance;
  744.     }
  746.     /**
  747.      * Create a new safe Carbon instance from a specific date and time.
  748.      *
  749.      * If any of $year, $month or $day are set to null their now() values will
  750.      * be used.
  751.      *
  752.      * If $hour is null it will be set to its now() value and the default
  753.      * values for $minute and $second will be their now() values.
  754.      *
  755.      * If $hour is not null then the default values for $minute and $second
  756.      * will be 0.
  757.      *
  758.      * If one of the set values is not valid, an \InvalidArgumentException
  759.      * will be thrown.
  760.      *
  761.      * @param int|null                  $year
  762.      * @param int|null                  $month
  763.      * @param int|null                  $day
  764.      * @param int|null                  $hour
  765.      * @param int|null                  $minute
  766.      * @param int|null                  $second
  767.      * @param \DateTimeZone|string|null $tz
  768.      *
  769.      * @throws \Carbon\Exceptions\InvalidDateException|\InvalidArgumentException
  770.      *
  771.      * @return static
  772.      */
  773.     public static function createSafe($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null)
  774.     {
  775.         $fields = array(
  776.             'year' => array(0, 9999),
  777.             'month' => array(0, 12),
  778.             'day' => array(0, 31),
  779.             'hour' => array(0, 24),
  780.             'minute' => array(0, 59),
  781.             'second' => array(0, 59),
  782.         );
  784.         foreach ($fields as $field => $range) {
  785.             if ($$field !== null && (!is_int($$field) || $$field < $range[0] || $$field > $range[1])) {
  786.                 throw new InvalidDateException($field, $$field);
  787.             }
  788.         }
  790.         $instance = static::create($year, $month, $day, $hour, $minute, $second, $tz);
  792.         foreach (array_reverse($fields) as $field => $range) {
  793.             if ($$field !== null && (!is_int($$field) || $$field !== $instance->$field)) {
  794.                 throw new InvalidDateException($field, $$field);
  795.             }
  796.         }
  798.         return $instance;
  799.     }
  801.     /**
  802.      * Create a Carbon instance from just a date. The time portion is set to now.
  803.      *
  804.      * @param int|null                  $year
  805.      * @param int|null                  $month
  806.      * @param int|null                  $day
  807.      * @param \DateTimeZone|string|null $tz
  808.      *
  809.      * @throws \InvalidArgumentException
  810.      *
  811.      * @return static
  812.      */
  813.     public static function createFromDate($year = null, $month = null, $day = null, $tz = null)
  814.     {
  815.         return static::create($year, $month, $day, null, null, null, $tz);
  816.     }
  818.     /**
  819.      * Create a Carbon instance from just a date. The time portion is set to midnight.
  820.      *
  821.      * @param int|null                  $year
  822.      * @param int|null                  $month
  823.      * @param int|null                  $day
  824.      * @param \DateTimeZone|string|null $tz
  825.      *
  826.      * @return static
  827.      */
  828.     public static function createMidnightDate($year = null, $month = null, $day = null, $tz = null)
  829.     {
  830.         return static::create($year, $month, $day, 0, 0, 0, $tz);
  831.     }
  833.     /**
  834.      * Create a Carbon instance from just a time. The date portion is set to today.
  835.      *
  836.      * @param int|null                  $hour
  837.      * @param int|null                  $minute
  838.      * @param int|null                  $second
  839.      * @param \DateTimeZone|string|null $tz
  840.      *
  841.      * @throws \InvalidArgumentException
  842.      *
  843.      * @return static
  844.      */
  845.     public static function createFromTime($hour = null, $minute = null, $second = null, $tz = null)
  846.     {
  847.         return static::create(null, null, null, $hour, $minute, $second, $tz);
  848.     }
  850.     /**
  851.      * Create a Carbon instance from a time string. The date portion is set to today.
  852.      *
  853.      * @param string                    $time
  854.      * @param \DateTimeZone|string|null $tz
  855.      *
  856.      * @throws \InvalidArgumentException
  857.      *
  858.      * @return static
  859.      */
  860.     public static function createFromTimeString($time, $tz = null)
  861.     {
  862.         return static::today($tz)->setTimeFromTimeString($time);
  863.     }
  865.     private static function createFromFormatAndTimezone($format, $time, $tz)
  866.     {
  867.         return $tz !== null
  868.             ? parent::createFromFormat($format, $time, static::safeCreateDateTimeZone($tz))
  869.             : parent::createFromFormat($format, $time);
  870.     }
  872.     /**
  873.      * Create a Carbon instance from a specific format.
  874.      *
  875.      * @param string                    $format Datetime format
  876.      * @param string                    $time
  877.      * @param \DateTimeZone|string|null $tz
  878.      *
  879.      * @throws InvalidArgumentException
  880.      *
  881.      * @return static
  882.      */
  883.     public static function createFromFormat($format, $time, $tz = null)
  884.     {
  885.         // First attempt to create an instance, so that error messages are based on the unmodified format.
  886.         $date = self::createFromFormatAndTimezone($format, $time, $tz);
  887.         $lastErrors = parent::getLastErrors();
  889.         if (($mock = static::getTestNow()) && ($date instanceof DateTime || $date instanceof DateTimeInterface)) {
  890.             // Set timezone from mock if custom timezone was neither given directly nor as a part of format.
  891.             // First let's skip the part that will be ignored by the parser.
  892.             $nonEscaped = '(?<!\\\\)(\\\\{2})*';
  894.             $nonIgnored = preg_replace("/^.*{$nonEscaped}!/s", '', $format);
  896.             if ($tz === null && !preg_match("/{$nonEscaped}[eOPT]/", $nonIgnored)) {
  897.                 $tz = $mock->getTimezone();
  898.             }
  900.             // Prepend mock datetime only if the format does not contain non escaped unix epoch reset flag.
  901.             if (!preg_match("/{$nonEscaped}[!|]/", $format)) {
  902.                 $format = static::MOCK_DATETIME_FORMAT.' '.$format;
  903.                 $time = $mock->format(static::MOCK_DATETIME_FORMAT).' '.$time;
  904.             }
  906.             // Regenerate date from the modified format to base result on the mocked instance instead of now.
  907.             $date = self::createFromFormatAndTimezone($format, $time, $tz);
  908.         }
  910.         if ($date instanceof DateTime || $date instanceof DateTimeInterface) {
  911.             $instance = static::instance($date);
  912.             $instance::setLastErrors($lastErrors);
  914.             return $instance;
  915.         }
  917.         throw new InvalidArgumentException(implode(PHP_EOL, $lastErrors['errors']));
  918.     }
  920.     /**
  921.      * Set last errors.
  922.      *
  923.      * @param array $lastErrors
  924.      *
  925.      * @return void
  926.      */
  927.     private static function setLastErrors(array $lastErrors)
  928.     {
  929.         static::$lastErrors = $lastErrors;
  930.     }
  932.     /**
  933.      * {@inheritdoc}
  934.      */
  935.     public static function getLastErrors()
  936.     {
  937.         return static::$lastErrors;
  938.     }
  940.     /**
  941.      * Create a Carbon instance from a timestamp.
  942.      *
  943.      * @param int                       $timestamp
  944.      * @param \DateTimeZone|string|null $tz
  945.      *
  946.      * @return static
  947.      */
  948.     public static function createFromTimestamp($timestamp, $tz = null)
  949.     {
  950.         return static::today($tz)->setTimestamp($timestamp);
  951.     }
  953.     /**
  954.      * Create a Carbon instance from a timestamp in milliseconds.
  955.      *
  956.      * @param int                       $timestamp
  957.      * @param \DateTimeZone|string|null $tz
  958.      *
  959.      * @return static
  960.      */
  961.     public static function createFromTimestampMs($timestamp, $tz = null)
  962.     {
  963.         return static::createFromFormat('U.u', sprintf('%F', $timestamp / 1000))
  964.             ->setTimezone($tz);
  965.     }
  967.     /**
  968.      * Create a Carbon instance from an UTC timestamp.
  969.      *
  970.      * @param int $timestamp
  971.      *
  972.      * @return static
  973.      */
  974.     public static function createFromTimestampUTC($timestamp)
  975.     {
  976.         return new static('@'.$timestamp);
  977.     }
  979.     /**
  980.      * Make a Carbon instance from given variable if possible.
  981.      *
  982.      * Always return a new instance. Parse only strings and only these likely to be dates (skip intervals
  983.      * and recurrences). Throw an exception for invalid format, but otherwise return null.
  984.      *
  985.      * @param mixed $var
  986.      *
  987.      * @return static|null
  988.      */
  989.     public static function make($var)
  990.     {
  991.         if ($var instanceof DateTime || $var instanceof DateTimeInterface) {
  992.             return static::instance($var);
  993.         }
  995.         if (is_string($var)) {
  996.             $var = trim($var);
  997.             $first = substr($var, 0, 1);
  999.             if (is_string($var) && $first !== 'P' && $first !== 'R' && preg_match('/[a-z0-9]/i', $var)) {
  1000.                 return static::parse($var);
  1001.             }
  1002.         }
  1003.     }
  1005.     /**
  1006.      * Get a copy of the instance.
  1007.      *
  1008.      * @return static
  1009.      */
  1010.     public function copy()
  1011.     {
  1012.         return clone $this;
  1013.     }
  1015.     /**
  1016.      * Returns a present instance in the same timezone.
  1017.      *
  1018.      * @return static
  1019.      */
  1020.     public function nowWithSameTz()
  1021.     {
  1022.         return static::now($this->getTimezone());
  1023.     }
  1025.     /**
  1026.      * Throws an exception if the given object is not a DateTime and does not implement DateTimeInterface
  1027.      * and not in $other.
  1028.      *
  1029.      * @param mixed        $date
  1030.      * @param string|array $other
  1031.      *
  1032.      * @throws \InvalidArgumentException
  1033.      */
  1034.     protected static function expectDateTime($date, $other = array())
  1035.     {
  1036.         $message = 'Expected ';
  1037.         foreach ((array) $other as $expect) {
  1038.             $message .= "{$expect}, ";
  1039.         }
  1041.         if (!$date instanceof DateTime && !$date instanceof DateTimeInterface) {
  1042.             throw new InvalidArgumentException(
  1043.                 $message.'DateTime or DateTimeInterface, '.
  1044.                 (is_object($date) ? get_class($date) : gettype($date)).' given'
  1045.             );
  1046.         }
  1047.     }
  1049.     /**
  1050.      * Return the Carbon instance passed through, a now instance in the same timezone
  1051.      * if null given or parse the input if string given.
  1052.      *
  1053.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  1054.      *
  1055.      * @return static
  1056.      */
  1057.     protected function resolveCarbon($date = null)
  1058.     {
  1059.         if (!$date) {
  1060.             return $this->nowWithSameTz();
  1061.         }
  1063.         if (is_string($date)) {
  1064.             return static::parse($date, $this->getTimezone());
  1065.         }
  1067.         static::expectDateTime($date, array('null', 'string'));
  1069.         return $date instanceof self ? $date : static::instance($date);
  1070.     }
  1072.     ///////////////////////////////////////////////////////////////////
  1073.     ///////////////////////// GETTERS AND SETTERS /////////////////////
  1074.     ///////////////////////////////////////////////////////////////////
  1076.     /**
  1077.      * Get a part of the Carbon object
  1078.      *
  1079.      * @param string $name
  1080.      *
  1081.      * @throws \InvalidArgumentException
  1082.      *
  1083.      * @return string|int|bool|\DateTimeZone
  1084.      */
  1085.     public function __get($name)
  1086.     {
  1087.         static $formats = array(
  1088.             'year' => 'Y',
  1089.             'yearIso' => 'o',
  1090.             'month' => 'n',
  1091.             'day' => 'j',
  1092.             'hour' => 'G',
  1093.             'minute' => 'i',
  1094.             'second' => 's',
  1095.             'micro' => 'u',
  1096.             'dayOfWeek' => 'w',
  1097.             'dayOfWeekIso' => 'N',
  1098.             'dayOfYear' => 'z',
  1099.             'weekOfYear' => 'W',
  1100.             'daysInMonth' => 't',
  1101.             'timestamp' => 'U',
  1102.             'englishDayOfWeek' => 'l',
  1103.             'shortEnglishDayOfWeek' => 'D',
  1104.             'englishMonth' => 'F',
  1105.             'shortEnglishMonth' => 'M',
  1106.             'localeDayOfWeek' => '%A',
  1107.             'shortLocaleDayOfWeek' => '%a',
  1108.             'localeMonth' => '%B',
  1109.             'shortLocaleMonth' => '%b',
  1110.         );
  1112.         switch (true) {
  1113.             case isset($formats[$name]):
  1114.                 $format = $formats[$name];
  1115.                 $method = substr($format, 0, 1) === '%' ? 'formatLocalized' : 'format';
  1116.                 $value = $this->$method($format);
  1118.                 return is_numeric($value) ? (int) $value : $value;
  1120.             case $name === 'weekOfMonth':
  1121.                 return (int) ceil($this->day / static::DAYS_PER_WEEK);
  1123.             case $name === 'weekNumberInMonth':
  1124.                 return (int) ceil(($this->day + $this->copy()->startOfMonth()->dayOfWeek - 1) / static::DAYS_PER_WEEK);
  1126.             case $name === 'age':
  1127.                 return $this->diffInYears();
  1129.             case $name === 'quarter':
  1130.                 return (int) ceil($this->month / static::MONTHS_PER_QUARTER);
  1132.             case $name === 'offset':
  1133.                 return $this->getOffset();
  1135.             case $name === 'offsetHours':
  1136.                 return $this->getOffset() / static::SECONDS_PER_MINUTE / static::MINUTES_PER_HOUR;
  1138.             case $name === 'dst':
  1139.                 return $this->format('I') === '1';
  1141.             case $name === 'local':
  1142.                 return $this->getOffset() === $this->copy()->setTimezone(date_default_timezone_get())->getOffset();
  1144.             case $name === 'utc':
  1145.                 return $this->getOffset() === 0;
  1147.             case $name === 'timezone' || $name === 'tz':
  1148.                 return $this->getTimezone();
  1150.             case $name === 'timezoneName' || $name === 'tzName':
  1151.                 return $this->getTimezone()->getName();
  1153.             default:
  1154.                 throw new InvalidArgumentException(sprintf("Unknown getter '%s'", $name));
  1155.         }
  1156.     }
  1158.     /**
  1159.      * Check if an attribute exists on the object
  1160.      *
  1161.      * @param string $name
  1162.      *
  1163.      * @return bool
  1164.      */
  1165.     public function __isset($name)
  1166.     {
  1167.         try {
  1168.             $this->__get($name);
  1169.         } catch (InvalidArgumentException $e) {
  1170.             return false;
  1171.         }
  1173.         return true;
  1174.     }
  1176.     /**
  1177.      * Set a part of the Carbon object
  1178.      *
  1179.      * @param string                   $name
  1180.      * @param string|int|\DateTimeZone $value
  1181.      *
  1182.      * @throws \InvalidArgumentException
  1183.      *
  1184.      * @return void
  1185.      */
  1186.     public function __set($name, $value)
  1187.     {
  1188.         switch ($name) {
  1189.             case 'year':
  1190.             case 'month':
  1191.             case 'day':
  1192.             case 'hour':
  1193.             case 'minute':
  1194.             case 'second':
  1195.                 list($year, $month, $day, $hour, $minute, $second) = explode('-', $this->format('Y-n-j-G-i-s'));
  1196.                 $$name = $value;
  1197.                 $this->setDateTime($year, $month, $day, $hour, $minute, $second);
  1198.                 break;
  1200.             case 'timestamp':
  1201.                 parent::setTimestamp($value);
  1202.                 break;
  1204.             case 'timezone':
  1205.             case 'tz':
  1206.                 $this->setTimezone($value);
  1207.                 break;
  1209.             default:
  1210.                 throw new InvalidArgumentException(sprintf("Unknown setter '%s'", $name));
  1211.         }
  1212.     }
  1214.     /**
  1215.      * Set the instance's year
  1216.      *
  1217.      * @param int $value
  1218.      *
  1219.      * @return static
  1220.      */
  1221.     public function year($value)
  1222.     {
  1223.         $this->year = $value;
  1225.         return $this;
  1226.     }
  1228.     /**
  1229.      * Set the instance's month
  1230.      *
  1231.      * @param int $value
  1232.      *
  1233.      * @return static
  1234.      */
  1235.     public function month($value)
  1236.     {
  1237.         $this->month = $value;
  1239.         return $this;
  1240.     }
  1242.     /**
  1243.      * Set the instance's day
  1244.      *
  1245.      * @param int $value
  1246.      *
  1247.      * @return static
  1248.      */
  1249.     public function day($value)
  1250.     {
  1251.         $this->day = $value;
  1253.         return $this;
  1254.     }
  1256.     /**
  1257.      * Set the instance's hour
  1258.      *
  1259.      * @param int $value
  1260.      *
  1261.      * @return static
  1262.      */
  1263.     public function hour($value)
  1264.     {
  1265.         $this->hour = $value;
  1267.         return $this;
  1268.     }
  1270.     /**
  1271.      * Set the instance's minute
  1272.      *
  1273.      * @param int $value
  1274.      *
  1275.      * @return static
  1276.      */
  1277.     public function minute($value)
  1278.     {
  1279.         $this->minute = $value;
  1281.         return $this;
  1282.     }
  1284.     /**
  1285.      * Set the instance's second
  1286.      *
  1287.      * @param int $value
  1288.      *
  1289.      * @return static
  1290.      */
  1291.     public function second($value)
  1292.     {
  1293.         $this->second = $value;
  1295.         return $this;
  1296.     }
  1298.     /**
  1299.      * Sets the current date of the DateTime object to a different date.
  1300.      * Calls modify as a workaround for a php bug
  1301.      *
  1302.      * @param int $year
  1303.      * @param int $month
  1304.      * @param int $day
  1305.      *
  1306.      * @return static
  1307.      *
  1308.      * @see https://github.com/briannesbitt/Carbon/issues/539
  1309.      * @see https://bugs.php.net/bug.php?id=63863
  1310.      */
  1311.     public function setDate($year, $month, $day)
  1312.     {
  1313.         $this->modify('+0 day');
  1315.         return parent::setDate($year, $month, $day);
  1316.     }
  1318.     /**
  1319.      * Set the date and time all together
  1320.      *
  1321.      * @param int $year
  1322.      * @param int $month
  1323.      * @param int $day
  1324.      * @param int $hour
  1325.      * @param int $minute
  1326.      * @param int $second
  1327.      *
  1328.      * @return static
  1329.      */
  1330.     public function setDateTime($year, $month, $day, $hour, $minute, $second = 0)
  1331.     {
  1332.         return $this->setDate($year, $month, $day)->setTime($hour, $minute, $second);
  1333.     }
  1335.     /**
  1336.      * Set the time by time string
  1337.      *
  1338.      * @param string $time
  1339.      *
  1340.      * @return static
  1341.      */
  1342.     public function setTimeFromTimeString($time)
  1343.     {
  1344.         if (strpos($time, ':') === false) {
  1345.             $time .= ':0';
  1346.         }
  1348.         return $this->modify($time);
  1349.     }
  1351.     /**
  1352.      * Set the instance's timestamp
  1353.      *
  1354.      * @param int $value
  1355.      *
  1356.      * @return static
  1357.      */
  1358.     public function timestamp($value)
  1359.     {
  1360.         return $this->setTimestamp($value);
  1361.     }
  1363.     /**
  1364.      * Alias for setTimezone()
  1365.      *
  1366.      * @param \DateTimeZone|string $value
  1367.      *
  1368.      * @return static
  1369.      */
  1370.     public function timezone($value)
  1371.     {
  1372.         return $this->setTimezone($value);
  1373.     }
  1375.     /**
  1376.      * Alias for setTimezone()
  1377.      *
  1378.      * @param \DateTimeZone|string $value
  1379.      *
  1380.      * @return static
  1381.      */
  1382.     public function tz($value)
  1383.     {
  1384.         return $this->setTimezone($value);
  1385.     }
  1387.     /**
  1388.      * Set the instance's timezone from a string or object
  1389.      *
  1390.      * @param \DateTimeZone|string $value
  1391.      *
  1392.      * @return static
  1393.      */
  1394.     public function setTimezone($value)
  1395.     {
  1396.         parent::setTimezone(static::safeCreateDateTimeZone($value));
  1397.         // https://bugs.php.net/bug.php?id=72338
  1398.         // just workaround on this bug
  1399.         $this->getTimestamp();
  1401.         return $this;
  1402.     }
  1404.     /**
  1405.      * Set the year, month, and date for this instance to that of the passed instance.
  1406.      *
  1407.      * @param \Carbon\Carbon|\DateTimeInterface $date
  1408.      *
  1409.      * @return static
  1410.      */
  1411.     public function setDateFrom($date)
  1412.     {
  1413.         $date = static::instance($date);
  1415.         $this->setDate($date->year, $date->month, $date->day);
  1417.         return $this;
  1418.     }
  1420.     /**
  1421.      * Set the hour, day, and time for this instance to that of the passed instance.
  1422.      *
  1423.      * @param \Carbon\Carbon|\DateTimeInterface $date
  1424.      *
  1425.      * @return static
  1426.      */
  1427.     public function setTimeFrom($date)
  1428.     {
  1429.         $date = static::instance($date);
  1431.         $this->setTime($date->hour, $date->minute, $date->second);
  1433.         return $this;
  1434.     }
  1436.     /**
  1437.      * Get the days of the week
  1438.      *
  1439.      * @return array
  1440.      */
  1441.     public static function getDays()
  1442.     {
  1443.         return static::$days;
  1444.     }
  1446.     ///////////////////////////////////////////////////////////////////
  1447.     /////////////////////// WEEK SPECIAL DAYS /////////////////////////
  1448.     ///////////////////////////////////////////////////////////////////
  1450.     /**
  1451.      * Get the first day of week
  1452.      *
  1453.      * @return int
  1454.      */
  1455.     public static function getWeekStartsAt()
  1456.     {
  1457.         return static::$weekStartsAt;
  1458.     }
  1460.     /**
  1461.      * Set the first day of week
  1462.      *
  1463.      * @param int $day week start day
  1464.      *
  1465.      * @throws InvalidArgumentException
  1466.      *
  1467.      * @return void
  1468.      */
  1469.     public static function setWeekStartsAt($day)
  1470.     {
  1471.         if ($day > static::SATURDAY || $day < static::SUNDAY) {
  1472.             throw new InvalidArgumentException('Day of a week should be greater than or equal to 0 and less than or equal to 6.');
  1473.         }
  1475.         static::$weekStartsAt = $day;
  1476.     }
  1478.     /**
  1479.      * Get the last day of week
  1480.      *
  1481.      * @return int
  1482.      */
  1483.     public static function getWeekEndsAt()
  1484.     {
  1485.         return static::$weekEndsAt;
  1486.     }
  1488.     /**
  1489.      * Set the last day of week
  1490.      *
  1491.      * @param int $day
  1492.      *
  1493.      * @throws InvalidArgumentException
  1494.      *
  1495.      * @return void
  1496.      */
  1497.     public static function setWeekEndsAt($day)
  1498.     {
  1499.         if ($day > static::SATURDAY || $day < static::SUNDAY) {
  1500.             throw new InvalidArgumentException('Day of a week should be greater than or equal to 0 and less than or equal to 6.');
  1501.         }
  1503.         static::$weekEndsAt = $day;
  1504.     }
  1506.     /**
  1507.      * Get weekend days
  1508.      *
  1509.      * @return array
  1510.      */
  1511.     public static function getWeekendDays()
  1512.     {
  1513.         return static::$weekendDays;
  1514.     }
  1516.     /**
  1517.      * Set weekend days
  1518.      *
  1519.      * @param array $days
  1520.      *
  1521.      * @return void
  1522.      */
  1523.     public static function setWeekendDays($days)
  1524.     {
  1525.         static::$weekendDays = $days;
  1526.     }
  1528.     /**
  1529.      * get midday/noon hour
  1530.      *
  1531.      * @return int
  1532.      */
  1533.     public static function getMidDayAt()
  1534.     {
  1535.         return static::$midDayAt;
  1536.     }
  1538.     /**
  1539.      * Set midday/noon hour
  1540.      *
  1541.      * @param int $hour midday hour
  1542.      *
  1543.      * @return void
  1544.      */
  1545.     public static function setMidDayAt($hour)
  1546.     {
  1547.         static::$midDayAt = $hour;
  1548.     }
  1550.     ///////////////////////////////////////////////////////////////////
  1551.     ///////////////////////// TESTING AIDS ////////////////////////////
  1552.     ///////////////////////////////////////////////////////////////////
  1554.     /**
  1555.      * Set a Carbon instance (real or mock) to be returned when a "now"
  1556.      * instance is created.  The provided instance will be returned
  1557.      * specifically under the following conditions:
  1558.      *   - A call to the static now() method, ex. Carbon::now()
  1559.      *   - When a null (or blank string) is passed to the constructor or parse(), ex. new Carbon(null)
  1560.      *   - When the string "now" is passed to the constructor or parse(), ex. new Carbon('now')
  1561.      *   - When a string containing the desired time is passed to Carbon::parse().
  1562.      *
  1563.      * Note the timezone parameter was left out of the examples above and
  1564.      * has no affect as the mock value will be returned regardless of its value.
  1565.      *
  1566.      * To clear the test instance call this method using the default
  1567.      * parameter of null.
  1568.      *
  1569.      * @param \Carbon\Carbon|null        $testNow real or mock Carbon instance
  1570.      * @param \Carbon\Carbon|string|null $testNow
  1571.      */
  1572.     public static function setTestNow($testNow = null)
  1573.     {
  1574.         static::$testNow = is_string($testNow) ? static::parse($testNow) : $testNow;
  1575.     }
  1577.     /**
  1578.      * Get the Carbon instance (real or mock) to be returned when a "now"
  1579.      * instance is created.
  1580.      *
  1581.      * @return static the current instance used for testing
  1582.      */
  1583.     public static function getTestNow()
  1584.     {
  1585.         return static::$testNow;
  1586.     }
  1588.     /**
  1589.      * Determine if there is a valid test instance set. A valid test instance
  1590.      * is anything that is not null.
  1591.      *
  1592.      * @return bool true if there is a test instance, otherwise false
  1593.      */
  1594.     public static function hasTestNow()
  1595.     {
  1596.         return static::getTestNow() !== null;
  1597.     }
  1599.     /**
  1600.      * Determine if a time string will produce a relative date.
  1601.      *
  1602.      * @param string $time
  1603.      *
  1604.      * @return bool true if time match a relative date, false if absolute or invalid time string
  1605.      */
  1606.     public static function hasRelativeKeywords($time)
  1607.     {
  1608.         if (strtotime($time) === false) {
  1609.             return false;
  1610.         }
  1612.         $date1 = new DateTime('2000-01-01T00:00:00Z');
  1613.         $date1->modify($time);
  1614.         $date2 = new DateTime('2001-12-25T00:00:00Z');
  1615.         $date2->modify($time);
  1617.         return $date1 != $date2;
  1618.     }
  1620.     ///////////////////////////////////////////////////////////////////
  1621.     /////////////////////// LOCALIZATION //////////////////////////////
  1622.     ///////////////////////////////////////////////////////////////////
  1624.     /**
  1625.      * Initialize the translator instance if necessary.
  1626.      *
  1627.      * @return \Symfony\Component\Translation\TranslatorInterface
  1628.      */
  1629.     protected static function translator()
  1630.     {
  1631.         if (static::$translator === null) {
  1632.             static::$translator = Translator::get();
  1633.         }
  1635.         return static::$translator;
  1636.     }
  1638.     /**
  1639.      * Get the translator instance in use
  1640.      *
  1641.      * @return \Symfony\Component\Translation\TranslatorInterface
  1642.      */
  1643.     public static function getTranslator()
  1644.     {
  1645.         return static::translator();
  1646.     }
  1648.     /**
  1649.      * Set the translator instance to use
  1650.      *
  1651.      * @param \Symfony\Component\Translation\TranslatorInterface $translator
  1652.      *
  1653.      * @return void
  1654.      */
  1655.     public static function setTranslator(TranslatorInterface $translator)
  1656.     {
  1657.         static::$translator = $translator;
  1658.     }
  1660.     /**
  1661.      * Get the current translator locale
  1662.      *
  1663.      * @return string
  1664.      */
  1665.     public static function getLocale()
  1666.     {
  1667.         return static::translator()->getLocale();
  1668.     }
  1670.     /**
  1671.      * Set the current translator locale and indicate if the source locale file exists
  1672.      *
  1673.      * @param string $locale locale ex. en
  1674.      *
  1675.      * @return bool
  1676.      */
  1677.     public static function setLocale($locale)
  1678.     {
  1679.         return static::translator()->setLocale($locale) !== false;
  1680.     }
  1682.     /**
  1683.      * Set the current locale to the given, execute the passed function, reset the locale to previous one,
  1684.      * then return the result of the closure (or null if the closure was void).
  1685.      *
  1686.      * @param string $locale locale ex. en
  1687.      *
  1688.      * @return mixed
  1689.      */
  1690.     public static function executeWithLocale($locale, $func)
  1691.     {
  1692.         $currentLocale = static::getLocale();
  1693.         $result = call_user_func($func, static::setLocale($locale) ? static::getLocale() : false, static::translator());
  1694.         static::setLocale($currentLocale);
  1696.         return $result;
  1697.     }
  1699.     /**
  1700.      * Returns true if the given locale is internally supported and has short-units support.
  1701.      * Support is considered enabled if either year, day or hour has a short variant translated.
  1702.      *
  1703.      * @param string $locale locale ex. en
  1704.      *
  1705.      * @return bool
  1706.      */
  1707.     public static function localeHasShortUnits($locale)
  1708.     {
  1709.         return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
  1710.             return $newLocale &&
  1711.                 (
  1712.                     ($y = $translator->trans('y')) !== 'y' &&
  1713.                     $y !== $translator->trans('year')
  1714.                 ) || (
  1715.                     ($y = $translator->trans('d')) !== 'd' &&
  1716.                     $y !== $translator->trans('day')
  1717.                 ) || (
  1718.                     ($y = $translator->trans('h')) !== 'h' &&
  1719.                     $y !== $translator->trans('hour')
  1720.                 );
  1721.         });
  1722.     }
  1724.     /**
  1725.      * Returns true if the given locale is internally supported and has diff syntax support (ago, from now, before, after).
  1726.      * Support is considered enabled if the 4 sentences are translated in the given locale.
  1727.      *
  1728.      * @param string $locale locale ex. en
  1729.      *
  1730.      * @return bool
  1731.      */
  1732.     public static function localeHasDiffSyntax($locale)
  1733.     {
  1734.         return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
  1735.             return $newLocale &&
  1736.                 $translator->trans('ago') !== 'ago' &&
  1737.                 $translator->trans('from_now') !== 'from_now' &&
  1738.                 $translator->trans('before') !== 'before' &&
  1739.                 $translator->trans('after') !== 'after';
  1740.         });
  1741.     }
  1743.     /**
  1744.      * Returns true if the given locale is internally supported and has words for 1-day diff (just now, yesterday, tomorrow).
  1745.      * Support is considered enabled if the 3 words are translated in the given locale.
  1746.      *
  1747.      * @param string $locale locale ex. en
  1748.      *
  1749.      * @return bool
  1750.      */
  1751.     public static function localeHasDiffOneDayWords($locale)
  1752.     {
  1753.         return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
  1754.             return $newLocale &&
  1755.                 $translator->trans('diff_now') !== 'diff_now' &&
  1756.                 $translator->trans('diff_yesterday') !== 'diff_yesterday' &&
  1757.                 $translator->trans('diff_tomorrow') !== 'diff_tomorrow';
  1758.         });
  1759.     }
  1761.     /**
  1762.      * Returns true if the given locale is internally supported and has words for 2-days diff (before yesterday, after tomorrow).
  1763.      * Support is considered enabled if the 2 words are translated in the given locale.
  1764.      *
  1765.      * @param string $locale locale ex. en
  1766.      *
  1767.      * @return bool
  1768.      */
  1769.     public static function localeHasDiffTwoDayWords($locale)
  1770.     {
  1771.         return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
  1772.             return $newLocale &&
  1773.                 $translator->trans('diff_before_yesterday') !== 'diff_before_yesterday' &&
  1774.                 $translator->trans('diff_after_tomorrow') !== 'diff_after_tomorrow';
  1775.         });
  1776.     }
  1778.     /**
  1779.      * Returns true if the given locale is internally supported and has period syntax support (X times, every X, from X, to X).
  1780.      * Support is considered enabled if the 4 sentences are translated in the given locale.
  1781.      *
  1782.      * @param string $locale locale ex. en
  1783.      *
  1784.      * @return bool
  1785.      */
  1786.     public static function localeHasPeriodSyntax($locale)
  1787.     {
  1788.         return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
  1789.             return $newLocale &&
  1790.                 $translator->trans('period_recurrences') !== 'period_recurrences' &&
  1791.                 $translator->trans('period_interval') !== 'period_interval' &&
  1792.                 $translator->trans('period_start_date') !== 'period_start_date' &&
  1793.                 $translator->trans('period_end_date') !== 'period_end_date';
  1794.         });
  1795.     }
  1797.     /**
  1798.      * Returns the list of internally available locales and already loaded custom locales.
  1799.      * (It will ignore custom translator dynamic loading.)
  1800.      *
  1801.      * @return array
  1802.      */
  1803.     public static function getAvailableLocales()
  1804.     {
  1805.         $translator = static::translator();
  1806.         $locales = array();
  1807.         if ($translator instanceof Translator) {
  1808.             foreach (glob(__DIR__.'/Lang/*.php') as $file) {
  1809.                 $locales[] = substr($file, strrpos($file, '/') + 1, -4);
  1810.             }
  1812.             $locales = array_unique(array_merge($locales, array_keys($translator->getMessages())));
  1813.         }
  1815.         return $locales;
  1816.     }
  1818.     ///////////////////////////////////////////////////////////////////
  1819.     /////////////////////// STRING FORMATTING /////////////////////////
  1820.     ///////////////////////////////////////////////////////////////////
  1822.     /**
  1823.      * Set if UTF8 will be used for localized date/time
  1824.      *
  1825.      * @param bool $utf8
  1826.      */
  1827.     public static function setUtf8($utf8)
  1828.     {
  1829.         static::$utf8 = $utf8;
  1830.     }
  1832.     /**
  1833.      * Format the instance with the current locale.  You can set the current
  1834.      * locale using setlocale() http://php.net/setlocale.
  1835.      *
  1836.      * @param string $format
  1837.      *
  1838.      * @return string
  1839.      */
  1840.     public function formatLocalized($format)
  1841.     {
  1842.         // Check for Windows to find and replace the %e modifier correctly.
  1843.         if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
  1844.             $format = preg_replace('#(?<!%)((?:%%)*)%e#', '\1%#d', $format); // @codeCoverageIgnore
  1845.         }
  1847.         $formatted = strftime($format, strtotime($this->toDateTimeString()));
  1849.         return static::$utf8 ? utf8_encode($formatted) : $formatted;
  1850.     }
  1852.     /**
  1853.      * Reset the format used to the default when type juggling a Carbon instance to a string
  1854.      *
  1855.      * @return void
  1856.      */
  1857.     public static function resetToStringFormat()
  1858.     {
  1859.         static::setToStringFormat(static::DEFAULT_TO_STRING_FORMAT);
  1860.     }
  1862.     /**
  1863.      * Set the default format used when type juggling a Carbon instance to a string
  1864.      *
  1865.      * @param string|Closure $format
  1866.      *
  1867.      * @return void
  1868.      */
  1869.     public static function setToStringFormat($format)
  1870.     {
  1871.         static::$toStringFormat = $format;
  1872.     }
  1874.     /**
  1875.      * Format the instance as a string using the set format
  1876.      *
  1877.      * @return string
  1878.      */
  1879.     public function __toString()
  1880.     {
  1881.         $format = static::$toStringFormat;
  1883.         return $this->format($format instanceof Closure ? $format($this) : $format);
  1884.     }
  1886.     /**
  1887.      * Format the instance as date
  1888.      *
  1889.      * @return string
  1890.      */
  1891.     public function toDateString()
  1892.     {
  1893.         return $this->format('Y-m-d');
  1894.     }
  1896.     /**
  1897.      * Format the instance as a readable date
  1898.      *
  1899.      * @return string
  1900.      */
  1901.     public function toFormattedDateString()
  1902.     {
  1903.         return $this->format('M j, Y');
  1904.     }
  1906.     /**
  1907.      * Format the instance as time
  1908.      *
  1909.      * @return string
  1910.      */
  1911.     public function toTimeString()
  1912.     {
  1913.         return $this->format('H:i:s');
  1914.     }
  1916.     /**
  1917.      * Format the instance as date and time
  1918.      *
  1919.      * @return string
  1920.      */
  1921.     public function toDateTimeString()
  1922.     {
  1923.         return $this->format('Y-m-d H:i:s');
  1924.     }
  1926.     /**
  1927.      * Format the instance as date and time T-separated with no timezone
  1928.      *
  1929.      * @example
  1930.      * ```
  1931.      * echo Carbon::now()->toDateTimeLocalString();
  1932.      * ```
  1933.      *
  1934.      * @return string
  1935.      */
  1936.     public function toDateTimeLocalString()
  1937.     {
  1938.         return $this->format('Y-m-d\TH:i:s');
  1939.     }
  1941.     /**
  1942.      * Format the instance with day, date and time
  1943.      *
  1944.      * @return string
  1945.      */
  1946.     public function toDayDateTimeString()
  1947.     {
  1948.         return $this->format('D, M j, Y g:i A');
  1949.     }
  1951.     /**
  1952.      * Format the instance as ATOM
  1953.      *
  1954.      * @return string
  1955.      */
  1956.     public function toAtomString()
  1957.     {
  1958.         return $this->format(static::ATOM);
  1959.     }
  1961.     /**
  1962.      * Format the instance as COOKIE
  1963.      *
  1964.      * @return string
  1965.      */
  1966.     public function toCookieString()
  1967.     {
  1968.         return $this->format(static::COOKIE);
  1969.     }
  1971.     /**
  1972.      * Format the instance as ISO8601
  1973.      *
  1974.      * @return string
  1975.      */
  1976.     public function toIso8601String()
  1977.     {
  1978.         return $this->toAtomString();
  1979.     }
  1981.     /**
  1982.      * Format the instance as RFC822
  1983.      *
  1984.      * @return string
  1985.      */
  1986.     public function toRfc822String()
  1987.     {
  1988.         return $this->format(static::RFC822);
  1989.     }
  1991.     /**
  1992.      * Convert the instance to UTC and return as Zulu ISO8601
  1993.      *
  1994.      * @return string
  1995.      */
  1996.     public function toIso8601ZuluString()
  1997.     {
  1998.         return $this->copy()->setTimezone('UTC')->format('Y-m-d\TH:i:s\Z');
  1999.     }
  2001.     /**
  2002.      * Format the instance as RFC850
  2003.      *
  2004.      * @return string
  2005.      */
  2006.     public function toRfc850String()
  2007.     {
  2008.         return $this->format(static::RFC850);
  2009.     }
  2011.     /**
  2012.      * Format the instance as RFC1036
  2013.      *
  2014.      * @return string
  2015.      */
  2016.     public function toRfc1036String()
  2017.     {
  2018.         return $this->format(static::RFC1036);
  2019.     }
  2021.     /**
  2022.      * Format the instance as RFC1123
  2023.      *
  2024.      * @return string
  2025.      */
  2026.     public function toRfc1123String()
  2027.     {
  2028.         return $this->format(static::RFC1123);
  2029.     }
  2031.     /**
  2032.      * Format the instance as RFC2822
  2033.      *
  2034.      * @return string
  2035.      */
  2036.     public function toRfc2822String()
  2037.     {
  2038.         return $this->format(static::RFC2822);
  2039.     }
  2041.     /**
  2042.      * Format the instance as RFC3339
  2043.      *
  2044.      * @return string
  2045.      */
  2046.     public function toRfc3339String()
  2047.     {
  2048.         return $this->format(static::RFC3339);
  2049.     }
  2051.     /**
  2052.      * Format the instance as RSS
  2053.      *
  2054.      * @return string
  2055.      */
  2056.     public function toRssString()
  2057.     {
  2058.         return $this->format(static::RSS);
  2059.     }
  2061.     /**
  2062.      * Format the instance as W3C
  2063.      *
  2064.      * @return string
  2065.      */
  2066.     public function toW3cString()
  2067.     {
  2068.         return $this->format(static::W3C);
  2069.     }
  2071.     /**
  2072.      * Format the instance as RFC7231
  2073.      *
  2074.      * @return string
  2075.      */
  2076.     public function toRfc7231String()
  2077.     {
  2078.         return $this->copy()
  2079.             ->setTimezone('GMT')
  2080.             ->format(static::RFC7231_FORMAT);
  2081.     }
  2083.     /**
  2084.      * Get default array representation
  2085.      *
  2086.      * @return array
  2087.      */
  2088.     public function toArray()
  2089.     {
  2090.         return array(
  2091.             'year' => $this->year,
  2092.             'month' => $this->month,
  2093.             'day' => $this->day,
  2094.             'dayOfWeek' => $this->dayOfWeek,
  2095.             'dayOfYear' => $this->dayOfYear,
  2096.             'hour' => $this->hour,
  2097.             'minute' => $this->minute,
  2098.             'second' => $this->second,
  2099.             'micro' => $this->micro,
  2100.             'timestamp' => $this->timestamp,
  2101.             'formatted' => $this->format(self::DEFAULT_TO_STRING_FORMAT),
  2102.             'timezone' => $this->timezone,
  2103.         );
  2104.     }
  2106.     /**
  2107.      * Get default object representation.
  2108.      *
  2109.      * @example
  2110.      * ```
  2111.      * var_dump(Carbon::now()->toObject());
  2112.      * ```
  2113.      *
  2114.      * @return object
  2115.      */
  2116.     public function toObject()
  2117.     {
  2118.         return (object) $this->toArray();
  2119.     }
  2121.     /**
  2122.      * Returns english human readable complete date string.
  2123.      *
  2124.      * @example
  2125.      * ```
  2126.      * echo Carbon::now()->toString();
  2127.      * ```
  2128.      *
  2129.      * @return string
  2130.      */
  2131.     public function toString()
  2132.     {
  2133.         return $this->format('D M j Y H:i:s \G\M\TO');
  2134.     }
  2136.     /**
  2137.      * Return the ISO-8601 string (ex: 1977-04-22T06:00:00Z, if $keepOffset truthy, offset will be kept:
  2138.      * 1977-04-22T01:00:00-05:00).
  2139.      *
  2140.      * @example
  2141.      * ```
  2142.      * echo Carbon::now('America/Toronto')->toISOString() . "\n";
  2143.      * echo Carbon::now('America/Toronto')->toISOString(true) . "\n";
  2144.      * ```
  2145.      *
  2146.      * @param bool $keepOffset Pass true to keep the date offset. Else forced to UTC.
  2147.      *
  2148.      * @return null|string
  2149.      */
  2150.     public function toISOString($keepOffset = false)
  2151.     {
  2152.         if ($this->year === 0) {
  2153.             return null;
  2154.         }
  2156.         $year = $this->year < 0 || $this->year > 9999
  2157.             ? ($this->year < 0 ? '-' : '+').str_pad(abs($this->year), 6, '0', STR_PAD_LEFT)
  2158.             : str_pad($this->year, 4, '0', STR_PAD_LEFT);
  2159.         $tz = $keepOffset ? $this->format('P') : 'Z';
  2160.         $date = $keepOffset ? $this : $this->copy()->setTimezone('UTC');
  2162.         return $year.$date->format('-m-d\TH:i:s.u').$tz;
  2163.     }
  2165.     /**
  2166.      * Return the ISO-8601 string (ex: 1977-04-22T06:00:00Z) with UTC timezone.
  2167.      *
  2168.      * @example
  2169.      * ```
  2170.      * echo Carbon::now('America/Toronto')->toJSON();
  2171.      * ```
  2172.      *
  2173.      * @return null|string
  2174.      */
  2175.     public function toJSON()
  2176.     {
  2177.         return $this->toISOString();
  2178.     }
  2180.     /**
  2181.      * Return native DateTime PHP object matching the current instance.
  2182.      *
  2183.      * @example
  2184.      * ```
  2185.      * var_dump(Carbon::now()->toDateTime());
  2186.      * ```
  2187.      *
  2188.      * @return DateTime
  2189.      */
  2190.     public function toDateTime()
  2191.     {
  2192.         return new DateTime($this->format('Y-m-d H:i:s.u'), $this->getTimezone());
  2193.     }
  2195.     /**
  2196.      * @alias toDateTime
  2197.      *
  2198.      * Return native DateTime PHP object matching the current instance.
  2199.      *
  2200.      * @example
  2201.      * ```
  2202.      * var_dump(Carbon::now()->toDate());
  2203.      * ```
  2204.      *
  2205.      * @return DateTime
  2206.      */
  2207.     public function toDate()
  2208.     {
  2209.         return $this->toDateTime();
  2210.     }
  2212.     ///////////////////////////////////////////////////////////////////
  2213.     ////////////////////////// COMPARISONS ////////////////////////////
  2214.     ///////////////////////////////////////////////////////////////////
  2216.     /**
  2217.      * Determines if the instance is equal to another
  2218.      *
  2219.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2220.      *
  2221.      * @return bool
  2222.      */
  2223.     public function eq($date)
  2224.     {
  2225.         return $this == $date;
  2226.     }
  2228.     /**
  2229.      * Determines if the instance is equal to another
  2230.      *
  2231.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2232.      *
  2233.      * @see eq()
  2234.      *
  2235.      * @return bool
  2236.      */
  2237.     public function equalTo($date)
  2238.     {
  2239.         return $this->eq($date);
  2240.     }
  2242.     /**
  2243.      * Determines if the instance is not equal to another
  2244.      *
  2245.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2246.      *
  2247.      * @return bool
  2248.      */
  2249.     public function ne($date)
  2250.     {
  2251.         return !$this->eq($date);
  2252.     }
  2254.     /**
  2255.      * Determines if the instance is not equal to another
  2256.      *
  2257.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2258.      *
  2259.      * @see ne()
  2260.      *
  2261.      * @return bool
  2262.      */
  2263.     public function notEqualTo($date)
  2264.     {
  2265.         return $this->ne($date);
  2266.     }
  2268.     /**
  2269.      * Determines if the instance is greater (after) than another
  2270.      *
  2271.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2272.      *
  2273.      * @return bool
  2274.      */
  2275.     public function gt($date)
  2276.     {
  2277.         return $this > $date;
  2278.     }
  2280.     /**
  2281.      * Determines if the instance is greater (after) than another
  2282.      *
  2283.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2284.      *
  2285.      * @see gt()
  2286.      *
  2287.      * @return bool
  2288.      */
  2289.     public function greaterThan($date)
  2290.     {
  2291.         return $this->gt($date);
  2292.     }
  2294.     /**
  2295.      * Determines if the instance is greater (after) than another
  2296.      *
  2297.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2298.      *
  2299.      * @see gt()
  2300.      *
  2301.      * @return bool
  2302.      */
  2303.     public function isAfter($date)
  2304.     {
  2305.         return $this->gt($date);
  2306.     }
  2308.     /**
  2309.      * Determines if the instance is greater (after) than or equal to another
  2310.      *
  2311.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2312.      *
  2313.      * @return bool
  2314.      */
  2315.     public function gte($date)
  2316.     {
  2317.         return $this >= $date;
  2318.     }
  2320.     /**
  2321.      * Determines if the instance is greater (after) than or equal to another
  2322.      *
  2323.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2324.      *
  2325.      * @see gte()
  2326.      *
  2327.      * @return bool
  2328.      */
  2329.     public function greaterThanOrEqualTo($date)
  2330.     {
  2331.         return $this->gte($date);
  2332.     }
  2334.     /**
  2335.      * Determines if the instance is less (before) than another
  2336.      *
  2337.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2338.      *
  2339.      * @return bool
  2340.      */
  2341.     public function lt($date)
  2342.     {
  2343.         return $this < $date;
  2344.     }
  2346.     /**
  2347.      * Determines if the instance is less (before) than another
  2348.      *
  2349.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2350.      *
  2351.      * @see lt()
  2352.      *
  2353.      * @return bool
  2354.      */
  2355.     public function lessThan($date)
  2356.     {
  2357.         return $this->lt($date);
  2358.     }
  2360.     /**
  2361.      * Determines if the instance is less (before) than another
  2362.      *
  2363.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2364.      *
  2365.      * @see lt()
  2366.      *
  2367.      * @return bool
  2368.      */
  2369.     public function isBefore($date)
  2370.     {
  2371.         return $this->lt($date);
  2372.     }
  2374.     /**
  2375.      * Determines if the instance is less (before) or equal to another
  2376.      *
  2377.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2378.      *
  2379.      * @return bool
  2380.      */
  2381.     public function lte($date)
  2382.     {
  2383.         return $this <= $date;
  2384.     }
  2386.     /**
  2387.      * Determines if the instance is less (before) or equal to another
  2388.      *
  2389.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2390.      *
  2391.      * @see lte()
  2392.      *
  2393.      * @return bool
  2394.      */
  2395.     public function lessThanOrEqualTo($date)
  2396.     {
  2397.         return $this->lte($date);
  2398.     }
  2400.     /**
  2401.      * Determines if the instance is between two others
  2402.      *
  2403.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date1
  2404.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date2
  2405.      * @param bool                                    $equal Indicates if an equal to comparison should be done
  2406.      *
  2407.      * @return bool
  2408.      */
  2409.     public function between($date1, $date2, $equal = true)
  2410.     {
  2411.         if ($date1->gt($date2)) {
  2412.             $temp = $date1;
  2413.             $date1 = $date2;
  2414.             $date2 = $temp;
  2415.         }
  2417.         if ($equal) {
  2418.             return $this->gte($date1) && $this->lte($date2);
  2419.         }
  2421.         return $this->gt($date1) && $this->lt($date2);
  2422.     }
  2424.     protected function floatDiffInSeconds($date)
  2425.     {
  2426.         $date = $this->resolveCarbon($date);
  2428.         return abs($this->diffInRealSeconds($date, false) + ($date->micro - $this->micro) / 1000000);
  2429.     }
  2431.     /**
  2432.      * Determines if the instance is between two others
  2433.      *
  2434.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date1
  2435.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date2
  2436.      * @param bool                                    $equal Indicates if a > and < comparison should be used or <= or >=
  2437.      *
  2438.      * @return bool
  2439.      */
  2440.     public function isBetween($date1, $date2, $equal = true)
  2441.     {
  2442.         return $this->between($date1, $date2, $equal);
  2443.     }
  2445.     /**
  2446.      * Get the closest date from the instance.
  2447.      *
  2448.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date1
  2449.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date2
  2450.      *
  2451.      * @return static
  2452.      */
  2453.     public function closest($date1, $date2)
  2454.     {
  2455.         return $this->floatDiffInSeconds($date1) < $this->floatDiffInSeconds($date2) ? $date1 : $date2;
  2456.     }
  2458.     /**
  2459.      * Get the farthest date from the instance.
  2460.      *
  2461.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date1
  2462.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date2
  2463.      *
  2464.      * @return static
  2465.      */
  2466.     public function farthest($date1, $date2)
  2467.     {
  2468.         return $this->floatDiffInSeconds($date1) > $this->floatDiffInSeconds($date2) ? $date1 : $date2;
  2469.     }
  2471.     /**
  2472.      * Get the minimum instance between a given instance (default now) and the current instance.
  2473.      *
  2474.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  2475.      *
  2476.      * @return static
  2477.      */
  2478.     public function min($date = null)
  2479.     {
  2480.         $date = $this->resolveCarbon($date);
  2482.         return $this->lt($date) ? $this : $date;
  2483.     }
  2485.     /**
  2486.      * Get the minimum instance between a given instance (default now) and the current instance.
  2487.      *
  2488.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2489.      *
  2490.      * @see min()
  2491.      *
  2492.      * @return static
  2493.      */
  2494.     public function minimum($date = null)
  2495.     {
  2496.         return $this->min($date);
  2497.     }
  2499.     /**
  2500.      * Get the maximum instance between a given instance (default now) and the current instance.
  2501.      *
  2502.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  2503.      *
  2504.      * @return static
  2505.      */
  2506.     public function max($date = null)
  2507.     {
  2508.         $date = $this->resolveCarbon($date);
  2510.         return $this->gt($date) ? $this : $date;
  2511.     }
  2513.     /**
  2514.      * Get the maximum instance between a given instance (default now) and the current instance.
  2515.      *
  2516.      * @param \Carbon\Carbon|\DateTimeInterface|mixed $date
  2517.      *
  2518.      * @see max()
  2519.      *
  2520.      * @return static
  2521.      */
  2522.     public function maximum($date = null)
  2523.     {
  2524.         return $this->max($date);
  2525.     }
  2527.     /**
  2528.      * Determines if the instance is a weekday.
  2529.      *
  2530.      * @return bool
  2531.      */
  2532.     public function isWeekday()
  2533.     {
  2534.         return !$this->isWeekend();
  2535.     }
  2537.     /**
  2538.      * Determines if the instance is a weekend day.
  2539.      *
  2540.      * @return bool
  2541.      */
  2542.     public function isWeekend()
  2543.     {
  2544.         return in_array($this->dayOfWeek, static::$weekendDays);
  2545.     }
  2547.     /**
  2548.      * Determines if the instance is yesterday.
  2549.      *
  2550.      * @return bool
  2551.      */
  2552.     public function isYesterday()
  2553.     {
  2554.         return $this->toDateString() === static::yesterday($this->getTimezone())->toDateString();
  2555.     }
  2557.     /**
  2558.      * Determines if the instance is today.
  2559.      *
  2560.      * @return bool
  2561.      */
  2562.     public function isToday()
  2563.     {
  2564.         return $this->toDateString() === $this->nowWithSameTz()->toDateString();
  2565.     }
  2567.     /**
  2568.      * Determines if the instance is tomorrow.
  2569.      *
  2570.      * @return bool
  2571.      */
  2572.     public function isTomorrow()
  2573.     {
  2574.         return $this->toDateString() === static::tomorrow($this->getTimezone())->toDateString();
  2575.     }
  2577.     /**
  2578.      * Determines if the instance is within the next week.
  2579.      *
  2580.      * @return bool
  2581.      */
  2582.     public function isNextWeek()
  2583.     {
  2584.         return $this->weekOfYear === $this->nowWithSameTz()->addWeek()->weekOfYear;
  2585.     }
  2587.     /**
  2588.      * Determines if the instance is within the last week.
  2589.      *
  2590.      * @return bool
  2591.      */
  2592.     public function isLastWeek()
  2593.     {
  2594.         return $this->weekOfYear === $this->nowWithSameTz()->subWeek()->weekOfYear;
  2595.     }
  2597.     /**
  2598.      * Determines if the instance is within the next quarter.
  2599.      *
  2600.      * @return bool
  2601.      */
  2602.     public function isNextQuarter()
  2603.     {
  2604.         return $this->quarter === $this->nowWithSameTz()->addQuarter()->quarter;
  2605.     }
  2607.     /**
  2608.      * Determines if the instance is within the last quarter.
  2609.      *
  2610.      * @return bool
  2611.      */
  2612.     public function isLastQuarter()
  2613.     {
  2614.         return $this->quarter === $this->nowWithSameTz()->subQuarter()->quarter;
  2615.     }
  2617.     /**
  2618.      * Determines if the instance is within the next month.
  2619.      *
  2620.      * @return bool
  2621.      */
  2622.     public function isNextMonth()
  2623.     {
  2624.         return $this->month === $this->nowWithSameTz()->addMonthNoOverflow()->month;
  2625.     }
  2627.     /**
  2628.      * Determines if the instance is within the last month.
  2629.      *
  2630.      * @return bool
  2631.      */
  2632.     public function isLastMonth()
  2633.     {
  2634.         return $this->month === $this->nowWithSameTz()->subMonthNoOverflow()->month;
  2635.     }
  2637.     /**
  2638.      * Determines if the instance is within next year.
  2639.      *
  2640.      * @return bool
  2641.      */
  2642.     public function isNextYear()
  2643.     {
  2644.         return $this->year === $this->nowWithSameTz()->addYear()->year;
  2645.     }
  2647.     /**
  2648.      * Determines if the instance is within the previous year.
  2649.      *
  2650.      * @return bool
  2651.      */
  2652.     public function isLastYear()
  2653.     {
  2654.         return $this->year === $this->nowWithSameTz()->subYear()->year;
  2655.     }
  2657.     /**
  2658.      * Determines if the instance is in the future, ie. greater (after) than now.
  2659.      *
  2660.      * @return bool
  2661.      */
  2662.     public function isFuture()
  2663.     {
  2664.         return $this->gt($this->nowWithSameTz());
  2665.     }
  2667.     /**
  2668.      * Determines if the instance is in the past, ie. less (before) than now.
  2669.      *
  2670.      * @return bool
  2671.      */
  2672.     public function isPast()
  2673.     {
  2674.         return $this->lt($this->nowWithSameTz());
  2675.     }
  2677.     /**
  2678.      * Determines if the instance is a leap year.
  2679.      *
  2680.      * @return bool
  2681.      */
  2682.     public function isLeapYear()
  2683.     {
  2684.         return $this->format('L') === '1';
  2685.     }
  2687.     /**
  2688.      * Determines if the instance is a long year
  2689.      *
  2690.      * @see https://en.wikipedia.org/wiki/ISO_8601#Week_dates
  2691.      *
  2692.      * @return bool
  2693.      */
  2694.     public function isLongYear()
  2695.     {
  2696.         return static::create($this->year, 12, 28, 0, 0, 0, $this->tz)->weekOfYear === 53;
  2697.     }
  2699.     /**
  2700.      * Compares the formatted values of the two dates.
  2701.      *
  2702.      * @param string                                 $format The date formats to compare.
  2703.      * @param \Carbon\Carbon|\DateTimeInterface|null $date   The instance to compare with or null to use current day.
  2704.      *
  2705.      * @throws \InvalidArgumentException
  2706.      *
  2707.      * @return bool
  2708.      */
  2709.     public function isSameAs($format, $date = null)
  2710.     {
  2711.         $date = $date ?: static::now($this->tz);
  2713.         static::expectDateTime($date, 'null');
  2715.         return $this->format($format) === $date->format($format);
  2716.     }
  2718.     /**
  2719.      * Determines if the instance is in the current year.
  2720.      *
  2721.      * @return bool
  2722.      */
  2723.     public function isCurrentYear()
  2724.     {
  2725.         return $this->isSameYear();
  2726.     }
  2728.     /**
  2729.      * Checks if the passed in date is in the same year as the instance year.
  2730.      *
  2731.      * @param \Carbon\Carbon|\DateTimeInterface|null $date The instance to compare with or null to use current day.
  2732.      *
  2733.      * @return bool
  2734.      */
  2735.     public function isSameYear($date = null)
  2736.     {
  2737.         return $this->isSameAs('Y', $date);
  2738.     }
  2740.     /**
  2741.      * Determines if the instance is in the current month.
  2742.      *
  2743.      * @return bool
  2744.      */
  2745.     public function isCurrentQuarter()
  2746.     {
  2747.         return $this->isSameQuarter();
  2748.     }
  2750.     /**
  2751.      * Checks if the passed in date is in the same quarter as the instance quarter (and year if needed).
  2752.      *
  2753.      * @param \Carbon\Carbon|\DateTimeInterface|null $date       The instance to compare with or null to use current day.
  2754.      * @param bool                                   $ofSameYear Check if it is the same month in the same year.
  2755.      *
  2756.      * @return bool
  2757.      */
  2758.     public function isSameQuarter($date = null, $ofSameYear = null)
  2759.     {
  2760.         $date = $date ? static::instance($date) : static::now($this->tz);
  2762.         static::expectDateTime($date, 'null');
  2764.         $ofSameYear = is_null($ofSameYear) ? static::shouldCompareYearWithMonth() : $ofSameYear;
  2766.         return $this->quarter === $date->quarter && (!$ofSameYear || $this->isSameYear($date));
  2767.     }
  2769.     /**
  2770.      * Determines if the instance is in the current month.
  2771.      *
  2772.      * @param bool $ofSameYear Check if it is the same month in the same year.
  2773.      *
  2774.      * @return bool
  2775.      */
  2776.     public function isCurrentMonth($ofSameYear = null)
  2777.     {
  2778.         return $this->isSameMonth(null, $ofSameYear);
  2779.     }
  2781.     /**
  2782.      * Checks if the passed in date is in the same month as the instance´s month.
  2783.      *
  2784.      * Note that this defaults to only comparing the month while ignoring the year.
  2785.      * To test if it is the same exact month of the same year, pass in true as the second parameter.
  2786.      *
  2787.      * @param \Carbon\Carbon|\DateTimeInterface|null $date       The instance to compare with or null to use the current date.
  2788.      * @param bool                                   $ofSameYear Check if it is the same month in the same year.
  2789.      *
  2790.      * @return bool
  2791.      */
  2792.     public function isSameMonth($date = null, $ofSameYear = null)
  2793.     {
  2794.         $ofSameYear = is_null($ofSameYear) ? static::shouldCompareYearWithMonth() : $ofSameYear;
  2796.         return $this->isSameAs($ofSameYear ? 'Y-m' : 'm', $date);
  2797.     }
  2799.     /**
  2800.      * Determines if the instance is in the current day.
  2801.      *
  2802.      * @return bool
  2803.      */
  2804.     public function isCurrentDay()
  2805.     {
  2806.         return $this->isSameDay();
  2807.     }
  2809.     /**
  2810.      * Checks if the passed in date is the same exact day as the instance´s day.
  2811.      *
  2812.      * @param \Carbon\Carbon|\DateTimeInterface|null $date The instance to compare with or null to use the current date.
  2813.      *
  2814.      * @return bool
  2815.      */
  2816.     public function isSameDay($date = null)
  2817.     {
  2818.         return $this->isSameAs('Y-m-d', $date);
  2819.     }
  2821.     /**
  2822.      * Determines if the instance is in the current hour.
  2823.      *
  2824.      * @return bool
  2825.      */
  2826.     public function isCurrentHour()
  2827.     {
  2828.         return $this->isSameHour();
  2829.     }
  2831.     /**
  2832.      * Checks if the passed in date is the same exact hour as the instance´s hour.
  2833.      *
  2834.      * @param \Carbon\Carbon|\DateTimeInterface|null $date The instance to compare with or null to use the current date.
  2835.      *
  2836.      * @return bool
  2837.      */
  2838.     public function isSameHour($date = null)
  2839.     {
  2840.         return $this->isSameAs('Y-m-d H', $date);
  2841.     }
  2843.     /**
  2844.      * Determines if the instance is in the current minute.
  2845.      *
  2846.      * @return bool
  2847.      */
  2848.     public function isCurrentMinute()
  2849.     {
  2850.         return $this->isSameMinute();
  2851.     }
  2853.     /**
  2854.      * Checks if the passed in date is the same exact minute as the instance´s minute.
  2855.      *
  2856.      * @param \Carbon\Carbon|\DateTimeInterface|null $date The instance to compare with or null to use the current date.
  2857.      *
  2858.      * @return bool
  2859.      */
  2860.     public function isSameMinute($date = null)
  2861.     {
  2862.         return $this->isSameAs('Y-m-d H:i', $date);
  2863.     }
  2865.     /**
  2866.      * Determines if the instance is in the current second.
  2867.      *
  2868.      * @return bool
  2869.      */
  2870.     public function isCurrentSecond()
  2871.     {
  2872.         return $this->isSameSecond();
  2873.     }
  2875.     /**
  2876.      * Checks if the passed in date is the same exact second as the instance´s second.
  2877.      *
  2878.      * @param \Carbon\Carbon|\DateTimeInterface|null $date The instance to compare with or null to use the current date.
  2879.      *
  2880.      * @return bool
  2881.      */
  2882.     public function isSameSecond($date = null)
  2883.     {
  2884.         return $this->isSameAs('Y-m-d H:i:s', $date);
  2885.     }
  2887.     /**
  2888.      * Checks if this day is a specific day of the week.
  2889.      *
  2890.      * @param int $dayOfWeek
  2891.      *
  2892.      * @return bool
  2893.      */
  2894.     public function isDayOfWeek($dayOfWeek)
  2895.     {
  2896.         return $this->dayOfWeek === $dayOfWeek;
  2897.     }
  2899.     /**
  2900.      * Checks if this day is a Sunday.
  2901.      *
  2902.      * @return bool
  2903.      */
  2904.     public function isSunday()
  2905.     {
  2906.         return $this->dayOfWeek === static::SUNDAY;
  2907.     }
  2909.     /**
  2910.      * Checks if this day is a Monday.
  2911.      *
  2912.      * @return bool
  2913.      */
  2914.     public function isMonday()
  2915.     {
  2916.         return $this->dayOfWeek === static::MONDAY;
  2917.     }
  2919.     /**
  2920.      * Checks if this day is a Tuesday.
  2921.      *
  2922.      * @return bool
  2923.      */
  2924.     public function isTuesday()
  2925.     {
  2926.         return $this->dayOfWeek === static::TUESDAY;
  2927.     }
  2929.     /**
  2930.      * Checks if this day is a Wednesday.
  2931.      *
  2932.      * @return bool
  2933.      */
  2934.     public function isWednesday()
  2935.     {
  2936.         return $this->dayOfWeek === static::WEDNESDAY;
  2937.     }
  2939.     /**
  2940.      * Checks if this day is a Thursday.
  2941.      *
  2942.      * @return bool
  2943.      */
  2944.     public function isThursday()
  2945.     {
  2946.         return $this->dayOfWeek === static::THURSDAY;
  2947.     }
  2949.     /**
  2950.      * Checks if this day is a Friday.
  2951.      *
  2952.      * @return bool
  2953.      */
  2954.     public function isFriday()
  2955.     {
  2956.         return $this->dayOfWeek === static::FRIDAY;
  2957.     }
  2959.     /**
  2960.      * Checks if this day is a Saturday.
  2961.      *
  2962.      * @return bool
  2963.      */
  2964.     public function isSaturday()
  2965.     {
  2966.         return $this->dayOfWeek === static::SATURDAY;
  2967.     }
  2969.     /**
  2970.      * Check if its the birthday. Compares the date/month values of the two dates.
  2971.      *
  2972.      * @param \Carbon\Carbon|\DateTimeInterface|null $date The instance to compare with or null to use current day.
  2973.      *
  2974.      * @return bool
  2975.      */
  2976.     public function isBirthday($date = null)
  2977.     {
  2978.         return $this->isSameAs('md', $date);
  2979.     }
  2981.     /**
  2982.      * Check if today is the last day of the Month
  2983.      *
  2984.      * @return bool
  2985.      */
  2986.     public function isLastOfMonth()
  2987.     {
  2988.         return $this->day === $this->daysInMonth;
  2989.     }
  2991.     /**
  2992.      * Check if the instance is start of day / midnight.
  2993.      *
  2994.      * @param bool $checkMicroseconds check time at microseconds precision
  2995.      *                                /!\ Warning, this is not reliable with PHP < 7.1.4
  2996.      *
  2997.      * @return bool
  2998.      */
  2999.     public function isStartOfDay($checkMicroseconds = false)
  3000.     {
  3001.         return $checkMicroseconds
  3002.             ? $this->format('H:i:s.u') === '00:00:00.000000'
  3003.             : $this->format('H:i:s') === '00:00:00';
  3004.     }
  3006.     /**
  3007.      * Check if the instance is end of day.
  3008.      *
  3009.      * @param bool $checkMicroseconds check time at microseconds precision
  3010.      *                                /!\ Warning, this is not reliable with PHP < 7.1.4
  3011.      *
  3012.      * @return bool
  3013.      */
  3014.     public function isEndOfDay($checkMicroseconds = false)
  3015.     {
  3016.         return $checkMicroseconds
  3017.             ? $this->format('H:i:s.u') === '23:59:59.999999'
  3018.             : $this->format('H:i:s') === '23:59:59';
  3019.     }
  3021.     /**
  3022.      * Check if the instance is start of day / midnight.
  3023.      *
  3024.      * @return bool
  3025.      */
  3026.     public function isMidnight()
  3027.     {
  3028.         return $this->isStartOfDay();
  3029.     }
  3031.     /**
  3032.      * Check if the instance is midday.
  3033.      *
  3034.      * @return bool
  3035.      */
  3036.     public function isMidday()
  3037.     {
  3038.         return $this->format('G:i:s') === static::$midDayAt.':00:00';
  3039.     }
  3041.     /**
  3042.      * Checks if the (date)time string is in a given format.
  3043.      *
  3044.      * @param string $date
  3045.      * @param string $format
  3046.      *
  3047.      * @return bool
  3048.      */
  3049.     public static function hasFormat($date, $format)
  3050.     {
  3051.         try {
  3052.             // Try to create a DateTime object. Throws an InvalidArgumentException if the provided time string
  3053.             // doesn't match the format in any way.
  3054.             static::createFromFormat($format, $date);
  3056.             // createFromFormat() is known to handle edge cases silently.
  3057.             // E.g. "1975-5-1" (Y-n-j) will still be parsed correctly when "Y-m-d" is supplied as the format.
  3058.             // To ensure we're really testing against our desired format, perform an additional regex validation.
  3059.             $regex = strtr(
  3060.                 preg_quote($format, '/'),
  3061.                 static::$regexFormats
  3062.             );
  3064.             return (bool) preg_match('/^'.$regex.'$/', $date);
  3065.         } catch (InvalidArgumentException $e) {
  3066.         }
  3068.         return false;
  3069.     }
  3071.     ///////////////////////////////////////////////////////////////////
  3072.     /////////////////// ADDITIONS AND SUBTRACTIONS ////////////////////
  3073.     ///////////////////////////////////////////////////////////////////
  3075.     /**
  3076.      * Add centuries to the instance. Positive $value travels forward while
  3077.      * negative $value travels into the past.
  3078.      *
  3079.      * @param int $value
  3080.      *
  3081.      * @return static
  3082.      */
  3083.     public function addCenturies($value)
  3084.     {
  3085.         return $this->addYears(static::YEARS_PER_CENTURY * $value);
  3086.     }
  3088.     /**
  3089.      * Add a century to the instance
  3090.      *
  3091.      * @param int $value
  3092.      *
  3093.      * @return static
  3094.      */
  3095.     public function addCentury($value = 1)
  3096.     {
  3097.         return $this->addCenturies($value);
  3098.     }
  3100.     /**
  3101.      * Remove centuries from the instance
  3102.      *
  3103.      * @param int $value
  3104.      *
  3105.      * @return static
  3106.      */
  3107.     public function subCenturies($value)
  3108.     {
  3109.         return $this->addCenturies(-1 * $value);
  3110.     }
  3112.     /**
  3113.      * Remove a century from the instance
  3114.      *
  3115.      * @param int $value
  3116.      *
  3117.      * @return static
  3118.      */
  3119.     public function subCentury($value = 1)
  3120.     {
  3121.         return $this->subCenturies($value);
  3122.     }
  3124.     /**
  3125.      * Add years to the instance. Positive $value travel forward while
  3126.      * negative $value travel into the past.
  3127.      *
  3128.      * @param int $value
  3129.      *
  3130.      * @return static
  3131.      */
  3132.     public function addYears($value)
  3133.     {
  3134.         if ($this->shouldOverflowYears()) {
  3135.             return $this->addYearsWithOverflow($value);
  3136.         }
  3138.         return $this->addYearsNoOverflow($value);
  3139.     }
  3141.     /**
  3142.      * Add a year to the instance
  3143.      *
  3144.      * @param int $value
  3145.      *
  3146.      * @return static
  3147.      */
  3148.     public function addYear($value = 1)
  3149.     {
  3150.         return $this->addYears($value);
  3151.     }
  3153.     /**
  3154.      * Add years to the instance with no overflow of months
  3155.      * Positive $value travel forward while
  3156.      * negative $value travel into the past.
  3157.      *
  3158.      * @param int $value
  3159.      *
  3160.      * @return static
  3161.      */
  3162.     public function addYearsNoOverflow($value)
  3163.     {
  3164.         return $this->addMonthsNoOverflow($value * static::MONTHS_PER_YEAR);
  3165.     }
  3167.     /**
  3168.      * Add year with overflow months set to false
  3169.      *
  3170.      * @param int $value
  3171.      *
  3172.      * @return static
  3173.      */
  3174.     public function addYearNoOverflow($value = 1)
  3175.     {
  3176.         return $this->addYearsNoOverflow($value);
  3177.     }
  3179.     /**
  3180.      * Add years to the instance.
  3181.      * Positive $value travel forward while
  3182.      * negative $value travel into the past.
  3183.      *
  3184.      * @param int $value
  3185.      *
  3186.      * @return static
  3187.      */
  3188.     public function addYearsWithOverflow($value)
  3189.     {
  3190.         return $this->modify((int) $value.' year');
  3191.     }
  3193.     /**
  3194.      * Add year with overflow.
  3195.      *
  3196.      * @param int $value
  3197.      *
  3198.      * @return static
  3199.      */
  3200.     public function addYearWithOverflow($value = 1)
  3201.     {
  3202.         return $this->addYearsWithOverflow($value);
  3203.     }
  3205.     /**
  3206.      * Remove years from the instance.
  3207.      *
  3208.      * @param int $value
  3209.      *
  3210.      * @return static
  3211.      */
  3212.     public function subYears($value)
  3213.     {
  3214.         return $this->addYears(-1 * $value);
  3215.     }
  3217.     /**
  3218.      * Remove a year from the instance
  3219.      *
  3220.      * @param int $value
  3221.      *
  3222.      * @return static
  3223.      */
  3224.     public function subYear($value = 1)
  3225.     {
  3226.         return $this->subYears($value);
  3227.     }
  3229.     /**
  3230.      * Remove years from the instance with no month overflow.
  3231.      *
  3232.      * @param int $value
  3233.      *
  3234.      * @return static
  3235.      */
  3236.     public function subYearsNoOverflow($value)
  3237.     {
  3238.         return $this->subMonthsNoOverflow($value * static::MONTHS_PER_YEAR);
  3239.     }
  3241.     /**
  3242.      * Remove year from the instance with no month overflow
  3243.      *
  3244.      * @param int $value
  3245.      *
  3246.      * @return static
  3247.      */
  3248.     public function subYearNoOverflow($value = 1)
  3249.     {
  3250.         return $this->subYearsNoOverflow($value);
  3251.     }
  3253.     /**
  3254.      * Remove years from the instance.
  3255.      *
  3256.      * @param int $value
  3257.      *
  3258.      * @return static
  3259.      */
  3260.     public function subYearsWithOverflow($value)
  3261.     {
  3262.         return $this->subMonthsWithOverflow($value * static::MONTHS_PER_YEAR);
  3263.     }
  3265.     /**
  3266.      * Remove year from the instance.
  3267.      *
  3268.      * @param int $value
  3269.      *
  3270.      * @return static
  3271.      */
  3272.     public function subYearWithOverflow($value = 1)
  3273.     {
  3274.         return $this->subYearsWithOverflow($value);
  3275.     }
  3277.     /**
  3278.      * Add quarters to the instance. Positive $value travels forward while
  3279.      * negative $value travels into the past.
  3280.      *
  3281.      * @param int $value
  3282.      *
  3283.      * @return static
  3284.      */
  3285.     public function addQuarters($value)
  3286.     {
  3287.         return $this->addMonths(static::MONTHS_PER_QUARTER * $value);
  3288.     }
  3290.     /**
  3291.      * Add a quarter to the instance
  3292.      *
  3293.      * @param int $value
  3294.      *
  3295.      * @return static
  3296.      */
  3297.     public function addQuarter($value = 1)
  3298.     {
  3299.         return $this->addQuarters($value);
  3300.     }
  3302.     /**
  3303.      * Remove quarters from the instance
  3304.      *
  3305.      * @param int $value
  3306.      *
  3307.      * @return static
  3308.      */
  3309.     public function subQuarters($value)
  3310.     {
  3311.         return $this->addQuarters(-1 * $value);
  3312.     }
  3314.     /**
  3315.      * Remove a quarter from the instance
  3316.      *
  3317.      * @param int $value
  3318.      *
  3319.      * @return static
  3320.      */
  3321.     public function subQuarter($value = 1)
  3322.     {
  3323.         return $this->subQuarters($value);
  3324.     }
  3326.     /**
  3327.      * Add months to the instance. Positive $value travels forward while
  3328.      * negative $value travels into the past.
  3329.      *
  3330.      * @param int $value
  3331.      *
  3332.      * @return static
  3333.      */
  3334.     public function addMonths($value)
  3335.     {
  3336.         if (static::shouldOverflowMonths()) {
  3337.             return $this->addMonthsWithOverflow($value);
  3338.         }
  3340.         return $this->addMonthsNoOverflow($value);
  3341.     }
  3343.     /**
  3344.      * Add a month to the instance
  3345.      *
  3346.      * @param int $value
  3347.      *
  3348.      * @return static
  3349.      */
  3350.     public function addMonth($value = 1)
  3351.     {
  3352.         return $this->addMonths($value);
  3353.     }
  3355.     /**
  3356.      * Remove months from the instance
  3357.      *
  3358.      * @param int $value
  3359.      *
  3360.      * @return static
  3361.      */
  3362.     public function subMonths($value)
  3363.     {
  3364.         return $this->addMonths(-1 * $value);
  3365.     }
  3367.     /**
  3368.      * Remove a month from the instance
  3369.      *
  3370.      * @param int $value
  3371.      *
  3372.      * @return static
  3373.      */
  3374.     public function subMonth($value = 1)
  3375.     {
  3376.         return $this->subMonths($value);
  3377.     }
  3379.     /**
  3380.      * Add months to the instance. Positive $value travels forward while
  3381.      * negative $value travels into the past.
  3382.      *
  3383.      * @param int $value
  3384.      *
  3385.      * @return static
  3386.      */
  3387.     public function addMonthsWithOverflow($value)
  3388.     {
  3389.         return $this->modify((int) $value.' month');
  3390.     }
  3392.     /**
  3393.      * Add a month to the instance
  3394.      *
  3395.      * @param int $value
  3396.      *
  3397.      * @return static
  3398.      */
  3399.     public function addMonthWithOverflow($value = 1)
  3400.     {
  3401.         return $this->addMonthsWithOverflow($value);
  3402.     }
  3404.     /**
  3405.      * Remove months from the instance
  3406.      *
  3407.      * @param int $value
  3408.      *
  3409.      * @return static
  3410.      */
  3411.     public function subMonthsWithOverflow($value)
  3412.     {
  3413.         return $this->addMonthsWithOverflow(-1 * $value);
  3414.     }
  3416.     /**
  3417.      * Remove a month from the instance
  3418.      *
  3419.      * @param int $value
  3420.      *
  3421.      * @return static
  3422.      */
  3423.     public function subMonthWithOverflow($value = 1)
  3424.     {
  3425.         return $this->subMonthsWithOverflow($value);
  3426.     }
  3428.     /**
  3429.      * Add months without overflowing to the instance. Positive $value
  3430.      * travels forward while negative $value travels into the past.
  3431.      *
  3432.      * @param int $value
  3433.      *
  3434.      * @return static
  3435.      */
  3436.     public function addMonthsNoOverflow($value)
  3437.     {
  3438.         $day = $this->day;
  3440.         $this->modify((int) $value.' month');
  3442.         if ($day !== $this->day) {
  3443.             $this->modify('last day of previous month');
  3444.         }
  3446.         return $this;
  3447.     }
  3449.     /**
  3450.      * Add a month with no overflow to the instance
  3451.      *
  3452.      * @param int $value
  3453.      *
  3454.      * @return static
  3455.      */
  3456.     public function addMonthNoOverflow($value = 1)
  3457.     {
  3458.         return $this->addMonthsNoOverflow($value);
  3459.     }
  3461.     /**
  3462.      * Remove months with no overflow from the instance
  3463.      *
  3464.      * @param int $value
  3465.      *
  3466.      * @return static
  3467.      */
  3468.     public function subMonthsNoOverflow($value)
  3469.     {
  3470.         return $this->addMonthsNoOverflow(-1 * $value);
  3471.     }
  3473.     /**
  3474.      * Remove a month with no overflow from the instance
  3475.      *
  3476.      * @param int $value
  3477.      *
  3478.      * @return static
  3479.      */
  3480.     public function subMonthNoOverflow($value = 1)
  3481.     {
  3482.         return $this->subMonthsNoOverflow($value);
  3483.     }
  3485.     /**
  3486.      * Add days to the instance. Positive $value travels forward while
  3487.      * negative $value travels into the past.
  3488.      *
  3489.      * @param int $value
  3490.      *
  3491.      * @return static
  3492.      */
  3493.     public function addDays($value)
  3494.     {
  3495.         return $this->modify((int) $value.' day');
  3496.     }
  3498.     /**
  3499.      * Add a day to the instance
  3500.      *
  3501.      * @param int $value
  3502.      *
  3503.      * @return static
  3504.      */
  3505.     public function addDay($value = 1)
  3506.     {
  3507.         return $this->addDays($value);
  3508.     }
  3510.     /**
  3511.      * Remove days from the instance
  3512.      *
  3513.      * @param int $value
  3514.      *
  3515.      * @return static
  3516.      */
  3517.     public function subDays($value)
  3518.     {
  3519.         return $this->addDays(-1 * $value);
  3520.     }
  3522.     /**
  3523.      * Remove a day from the instance
  3524.      *
  3525.      * @param int $value
  3526.      *
  3527.      * @return static
  3528.      */
  3529.     public function subDay($value = 1)
  3530.     {
  3531.         return $this->subDays($value);
  3532.     }
  3534.     /**
  3535.      * Add weekdays to the instance. Positive $value travels forward while
  3536.      * negative $value travels into the past.
  3537.      *
  3538.      * @param int $value
  3539.      *
  3540.      * @return static
  3541.      */
  3542.     public function addWeekdays($value)
  3543.     {
  3544.         // Fix for weekday bug https://bugs.php.net/bug.php?id=54909
  3545.         $t = $this->toTimeString();
  3546.         $this->modify((int) $value.' weekday');
  3548.         return $this->setTimeFromTimeString($t);
  3549.     }
  3551.     /**
  3552.      * Add a weekday to the instance
  3553.      *
  3554.      * @param int $value
  3555.      *
  3556.      * @return static
  3557.      */
  3558.     public function addWeekday($value = 1)
  3559.     {
  3560.         return $this->addWeekdays($value);
  3561.     }
  3563.     /**
  3564.      * Remove weekdays from the instance
  3565.      *
  3566.      * @param int $value
  3567.      *
  3568.      * @return static
  3569.      */
  3570.     public function subWeekdays($value)
  3571.     {
  3572.         return $this->addWeekdays(-1 * $value);
  3573.     }
  3575.     /**
  3576.      * Remove a weekday from the instance
  3577.      *
  3578.      * @param int $value
  3579.      *
  3580.      * @return static
  3581.      */
  3582.     public function subWeekday($value = 1)
  3583.     {
  3584.         return $this->subWeekdays($value);
  3585.     }
  3587.     /**
  3588.      * Add weeks to the instance. Positive $value travels forward while
  3589.      * negative $value travels into the past.
  3590.      *
  3591.      * @param int $value
  3592.      *
  3593.      * @return static
  3594.      */
  3595.     public function addWeeks($value)
  3596.     {
  3597.         return $this->modify((int) $value.' week');
  3598.     }
  3600.     /**
  3601.      * Add a week to the instance
  3602.      *
  3603.      * @param int $value
  3604.      *
  3605.      * @return static
  3606.      */
  3607.     public function addWeek($value = 1)
  3608.     {
  3609.         return $this->addWeeks($value);
  3610.     }
  3612.     /**
  3613.      * Remove weeks to the instance
  3614.      *
  3615.      * @param int $value
  3616.      *
  3617.      * @return static
  3618.      */
  3619.     public function subWeeks($value)
  3620.     {
  3621.         return $this->addWeeks(-1 * $value);
  3622.     }
  3624.     /**
  3625.      * Remove a week from the instance
  3626.      *
  3627.      * @param int $value
  3628.      *
  3629.      * @return static
  3630.      */
  3631.     public function subWeek($value = 1)
  3632.     {
  3633.         return $this->subWeeks($value);
  3634.     }
  3636.     /**
  3637.      * Add hours to the instance. Positive $value travels forward while
  3638.      * negative $value travels into the past.
  3639.      *
  3640.      * @param int $value
  3641.      *
  3642.      * @return static
  3643.      */
  3644.     public function addHours($value)
  3645.     {
  3646.         return $this->modify((int) $value.' hour');
  3647.     }
  3649.     /**
  3650.      * Add hours to the instance using timestamp. Positive $value travels
  3651.      * forward while negative $value travels into the past.
  3652.      *
  3653.      * @param int $value
  3654.      *
  3655.      * @return static
  3656.      */
  3657.     public function addRealHours($value)
  3658.     {
  3659.         return $this->addRealMinutes($value * static::MINUTES_PER_HOUR);
  3660.     }
  3662.     /**
  3663.      * Add an hour to the instance.
  3664.      *
  3665.      * @param int $value
  3666.      *
  3667.      * @return static
  3668.      */
  3669.     public function addHour($value = 1)
  3670.     {
  3671.         return $this->addHours($value);
  3672.     }
  3674.     /**
  3675.      * Add an hour to the instance using timestamp.
  3676.      *
  3677.      * @param int $value
  3678.      *
  3679.      * @return static
  3680.      */
  3681.     public function addRealHour($value = 1)
  3682.     {
  3683.         return $this->addRealHours($value);
  3684.     }
  3686.     /**
  3687.      * Remove hours from the instance.
  3688.      *
  3689.      * @param int $value
  3690.      *
  3691.      * @return static
  3692.      */
  3693.     public function subHours($value)
  3694.     {
  3695.         return $this->addHours(-1 * $value);
  3696.     }
  3698.     /**
  3699.      * Remove hours from the instance using timestamp.
  3700.      *
  3701.      * @param int $value
  3702.      *
  3703.      * @return static
  3704.      */
  3705.     public function subRealHours($value)
  3706.     {
  3707.         return $this->addRealHours(-1 * $value);
  3708.     }
  3710.     /**
  3711.      * Remove an hour from the instance.
  3712.      *
  3713.      * @param int $value
  3714.      *
  3715.      * @return static
  3716.      */
  3717.     public function subHour($value = 1)
  3718.     {
  3719.         return $this->subHours($value);
  3720.     }
  3722.     /**
  3723.      * Remove an hour from the instance.
  3724.      *
  3725.      * @param int $value
  3726.      *
  3727.      * @return static
  3728.      */
  3729.     public function subRealHour($value = 1)
  3730.     {
  3731.         return $this->subRealHours($value);
  3732.     }
  3734.     /**
  3735.      * Add minutes to the instance using timestamp. Positive $value
  3736.      * travels forward while negative $value travels into the past.
  3737.      *
  3738.      * @param int $value
  3739.      *
  3740.      * @return static
  3741.      */
  3742.     public function addMinutes($value)
  3743.     {
  3744.         return $this->modify((int) $value.' minute');
  3745.     }
  3747.     /**
  3748.      * Add minutes to the instance using timestamp. Positive $value travels
  3749.      * forward while negative $value travels into the past.
  3750.      *
  3751.      * @param int $value
  3752.      *
  3753.      * @return static
  3754.      */
  3755.     public function addRealMinutes($value)
  3756.     {
  3757.         return $this->addRealSeconds($value * static::SECONDS_PER_MINUTE);
  3758.     }
  3760.     /**
  3761.      * Add a minute to the instance.
  3762.      *
  3763.      * @param int $value
  3764.      *
  3765.      * @return static
  3766.      */
  3767.     public function addMinute($value = 1)
  3768.     {
  3769.         return $this->addMinutes($value);
  3770.     }
  3772.     /**
  3773.      * Add a minute to the instance using timestamp.
  3774.      *
  3775.      * @param int $value
  3776.      *
  3777.      * @return static
  3778.      */
  3779.     public function addRealMinute($value = 1)
  3780.     {
  3781.         return $this->addRealMinutes($value);
  3782.     }
  3784.     /**
  3785.      * Remove a minute from the instance.
  3786.      *
  3787.      * @param int $value
  3788.      *
  3789.      * @return static
  3790.      */
  3791.     public function subMinute($value = 1)
  3792.     {
  3793.         return $this->subMinutes($value);
  3794.     }
  3796.     /**
  3797.      * Remove a minute from the instance using timestamp.
  3798.      *
  3799.      * @param int $value
  3800.      *
  3801.      * @return static
  3802.      */
  3803.     public function subRealMinute($value = 1)
  3804.     {
  3805.         return $this->addRealMinutes(-1 * $value);
  3806.     }
  3808.     /**
  3809.      * Remove minutes from the instance.
  3810.      *
  3811.      * @param int $value
  3812.      *
  3813.      * @return static
  3814.      */
  3815.     public function subMinutes($value)
  3816.     {
  3817.         return $this->addMinutes(-1 * $value);
  3818.     }
  3820.     /**
  3821.      * Remove a minute from the instance using timestamp.
  3822.      *
  3823.      * @param int $value
  3824.      *
  3825.      * @return static
  3826.      */
  3827.     public function subRealMinutes($value = 1)
  3828.     {
  3829.         return $this->subRealMinute($value);
  3830.     }
  3832.     /**
  3833.      * Add seconds to the instance. Positive $value travels forward while
  3834.      * negative $value travels into the past.
  3835.      *
  3836.      * @param int $value
  3837.      *
  3838.      * @return static
  3839.      */
  3840.     public function addSeconds($value)
  3841.     {
  3842.         return $this->modify((int) $value.' second');
  3843.     }
  3845.     /**
  3846.      * Add seconds to the instance using timestamp. Positive $value travels
  3847.      * forward while negative $value travels into the past.
  3848.      *
  3849.      * @param int $value
  3850.      *
  3851.      * @return static
  3852.      */
  3853.     public function addRealSeconds($value)
  3854.     {
  3855.         return $this->setTimestamp($this->getTimestamp() + $value);
  3856.     }
  3858.     /**
  3859.      * Add a second to the instance.
  3860.      *
  3861.      * @param int $value
  3862.      *
  3863.      * @return static
  3864.      */
  3865.     public function addSecond($value = 1)
  3866.     {
  3867.         return $this->addSeconds($value);
  3868.     }
  3870.     /**
  3871.      * Add a second to the instance using timestamp.
  3872.      *
  3873.      * @param int $value
  3874.      *
  3875.      * @return static
  3876.      */
  3877.     public function addRealSecond($value = 1)
  3878.     {
  3879.         return $this->addRealSeconds($value);
  3880.     }
  3882.     /**
  3883.      * Remove seconds from the instance.
  3884.      *
  3885.      * @param int $value
  3886.      *
  3887.      * @return static
  3888.      */
  3889.     public function subSeconds($value)
  3890.     {
  3891.         return $this->addSeconds(-1 * $value);
  3892.     }
  3894.     /**
  3895.      * Remove seconds from the instance using timestamp.
  3896.      *
  3897.      * @param int $value
  3898.      *
  3899.      * @return static
  3900.      */
  3901.     public function subRealSeconds($value)
  3902.     {
  3903.         return $this->addRealSeconds(-1 * $value);
  3904.     }
  3906.     /**
  3907.      * Remove a second from the instance
  3908.      *
  3909.      * @param int $value
  3910.      *
  3911.      * @return static
  3912.      */
  3913.     public function subSecond($value = 1)
  3914.     {
  3915.         return $this->subSeconds($value);
  3916.     }
  3918.     /**
  3919.      * Remove a second from the instance using timestamp.
  3920.      *
  3921.      * @param int $value
  3922.      *
  3923.      * @return static
  3924.      */
  3925.     public function subRealSecond($value = 1)
  3926.     {
  3927.         return $this->subRealSeconds($value);
  3928.     }
  3930.     ///////////////////////////////////////////////////////////////////
  3931.     /////////////////////////// DIFFERENCES ///////////////////////////
  3932.     ///////////////////////////////////////////////////////////////////
  3934.     /**
  3935.      * @param DateInterval $diff
  3936.      * @param bool         $absolute
  3937.      * @param bool         $trimMicroseconds
  3938.      *
  3939.      * @return CarbonInterval
  3940.      */
  3941.     protected static function fixDiffInterval(DateInterval $diff, $absolute, $trimMicroseconds)
  3942.     {
  3943.         $diff = CarbonInterval::instance($diff, $trimMicroseconds);
  3945.         // @codeCoverageIgnoreStart
  3946.         if (version_compare(PHP_VERSION, '7.1.0-dev', '<')) {
  3947.             return $diff;
  3948.         }
  3950.         // Work-around for https://bugs.php.net/bug.php?id=77145
  3951.         if ($diff->f > 0 && $diff->y === -1 && $diff->m === 11 && $diff->d >= 27 && $diff->h === 23 && $diff->i === 59 && $diff->s === 59) {
  3952.             $diff->y = 0;
  3953.             $diff->m = 0;
  3954.             $diff->d = 0;
  3955.             $diff->h = 0;
  3956.             $diff->i = 0;
  3957.             $diff->s = 0;
  3958.             $diff->f = (1000000 - round($diff->f * 1000000)) / 1000000;
  3959.             $diff->invert();
  3960.         } elseif ($diff->f < 0) {
  3961.             if ($diff->s !== 0 || $diff->i !== 0 || $diff->h !== 0 || $diff->d !== 0 || $diff->m !== 0 || $diff->y !== 0) {
  3962.                 $diff->f = (round($diff->f * 1000000) + 1000000) / 1000000;
  3963.                 $diff->s--;
  3964.                 if ($diff->s < 0) {
  3965.                     $diff->s += 60;
  3966.                     $diff->i--;
  3967.                     if ($diff->i < 0) {
  3968.                         $diff->i += 60;
  3969.                         $diff->h--;
  3970.                         if ($diff->h < 0) {
  3971.                             $diff->h += 24;
  3972.                             $diff->d--;
  3973.                             if ($diff->d < 0) {
  3974.                                 $diff->d += 30;
  3975.                                 $diff->m--;
  3976.                                 if ($diff->m < 0) {
  3977.                                     $diff->m += 12;
  3978.                                     $diff->y--;
  3979.                                 }
  3980.                             }
  3981.                         }
  3982.                     }
  3983.                 }
  3984.             } else {
  3985.                 $diff->f *= -1;
  3986.                 $diff->invert();
  3987.             }
  3988.         }
  3989.         // @codeCoverageIgnoreEnd
  3990.         if ($absolute && $diff->invert) {
  3991.             $diff->invert();
  3992.         }
  3994.         return $diff;
  3995.     }
  3997.     /**
  3998.      * Get the difference as a CarbonInterval instance.
  3999.      *
  4000.      * Pass false as second argument to get a microseconds-precise interval. Else
  4001.      * microseconds in the original interval will not be kept.
  4002.      *
  4003.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4004.      * @param bool                                          $absolute         Get the absolute of the difference
  4005.      * @param bool                                          $trimMicroseconds (true by default)
  4006.      *
  4007.      * @return CarbonInterval
  4008.      */
  4009.     public function diffAsCarbonInterval($date = null, $absolute = true, $trimMicroseconds = true)
  4010.     {
  4011.         $from = $this;
  4012.         $to = $this->resolveCarbon($date);
  4014.         if ($trimMicroseconds) {
  4015.             $from = $from->copy()->startOfSecond();
  4016.             $to = $to->copy()->startOfSecond();
  4017.         }
  4019.         return static::fixDiffInterval($from->diff($to, $absolute), $absolute, $trimMicroseconds);
  4020.     }
  4022.     /**
  4023.      * Get the difference in years
  4024.      *
  4025.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4026.      * @param bool                                          $absolute Get the absolute of the difference
  4027.      *
  4028.      * @return int
  4029.      */
  4030.     public function diffInYears($date = null, $absolute = true)
  4031.     {
  4032.         return (int) $this->diff($this->resolveCarbon($date), $absolute)->format('%r%y');
  4033.     }
  4035.     /**
  4036.      * Get the difference in months
  4037.      *
  4038.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4039.      * @param bool                                          $absolute Get the absolute of the difference
  4040.      *
  4041.      * @return int
  4042.      */
  4043.     public function diffInMonths($date = null, $absolute = true)
  4044.     {
  4045.         $date = $this->resolveCarbon($date);
  4047.         return $this->diffInYears($date, $absolute) * static::MONTHS_PER_YEAR + (int) $this->diff($date, $absolute)->format('%r%m');
  4048.     }
  4050.     /**
  4051.      * Get the difference in weeks
  4052.      *
  4053.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4054.      * @param bool                                          $absolute Get the absolute of the difference
  4055.      *
  4056.      * @return int
  4057.      */
  4058.     public function diffInWeeks($date = null, $absolute = true)
  4059.     {
  4060.         return (int) ($this->diffInDays($date, $absolute) / static::DAYS_PER_WEEK);
  4061.     }
  4063.     /**
  4064.      * Get the difference in days
  4065.      *
  4066.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4067.      * @param bool                                          $absolute Get the absolute of the difference
  4068.      *
  4069.      * @return int
  4070.      */
  4071.     public function diffInDays($date = null, $absolute = true)
  4072.     {
  4073.         return (int) $this->diff($this->resolveCarbon($date), $absolute)->format('%r%a');
  4074.     }
  4076.     /**
  4077.      * Get the difference in days using a filter closure
  4078.      *
  4079.      * @param Closure                                       $callback
  4080.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4081.      * @param bool                                          $absolute Get the absolute of the difference
  4082.      *
  4083.      * @return int
  4084.      */
  4085.     public function diffInDaysFiltered(Closure $callback, $date = null, $absolute = true)
  4086.     {
  4087.         return $this->diffFiltered(CarbonInterval::day(), $callback, $date, $absolute);
  4088.     }
  4090.     /**
  4091.      * Get the difference in hours using a filter closure
  4092.      *
  4093.      * @param Closure                                       $callback
  4094.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4095.      * @param bool                                          $absolute Get the absolute of the difference
  4096.      *
  4097.      * @return int
  4098.      */
  4099.     public function diffInHoursFiltered(Closure $callback, $date = null, $absolute = true)
  4100.     {
  4101.         return $this->diffFiltered(CarbonInterval::hour(), $callback, $date, $absolute);
  4102.     }
  4104.     /**
  4105.      * Get the difference by the given interval using a filter closure
  4106.      *
  4107.      * @param CarbonInterval                                $ci       An interval to traverse by
  4108.      * @param Closure                                       $callback
  4109.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4110.      * @param bool                                          $absolute Get the absolute of the difference
  4111.      *
  4112.      * @return int
  4113.      */
  4114.     public function diffFiltered(CarbonInterval $ci, Closure $callback, $date = null, $absolute = true)
  4115.     {
  4116.         $start = $this;
  4117.         $end = $this->resolveCarbon($date);
  4118.         $inverse = false;
  4120.         if ($end < $start) {
  4121.             $start = $end;
  4122.             $end = $this;
  4123.             $inverse = true;
  4124.         }
  4126.         $period = new DatePeriod($start, $ci, $end);
  4127.         $values = array_filter(iterator_to_array($period), function ($date) use ($callback) {
  4128.             return call_user_func($callback, Carbon::instance($date));
  4129.         });
  4131.         $diff = count($values);
  4133.         return $inverse && !$absolute ? -$diff : $diff;
  4134.     }
  4136.     /**
  4137.      * Get the difference in weekdays
  4138.      *
  4139.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4140.      * @param bool                                          $absolute Get the absolute of the difference
  4141.      *
  4142.      * @return int
  4143.      */
  4144.     public function diffInWeekdays($date = null, $absolute = true)
  4145.     {
  4146.         return $this->diffInDaysFiltered(function (Carbon $date) {
  4147.             return $date->isWeekday();
  4148.         }, $date, $absolute);
  4149.     }
  4151.     /**
  4152.      * Get the difference in weekend days using a filter
  4153.      *
  4154.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4155.      * @param bool                                          $absolute Get the absolute of the difference
  4156.      *
  4157.      * @return int
  4158.      */
  4159.     public function diffInWeekendDays($date = null, $absolute = true)
  4160.     {
  4161.         return $this->diffInDaysFiltered(function (Carbon $date) {
  4162.             return $date->isWeekend();
  4163.         }, $date, $absolute);
  4164.     }
  4166.     /**
  4167.      * Get the difference in hours.
  4168.      *
  4169.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4170.      * @param bool                                          $absolute Get the absolute of the difference
  4171.      *
  4172.      * @return int
  4173.      */
  4174.     public function diffInHours($date = null, $absolute = true)
  4175.     {
  4176.         return (int) ($this->diffInSeconds($date, $absolute) / static::SECONDS_PER_MINUTE / static::MINUTES_PER_HOUR);
  4177.     }
  4179.     /**
  4180.      * Get the difference in hours using timestamps.
  4181.      *
  4182.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4183.      * @param bool                                          $absolute Get the absolute of the difference
  4184.      *
  4185.      * @return int
  4186.      */
  4187.     public function diffInRealHours($date = null, $absolute = true)
  4188.     {
  4189.         return (int) ($this->diffInRealSeconds($date, $absolute) / static::SECONDS_PER_MINUTE / static::MINUTES_PER_HOUR);
  4190.     }
  4192.     /**
  4193.      * Get the difference in minutes.
  4194.      *
  4195.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4196.      * @param bool                                          $absolute Get the absolute of the difference
  4197.      *
  4198.      * @return int
  4199.      */
  4200.     public function diffInMinutes($date = null, $absolute = true)
  4201.     {
  4202.         return (int) ($this->diffInSeconds($date, $absolute) / static::SECONDS_PER_MINUTE);
  4203.     }
  4205.     /**
  4206.      * Get the difference in minutes using timestamps.
  4207.      *
  4208.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4209.      * @param bool                                          $absolute Get the absolute of the difference
  4210.      *
  4211.      * @return int
  4212.      */
  4213.     public function diffInRealMinutes($date = null, $absolute = true)
  4214.     {
  4215.         return (int) ($this->diffInRealSeconds($date, $absolute) / static::SECONDS_PER_MINUTE);
  4216.     }
  4218.     /**
  4219.      * Get the difference in seconds.
  4220.      *
  4221.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4222.      * @param bool                                          $absolute Get the absolute of the difference
  4223.      *
  4224.      * @return int
  4225.      */
  4226.     public function diffInSeconds($date = null, $absolute = true)
  4227.     {
  4228.         $diff = $this->diff($this->resolveCarbon($date));
  4229.         if (!$diff->days && version_compare(PHP_VERSION, '5.4.0-dev', '>=')) {
  4230.             $diff = static::fixDiffInterval($diff, $absolute, false);
  4231.         }
  4232.         $value = $diff->days * static::HOURS_PER_DAY * static::MINUTES_PER_HOUR * static::SECONDS_PER_MINUTE +
  4233.             $diff->h * static::MINUTES_PER_HOUR * static::SECONDS_PER_MINUTE +
  4234.             $diff->i * static::SECONDS_PER_MINUTE +
  4235.             $diff->s;
  4237.         return $absolute || !$diff->invert ? $value : -$value;
  4238.     }
  4240.     /**
  4241.      * Get the difference in seconds using timestamps.
  4242.      *
  4243.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4244.      * @param bool                                          $absolute Get the absolute of the difference
  4245.      *
  4246.      * @return int
  4247.      */
  4248.     public function diffInRealSeconds($date = null, $absolute = true)
  4249.     {
  4250.         $date = $this->resolveCarbon($date);
  4251.         $value = $date->getTimestamp() - $this->getTimestamp();
  4253.         return $absolute ? abs($value) : $value;
  4254.     }
  4256.     /**
  4257.      * Get the difference in milliseconds.
  4258.      *
  4259.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4260.      * @param bool                                          $absolute Get the absolute of the difference
  4261.      *
  4262.      * @return int
  4263.      */
  4264.     public function diffInMilliseconds($date = null, $absolute = true)
  4265.     {
  4266.         return (int) ($this->diffInMicroseconds($date, $absolute) / static::MICROSECONDS_PER_MILLISECOND);
  4267.     }
  4269.     /**
  4270.      * Get the difference in milliseconds using timestamps.
  4271.      *
  4272.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4273.      * @param bool                                          $absolute Get the absolute of the difference
  4274.      *
  4275.      * @return int
  4276.      */
  4277.     public function diffInRealMilliseconds($date = null, $absolute = true)
  4278.     {
  4279.         return (int) ($this->diffInRealMicroseconds($date, $absolute) / static::MICROSECONDS_PER_MILLISECOND);
  4280.     }
  4282.     /**
  4283.      * Get the difference in microseconds.
  4284.      *
  4285.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4286.      * @param bool                                          $absolute Get the absolute of the difference
  4287.      *
  4288.      * @return int
  4289.      */
  4290.     public function diffInMicroseconds($date = null, $absolute = true)
  4291.     {
  4292.         $diff = $this->diff($this->resolveCarbon($date));
  4293.         $micro = isset($diff->f) ? $diff->f : 0;
  4294.         $value = (int) round((((($diff->days * static::HOURS_PER_DAY) +
  4295.             $diff->h) * static::MINUTES_PER_HOUR +
  4296.             $diff->i) * static::SECONDS_PER_MINUTE +
  4297.             ($micro + $diff->s)) * static::MICROSECONDS_PER_SECOND);
  4299.         return $absolute || !$diff->invert ? $value : -$value;
  4300.     }
  4302.     /**
  4303.      * Get the difference in microseconds using timestamps.
  4304.      *
  4305.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  4306.      * @param bool                                          $absolute Get the absolute of the difference
  4307.      *
  4308.      * @return int
  4309.      */
  4310.     public function diffInRealMicroseconds($date = null, $absolute = true)
  4311.     {
  4312.         /** @var Carbon $date */
  4313.         $date = $this->resolveCarbon($date);
  4314.         $value = ($date->timestamp - $this->timestamp) * static::MICROSECONDS_PER_SECOND +
  4315.             $date->micro - $this->micro;
  4317.         return $absolute ? abs($value) : $value;
  4318.     }
  4320.     /**
  4321.      * The number of seconds since midnight.
  4322.      *
  4323.      * @return int
  4324.      */
  4325.     public function secondsSinceMidnight()
  4326.     {
  4327.         return $this->diffInSeconds($this->copy()->startOfDay());
  4328.     }
  4330.     /**
  4331.      * The number of seconds until 23:59:59.
  4332.      *
  4333.      * @return int
  4334.      */
  4335.     public function secondsUntilEndOfDay()
  4336.     {
  4337.         return $this->diffInSeconds($this->copy()->endOfDay());
  4338.     }
  4340.     /**
  4341.      * Get the difference in a human readable format in the current locale.
  4342.      *
  4343.      * When comparing a value in the past to default now:
  4344.      * 1 hour ago
  4345.      * 5 months ago
  4346.      *
  4347.      * When comparing a value in the future to default now:
  4348.      * 1 hour from now
  4349.      * 5 months from now
  4350.      *
  4351.      * When comparing a value in the past to another value:
  4352.      * 1 hour before
  4353.      * 5 months before
  4354.      *
  4355.      * When comparing a value in the future to another value:
  4356.      * 1 hour after
  4357.      * 5 months after
  4358.      *
  4359.      * @param Carbon|null $other
  4360.      * @param bool        $absolute removes time difference modifiers ago, after, etc
  4361.      * @param bool        $short    displays short format of time units
  4362.      * @param int         $parts    displays number of parts in the interval
  4363.      *
  4364.      * @return string
  4365.      */
  4366.     public function diffForHumans($other = null, $absolute = false, $short = false, $parts = 1)
  4367.     {
  4368.         $isNow = $other === null;
  4369.         $relativeToNow = $isNow;
  4371.         if ($absolute === static::DIFF_RELATIVE_TO_NOW) {
  4372.             $absolute = false;
  4373.             $relativeToNow = true;
  4374.         } elseif ($absolute === static::DIFF_RELATIVE_TO_OTHER) {
  4375.             $absolute = false;
  4376.             $relativeToNow = false;
  4377.         }
  4379.         $interval = array();
  4381.         $parts = min(6, max(1, (int) $parts));
  4382.         $count = 1;
  4383.         $unit = $short ? 's' : 'second';
  4385.         if ($isNow) {
  4386.             $other = $this->nowWithSameTz();
  4387.         } elseif (!$other instanceof DateTime && !$other instanceof DateTimeInterface) {
  4388.             $other = static::parse($other);
  4389.         }
  4391.         $diffInterval = $this->diff($other);
  4393.         $diffIntervalArray = array(
  4394.             array('value' => $diffInterval->y, 'unit' => 'year',    'unitShort' => 'y'),
  4395.             array('value' => $diffInterval->m, 'unit' => 'month',   'unitShort' => 'm'),
  4396.             array('value' => $diffInterval->d, 'unit' => 'day',     'unitShort' => 'd'),
  4397.             array('value' => $diffInterval->h, 'unit' => 'hour',    'unitShort' => 'h'),
  4398.             array('value' => $diffInterval->i, 'unit' => 'minute',  'unitShort' => 'min'),
  4399.             array('value' => $diffInterval->s, 'unit' => 'second',  'unitShort' => 's'),
  4400.         );
  4402.         foreach ($diffIntervalArray as $diffIntervalData) {
  4403.             if ($diffIntervalData['value'] > 0) {
  4404.                 $unit = $short ? $diffIntervalData['unitShort'] : $diffIntervalData['unit'];
  4405.                 $count = $diffIntervalData['value'];
  4407.                 if ($diffIntervalData['unit'] === 'day' && $count >= static::DAYS_PER_WEEK) {
  4408.                     $unit = $short ? 'w' : 'week';
  4409.                     $count = (int) ($count / static::DAYS_PER_WEEK);
  4411.                     $interval[] = static::translator()->transChoice($unit, $count, array(':count' => $count));
  4413.                     // get the count days excluding weeks (might be zero)
  4414.                     $numOfDaysCount = (int) ($diffIntervalData['value'] - ($count * static::DAYS_PER_WEEK));
  4416.                     if ($numOfDaysCount > 0 && count($interval) < $parts) {
  4417.                         $unit = $short ? 'd' : 'day';
  4418.                         $count = $numOfDaysCount;
  4419.                         $interval[] = static::translator()->transChoice($unit, $count, array(':count' => $count));
  4420.                     }
  4421.                 } else {
  4422.                     $interval[] = static::translator()->transChoice($unit, $count, array(':count' => $count));
  4423.                 }
  4424.             }
  4426.             // break the loop after we get the required number of parts in array
  4427.             if (count($interval) >= $parts) {
  4428.                 break;
  4429.             }
  4430.         }
  4432.         if (count($interval) === 0) {
  4433.             if ($isNow && static::getHumanDiffOptions() & self::JUST_NOW) {
  4434.                 $key = 'diff_now';
  4435.                 $translation = static::translator()->trans($key);
  4436.                 if ($translation !== $key) {
  4437.                     return $translation;
  4438.                 }
  4439.             }
  4440.             $count = static::getHumanDiffOptions() & self::NO_ZERO_DIFF ? 1 : 0;
  4441.             $unit = $short ? 's' : 'second';
  4442.             $interval[] = static::translator()->transChoice($unit, $count, array(':count' => $count));
  4443.         }
  4445.         // join the interval parts by a space
  4446.         $time = implode(' ', $interval);
  4448.         unset($diffIntervalArray, $interval);
  4450.         if ($absolute) {
  4451.             return $time;
  4452.         }
  4454.         $isFuture = $diffInterval->invert === 1;
  4456.         $transId = $relativeToNow ? ($isFuture ? 'from_now' : 'ago') : ($isFuture ? 'after' : 'before');
  4458.         if ($parts === 1) {
  4459.             if ($isNow && $unit === 'day') {
  4460.                 if ($count === 1 && static::getHumanDiffOptions() & self::ONE_DAY_WORDS) {
  4461.                     $key = $isFuture ? 'diff_tomorrow' : 'diff_yesterday';
  4462.                     $translation = static::translator()->trans($key);
  4463.                     if ($translation !== $key) {
  4464.                         return $translation;
  4465.                     }
  4466.                 }
  4467.                 if ($count === 2 && static::getHumanDiffOptions() & self::TWO_DAY_WORDS) {
  4468.                     $key = $isFuture ? 'diff_after_tomorrow' : 'diff_before_yesterday';
  4469.                     $translation = static::translator()->trans($key);
  4470.                     if ($translation !== $key) {
  4471.                         return $translation;
  4472.                     }
  4473.                 }
  4474.             }
  4475.             // Some languages have special pluralization for past and future tense.
  4476.             $key = $unit.'_'.$transId;
  4477.             if ($key !== static::translator()->transChoice($key, $count)) {
  4478.                 $time = static::translator()->transChoice($key, $count, array(':count' => $count));
  4479.             }
  4480.         }
  4482.         return static::translator()->trans($transId, array(':time' => $time));
  4483.     }
  4485.     /**
  4486.      * @alias diffForHumans
  4487.      *
  4488.      * Get the difference in a human readable format in the current locale.
  4489.      *
  4490.      * When comparing a value in the past to default now:
  4491.      * 1 hour ago
  4492.      * 5 months ago
  4493.      *
  4494.      * When comparing a value in the future to default now:
  4495.      * 1 hour from now
  4496.      * 5 months from now
  4497.      *
  4498.      * When comparing a value in the past to another value:
  4499.      * 1 hour before
  4500.      * 5 months before
  4501.      *
  4502.      * When comparing a value in the future to another value:
  4503.      * 1 hour after
  4504.      * 5 months after
  4505.      *
  4506.      * @param Carbon|null $other
  4507.      * @param bool        $absolute removes time difference modifiers ago, after, etc
  4508.      * @param bool        $short    displays short format of time units
  4509.      * @param int         $parts    displays number of parts in the interval
  4510.      *
  4511.      * @return string
  4512.      */
  4513.     public function from($other = null, $absolute = false, $short = false, $parts = 1)
  4514.     {
  4515.         if (!$other && !$absolute) {
  4516.             $absolute = static::DIFF_RELATIVE_TO_NOW;
  4517.         }
  4519.         return $this->diffForHumans($other, $absolute, $short, $parts);
  4520.     }
  4522.     /**
  4523.      * @alias diffForHumans
  4524.      *
  4525.      * Get the difference in a human readable format in the current locale.
  4526.      *
  4527.      * When comparing a value in the past to default now:
  4528.      * 1 hour ago
  4529.      * 5 months ago
  4530.      *
  4531.      * When comparing a value in the future to default now:
  4532.      * 1 hour from now
  4533.      * 5 months from now
  4534.      *
  4535.      * When comparing a value in the past to another value:
  4536.      * 1 hour before
  4537.      * 5 months before
  4538.      *
  4539.      * When comparing a value in the future to another value:
  4540.      * 1 hour after
  4541.      * 5 months after
  4542.      *
  4543.      * @param Carbon|null $other
  4544.      * @param bool        $absolute removes time difference modifiers ago, after, etc
  4545.      * @param bool        $short    displays short format of time units
  4546.      * @param int         $parts    displays number of parts in the interval
  4547.      *
  4548.      * @return string
  4549.      */
  4550.     public function since($other = null, $absolute = false, $short = false, $parts = 1)
  4551.     {
  4552.         return $this->diffForHumans($other, $absolute, $short, $parts);
  4553.     }
  4555.     /**
  4556.      * Get the difference in a human readable format in the current locale from an other
  4557.      * instance given (or now if null given) to current instance.
  4558.      *
  4559.      * When comparing a value in the past to default now:
  4560.      * 1 hour from now
  4561.      * 5 months from now
  4562.      *
  4563.      * When comparing a value in the future to default now:
  4564.      * 1 hour ago
  4565.      * 5 months ago
  4566.      *
  4567.      * When comparing a value in the past to another value:
  4568.      * 1 hour after
  4569.      * 5 months after
  4570.      *
  4571.      * When comparing a value in the future to another value:
  4572.      * 1 hour before
  4573.      * 5 months before
  4574.      *
  4575.      * @param Carbon|null $other
  4576.      * @param bool        $absolute removes time difference modifiers ago, after, etc
  4577.      * @param bool        $short    displays short format of time units
  4578.      * @param int         $parts    displays number of parts in the interval
  4579.      *
  4580.      * @return string
  4581.      */
  4582.     public function to($other = null, $absolute = false, $short = false, $parts = 1)
  4583.     {
  4584.         if (!$other && !$absolute) {
  4585.             $absolute = static::DIFF_RELATIVE_TO_NOW;
  4586.         }
  4588.         return $this->resolveCarbon($other)->diffForHumans($this, $absolute, $short, $parts);
  4589.     }
  4591.     /**
  4592.      * @alias to
  4593.      *
  4594.      * Get the difference in a human readable format in the current locale from an other
  4595.      * instance given (or now if null given) to current instance.
  4596.      *
  4597.      * @param Carbon|null $other
  4598.      * @param bool        $absolute removes time difference modifiers ago, after, etc
  4599.      * @param bool        $short    displays short format of time units
  4600.      * @param int         $parts    displays number of parts in the interval
  4601.      *
  4602.      * @return string
  4603.      */
  4604.     public function until($other = null, $absolute = false, $short = false, $parts = 1)
  4605.     {
  4606.         return $this->to($other, $absolute, $short, $parts);
  4607.     }
  4609.     /**
  4610.      * Get the difference in a human readable format in the current locale from current
  4611.      * instance to now.
  4612.      *
  4613.      * @param bool $absolute removes time difference modifiers ago, after, etc
  4614.      * @param bool $short    displays short format of time units
  4615.      * @param int  $parts    displays number of parts in the interval
  4616.      *
  4617.      * @return string
  4618.      */
  4619.     public function fromNow($absolute = null, $short = false, $parts = 1)
  4620.     {
  4621.         $other = null;
  4623.         if ($absolute instanceof DateTimeInterface) {
  4624.             list($other, $absolute, $short, $parts) = array_pad(func_get_args(), 5, null);
  4625.         }
  4627.         return $this->from($other, $absolute, $short, $parts);
  4628.     }
  4630.     /**
  4631.      * Get the difference in a human readable format in the current locale from an other
  4632.      * instance given to now
  4633.      *
  4634.      * @param bool $absolute removes time difference modifiers ago, after, etc
  4635.      * @param bool $short    displays short format of time units
  4636.      * @param int  $parts    displays number of parts in the interval
  4637.      *
  4638.      * @return string
  4639.      */
  4640.     public function toNow($absolute = null, $short = false, $parts = 1)
  4641.     {
  4642.         return $this->to(null, $absolute, $short, $parts);
  4643.     }
  4645.     /**
  4646.      * Get the difference in a human readable format in the current locale from an other
  4647.      * instance given to now
  4648.      *
  4649.      * @param bool $absolute removes time difference modifiers ago, after, etc
  4650.      * @param bool $short    displays short format of time units
  4651.      * @param int  $parts    displays number of parts in the interval
  4652.      *
  4653.      * @return string
  4654.      */
  4655.     public function ago($absolute = null, $short = false, $parts = 1)
  4656.     {
  4657.         $other = null;
  4659.         if ($absolute instanceof DateTimeInterface) {
  4660.             list($other, $absolute, $short, $parts) = array_pad(func_get_args(), 5, null);
  4661.         }
  4663.         return $this->from($other, $absolute, $short, $parts);
  4664.     }
  4666.     ///////////////////////////////////////////////////////////////////
  4667.     //////////////////////////// MODIFIERS ////////////////////////////
  4668.     ///////////////////////////////////////////////////////////////////
  4670.     /**
  4671.      * Resets the time to 00:00:00 start of day
  4672.      *
  4673.      * @return static
  4674.      */
  4675.     public function startOfDay()
  4676.     {
  4677.         return $this->modify('00:00:00.000000');
  4678.     }
  4680.     /**
  4681.      * Resets the time to 23:59:59 end of day
  4682.      *
  4683.      * @return static
  4684.      */
  4685.     public function endOfDay()
  4686.     {
  4687.         return $this->modify('23:59:59.999999');
  4688.     }
  4690.     /**
  4691.      * Resets the date to the first day of the month and the time to 00:00:00
  4692.      *
  4693.      * @return static
  4694.      */
  4695.     public function startOfMonth()
  4696.     {
  4697.         return $this->setDate($this->year, $this->month, 1)->startOfDay();
  4698.     }
  4700.     /**
  4701.      * Resets the date to end of the month and time to 23:59:59
  4702.      *
  4703.      * @return static
  4704.      */
  4705.     public function endOfMonth()
  4706.     {
  4707.         return $this->setDate($this->year, $this->month, $this->daysInMonth)->endOfDay();
  4708.     }
  4710.     /**
  4711.      * Resets the date to the first day of the quarter and the time to 00:00:00
  4712.      *
  4713.      * @return static
  4714.      */
  4715.     public function startOfQuarter()
  4716.     {
  4717.         $month = ($this->quarter - 1) * static::MONTHS_PER_QUARTER + 1;
  4719.         return $this->setDate($this->year, $month, 1)->startOfDay();
  4720.     }
  4722.     /**
  4723.      * Resets the date to end of the quarter and time to 23:59:59
  4724.      *
  4725.      * @return static
  4726.      */
  4727.     public function endOfQuarter()
  4728.     {
  4729.         return $this->startOfQuarter()->addMonths(static::MONTHS_PER_QUARTER - 1)->endOfMonth();
  4730.     }
  4732.     /**
  4733.      * Resets the date to the first day of the year and the time to 00:00:00
  4734.      *
  4735.      * @return static
  4736.      */
  4737.     public function startOfYear()
  4738.     {
  4739.         return $this->setDate($this->year, 1, 1)->startOfDay();
  4740.     }
  4742.     /**
  4743.      * Resets the date to end of the year and time to 23:59:59
  4744.      *
  4745.      * @return static
  4746.      */
  4747.     public function endOfYear()
  4748.     {
  4749.         return $this->setDate($this->year, 12, 31)->endOfDay();
  4750.     }
  4752.     /**
  4753.      * Resets the date to the first day of the decade and the time to 00:00:00
  4754.      *
  4755.      * @return static
  4756.      */
  4757.     public function startOfDecade()
  4758.     {
  4759.         $year = $this->year - $this->year % static::YEARS_PER_DECADE;
  4761.         return $this->setDate($year, 1, 1)->startOfDay();
  4762.     }
  4764.     /**
  4765.      * Resets the date to end of the decade and time to 23:59:59
  4766.      *
  4767.      * @return static
  4768.      */
  4769.     public function endOfDecade()
  4770.     {
  4771.         $year = $this->year - $this->year % static::YEARS_PER_DECADE + static::YEARS_PER_DECADE - 1;
  4773.         return $this->setDate($year, 12, 31)->endOfDay();
  4774.     }
  4776.     /**
  4777.      * Resets the date to the first day of the century and the time to 00:00:00
  4778.      *
  4779.      * @return static
  4780.      */
  4781.     public function startOfCentury()
  4782.     {
  4783.         $year = $this->year - ($this->year - 1) % static::YEARS_PER_CENTURY;
  4785.         return $this->setDate($year, 1, 1)->startOfDay();
  4786.     }
  4788.     /**
  4789.      * Resets the date to end of the century and time to 23:59:59
  4790.      *
  4791.      * @return static
  4792.      */
  4793.     public function endOfCentury()
  4794.     {
  4795.         $year = $this->year - 1 - ($this->year - 1) % static::YEARS_PER_CENTURY + static::YEARS_PER_CENTURY;
  4797.         return $this->setDate($year, 12, 31)->endOfDay();
  4798.     }
  4800.     /**
  4801.      * Resets the date to the first day of the century and the time to 00:00:00
  4802.      *
  4803.      * @return static
  4804.      */
  4805.     public function startOfMillennium()
  4806.     {
  4807.         $year = $this->year - ($this->year - 1) % static::YEARS_PER_MILLENNIUM;
  4809.         return $this->setDate($year, 1, 1)->startOfDay();
  4810.     }
  4812.     /**
  4813.      * Resets the date to end of the century and time to 23:59:59
  4814.      *
  4815.      * @return static
  4816.      */
  4817.     public function endOfMillennium()
  4818.     {
  4819.         $year = $this->year - 1 - ($this->year - 1) % static::YEARS_PER_MILLENNIUM + static::YEARS_PER_MILLENNIUM;
  4821.         return $this->setDate($year, 12, 31)->endOfDay();
  4822.     }
  4824.     /**
  4825.      * Resets the date to the first day of week (defined in $weekStartsAt) and the time to 00:00:00
  4826.      *
  4827.      * @return static
  4828.      */
  4829.     public function startOfWeek()
  4830.     {
  4831.         while ($this->dayOfWeek !== static::$weekStartsAt) {
  4832.             $this->subDay();
  4833.         }
  4835.         return $this->startOfDay();
  4836.     }
  4838.     /**
  4839.      * Resets the date to end of week (defined in $weekEndsAt) and time to 23:59:59
  4840.      *
  4841.      * @return static
  4842.      */
  4843.     public function endOfWeek()
  4844.     {
  4845.         while ($this->dayOfWeek !== static::$weekEndsAt) {
  4846.             $this->addDay();
  4847.         }
  4849.         return $this->endOfDay();
  4850.     }
  4852.     /**
  4853.      * Modify to start of current hour, minutes and seconds become 0
  4854.      *
  4855.      * @return static
  4856.      */
  4857.     public function startOfHour()
  4858.     {
  4859.         return $this->setTime($this->hour, 0, 0);
  4860.     }
  4862.     /**
  4863.      * Modify to end of current hour, minutes and seconds become 59
  4864.      *
  4865.      * @return static
  4866.      */
  4867.     public function endOfHour()
  4868.     {
  4869.         return $this->modify("$this->hour:59:59.999999");
  4870.     }
  4872.     /**
  4873.      * Modify to start of current minute, seconds become 0
  4874.      *
  4875.      * @return static
  4876.      */
  4877.     public function startOfMinute()
  4878.     {
  4879.         return $this->setTime($this->hour, $this->minute, 0);
  4880.     }
  4882.     /**
  4883.      * Modify to end of current minute, seconds become 59
  4884.      *
  4885.      * @return static
  4886.      */
  4887.     public function endOfMinute()
  4888.     {
  4889.         return $this->modify("$this->hour:$this->minute:59.999999");
  4890.     }
  4892.     /**
  4893.      * Modify to start of current minute, seconds become 0
  4894.      *
  4895.      * @return static
  4896.      */
  4897.     public function startOfSecond()
  4898.     {
  4899.         return $this->modify("$this->hour:$this->minute:$this->second.0");
  4900.     }
  4902.     /**
  4903.      * Modify to end of current minute, seconds become 59
  4904.      *
  4905.      * @return static
  4906.      */
  4907.     public function endOfSecond()
  4908.     {
  4909.         return $this->modify("$this->hour:$this->minute:$this->second.999999");
  4910.     }
  4912.     /**
  4913.      * Modify to midday, default to self::$midDayAt
  4914.      *
  4915.      * @return static
  4916.      */
  4917.     public function midDay()
  4918.     {
  4919.         return $this->setTime(self::$midDayAt, 0, 0);
  4920.     }
  4922.     /**
  4923.      * Modify to the next occurrence of a given day of the week.
  4924.      * If no dayOfWeek is provided, modify to the next occurrence
  4925.      * of the current day of the week.  Use the supplied constants
  4926.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  4927.      *
  4928.      * @param int|null $dayOfWeek
  4929.      *
  4930.      * @return static
  4931.      */
  4932.     public function next($dayOfWeek = null)
  4933.     {
  4934.         if ($dayOfWeek === null) {
  4935.             $dayOfWeek = $this->dayOfWeek;
  4936.         }
  4938.         return $this->startOfDay()->modify('next '.static::$days[$dayOfWeek]);
  4939.     }
  4941.     /**
  4942.      * Go forward or backward to the next week- or weekend-day.
  4943.      *
  4944.      * @param bool $weekday
  4945.      * @param bool $forward
  4946.      *
  4947.      * @return $this
  4948.      */
  4949.     private function nextOrPreviousDay($weekday = true, $forward = true)
  4950.     {
  4951.         $step = $forward ? 1 : -1;
  4953.         do {
  4954.             $this->addDay($step);
  4955.         } while ($weekday ? $this->isWeekend() : $this->isWeekday());
  4957.         return $this;
  4958.     }
  4960.     /**
  4961.      * Go forward to the next weekday.
  4962.      *
  4963.      * @return $this
  4964.      */
  4965.     public function nextWeekday()
  4966.     {
  4967.         return $this->nextOrPreviousDay();
  4968.     }
  4970.     /**
  4971.      * Go backward to the previous weekday.
  4972.      *
  4973.      * @return $this
  4974.      */
  4975.     public function previousWeekday()
  4976.     {
  4977.         return $this->nextOrPreviousDay(true, false);
  4978.     }
  4980.     /**
  4981.      * Go forward to the next weekend day.
  4982.      *
  4983.      * @return $this
  4984.      */
  4985.     public function nextWeekendDay()
  4986.     {
  4987.         return $this->nextOrPreviousDay(false);
  4988.     }
  4990.     /**
  4991.      * Go backward to the previous weekend day.
  4992.      *
  4993.      * @return $this
  4994.      */
  4995.     public function previousWeekendDay()
  4996.     {
  4997.         return $this->nextOrPreviousDay(false, false);
  4998.     }
  5000.     /**
  5001.      * Modify to the previous occurrence of a given day of the week.
  5002.      * If no dayOfWeek is provided, modify to the previous occurrence
  5003.      * of the current day of the week.  Use the supplied constants
  5004.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5005.      *
  5006.      * @param int|null $dayOfWeek
  5007.      *
  5008.      * @return static
  5009.      */
  5010.     public function previous($dayOfWeek = null)
  5011.     {
  5012.         if ($dayOfWeek === null) {
  5013.             $dayOfWeek = $this->dayOfWeek;
  5014.         }
  5016.         return $this->startOfDay()->modify('last '.static::$days[$dayOfWeek]);
  5017.     }
  5019.     /**
  5020.      * Modify to the first occurrence of a given day of the week
  5021.      * in the current month. If no dayOfWeek is provided, modify to the
  5022.      * first day of the current month.  Use the supplied constants
  5023.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5024.      *
  5025.      * @param int|null $dayOfWeek
  5026.      *
  5027.      * @return static
  5028.      */
  5029.     public function firstOfMonth($dayOfWeek = null)
  5030.     {
  5031.         $this->startOfDay();
  5033.         if ($dayOfWeek === null) {
  5034.             return $this->day(1);
  5035.         }
  5037.         return $this->modify('first '.static::$days[$dayOfWeek].' of '.$this->format('F').' '.$this->year);
  5038.     }
  5040.     /**
  5041.      * Modify to the last occurrence of a given day of the week
  5042.      * in the current month. If no dayOfWeek is provided, modify to the
  5043.      * last day of the current month.  Use the supplied constants
  5044.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5045.      *
  5046.      * @param int|null $dayOfWeek
  5047.      *
  5048.      * @return static
  5049.      */
  5050.     public function lastOfMonth($dayOfWeek = null)
  5051.     {
  5052.         $this->startOfDay();
  5054.         if ($dayOfWeek === null) {
  5055.             return $this->day($this->daysInMonth);
  5056.         }
  5058.         return $this->modify('last '.static::$days[$dayOfWeek].' of '.$this->format('F').' '.$this->year);
  5059.     }
  5061.     /**
  5062.      * Modify to the given occurrence of a given day of the week
  5063.      * in the current month. If the calculated occurrence is outside the scope
  5064.      * of the current month, then return false and no modifications are made.
  5065.      * Use the supplied constants to indicate the desired dayOfWeek, ex. static::MONDAY.
  5066.      *
  5067.      * @param int $nth
  5068.      * @param int $dayOfWeek
  5069.      *
  5070.      * @return mixed
  5071.      */
  5072.     public function nthOfMonth($nth, $dayOfWeek)
  5073.     {
  5074.         $date = $this->copy()->firstOfMonth();
  5075.         $check = $date->format('Y-m');
  5076.         $date->modify('+'.$nth.' '.static::$days[$dayOfWeek]);
  5078.         return $date->format('Y-m') === $check ? $this->modify($date) : false;
  5079.     }
  5081.     /**
  5082.      * Modify to the first occurrence of a given day of the week
  5083.      * in the current quarter. If no dayOfWeek is provided, modify to the
  5084.      * first day of the current quarter.  Use the supplied constants
  5085.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5086.      *
  5087.      * @param int|null $dayOfWeek day of the week default null
  5088.      *
  5089.      * @return static
  5090.      */
  5091.     public function firstOfQuarter($dayOfWeek = null)
  5092.     {
  5093.         return $this->setDate($this->year, $this->quarter * static::MONTHS_PER_QUARTER - 2, 1)->firstOfMonth($dayOfWeek);
  5094.     }
  5096.     /**
  5097.      * Modify to the last occurrence of a given day of the week
  5098.      * in the current quarter. If no dayOfWeek is provided, modify to the
  5099.      * last day of the current quarter.  Use the supplied constants
  5100.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5101.      *
  5102.      * @param int|null $dayOfWeek day of the week default null
  5103.      *
  5104.      * @return static
  5105.      */
  5106.     public function lastOfQuarter($dayOfWeek = null)
  5107.     {
  5108.         return $this->setDate($this->year, $this->quarter * static::MONTHS_PER_QUARTER, 1)->lastOfMonth($dayOfWeek);
  5109.     }
  5111.     /**
  5112.      * Modify to the given occurrence of a given day of the week
  5113.      * in the current quarter. If the calculated occurrence is outside the scope
  5114.      * of the current quarter, then return false and no modifications are made.
  5115.      * Use the supplied constants to indicate the desired dayOfWeek, ex. static::MONDAY.
  5116.      *
  5117.      * @param int $nth
  5118.      * @param int $dayOfWeek
  5119.      *
  5120.      * @return mixed
  5121.      */
  5122.     public function nthOfQuarter($nth, $dayOfWeek)
  5123.     {
  5124.         $date = $this->copy()->day(1)->month($this->quarter * static::MONTHS_PER_QUARTER);
  5125.         $lastMonth = $date->month;
  5126.         $year = $date->year;
  5127.         $date->firstOfQuarter()->modify('+'.$nth.' '.static::$days[$dayOfWeek]);
  5129.         return ($lastMonth < $date->month || $year !== $date->year) ? false : $this->modify($date);
  5130.     }
  5132.     /**
  5133.      * Modify to the first occurrence of a given day of the week
  5134.      * in the current year. If no dayOfWeek is provided, modify to the
  5135.      * first day of the current year.  Use the supplied constants
  5136.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5137.      *
  5138.      * @param int|null $dayOfWeek day of the week default null
  5139.      *
  5140.      * @return static
  5141.      */
  5142.     public function firstOfYear($dayOfWeek = null)
  5143.     {
  5144.         return $this->month(1)->firstOfMonth($dayOfWeek);
  5145.     }
  5147.     /**
  5148.      * Modify to the last occurrence of a given day of the week
  5149.      * in the current year. If no dayOfWeek is provided, modify to the
  5150.      * last day of the current year.  Use the supplied constants
  5151.      * to indicate the desired dayOfWeek, ex. static::MONDAY.
  5152.      *
  5153.      * @param int|null $dayOfWeek day of the week default null
  5154.      *
  5155.      * @return static
  5156.      */
  5157.     public function lastOfYear($dayOfWeek = null)
  5158.     {
  5159.         return $this->month(static::MONTHS_PER_YEAR)->lastOfMonth($dayOfWeek);
  5160.     }
  5162.     /**
  5163.      * Modify to the given occurrence of a given day of the week
  5164.      * in the current year. If the calculated occurrence is outside the scope
  5165.      * of the current year, then return false and no modifications are made.
  5166.      * Use the supplied constants to indicate the desired dayOfWeek, ex. static::MONDAY.
  5167.      *
  5168.      * @param int $nth
  5169.      * @param int $dayOfWeek
  5170.      *
  5171.      * @return mixed
  5172.      */
  5173.     public function nthOfYear($nth, $dayOfWeek)
  5174.     {
  5175.         $date = $this->copy()->firstOfYear()->modify('+'.$nth.' '.static::$days[$dayOfWeek]);
  5177.         return $this->year === $date->year ? $this->modify($date) : false;
  5178.     }
  5180.     /**
  5181.      * Modify the current instance to the average of a given instance (default now) and the current instance.
  5182.      *
  5183.      * @param \Carbon\Carbon|\DateTimeInterface|string|null $date
  5184.      *
  5185.      * @return static
  5186.      */
  5187.     public function average($date = null)
  5188.     {
  5189.         $date = $this->resolveCarbon($date);
  5190.         $increment = $this->diffInRealSeconds($date, false) / 2;
  5191.         $intIncrement = floor($increment);
  5192.         $microIncrement = (int) (($date->micro - $this->micro) / 2 + 1000000 * ($increment - $intIncrement));
  5193.         $micro = (int) ($this->micro + $microIncrement);
  5194.         while ($micro >= 1000000) {
  5195.             $micro -= 1000000;
  5196.             $intIncrement++;
  5197.         }
  5198.         $this->addSeconds($intIncrement);
  5200.         if (version_compare(PHP_VERSION, '7.1.8-dev', '>=')) {
  5201.             $this->setTime($this->hour, $this->minute, $this->second, $micro);
  5202.         }
  5204.         return $this;
  5205.     }
  5207.     ///////////////////////////////////////////////////////////////////
  5208.     /////////////////////////// SERIALIZATION /////////////////////////
  5209.     ///////////////////////////////////////////////////////////////////
  5211.     /**
  5212.      * Return a serialized string of the instance.
  5213.      *
  5214.      * @return string
  5215.      */
  5216.     public function serialize()
  5217.     {
  5218.         return serialize($this);
  5219.     }
  5221.     /**
  5222.      * Create an instance from a serialized string.
  5223.      *
  5224.      * @param string $value
  5225.      *
  5226.      * @throws \InvalidArgumentException
  5227.      *
  5228.      * @return static
  5229.      */
  5230.     public static function fromSerialized($value)
  5231.     {
  5232.         $instance = @unserialize($value);
  5234.         if (!$instance instanceof static) {
  5235.             throw new InvalidArgumentException('Invalid serialized value.');
  5236.         }
  5238.         return $instance;
  5239.     }
  5241.     /**
  5242.      * The __set_state handler.
  5243.      *
  5244.      * @param array $array
  5245.      *
  5246.      * @return static
  5247.      */
  5248.     public static function __set_state($array)
  5249.     {
  5250.         return static::instance(parent::__set_state($array));
  5251.     }
  5253.     /**
  5254.      * Prepare the object for JSON serialization.
  5255.      *
  5256.      * @return array|string
  5257.      */
  5258.     public function jsonSerialize()
  5259.     {
  5260.         if (static::$serializer) {
  5261.             return call_user_func(static::$serializer, $this);
  5262.         }
  5264.         $carbon = $this;
  5266.         return call_user_func(function () use ($carbon) {
  5267.             return get_object_vars($carbon);
  5268.         });
  5269.     }
  5271.     /**
  5272.      * JSON serialize all Carbon instances using the given callback.
  5273.      *
  5274.      * @param callable $callback
  5275.      *
  5276.      * @return void
  5277.      */
  5278.     public static function serializeUsing($callback)
  5279.     {
  5280.         static::$serializer = $callback;
  5281.     }
  5283.     ///////////////////////////////////////////////////////////////////
  5284.     /////////////////////////////// MACRO /////////////////////////////
  5285.     ///////////////////////////////////////////////////////////////////
  5287.     /**
  5288.      * Register a custom macro.
  5289.      *
  5290.      * @param string          $name
  5291.      * @param object|callable $macro
  5292.      *
  5293.      * @return void
  5294.      */
  5295.     public static function macro($name, $macro)
  5296.     {
  5297.         static::$localMacros[$name] = $macro;
  5298.     }
  5300.     /**
  5301.      * Remove all macros.
  5302.      */
  5303.     public static function resetMacros()
  5304.     {
  5305.         static::$localMacros = array();
  5306.     }
  5308.     /**
  5309.      * Mix another object into the class.
  5310.      *
  5311.      * @param object $mixin
  5312.      *
  5313.      * @return void
  5314.      */
  5315.     public static function mixin($mixin)
  5316.     {
  5317.         $reflection = new \ReflectionClass($mixin);
  5318.         $methods = $reflection->getMethods(
  5319.             \ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED
  5320.         );
  5322.         foreach ($methods as $method) {
  5323.             $method->setAccessible(true);
  5325.             static::macro($method->name, $method->invoke($mixin));
  5326.         }
  5327.     }
  5329.     /**
  5330.      * Checks if macro is registered.
  5331.      *
  5332.      * @param string $name
  5333.      *
  5334.      * @return bool
  5335.      */
  5336.     public static function hasMacro($name)
  5337.     {
  5338.         return isset(static::$localMacros[$name]);
  5339.     }
  5341.     /**
  5342.      * Dynamically handle calls to the class.
  5343.      *
  5344.      * @param string $method
  5345.      * @param array  $parameters
  5346.      *
  5347.      * @throws \BadMethodCallException
  5348.      *
  5349.      * @return mixed
  5350.      */
  5351.     public static function __callStatic($method, $parameters)
  5352.     {
  5353.         if (!static::hasMacro($method)) {
  5354.             throw new \BadMethodCallException("Method $method does not exist.");
  5355.         }
  5357.         if (static::$localMacros[$method] instanceof Closure && method_exists('Closure', 'bind')) {
  5358.             return call_user_func_array(Closure::bind(static::$localMacros[$method], null, get_called_class()), $parameters);
  5359.         }
  5361.         return call_user_func_array(static::$localMacros[$method], $parameters);
  5362.     }
  5364.     /**
  5365.      * Dynamically handle calls to the class.
  5366.      *
  5367.      * @param string $method
  5368.      * @param array  $parameters
  5369.      *
  5370.      * @throws \BadMethodCallException|\ReflectionException
  5371.      *
  5372.      * @return mixed
  5373.      */
  5374.     public function __call($method, $parameters)
  5375.     {
  5376.         if (!static::hasMacro($method)) {
  5377.             throw new \BadMethodCallException("Method $method does not exist.");
  5378.         }
  5380.         $macro = static::$localMacros[$method];
  5382.         $reflexion = new \ReflectionFunction($macro);
  5383.         $reflectionParameters = $reflexion->getParameters();
  5384.         $expectedCount = count($reflectionParameters);
  5385.         $actualCount = count($parameters);
  5386.         if ($expectedCount > $actualCount && $reflectionParameters[$expectedCount - 1]->name === 'self') {
  5387.             for ($i = $actualCount; $i < $expectedCount - 1; $i++) {
  5388.                 $parameters[] = $reflectionParameters[$i]->getDefaultValue();
  5389.             }
  5390.             $parameters[] = $this;
  5391.         }
  5393.         if ($macro instanceof Closure && method_exists($macro, 'bindTo')) {
  5394.             return call_user_func_array($macro->bindTo($this, get_class($this)), $parameters);
  5395.         }
  5397.         return call_user_func_array($macro, $parameters);
  5398.     }
  5400.     /**
  5401.      * Show truthy properties on var_dump().
  5402.      *
  5403.      * @return array
  5404.      */
  5405.     public function __debugInfo()
  5406.     {
  5407.         return array_filter(get_object_vars($this), function ($var) {
  5408.             return $var;
  5409.         });
  5410.     }
  5412.     /**
  5413.      * Cast the current instance into the given class.
  5414.      *
  5415.      * @param string $className The $className::instance() method will be called to cast the current object.
  5416.      *
  5417.      * @return object
  5418.      */
  5419.     public function cast($className)
  5420.     {
  5421.         if (!method_exists($className, 'instance')) {
  5422.             throw new \InvalidArgumentException("$className has not the instance() method needed to cast the date.");
  5423.         }
  5425.         return $className::instance($this);
  5426.     }
  5427. }