node_info.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_NODE_INFO_H_
#define MINHTON_CORE_NODE_INFO_H_
 
#include <string>
 
#include "minhton/core/logical_node_info.h"
#include "minhton/core/physical_node_info.h"
#include "solanet/serializer/serialize.h"
 
namespace minhton {
 
enum class NodeStatus : uint8_t { kUninit = 0, kRunning = 1, kLeft = 2, kFailed = 3 };
 
class NodeInfo {
public:
  NodeInfo() = default;
 
  NodeInfo(uint32_t level, uint32_t number, uint16_t fanout);
 
  NodeInfo(uint32_t level, uint32_t number, uint16_t fanout, const std::string &address,
           uint16_t port);
 
  minhton::LogicalNodeInfo getLogicalNodeInfo() const;
 
  void setLogicalNodeInfo(const minhton::LogicalNodeInfo &l_node_info);
 
  minhton::PhysicalNodeInfo getPhysicalNodeInfo() const;
 
  void setPhysicalNodeInfo(const minhton::PhysicalNodeInfo &p_node_info);
 
  std::string getString() const;
 
  bool isInitialized() const;
 
  // -------------- LogicalNodeInfo access Helper methods -------------------
 
  void setPosition(uint32_t level, uint32_t number);
 
  void setPosition(LogicalNodeInfo other);
 
  void setFanout(uint16_t fanout);
 
  uint32_t getLevel() const;
 
  uint32_t getNumber() const;
 
  uint16_t getFanout() const;
 
  NodeStatus getStatus() const;
 
  void setStatus(NodeStatus status);
 
  bool isValidPeer() const;
 
  // -------------- PhysicalNodeInfo access Helper methods -------------------
 
  void setPort(uint16_t port);
 
  void setAddress(const std::string &address);
 
  uint16_t getPort() const;
 
  std::string getAddress() const;
 
  uint32_t getAddressValue() const;
 
  friend bool operator==(const minhton::NodeInfo &n1, const minhton::NodeInfo &n2);
  friend bool operator!=(const minhton::NodeInfo &n1, const minhton::NodeInfo &n2);
  friend bool operator<(const minhton::NodeInfo &n1, const minhton::NodeInfo &n2);
  friend bool operator<=(const minhton::NodeInfo &n1, const minhton::NodeInfo &n2);
  friend bool operator>(const minhton::NodeInfo &n1, const minhton::NodeInfo &n2);
  friend bool operator>=(const minhton::NodeInfo &n1, const minhton::NodeInfo &n2);
 
  SERIALIZE(l_node_info_, p_node_info_);
 
private:
  minhton::LogicalNodeInfo l_node_info_;
  minhton::PhysicalNodeInfo p_node_info_;
 
  NodeStatus status_{NodeStatus::kUninit};
};
 
struct NodeInfoHasher {
  std::size_t operator()(const minhton::NodeInfo &node) const {
    using std::hash;
    using std::size_t;
 
    std::size_t peer_hash = minhton::LogicalNodeInfoHasher()(node.getLogicalNodeInfo());
    std::size_t network_hash = minhton::PhysicalNodeInfoHasher()(node.getPhysicalNodeInfo());
 
    return peer_hash ^ network_hash;
  }
};
 
}  // namespace minhton
#endif