app_framework.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
  {
    T* result = nullptr;
    alias_list_.Foreach<AliasEntry>(
        [&](AliasEntry& entry)
        {
          if (std::strcmp(entry.name, alias) == 0)
          {
            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)
    {
      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);
    ASSERT(result != nullptr);
    return result;
  }
 
  template <typename T>
  void Register(const Entry<T>& entry)
  {
    for (const auto& alias : entry.aliases)
    {
      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_;
};
 
class Application
{
 public:
  virtual void OnMonitor() = 0;  
  virtual ~Application() = default;
};
 
class ApplicationManager
{
 public:
  LibXR::LockFreeList app_list_;  
 
  void Register(Application& app)
  {
    auto node = new (std::align_val_t(LIBXR_CACHE_LINE_SIZE))
        LibXR::LockFreeList::Node<Application*>(&app);
    app_list_.Add(*node);
  }
 
  void MonitorAll()
  {
    app_list_.Foreach<Application*>(
        [](Application* app)
        {
          app->OnMonitor();
          return ErrorCode::OK;
        });
  }
 
  size_t Size() { return app_list_.Size(); }
};
 
}  // namespace LibXR