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 { dlMap_.clear(); }
 
inline void GManager::registerDL(std::string_view name) {
    const std::string filename = std::string{name} + ".gplugin";
    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) {
    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.");
    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) {
        T* raw = T::instantiate(pluginLib->handle, gopts);
        raw->set_loggers(gopts);
 
        // return shared_ptr<T> with deleter that captures pluginLib
        return std::shared_ptr<T>(raw, [pluginLib](T* ptr) {
            delete ptr;
            // pluginLib keeps .so alive until ptr is destroyed
        });
    }
 
    log->error(ERR_DLHANDLENOTFOUND, "Plugin ", name, " could not be loaded.");
}