ModuleManager.h

Go to the documentation of this file.

#ifndef CORE_MODULEMANAGER_H_
#define CORE_MODULEMANAGER_H_

/* Internal Includes */
#include "Core/ExportControl.h"
#include "Core/Module.h"
/* External Includes */
#include <boost/filesystem.hpp>
#include <memory>
#include <vector>

namespace boost {
namespace dll {
class shared_library;
} // namespace dll
} // namespace boost

namespace Scine {
namespace Core {

class CORE_EXPORT ModuleManager {
 public:
  static ModuleManager& getInstance() {
    static ModuleManager instance;
    return instance;
  }

  ModuleManager(ModuleManager const&) = delete;

  void operator=(ModuleManager const&) = delete;

  void load(const boost::filesystem::path& libraryPath);

  void load(boost::dll::shared_library library);

  std::vector<std::string> getLoadedModuleNames() const;

  //* Announces a list of all interfaces for which at least one model is loaded.
  std::vector<std::string> getLoadedInterfaces() const;

  template<typename Interface>
  std::vector<std::string> getLoadedModels() const {
    return getLoadedModels(Interface::interface);
  }

  std::vector<std::string> getLoadedModels(const std::string& interface) const;

  template<typename Interface>
  bool has(const std::string& model, const std::string& moduleName = "") const {
    return has(Interface::interface, model, moduleName);
  }

  bool has(const std::string& interface, const std::string& model, const std::string& moduleName = "") const;

  template<typename Interface>
  std::shared_ptr<Interface> get(const std::string& model, const std::string& moduleName = "") const {
    auto any = _get(Interface::interface, model, moduleName);
    assert(!any.empty() && "Contract of a module's get states that the any may not be empty!");
    return boost::any_cast<std::shared_ptr<Interface>>(any);
  }

  template<typename Interface, typename UnaryPredicate>
  std::enable_if_t<!std::is_convertible<UnaryPredicate, std::string>::value, std::shared_ptr<Interface>>
  get(UnaryPredicate&& predicate, const std::string& moduleName = "") const {
    /* NOTE: Yes, this implementation is a little wasteful in that it gathers
     * all models, and only then tests the predicate, but this is necessary
     * to maintain type erasure. Only here do we know what interface type the
     * models actually are and only here can we call a predicate on them.
     */
    auto anys = _getAll(Interface::interface, moduleName);

    if (anys.empty()) {
      throw std::runtime_error("There are no models of this interface loaded.");
    }

    for (auto& any : anys) {
      assert(!any.empty() && "Contract of a module's get states the any may not be empty!");
      auto interfacePtr = boost::any_cast<std::shared_ptr<Interface>>(any);
      assert(interfacePtr && "Contract of module's get states the wrapped pointer may not be empty!");
      if (predicate(interfacePtr)) {
        return interfacePtr;
      }
    }

    throw std::runtime_error("No model matches the supplied predicate!");
  }

  bool moduleLoaded(const std::string& moduleName) const;

 private:
  // Private Constructor, as required by the singleton design pattern.
  ModuleManager();

  boost::any _get(const std::string& interface, const std::string& model, const std::string& moduleName = "") const;

  std::vector<boost::any> _getAll(const std::string& interface, const std::string& moduleName = "") const;

  struct LibraryAndModules;

  static std::vector<LibraryAndModules> _sources;
};

} /* namespace Core */
} /* namespace Scine */

#endif /* CORE_MODULEMANAGER_H_ */