pluginmanager.hh

Go to the documentation of this file.

#ifndef TYPELIB_PLUGINMANAGER_HH
#define TYPELIB_PLUGINMANAGER_HH

#include <map>
#include <string>
#include <vector>
#include <utilmm/singleton/use.hh>
#include <utilmm/configfile/configset.hh>
#include <stdexcept>

namespace Typelib
{
    class Registry;
    
    class Exporter;
    class ExportPlugin;

    class Importer;
    class ImportPlugin;

    class TypeDefinitionPlugin;
    
    struct PluginNotFound : std::runtime_error
    {
        PluginNotFound() : std::runtime_error("plugin not found") { }
    };

    struct ExportError : std::runtime_error
    { 
        ExportError(std::string const& msg) : std::runtime_error(msg) {}
    };

    class PluginManager
    {
        std::map<std::string, ExportPlugin*> m_exporters;
        std::map<std::string, ImportPlugin*> m_importers;
        std::vector<TypeDefinitionPlugin*> m_definition_plugins;
        std::vector<void*> m_library_handles;
        bool loadPlugin(std::string const& path);

        typedef void (*PluginEntryPoint)(PluginManager&);

        PluginManager();
        ~PluginManager();
        
    public:
        bool add(ExportPlugin* plugin);

        Importer* importer(std::string const& name) const;

        bool add(ImportPlugin* plugin);

        Exporter* exporter(std::string const& name) const;

        void add(TypeDefinitionPlugin* plugin);

        void registerPluginTypes(Registry& registry);

        static std::string save
            ( std::string const& kind
            , Registry const& registry);

        static std::string save
            ( std::string const& kind
            , utilmm::config_set const& config
            , Registry const& registry);

        static void save
            ( std::string const& kind
            , Registry const& registry
            , std::ostream& into);

        static void save
            ( std::string const& kind
            , utilmm::config_set const& config
            , Registry const& registry
            , std::ostream& into);

        static Registry* load
            ( std::string const& kind
            , std::istream& stream );
        
        static void load
            ( std::string const& kind
            , std::istream& stream
            , Registry& into );

        static Registry* load
            ( std::string const& kind
            , std::string const& file );

        static void load
            ( std::string const& kind
            , std::string const& file
            , Registry& into );


        static Registry* load
            ( std::string const& kind
            , std::istream& stream
            , utilmm::config_set const& config );
        
        static void load
            ( std::string const& kind
            , std::istream& stream
            , utilmm::config_set const& config
            , Registry& into );

        static Registry* load
            ( std::string const& kind
            , std::string const& file
            , utilmm::config_set const& config );

        static void load
            ( std::string const& kind
            , std::string const& file
            , utilmm::config_set const& config
            , Registry& into );

        typedef utilmm::singleton::use<PluginManager> self;

    private:
        friend class utilmm::singleton::wrapper<PluginManager>;
    };
}

#endif