PluginManager.h

Go to the documentation of this file.

/*  This file is part of Charon.

 Charon is free software: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 Charon is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with Charon.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef PLUGINMANAGER_H_
#define PLUGINMANAGER_H_

#if defined(_WIN32) || defined(__WIN32__)
    #include "WindowsPluginLoader.h"
    #define PLUGIN_LOADER WindowsPluginLoader
    #define PLUGIN_EXTENSION ".dll"
#else // UNIX
    #include "UnixPluginLoader.h"
    #include <set>
    #define PLUGIN_LOADER UnixPluginLoader

    #ifdef APPLE
        #define PLUGIN_EXTENSION ".dylib"
    #else /* APPLE */
        #define PLUGIN_EXTENSION ".so"
    #endif /* APPLE */
#endif

#include <iostream>
#include <map>
#include <list>
#include "PluginManagerInterface.h"
#include "ParameteredObject.h"

class charon_plugins_DLL_PUBLIC PluginManager: public PluginManagerInterface {
private:
    std::vector<std::string> pluginPaths;

    std::string libSuffix;

    std::map<std::string, PLUGIN_LOADER*> _loadedPlugins;


    std::map<ParameteredObject*, PLUGIN_LOADER*> _instances;

    ParameteredObject::template_type _defaultTemplateType;

    PluginVersionCheckLevel _versionInfo ;


    void _destroyAllInstances(PLUGIN_LOADER * p);

    void _unloadAllPlugins();

    bool isInternal(ParameteredObject* obj);


    void _unloadPlugin(PLUGIN_LOADER * p, bool erase = true);


    bool _generateMetadataForPlugin(
        const std::string& pluginName,
        const std::string& filename);


    std::list<ParameteredObject*> _determineTargetPoints();

    //  @{

    void _getConnected(std::set<std::string>& visited, const std::set<
            std::string>& cur) const;

    void _getConnected(std::set<std::string>& visited, const std::set<
            std::string>& cur, const ParameterFile& pf) const;
    // @}

    std::vector<std::string> _excludeList;

    std::map<std::string, ParameteredObject *> objects;

    bool _initializePluginOnLoad;

public:
#ifdef NDEBUG
    #define DEFAULT_DEBUG_SUFFIX false
#else
    #define DEFAULT_DEBUG_SUFFIX true
#endif


    PluginManager(
            const std::vector<std::string>& pluginPaths,
            bool debugSuffix = DEFAULT_DEBUG_SUFFIX,
            bool initializeOnLoad=false,
            PluginVersionCheckLevel versionInfo=PluginVersionIgnore
    );


    PluginManager(
            const std::string& globalPath,
            const std::string& localPath = "",
            bool debugSuffix = DEFAULT_DEBUG_SUFFIX,
            bool initializeOnLoad=false,
            PluginVersionCheckLevel versionInfo=PluginVersionIgnore
    );


    void loadPlugin(std::string name)
            throw (AbstractPluginLoader::PluginException);


    void unloadPlugin(const std::string & name)
            throw (AbstractPluginLoader::PluginException);


    bool isLoaded(const std::string & name) const;

    const std::vector<std::string>& getPluginPaths() const;

    size_t getLoadedPluginsCount() const;

    size_t getInstancesCount() const;


    ParameteredObject* getInstance(const std::string & instanceName) const
            throw (AbstractPluginLoader::PluginException);


    const std::map<std::string, ParameteredObject *>&
            getObjectList() const {
        return objects;
    }


    ParameteredObject* createInstance(
        std::string pluginName,
        ParameteredObject::template_type t,
        std::string instanceName = "")
            throw (AbstractPluginLoader::PluginException);


    ParameteredObject* createInstance(const std::string & pluginName,
            const std::string & instanceName = "")
            throw (AbstractPluginLoader::PluginException);


    void insertInstance(ParameteredObject* instance);


    void destroyInstance(ParameteredObject * toDestroy)
            throw (AbstractPluginLoader::PluginException);


    void loadParameterFile(const ParameterFile& pf);


    void loadParameterFile(const std::string& path);


    void saveParameterFile(ParameterFile& paramFile) const;


    void saveParameterFile(const std::string & path) const;


    void setDefaultTemplateType(ParameteredObject::template_type t);


    ParameteredObject::template_type getDefaultTemplateType() const;


    void runWorkflow();

    charon_DEPRECATED void executeWorkflow() {
        runWorkflow();
    }

    void setExcludeList(const std::vector<std::string>& list);


    void resetExecuted();


    void createMetadata(const std::string & targetPath = "");


    void createDynamicMetadata(const ParameterFile& paramFile,
        const std::string& filePrefix);


    void createDynamicMetadata(const std::string& pluginName,
        const ParameterFile& paramFile, const std::string& fileName);


    void reset();


    virtual ~PluginManager();

    //  \{


    std::set<std::string> getNeighbours(const std::string& root) const;


    std::set<std::string> getNeighbours(const std::string& root,
            const ParameterFile& pf) const;


    virtual std::set<std::string> getConnected(const std::string& root,
            const ParameterFile& pf) const;


    std::set<std::string> getConnected(const std::string& root) const;

    std::set<std::string> getConnected(ParameterFile & pf,
            ParameteredObject * obj) const;


    bool connect(Slot& slot1, Slot& slot2);


    bool connect(Slot* slot1, Slot* slot2);


    bool connect(const std::string& slot1, const std::string& slot2);


    bool disconnect(Slot& slot1, Slot& slot2);


    bool disconnect(const std::string& slot1, const std::string& slot2);
    // \}


    std::list<ParameteredObject*> determineExecutionOrder();

    virtual bool initializePluginOnLoad() const;
    virtual void setInitiailizePluginOnLoad (bool initOnLoad);
    virtual std::string templateTypeToString(
            ParameteredObject::template_type t) const;
};

#endif /* PLUGINMANAGER_H_ */