Changeset 2063 for code/branches/objecthierarchy/src/core

Timestamp:

Oct 29, 2008, 6:39:31 PM (16 years ago)

Author:

landauf

Message:

added events but not yet connected with triggers

Location:

code/branches/objecthierarchy/src/core

Files:

• BaseObject.cc (modified) (2 diffs)
• BaseObject.h (modified) (4 diffs)
• CMakeLists.txt (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• Event.cc (added)
• Event.h (added)
• Identifier.cc (modified) (4 diffs)
• Identifier.h (modified) (3 diffs)
• Super.h (modified) (4 diffs)

code/branches/objecthierarchy/src/core/BaseObject.cc

@@ -94 +94 @@
 
         XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
+
+        Element* events = xmlelement.FirstChildElement("events", false);
+
+        if (events)
+        {
+            std::list<std::string> eventnames;
+
+            if (mode == XMLPort::LoadObject)
+            {
+                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
+                    eventnames.push_back(child->Value());
+            }
+            else if (mode == XMLPort::SaveObject)
+            {
+                for (std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->getIdentifier()->getXMLPortEventMapBegin(); it != this->getIdentifier()->getXMLPortEventMapEnd(); ++it)
+                    eventnames.push_back(it->first);
+            }
+
+            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
+                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");
+                loadexecutor->setDefaultValue(1, sectionname);
+
+                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = 0;
+                container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(this->getIdentifier()->getXMLPortEventContainer(sectionname));
+                if (!container)
+                {
+                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(sectionname, this->getIdentifier(), loadexecutor, saveexecutor, false, true);
+                    this->getIdentifier()->addXMLPortEventContainer(sectionname, container);
+                }
+                container->port(this, *events, mode);
+            }
+        }
     }
 
@@ -146 +181 @@
         return 0;
     }
+
+    void BaseObject::addEvent(BaseObject* event, const std::string& sectionname)
+    {
+        this->eventListeners_.insert(std::pair<std::string, BaseObject*>(sectionname, event));
+    }
+
+    BaseObject* BaseObject::getEvent(unsigned int index) const
+    {
+        unsigned int i = 0;
+        for (std::set<std::pair<std::string, BaseObject*> >::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            if (i == index)
+                return (*it).second;
+            ++i;
+        }
+        return 0;
+    }
+
+    void BaseObject::addEventContainer(const std::string& sectionname, EventContainer* container)
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting EventContainer in class " << this->getIdentifier()->getName() << "." << std::endl;
+            delete (it->second);
+        }
+
+        this->eventContainers_[sectionname] = container;
+    }
+
+    EventContainer* BaseObject::getEventContainer(const std::string& sectionname) const
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.begin();
+        if (it != this->eventContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    void BaseObject::fireEvent()
+    {
+        this->fireEvent(true);
+        this->fireEvent(false);
+    }
+
+    void BaseObject::fireEvent(bool activate)
+    {
+        Event event(activate, this);
+
+        for (std::set<std::pair<std::string, BaseObject*> >::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.sectionname_ = (*it).first;
+            (*it).second->processEvent(event);
+        }
+    }
+
+    void BaseObject::processEvent(Event& event)
+    {
+        SetEvent(BaseObject, "activity", setActive, event);
+        SetEvent(BaseObject, "visibility", setVisible, event);
+    }
 }

code/branches/objecthierarchy/src/core/BaseObject.h

@@ -42 +42 @@
 #include "OrxonoxClass.h"
 #include "XMLIncludes.h"
+#include "Event.h"
 
 namespace orxonox
@@ -110 +111 @@
             virtual inline void changedGametype() {}
 
+            void fireEvent();
+            void fireEvent(bool activate);
+
+            virtual void processEvent(Event& event);
+
+            void addEvent(BaseObject* event, const std::string& sectionname);
+            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; }
@@ -124 +136 @@
             Template* getTemplate(unsigned int index) const;
 
-            bool                bInitialized_;         //!< True if the object was initialized (passed the object registration)
-            const XMLFile*      file_;                 //!< The XMLFile that loaded this object
-            std::string         loaderIndentation_;    //!< Indentation of the debug output in the Loader
-            Namespace*          namespace_;
-            BaseObject*         creator_;
-            Scene*              scene_;
-            Gametype*           gametype_;
-            Gametype*           oldGametype_;
-            std::set<Template*> templates_;
+            bool                  bInitialized_;         //!< True if the object was initialized (passed the object registration)
+            const XMLFile*        file_;                 //!< The XMLFile that loaded this object
+            std::string           loaderIndentation_;    //!< Indentation of the debug output in the Loader
+            Namespace*            namespace_;
+            BaseObject*           creator_;
+            Scene*                scene_;
+            Gametype*             gametype_;
+            Gametype*             oldGametype_;
+            std::set<Template*>   templates_;
+            std::set<std::pair<std::string, BaseObject*> > eventListeners_;
+            std::map<std::string, EventContainer*> eventContainers_;
     };
 
@@ -138 +152 @@
     SUPER_FUNCTION(2, BaseObject, changedActivity, false);
     SUPER_FUNCTION(3, BaseObject, changedVisibility, false);
+    SUPER_FUNCTION(4, BaseObject, processEvent, false);
 }
 

code/branches/objecthierarchy/src/core/CMakeLists.txt

@@ -4 +4 @@
   ConfigValueContainer.cc
   Core.cc
+  Event.cc
   GameState.cc
   Language.cc

code/branches/objecthierarchy/src/core/CorePrereqs.h

@@ -113 +113 @@
   class ConsoleCommand;
   class Core;
+  struct Event;
+  class EventContainer;
   class Executor;
   template <class T>

code/branches/objecthierarchy/src/core/Identifier.cc

@@ -421 +421 @@
     XMLPortParamContainer* Identifier::getXMLPortParamContainer(const std::string& paramname)
     {
-        std::map<std::string, XMLPortParamContainer*>::const_iterator it = xmlportParamContainers_.find(paramname);
-        if (it != xmlportParamContainers_.end())
+        std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
+        if (it != this->xmlportParamContainers_.end())
             return ((*it).second);
         else
@@ -435 +435 @@
     void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
     {
+        std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
+        if (it != this->xmlportParamContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting XMLPortParamContainer in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
+
         this->xmlportParamContainers_[paramname] = container;
     }
@@ -445 +452 @@
     XMLPortObjectContainer* Identifier::getXMLPortObjectContainer(const std::string& sectionname)
     {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
-        if (it != xmlportObjectContainers_.end())
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
+        if (it != this->xmlportObjectContainers_.end())
             return ((*it).second);
         else
@@ -459 +466 @@
     void Identifier::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
     {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
+        if (it != this->xmlportObjectContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting XMLPortObjectContainer in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
+
         this->xmlportObjectContainers_[sectionname] = container;
+    }
+
+    /**
+        @brief Returns a XMLPortEventContainer that attaches an event to this class.
+        @param sectionname The name of the section that contains the event
+        @return The container
+    */
+    XMLPortObjectContainer* Identifier::getXMLPortEventContainer(const std::string& eventname)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
+        if (it != this->xmlportEventContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds a new XMLPortEventContainer that attaches an event to this class.
+        @param sectionname The name of the section that contains the event
+        @param container The container
+    */
+    void Identifier::addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
+        if (it != this->xmlportEventContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting XMLPortEventContainer in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
+
+        this->xmlportEventContainers_[eventname] = container;
     }
 

code/branches/objecthierarchy/src/core/Identifier.h

@@ -210 +210 @@
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
 
+            /** @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_; }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
+            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
+            /** @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(); }
+
             /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
             inline bool hasConfigValues() const { return this->bHasConfigValues_; }
@@ -233 +240 @@
             void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
             XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
+
+            void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
+            XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
 
             ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
@@ -307 +317 @@
             std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
             std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
+            std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_;    //!< All events
     };
 

code/branches/objecthierarchy/src/core/Super.h

@@ -73 +73 @@
 #include "util/Debug.h"
 #include "XMLIncludes.h"
+#include "Event.h"
 
 ///////////////////////
@@ -229 +230 @@
     #define SUPER_changedVisibility(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
+
+    #define SUPER_processEvent(classname, functionname, ...) \
+        SUPER_ARGS(classname, functionname, __VA_ARGS__)
     // (1/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 
@@ -433 +437 @@
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(4, processEvent, true, Event& event)
+            (event)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
         // (2/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 
@@ -479 +487 @@
     SUPER_INTRUSIVE_DECLARATION(changedActivity);
     SUPER_INTRUSIVE_DECLARATION(changedVisibility);
+    SUPER_INTRUSIVE_DECLARATION(processEvent);
     // (3/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--