AbstractTimer::computeElapsed() - Code Metrics - alecrabbit/php-timers - Measure and Improve Code Quality continuously with Scrutinizer

AbstractTimer::computeElapsed() A
last analyzed 2021-12-07 03:17 UTC

↳ Parent: AbstractTimer

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php declare(strict_types=1);

namespace AlecRabbit\Timers\Core;

use AlecRabbit\Formatters\Contracts\TimerReportFormatterInterface;
use AlecRabbit\Reports\Core\AbstractReportable;
use AlecRabbit\Timers\Contracts\TimerInterface;
use AlecRabbit\Timers\Core\Traits\TimerFields;

/**
 * Class AbstractTimer
 */
abstract class AbstractTimer extends AbstractReportable implements TimerInterface
{
    use TimerFields;

    /**
     * Timer constructor.
     * @param null|string $name
     * @param bool $start
     * @throws \Exception
     */
    public function __construct(?string $name = null, bool $start = true)
    {
        parent::__construct();
        $this->checkEnvironment();
        $this->name = $this->defaultName($name);
        $this->creationTime = new \DateTimeImmutable();
        $this->computeElapsed();
        if ($start) {
            $this->start();
        }
    }

    protected function checkEnvironment(): void
    {
    }

    /**
     * @throws \Exception
     */
    protected function computeElapsed(): void
    {
        $this->elapsed = (new \DateTimeImmutable())->diff($this->creationTime);
    }

    /**
     * Starts the timer.
     *
     * @return void
     */
    public function start(): void
    {
        if ($this->isNotStarted()) {
            $this->previous = $this->current();
        }
        $this->started = true;
    }

    abstract public function current();

    /**
     * Marks the time.
     * If timer was not started starts the timer.
     * @param int|null $iterationNumber
     * @return self
     */
    public function check(?int $iterationNumber = null): self
    {
        if ($this->isStopped()) {
            throw new \RuntimeException('Timer[' . $this->name . '] is already stopped.');
        }
        if ($this->isNotStarted()) {
            $this->start();
        } else {
            $this->mark($iterationNumber);
        }
        return $this;
    }

    /**
     * @param int|null $iterationNumber
     */
    protected function mark(?int $iterationNumber = null): void
    {
        $current = $this->current();
        $this->currentValue = $current - $this->previous;
        $this->previous = $current;

        $this->compute($iterationNumber);
    }

    /**
     * @param null|int $iterationNumber
     */
    protected function compute(?int $iterationNumber): void
    {
        if (0 !== $this->count) {
            ++$this->count;
            $this->checkMinValue($iterationNumber);
            $this->checkMaxValue($iterationNumber);
            $this->computeAverage();
        } else {
            $this->initValues();
        }
    }

    /**
     * @param null|int $iterationNumber
     */
    protected function checkMinValue(?int $iterationNumber): void
    {
        if ($this->currentValue < $this->minValue) {
            $this->minValue = $this->currentValue;
            $this->minValueIteration = $iterationNumber ?? $this->count;
        }
    }

    /**
     * @param null|int $iterationNumber
     */
    protected function checkMaxValue(?int $iterationNumber): void
    {
        if ($this->currentValue > $this->maxValue) {
            $this->maxValue = $this->currentValue;
            $this->maxValueIteration = $iterationNumber ?? $this->count;
        }
    }

    protected function computeAverage(): void
    {
        $this->avgValue = (($this->avgValue * ($this->count - 1)) + $this->currentValue) / $this->count;
    }

    protected function initValues(): void
    {
        $this->maxValueIteration = $this->minValueIteration = $this->count = 1;
        $this->maxValue = $this->currentValue;
        $this->minValue = $this->currentValue;
        $this->avgValue = $this->currentValue;
    }

    /**
     * Stops the timer and returns elapsed time string.
     * @return string
     * @throws \Exception
     */
    public function elapsed(): string
    {
        if ($this->isNotStopped()) {
            $this->stop();
        }
        return
            $this->formattedElapsed();
    }

    /**
     * Stops the timer.
     * @throws \Exception
     */
    public function stop(): void
    {
        $this->computeElapsed();
        $this->stopped = true;
    }

    /**
     * @return string
     * @throws \Exception
     */
    protected function formattedElapsed(): string
    {
        $formatter = $this->report()->getFormatter();
        if ($formatter instanceof TimerReportFormatterInterface) {
            return $formatter->formatElapsed($this->elapsed);
        }
        // @codeCoverageIgnoreStart
        return
            $this->elapsed->format('%ss');
        // @codeCoverageIgnoreEnd
    }

    /**
     * @return \DateInterval
     * @throws \Exception
     */
    public function getElapsed(): \DateInterval
    {
        if ($this->isNotStopped()) {
            $this->computeElapsed();
        }
        return $this->elapsed;
    }

    /**
     * @param int|float $start
     * @param int|float $stop
     * @param null|int $iterationNumber
     * @return self
     */
    public function bounds($start, $stop, ?int $iterationNumber = null): self
    {
        $this->assertStartAndStop($start, $stop);
        if ($this->isNotStarted()) {
            $this->start();
        }
        $this->updateCurrentAndPrevious($start, $stop);

        $this->compute($iterationNumber);
        return $this;
    }

    /**
     * @psalm-suppress MissingParamType
     */
    abstract protected function assertStartAndStop(/** @noinspection PhpDocSignatureInspection */ $start, $stop): void;

    /**
     * @param float $start
     * @param float $stop
     */
    protected function updateCurrentAndPrevious($start, $stop): void
    {
        $this->currentValue = $stop - $start;
        $this->previous = $stop;
    }
}


1		<?php declare(strict_types=1);
2
3		namespace AlecRabbit\Timers\Core;
4
5		use AlecRabbit\Formatters\Contracts\TimerReportFormatterInterface;
6		use AlecRabbit\Reports\Core\AbstractReportable;
7		use AlecRabbit\Timers\Contracts\TimerInterface;
8		use AlecRabbit\Timers\Core\Traits\TimerFields;
9
10		/**
11		* Class AbstractTimer
12		*/
13		abstract class AbstractTimer extends AbstractReportable implements TimerInterface
14		{
15		use TimerFields;
16
17		/**
18		* Timer constructor.
19		* @param null\|string $name
20		* @param bool $start
21		* @throws \Exception
22		*/
23	39	public function __construct(?string $name = null, bool $start = true)
24		{
25	39	parent::__construct();
26	39	$this->checkEnvironment();
27	39	$this->name = $this->defaultName($name);
28	39	$this->creationTime = new \DateTimeImmutable();
29	39	$this->computeElapsed();
30	39	if ($start) {
31	27	$this->start();
32		}
33	39	}
34
35	19	protected function checkEnvironment(): void
36		{
37	19	}
38
39		/**
40		* @throws \Exception
41		*/
42	39	protected function computeElapsed(): void
43		{
44	39	$this->elapsed = (new \DateTimeImmutable())->diff($this->creationTime);
45	39	}
46
47		/**
48		* Starts the timer.
49		*
50		* @return void
51		*/
52	32	public function start(): void
53		{
54	32	if ($this->isNotStarted()) {
55	32	$this->previous = $this->current();
56		}
57	32	$this->started = true;
58	32	}
59
60		abstract public function current();
61
62		/**
63		* Marks the time.
64		* If timer was not started starts the timer.
65		* @param int\|null $iterationNumber
66		* @return self
67		*/
68	7	public function check(?int $iterationNumber = null): self
69		{
70	7	if ($this->isStopped()) {
71	1	throw new \RuntimeException('Timer[' . $this->name . '] is already stopped.');
72		}
73	7	if ($this->isNotStarted()) {
74	2	$this->start();
75		} else {
76	7	$this->mark($iterationNumber);
77		}
78	7	return $this;
79		}
80
81		/**
82		* @param int\|null $iterationNumber
83		*/
84	7	protected function mark(?int $iterationNumber = null): void
85		{
86	7	$current = $this->current();
87	7	$this->currentValue = $current - $this->previous;
88	7	$this->previous = $current;
89
90	7	$this->compute($iterationNumber);
91	7	}
92
93		/**
94		* @param null\|int $iterationNumber
95		*/
96	12	protected function compute(?int $iterationNumber): void
97		{
98	12	if (0 !== $this->count) {
99	11	++$this->count;
100	11	$this->checkMinValue($iterationNumber);
101	11	$this->checkMaxValue($iterationNumber);
102	11	$this->computeAverage();
103		} else {
104	12	$this->initValues();
105		}
106	12	}
107
108		/**
109		* @param null\|int $iterationNumber
110		*/
111	11	protected function checkMinValue(?int $iterationNumber): void
112		{
113	11	if ($this->currentValue < $this->minValue) {
114	5	$this->minValue = $this->currentValue;
115	5	$this->minValueIteration = $iterationNumber ?? $this->count;
116		}
117	11	}
118
119		/**
120		* @param null\|int $iterationNumber
121		*/
122	11	protected function checkMaxValue(?int $iterationNumber): void
123		{
124	11	if ($this->currentValue > $this->maxValue) {
125	8	$this->maxValue = $this->currentValue;
126	8	$this->maxValueIteration = $iterationNumber ?? $this->count;
127		}
128	11	}
129
130	11	protected function computeAverage(): void
131		{
132	11	$this->avgValue = (($this->avgValue * ($this->count - 1)) + $this->currentValue) / $this->count;
133	11	}
134
135	12	protected function initValues(): void
136		{
137	12	$this->maxValueIteration = $this->minValueIteration = $this->count = 1;
138	12	$this->maxValue = $this->currentValue;
139	12	$this->minValue = $this->currentValue;
140	12	$this->avgValue = $this->currentValue;
141	12	}
142
143		/**
144		* Stops the timer and returns elapsed time string.
145		* @return string
146		* @throws \Exception
147		*/
148	5	public function elapsed(): string
149		{
150	5	if ($this->isNotStopped()) {
151	5	$this->stop();
152		}
153		return
154	5	$this->formattedElapsed();
155		}
156
157		/**
158		* Stops the timer.
159		* @throws \Exception
160		*/
161	6	public function stop(): void
162		{
163	6	$this->computeElapsed();
164	6	$this->stopped = true;
165	6	}
166
167		/**
168		* @return string
169		* @throws \Exception
170		*/
171	5	protected function formattedElapsed(): string
172		{
173	5	$formatter = $this->report()->getFormatter();
174	5	if ($formatter instanceof TimerReportFormatterInterface) {
175	5	return $formatter->formatElapsed($this->elapsed);
176		}
177		// @codeCoverageIgnoreStart
178		return
179		$this->elapsed->format('%ss');
180		// @codeCoverageIgnoreEnd
181		}
182
183		/**
184		* @return \DateInterval
185		* @throws \Exception
186		*/
187	15	public function getElapsed(): \DateInterval
188		{
189	15	if ($this->isNotStopped()) {
190	14	$this->computeElapsed();
191		}
192	15	return $this->elapsed;
193		}
194
195		/**
196		* @param int\|float $start
197		* @param int\|float $stop
198		* @param null\|int $iterationNumber
199		* @return self
200		*/
201	9	public function bounds($start, $stop, ?int $iterationNumber = null): self
202		{
203	9	$this->assertStartAndStop($start, $stop);
204	5	if ($this->isNotStarted()) {
205	1	$this->start();
206		}
207	5	$this->updateCurrentAndPrevious($start, $stop);
208
209	5	$this->compute($iterationNumber);
210	5	return $this;
211		}
212
213		/**
214		* @psalm-suppress MissingParamType
215		*/
216		abstract protected function assertStartAndStop(/** @noinspection PhpDocSignatureInspection */ $start, $stop): void;
217
218		/**
219		* @param float $start
220		* @param float $stop
221		*/
222	5	protected function updateCurrentAndPrevious($start, $stop): void
223		{
224	5	$this->currentValue = $stop - $start;
225	5	$this->previous = $stop;
226	5	}
227		}
228

alecrabbit / php-timers

AbstractTimer::computeElapsed() A last analyzed 2021-12-07 03:17 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractTimer::computeElapsed() A
last analyzed 2021-12-07 03:17 UTC