on_demand_ordering_service.hpp

Go to the documentation of this file.

#ifndef IROHA_ON_DEMAND_ORDERING_SERVICE_HPP
#define IROHA_ON_DEMAND_ORDERING_SERVICE_HPP

#include <unordered_set>

#include "consensus/round.hpp"
#include "cryptography/hash.hpp"
#include "interfaces/iroha_internal/transaction_batch.hpp"

namespace shared_model {
  namespace interface {
    class TransactionBatch;
    class Proposal;
  }  // namespace interface
}  // namespace shared_model

namespace iroha {
  namespace ordering {

    class OnDemandOrderingService {
     public:
      virtual ~OnDemandOrderingService() = default;

      using ProposalType = shared_model::interface::Proposal;

      struct BatchPointerHasher {
        shared_model::crypto::Hash::Hasher hasher_;
        size_t operator()(
            const std::shared_ptr<shared_model::interface::TransactionBatch> &a)
            const {
          return hasher_(a->reducedHash());
        }
      };

      using BatchesSetType = std::unordered_set<
          std::shared_ptr<shared_model::interface::TransactionBatch>,
          BatchPointerHasher,
          shared_model::interface::BatchHashEquality>;

      using TransactionBatchType =
          std::shared_ptr<shared_model::interface::TransactionBatch>;

      using CollectionType = std::vector<TransactionBatchType>;

      virtual void onBatches(CollectionType batches) = 0;

      virtual std::optional<std::shared_ptr<const ProposalType>>
      onRequestProposal(consensus::Round round) = 0;

      using HashesSetType =
          std::unordered_set<shared_model::crypto::Hash,
                             shared_model::crypto::Hash::Hasher>;

      virtual void onCollaborationOutcome(consensus::Round round) = 0;

      virtual void onTxsCommitted(const HashesSetType &hashes) = 0;

      virtual void forCachedBatches(
          std::function<void(const BatchesSetType &)> const &f) const = 0;

      virtual bool isEmptyBatchesCache() const = 0;

      virtual bool hasProposal(consensus::Round round) const = 0;

      virtual void processReceivedProposal(CollectionType batches) = 0;
    };

  }  // namespace ordering
}  // namespace iroha

#endif  // IROHA_ON_DEMAND_ORDERING_SERVICE_HPP