Ivory\Value\TimeBase

Complexity

Total Complexity

29

Size/Duplication

Total Lines	181
Duplicated Lines	4.42 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	partsToSec()	0	12	3
B	partsToSecStrict()	8	20	10
A	cutUnixTimestampToSec()	0	14	3
A	__construct()	0	4	1
A	getHours()	0	4	1
A	getMinutes()	0	4	1
A	getSeconds()	0	4	1
A	toUnixTimestamp()	0	16	4
A	format()	0	20	3
A	toString()	0	9	2

<?php
namespace Ivory\Value;

use Ivory\Utils\ComparableWithPhpOperators;
use Ivory\Utils\IComparable;

/**
 * Common base for time representations.
 *
 * @internal Only for the purpose of Ivory itself.
 */
abstract class TimeBase implements IComparable
{
    use ComparableWithPhpOperators;

    /** Number of decimal digits of precision in the fractional seconds part. */
    const PRECISION = 6;

    /** @var int|float */
    protected $sec;


    /**
     * @internal
     * @param int $hour
     * @param int $minute
     * @param int|float $second
     * @return int|float
     * @throws \OutOfRangeException
     */
    protected static function partsToSec($hour, $minute, $second)
    {
        $s = $hour * 60 * 60 + $minute * 60 + $second;

        if ($s < 0) {
            throw new \OutOfRangeException('The resulting time underruns 00:00:00');
        } elseif ($s > 24 * 60 * 60) {
            throw new \OutOfRangeException('The resulting time exceeds 24:00:00');
        } else {
            return $s;
        }
    }

    /**
     * @internal
     * @param int $hour
     * @param int $minute
     * @param int|float $second
     * @return int|float
     * @throws \OutOfRangeException
     */
    protected static function partsToSecStrict($hour, $minute, $second)
    {
        if ($hour == 24) {

This code seems to be duplicated across your project.

            if ($minute > 0 || $second > 0) {
                throw new \OutOfRangeException('with hour 24, the minutes and seconds must be zero');
            }
        } elseif ($hour < 0 || $hour > 24) {
            throw new \OutOfRangeException('hours');
        }

        if ($minute < 0 || $minute > 59) {
            throw new \OutOfRangeException('minutes');
        }

        if ($second < 0 || $second >= 61) {
            throw new \OutOfRangeException('seconds');
        }

        return $hour * 60 * 60 + $minute * 60 + $second;
    }

    /**
     * @internal
     * @param int|float $timestamp
     * @return int
     */
    protected static function cutUnixTimestampToSec($timestamp)
    {
        if ($timestamp == 24 * 60 * 60) {
            return $timestamp;
        }

        $dayRes = (int)($timestamp - ($timestamp % (24 * 60 * 60)));
        $sec = $timestamp - $dayRes;
        if ($sec < 0) {
            $sec += 24 * 60 * 60;
        }

        return $sec;
    }

    /**
     * @internal Only for the purpose of Ivory itself.
     * @param int|float $sec
     */
    protected function __construct($sec)
    {
        $this->sec = $sec;
    }

    /**
     * @return int the hours part of the time (0-24)
     */
    public function getHours()
    {
        return (int)($this->sec / (60 * 60));
    }

    /**
     * @return int the minutes part of the time (0-59)
     */
    public function getMinutes()
    {
        return ($this->sec / 60) % 60;
    }

    /**
     * @return int|float the seconds part of the time (0-59), potentially with the fractional part, if any
     */
    public function getSeconds()
    {
        return $this->sec - $this->getMinutes() * 60 - $this->getHours() * 60 * 60;
    }

    /**
     * @param Date|string|null $date the date for the resulting timestamp;
     *                               besides a {@link Date} object, an ISO date string is accepted - see
     *                                 {@link Date::fromISOString()};
     *                               the given date (if any) must be finite;
     *                               if not given the time on 1970-01-01 is returned, which is effectively the amount of
     *                                 time, in seconds, between the time this object represents and <tt>00:00:00</tt>
     * @return float|int the UNIX timestamp of this time on the given day
     * @throws \InvalidArgumentException if the date is infinite or if the <tt>$date</tt> string is not a valid ISO date
     *                                     string
     */
    public function toUnixTimestamp($date = null)
    {
        if ($date === null) {
            return $this->sec;
        } else {
            if (!$date instanceof Date) {
                $date = Date::fromISOString($date);
            }
            $dayTs = $date->toUnixTimestamp();
            if ($dayTs !== null) {
                return $dayTs + $this->sec;
            } else {
                throw new \InvalidArgumentException('infinite date');
            }
        }
    }

    /**
     * @param string $timeFmt the format string as accepted by {@link date()}
     * @return string the time formatted according to <tt>$timeFmt</tt>
     */
    public function format($timeFmt)
    {
        $ts = $this->toUnixTimestamp();

        // microseconds are not supported by gmdate(), and constructing a new \DateTime object would be overkill
        if (strpos($timeFmt, 'u') !== false) {
            $frac = round($ts - (int)$ts, self::PRECISION);
            $fracPart = ($frac ? substr($frac, 2) : '0'); // cut off the leading "0." for non-zero fractional seconds
            $fracStr = str_pad($fracPart, 6, '0', STR_PAD_RIGHT);

            $re = '~
                   (?<!\\\\)            # not prefixed with a backslash
                   ((?:\\\\\\\\)*)      # any number of pairs of backslashes, each meaning a single literal backslash
                   u                    # the microseconds format character to be replaced
                   ~x';
            $timeFmt = preg_replace($re, '${1}' . $fracStr, $timeFmt);
        }

        return gmdate($timeFmt, $ts);
    }

    /**
     * @return string the ISO representation of this time, in format <tt>HH:MM:SS[.p]</tt>;
     *                the fractional seconds part is only used if non-zero
     */
    public function toString()
    {
        $frac = round($this->sec - (int)$this->sec, self::PRECISION);
        return sprintf(
            '%02d:%02d:%02d%s',
            $this->getHours(), $this->getMinutes(), $this->getSeconds(),
            ($frac ? substr($frac, 1) : '') // cut off the leading "0" for non-zero fractional seconds
        );
    }
}