AlecRabbit\Tools\Reports\BenchmarkReport

Complexity

Total Complexity

12

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Test Coverage

Coverage

94.12%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getRelatives()	0	3	1
A	computeRelatives()	0	18	4
A	computeAverages()	0	14	4
A	getFunctionObject()	0	3	1
A	__construct()	0	11	1
A	getFunctionObjects()	0	3	1

<?php
/**
 * User: alec
 * Date: 29.11.18
 * Time: 20:56
 */

namespace AlecRabbit\Tools\Reports;

use AlecRabbit\Tools\Benchmark;
use AlecRabbit\Tools\Internal\BenchmarkFunction;
use AlecRabbit\Tools\Internal\BenchmarkRelative;
use AlecRabbit\Tools\Reports\Base\Report;
use AlecRabbit\Tools\Timer;
use AlecRabbit\Tools\Traits\BenchmarkFields;
use const \AlecRabbit\Constants\Traits\DEFAULT_NAME;

The constant AlecRabbit\Constants\Traits\DEFAULT_NAME was not found. Maybe you did not declare it correctly or list all dependencies?

class BenchmarkReport extends Report
{
    use BenchmarkFields;

    /** @var array */
    protected $relatives;

    /**
     * BenchmarkReport constructor.
     * @param Benchmark $benchmark
     */
    public function __construct(Benchmark $benchmark)
    {
        $this->profiler = $benchmark->getProfiler();
        $this->functions = $benchmark->getFunctions();
        $this->totalIterations = $benchmark->getTotalIterations();
        $this->withResults = $benchmark->isWithResults();
        $this->exceptionMessages = $benchmark->getExceptionMessages();
        $this->exceptions = $benchmark->getExceptions();
        $this->relatives = $this->computeRelatives();

        parent::__construct();
    }

    /**
     * @return array
     */
    private function computeRelatives(): array
    {
        $averages = $this->computeAverages($this->profiler->getTimers());
        $relatives = [];
        if (!empty($averages)) {
            $min = min($averages);

            foreach ($averages as $name => $average) {
                $relatives[$name] = $average / $min;
            }
            asort($relatives);

            /** @var  float|int $relative */
            foreach ($relatives as $name => $relative) {
                $relatives[$name] = new BenchmarkRelative((float)$relative - 1, $averages[$name]);
            }
        }
        return $relatives;
    }

    /**
     * @param array $timers
     * @return array
     */
    private function computeAverages(array $timers): array
    {
        $averages = [];
        /** @var Timer $timer */
        foreach ($timers as $timer) {
            if (DEFAULT_NAME !== $name = $timer->getName()) {
                try {
                    $averages[$name] = $timer->getAverageValue();
                } catch (\Throwable $e) {
                    // no further action
                }
            }
        }
        return $averages;
    }

    /**
     * @param string $name
     * @return BenchmarkFunction
     */
    public function getFunctionObject(string $name): BenchmarkFunction
    {
        return $this->functions[$name];
    }

    /**
     * @return array
     */
    public function getFunctionObjects(): array
    {
        return $this->functions;
    }

    /**
     * @return array
     */
    public function getRelatives(): array
    {
        return $this->relatives;
    }
}