MosaicUnit.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/utils/ImmutableValue.h"
#include "catapult/utils/StreamFormatGuard.h"
#include "catapult/types.h"
 
namespace catapult { namespace extensions {
 
    struct BasicUnitAmount_tag {};
 
    using BasicUnitAmount = utils::BaseValue<uint64_t, BasicUnitAmount_tag>;
 
    template<size_t Divisibility>
    class MosaicUnit {
    public:
        using ValueType = uint64_t;
 
    public:
        MosaicUnit() : m_value(0)
        {}
 
        explicit MosaicUnit(Amount amount) : m_value(amount.unwrap())
        {}
 
        explicit MosaicUnit(BasicUnitAmount amount) : m_value(amount.unwrap() * GetAtomicUnitMultiplier())
        {}
 
        MosaicUnit(const MosaicUnit& rhs) : m_value(static_cast<ValueType>(rhs.m_value))
        {}
 
    private:
        static uint64_t GetAtomicUnitMultiplier() {
            uint64_t value = 1;
            for (auto i = 0u; i < Divisibility; ++i)
                value *= 10;
 
            return value;
        }
 
    public:
        MosaicUnit& operator=(MosaicUnit rhs) {
            m_value = std::move(rhs.m_value);
            return *this;
        }
 
        MosaicUnit& operator=(Amount rhs) {
            m_value = MosaicUnit(rhs).m_value;
            return *this;
        }
 
        MosaicUnit& operator=(BasicUnitAmount rhs) {
            m_value = MosaicUnit(rhs).m_value;
            return *this;
        }
 
    public:
        BasicUnitAmount basicUnit() const {
            return BasicUnitAmount(m_value / GetAtomicUnitMultiplier());
        }
 
        Amount atomicUnit() const {
            return Amount(m_value);
        }
 
        bool isFractional() const {
            return 0 != m_value % GetAtomicUnitMultiplier();
        }
 
    public:
        bool operator==(MosaicUnit rhs) const {
            return m_value == rhs.m_value;
        }
 
        bool operator!=(MosaicUnit rhs) const {
            return !(*this == rhs);
        }
 
        friend std::ostream& operator<<(std::ostream& out, MosaicUnit unit) {
            utils::StreamFormatGuard guard(out, std::ios::dec, '0');
            out << unit.basicUnit();
            if (unit.isFractional())
                out << '.' << std::setw(Divisibility) << (unit.m_value % GetAtomicUnitMultiplier());
 
            return out;
        }
 
    private:
        utils::ImmutableValue<ValueType> m_value;
    };
}}