vendor/symfony/stopwatch/StopwatchEvent.php line 19

  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 array $periods = [];
  26.     private float $origin;
  27.     private string $category;
  28.     private bool $morePrecision;
  30.     /**
  31.      * @var float[]
  32.      */
  33.     private array $started = [];
  35.     private string $name;
  37.     /**
  38.      * @param float       $origin        The origin time in milliseconds
  39.      * @param string|null $category      The event category or null to use the default
  40.      * @param bool        $morePrecision If true, time is stored as float to keep the original microsecond precision
  41.      * @param string|null $name          The event name or null to define the name as default
  42.      *
  43.      * @throws \InvalidArgumentException When the raw time is not valid
  44.      */
  45.     public function __construct(float $origin, string $category = null, bool $morePrecision = false, string $name = null)
  46.     {
  47.         $this->origin = $this->formatTime($origin);
  48.         $this->category = \is_string($category) ? $category : 'default';
  49.         $this->morePrecision = $morePrecision;
  50.         $this->name = $name ?? 'default';
  51.     }
  53.     /**
  54.      * Gets the category.
  55.      */
  56.     public function getCategory(): string
  57.     {
  58.         return $this->category;
  59.     }
  61.     /**
  62.      * Gets the origin in milliseconds.
  63.      */
  64.     public function getOrigin(): float
  65.     {
  66.         return $this->origin;
  67.     }
  69.     /**
  70.      * Starts a new event period.
  71.      *
  72.      * @return $this
  73.      */
  74.     public function start(): static
  75.     {
  76.         $this->started[] = $this->getNow();
  78.         return $this;
  79.     }
  81.     /**
  82.      * Stops the last started event period.
  83.      *
  84.      * @return $this
  85.      *
  86.      * @throws \LogicException When stop() is called without a matching call to start()
  87.      */
  88.     public function stop(): static
  89.     {
  90.         if (!\count($this->started)) {
  91.             throw new \LogicException('stop() called but start() has not been called before.');
  92.         }
  94.         $this->periods[] = new StopwatchPeriod(array_pop($this->started), $this->getNow(), $this->morePrecision);
  96.         return $this;
  97.     }
  99.     /**
  100.      * Checks if the event was started.
  101.      */
  102.     public function isStarted(): bool
  103.     {
  104.         return !empty($this->started);
  105.     }
  107.     /**
  108.      * Stops the current period and then starts a new one.
  109.      *
  110.      * @return $this
  111.      */
  112.     public function lap(): static
  113.     {
  114.         return $this->stop()->start();
  115.     }
  117.     /**
  118.      * Stops all non already stopped periods.
  119.      */
  120.     public function ensureStopped()
  121.     {
  122.         while (\count($this->started)) {
  123.             $this->stop();
  124.         }
  125.     }
  127.     /**
  128.      * Gets all event periods.
  129.      *
  130.      * @return StopwatchPeriod[]
  131.      */
  132.     public function getPeriods(): array
  133.     {
  134.         return $this->periods;
  135.     }
  137.     /**
  138.      * Gets the relative time of the start of the first period in milliseconds.
  139.      */
  140.     public function getStartTime(): int|float
  141.     {
  142.         if (isset($this->periods[0])) {
  143.             return $this->periods[0]->getStartTime();
  144.         }
  146.         if ($this->started) {
  147.             return $this->started[0];
  148.         }
  150.         return 0;
  151.     }
  153.     /**
  154.      * Gets the relative time of the end of the last period in milliseconds.
  155.      */
  156.     public function getEndTime(): int|float
  157.     {
  158.         $count = \count($this->periods);
  160.         return $count ? $this->periods[$count - 1]->getEndTime() : 0;
  161.     }
  163.     /**
  164.      * Gets the duration of the events in milliseconds (including all periods).
  165.      */
  166.     public function getDuration(): int|float
  167.     {
  168.         $periods = $this->periods;
  169.         $left = \count($this->started);
  171.         for ($i = $left - 1; $i >= 0; --$i) {
  172.             $periods[] = new StopwatchPeriod($this->started[$i], $this->getNow(), $this->morePrecision);
  173.         }
  175.         $total = 0;
  176.         foreach ($periods as $period) {
  177.             $total += $period->getDuration();
  178.         }
  180.         return $total;
  181.     }
  183.     /**
  184.      * Gets the max memory usage of all periods in bytes.
  185.      */
  186.     public function getMemory(): int
  187.     {
  188.         $memory = 0;
  189.         foreach ($this->periods as $period) {
  190.             if ($period->getMemory() > $memory) {
  191.                 $memory = $period->getMemory();
  192.             }
  193.         }
  195.         return $memory;
  196.     }
  198.     /**
  199.      * Return the current time relative to origin in milliseconds.
  200.      */
  201.     protected function getNow(): float
  202.     {
  203.         return $this->formatTime(microtime(true) * 1000 - $this->origin);
  204.     }
  206.     /**
  207.      * Formats a time.
  208.      *
  209.      * @throws \InvalidArgumentException When the raw time is not valid
  210.      */
  211.     private function formatTime(float $time): float
  212.     {
  213.         return round($time, 1);
  214.     }
  216.     /**
  217.      * Gets the event name.
  218.      */
  219.     public function getName(): string
  220.     {
  221.         return $this->name;
  222.     }
  224.     public function __toString(): string
  225.     {
  226.         return sprintf('%s/%s: %.2F MiB - %d ms', $this->getCategory(), $this->getName(), $this->getMemory() / 1024 / 1024, $this->getDuration());
  227.     }
  228. }