index/src/TimeSpan.php

526 lines
17 KiB
PHP

<?php
// TimeSpan.php
// Created: 2021-06-11
// Updated: 2022-02-27
namespace Index;
use DateInterval;
use JsonSerializable;
use Stringable;
/**
* Represents a duration of time.
*/
class TimeSpan extends DateInterval implements JsonSerializable, Stringable, IComparable, IEquatable {
private const HOURS_IN_DAY = 24;
private const MINS_IN_HOUR = 60;
private const SECS_IN_MIN = 60;
private const MILLIS_IN_SEC = 1000;
private const MINS_IN_DAY = 1440;
private const SECS_IN_HOUR = 3600;
private const MILLIS_IN_MIN = 60000;
private const SECS_IN_DAY = 86400;
private const MICROS_IN_SEC = 1000000;
private const MILLIS_IN_HOUR = 3600000;
private const MICROS_IN_MIN = 60000000;
private const MILLIS_IN_DAY = 86400000;
private const MICROS_IN_HOUR = 3600000000;
private const MICROS_IN_DAY = 86400000000;
private int $realDays = -1;
/**
* Creates a new instance of TimeSpan.
*
* @param string $duration An ISO8601 duration string.
* @return TimeSpan A TimeSpan instance representing the given duration.
*/
public function __construct(string $duration = 'PT0S') {
parent::__construct($duration);
$this->realDays = $this->days === false ? $this->calculateRealDays() : $this->days;
}
private function calculateRealDays(): int {
return ($this->y * 365)
+ ($this->m * 31)
+ $this->d;
}
/**
* Gets the amount of days this TimeSpan represents.
*
* @return int Amount of days.
*/
public function getDays(): int {
return $this->realDays;
}
/**
* Gets the amount of hours this TimeSpan represents.
*
* @retunr int Amount of hours.
*/
public function getHours(): int {
return $this->h;
}
/**
* Gets the amount of minutes this TimeSpan represents.
*
* @return int Amount of minutes.
*/
public function getMinutes(): int {
return $this->i;
}
/**
* Gets the amount of seconds this TimeSpan represents.
*
* @return int Amount of seconds.
*/
public function getSeconds(): int {
return $this->s;
}
/**
* Gets the amount of milliseconds this TimeSpan represents.
*
* @return int Amount of milliseconds.
*/
public function getMilliseconds(): int {
return (int)($this->f * 1000);
}
/**
* Gets the amount of microseconds this TimeSpan represents.
*
* @return int Amount of microseconds.
*/
public function getMicroseconds(): int {
return (int)($this->f * 1000000);
}
/**
* Gets whether this TimeSpan represents a negative amount of time.
*
* @return bool true if negative, false if positive.
*/
public function isNegative(): bool {
return $this->invert !== 0;
}
/**
* Counts the total amount of days this TimeSpan contains.
*
* @return float Total amount of days.
*/
public function totalDays(): float {
$days = $this->getDays();
$days += $this->getHours() / self::HOURS_IN_DAY;
$days += $this->getMinutes() / self::MINS_IN_DAY;
$days += $this->getSeconds() / self::SECS_IN_DAY;
$days += $this->getMicroseconds() / self::MICROS_IN_DAY;
return $days;
}
/**
* Counts the total amount of hours this TimeSpan contains.
*
* @return float Total amount of hours.
*/
public function totalHours(): float {
$hours = $this->getDays() * self::HOURS_IN_DAY;
$hours += $this->getHours();
$hours += $this->getMinutes() / self::MINS_IN_HOUR;
$hours += $this->getSeconds() / self::SECS_IN_HOUR;
$hours += $this->getMicroseconds() / self::MICROS_IN_HOUR;
return $hours;
}
/**
* Counts the total amount of minutes this TimeSpan contains.
*
* @return float Total amount of minutes.
*/
public function totalMinutes(): float {
$mins = $this->getDays() * self::MINS_IN_DAY;
$mins += $this->getHours() * self::MINS_IN_HOUR;
$mins += $this->getMinutes();
$mins += $this->getSeconds() / self::SECS_IN_MIN;
$mins += $this->getMicroseconds() / self::MICROS_IN_MIN;
return $mins;
}
/**
* Counts the total amount of seconds this TimeSpan contains.
*
* @return float Total amount of seconds.
*/
public function totalSeconds(): float {
$secs = $this->getDays() * self::SECS_IN_DAY;
$secs += $this->getHours() * self::SECS_IN_HOUR;
$secs += $this->getMinutes() * self::SECS_IN_MIN;
$secs += $this->getSeconds();
$secs += $this->getMicroseconds() * self::MICROS_IN_SEC;
return $secs;
}
/**
* Counts the total amount of milliseconds this TimeSpan contains.
*
* @return float Total amount of milliseconds.
*/
public function totalMilliseconds(): float {
$millis = $this->getDays() * self::MILLIS_IN_DAY;
$millis += $this->getHours() * self::MILLIS_IN_HOUR;
$millis += $this->getMinutes() * self::MILLIS_IN_MIN;
$millis += $this->getSeconds() * self::MILLIS_IN_SEC;
$millis += $this->getMilliseconds();
return $millis;
}
/**
* Counts the total amount of microseconds this TimeSpan contains.
*
* @return float Total amount of microseconds.
*/
public function totalMicroseconds(): float {
$micros = $this->getDays() * self::MICROS_IN_DAY;
$micros += $this->getHours() * self::MICROS_IN_HOUR;
$micros += $this->getMinutes() * self::MICROS_IN_MIN;
$micros += $this->getSeconds() * self::MICROS_IN_SEC;
$micros += $this->getMicroseconds();
return $micros;
}
/**
* Returns a new TimeSpan whose value is the sum of this instance and the provided instance.
*
* @param DateInterval $timeSpan Interval to add.
* @return TimeSpan Instance that represents this instance plus the value of $timeSpan.
*/
public function add(DateInterval $timeSpan): TimeSpan {
$timeSpan = self::cast($timeSpan);
$days1 = $this->totalDays();
if($this->isNegative())
$days1 *= -1;
$days2 = $timeSpan->totalDays();
if($timeSpan->isNegative())
$days2 *= -1;
return self::fromDays($days1 + $days2);
}
/**
* Returns a new TimeSpan whose value is the difference of this instance and the provided instance.
*
* @param DateInterval $timeSpan Interval to subtract.
* @return TimeSpan Instance that represents this instance minus the value of $timeSpan.
*/
public function subtract(DateInterval $timeSpan): TimeSpan {
$timeSpan = self::cast($timeSpan);
$days1 = $this->totalDays();
if($this->isNegative())
$days1 *= -1;
$days2 = $timeSpan->totalDays();
if($timeSpan->isNegative())
$days2 *= -1;
return self::fromDays($days1 - $days2);
}
/**
* Returns the result of a division of this instance and the provided instance.
*
* @param DateInterval $timeSpan Interval to be divided by.
* @return float $timeSpan Number that represents this instance divided by the value of $timeSpan.
*/
public function divideTimeSpan(DateInterval $timeSpan): float {
$timeSpan = self::cast($timeSpan);
$days1 = $this->totalDays();
if($this->isNegative())
$days1 *= -1;
$days2 = $timeSpan->totalDays();
if($timeSpan->isNegative())
$days2 *= -1;
if($days2 === 0.0)
return 0.0;
return $days1 / $days2;
}
/**
* Returns the result of a division of this instance and the provided divisor.
*
* @param float $divisor Value to divide by.
* @return TimeSpan Instance that represents this instance divided by the value of $divisor.
*/
public function divideFloat(float $divisor): TimeSpan {
$totalDays = $this->totalDays();
if($this->isNegative())
$totalDays *= -1;
$totalDays /= $divisor;
return self::fromDays($totalDays);
}
/**
* Returns a new TimeSpan whose alue is the result of a multiplication of this oinstance and the provided factor.
*
* @param float $factor Value to multiply with.
* @return TimeSpan Instance that represents this instance multiplied by the value of $factor.
*/
public function multiply(float $factor): TimeSpan {
$totalDays = $this->totalDays();
if($this->isNegative())
$totalDays *= -1;
$totalDays *= $factor;
return self::fromDays($totalDays);
}
/**
* Return a new TimeSpan whose value is the negated value of this instance.
*
* @return TimeSpan Negated copy of this instance.
*/
public function negate(): TimeSpan {
return self::create(
$this->getDays(),
$this->getHours(),
$this->getMinutes(),
$this->getSeconds(),
$this->getMicroseconds(),
!$this->isNegative()
);
}
public function compare(mixed $other): int {
if(!($other instanceof DateInterval))
return -1;
$other = self::cast($other);
$diff = $this->getDays() <=> $other->getDays();
if($diff) return $diff;
$diff = $this->getHours() <=> $other->getHours();
if($diff) return $diff;
$diff = $this->getMinutes() <=> $other->getMinutes();
if($diff) return $diff;
$diff = $this->getSeconds() <=> $other->getSeconds();
if($diff) return $diff;
$diff = $this->getMicroseconds() <=> $other->getMicroseconds();
if($diff) return $diff;
$diff = $this->isNegative() <=> $other->isNegative();
if($diff) return $diff;
return 0;
}
public function equals(mixed $other): bool {
if(!($other instanceof DateInterval))
return false;
$other = self::cast($other);
return $this->getDays() === $other->getDays()
&& $this->getHours() === $other->getHours()
&& $this->getMinutes() === $other->getMinutes()
&& $this->getSeconds() === $other->getSeconds()
&& $this->getMicroseconds() === $other->getMicroseconds()
&& $this->isNegative() === $other->isNegative();
}
/**
* Returns the data which should be serialized as json.
*
* @see https://www.php.net/manual/en/jsonserializable.jsonserialize.php
* @return mixed Data to be passed to json_encode.
*/
public function jsonSerialize(): mixed {
return (string)$this;
}
/**
* Creates a string representation of this object.
*
* @return string Representation of this object.
*/
public function __toString(): string {
$string = $this->isNegative() ? '-' : '';
return sprintf(
'%sP%dY%dM%dDT%dH%dM%d.%dS',
$this->isNegative() ? '-' : '',
$this->y,
$this->m,
$this->d,
$this->getHours(),
$this->getMinutes(),
$this->getSeconds(),
$this->getMicroseconds()
);
}
/**
* Creates a new TimeSpan instance that represents the specified number of days.
*
* @param float $days Number of days.
* @return TimeSpan Instance representing the provided number of days.
*/
public static function fromDays(float $days): TimeSpan {
$abs = abs($days);
$round = (int)floor($abs);
$hours = ($abs - $round) * self::HOURS_IN_DAY;
$hoursRound = (int)floor($hours);
$minutes = ($hours - $hoursRound) * self::MINS_IN_HOUR;
$minsRound = (int)floor($minutes);
$seconds = ($minutes - $minsRound) * self::SECS_IN_MIN;
$secsRound = (int)floor($seconds);
$micros = (int)floor(($seconds - $secsRound) * self::MICROS_IN_SEC);
return self::create($round, $hoursRound, $minsRound, $secsRound, $micros, $days < 0);
}
/**
* Creates a new TimeSpan instance that represents the specified number of hours.
*
* @param float $hours Number of hours.
* @return TimeSpan Instance representing the provided number of hours.
*/
public static function fromHours(float $hours): TimeSpan {
$abs = abs($hours);
$round = (int)floor($abs);
$minutes = ($abs - $round) * self::MINS_IN_HOUR;
$minsRound = (int)floor($minutes);
$seconds = ($minutes - $minsRound) * self::SECS_IN_MIN;
$secsRound = (int)floor($seconds);
$micros = (int)floor(($seconds - $secsRound) * self::MICROS_IN_SEC);
return self::create(0, $round, $minsRound, $secsRound, $micros, $hours < 0);
}
/**
* Creates a new TimeSpan instance that represents the specified number of minutes.
*
* @param float $minutes Number of minutes.
* @return TimeSpan Instance representing the provided number of minutes.
*/
public static function fromMinutes(float $minutes): TimeSpan {
$abs = abs($minutes);
$round = (int)floor($abs);
$seconds = ($abs - $round) * self::SECS_IN_MIN;
$secsRound = (int)floor($seconds);
$micros = (int)floor(($seconds - $secsRound) * self::MICROS_IN_SEC);
return self::create(0, 0, $round, $secsRound, $micros, $minutes < 0);
}
/**
* Creates a new TimeSpan instance that represents the specified number of seconds.
*
* @param float $seconds Number of seconds.
* @return TimeSpan Instance representing the provided number of seconds.
*/
public static function fromSeconds(float $seconds): TimeSpan {
$abs = abs($seconds);
$round = (int)floor($abs);
$micros = (int)floor(($abs - $round) * self::MICROS_IN_SEC);
return self::create(0, 0, 0, $round, $micros, $seconds < 0);
}
/**
* Creates a new TimeSpan instance that represents the specified number of milliseconds.
*
* @param float $millis Number of milliseconds.
* @return TimeSpan Instance representing the provided number of milliseconds.
*/
public static function fromMilliseconds(float $millis): TimeSpan {
return self::fromMicroseconds($millis * 1000);
}
/**
* Creates a new TimeSpan instance that represents the specified number of microseconds.
*
* @param float $micros Number of microseconds.
* @return TimeSpan Instance representing the provided number of microseconds.
*/
public static function fromMicroseconds(float $micros): TimeSpan {
return self::create(0, 0, 0, 0, (int)floor(abs($micros)), $micros < 0);
}
/**
* Creates a new TimeSpan using the given parameters.
*
* @param int $days Number of days.
* @param int $hours Number of hours.
* @param int $minutes Number of minutes.
* @param int $seconds Number of seconds.
* @param int $micros Number of microseconds.
* @param bool $negative true for a negative TimeSpan, false for positive.
* @return TimeSpan A new TimeSpan from the provided parameters.
*/
public static function create(int $days, int $hours, int $minutes, int $seconds, int $micros = 0, bool $negative = false): TimeSpan {
$ts = new TimeSpan;
$ts->realDays = $days = max(0, $days);
$ts->h = max(0, min(23, $hours));
$ts->i = max(0, min(59, $minutes));
$ts->s = max(0, min(59, $seconds));
$ts->f = $micros / self::MICROS_IN_SEC;
$ts->invert = $negative ? 1 : 0;
// this may still be stupid
if($days > 0) {
$days /= 365;
$ts->y = (int)$days;
$days -= $ts->y;
$days *= 12;
$ts->m = (int)$days;
$days -= $ts->m;
$days *= 31;
$ts->d = (int)$days;
}
return $ts;
}
/**
* Creates a TimeSpan from the relative parts of a string.
*
* Uses the same parser as strtotime and the DateTime constructor internally.
*
* @param string $dateTime A date with relative parts.
* @return TimeSpan A TimeSpan representing the given
*/
public static function createFromDateString(string $dateTime): TimeSpan {
return self::cast(parent::createFromDateString($dateTime));
}
/**
* Makes sure a DateInterval inheriting object is a TimeSpan instance.
*
* @param DateInterval $dateInterval Input object.
* @return TimeSpan If the input was a TimeSpan, the same instance will be returned.
* If the input was something else, a new TimeSpan instance will be returned based on the input.
*/
public static function cast(DateInterval $dateInterval): TimeSpan {
if($dateInterval instanceof TimeSpan)
return $dateInterval;
$timeSpan = new TimeSpan;
$timeSpan->y = $dateInterval->y;
$timeSpan->m = $dateInterval->m;
$timeSpan->d = $dateInterval->d;
$timeSpan->h = $dateInterval->h;
$timeSpan->i = $dateInterval->i;
$timeSpan->s = $dateInterval->s;
$timeSpan->f = $dateInterval->f;
$timeSpan->invert = $dateInterval->invert;
$timeSpan->realDays = $timeSpan->calculateRealDays();
return $timeSpan;
}
}