messenger.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_MESSENGER_HH_
#define _GLASS_PLUGIN_MESSENGER_HH_

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

namespace libglass {

class _Messenger;

class MessengerBase : public PluginBase {
        PLUGIN(MessengerBase);

private:
        std::map<const string *, _Messenger *, StringPointerCompare> 
                                messengers;             
        boost::mutex                            msg_lock; 
protected:
        friend class _Messenger;

        ~MessengerBase();

        bool registerMessenger(_Messenger *v);

        bool unregisterMessenger(_Messenger *v);
public:
};

class _Messenger : public PluginInterface { 
private:
        MessengerBase           *mb;            
        string                  name;

        std::set<nodeId>        owners;

protected:
        friend class MessengerBase;

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

        virtual ~_Messenger();

        bool _sendMessage(nodeId id, chain &message);

        virtual bool pushMessage(chain &) = 0;
public:
};

template<typename T,
        Serializer(*packf, T) = toString<T>,
        Unserializer(*unpackf, T) = fromString<T> >
class Messenger : public _Messenger {
protected:
        std::queue<string>      q;
        void                    (*handler)(T &);

        bool pushMessage(chain &c) {
                
        }
public:

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

        bool getMessage(nodeId id, string &message, bool block = false);


        bool setMessageHandler(void (*func)(string &message));

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

}//namespace

#endif

---