Class Clock

include/process/clock.hpp:37–134

* Provides timers. */

 * Provides timers.
 */
class Clock
{
public:
  /**
   * Initialize the clock with the specified callback that will be
   * invoked whenever a batch of timers has expired.
   */
  // TODO(benh): Introduce a "channel" or listener pattern for getting
  // the expired Timers rather than passing in a callback. This might
  // mean we don't need 'initialize' or 'shutdown'.
  static void initialize(
      lambda::function<void(const std::list<Timer>&)>&& callback);

  /**
   * Clears all timers without executing them.
   *
   * The process manager must be properly finalized before the clock is
   * finalized.  This will eliminate the need for timers to activate and
   * prevent further timers from being added after finalization.
   *
   * Also, the Clock must not be paused when finalizing.
   */
  static void finalize();

  /**
   * The current clock time for either the current process that makes
   * this call or the global clock time if not invoked from a process.
   *
   * @return This process' current clock time or the global clock time
   *         if not invoked from a process.
   */
  static Time now();

  static Time now(ProcessBase* process);

  static Timer timer(
      const Duration& duration,
      const lambda::function<void()>& thunk);

  static bool cancel(const Timer& timer);

  /**
   * Pauses the clock e.g. for testing purposes.
   */
  static void pause();

  /**
   * Check whether clock is currently running.
   */
  static bool paused();

  static void resume();

  static void advance(const Duration& duration);
  static void advance(ProcessBase* process, const Duration& duration);

  static void update(const Time& time);