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 {
  namespace consensus {
    namespace 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);

        void remove(const Round &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);

        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, RoundTypeHasher>
            processing_state_;

        std::shared_ptr<CleanupStrategy> strategy_;

        boost::optional<Round> last_round_;

        std::shared_ptr<SupermajorityChecker> supermajority_checker_;

        logger::LoggerManagerTreePtr log_manager_;
      };

    }  // namespace yac
  }    // namespace consensus
}  // namespace iroha

#endif  // IROHA_YAC_VOTE_STORAGE_HPP