routing_information.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_CORE_ROUTING_INFORMATION_H_
#define MINHTON_CORE_ROUTING_INFORMATION_H_
 
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <tuple>
#include <vector>
 
#include "minhton/core/constants.h"
#include "minhton/core/node_info.h"
#include "minhton/core/routing_calculations.h"
#include "minhton/logging/logger.h"
 
namespace minhton {
 
class RoutingInformation {
public:
  RoutingInformation() = default;
 
  RoutingInformation(minhton::NodeInfo self_node_info, Logger logger);
 
  ~RoutingInformation() = default;
 
  void resetPosition(uint64_t event_id);
 
  void setPosition(const minhton::LogicalNodeInfo &peer_position);
 
  void setNodeStatus(NodeStatus status, uint64_t event_id);
 
  minhton::NodeInfo getSelfNodeInfo() const;
 
  uint16_t getFanout() const;
 
  std::string getString() const;
 
  minhton::NodeInfo getParent() const;
 
  void setParent(const minhton::NodeInfo &parent, uint64_t ref_event_id = 0);
 
  minhton::NodeInfo getChild(uint16_t child_position);
 
  std::vector<minhton::NodeInfo> getChildren() const;
 
  void setChild(const minhton::NodeInfo &child, uint16_t position, uint64_t ref_event_id = 0);
 
  minhton::NodeInfo getAdjacentLeft() const;
 
  minhton::NodeInfo getAdjacentRight() const;
 
  void setAdjacentLeft(const minhton::NodeInfo &adjacent_left, uint64_t ref_event_id = 0);
 
  void setAdjacentRight(const minhton::NodeInfo &adjacent_right, uint64_t ref_event_id = 0);
 
  std::vector<minhton::NodeInfo> getRoutingTableNeighbors() const;
 
  std::vector<minhton::NodeInfo> getRoutingTableNeighborChildren() const;
 
  std::vector<minhton::NodeInfo> getInitializedRoutingTableNeighborsAndChildren() const;
 
  std::vector<minhton::NodeInfo> getLeftRoutingTableNeighborsLeftToRight() const;
 
  std::vector<minhton::NodeInfo> getRightRoutingTableNeighborsLeftToRight() const;
 
  std::vector<minhton::NodeInfo> getLeftRoutingTableNeighborChildrenLeftToRight() const;
 
  std::vector<minhton::NodeInfo> getRightRoutingTableNeighborChildrenLeftToRight() const;
 
  std::vector<minhton::NodeInfo> getLeftRoutingTableNeighborsRightToLeft() const;
 
  std::vector<minhton::NodeInfo> getRightRoutingTableNeighborsRightToLeft() const;
 
  std::vector<minhton::NodeInfo> getLeftRoutingTableNeighborChildrenRightToLeft() const;
 
  std::vector<minhton::NodeInfo> getRightRoutingTableNeighborChildrenRightToLeft() const;
 
  std::vector<minhton::NodeInfo> getAllLeftRoutingTableNeighborsAndChildren() const;
 
  std::vector<minhton::NodeInfo> getAllRightRoutingTableNeighborsAndChildren() const;
 
  std::vector<minhton::NodeInfo> getRoutingTableNeighborsAndChildren() const;
 
  std::vector<minhton::NodeInfo> getAllInitializedLeftRoutingTableNeighborsAndChildren() const;
 
  std::vector<minhton::NodeInfo> getAllInitializedRightRoutingTableNeighborsAndChildren() const;
 
  std::vector<minhton::NodeInfo> getAllInitializedRoutingTableNeighbors() const;
 
  std::vector<minhton::NodeInfo> getAllInitializedRoutingTableNeighborChildren() const;
 
  minhton::NodeInfo getDirectLeftNeighbor() const;
 
  minhton::NodeInfo getDirectRightNeighbor() const;
 
  minhton::NodeInfo getLeftmostNeighbor() const;
 
  minhton::NodeInfo getRightmostNeighbor() const;
 
  minhton::NodeInfo getLeftmostNeighborChild() const;
 
  bool atLeastOneChildExists() const;
 
  bool atLeastOneChildIsFree() const;
 
  bool atLeastOneRoutingTableNeighborChildExists() const;
 
  bool atLeastOneRoutingTableNeighborChildIsFree() const;
 
  std::vector<minhton::NodeInfo> getInitializedChildren() const;
 
  bool areChildrenFull() const;
 
  bool areRoutingTableNeighborsFull() const;
 
  bool areRoutingTableNeighborChildrenEmpty() const;
 
  bool areRoutingTableNeighborChildrenFull() const;
 
  void updateRoutingTableNeighbor(minhton::NodeInfo routing_table_neighbor,
                                  uint64_t ref_event_id = 0);
 
  void updateRoutingTableNeighborChild(minhton::NodeInfo routing_table_neighbor_child,
                                       uint64_t ref_event_id = 0);
 
  void resetChild(uint16_t position, uint64_t ref_event_id = 0);
 
  void resetAdjacentRight(uint64_t ref_event_id = 0);
 
  void resetAdjacentLeft(uint64_t ref_event_id = 0);
 
  bool resetRoutingTableNeighbor(const minhton::NodeInfo &routing_table_neighbor,
                                 uint64_t ref_event_id = 0);
 
  bool resetChildOrRoutingTableNeighborChild(
      const minhton::NodeInfo &routing_table_neighbor_child_or_child, uint64_t ref_event_id = 0);
 
  minhton::NodeInfo getLowestNode() const;
 
  std::vector<minhton::NodeInfo> getAllUniqueKnownExistingNeighbors() const;
 
  std::vector<minhton::NodeInfo> getAllUniqueSymmetricalExistingNeighbors() const;
 
  void removeNeighbor(const minhton::NodeInfo &position_to_remove, uint64_t ref_event_id = 0);
 
  void updateNeighbor(const minhton::NodeInfo &position_to_update, uint64_t ref_event_id = 0);
 
  bool resetRoutingTableNeighborChild(const minhton::NodeInfo &routing_table_neighbor_child,
                                      uint64_t ref_event_id = 0);
 
  minhton::NodeInfo getNodeInfoByPosition(uint32_t level, uint32_t number);
 
  static std::vector<minhton::NodeInfo> calcRoutingTableNeighborParents(
      const minhton::NodeInfo &node);
 
  static std::vector<minhton::NodeInfo> combiningNodeVectorsWithoutDuplicate(
      std::vector<minhton::NodeInfo> v1, const std::vector<minhton::NodeInfo> &v2);
 
  static std::vector<minhton::NodeInfo> removeRoutingTableNeighborChildrenFromVector(
      minhton::NodeInfo node, std::vector<minhton::NodeInfo> neighbors);
 
  void addNeighborChangeSubscription(
      const std::function<void(const minhton::NodeInfo &new_node, NeighborRelationship relationship,
                               const minhton::NodeInfo &old_node, uint16_t position)> &callback);
 
  void addNodeInfoChangeSubscription(
      const std::function<void(const minhton::NodeInfo &previous_node_info,
                               const minhton::NodeInfo &new_node_info)> &callback);
 
  bool areWeDSN() const;
  bool areWeTempDSN() const;
 
  NodeInfo getCoveringDSNOrTempDSN();
 
  bool nextDSNExists();
 
  NodeInfo getNextDSN();
 
private:
  minhton::NodeInfo self_node_info_;
 
  minhton::Logger logger_;
 
  minhton::NodeInfo parent_;
 
  minhton::NodeInfo adjacent_left_;
 
  minhton::NodeInfo adjacent_right_;
 
  std::vector<minhton::NodeInfo> children_;
 
  // vector of routing table neighbors on our level with specific horizontal distances
  std::vector<minhton::NodeInfo> routing_table_neighbors_;
 
  // vector of children of our routing table neighbors
  std::vector<minhton::NodeInfo> routing_table_neighbor_children_;
 
  // at this index the first routing table neighbor of the right side starts
  // simultanously the first routing table neighbor child starts at
  // (right_table_neighbor_start_index_ * fanout)
  uint32_t right_table_neighbor_start_index_ = 0;
 
  std::vector<
      std::function<void(const minhton::NodeInfo &new_node, NeighborRelationship relationship,
                         const minhton::NodeInfo &old_node, uint16_t position)>>
      neighbor_change_subscription_callbacks_;
 
  std::vector<std::function<void(const minhton::NodeInfo &previous_node_info,
                                 const minhton::NodeInfo &new_node_info)>>
      node_info_change_subscription_callbacks_;
 
  void notifyNeighborChange(const minhton::NodeInfo &new_node, NeighborRelationship relationship,
                            uint64_t ref_event_id,
                            const minhton::NodeInfo &old_node = minhton::NodeInfo(),
                            uint16_t index = 0);  // TODO Remove default argument
 
  void notifyNodeInfoChange(const minhton::NodeInfo &previous_node_info,
                            const minhton::NodeInfo &new_node_info);
 
  void initRoutingTableNeighbors();
 
  void initRoutingTableNeighborChildren(uint32_t parent_level, uint32_t parent_number);
 
  void initParentAndChildren();
 
  void clearRoutingTable();
};
}  // namespace minhton
#endif