TimeSpan.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/types.h"
#include <chrono>
#include <iosfwd>
#include <stdint.h>
 
namespace catapult { namespace utils {
 
    class TimeSpan final {
    private:
        template<typename TRep, typename TPeriod>
        constexpr explicit TimeSpan(const std::chrono::duration<TRep, TPeriod>& duration)
                : m_millis(std::chrono::duration_cast<std::chrono::milliseconds>(duration))
        {}
 
    public:
        constexpr TimeSpan() : TimeSpan(std::chrono::milliseconds(0))
        {}
 
    public:
        static constexpr TimeSpan FromHours(uint64_t hours) {
            return TimeSpan(std::chrono::hours(hours));
        }
 
        static constexpr TimeSpan FromMinutes(uint64_t minutes) {
            return TimeSpan(std::chrono::minutes(minutes));
        }
 
        static constexpr TimeSpan FromSeconds(uint64_t seconds) {
            return TimeSpan(std::chrono::seconds(seconds));
        }
 
        static constexpr TimeSpan FromMilliseconds(uint64_t milliseconds) {
            return TimeSpan(std::chrono::milliseconds(milliseconds));
        }
 
        static constexpr TimeSpan FromDifference(Timestamp end, Timestamp start) {
            return FromMilliseconds((end - start).unwrap());
        }
 
    private:
        template<typename TDuration>
        static constexpr uint64_t ConvertToDuration(const std::chrono::milliseconds& millis) {
            return static_cast<uint64_t>(std::chrono::duration_cast<TDuration>(millis).count());
        }
 
    public:
        constexpr uint64_t hours() const {
            return ConvertToDuration<std::chrono::hours>(m_millis);
        }
 
        constexpr uint64_t minutes() const {
            return ConvertToDuration<std::chrono::minutes>(m_millis);
        }
 
        constexpr uint64_t seconds() const {
            return ConvertToDuration<std::chrono::seconds>(m_millis);
        }
 
        constexpr uint64_t millis() const {
            return static_cast<uint64_t>(m_millis.count());
        }
 
    public:
        constexpr bool operator==(const TimeSpan& rhs) const {
            return m_millis == rhs.m_millis;
        }
 
        constexpr bool operator!=(const TimeSpan& rhs) const {
            return !(*this == rhs);
        }
 
        constexpr bool operator>=(const TimeSpan& rhs) const {
            return m_millis >= rhs.m_millis;
        }
 
        constexpr bool operator>(const TimeSpan& rhs) const {
            return m_millis > rhs.m_millis;
        }
 
        constexpr bool operator<=(const TimeSpan& rhs) const {
            return m_millis <= rhs.m_millis;
        }
 
        constexpr bool operator<(const TimeSpan& rhs) const {
            return m_millis < rhs.m_millis;
        }
 
    private:
        std::chrono::milliseconds m_millis;
    };
 
    std::ostream& operator<<(std::ostream& out, const TimeSpan& timeSpan);
 
    constexpr Timestamp operator+(const Timestamp& timestamp, const TimeSpan& timeSpan) {
        return timestamp + Timestamp(timeSpan.millis());
    }
 
    constexpr Timestamp SubtractNonNegative(const Timestamp& timestamp, const TimeSpan& timeSpan) {
        return Timestamp(timestamp.unwrap() < timeSpan.millis() ? 0u : timestamp.unwrap() - timeSpan.millis());
    }
}}