event.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_EVENT_HH_
#define _GLASS_PLUGIN_EVENT_HH_

#include <map>
#include <queue>
#include <set>
#include "types.h"
#include "plugin.h"
#include "exception.h"
#include "packager.h"
#include <boost/thread.hpp>
#include "serial.h"

namespace libglass {

class _Event;

class EventBase : public PluginBase {
        PLUGIN(EventBase);
private:
        /* client */
        std::map<const string *, _Event *,
                StringPointerCompare>           events; 
        std::map<string, std::set<nodeId> >     owners; 
        boost::mutex                            events_lock; 
protected:
        friend class _Event;

        bool registerEvent(_Event *e);

        bool unregisterEvent(_Event *e);

        // *********************************************************************
        // Destructor should be PROTECTED to ensure singleton behaviour
        // However, Microsoft compilers prior to VC v7.0 .NET are buggy and
        // generate the following error
        //   error C2248: 'AliasBase::~AliasBase' : cannot access protected member declared in class 'libglass::AliasBase'
        // The only workaround is to make the destructor public - which kind
        // of destroys the whole reason for implementing the singleton class
#if defined(_MSC_VER) && (_MSC_VER < 1300)  // earlier than .NET compiler (VC 7.0)
public:
#else
protected:
#endif
        // *********************************************************************
        ~EventBase();

public:
};

class LIBGLASS_API _Event : public PluginInterface {
private:
        EventBase               *eb;            
        string                  name;           
protected:
        friend class EventBase;
        friend class EventPacket;

        _Event(const char *name) throw(Exception);

        virtual ~_Event();

        bool _enqueueEvent(chain &s, nodeId target);

        bool _enqueueEvent(chain &s, std::vector<nodeId> &targets);

        virtual bool pushEvent(chain &s, nodeId sender) = 0;
public:
};

template<typename T,
        Serializer(*packf, T) = toString<T>,
        Unserializer(*unpackf, T) = fromString<T> >
class Event : public _Event {
private:
        struct _EventData {
                T               data;
                nodeId          sender;
                unsigned int used;
        };
        std::queue<_EventData>  q;              
        void                    (*handler)(T &);
protected:

        bool pushEvent(chain &c, nodeId sender) {
                _EventData      d;
                unsigned int    initial = 0;

                /* get the data */
                // TODO: used
                if (unpackf(c, initial, d.data, d.used, 1, NULL) == false) {
                        return false;
                }
                d.sender = sender;

                if (handler) {
                        handler(d.data);
                }
                else {
                        q.push(d);
                }
                return true;
        }
public:

        Event(const char *name, void (*func)(T &data) = NULL) throw(Exception) :
                _Event(name), handler(func) {
        }

        ~Event() {
        }

        void clear(void) {
                while (!q.empty()) {
                        _EventData d(q.front());
                        q.pop();
                        // TODO: free??
                }
        }

        bool enqueueEvent(const T data, nodeId target = everybodyId, unsigned int len = 1) {
                chain c;
                if (packf(c, data, len, NULL) == false) {
                        return false;
                }
                return _enqueueEvent(c, target);
        }

#ifdef TODO

        bool enqueueEvent(T data, std::vector<nodeId> &targets) {
                // todo
                return false;
        }
#endif

        T getEvent(nodeId id = everybodyId, unsigned int *used = 0) throw(EmptyException) {
                if (q.empty()) {
                        throw EmptyException();
                }

                if (id == everybodyId) {
                        _EventData d(q.front());
                        q.pop();
                        if (used) *used = d.used;
                        return d.data;
                }
                else {
                        // TODO!!!!
                        throw EmptyException();
                }
        }

        inline bool isEmpty(void) {
                return q.empty();
        }

        bool setHandler(void (*func)(T &data)) {
                this->handler = func;

                if (!func) { // queue mode
                        return true;
                }

                while (!q.empty()) {
                        handler(q.front());
                        q.pop();
                }

                return true;
        }

        unsigned int queueSize(void) {
                return q.size();
        }

};

class EventSerializable : public _Event {
private:
        std::queue<SerializableObject *>        q;      
        void                    (*handler)(SerializableObject *o);

protected:
        bool pushEvent(chain &s, nodeId sender);

public:

        EventSerializable(const char *name,
                void (*func)(SerializableObject *o) = NULL) throw(Exception);

        ~EventSerializable();

        void clear(void);

        bool enqueueEvent(SerializableObject &o, nodeId target = everybodyId);

#ifdef TODO
        bool enqueueEvent(SerializableObject &o, std::vector<nodeId> &targets);
#endif

        SerializableObject *getEvent(void) throw(EmptyException);

        bool isEmpty(void);

        bool setHandler(void (*func)(SerializableObject *o));

        unsigned int queueSize(void);
};

}//namespace


#endif // _GLASS_PLUGIN_EVENT_HH_

---