vendor/symfony/stopwatch/StopwatchEvent.php line 112

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Stopwatch;
  14. /**
  15.  * Represents an Event managed by Stopwatch.
  16.  *
  17.  * @author Fabien Potencier <fabien@symfony.com>
  18.  */
  19. class StopwatchEvent
  20. {
  21.     /**
  22.      * @var StopwatchPeriod[]
  23.      */
  24.     private $periods = [];
  26.     /**
  27.      * @var float
  28.      */
  29.     private $origin;
  31.     /**
  32.      * @var string
  33.      */
  34.     private $category;
  36.     /**
  37.      * @var bool
  38.      */
  39.     private $morePrecision;
  41.     /**
  42.      * @var float[]
  43.      */
  44.     private $started = [];
  46.     /**
  47.      * @var string
  48.      */
  49.     private $name;
  51.     /**
  52.      * @param float       $origin        The origin time in milliseconds
  53.      * @param string|null $category      The event category or null to use the default
  54.      * @param bool        $morePrecision If true, time is stored as float to keep the original microsecond precision
  55.      * @param string|null $name          The event name or null to define the name as default
  56.      *
  57.      * @throws \InvalidArgumentException When the raw time is not valid
  58.      */
  59.     public function __construct(float $origin, string $category = null, bool $morePrecision = false, string $name = null)
  60.     {
  61.         $this->origin = $this->formatTime($origin);
  62.         $this->category = \is_string($category) ? $category : 'default';
  63.         $this->morePrecision = $morePrecision;
  64.         $this->name = $name ?? 'default';
  65.     }
  67.     /**
  68.      * Gets the category.
  69.      *
  70.      * @return string
  71.      */
  72.     public function getCategory()
  73.     {
  74.         return $this->category;
  75.     }
  77.     /**
  78.      * Gets the origin in milliseconds.
  79.      *
  80.      * @return float
  81.      */
  82.     public function getOrigin()
  83.     {
  84.         return $this->origin;
  85.     }
  87.     /**
  88.      * Starts a new event period.
  89.      *
  90.      * @return $this
  91.      */
  92.     public function start()
  93.     {
  94.         $this->started[] = $this->getNow();
  96.         return $this;
  97.     }
  99.     /**
  100.      * Stops the last started event period.
  101.      *
  102.      * @return $this
  103.      *
  104.      * @throws \LogicException When stop() is called without a matching call to start()
  105.      */
  106.     public function stop()
  107.     {
  108.         if (!\count($this->started)) {
  109.             throw new \LogicException('stop() called but start() has not been called before.');
  110.         }
  112.         $this->periods[] = new StopwatchPeriod(array_pop($this->started), $this->getNow(), $this->morePrecision);
  114.         return $this;
  115.     }
  117.     /**
  118.      * Checks if the event was started.
  119.      *
  120.      * @return bool
  121.      */
  122.     public function isStarted()
  123.     {
  124.         return !empty($this->started);
  125.     }
  127.     /**
  128.      * Stops the current period and then starts a new one.
  129.      *
  130.      * @return $this
  131.      */
  132.     public function lap()
  133.     {
  134.         return $this->stop()->start();
  135.     }
  137.     /**
  138.      * Stops all non already stopped periods.
  139.      */
  140.     public function ensureStopped()
  141.     {
  142.         while (\count($this->started)) {
  143.             $this->stop();
  144.         }
  145.     }
  147.     /**
  148.      * Gets all event periods.
  149.      *
  150.      * @return StopwatchPeriod[]
  151.      */
  152.     public function getPeriods()
  153.     {
  154.         return $this->periods;
  155.     }
  157.     /**
  158.      * Gets the relative time of the start of the first period in milliseconds.
  159.      *
  160.      * @return int|float
  161.      */
  162.     public function getStartTime()
  163.     {
  164.         if (isset($this->periods[0])) {
  165.             return $this->periods[0]->getStartTime();
  166.         }
  168.         if ($this->started) {
  169.             return $this->started[0];
  170.         }
  172.         return 0;
  173.     }
  175.     /**
  176.      * Gets the relative time of the end of the last period in milliseconds.
  177.      *
  178.      * @return int|float
  179.      */
  180.     public function getEndTime()
  181.     {
  182.         $count = \count($this->periods);
  184.         return $count ? $this->periods[$count - 1]->getEndTime() : 0;
  185.     }
  187.     /**
  188.      * Gets the duration of the events in milliseconds (including all periods).
  189.      *
  190.      * @return int|float
  191.      */
  192.     public function getDuration()
  193.     {
  194.         $periods = $this->periods;
  195.         $left = \count($this->started);
  197.         for ($i = $left - 1; $i >= 0; --$i) {
  198.             $periods[] = new StopwatchPeriod($this->started[$i], $this->getNow(), $this->morePrecision);
  199.         }
  201.         $total = 0;
  202.         foreach ($periods as $period) {
  203.             $total += $period->getDuration();
  204.         }
  206.         return $total;
  207.     }
  209.     /**
  210.      * Gets the max memory usage of all periods in bytes.
  211.      *
  212.      * @return int
  213.      */
  214.     public function getMemory()
  215.     {
  216.         $memory = 0;
  217.         foreach ($this->periods as $period) {
  218.             if ($period->getMemory() > $memory) {
  219.                 $memory = $period->getMemory();
  220.             }
  221.         }
  223.         return $memory;
  224.     }
  226.     /**
  227.      * Return the current time relative to origin in milliseconds.
  228.      *
  229.      * @return float
  230.      */
  231.     protected function getNow()
  232.     {
  233.         return $this->formatTime(microtime(true) * 1000 - $this->origin);
  234.     }
  236.     /**
  237.      * Formats a time.
  238.      *
  239.      * @throws \InvalidArgumentException When the raw time is not valid
  240.      */
  241.     private function formatTime(float $time): float
  242.     {
  243.         return round($time, 1);
  244.     }
  246.     /**
  247.      * Gets the event name.
  248.      */
  249.     public function getName(): string
  250.     {
  251.         return $this->name;
  252.     }
  254.     public function __toString(): string
  255.     {
  256.         return sprintf('%s/%s: %.2F MiB - %d ms', $this->getCategory(), $this->getName(), $this->getMemory() / 1024 / 1024, $this->getDuration());
  257.     }
  258. }