Changeset 5866

Timestamp:

Oct 3, 2009, 6:32:05 PM (15 years ago)

Author:

landauf

Message:

some cleanup in the eventsystem. not sure if everything still works, but there are more changes to come.

Location:

code/branches/core5/src

Files:

• libraries/core/BaseObject.cc (modified) (6 diffs)
• libraries/core/BaseObject.h (modified) (4 diffs)
• libraries/core/Event.cc (modified) (1 diff)
• libraries/core/Event.h (modified) (2 diffs)
• libraries/core/EventIncludes.h (modified) (3 diffs)
• libraries/core/Identifier.h (modified) (2 diffs)
• modules/objects/eventsystem/EventListener.cc (modified) (2 diffs)
• modules/objects/eventsystem/EventListener.h (modified) (1 diff)
• modules/objects/eventsystem/EventTarget.cc (modified) (2 diffs)
• modules/objects/eventsystem/EventTarget.h (modified) (1 diff)

code/branches/core5/src/libraries/core/BaseObject.cc

@@ -94 +94 @@
         if (this->isInitialized())
         {
-            for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
-                (*it)->unregisterEventListener(this);
-
-            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
-                it->first->removeEvent(this);
+            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); )
+                this->removeEventSource((it++)->first);
+
+            for (std::set<BaseObject*>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); )
+                (*(it++))->removeEventSource(this);
 
             for (std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.begin(); it != this->eventContainers_.end(); ++it)
@@ -145 +145 @@
             {
                 std::string sectionname = (*it);
-                ExecutorMember<BaseObject>* loadexecutor = createExecutor(createFunctor(&BaseObject::addEvent), std::string( "BaseObject" ) + "::" + "addEvent");
-                ExecutorMember<BaseObject>* saveexecutor = createExecutor(createFunctor(&BaseObject::getEvent), std::string( "BaseObject" ) + "::" + "getEvent");
+                ExecutorMember<BaseObject>* loadexecutor = createExecutor(createFunctor(&BaseObject::addEventSource), std::string( "BaseObject" ) + "::" + "addEventSource");
+                ExecutorMember<BaseObject>* saveexecutor = createExecutor(createFunctor(&BaseObject::getEventSource), std::string( "BaseObject" ) + "::" + "getEventSource");
                 loadexecutor->setDefaultValue(1, sectionname);
+                saveexecutor->setDefaultValue(1, sectionname);
 
                 XMLPortClassObjectContainer<BaseObject, BaseObject>* container = 0;
@@ -224 +225 @@
     }
 
-    void BaseObject::addEvent(BaseObject* event, const std::string& sectionname)
-    {
-        event->registerEventListener(this, sectionname);
-        this->events_.push_back(event);
-    }
-
-    void BaseObject::removeEvent(BaseObject* event)
-    {
-        this->events_.remove(event);
-    }
-
-    BaseObject* BaseObject::getEvent(unsigned int index) const
+    /**
+        @brief Adds a new event source for a specific state.
+        @param source The object which sends events to this object
+        @param state The state of this object which will be affected by the events
+    */
+    void BaseObject::addEventSource(BaseObject* source, const std::string& state)
+    {
+        this->eventSources_[source] = state;
+        source->registerEventListener(this);
+    }
+
+    /**
+        @brief Removes an eventsource (but doesn't unregister itself at the source).
+    */
+    void BaseObject::removeEventSource(BaseObject* source)
+    {
+        this->eventSources_.erase(source);
+        source->unregisterEventListener(this);
+    }
+
+    /**
+        @brief Returns an eventsource with a given index.
+    */
+    BaseObject* BaseObject::getEventSource(unsigned int index, const std::string& state) const
     {
         unsigned int i = 0;
-        for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
-        {
+        for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); ++it)
+        {
+            if (it->second != state)
+                continue;
+            
             if (i == index)
-                return (*it);
+                return it->first;
             ++i;
         }
@@ -268 +284 @@
     }
 
+    /**
+        @brief Fires an event (without a state).
+    */
     void BaseObject::fireEvent()
     {
@@ -274 +293 @@
     }
 
+    /**
+        @brief Fires an event which activates or deactivates a state.
+    */
     void BaseObject::fireEvent(bool activate)
     {
@@ -279 +301 @@
     }
 
+    /**
+        @brief Fires an event which activates or deactivates a state with agiven originator (the object which sends the event).
+    */
     void BaseObject::fireEvent(bool activate, BaseObject* originator)
     {
         Event event(activate, originator);
 
-        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
-        {
-            event.sectionname_ = it->second;
-            it->first->processEvent(event);
-        }
-    }
-
+        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.sectionname_ = (*it)->eventSources_[this];
+            (*it)->processEvent(event);
+        }
+    }
+
+    /**
+        @brief Fires an event, using the Event struct.
+    */
     void BaseObject::fireEvent(Event& event)
     {
-        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
-            it->first->processEvent(event);
+        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            (*it)->processEvent(event);
     }
 

code/branches/core5/src/libraries/core/BaseObject.h

@@ -152 +152 @@
             virtual void changedGametype() {}
 
+            void addEventSource(BaseObject* source, const std::string& state);
+            void removeEventSource(BaseObject* source);
+            BaseObject* getEventSource(unsigned int index, const std::string& state) const;
+
             void fireEvent();
             void fireEvent(bool activate);
@@ -159 +163 @@
             virtual void processEvent(Event& event);
 
-            inline void registerEventListener(BaseObject* object, const std::string& sectionname)
-                { this->eventListeners_[object] = sectionname; }
-            inline void unregisterEventListener(BaseObject* object)
-                { this->eventListeners_.erase(object); }
-
-            void addEvent(BaseObject* event, const std::string& sectionname);
-            void removeEvent(BaseObject* event);
-            BaseObject* getEvent(unsigned int index) const;
-
-            void addEventContainer(const std::string& sectionname, EventContainer* container);
-            EventContainer* getEventContainer(const std::string& sectionname) const;
-
             /** @brief Sets the indentation of the debug output in the Loader. @param indentation The indentation */
             inline void setLoaderIndentation(const std::string& indentation) { this->loaderIndentation_ = indentation; }
@@ -177 +169 @@
 
         protected:
+            /** @brief Adds an object which listens to the events of this object. */
+            inline void registerEventListener(BaseObject* object)
+                { this->eventListeners_.insert(object); }
+            /** @brief Removes an event listener from this object. */
+            inline void unregisterEventListener(BaseObject* object)
+                { this->eventListeners_.erase(object); }
+
+            void addEventContainer(const std::string& sectionname, EventContainer* container);
+            EventContainer* getEventContainer(const std::string& sectionname) const;
+
             std::string name_;                                 //!< The name of the object
             std::string oldName_;                              //!< The old name of the object
@@ -197 +199 @@
             BaseObject*            creator_;
             SmartPtr<Scene>        scene_;
+            uint32_t               sceneID_;
             SmartPtr<Gametype>     gametype_;
             Gametype*              oldGametype_;
             std::set<Template*>    templates_;
-            std::map<BaseObject*,  std::string> eventListeners_;
-            std::list<BaseObject*> events_;
-            std::map<std::string, EventContainer*> eventContainers_;
-            uint32_t               sceneID_;
+            
+            std::map<BaseObject*, std::string>      eventSources_;      //!< List of objects which send events to this object, mapped to the state which they affect
+            std::set<BaseObject*>                   eventListeners_;    //!< List of objects which listen to the events of this object
+            std::map<std::string, EventContainer*>  eventContainers_;
     };
 

code/branches/core5/src/libraries/core/Event.cc

@@ -30 +30 @@
 
 #include "BaseObject.h"
-#include "Executor.h"
 
 namespace orxonox

code/branches/core5/src/libraries/core/Event.h

@@ -48 +48 @@
     {
         public:
-            EventContainer(const std::string& eventname, Executor* eventfunction, Identifier* subclass) : bActive_(false), eventname_(eventname), eventfunction_(eventfunction), subclass_(subclass), activeEvents_(0) {}
+            EventContainer(const std::string& eventname, Functor* eventfunction, Identifier* subclass) : bActive_(false), eventname_(eventname), eventfunction_(eventfunction), subclass_(subclass), activeEvents_(0) {}
             virtual ~EventContainer();
 
@@ -56 +56 @@
             bool bActive_;
             std::string eventname_;
-            Executor* eventfunction_;
+            Functor* eventfunction_;
             Identifier* subclass_;
 

code/branches/core5/src/libraries/core/EventIncludes.h

@@ -40 +40 @@
 
 #define ORXONOX_SET_SUBCLASS_EVENT(classname, eventname, functionname, event, subclassname) \
+    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
     ORXONOX_SET_EVENT_GENERIC(eventcontainer##classname##functionname, classname, eventname, functionname, event, subclassname)
 
 #define ORXONOX_SET_SUBCLASS_EVENT_TEMPLATE(classname, eventname, functionname, event, subclassname, ...) \
+    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
     ORXONOX_SET_EVENT_GENERIC_TEMPLATE(eventcontainer##classname##functionname, classname, eventname, functionname, event, subclassname, __VA_ARGS__)
 
@@ -49 +51 @@
     if (!containername) \
     { \
-        ExecutorMember<classname>* executor = orxonox::createExecutor(orxonox::createFunctor(&classname::functionname, this), std::string( #classname ) + "::" + #functionname); \
-        containername = new orxonox::EventContainer(std::string(eventname), executor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        Functor* functor = orxonox::createFunctor(&classname::functionname, this); \
+        containername = new orxonox::EventContainer(std::string(eventname), functor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
         this->addEventContainer(eventname, containername); \
     } \
-    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
     containername->process(this, event)
 
@@ -60 +61 @@
     if (!containername) \
     { \
-        ExecutorMember<classname>* executor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::functionname, this), std::string( #classname ) + "::" + #functionname); \
-        containername = new orxonox::EventContainer(std::string(eventname), executor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        Functor* functor = orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::functionname, this); \
+        containername = new orxonox::EventContainer(std::string(eventname), functor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
         this->addEventContainer(eventname, containername); \
     } \
-    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
     containername->process(this, event)
 

code/branches/core5/src/libraries/core/Identifier.h

@@ -261 +261 @@
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
 
+            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
+            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
+
+            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
+            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
+
+
+            //////////////////
+            ///// Events /////
+            //////////////////
             /** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
             inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
@@ -267 +277 @@
             /** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
-
-            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
-            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
-
-            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
-            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
 
             void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);

code/branches/core5/src/modules/objects/eventsystem/EventListener.cc

@@ -78 +78 @@
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
             if (it->getName() == this->eventName_)
-                this->registerAsListener(*it);
+                this->addEventSource(*it, "");
     }
 
@@ -87 +87 @@
 
         if (object->getName() == this->eventName_)
-            this->registerAsListener(object);
-    }
-
-    void EventListener::registerAsListener(BaseObject* object)
-    {
-        object->registerEventListener(this, "");
+            this->addEventSource(object, "");
     }
 }

code/branches/core5/src/modules/objects/eventsystem/EventListener.h

@@ -54 +54 @@
         private:
             virtual void loadedNewXMLName(BaseObject* object);
-            void registerAsListener(BaseObject* object);
 
             std::string eventName_;

code/branches/core5/src/modules/objects/eventsystem/EventTarget.cc

@@ -49 +49 @@
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
             if (it->getName() == this->getName())
-                this->addAsEvent(*it);
+                this->addEventTarget(*it);
     }
 
@@ -58 +58 @@
 
         if (object->getName() == this->getName())
-            this->addAsEvent(object);
+            this->addEventTarget(object);
     }
 
-    void EventTarget::addAsEvent(BaseObject* object)
+    void EventTarget::addEventTarget(BaseObject* object)
     {
         if (object != static_cast<BaseObject*>(this))
-            object->addEvent(this, "");
+            object->addEventSource(this, "");
     }
 }

code/branches/core5/src/modules/objects/eventsystem/EventTarget.h

@@ -47 +47 @@
         private:
             virtual void loadedNewXMLName(BaseObject* object);
-            void addAsEvent(BaseObject* object);
+            void addEventTarget(BaseObject* object);
     };
 }