[ create a new paste ] login | about

Link: http://codepad.org/vVVA7qLC    [ raw code | fork ]

C++, pasted on Dec 8:
#ifndef CORE_CHRONO_TIMER_HPP
#define CORE_CHRONO_TIMER_HPP

#ifndef _GLIBCXX_USE_NANOSLEEP
#define _GLIBCXX_USE_NANOSLEEP
#endif

#include <chrono>
#include <thread>

class chrono_timer
{
    bool m_running;
    std::chrono::time_point<std::chrono::steady_clock> m_start;
    std::chrono::time_point<std::chrono::steady_clock> m_endex;

    public:

    enum unit { MS, US, NS } default_unit;

    chrono_timer ( ) : default_unit(unit::MS), m_running(1),
        m_start(std::chrono::high_resolution_clock::now())
    {
        m_endex = m_start;
    }
    
    chrono_timer (unit UN) : default_unit(UN), m_running(1),
        m_start(std::chrono::high_resolution_clock::now())
    {
        m_endex = m_start;
    }

    void start(void)
    {
        m_running = 1;
        m_start = std::chrono::high_resolution_clock::now();
    }
    void reset(void)
    {
        this->start();
    }
    void endex(void)
    {
        m_running = 0;
        m_endex = std::chrono::high_resolution_clock::now();
    }
//------------------------------------------------------------------------------
    void delay(std::size_t duration)
    {
        switch (default_unit)
        {
            case unit::MS:
                std::this_thread::sleep_for(std::chrono::milliseconds(duration));
        break;
            case unit::US:
                std::this_thread::sleep_for(std::chrono::microseconds(duration));
        break;
            case unit::NS:
                std::this_thread::sleep_for(std::chrono::nanoseconds(duration));
        }
    }
    static void delay(std::size_t duration, chrono_timer::unit type)
    {
        switch (type)
        {
            case unit::MS:
                std::this_thread::sleep_for(std::chrono::milliseconds(duration));
        break;
            case unit::US:
                std::this_thread::sleep_for(std::chrono::microseconds(duration));
        break;
            case unit::NS:
                std::this_thread::sleep_for(std::chrono::nanoseconds(duration));
        }
    }
    static std::size_t current_time(void)
    {
        return std::chrono::high_resolution_clock::now()
            .time_since_epoch().count();
    }
//------------------------------------------------------------------------------
    std::size_t elapsed_xx(chrono_timer::unit type)
    {
        if (m_running)
        {
            m_endex = std::chrono::high_resolution_clock::now();
        }
        switch (type)
        {
            case unit::MS:
                return std::chrono::duration_cast<std::chrono::milliseconds>
                    (m_endex - m_start).count();
        break;
            case unit::US:
                return std::chrono::duration_cast<std::chrono::microseconds>
                    (m_endex - m_start).count();
        break;
            case unit::NS:
                return std::chrono::duration_cast<std::chrono::nanoseconds>
                    (m_endex - m_start).count();
        }
    }
//------------------------------------------------------------------------------
    std::size_t elapsed_ms(void)
    {
        if (m_running)
        {
            m_endex = std::chrono::high_resolution_clock::now();
        }
        return std::chrono::duration_cast<std::chrono::milliseconds>
            (m_endex - m_start).count();
    }
    std::size_t elapsed_us(void)
    {
        if (m_running)
        {
            m_endex = std::chrono::high_resolution_clock::now();
        }
        return std::chrono::duration_cast<std::chrono::microseconds>
            (m_endex - m_start).count();
    }
    std::size_t elapsed_ns(void)
    {
        if (m_running)
        {
            m_endex = std::chrono::high_resolution_clock::now();
        }
        return std::chrono::duration_cast<std::chrono::nanoseconds>
            (m_endex - m_start).count();
    }
};

#endif // CORE_CHRONO_TIMER_HPP


Create a new paste based on this one


Comments: