yac_vote_storage.hpp

Go to the documentation of this file.

#ifndef IROHA_YAC_VOTE_STORAGE_HPP
#define IROHA_YAC_VOTE_STORAGE_HPP

#include <memory>
#include <unordered_map>
#include <vector>

#include <boost/optional.hpp>
#include "consensus/yac/consistency_model.hpp"
#include "consensus/yac/outcome_messages.hpp"  // because messages passed by value
#include "consensus/yac/storage/cleanup_strategy.hpp"
#include "consensus/yac/storage/storage_result.hpp"  // for Answer
#include "consensus/yac/storage/yac_common.hpp"      // for ProposalHash
#include "consensus/yac/storage/yac_proposal_storage.hpp"
#include "consensus/yac/supermajority_checker.hpp"
#include "consensus/yac/yac_types.hpp"
#include "logger/logger_manager_fwd.hpp"

namespace iroha::consensus::yac {
  enum class ProposalState {
    kNotSentNotProcessed,
    kSentNotProcessed,
    kSentProcessed
  };

  class YacVoteStorage {
   private:
    // --------| private api |--------

    auto getProposalStorage(const Round &round);
    auto getProposalStorage(const Round &round) const;

    boost::optional<std::vector<YacProposalStorage>::iterator>
    findProposalStorage(const VoteMessage &msg, PeersNumberType peers_in_round);

   public:
    // --------| public api |--------

    YacVoteStorage(std::shared_ptr<CleanupStrategy> cleanup_strategy,
                   std::unique_ptr<SupermajorityChecker> supermajority_checker,
                   logger::LoggerManagerTreePtr log_manager);

    boost::optional<Answer> store(std::vector<VoteMessage> state,
                                  PeersNumberType peers_in_round);

    bool isCommitted(const Round &round);

    void remove(const Round &round);

    ProposalState getProcessingState(const Round &round);

    void nextProcessingState(const Round &round);

    boost::optional<Round> getLastFinalizedRound() const;

    boost::optional<Answer> getState(const Round &round) const;

   private:
    // --------| fields |--------

    // TODO: 2019-02-28 @muratovv refactor proposal_storages_ &
    // processing_state_ with separate entity IR-360

    std::vector<YacProposalStorage> proposal_storages_;

    std::unordered_map<Round, ProposalState> processing_state_;

    std::shared_ptr<CleanupStrategy> strategy_;

    boost::optional<Round> last_round_;

    std::shared_ptr<SupermajorityChecker> supermajority_checker_;

    logger::LoggerManagerTreePtr log_manager_;
  };
}  // namespace iroha::consensus::yac

#endif  // IROHA_YAC_VOTE_STORAGE_HPP