BlockSpan.h

Go to the documentation of this file.

 
#pragma once
#include "Casting.h"
#include "TimeSpan.h"
 
namespace catapult { namespace utils {
 
    class BlockSpan final {
    private:
        constexpr explicit BlockSpan(uint64_t hours) : m_hours(hours)
        {}
 
    public:
        constexpr BlockSpan() : BlockSpan(0)
        {}
 
    public:
        static constexpr BlockSpan FromHours(uint64_t hours) {
            return BlockSpan(hours);
        }
 
        static constexpr BlockSpan FromDays(uint64_t days) {
            return BlockSpan(days * 24);
        }
 
    public:
        constexpr uint64_t hours() const {
            return m_hours;
        }
 
        constexpr uint64_t days() const {
            return m_hours / 24;
        }
 
        BlockDuration blocks(const TimeSpan& generationTargetTime) const {
            auto millisPerHour = TimeSpan::FromHours(1).millis();
            if (m_hours > std::numeric_limits<uint64_t>::max() / millisPerHour)
                CATAPULT_THROW_RUNTIME_ERROR_1("overflow while calculating blocks from hours", m_hours);
 
            return BlockDuration(m_hours * millisPerHour / generationTargetTime.millis());
        }
 
    public:
        constexpr bool operator==(const BlockSpan& rhs) const {
            return m_hours == rhs.m_hours;
        }
 
        constexpr bool operator!=(const BlockSpan& rhs) const {
            return !(*this == rhs);
        }
 
        constexpr bool operator>=(const BlockSpan& rhs) const {
            return m_hours >= rhs.m_hours;
        }
 
        constexpr bool operator>(const BlockSpan& rhs) const {
            return m_hours > rhs.m_hours;
        }
 
        constexpr bool operator<=(const BlockSpan& rhs) const {
            return m_hours <= rhs.m_hours;
        }
 
        constexpr bool operator<(const BlockSpan& rhs) const {
            return m_hours < rhs.m_hours;
        }
 
    private:
        uint64_t m_hours;
    };
 
    std::ostream& operator<<(std::ostream& out, const BlockSpan& blockSpan);
}}