MicoleBus.h

Go to the documentation of this file.

/*
 * This file is part of Micole Architecture
 *
 * Copyright (C) 2007 Micole partners
 *
 * Micole Architecture 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 3 of the License, or (at your option) any 
 * later version.
 *
 * Micole Architecture 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 Micole Architecture.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef MicoleBus_H
#define MicoleBus_H
#include "micolelib.h"

#include "micolebus.h"

//#include "MicoleBusWriteLock.h"

#include <string>
#include <list>
#include <queue>

#include <boost/regex.hpp>

using namespace boost;
using namespace std;

#include <lo2kThread.h>

#include <process.h>
#include <windows.h>

#define MAXREADERS 12

//define MicoleCallBack class defined later
class MicoleCallback;

struct MicoleBusRegexp
{
        regex _regexp;
        list <MicoleCallback *> _cbList;
};


class MICOLELIB_API MicoleBus : lo2k::Thread
{
        private:
                bool _sync; 
                HANDLE _isWriting;

                HANDLE _semLock;

        protected:
                int _regexpNumber; 
                int _bindNumber;
                bool _run;

                virtual void run();

                map<string, MicoleBusRegexp> _regexpList; 
                queue<string> _buffer;


        public:
                MicoleBus(bool sync);
                MicoleBus(const MicoleBus &mb);

                virtual ~MicoleBus();
                
                void stop();

                void interpret(string);
                
                void sendMsg(string s);

                int bindMsg(string regexp, MicoleCallback * cb);

                void lockSlot() { WaitForSingleObject( _semLock, INFINITE ); }

                void lockAllSlots()
                {
                        WaitForSingleObject( _isWriting, INFINITE );
                        for (int i = 0; i< MAXREADERS-1; i++)
                                lockSlot();
                }

                void unlockSlot() { ReleaseSemaphore(_semLock,1,NULL); }

                void unlockAllSlots()
                {
                        ReleaseSemaphore( _isWriting, 1, NULL );
                        for (int i = 0; i< MAXREADERS-1; i++)
                                unlockSlot();
                }

                void unbindMsg(MicoleCallback * cb);
};

class MicoleCallback
{
        public:
                MicoleCallback() {};

                virtual ~MicoleCallback() {};

                virtual void execute (MicoleBus *bus, int argc, const char **argv) = 0;
};


class MicoleAgent;

template <class T>  class MicoleCallbackOf: public MicoleCallback
{
        public:
                typedef void (T::*MicoleAgentMemberFn) (MicoleBus * bus, int argc , const char ** argv);

                MicoleAgentMemberFn _memberFn;
                T * _obj;

                MicoleCallbackOf(T * obj, MicoleAgentMemberFn fn)
                :_memberFn(fn),_obj(obj)
                {
                }

                MicoleCallbackOf(const MicoleCallbackOf &b)
                :_memberFn(b._memberFn),_obj(b._obj)
                {
                }

                void execute (MicoleBus *bus, int argc, const char **argv)
                {
                        (_obj->*_memberFn) (bus, argc, argv);
                }
};
 // end core

#define BUS_CALLBACK_OF( cl, m ) new MicoleCallbackOf<cl>( this, (&cl::m) )

#endif

---