timer.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_TIMER_H_
#define SYDEVS_TIMER_H_
 
#include <sydevs/core/quantity.h>
#include <chrono>
 
namespace sydevs {
 
using clock = std::chrono::steady_clock;
using clock_time = std::chrono::time_point<clock>;
 
 
class timer
{
public:
    timer();
 
    explicit timer(duration cumulative_dt);
 
    timer(const timer&)            = delete;   
    timer& operator=(const timer&) = delete;   
    timer(timer&&)                 = default;  
    timer& operator=(timer&&)      = default;  
    ~timer()                       = default;  
 
    bool timing() const;  
 
    duration cumulative_duration() const;  
 
    void start();     
    duration stop();  
 
private:
    clock_time start_clk_t_;
    duration cumulative_dt_;
};
 
 
inline timer::timer()
    : start_clk_t_()
    , cumulative_dt_(0)
{
    cumulative_dt_ = cumulative_dt_.fixed_at(micro);
}
 
 
inline timer::timer(duration cumulative_dt)
    : start_clk_t_()
    , cumulative_dt_(cumulative_dt)
{
    cumulative_dt_ = cumulative_dt_.fixed_at(micro);
}
 
    
inline bool timer::timing() const
{
    return start_clk_t_ != clock_time();
}
 
 
inline duration timer::cumulative_duration() const
{
    return cumulative_dt_;
}
 
 
inline void timer::start()
{
    if (timing()) {
        throw std::runtime_error("Attempt to start timer that has already been started");
    }
    start_clk_t_ = clock::now();
}
 
 
inline duration timer::stop()
{
    auto stop_clk_t = clock::now();
    if (!timing()) {
        throw std::runtime_error("Attempt to stop timer that has not been started");
    }
    auto microsecond_count = std::chrono::duration_cast<std::chrono::microseconds>(stop_clk_t - start_clk_t_).count();
    auto interval_dt = duration(microsecond_count, micro).fixed_at(micro);
    cumulative_dt_ += interval_dt;
    start_clk_t_ = clock_time();
    return interval_dt;
}
 
 
}  // namespace
 
#endif