WeakEntityInfo.h

Go to the documentation of this file.

 
#pragma once
#include "VerifiableEntity.h"
#include "catapult/utils/HexFormatter.h"
#include <iosfwd>
#include <vector>
 
namespace catapult { namespace model { struct BlockHeader; } }
 
namespace catapult { namespace model {
 
    template<typename TEntity>
    class WeakEntityInfoT {
    public:
        constexpr WeakEntityInfoT()
                : m_pEntity(nullptr)
                , m_pHash(nullptr)
                , m_pAssociatedBlockHeader(nullptr)
        {}
 
        constexpr WeakEntityInfoT(const TEntity& entity)
                : m_pEntity(&entity)
                , m_pHash(nullptr)
                , m_pAssociatedBlockHeader(nullptr)
        {}
 
        constexpr explicit WeakEntityInfoT(const TEntity& entity, const Hash256& hash)
                : m_pEntity(&entity)
                , m_pHash(&hash)
                , m_pAssociatedBlockHeader(nullptr)
        {}
 
        constexpr explicit WeakEntityInfoT(const TEntity& entity, const Hash256& hash, const BlockHeader& associatedBlockHeader)
                : m_pEntity(&entity)
                , m_pHash(&hash)
                , m_pAssociatedBlockHeader(&associatedBlockHeader)
        {}
 
    public:
        constexpr bool isSet() const {
            return !!m_pEntity;
        }
 
        constexpr bool isHashSet() const {
            return !!m_pHash;
        }
 
        constexpr bool isAssociatedBlockHeaderSet() const {
            return !!m_pAssociatedBlockHeader;
        }
 
    public:
        constexpr const TEntity& entity() const {
            return *m_pEntity;
        }
 
        constexpr EntityType type() const {
            return m_pEntity->Type;
        }
 
        constexpr const Hash256& hash() const {
            return *m_pHash;
        }
 
        constexpr const BlockHeader& associatedBlockHeader() const {
            return *m_pAssociatedBlockHeader;
        }
 
    public:
        template<typename TEntityResult>
        WeakEntityInfoT<TEntityResult> cast() const {
            const auto& typedEntity = static_cast<const TEntityResult&>(entity());
            return isAssociatedBlockHeaderSet()
                    ? WeakEntityInfoT<TEntityResult>(typedEntity, hash(), associatedBlockHeader())
                    : WeakEntityInfoT<TEntityResult>(typedEntity, hash());
        }
 
    public:
        constexpr bool operator==(const WeakEntityInfoT& rhs) const {
            return m_pEntity == rhs.m_pEntity && m_pHash == rhs.m_pHash;
        }
 
        constexpr bool operator!=(const WeakEntityInfoT& rhs) const {
            return !(*this == rhs);
        }
 
    private:
        const TEntity* m_pEntity;
        const Hash256* m_pHash;
        const BlockHeader* m_pAssociatedBlockHeader;
    };
 
    using WeakEntityInfo = WeakEntityInfoT<VerifiableEntity>;
 
    template<typename TEntity>
    std::ostream& operator<<(std::ostream& out, const WeakEntityInfoT<TEntity>& entityInfo) {
        if (!entityInfo.isSet()) {
            out << "WeakEntityInfo (unset)";
        } else {
            const auto& hash = entityInfo.hash();
            out << entityInfo.entity() << " [" << utils::HexFormat(hash.cbegin(), hash.cend()) << "]";
        }
 
        return out;
    }
 
    using WeakEntityInfos = std::vector<WeakEntityInfo>;
}}