hardware.hpp

#pragma once
 
#include <cstring>
#include <initializer_list>
 
#include "libxr_def.hpp"
#include "libxr_type.hpp"
#include "lockfree_list.hpp"
 
namespace LibXR
{
template <typename T>
struct Entry
{
  T& object;  
  std::initializer_list<const char*>
      aliases;  
};
 
class HardwareContainer
{
 public:
  template <typename... Entries>
  constexpr HardwareContainer(Entries&&... entries)
  {
    (Register(std::forward<Entries>(entries)), ...);
  }
 
  template <typename T>
  T* Find(const char* alias) const
  {
    ASSERT(alias != nullptr);
    T* result = nullptr;
    const auto wanted_id = TypeID::GetID<T>();
    alias_list_.Foreach<AliasEntry>(
        [&](AliasEntry& entry)
        {
          if (std::strcmp(entry.name, alias) == 0 && entry.id == wanted_id)
          {
            result = static_cast<T*>(entry.object);
            return ErrorCode::FAILED;
          }
          return ErrorCode::OK;
        });
    return result;
  }
 
  template <typename T>
  T* Find(const std::initializer_list<const char*> ALIASES) const
  {
    for (const auto& alias : ALIASES)
    {
      ASSERT(alias != nullptr);
      if (T* obj = Find<T>(alias))
      {
        return obj;
      }
    }
    return nullptr;
  }
 
  template <typename T>
  T* FindOrExit(std::initializer_list<const char*> aliases) const
  {
    T* result = Find<T>(aliases);
    REQUIRE(result != nullptr);
    return result;
  }
 
  template <typename T>
  void Register(const Entry<T>& entry)
  {
    for (const auto& alias : entry.aliases)
    {
      ASSERT(alias != nullptr);
      auto node = new (std::align_val_t(LibXR::CACHE_LINE_SIZE))
          LibXR::LockFreeList::Node<AliasEntry>{alias, static_cast<void*>(&entry.object),
                                                TypeID::GetID<T>()};
      alias_list_.Add(*node);
    }
  }
 
 protected:
  struct AliasEntry
  {
    const char* name;  
    void* object;      
    TypeID::ID id;     
  };
 
  mutable LibXR::LockFreeList alias_list_;  
};
 
}  // namespace LibXR