mst_state.hpp

Go to the documentation of this file.

#ifndef IROHA_MST_STATE_HPP
#define IROHA_MST_STATE_HPP

#include <chrono>
#include <unordered_set>

#include <boost/bimap.hpp>
#include <boost/bimap/multiset_of.hpp>
#include <boost/bimap/unordered_multiset_of.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <boost/optional/optional.hpp>
#include <boost/range/adaptor/map.hpp>
#include <boost/range/any_range.hpp>
#include "cryptography/hash.hpp"
#include "interfaces/iroha_internal/transaction_batch.hpp"
#include "logger/logger_fwd.hpp"
#include "multi_sig_transactions/hash.hpp"
#include "multi_sig_transactions/mst_types.hpp"

namespace iroha {

  class Completer {
   public:
    virtual bool isCompleted(const DataType &batch) const = 0;

    virtual bool isExpired(const DataType &batch,
                           const TimeType &current_time) const = 0;

    virtual ~Completer() = default;
  };

  class DefaultCompleter : public Completer {
   public:
    explicit DefaultCompleter(std::chrono::minutes expiration_time);

    bool isCompleted(const DataType &batch) const override;

    bool isExpired(const DataType &tx,
                   const TimeType &current_time) const override;

   private:
    std::chrono::minutes expiration_time_;
  };

  using CompleterType = std::shared_ptr<const Completer>;

  class MstState {
   public:
    // -----------------------------| public api |------------------------------

    static MstState empty(logger::LoggerPtr log,
                          const CompleterType &completer);

    StateUpdateResult operator+=(const DataType &rhs);

    StateUpdateResult operator+=(const MstState &rhs);

    MstState operator-(const MstState &rhs) const;

    bool isEmpty() const;

    std::unordered_set<DataType,
                       iroha::model::PointerBatchHasher,
                       shared_model::interface::BatchHashEquality>
    getBatches() const;

    MstState extractExpired(const TimeType &current_time);

    void eraseExpired(const TimeType &current_time);

    void eraseByTransactionHash(
        const shared_model::interface::types::HashType &hash);

    bool contains(const DataType &element) const;

    template <typename Visitor>
    inline void iterateBatches(const Visitor &visitor) const {
      const auto batches_range = batches_.right | boost::adaptors::map_keys;
      std::for_each(batches_range.begin(), batches_range.end(), visitor);
    }

    template <typename Visitor>
    inline void iterateTransactions(const Visitor &visitor) const {
      for (const auto &batch : batches_.right | boost::adaptors::map_keys) {
        std::for_each(batch->transactions().begin(),
                      batch->transactions().end(),
                      visitor);
      }
    }

   private:
    // --------------------------| private api |------------------------------

    using BatchesForwardCollectionType = boost::
        any_range<BatchPtr, boost::forward_traversal_tag, const BatchPtr &>;

    using BatchesToHashBimap =
        boost::bimap<boost::bimaps::unordered_set_of<
                         shared_model::interface::types::HashType,
                         shared_model::crypto::Hash::Hasher>,
                     boost::bimaps::unordered_multiset_of<
                         DataType,
                         iroha::model::PointerBatchHasher,
                         shared_model::interface::BatchHashEquality>>;

    using BatchesBimap =
        boost::bimap<boost::bimaps::multiset_of<
                         shared_model::interface::types::TimestampType>,
                     boost::bimaps::unordered_set_of<
                         DataType,
                         iroha::model::PointerBatchHasher,
                         shared_model::interface::BatchHashEquality>>;

    MstState(CompleterType const &completer, logger::LoggerPtr log);

    MstState(CompleterType const &completer,
             BatchesForwardCollectionType const &batches,
             logger::LoggerPtr log);

    void insertOne(StateUpdateResult &state_update, const DataType &rhs_tx);

    void rawInsert(const DataType &rhs_tx);

    void extractExpiredImpl(const TimeType &current_time,
                            boost::optional<MstState &> extracted);

    // -----------------------------| fields |------------------------------

    CompleterType completer_;

    BatchesBimap batches_;
    BatchesToHashBimap batches_to_hash_;

    logger::LoggerPtr log_;
  };

}  // namespace iroha

#endif  // IROHA_MST_STATE_HPP