PtUpdater.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/chain/ChainFunctions.h"
#include "catapult/thread/Future.h"
#include <memory>
 
namespace catapult {
    namespace cache { class MemoryPtCacheProxy; }
    namespace chain { class PtValidator; }
    namespace model {
        struct DetachedCosignature;
        struct Transaction;
        struct TransactionInfo;
    }
    namespace thread { class IoThreadPool; }
}
 
namespace catapult { namespace chain {
 
    // region results
 
    struct TransactionUpdateResult {
        enum class UpdateType {
            New,
 
            Existing,
 
            Invalid
        };
 
        UpdateType Type;
 
        size_t NumCosignaturesAdded;
    };
 
    enum class CosignatureUpdateResult {
        Error,
 
        Ineligible,
 
        Unverifiable,
 
        Redundant,
 
        Added_Incomplete,
 
        Added_Complete
    };
 
    // endregion
 
    class PtUpdater {
    public:
        using CompletedTransactionSink = consumer<std::unique_ptr<model::Transaction>&&>;
 
    public:
        PtUpdater(
                cache::MemoryPtCacheProxy& transactionsCache,
                std::unique_ptr<const PtValidator>&& pValidator,
                const CompletedTransactionSink& completedTransactionSink,
                const FailedTransactionSink& failedTransactionSink,
                const std::shared_ptr<thread::IoThreadPool>& pPool);
 
        ~PtUpdater();
 
    public:
        thread::future<TransactionUpdateResult> update(const model::TransactionInfo& transactionInfo);
 
        thread::future<CosignatureUpdateResult> update(const model::DetachedCosignature& cosignature);
 
    private:
        class Impl;
        std::shared_ptr<Impl> m_pImpl; // shared_ptr to allow use of enable_shared_from_this
    };
}}