Ayesh\PHP_Timer\Timer

Complexity

Total Complexity

18

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	start()	0	8	2
A	reset()	0	3	1
A	resetAll()	0	3	1
A	formatTime()	0	16	5
A	secondsToTimeString()	0	13	4
A	read()	0	6	2
A	stop()	0	7	2
A	getTimers()	0	3	1

<?php
declare(strict_types = 1);

namespace Ayesh\PHP_Timer;

/**
 * Class Timer
 *
 * Helper class to measure the execution time between two points in a single
 * request.
 *
 * @package Ayesh\PHP_Timer
 */
class Timer {
  public const FORMAT_PRECISE = FALSE;
  public const FORMAT_MILLISECONDS = 'ms';
  public const FORMAT_SECONDS = 's';
  public const FORMAT_HUMAN = 'h';

  private const TIMES = [
    'hour'   => 3600000,
    'minute' => 60000,
    'second' => 1000,
  ];

  /**
   * Stores all the timers statically.
   * @var Stopwatch[]
   */
  static private $timers = [];

  /**
   * Start or resume the timer.
   *
   * Call this method to start the timer with a given key. The default key
   * is "default", and used in @see \Ayesh\PHP_Timer\Timer::read() and reset()
   * methods as well
   *
   * Calling this with the same $key will not restart the timer if it has already
   * started.
   *
   * @param string $key
   */
  public static function start(string $key = 'default'): void {
    if (isset(self::$timers[$key])) {
      self::$timers[$key]->start();
    }
    else {
      self::$timers[$key] = new Stopwatch();
    }
  }

  /**
   * Resets a specific timer, or default timer if not passed the $key parameter.
   * To reset all timers, call @see \Ayesh\PHP_Timer\Timer::resetAll().
   * @param string $key
   */
  public static function reset(string $key = 'default'): void {
    unset(self::$timers[$key]);
  }

  /**
   * Resets ALL timers.
   * To reset a specific timer, @see \Ayesh\PHP_Timer\Timer::reset().
   */
  public static function resetAll(): void {
    self::$timers = [];
  }

  /**
   * Formats the given time the processor into the given format.
   * @param float $value
   * @param string|bool $format
   * @return string
   */
  private static function formatTime(float $value, $format): string {
    switch ($format) {
      case static::FORMAT_MILLISECONDS:
        return (string) round($value * 1000, 2);

      case static::FORMAT_SECONDS:
        return (string) round($value, 3);

      case static::FORMAT_HUMAN:
        return static::secondsToTimeString($value);

Since secondsToTimeString() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of secondsToTimeString() to at least protected.

      case static::FORMAT_PRECISE:
      default:
        return (string) ($value * 1000);
    }
  }

  private static function secondsToTimeString(float $time): string
  {
    $ms = \round($time * 1000);

    foreach (self::TIMES as $unit => $value) {
      if ($ms >= $value) {
        $time = floor($ms / $value * 100.0) / 100.0;
        return $time . ' ' . ($time == 1 ? $unit : $unit . 's');
      }
    }

    return $ms . ' ms';
  }

  /**
   * Returns the time elapsed in the format requested in the $format parameter.
   * To access a specific timer, pass the same key that
   * @see \Ayesh\PHP_Timer\Timer::start() was called with. If the timer was not
   * started, a \LogicException will be thrown.
   *
   * The default format is milliseconds. See the class constants for additional
   * formats.
   *
   * @param string $key The key that the timer was started with. Default value is
   *   "default" throughout the class.
   * @param string $format
   * @return mixed The formatted time.
   * @throws \LogicException
   */
  public static function read(string $key = 'default', $format = self::FORMAT_MILLISECONDS) {
    if (isset(self::$timers[$key])) {
      return self::formatTime(self::$timers[$key]->read(), $format);
    }
    throw new \LogicException('Reading timer when the given key timer was not initialized.');
  }

  /**
   * Stops the timer with the given key. Default key is "default"
   *
   * @param string $key
   *
   * @throws \LogicException If the attempted timer has not started already.
   */
  public static function stop($key = 'default'): void {
    if (isset(self::$timers[$key])) {
      self::$timers[$key]->stop();
    } else {
      throw new \LogicException('Stopping timer when the given key timer was not initialized.');
    }
  }

  /**
   * Return a list of timer names. Note that resetting a timer removes the timer.
   * @return string[]
   */
  public static function getTimers(): array {
    return array_keys(self::$timers);
  }
}