gfactory.h

Go to the documentation of this file.

#pragma once
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
 
#include "gdl.h"
#include "glogger.h"
 
 
class GFactoryBase {
public:
    virtual ~GFactoryBase() = default;
    [[nodiscard]] virtual void* Create() = 0;
};
 
template <class T>
class GFactory final : public GFactoryBase {
public:
    [[nodiscard]] void* Create() override { return new T(); }
};
 
class GManager {
public:
    explicit GManager(std::shared_ptr<GLogger> logger, std::string description = "");
 
    GManager(const GManager&)            = delete;
    GManager& operator=(const GManager&) = delete;
    GManager(GManager&&) noexcept            = default;
    GManager& operator=(GManager&&) noexcept = default;
 
    ~GManager();
 
    template <class Derived>
    void RegisterObjectFactory(std::string_view name);
 
    template <class Base>
    [[nodiscard]] Base* CreateObject(std::string_view name) const;
 
    template <class T>
    [[nodiscard]] T* LoadAndRegisterObjectFromLibrary(std::string_view name, 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::unique_ptr<DynamicLib>>   dlMap_;
 
    std::string              gname;
    std::shared_ptr<GLogger> log;
};
 
 
inline GManager::GManager(std::shared_ptr<GLogger> logger, std::string description)
    : log(logger) {
    gname = log->get_verbosity_name() + description;
    log->debug(CONSTRUCTOR, gname);
}
 
inline GManager::~GManager() {
    log->debug(DESTRUCTOR, gname);
    clearDLMap();
}
 
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_unique<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 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>
T* GManager::LoadAndRegisterObjectFromLibrary(std::string_view name, GOptions *gopts) {
    registerDL(name);
    auto& dynamicLib = dlMap_.at(std::string{name});
    if (dynamicLib && dynamicLib->handle) {
        auto factory = T::instantiate(dynamicLib->handle);
        // in c++20 it is possible to use introspection with concept thuse removing the
        // need of having to define a set_loggers function
        // it didn't work on 5/21/2025 so for now the function is required
        factory->set_loggers(gopts);
        return factory;
    }
    log->error(ERR_DLHANDLENOTFOUND, "Plugin ", name, " could not be loaded.");
}