on_demand_os_transport.hpp

Go to the documentation of this file.

#ifndef IROHA_ON_DEMAND_OS_TRANSPORT_HPP
#define IROHA_ON_DEMAND_OS_TRANSPORT_HPP

#include <memory>
#include <unordered_set>
#include <utility>
#include <vector>

#include <boost/optional.hpp>
#include "common/result_fwd.hpp"
#include "consensus/round.hpp"
#include "cryptography/hash.hpp"
#include "interfaces/iroha_internal/transaction_batch.hpp"

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

namespace iroha {
  namespace ordering {
    namespace transport {

      class OdOsNotification {
       public:
        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 boost::optional<std::shared_ptr<const ProposalType>>
        onRequestProposal(consensus::Round round) = 0;

        virtual ~OdOsNotification() = default;
      };

      class OdOsNotificationFactory {
       public:
        virtual iroha::expected::Result<std::unique_ptr<OdOsNotification>,
                                        std::string>
        create(const shared_model::interface::Peer &to) = 0;

        virtual ~OdOsNotificationFactory() = default;
      };

    }  // namespace transport
  }    // namespace ordering
}  // namespace iroha

#endif  // IROHA_ON_DEMAND_OS_TRANSPORT_HPP