PluginManager.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2010 Jacek Sieka, arnetheduck on gmail point com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef ADCHPP_PLUGINMANAGER_H
#define ADCHPP_PLUGINMANAGER_H

#include "Singleton.h"
#include "version.h"
#include "Signal.h"
#include "ClientManager.h"
#include "Plugin.h"

namespace adchpp {

class SimpleXML;

#ifdef _WIN32

#ifdef BUILDING_ADCHPP
#define PLUGIN_API
#else
#define PLUGIN_API __declspec(dllexport)
#endif

typedef HMODULE plugin_t;

#else // WIN32

#ifdef BUILDING_ADCHPP
#define PLUGIN_API
#else
#define PLUGIN_API __attribute__ ((visibility("default")))
#endif

typedef void* plugin_t;

#endif // WIN32

typedef int (*PLUGIN_GET_VERSION)();

typedef int (*PLUGIN_LOAD)();

typedef void (*PLUGIN_UNLOAD)();

class PluginManager : public Singleton<PluginManager>
{
public:
    typedef std::unordered_map<std::string, Plugin*> Registry;
    typedef Registry::iterator RegistryIter;

    ADCHPP_DLL void attention(const std::function<void()>& f);

    const StringList& getPluginList() const {
        return plugins;
    }

    void setPluginList(const StringList& pluginList) { plugins = pluginList; }

    const std::string& getPluginPath() const {
        return pluginPath;
    }

    void setPluginPath(const std::string& path) { pluginPath = path; }

    PluginDataHandle registerPluginData(const PluginDataDeleter& deleter_) { return PluginDataHandle(new PluginData(deleter_)); }

    bool registerPlugin(const std::string& name, Plugin* ptr) {
        return registry.insert(std::make_pair(name, ptr)).second;
    }

    bool unregisterPlugin(const std::string& name) {
        return registry.erase(name) > 0;
    }

    Plugin* getPlugin(const std::string& name) {
        RegistryIter i = registry.find(name);
        return i == registry.end() ? NULL : i->second;
    }

    const Registry& getPlugins() const {
        return registry;
    }

    typedef SignalTraits<void (Entity&, const StringList&, bool&)>::Signal CommandSignal;
    typedef CommandSignal::Slot CommandSlot;
    ADCHPP_DLL ClientManager::SignalReceive::Connection onCommand(const std::string& commandName, const CommandSlot& f);
    ADCHPP_DLL CommandSignal& getCommandSignal(const std::string& commandName);

    void load();
    void shutdown();

private:
    virtual ~PluginManager() throw();

    class PluginInfo {
    public:

        PluginInfo(plugin_t h, PLUGIN_GET_VERSION v, PLUGIN_LOAD l, PLUGIN_UNLOAD u) :
        handle(h), pluginGetVersion(v), pluginLoad(l), pluginUnload(u) { }

        plugin_t handle;
        PLUGIN_GET_VERSION pluginGetVersion;
        PLUGIN_LOAD pluginLoad;
        PLUGIN_UNLOAD pluginUnload;
    };

    struct CommandDispatch {
        CommandDispatch(const std::string& name_, const PluginManager::CommandSlot& f_);

        void operator()(Entity& e, AdcCommand& cmd, bool& ok);

    private:
        std::string name;
        PluginManager::CommandSlot f;
    };

    friend struct CommandDispatch;

    friend class Singleton<PluginManager>;
    ADCHPP_DLL static PluginManager* instance;

    typedef std::vector<PluginInfo> PluginList;
    typedef PluginList::iterator PluginIter;

    PluginList active;
    Registry registry;

    StringList plugins;
    std::string pluginPath;

    static const std::string className;

    PluginManager() throw();

    bool loadPlugin(const std::string& file);

    typedef std::unordered_map<std::string, CommandSignal> CommandHandlers;
    CommandHandlers commandHandlers;
    bool handleCommand(Entity& e, const StringList& l);
};

}

#endif // PLUGINMANAGER_H