ExtensionRegistry.cpp

#include "ExtensionRegistry.h"
#include "Context.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Module.h"
 
#include <algorithm>
#include <cassert>
 
namespace
{
  class ExtensionModule : public Cogs::Module {
  public:
    typedef Cogs::Core::Extension* (*GETEXTFN)();
 
    GETEXTFN  getExtension = nullptr;
 
    virtual void initPtrs() override {
      getProcAddress(getExtension, "getExtension");
    }
  };
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ExtensionRegistry");
 
  std::vector<Cogs::Module> extensionHandles;
  constexpr Cogs::StringView internalVersion(COGS_CORE_VERSION_STRING);
}
 
std::vector<Cogs::Core::Context *> Cogs::Core::ExtensionRegistry::contexts;
 
bool Cogs::Core::ExtensionRegistry::initialized = false;
bool Cogs::Core::ExtensionRegistry::locked = false;
 
void Cogs::Core::ExtensionRegistry::add(Extension * extension, StringView version)
{
  LOG_INFO(logger, "ExtensionRegistry::add Extension: %s", extension->getExtensionKey());
 
  if (version.empty()) {
    LOG_WARNING(logger, "Extension %s has no versioning info. Update registration method.", extension->getExtensionKey());
  }
  else if (version != internalVersion) {
    LOG_WARNING(logger, "Extension %s built against a different version (%s) than the current (%s).",
      extension->getExtensionKey(),
      version.data(),
      internalVersion.data());
  }
 
  if (locked) {
    getDelayedExtensions().push_back(extension);
  }
  else {
    getExtensions().push_back(extension);
 
    if (initialized) {
      extension->initializeStatic();
 
      for (auto c : contexts) {
        extension->initialize(c);
      }
    }
  }
}
 
bool Cogs::Core::ExtensionRegistry::hasExtension(const StringView & key, bool silent)
{
  assert(key && "Extension search key cannot be nullptr.");
 
  for (auto extension : getExtensions()) {
    if (key == extension->getExtensionKey()) {
      return true;
    }
  }
 
  if (!silent) {
    LOG_WARNING(logger, "No extension named %.*s found.", StringViewFormat(key));
  }
 
  return false;
}
 
void* Cogs::Core::ExtensionRegistry::getExtensionSymbol(const char* extension, const char* name)
{
  for (auto e : getExtensions()) {
    if (strcmp(extension, e->getExtensionKey()) == 0) {
      return e->getSymbolPointer(name);
    }
  }
  return nullptr;
}
 
void Cogs::Core::ExtensionRegistry::initializeStatic()
{
  for (Cogs::Core::Extension* extension : getExtensions()) {
    const char* key = extension->getExtensionKey();
 
    if(key) {
      LOG_INFO(logger, "Initialized static extension: %s.", key);
    }
 
    extension->initializeStatic();
  }
 
  initialized = true;
}
 
void Cogs::Core::ExtensionRegistry::initialize(Context * context)
{
  for (auto extension : getExtensions()) {
    extension->initialize(context);
  }
 
  contexts.push_back(context);
}
 
void Cogs::Core::ExtensionRegistry::cleanup(Context * context)
{
  for (auto & e : getExtensions()) {
    e->cleanup(context);
  }
}
 
void Cogs::Core::ExtensionRegistry::remove(Context * context)
{
  contexts.erase(std::remove(std::begin(contexts), std::end(contexts), context), std::end(contexts));
}
 
const void * Cogs::Core::ExtensionRegistry::loadExtensionModule(const std::string & path, void ** modulehandle, ExtensionModuleLoadResult * result)
{
  const auto count = getExtensions().size();
 
  // Locked merely prevents the extension from being initialised
  // when it registers itself through a call to add (above).
  locked = true;
  auto module = Module::load<ExtensionModule>(path);
  locked = false;
 
  if (module.status == Module::LoadStatus::Failed) {
    LOG_ERROR(logger, "Failed loading extension module %s.", path.c_str());
 
    if (result) {
      *result = ExtensionModuleLoadResult::Failure;
    }
    return nullptr;
  }
 
  // Although delayedExtensions is a deque, it will only ever
  // contain a single item:  The extension being loaded by this
  // function.  Therefore if any of the following initialisation
  // calls fails, it is reasonably safe to return immediately.
  std::deque<Extension*>& delayedExtensions = getDelayedExtensions();
 
  while (!delayedExtensions.empty()) {
    Extension*  e = delayedExtensions.front();
 
    delayedExtensions.pop_front();
 
    if (!e->initializeStatic()) {
      LOG_ERROR(logger, "Extension %s failed static initialisation.", path.c_str());
 
      if (result) {
        *result = ExtensionModuleLoadResult::Failure;
      }
      Module::unload(module.handle);
      return nullptr;
    }
    for (auto context : contexts) {
      if (!e->initialize(context)) {
        LOG_ERROR(logger, "Extension %s failed to initialise.", path.c_str());
 
        if (result) {
          *result = ExtensionModuleLoadResult::Failure;
        }
        Module::unload(module.handle);
        return nullptr;
      }
    }
    getExtensions().push_back(e);
  }
 
  if (modulehandle) {
    *modulehandle = module.handle;
  }
 
  if (std::find(std::begin(extensionHandles), std::end(extensionHandles), module) != std::end(extensionHandles)) {
    // Already loaded. don't check for new extensions.
  }
  else if (getExtensions().size() <= count) {
    if (path != "Cogs.Core.Extensions.Terrain") {
      // Terrain module gets loaded before extension initialization. Avoid annoying Warning log.
      LOG_WARNING(logger, "No extensions were found in module %s.", path.c_str());
    }
 
    if (result) {
      *result = ExtensionModuleLoadResult::NoExtensionsFound;
    }
    return nullptr;
  }
  else {
    LOG_INFO(logger, "Extension %s loaded successfully.", path.c_str());
    extensionHandles.push_back(module);
  }
 
  return module.getExtension ? module.getExtension()->getPublicAPI() : reinterpret_cast<const void*>(-1);
}
 
std::vector<Cogs::Core::Extension *> & Cogs::Core::ExtensionRegistry::getExtensions()
{
  static std::vector<Extension *> extensions;
 
  return extensions;
}
 
std::deque<Cogs::Core::Extension*>& Cogs::Core::ExtensionRegistry::getDelayedExtensions()
{
  static std::deque<Extension*> delayedExtenions;
 
  return delayedExtenions;
}