MosaicProperties.h

Go to the documentation of this file.

 
#pragma once
#include "MosaicProperty.h"
#include "catapult/utils/Casting.h"
#include "catapult/types.h"
#include <array>
 
namespace catapult { namespace model {
 
#pragma pack(push, 1)
 
    struct MosaicPropertiesHeader {
        uint8_t Count;
 
        MosaicFlags Flags;
 
        uint8_t Divisibility;
    };
 
#pragma pack(pop)
 
    class MosaicProperties {
    private:
        using PropertiesContainer = std::array<MosaicProperty, Num_Mosaic_Properties>;
 
    public:
        using PropertyValuesContainer = std::array<uint64_t, Num_Mosaic_Properties>;
 
    private:
        explicit MosaicProperties(const PropertyValuesContainer& values) {
            uint8_t i = 0;
            for (auto value : values) {
                m_properties[i] = { static_cast<MosaicPropertyId>(i), value };
                ++i;
            }
        }
 
    public:
        static MosaicProperties FromValues(const PropertyValuesContainer& values) {
            return MosaicProperties(values);
        }
 
    public:
        size_t size() const {
            return Num_Mosaic_Properties;
        }
 
        auto begin() const {
            return m_properties.cbegin();
        }
 
        auto end() const {
            return m_properties.cend();
        }
 
    private:
        template<typename T>
        T property(MosaicPropertyId id) const {
            return T(m_properties[utils::to_underlying_type(id)].Value);
        }
 
    public:
        bool is(MosaicFlags testedFlag) const {
            return HasFlag(testedFlag, property<MosaicFlags>(MosaicPropertyId::Flags));
        }
 
        uint8_t divisibility() const {
            return property<uint8_t>(MosaicPropertyId::Divisibility);
        }
 
        BlockDuration duration() const {
            return property<BlockDuration>(MosaicPropertyId::Duration);
        }
 
    public:
        bool operator==(const MosaicProperties& rhs) const {
            for (auto i = 0u; i < Num_Mosaic_Properties; ++i) {
                if (m_properties[i].Value != rhs.m_properties[i].Value)
                    return false;
            }
 
            return true;
        }
 
        bool operator!=(const MosaicProperties& rhs) const {
            return !(*this == rhs);
        }
 
    private:
        std::array<MosaicProperty, Num_Mosaic_Properties> m_properties;
    };
 
    MosaicProperties ExtractAllProperties(const MosaicPropertiesHeader& header, const MosaicProperty* pProperties);
}}