Services.h

#pragma once
 
#include "Base.h"
#include "Context.h"
#include "MemoryContext.h"
 
#include "Foundation/Memory/Allocator.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <functional>
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    struct RegisteredService
    {
      void * service;
      size_t size;
      void(*destroy)(void *);
      Reflection::TypeId id;
    };
 
    class COGSCORE_DLL_API Services
    {
    public:
      Services(Context * context);
      ~Services();
 
      void clear();
 
      template<typename Service, typename... Args>
      Service * registerService(Args... args)
      {
        auto & type = Reflection::TypeDatabase::getType<Service>();
 
        if (!ensureUniqueService(type.getTypeId())) {
          return getService<Service>();
        }
 
        auto s = Memory::create<Service>(context->memory->baseAllocator, args...);
 
        RegisteredService service = {};
        service.service = s;
        service.size = sizeof(Service);
        service.id = type.getTypeId();
        service.destroy = [](void * t) { static_cast<Service *>(t)->~Service(); };
 
        services.push_back(service);
 
        return s;
      }
 
      template<typename Service>
      void registerServiceReference(Service * s)
      {
        auto & type = Reflection::TypeDatabase::getType<Service>();
 
        if (!ensureUniqueService(type.getTypeId())) {
          return;
        }
 
        RegisteredService service = {};
        service.service = s;
        service.id = type.getTypeId();
 
        services.push_back(service);
      }
 
      template<typename Service>
      Service * getService()
      {
        const auto typeId = Reflection::TypeDatabase::getType<Service>().getTypeId();
 
        return static_cast<Service *>(locateService(typeId));
      }
 
      void addFrameCallback(std::function<void(void)> callback);
      void dispatchFrameCallbacks();
 
    private:
      bool ensureUniqueService(Reflection::TypeId typeId);
      void * locateService(Reflection::TypeId typeId);
 
      std::vector<RegisteredService> services;
      std::vector<std::function<void(void)>> callbacks;
 
      Context * context;
    };
  }
}