Timer.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include <chrono>
// this has been borrowed from https://gist.github.com/mcleary/b0bf4fa88830ff7c882d
// and was slightly adapted and extended for methods tick(), tock() and TickTock()
 
class Timer
{
  public:
    void start()
    {
        m_StartTime = std::chrono::high_resolution_clock::now();
        m_bRunning = true;
    } 
 
    void stop()
    {
        m_EndTime = std::chrono::high_resolution_clock::now();
        m_bRunning = false;
    }
 
    void tick()
    {
        m_Tick = std::chrono::high_resolution_clock::now();
        TickBeforeTock = (!TockAfterTick && true);
    }
 
    void tock()
    {
        m_Tock = std::chrono::high_resolution_clock::now();
        TockAfterTick = (TickBeforeTock && true);
    }
 
    double TickTock()
    {
        double TT = -1;
        if ( TickBeforeTock && TockAfterTick )
        {
            TT = std::chrono::duration_cast<std::chrono::microseconds>(m_Tock - m_Tick).count();
        }
        TickBeforeTock = false;
        TockAfterTick = false;
        return TT;
    }
 
    double elapsedMicroSeconds()
    {
        std::chrono::time_point<std::chrono::high_resolution_clock> endTime;
 
        if(m_bRunning)
        {
            endTime = std::chrono::high_resolution_clock::now();
        }
        else
        {
            endTime = m_EndTime;
        }
 
        return std::chrono::duration_cast<std::chrono::microseconds>(endTime - m_StartTime).count();
    }
 
    double elapsedSeconds()
    {
        return elapsedMicroSeconds() / 1000000.0;
    }
 
  private:
    // std::chrono::high_resolution_clock::time_point
    std::chrono::time_point<std::chrono::high_resolution_clock> m_StartTime;
    std::chrono::time_point<std::chrono::high_resolution_clock> m_EndTime;
    std::chrono::time_point<std::chrono::high_resolution_clock> m_Tick;
    std::chrono::time_point<std::chrono::high_resolution_clock> m_Tock;
 
    bool                                               m_bRunning = false;
    bool                                               TickBeforeTock = false;
    bool                                               TockAfterTick = false;
};