time_watch.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_TIMEWATCH_HPP
#define SIG_UTIL_TIMEWATCH_HPP

#include "../sigutil.hpp"
#include "../helper/maybe.hpp"
#include <chrono>



namespace sig
{

template <class Clock = std::chrono::system_clock>
class TimeWatch
{
    using Time = typename Clock::time_point;
    using Duration = decltype(std::declval<Time>() - std::declval<Time>());

    Time st;
    std::vector<Duration> laps;
    std::vector<Duration> cache;
    bool is_run;

private:
    void init()
    {
        st = Clock::now();
        laps.clear();
        cache.clear();
    }

    Duration d_accumulate(std::vector<Duration> const& ds, uint end) const
    {
        return std::accumulate(ds.begin(), ds.begin() + end, Duration(), [&](Duration const& sum, Duration const& v){
            return sum + v;
        });
    }

public:
    TimeWatch()
    {
        init();
        is_run = true;
    }

    void reset()
    {
        init();
        is_run = false;
    }

    void stop()
    {
        if (is_run) cache.push_back(Clock::now() - st);
        is_run = false;
    }
        
    void restart()
    {
        st = Clock::now();
        is_run = true;
    }

    void save()
    {
        if (is_run){
            auto now = Clock::now();
            cache.push_back(now - st);
            st = std::move(now);
        }

        laps.push_back(d_accumulate(cache, cache.size()));
        cache.clear();
    }


    uint get_count() const{ return laps.size(); }



    template<class TimeUnit = std::chrono::milliseconds>
    long get_total_time()
    {
        return std::chrono::duration_cast<TimeUnit>(d_accumulate(laps, laps.size())).count();
    }


    template<class TimeUnit = std::chrono::milliseconds>
    auto get_split_time(uint index) ->Maybe<long>
    {
        return index < laps.size()
            ? Just<long>(std::chrono::duration_cast<TimeUnit>(d_accumulate(laps, index+1)).count())
            : Nothing(-1l);
    }


    template<class TimeUnit = std::chrono::milliseconds>
    auto get_lap_time(uint index) ->Maybe<long>
    {
        return index < laps.size()
            ? Just<long>(std::chrono::duration_cast<TimeUnit>(laps[index]).count())
            : Nothing(-1l);
    }
};

}

#endif