EventDispatcher.h

Go to the documentation of this file.

/***************************************************************************
                          EventDispatcher.h  -  description
                             -------------------
    begin                : Jul 2003
    copyright            : (C) 2003 by Jan Flasar
    email                : flasar@fi.muni.cz
 ***************************************************************************/


#ifndef EVENTDISPATCHER_H
#define EVENTDISPATCHER_H

#include <vrecko/Export>
#include <vrecko/BaseClass.h>
#include <vrecko/DeviceManager.h>
#include <vrecko/MTLock.h>

#include <string>
#include <vector>
#include <map>

#ifdef WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif

namespace vrecko {


class VRECKO_EXPORT EventDispatcher: public BaseClass {
    public:
        EventDispatcher();
        ~EventDispatcher();
        EventDispatcher(EventDispatcher &ed);

        enum InterconnectionType {
            FORWARD_OUTPUT = 1, 
            ACTIVATE_INPUT, 
            REQUEST 
        };

        enum SRType {
            UNKNOWN = 0,
            ENVIRONMENTOBJECT,
            ABILITY,
            DEVICE,
            SCENE,
            WORLD,
            OUTER_OBJECT
        };

        
        VRECKO_EXPORT struct ICSBase {
            friend EventDispatcher;
        public:
            ICSBase() { _receiver_ptr = NULL; }

            inline void setReceiverPtrDirty() { _receiver_ptr = NULL; }

            BaseClass* getReceiverPtr() { if (_receiver_ptr) return _receiver_ptr; else return getReceiverPtrCore(); }

            std::string receiver;
            std::string receiverPin;

            InterconnectionType type;

        protected:
            BaseClass *_receiver_ptr;

            VRECKO_EXPORT BaseClass* getReceiverPtrCore();
        };


        VRECKO_EXPORT struct ICS : public ICSBase{
        public:
            //TODO - vyresit lepe?
            std::string sender;

            osg::ref_ptr<VreckoMessage> conditionalMessage;

            osg::ref_ptr<VreckoMessage> activationMessage;
        };

        VRECKO_EXPORT struct REQUEST_Struct : public ICSBase {
        public:
            const std::string *sceneFile; // a file that this connection will be saved to.
                    // It is a pointer to a shared memory pool, so don't deallocate it.
                    // BTW it's a _variable pointer_ to a _constant string_
        };

        VRECKO_EXPORT struct EventStruct {
            EventType eventType;
            BaseClass *pReceiver;
            std::string senderIdOrInputName;
                // Depending on [pReceiver] this member semantics will change.
                // If [pReceiver] is NULL, then [senderIdOrInputName] will hold the full sender string with the output name
                // If [pReceiver] is not NULL, then [senderIdOrInputName] will hold the input name of the requested "pin" on the receiver side.
            osg::ref_ptr<VreckoMessage> message;
        };

        VRECKO_EXPORT struct StringWithHash {
            StringWithHash() {};
            StringWithHash(const std::string &str) { originalString = str; hashValue = calculateHash(originalString.c_str()); }
            StringWithHash(const StringWithHash& src) { originalString = src.originalString; hashValue = src.hashValue; };

            std::string originalString;
            unsigned int hashValue;

            unsigned int calculateHash(const char* str) {
                // From: http://www.partow.net/programming/hashfunctions/ (JSHash)
                // Simple use another method if this one isn't working well.
                unsigned int hash = 1315423911;

                int i = 0;
                while (str[i]) {
                    hash ^= ((hash << 5) + str[i] + (hash >> 2));
                    ++i;
                }

                return hash;
            }
        };

        VRECKO_EXPORT struct StringWithHashComparator {
            bool operator()(const StringWithHash &a, StringWithHash const &b) {
                if (a.hashValue != b.hashValue)
                    return (a.hashValue < b.hashValue);
                return (a.originalString < b.originalString);
            }
        };
        
        typedef std::multimap<StringWithHash, ICS *, StringWithHashComparator> EI_Type;

        typedef std::map<StringWithHash, REQUEST_Struct, StringWithHashComparator> REQUEST_Map;

#ifdef WIN32
        void setMainThreadId(DWORD dwID) { hMainThreadId = dwID; }
#else
        void setMainThreadId(pthread_t ptID) { hMainThreadId = ptID; }
#endif

        bool insertEventInterconnection(const std::string &sender, const std::string &receiver, InterconnectionType type = FORWARD_OUTPUT, const std::string &sceneFile = *((std::string*)NULL));

        bool deleteEventInterconnection(const std::string &sender, const std::string &receiver, InterconnectionType type = FORWARD_OUTPUT);

        void dirtyInterconnectionsForObject(BaseClass *object, bool bProcessEvents = true, bool bProcessRequests = true);


        inline bool reportEvent(const std::string &senderAndOutputString, VreckoMessage *pMessage, EventType eType = EXPRESS_EVENT) {
                return reportEventCore(NULL, senderAndOutputString, pMessage, eType);
            }
        
        inline bool reportEvent(BaseClass *receiver_ptr, const std::string &input_name, VreckoMessage *pMessage, EventType eType = EXPRESS_EVENT) {
                return reportEventCore(receiver_ptr, input_name, pMessage, eType);
            }
        
        osg::ref_ptr<VreckoMessage> request(const std::string &req_sender, VreckoMessage *pMessage);

        osg::ref_ptr<VreckoMessage> request(BaseClass *receiver_ptr, const std::string &request_name, VreckoMessage *pMessage);


        void update(void);

        void setScenePtr(Scene *ptr) {scene_ptr = ptr;}

        /* Sets pointer of the World. ... REDUNDANT: Already present in the BaseClass*/
//      void setWorldPtr(World *ptr) {pWorld = ptr;}

        bool addOuterObject(const std::string &object_id, BaseClass *pOObject);

        bool removeOuterObject(const std::string &object_id);

        bool removeOuterObject(BaseClass *pOObject);

        inline EI_Type &getEventInterconnectionMap() { return event_interconnection_map; }
        inline REQUEST_Map &getRequestInterconnectionMap() { return request_interconnection_map; }
        inline REQUEST_Map &getDefaultRequestInterconnectionMap() { return default_request_interconnection_map; }
        
        typedef struct {
            std::string sender;
            std::string receiver;
            InterconnectionType type;
            const std::string *sceneFile;
                // a file that this connection will be saved to. Pointer to a shared memory.
                // BTW it's a _variable pointer_ to a _constant string_
        } EventDefinitionStruct;

        std::vector<EventDefinitionStruct> &getEventsVector(void) {return eventsVector;}

        // ----- Net support

/* OBSOLETE - never really used in real life, but may be reimplemented again if necessary (it was made obsolete after the new message implementation

        typedef struct NetEventStruct {
            NetEventStruct() {message_event_image = NULL;}
            ~NetEventStruct() {if (message_event_image) free(message_event_image);}

            std::string sender;
            BaseClass::IO_Type type;
            long int int_event;
            double double_event;
            double field_event[16];
            std::string string_event;   // used also for Message ID
            void *message_event_image;
            long int message_image_size;
        };

        bool sendNetEvents(void);

        bool reportNetEvents(std::vector<NetEventStruct> *ne_vector);
*/
        void setNetSupport(bool status);

        bool parseSR(const std::string &sr, bool isSender, BaseClass **pEntity, SRType *pSRType, std::string *pIOName, osg::ref_ptr<VreckoMessage> *pRefMessage, bool isRequest = false, bool noErrorOuptut = false);

        int getProcessedEventsCounter() { return iProcessedEventsCounter; }

        void resetProcessedEventsCounter() { iProcessedEventsCounter = 0; }
    
    protected:
        std::vector<EventDefinitionStruct> eventsVector;
        EI_Type event_interconnection_map;
        std::vector<EventStruct*> incoming_events[2];
        int bgListId; // background list Id (index)
        bool bAllowForegroundListQueing;
            // Allow messages to be queued into the foreground list (with locking!)
            // Such messages will be guaranteed to be processed in the current frame.
            // WARNING: Only change this variable inside a locked block (see [mainLock])

        std::map<std::string, void*> received_event_map;

        typedef std::vector<std::string> Decomposition_vec;
        std::map<std::string, Decomposition_vec> sender_decomposition;

        std::map<std::string, Decomposition_vec> receiver_decomposition;
        
        REQUEST_Map request_interconnection_map;
        REQUEST_Map default_request_interconnection_map;

        Scene *scene_ptr;
        
//      World *pWorld;

         std::map<std::string, BaseClass *> outerObject_map;

        int iProcessedEventsCounter;


        bool net_support;
//      std::vector<NetEventStruct> *net_events;
//       void (*reportNetEventsToServer)(std::vector<NetEventStruct> *);

#ifdef WIN32
        DWORD hMainThreadId;
#else
        pthread_t hMainThreadId;
#endif
        MTLock mainLock;
        bool isInMainThread();

        /* Processes pending batch of message.
         * 
         * Typically called once per frame (in the EventDispatcher::update() ), to process all the messages,
         * which were accumulated over the last frame.
         * This is only relevant for messages with a lower priority then EXPRESS, as the EXPRESS messages
         * are usually processed immediately (except EXPRESS message from other-than-main threads, which
         * are converted into lower priority messages and processed here).
         */
        void processBatchOfEvents(std::vector<EventStruct*> *ref_incoming_events, bool bTurnOffForegroundQueing);

        /* Main low-level method, which handles processing of a single event.
         * 
         * Note that it is different from BaseClass::processEvent().
         */
        void processEvent(EventStruct *pES);
        
        /* Main low-level method, which handles attempts to send an event.
         * 
         * Decides the time of actual processing of the event. Either postpones the processing or diretly calls the EventDispatcher::processEvent().
         */
        bool reportEventCore(BaseClass *receiver_ptr, const std::string &sender, VreckoMessage *pMessage, EventType eType);
        
        void debugPrintInterconnectionMap(EI_Type *map);
        
        void debugPrintRequestMap(REQUEST_Map *map);


        bool checkInterconnection(const std::string &sender, const std::string &receiver, bool bRequest);
            // Great for debug, but can be turned off.
            // Checks interconnection for any problems (missing sender/receiver), incorrect output/input types
};

}

#endif