/var/www/vhosts/ihelp.ro/httpdocs/vendor/cakephp/chronos/src
Edit: /var/www/vhosts/ihelp.ro/httpdocs/vendor/cakephp/chronos/src/Chronos.php (9796B)
* @link https://cakephp.org CakePHP(tm) Project
* @license https://www.opensource.org/licenses/mit-license.php MIT License
*/
namespace Cake\Chronos;
use DateInterval;
use DateTimeImmutable;
use DateTimeZone;
/**
* An Immutable extension on the native DateTime object.
*
* Adds a number of convenience APIs methods and the ability
* to easily convert into a mutable object.
*
* @property-read int $year
* @property-read int $yearIso
* @property-read int $month
* @property-read int $day
* @property-read int $hour
* @property-read int $minute
* @property-read int $second
* @property-read int $micro
* @property-read int $microsecond
* @property-read int $timestamp seconds since the Unix Epoch
* @property-read \DateTimeZone $timezone the current timezone
* @property-read \DateTimeZone $tz alias of timezone
* @property-read int $dayOfWeek 1 (for Monday) through 7 (for Sunday)
* @property-read int $dayOfYear 0 through 365
* @property-read int $weekOfMonth 1 through 5
* @property-read int $weekOfYear ISO-8601 week number of year, weeks starting on Monday
* @property-read int $daysInMonth number of days in the given month
* @property-read int $age does a diffInYears() with default parameters
* @property-read int $quarter the quarter of this instance, 1 - 4
* @property-read int $offset the timezone offset in seconds from UTC
* @property-read int $offsetHours the timezone offset in hours from UTC
* @property-read bool $dst daylight savings time indicator, true if DST, false otherwise
* @property-read bool $local checks if the timezone is local, true if local, false otherwise
* @property-read bool $utc checks if the timezone is UTC, true if UTC, false otherwise
* @property-read string $timezoneName
* @property-read string $tzName
*/
class Chronos extends DateTimeImmutable implements ChronosInterface
{
use Traits\ComparisonTrait;
use Traits\DifferenceTrait;
use Traits\FactoryTrait;
use Traits\FormattingTrait;
use Traits\MagicPropertyTrait;
use Traits\ModifierTrait;
use Traits\RelativeKeywordTrait;
use Traits\TimezoneTrait;
/**
* A test ChronosInterface instance to be returned when now instances are created
*
* There is a single test now for all date/time classes provided by Chronos.
* This aims to emulate stubbing out 'now' which is a single global fact.
*
* @var \Cake\Chronos\ChronosInterface|null
*/
protected static $testNow;
/**
* Format to use for __toString method when type juggling occurs.
*
* @var string
*/
protected static $toStringFormat = ChronosInterface::DEFAULT_TO_STRING_FORMAT;
/**
* Create a new Chronos instance.
*
* Please see the testing aids section (specifically static::setTestNow())
* for more on the possibility of this constructor returning a test instance.
*
* @param \DateTimeInterface|string|int|null $time Fixed or relative time
* @param \DateTimeZone|string|null $tz The timezone for the instance
*/
public function __construct($time = 'now', $tz = null)
{
if (is_int($time)) {
parent::__construct('@' . $time);
return;
}
if ($tz !== null) {
$tz = $tz instanceof DateTimeZone ? $tz : new DateTimeZone($tz);
}
if ($time instanceof \DateTimeInterface) {
$time = $time->format('Y-m-d H:i:s.u');
}
static::$_lastErrors = [];
$testNow = static::getTestNow();
if ($testNow === null) {
parent::__construct($time ?? 'now', $tz);
return;
}
$relative = static::hasRelativeKeywords($time);
if (!empty($time) && $time !== 'now' && !$relative) {
parent::__construct($time, $tz);
return;
}
$testNow = clone $testNow;
$relativetime = static::isTimeExpression($time);
if (!$relativetime && $tz !== $testNow->getTimezone()) {
$testNow = $testNow->setTimezone($tz ?? date_default_timezone_get());
}
if ($relative) {
$testNow = $testNow->modify($time);
}
$time = $testNow->format('Y-m-d H:i:s.u');
parent::__construct($time, $tz);
}
/**
* Create a new mutable instance from current immutable instance.
*
* @return \Cake\Chronos\MutableDateTime
*/
public function toMutable(): MutableDateTime
{
trigger_error('2.5 Mutable classes will be removed in 3.0', E_USER_DEPRECATED);
return MutableDateTime::instance($this);
}
/**
* Get a copy of the instance
*
* @return static
*/
public function copy(): ChronosInterface
{
return clone $this;
}
/**
* Set a ChronosInterface instance (real or mock) to be returned when a "now"
* instance is created. The provided instance will be returned
* specifically under the following conditions:
* - A call to the static now() method, ex. ChronosInterface::now()
* - When a null (or blank string) is passed to the constructor or parse(), ex. new Chronos(null)
* - When the string "now" is passed to the constructor or parse(), ex. new Chronos('now')
* - When a string containing the desired time is passed to ChronosInterface::parse()
*
* Note the timezone parameter was left out of the examples above and
* has no affect as the mock value will be returned regardless of its value.
*
* To clear the test instance call this method using the default
* parameter of null.
*
* @param \Cake\Chronos\ChronosInterface|string|null $testNow The instance to use for all future instances.
* @return void
*/
public static function setTestNow($testNow = null): void
{
static::$testNow = is_string($testNow) ? static::parse($testNow) : $testNow;
}
/**
* Get the ChronosInterface instance (real or mock) to be returned when a "now"
* instance is created.
*
* @return \Cake\Chronos\ChronosInterface|null The current instance used for testing
*/
public static function getTestNow(): ?ChronosInterface
{
return static::$testNow;
}
/**
* Determine if there is a valid test instance set. A valid test instance
* is anything that is not null.
*
* @return bool True if there is a test instance, otherwise false
*/
public static function hasTestNow(): bool
{
return static::$testNow !== null;
}
/**
* Create a new DateInterval instance from specified values.
*
* @param int|null $years The year to use.
* @param int|null $months The month to use.
* @param int|null $weeks The week to use.
* @param int|null $days The day to use.
* @param int|null $hours The hours to use.
* @param int|null $minutes The minutes to use.
* @param int|null $seconds The seconds to use.
* @param int|null $microseconds The microseconds to use.
* @return \DateInterval
*/
public static function createInterval(
?int $years = null,
?int $months = null,
?int $weeks = null,
?int $days = null,
?int $hours = null,
?int $minutes = null,
?int $seconds = null,
?int $microseconds = null
): DateInterval {
$spec = 'P';
if ($years) {
$spec .= $years . 'Y';
}
if ($months) {
$spec .= $months . 'M';
}
if ($weeks) {
$spec .= $weeks . 'W';
}
if ($days) {
$spec .= $days . 'D';
}
if ($hours || $minutes || $seconds) {
$spec .= 'T';
if ($hours) {
$spec .= $hours . 'H';
}
if ($minutes) {
$spec .= $minutes . 'M';
}
if ($seconds) {
$spec .= $seconds . 'S';
}
}
if ($microseconds && $spec === 'P') {
$spec .= 'T0S';
}
$instance = new DateInterval($spec);
if ($microseconds) {
$instance->f = $microseconds / 1000000;
}
return $instance;
}
/**
* Return properties for debugging.
*
* @return array
*/
public function __debugInfo(): array
{
$properties = [
'hasFixedNow' => static::hasTestNow(),
'time' => $this->format('Y-m-d H:i:s.u'),
'timezone' => $this->getTimezone()->getName(),
];
return $properties;
}
/**
* Deprecation helper to compare types
*
* Future versions of Chronos will not support comparing date/datetimes to each other.
*
* @param object $first The first object.
* @param object|null $second The second object
* @return void
* @internal
*/
public static function checkTypes(object $first, $second): void
{
$firstClass = get_class($first);
$secondClass = $second !== null ? get_class($second) : null;
if ($second !== null && $firstClass !== $secondClass) {
trigger_error(
"2.5 Comparing {$firstClass} and {$secondClass} is deprecated. " .
'In 3.0 this functionality will be removed.',
E_USER_DEPRECATED
);
}
}
}