DisruptorTypes.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/model/Elements.h"
#include <functional>
#include <stdint.h>
 
namespace catapult { namespace disruptor {
 
    using PositionType = uint64_t;
 
    using DisruptorElementId = uint64_t;
 
    using CompletionCode = uint32_t;
 
    enum class CompletionStatus : uint8_t {
        Aborted,
 
        Normal,
 
        Consumed
    };
 
    enum class ConsumerResultSeverity : uint8_t {
        Neutral,
 
        Success,
 
        Failure
    };
 
    struct ConsumerResult {
    public:
        constexpr ConsumerResult() : ConsumerResult(disruptor::CompletionStatus::Normal, 0)
        {}
 
    private:
        constexpr ConsumerResult(disruptor::CompletionStatus status, disruptor::CompletionCode code)
                : CompletionStatus(status)
                , CompletionCode(code)
        {}
 
    public:
        disruptor::CompletionStatus CompletionStatus;
 
        disruptor::CompletionCode CompletionCode;
 
    public:
        static constexpr ConsumerResult Abort() {
            return Abort(0);
        }
 
        static constexpr ConsumerResult Abort(disruptor::CompletionCode code) {
            return ConsumerResult(CompletionStatus::Aborted, code);
        }
 
        static constexpr ConsumerResult Continue() {
            return {};
        }
 
        static constexpr ConsumerResult Complete(disruptor::CompletionCode code) {
            return ConsumerResult(CompletionStatus::Consumed, code);
        }
    };
 
    struct ConsumerCompletionResult : public ConsumerResult {
    public:
        constexpr ConsumerCompletionResult() : FinalConsumerPosition(std::numeric_limits<PositionType>::max())
        {}
 
    public:
        PositionType FinalConsumerPosition;
    };
 
    using ProcessingCompleteFunc = consumer<DisruptorElementId, const ConsumerCompletionResult&>;
 
    struct FreeTransactionElement : public model::TransactionElement {
        explicit FreeTransactionElement(const model::Transaction& transaction)
                : model::TransactionElement(transaction)
                , ResultSeverity(ConsumerResultSeverity::Success)
        {}
 
        ConsumerResultSeverity ResultSeverity;
    };
 
    using BlockElements = std::vector<model::BlockElement>;
 
    using TransactionElements = std::vector<FreeTransactionElement>;
}}