join_algorithm_general.h

// Copyright The SOLA Contributors
//
// Licensed under the MIT License.
// For details on the licensing terms, see the LICENSE file.
// SPDX-License-Identifier: MIT
 
#ifndef MINHTON_ALGORITHMS_JOIN_ALGORITHM_GENERAL_H_
#define MINHTON_ALGORITHMS_JOIN_ALGORITHM_GENERAL_H_
 
#include <memory>
 
#include "minhton/algorithms/join/interface_join_algorithm.h"
#include "minhton/message/types_all.h"
 
namespace minhton {
 
class JoinAlgorithmGeneral : public JoinAlgorithmInterface {
public:
  explicit JoinAlgorithmGeneral(std::shared_ptr<AccessContainer> access)
      : JoinAlgorithmInterface(access){};
 
  ~JoinAlgorithmGeneral() override = default;
 
  void process(const MessageVariant &msg) override;
 
  void initiateJoin(NodeInfo &node_info) override;
 
  void initiateJoin(const PhysicalNodeInfo &p_node_info) override;
 
protected:
  virtual void processJoin(const MessageJoin &msg) = 0;
 
  void processJoinAccept(const MessageJoinAccept &msg);
 
  void processJoinAcceptAck(const MessageJoinAcceptAck &msg);
 
  void performAcceptChild(minhton::NodeInfo entering_node, bool use_complete_balancing = false);
 
  void continueAcceptChildProcedure(const minhton::MessageInformAboutNeighbors &message) noexcept(
      false) override;
 
  void performSendJoinAccept(const minhton::NodeInfo &entering_node,
                             const minhton::NodeInfo &entering_node_adj_left,
                             const minhton::NodeInfo &entering_node_adj_right);
 
  virtual uint32_t performSendUpdateNeighborMessagesAboutEnteringNode(
      minhton::NodeInfo entering_node) = 0;
 
  std::vector<minhton::NodeInfo> getRoutingTableNeighborsForNewChild(
      const minhton::NodeInfo &new_child) const;
 
  minhton::NodeInfo calcNewChildPosition(bool use_complete_balancing = false) const;
 
  minhton::NodeInfo calcAdjacentLeftOfNewChild(const minhton::NodeInfo &entering_node) const;
 
  minhton::NodeInfo calcAdjacentRightOfNewChild(const minhton::NodeInfo &entering_node) const;
 
  minhton::NodeInfo calcOurNewAdjacentLeft(const minhton::NodeInfo &entering_node,
                                           const minhton::NodeInfo &entering_node_adj_right) const;
 
  minhton::NodeInfo calcOurNewAdjacentRight(const minhton::NodeInfo &entering_node,
                                            const minhton::NodeInfo &entering_node_adj_left) const;
 
  bool mustSendUpdateLeft(const minhton::NodeInfo &entering_node_adj_right) const;
 
  bool mustSendUpdateRight(const minhton::NodeInfo &entering_node_adj_left) const;
 
  minhton::NodeInfo getCloserAdjacent(const minhton::NodeInfo &entering_node,
                                      const minhton::NodeInfo &alleged_adjacent) const;
 
  void allUpdatesAcknowledged();
 
  PhysicalNodeInfo last_join_info_;
};
 
}  // namespace minhton
 
#endif