plugin.h

Go to the documentation of this file.

/*  Glass - a distributed computing library
    Copyright (C) 2003-2009 Bruno Barberi Gnecco
    Copyright (C) 2009-2010 Corollarium Technologies


    This library 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 2 of the License, or (at your option) any later version.

    This library 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 this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _GLASS_PLUGIN_HH_
#define _GLASS_PLUGIN_HH_

#include "exception.h"
#include "types.h"
#include <vector>
#include <map>
#include <string>

namespace libglass {

class Glass;
class Packet;
class PluginBase;
class PluginManager;

/* TODO!!! Plugins registered with PluginManagerBase are not registered in
PluginManager instances already created. Although this situation should never
happen currently, since all plugins register themselves before a PluginManager
class can be instantiated, it precludes registration of new plugins during
code execution. To overcome this, create a list of all the PluginManager's
the factory creates, and when a new plugin is registered, register in all of
them. */

class PluginManagerBase {
private:
        std::map<PluginId, PluginBase *> pluginmap;

        PluginManagerBase();

        void operator=(PluginManagerBase &);

        PluginManagerBase(const PluginManagerBase &) { }

protected:
        ~PluginManagerBase();

        friend class PluginBase;
        friend class Glass;

        PluginManager *createPluginManager(Glass *g);

        bool registerPlugin(PluginBase *base);
public:

        static PluginManagerBase& getHandle(void);
};

class PluginManager {
private:
        std::map<PluginId, PluginBase *> *pluginmap;

        Glass                           *glass;

        void operator=(PluginManager &);

        PluginManager(const PluginManager &);

protected:
        friend class PluginManagerBase;
        friend class PluginBase;
        friend class PluginInterface;
        friend class Glass;

        PluginManager(Glass *g, std::map<PluginId, PluginBase *> *pluginmap);

        bool processPacket(Packet &p, bool rootOnly = false);

        bool sendPacket(Packet &p);

        void unregisterNode(nodeId id);

        Glass *getGlass(void) const;

public:
        ~PluginManager();

        PluginBase *getPlugin(PluginId id) const;

        void printPlugins(void);
};


class PluginBase { 
private:
        PluginId id;

protected:
        friend class PluginManagerBase;
        friend class PluginManager;

        PluginManager                   *pm_parent;

        virtual bool processPacket(Packet &p) = 0;

        virtual PluginBase *instance(PluginManager *parent) = 0;

        virtual void unregisterNode(nodeId id) = 0;

        virtual bool sendPacket(Packet &p);

        nodeRelation getNodeRelation(nodeId id) const; 
        
        Glass *getGlass(void) const;

public:
        PluginBase(const PluginId id, bool *registered);

        virtual ~PluginBase() = 0;

        PluginId getPluginId(void) const;
};


/* And now, the plugins themselves */

#define PLUGIN(cl)                                      \
private:                                                \
        cl();                                           \
        void operator=(cl &);                           \
        static bool registered; /* avoid duplicate id */\
        static cl singleton; /* for auto-registering */ \
protected:                                              \
        /* prototypes for virtual functions */          \
        bool processPacket(Packet &p);                  \
        void unregisterNode(nodeId id);                 \
        /* the virtual constructor */                   \
        PluginBase *instance(PluginManager *parent) {   \
                cl *inst = new cl();                    \
                inst->pm_parent = parent;               \
                return inst;                            \
        }                                               \
        friend class PluginManagerBase;                 \
public:                                                 \
        static cl & getHandle(void) {                   \
                return singleton;                       \
        }

#define PLUGIN_CONSTRUCTOR(cl)                          \
  bool cl::registered = false;                          \
  cl cl::singleton;                                     \
  cl::cl() : PluginBase(#cl, &registered)


class PluginInterface {
private:
        Glass                           *g;
protected:
        PluginInterface();

        virtual ~PluginInterface() = 0;

        PluginBase *getPluginBase(PluginId id);

        nodeRelation getNodeRelation(nodeId id) const;

        static const PluginManager *getPluginManager(void);
};

} //namespace

#endif

---