ExtensionRegistry.h

#pragma once
 
#include "Base.h"
 
#include "Context.h"
#include "Engine.h"
 
#include "CogsVersion.h"
 
#include "Foundation/Platform/Module.h"
 
#include <vector>
#include <deque>
 
namespace Cogs
{
  namespace Core
  {
    struct COGSCORE_DLL_API Extension
    {
      virtual bool initializeStatic() { return true; }
 
      virtual bool initialize(Context * /*context*/) { return true; }
 
      virtual void cleanup(Context * /*context*/) {}
 
      virtual const char * getExtensionKey() const = 0;
 
      virtual void * getSymbolPointer(const char* /*symbol*/) const { return nullptr; }
 
      virtual const void * getPublicAPI() const { return reinterpret_cast<const void*>(-1); }
    };
 
    class COGSCORE_DLL_API ExtensionRegistry
    {
    public:
      static void add(Extension * extension, StringView version);
 
      static bool hasExtension(const StringView & key, bool silent = false);
 
      static void* getExtensionSymbol(const char* extension, const char* name);
 
      static void initializeStatic();
 
      static void initialize(Context * context);
 
      static void cleanup(Context * context);
 
      static void remove(Context * context);
 
      enum class ExtensionModuleLoadResult
      {
        Success,
        Failure,
        NoExtensionsFound,
      };
 
      static const void * loadExtensionModule(const std::string & path, void ** modulehandle = nullptr, ExtensionModuleLoadResult * result = nullptr);
 
      template<typename API>
      static ModuleAPI<API> loadExtensionModule(const std::string& path) {
        void*       moduleHandle = nullptr;
        const void* api = loadExtensionModule(path, &moduleHandle);
 
        if (moduleHandle && api && (api != reinterpret_cast<void*>(-1))) {
          return ModuleAPI<API>(moduleHandle, api);
        }
        return ModuleAPI<API>();
      }
 
      template<typename ComponentSystemType>
      static ComponentSystemType * registerExtensionSystem(Context * context, SystemPriority::ESystemPriority systemPriority, uint32_t capacity)
      {
        auto system = context->engine->registerSystem<ComponentSystemType>(systemPriority, nullptr, capacity);
 
        context->registerExtensionSystem(system->getComponentType(), system);
 
        return system;
      }
 
      template<typename ComponentSystemType>
      static ComponentSystemType * getExtensionSystem(Context * context)
      {
        return static_cast<ComponentSystemType *>(context->getExtensionSystem(ComponentSystemType::getTypeId()));
      }
 
    private:
      static std::vector<Extension *> & getExtensions();
 
      static std::deque<Extension *> & getDelayedExtensions();
 
      static std::vector<Context *> contexts;
      static bool initialized;
      static bool locked;
    };
  }
}