gfactory.h

Go to the documentation of this file.

#ifndef  GFACTORY_H
#define  GFACTORY_H 1
 
// c++
#include <map>
#include <string>
 
// dynamic loading
#include "gdl.h"
 
/*
 * @class GFactoryBase
 * @brief Base class. Use polymorphism to run Create on the
 * derived classes
 */
class GFactoryBase {
public:
    virtual void *Create() = 0;
};
 
template<class T>
class GFactory : public GFactoryBase {
    virtual void *Create() override {
        return new T();
    }
};
 
class GManager {
private:
 
    // the map of GFactoryBase is kept on GManager
    std::map<std::string, GFactoryBase *> factoryMap;
 
    // the reason to keep this map is to keep the (DynamicLib?) pointers in memory
    // for some reason declaring a dynamic_lib local variable in LoadAndRegisterObjectFromLibrary
    // scope does not work
    std::map<std::string, DynamicLib *> dlMap;
 
    std::string gname; // manager name
 
    void registerDL(std::string name) {
        // PRAGMA TODO: make it OS independent?
        dlMap[name] = new DynamicLib(log, name + ".gplugin");
        log->debug(NORMAL, "Loading DL ", name);
    }
 
    GLogger const *log;
 
public:
    GManager(GLogger const *logger, std::string name) : gname(name), log(logger)  {
        log->debug(CONSTRUCTOR, "Instantiating ", gname);
    }
 
public:
    template<class Derived>
    void RegisterObjectFactory(std::string name) {
        factoryMap[name] = new GFactory<Derived>();
        log->debug(NORMAL, "Registering ", name, "into factory Map");
 
    }
 
    template<class Base>
    Base *CreateObject(std::string name) const {
 
        auto factory = factoryMap.find(name);
 
        if (factory == factoryMap.end()) {
            log->error(EC__FACTORYNOTFOUND, "couldn't find factory ", name, " in factory Map.");
        }
 
        log->debug(NORMAL, "Creating instance of ", name, " factory.");
        return static_cast<Base *>(factory->second->Create());
    }
 
 
    template<class T>
    T *LoadAndRegisterObjectFromLibrary(std::string name) {
 
        registerDL(name);
 
        // will return nullptr if handle is null
        DynamicLib *dynamicLib = dlMap[name];
        if (dynamicLib != nullptr) {
            dlhandle thisDLHandle = dynamicLib->handle;
            if (thisDLHandle != nullptr) {
                return T::instantiate(thisDLHandle);
            }
        } else {
            // warning message already given if plugin not found
            log->error(EC__DLHANDLENOTFOUND, "plugin ", name, " could not be loaded.");
        }
        return nullptr;
    }
 
    //  template <class T> void destroyObject(T* object) {
    //      delete object;
    //  }
 
    void clearDLMap() {
        for (auto &i: dlMap) {
            delete i.second;
        }
    }
 
};
 
#endif