AggregateTransaction.h

Go to the documentation of this file.

 
#pragma once
#include "AggregateEntityType.h"
#include "catapult/model/Cosignature.h"
#include "catapult/model/EntityType.h"
#include "catapult/model/Transaction.h"
#include "catapult/model/TransactionContainer.h"
 
namespace catapult { namespace model {
 
#pragma pack(push, 1)
 
    struct AggregateTransactionHeader : public Transaction {
    public:
        DEFINE_TRANSACTION_CONSTANTS(Entity_Type_Aggregate_Complete, 1)
 
    public:
        uint32_t PayloadSize;
 
        // followed by sub-transaction data
        // followed by cosignatures data
    };
 
    struct AggregateTransaction : public TransactionContainer<AggregateTransactionHeader, EmbeddedTransaction> {
    private:
        template<typename T>
        static auto* CosignaturesPtrT(T& transaction) {
            return transaction.Size <= sizeof(T) + transaction.PayloadSize
                    ? nullptr
                    : transaction.ToBytePointer() + sizeof(T) + transaction.PayloadSize;
        }
 
        template<typename T>
        static size_t CosignaturesCountT(T& transaction) {
            return transaction.Size <= sizeof(T) + transaction.PayloadSize
                    ? 0
                    : (transaction.Size - sizeof(T) - transaction.PayloadSize) / sizeof(Cosignature);
        }
 
    public:
        const Cosignature* CosignaturesPtr() const {
            return reinterpret_cast<const Cosignature*>(CosignaturesPtrT(*this));
        }
 
        Cosignature* CosignaturesPtr() {
            return reinterpret_cast<Cosignature*>(CosignaturesPtrT(*this));
        }
 
        size_t CosignaturesCount() const {
            return CosignaturesCountT(*this);
        }
 
        size_t CosignaturesCount() {
            return CosignaturesCountT(*this);
        }
    };
 
#pragma pack(pop)
 
    size_t GetTransactionPayloadSize(const AggregateTransactionHeader& header);
 
    bool IsSizeValid(const AggregateTransaction& aggregate, const TransactionRegistry& registry);
}}