resource_id.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <etl/hash.h>
 
#include <cstdint>
#include <functional>
 
enum class ResourceType : uint8_t {
  kNone = 0x00,
  kMutex = 0x01,
  kSemaphore = 0x02,
  kCondVar = 0x03,
  kChildExit = 0x04,
  kIoComplete = 0x05,
  kFutex = 0x06,
  kSignal = 0x07,
  kTimer = 0x08,
  kInterrupt = 0x09,
  // 可以继续扩展...
  kResourceTypeCount,
};
 
[[nodiscard]] constexpr auto GetResourceTypeName(ResourceType type) -> const
    char* {
  switch (type) {
    case ResourceType::kNone:
      return "None";
    case ResourceType::kMutex:
      return "Mutex";
    case ResourceType::kSemaphore:
      return "Semaphore";
    case ResourceType::kCondVar:
      return "CondVar";
    case ResourceType::kChildExit:
      return "ChildExit";
    case ResourceType::kIoComplete:
      return "IoComplete";
    case ResourceType::kFutex:
      return "Futex";
    case ResourceType::kSignal:
      return "Signal";
    case ResourceType::kTimer:
      return "Timer";
    default:
      return "Unknown";
  }
}
 
class ResourceId {
 public:
  [[nodiscard]] constexpr auto GetType() const -> ResourceType {
    return static_cast<ResourceType>((value_ >> kTypeShift) & 0xFF);
  }
 
  [[nodiscard]] constexpr auto GetData() const -> uint64_t {
    return value_ & kDataMask;
  }
 
  [[nodiscard]] constexpr auto GetTypeName() const -> const char* {
    return GetResourceTypeName(GetType());
  }
 
  constexpr explicit operator bool() const {
    return GetType() != ResourceType::kNone;
  }
 
  constexpr operator uint64_t() const { return value_; }
 
  constexpr auto operator==(const ResourceId& other) const -> bool {
    return value_ == other.value_;
  }
 
  constexpr auto operator!=(const ResourceId& other) const -> bool {
    return value_ != other.value_;
  }
 
 
  constexpr ResourceId(ResourceType type, uint64_t data)
      : value_((static_cast<uint64_t>(type) << kTypeShift) |
               (data & kDataMask)) {}
 
  ResourceId() = default;
  ResourceId(const ResourceId&) = default;
  ResourceId(ResourceId&&) = default;
  auto operator=(const ResourceId&) -> ResourceId& = default;
  auto operator=(ResourceId&&) -> ResourceId& = default;
  ~ResourceId() = default;
 
 private:
  static constexpr uint8_t kTypeShift = 56;
  static constexpr uint64_t kTypeMask = 0xFF00000000000000ULL;
  static constexpr uint64_t kDataMask = 0x00FFFFFFFFFFFFFFULL;
 
  uint64_t value_{0};
};
 
// std::hash 特化，使 ResourceId 可以作为 unordered_map 的键
namespace std {
template <>
struct hash<ResourceId> {
  constexpr auto operator()(const ResourceId& id) const noexcept -> size_t {
    return hash<uint64_t>{}(static_cast<uint64_t>(id));
  }
};
}  // namespace std
 
// etl::hash 特化，使 ResourceId 可以作为 etl::unordered_map 的键
 
namespace etl {
template <>
struct hash<ResourceId> {
  auto operator()(const ResourceId& id) const -> size_t {
    return etl::hash<uint64_t>{}(static_cast<uint64_t>(id));
  }
};
}  // namespace etl