logical_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_LOGICAL_NODE_INFO_H_
#define MINHTON_CORE_LOGICAL_NODE_INFO_H_
 
#include <string>
 
#include "solanet/serializer/serialize.h"
#include "solanet/uuid.h"
#include "solanet/uuid_generator.h"
 
namespace minhton
 
{
 
class LogicalNodeInfo {
public:
  LogicalNodeInfo() = default;
 
  explicit LogicalNodeInfo(uint16_t fanout);
 
  LogicalNodeInfo(uint32_t level, uint32_t number);
 
  LogicalNodeInfo(uint32_t level, uint32_t number, uint16_t fanout);
 
  uint32_t getLevel() const;
 
  uint32_t getNumber() const;
 
  std::string getString() const;
 
  uint16_t getFanout() const;
 
  std::string getUuid() const;
 
  solanet::UUID getRawUuid() const;
 
  double getHorizontalValue() const;
 
  void setFanout(uint16_t fanout);
 
  void setPosition(uint32_t level, uint32_t number);
 
  void setPosition(LogicalNodeInfo other);
 
  bool isInitialized() const;
 
  bool isRoot() const;
 
  bool isSameLevel(LogicalNodeInfo other) const;
 
  bool isDeeperThan(LogicalNodeInfo other) const;
 
  bool isDeeperThanOrSameLevel(LogicalNodeInfo other) const;
 
  bool isPrioNode() const;
 
  friend bool operator==(const minhton::LogicalNodeInfo &p1, const minhton::LogicalNodeInfo &p2);
  friend bool operator!=(const minhton::LogicalNodeInfo &p1, const minhton::LogicalNodeInfo &p2);
  friend bool operator<(const minhton::LogicalNodeInfo &p1, const minhton::LogicalNodeInfo &p2);
  friend bool operator<=(const minhton::LogicalNodeInfo &p1, const minhton::LogicalNodeInfo &p2);
  friend bool operator>(const minhton::LogicalNodeInfo &p1, const minhton::LogicalNodeInfo &p2);
  friend bool operator>=(const minhton::LogicalNodeInfo &p1, const minhton::LogicalNodeInfo &p2);
 
  SERIALIZE(level_, number_, fanout_, uuid_, initialized_);
 
private:
  uint32_t level_ = 0;
  uint32_t number_ = 0;
  uint16_t fanout_ = 0;
  solanet::UUID uuid_ = solanet::generateUUID();
  bool initialized_ = false;
};
 
struct LogicalNodeInfoHasher {
  std::size_t operator()(const minhton::LogicalNodeInfo &l_node_info) const {
    using std::hash;
    using std::size_t;
    using std::string;
 
    std::string rep = std::to_string(l_node_info.getLevel()) + ":" +
                      std::to_string(l_node_info.getNumber()) + ":" +
                      std::to_string(l_node_info.getFanout()) +
                      (l_node_info.isInitialized() ? "init" : "uninit");
    std::size_t res = std::hash<std::string>()(rep);
    return res;
  }
};
 
}  // namespace minhton
#endif