gfactory.h

Go to the documentation of this file.

#pragma once
// C++
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
 
// gfactory
#include "gdl.h"
#include "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) {
    }
 
    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::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) {
    // Convention: plugins are packaged as "<name>.gplugin".
    const std::string filename = std::string{name} + ".gplugin";
 
    // Store the DynamicLib in a shared_ptr so it can be safely captured by
    // a shared_ptr deleter in LoadAndRegisterObjectFromLibrary().
    dlMap_.emplace(std::string{name},
                   std::make_shared<DynamicLib>(log, filename));
    log->debug(NORMAL, "Loading DL ", name);
}
 
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);
 
        // 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.
        });
    }
 
    log->error(ERR_DLHANDLENOTFOUND, "Plugin ", name, " could not be loaded.");
}