sync_timer.h

Go to the documentation of this file.

/* Diagnostic Client library
* Copyright (C) 2024  Avijit Dey
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef DIAGNOSTIC_CLIENT_LIB_LIB_UTILITY_UTILITY_SYNC_TIMER_H
#define DIAGNOSTIC_CLIENT_LIB_LIB_UTILITY_UTILITY_SYNC_TIMER_H
 
namespace utility {
namespace sync_timer {
 
#include <chrono>
#include <condition_variable>
#include <mutex>
 
template<typename ClockType>
class SyncTimer final {
 public:
  using Clock = ClockType;
 
  using TimePoint = std::chrono::time_point<Clock>;
 
  enum class TimerState : std::uint8_t { kIdle = 0, kCancelRequested, kTimeout };
 
  SyncTimer() : cond_var_{}, mutex_lock_{}, exit_request_{false}, start_running_{false} {}
 
  ~SyncTimer() {
    std::lock_guard<std::mutex> const lck(mutex_lock_);
    exit_request_ = false;
    start_running_ = false;
    cond_var_.notify_all();
  }
 
  template<typename TimeoutCallback, typename CancelCallback>
  void WaitForTimeout(TimeoutCallback &&timeout_func, CancelCallback &&cancellation_func,
                      std::chrono::milliseconds const timeout) {
    if (Start(timeout) == TimerState::kTimeout) {
      timeout_func();
    } else {
      cancellation_func();
    }
  }
 
  auto IsTimerActive() {
    std::lock_guard<std::mutex> const lck(mutex_lock_);
    return start_running_;
  }
 
  void CancelWait() { Stop(); }
 
 private:
  auto Start(std::chrono::milliseconds const timeout) noexcept -> TimerState {
    TimerState timer_state{TimerState::kIdle};
    std::unique_lock<std::mutex> lck(mutex_lock_);
    start_running_ = true;
    TimePoint const expiry_time_point{Clock::now() + timeout};
    if (cond_var_.wait_until(lck, expiry_time_point, [this, &expiry_time_point, &timer_state]() {
          bool do_exit_wait{false};
          // check if exit was requested
          if (!exit_request_) {
            TimePoint const current_time{Clock::now()};
            // check for expiry
            if (current_time >= expiry_time_point) {
              // timeout
              timer_state = TimerState::kTimeout;
              do_exit_wait = true;
            } else {
              // check for cancellation request
              if (!start_running_) {
                timer_state = TimerState::kCancelRequested;
                do_exit_wait = true;
              }  // else - spurious wake-up, do nothing
            }
          } else {
            do_exit_wait = true;
          }
          return do_exit_wait;
        })) {}
    return timer_state;
  }
 
  void Stop() noexcept {
    std::lock_guard<std::mutex> const lck(mutex_lock_);
    start_running_ = false;
    cond_var_.notify_all();
  }
 
 private:
  std::condition_variable cond_var_;
 
  std::mutex mutex_lock_;
 
  bool exit_request_;
 
  bool start_running_;
};
 
}  // namespace sync_timer
}  // namespace utility
 
#endif  // DIAGNOSTIC_CLIENT_LIB_LIB_UTILITY_UTILITY_SYNC_TIMER_H