schedule_node.hpp

Go to the documentation of this file.

#ifndef KAGOME_CONSENSUS_AUTHORITIES_SCHEDULE_NODE
#define KAGOME_CONSENSUS_AUTHORITIES_SCHEDULE_NODE

#include <boost/variant.hpp>

#include "common/empty.hpp"
#include "common/tagged.hpp"
#include "primitives/authority.hpp"

namespace kagome::authority {

  using IsBlockFinalized = Tagged<bool, struct IsBlockFinalizedTag>;

  class ScheduleNode : public std::enable_shared_from_this<ScheduleNode> {
   public:
    ScheduleNode() = default;

    ScheduleNode(const std::shared_ptr<const ScheduleNode> &ancestor,
                 primitives::BlockInfo block);

    static std::shared_ptr<ScheduleNode> createAsRoot(
        std::shared_ptr<const primitives::AuthoritySet> current_authorities,
        primitives::BlockInfo block);

    void adjust(IsBlockFinalized finalized);

    std::shared_ptr<ScheduleNode> makeDescendant(
        const primitives::BlockInfo &block, IsBlockFinalized finalized) const;

    using NoAction = Empty;

    struct ScheduledChange {
      SCALE_TIE(2);

      primitives::BlockNumber applied_block{};
      std::shared_ptr<const primitives::AuthoritySet> new_authorities{};
    };

    struct ForcedChange {
      SCALE_TIE(3);

      primitives::BlockNumber delay_start{};
      size_t delay_length{};
      std::shared_ptr<const primitives::AuthoritySet> new_authorities{};
    };

    struct Pause {
      SCALE_TIE(1);

      primitives::BlockNumber applied_block{};
    };

    struct Resume {
      SCALE_TIE(1);

      primitives::BlockNumber applied_block{};
    };

    friend inline ::scale::ScaleEncoderStream &operator<<(
        ::scale::ScaleEncoderStream &s, const ScheduleNode &node) {
      return s << node.enabled << node.current_block
               << *node.current_authorities << node.action;
    }

    friend inline ::scale::ScaleDecoderStream &operator>>(
        ::scale::ScaleDecoderStream &s, ScheduleNode &node) {
      return s >> node.enabled
             >> const_cast<primitives::BlockInfo &>(node.current_block)
             >> node.current_authorities >> node.action;
    }

    const primitives::BlockInfo current_block{};
    std::weak_ptr<const ScheduleNode> parent;
    std::vector<std::shared_ptr<ScheduleNode>> descendants{};
    boost::variant<NoAction, ScheduledChange, ForcedChange, Pause, Resume>
        action;
    std::shared_ptr<const primitives::AuthoritySet> current_authorities;
    bool enabled = true;
  };

}  // namespace kagome::authority

#endif  // KAGOME_CONSENSUS_AUTHORITIES_SCHEDULE_NODE