ident.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <unordered_set>
 
// iRedac
struct StackId {
  uint8_t id;
 
  bool operator==(const StackId &other) const { return id == other.id; }
 
  bool operator!=(const StackId &other) const { return !(*this == other); }
 
  static StackId from(uint8_t stack) { return StackId{.id = stack}; }
};
 
// mRedac
struct CarrierId {
  StackId stack;
  uint8_t id;
 
  bool operator==(const CarrierId &other) const { return stack == other.stack && id == other.id; }
 
  bool operator!=(const CarrierId &other) const { return !(*this == other); }
 
  bool is_lhs() const { return id < 3; }
 
  static CarrierId from(uint8_t stack, uint8_t carrier) {
    return CarrierId{.stack = StackId::from(stack), .id = carrier};
  }
};
 
// Cluster
struct ClusterId {
  CarrierId carrier;
  uint8_t id;
 
  bool operator==(const ClusterId &other) const { return id == other.id && carrier == other.carrier; }
 
  bool operator!=(const ClusterId &other) const { return !(*this == other); }
 
  static ClusterId from(uint8_t stack, uint8_t carrier, uint8_t node) {
    return ClusterId{.carrier = CarrierId::from(stack, carrier), .id = node};
  }
};
 
struct SignalId {
  ClusterId cluster; // carrier cluster
  uint8_t id;
 
  bool operator==(const SignalId &other) const { return id == other.id && cluster == other.cluster; }
 
  bool operator!=(const SignalId &other) const { return !(*this == other); }
 
  static SignalId from(uint8_t stack, uint8_t carrier, uint8_t node, uint8_t lane) {
    return SignalId{.cluster = ClusterId::from(stack, carrier, node), .id = lane};
  }
};
 
namespace std {
template <> struct hash<StackId> {
  size_t operator()(const StackId &c) const noexcept { return hash<uint8_t>{}(c.id); }
};
 
template <> struct hash<CarrierId> {
  size_t operator()(const CarrierId &c) const noexcept {
    size_t h1 = hash<StackId>{}(c.stack);
    size_t h2 = hash<uint8_t>{}(c.id);
    return (h1 ^ (h2 << 1));
  }
};
 
template <> struct hash<ClusterId> {
  size_t operator()(const ClusterId &c) const noexcept {
    size_t h1 = hash<CarrierId>{}(c.carrier);
    size_t h2 = hash<uint8_t>{}(c.id);
    return (h1 ^ (h2 << 1));
  }
};
 
template <> struct hash<SignalId> {
  size_t operator()(const SignalId &s) const noexcept {
    size_t h1 = hash<ClusterId>{}(s.cluster);
    size_t h2 = hash<uint8_t>{}(s.id);
    return (h1 ^ (h2 << 1));
  }
};
 
} // namespace std