Stopwatch.h

Go to the documentation of this file.

/*
 *  This is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *  The software 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 General Public License for more details.
 *  You should have received a copy of the GNU General Public License
 *  along with the software. If not, see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2017, Kuylen E, Willem L, Broeckhove J
 */

#pragma once

#include "TimeToString.h"
#include <chrono>
#include <string>

namespace stride {
namespace util {

template <typename T = std::chrono::steady_clock>
class Stopwatch
{
public:
        using TClock = T;

        explicit Stopwatch(std::string name = "stopwatch", bool running = false)
            : m_accumulated(T::duration::zero()), m_last_start(), m_name(std::move(name)), m_running(running)
        {
                if (m_running) {
                        m_last_start = T::now();
                }
        }

        Stopwatch& Start()
        {
                if (!m_running) {
                        m_running    = true;
                        m_last_start = T::now();
                }
                return *this;
        }

        Stopwatch& Stop()
        {
                if (m_running) {
                        m_accumulated += (T::now() - m_last_start);
                        m_running = false;
                }
                return *this;
        }

        Stopwatch& Reset()
        {
                m_accumulated = T::duration::zero();
                m_running     = false;
                return *this;
        }

        bool IsRunning() const { return (m_running); }

        std::string GetName() const { return m_name; }

        typename T::duration Get() const
        {
                auto fTemp = m_accumulated;
                if (m_running) {
                        fTemp += (T::now() - m_last_start);
                }
                return fTemp;
        }

        std::string ToString() const
        {
                using namespace std;
                using namespace std::chrono;

                string                          colon_string;
                typedef typename TClock::period TPeriod;
                if (ratio_less_equal<TPeriod, micro>::value) {
                        microseconds d = duration_cast<microseconds>(Get());
                        colon_string   = TimeToString::ToColonString(d);
                } else if (ratio_less_equal<TPeriod, milli>::value) {
                        milliseconds d = duration_cast<milliseconds>(Get());
                        colon_string   = TimeToString::ToColonString(d);
                } else {
                        seconds d    = duration_cast<seconds>(Get());
                        colon_string = TimeToString::ToColonString(d);
                }
                return colon_string;
        }

private:
        typename T::duration   m_accumulated;
        typename T::time_point m_last_start;
        std::string            m_name;
        bool                   m_running;
};

template <typename T>
std::ostream& operator<<(std::ostream& oss, Stopwatch<T> const& stopwatch)
{
        return (oss << stopwatch.ToString());
}

} // namespace util
} // namespace stride