vendor/symfony/stopwatch/StopwatchEvent.php line 105

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.      * @param float       $origin        The origin time in milliseconds
  48.      * @param string|null $category      The event category or null to use the default
  49.      * @param bool        $morePrecision If true, time is stored as float to keep the original microsecond precision
  50.      *
  51.      * @throws \InvalidArgumentException When the raw time is not valid
  52.      */
  53.     public function __construct(float $origin, string $category = null, bool $morePrecision = false)
  54.     {
  55.         $this->origin = $this->formatTime($origin);
  56.         $this->category = \is_string($category) ? $category : 'default';
  57.         $this->morePrecision = $morePrecision;
  58.     }
  60.     /**
  61.      * Gets the category.
  62.      *
  63.      * @return string The category
  64.      */
  65.     public function getCategory()
  66.     {
  67.         return $this->category;
  68.     }
  70.     /**
  71.      * Gets the origin.
  72.      *
  73.      * @return float The origin in milliseconds
  74.      */
  75.     public function getOrigin()
  76.     {
  77.         return $this->origin;
  78.     }
  80.     /**
  81.      * Starts a new event period.
  82.      *
  83.      * @return $this
  84.      */
  85.     public function start()
  86.     {
  87.         $this->started[] = $this->getNow();
  89.         return $this;
  90.     }
  92.     /**
  93.      * Stops the last started event period.
  94.      *
  95.      * @return $this
  96.      *
  97.      * @throws \LogicException When stop() is called without a matching call to start()
  98.      */
  99.     public function stop()
  100.     {
  101.         if (!\count($this->started)) {
  102.             throw new \LogicException('stop() called but start() has not been called before.');
  103.         }
  105.         $this->periods[] = new StopwatchPeriod(array_pop($this->started), $this->getNow(), $this->morePrecision);
  107.         return $this;
  108.     }
  110.     /**
  111.      * Checks if the event was started.
  112.      *
  113.      * @return bool
  114.      */
  115.     public function isStarted()
  116.     {
  117.         return !empty($this->started);
  118.     }
  120.     /**
  121.      * Stops the current period and then starts a new one.
  122.      *
  123.      * @return $this
  124.      */
  125.     public function lap()
  126.     {
  127.         return $this->stop()->start();
  128.     }
  130.     /**
  131.      * Stops all non already stopped periods.
  132.      */
  133.     public function ensureStopped()
  134.     {
  135.         while (\count($this->started)) {
  136.             $this->stop();
  137.         }
  138.     }
  140.     /**
  141.      * Gets all event periods.
  142.      *
  143.      * @return StopwatchPeriod[] An array of StopwatchPeriod instances
  144.      */
  145.     public function getPeriods()
  146.     {
  147.         return $this->periods;
  148.     }
  150.     /**
  151.      * Gets the relative time of the start of the first period.
  152.      *
  153.      * @return int|float The time (in milliseconds)
  154.      */
  155.     public function getStartTime()
  156.     {
  157.         if (isset($this->periods[0])) {
  158.             return $this->periods[0]->getStartTime();
  159.         }
  161.         if ($this->started) {
  162.             return $this->started[0];
  163.         }
  165.         return 0;
  166.     }
  168.     /**
  169.      * Gets the relative time of the end of the last period.
  170.      *
  171.      * @return int|float The time (in milliseconds)
  172.      */
  173.     public function getEndTime()
  174.     {
  175.         $count = \count($this->periods);
  177.         return $count ? $this->periods[$count - 1]->getEndTime() : 0;
  178.     }
  180.     /**
  181.      * Gets the duration of the events (including all periods).
  182.      *
  183.      * @return int|float The duration (in milliseconds)
  184.      */
  185.     public function getDuration()
  186.     {
  187.         $periods = $this->periods;
  188.         $left = \count($this->started);
  190.         for ($i = $left - 1; $i >= 0; --$i) {
  191.             $periods[] = new StopwatchPeriod($this->started[$i], $this->getNow(), $this->morePrecision);
  192.         }
  194.         $total = 0;
  195.         foreach ($periods as $period) {
  196.             $total += $period->getDuration();
  197.         }
  199.         return $total;
  200.     }
  202.     /**
  203.      * Gets the max memory usage of all periods.
  204.      *
  205.      * @return int The memory usage (in bytes)
  206.      */
  207.     public function getMemory()
  208.     {
  209.         $memory = 0;
  210.         foreach ($this->periods as $period) {
  211.             if ($period->getMemory() > $memory) {
  212.                 $memory = $period->getMemory();
  213.             }
  214.         }
  216.         return $memory;
  217.     }
  219.     /**
  220.      * Return the current time relative to origin.
  221.      *
  222.      * @return float Time in ms
  223.      */
  224.     protected function getNow()
  225.     {
  226.         return $this->formatTime(microtime(true) * 1000 - $this->origin);
  227.     }
  229.     /**
  230.      * Formats a time.
  231.      *
  232.      * @throws \InvalidArgumentException When the raw time is not valid
  233.      */
  234.     private function formatTime(float $time): float
  235.     {
  236.         return round($time, 1);
  237.     }
  239.     /**
  240.      * @return string
  241.      */
  242.     public function __toString()
  243.     {
  244.         return sprintf('%s: %.2F MiB - %d ms', $this->getCategory(), $this->getMemory() / 1024 / 1024, $this->getDuration());
  245.     }
  246. }