gfactory.h

Go to the documentation of this file.

#pragma once
// C++
#include <filesystem>
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
#include <unordered_map>
 
// gfactory
#include "gdl.h"
#include <gemc/gbase/gbase.h>
#include "gfactory_options.h"
 
class GFactoryBase
{
public:
    virtual ~GFactoryBase() = default;
 
    [[nodiscard]] virtual void* Create() = 0;
};
 
template <class T>
class GFactory final : public GFactoryBase
{
public:
    explicit GFactory(const std::shared_ptr<GOptions>& gopts)
        : gopts_(gopts) {
        static_assert(std::is_constructible_v<T, const std::shared_ptr<GOptions>&>,
                      "T must be constructible from const std::shared_ptr<GOptions>&");
    }
 
    [[nodiscard]] void* Create() override { return static_cast<void*>(new T(gopts_)); }
 
private:
    std::shared_ptr<GOptions> gopts_;
};
 
class GManager : public GBase<GManager>
{
public:
    explicit GManager(const std::shared_ptr<GOptions>& gopt) : GBase(gopt, PLUGIN_LOGGER), gopts_(gopt) {
    }
 
    GManager(const GManager&)            = delete;
    GManager& operator=(const GManager&) = delete;
 
    GManager(GManager&&) noexcept            = default;
    GManager& operator=(GManager&&) noexcept = default;
 
    ~GManager() override { clearDLMap(); }
 
    template <class Derived>
    void RegisterObjectFactory(std::string_view name);
 
    template <class Derived>
    void RegisterObjectFactory(std::string_view name, const std::shared_ptr<GOptions>& gopts);
 
    template <class Base>
    [[nodiscard]] Base* CreateObject(std::string_view name) const;
 
    template <class T>
    [[nodiscard]] std::shared_ptr<T> LoadAndRegisterObjectFromLibrary(std::string_view                 name,
                                                                      const std::shared_ptr<GOptions>& gopts);
 
    void clearDLMap() noexcept;
 
private:
    void registerDL(std::string_view name);
 
    std::unordered_map<std::string, std::unique_ptr<GFactoryBase>> factoryMap_;
 
    std::unordered_map<std::string, std::shared_ptr<DynamicLib>> dlMap_;
 
    std::shared_ptr<GOptions> gopts_;
 
    std::string gname;
};
 
 
inline void GManager::clearDLMap() noexcept {
    // Clearing the map releases std::shared_ptr<DynamicLib> instances.
    // Each DynamicLib destructor closes its dlopen handle.
    dlMap_.clear();
}
 
inline void GManager::registerDL(std::string_view name) {
    const std::string basename = std::string{name} + ".gplugin";
 
    // Build the colon-separated search path: -plugin_path option takes
    // precedence, then GEMC_PLUGIN_PATH env var, then CWD / system library path.
    std::string filename = basename;
    if (gopts_) {
        std::string searchPath = gopts_->getScalarString("plugin_path");
        if (searchPath.empty()) {
            if (const char* env = std::getenv("GEMC_PLUGIN_PATH")) { searchPath = env; }
        }
        if (!searchPath.empty()) {
            std::istringstream ss(searchPath);
            std::string dir;
            while (std::getline(ss, dir, ':')) {
                const std::string candidate = dir + "/" + basename;
                if (std::filesystem::exists(candidate)) {
                    filename = candidate;
                    break;
                }
            }
        }
    }
 
    dlMap_.emplace(std::string{name},
                   std::make_shared<DynamicLib>(log, filename));
    log->debug(NORMAL, "Loading DL ", name, " (resolved: ", filename, ")");
}
 
template <class Derived>
void GManager::RegisterObjectFactory(std::string_view name) {
    // Note: the factory is stored type-erased (GFactoryBase) but remains responsible for creating Derived.
    factoryMap_.emplace(std::string{name}, std::make_unique<GFactory<Derived>>());
    log->debug(NORMAL, "Registering ", name, " into factory map");
}
 
template <class Derived>
void GManager::RegisterObjectFactory(std::string_view name, const std::shared_ptr<GOptions>& gopts) {
    factoryMap_.emplace(std::string{name}, std::make_unique<GFactory<Derived>>(gopts));
    log->debug(NORMAL, "Registering ", name, " into factory map");
}
 
template <class Base>
Base* GManager::CreateObject(std::string_view name) const {
    auto it = factoryMap_.find(std::string{name});
    if (it == factoryMap_.end()) {
        log->error(ERR_FACTORYNOTFOUND,
                   "Couldn't find factory <", name, "> in factory map.");
    }
    log->debug(NORMAL, "Creating instance of <", name, "> factory.");
 
    // Type-erased creation returns void*; caller requests a Base* view.
    return static_cast<Base*>(it->second->Create());
}
 
template <class T>
std::shared_ptr<T> GManager::LoadAndRegisterObjectFromLibrary(std::string_view                 name,
                                                              const std::shared_ptr<GOptions>& gopts) {
    registerDL(name);
    auto pluginName = std::string{name};
    auto pluginLib  = dlMap_.at(pluginName); // shared_ptr<DynamicLib>
 
    if (pluginLib && pluginLib->handle) {
        // The product type performs the symbol lookup and raw allocation.
        T* raw = T::instantiate(pluginLib->handle, gopts);
        if (raw == nullptr) {
            log->error(ERR_FACTORYNOTFOUND, "Plugin ", name, " could not instantiate its factory object.");
        }
 
        // Standardize logger wiring on the instance.
        raw->set_loggers(gopts);
 
        // Return shared_ptr<T> with a deleter that captures pluginLib so the library stays loaded
        // until the object is destroyed.
        return std::shared_ptr<T>(raw, [pluginLib](T* ptr) {
            delete ptr;
            // pluginLib keeps the dlopen handle alive until ptr is destroyed.
        });
    }
 
    const char* envPath = std::getenv("GEMC_PLUGIN_PATH");
    log->error(ERR_DLHANDLENOTFOUND,
               "Plugin ", name, ".gplugin could not be loaded.\n",
               "  GEMC_PLUGIN_PATH = ", (envPath ? envPath : "(not set)"), "\n",
               "  Hint: set GEMC_PLUGIN_PATH or use -plugin_path=<dir> to point to the directory ",
               "containing *.gplugin files.");
}