EntityInfo.h

Go to the documentation of this file.

 
#pragma once
#include "Block.h"
#include "ContainerTypes.h"
#include "Transaction.h"
#include "catapult/utils/Hashers.h"
#include "catapult/utils/NonCopyable.h"
#include <memory>
 
namespace catapult { namespace model {
 
    template<typename TEntity>
    struct EntityInfo : public utils::MoveOnly {
    public:
        EntityInfo() = default;
 
        explicit EntityInfo(const std::shared_ptr<TEntity>& pEntityParam, const Hash256& hash)
                : pEntity(pEntityParam)
                , EntityHash(hash)
        {}
 
        std::shared_ptr<TEntity> pEntity;
 
        Hash256 EntityHash;
 
    public:
        explicit operator bool() const noexcept {
            return !!pEntity;
        }
    };
 
    template<typename TEntity>
    struct EntityInfoHasher {
        size_t operator()(const EntityInfo<TEntity>& info) const {
            return utils::ArrayHasher<Hash256>()(info.EntityHash);
        }
    };
 
    template<typename TEntity>
    struct EntityInfoComparer {
        bool operator()(const EntityInfo<TEntity>& lhs, const EntityInfo<TEntity>& rhs) const {
            return lhs.EntityHash == rhs.EntityHash;
        }
    };
 
    struct DetachedTransactionInfo : EntityInfo<const Transaction> {
    public:
        using EntityInfo<const Transaction>::EntityInfo;
 
    public:
        DetachedTransactionInfo() = default;
 
        explicit DetachedTransactionInfo(const std::shared_ptr<const Transaction>& pTransaction)
                : DetachedTransactionInfo(pTransaction, Hash256())
        {}
 
    public:
        DetachedTransactionInfo copy() const {
            auto transactionInfo = DetachedTransactionInfo(pEntity, EntityHash);
            transactionInfo.OptionalExtractedAddresses = OptionalExtractedAddresses;
            return transactionInfo;
        }
 
    public:
        std::shared_ptr<const UnresolvedAddressSet> OptionalExtractedAddresses;
    };
 
    struct TransactionInfo : DetachedTransactionInfo {
    public:
        TransactionInfo() = default;
 
        explicit TransactionInfo(const std::shared_ptr<const Transaction>& pTransaction)
                : TransactionInfo(pTransaction, Hash256())
        {}
 
        explicit TransactionInfo(const std::shared_ptr<const Transaction>& pTransaction, const Hash256& hash)
                : DetachedTransactionInfo(pTransaction, hash)
                , MerkleComponentHash()
        {}
 
    public:
        TransactionInfo copy() const {
            auto transactionInfo = TransactionInfo(pEntity, EntityHash);
            transactionInfo.OptionalExtractedAddresses = OptionalExtractedAddresses;
            transactionInfo.MerkleComponentHash = MerkleComponentHash;
            return transactionInfo;
        }
 
    public:
        Hash256 MerkleComponentHash;
    };
}}