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_->getOptionalScalarString("plugin_path").value_or("");
        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 %1 (resolved: %2)", name, 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 %1 into factory map", name);
}
 
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 %1 into factory map", name);
}
 
template <class Base>
Base* GManager::CreateObject(std::string_view name) const {
    auto it = factoryMap_.find(std::string{name});
    if (it == factoryMap_.end()) {
        log->error(gfactory::ERR_FACTORYNOTFOUND, "Couldn't find factory <%1> in factory map.", name);
    }
    log->debug(NORMAL, "Creating instance of <%1> factory.", name);
 
    // 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(
                gfactory::ERR_FACTORYNOTFOUND, "Plugin %1 could not instantiate its factory object.", name);
        }
 
        // 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(
        gfactory::ERR_DLHANDLENOTFOUND,
        "Plugin %1.gplugin could not be loaded.\n  GEMC_PLUGIN_PATH = %2\n  Hint: set GEMC_PLUGIN_PATH or "
        "use -plugin_path=<dir> to point to the directory containing *.gplugin files.", name,
        (envPath ? envPath : "(not set)"));
}