Changeset 847

Timestamp:

Mar 3, 2008, 1:49:06 AM (17 years ago)

Author:

landauf

Message:

new loader-concept is taking shape, but not yet finished

added new classes: Functor, Executor and XMLPortParamContainer.
more to come (i.e. XMLPortObjectContainer)

Executor might be useless, depends on how we'll implement the ingame shell-commands and the keybindings

moved all non-identifier-related functions and variables from OrxonoxClass to BaseObject. this might result in some casts to BaseObject when working with all objects of an interface (like Synchronisable), but I think it improves the class hierarchy.

Location:

code/branches/core/src/orxonox/core

Files:

• BaseObject.cc (modified) (3 diffs)
• BaseObject.h (modified) (1 diff)
• CMakeLists.txt (modified) (1 diff)
• ConfigValueContainer.cc (modified) (1 diff)
• ConfigValueContainer.h (modified) (1 diff)
• CoreIncludes.h (modified) (1 diff)
• CorePrereqs.h (modified) (2 diffs)
• Executor.cc (added)
• Executor.h (added)
• Functor.h (added)
• Identifier.cc (modified) (1 diff)
• Identifier.h (modified) (5 diffs)
• Language.cc (modified) (2 diffs)
• Language.h (modified) (3 diffs)
• Loader.cc (modified) (1 diff)
• OrxonoxClass.cc (modified) (1 diff)
• OrxonoxClass.h (modified) (1 diff)
• XMLPort.cc (added)
• XMLPort.h (added)

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

@@ -34 +34 @@
 
 #include "BaseObject.h"
+#include "XMLPort.h"
 
 namespace orxonox
@@ -46 +47 @@
         RegisterRootObject(BaseObject);
 
+        this->bActive_ = true;
+        this->bVisible_ = true;
         this->level_ = 0;
     }
@@ -75 +78 @@
     Element& BaseObject::XMLPort(Element& xmlelement, bool loading)
     {
-//        XMLPortParam(BaseObject, "name", setName, getName, xmlelement, loading);
+        XMLPortParam(BaseObject, "name", setName, getName, xmlelement, loading);
 
         return xmlelement;

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

@@ -52 +52 @@
             virtual Element& XMLPort(Element& xmlelement, bool loading);
 
+            /** @brief Sets the name of the object. @param name The name */
+            inline void setName(const std::string& name) { this->name_ = name; this->changedName(); }
+            /** @brief Returns the name of the object. @return The name */
+            inline const std::string& getName() const { return this->name_; }
+            /** @brief This function gets called if the name of the object changes. */
+            virtual void changedName() {}
+
+            /** @brief Sets the state of the objects activity. @param bActive True = active */
+            inline void setActivity(bool bActive) { this->bActive_ = bActive; this->changedActivity(); }
+            /** @brief Returns the state of the objects activity. @return The state of the activity */
+            inline const bool isActive() const { return this->bActive_; }
+            /** @brief This function gets called if the activity of the object changes. */
+            virtual void changedActivity() {}
+
+            /** @brief Sets the state of the objects visibility. @param bVisible True = visible */
+            inline void setVisibility(bool bVisible) { this->bVisible_ = bVisible; this->changedVisibility(); }
+            /** @brief Returns the state of the objects visibility. @return The state of the visibility */
+            inline const bool isVisible() const { return this->bVisible_; }
+            /** @brief This function gets called if the visibility of the object changes. */
+            virtual void changedVisibility() {}
+
+            /** @brief Sets a pointer to the level that loaded this object. @param level The pointer to the level */
+            inline void setLevel(const Level* level) { this->level_ = level; }
             /** @brief Returns a pointer to the level that loaded this object. @return The level */
             inline const Level* getLevel() const { return this->level_; }
 
         private:
+            std::string name_;                          //!< The name of the object
+            bool bActive_;                              //!< True = the object is active
+            bool bVisible_;                             //!< True = the object is visible
             const Level* level_;                        //!< The level that loaded this object
     };

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

@@ -15 +15 @@
   ClassTreeMask.cc
   Loader.cc
+  Executor.cc
+  XMLPort.cc
 )
 

code/branches/core/src/orxonox/core/ConfigValueContainer.cc

@@ -957 +957 @@
         @return The description
     */
-    std::string ConfigValueContainer::getDescription() const
+    const std::string& ConfigValueContainer::getDescription() const
     {
         return GetLocalisation(this->description_);

code/branches/core/src/orxonox/core/ConfigValueContainer.h

@@ -100 +100 @@
 
             void description(const std::string& description);
-            std::string getDescription() const;
+            const std::string& getDescription() const;
 
             bool parseString(const std::string& input, MultiTypeMath& defvalue);

code/branches/core/src/orxonox/core/CoreIncludes.h

@@ -121 +121 @@
     { \
         container##varname = new orxonox::ConfigValueContainer(this->getIdentifier()->getName(), #varname, varname = defvalue); \
-        this->getIdentifier()->setConfigValueContainer(#varname, container##varname); \
+        this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
     } \
     container##varname->getValue(&varname)

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

@@ -82 +82 @@
   class DebugLevel;
   class Error;
+  class Executor;
   class Factory;
   class Identifier;
@@ -102 +103 @@
   template <class T>
   class SubclassIdentifier;
+  class XMLPortParamContainer;
+  template <class T>
+  class XMLPortClassParamContainer;
 }
 

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

@@ -198 +198 @@
 
     /**
+        @brief Returns the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variable
+        @return The ConfigValueContainer
+    */
+    ConfigValueContainer* Identifier::getConfigValueContainer(const std::string& varname)
+    {
+        std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_.find(varname);
+        if (it != configValues_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variablee
+        @param container The container
+    */
+    void Identifier::addConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
+    {
+        this->configValues_[varname] = container;
+    }
+
+    /**
         @brief Searches for a given identifier in a list and returns whether the identifier is in the list or not.
         @param identifier The identifier to look for

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

@@ -62 +62 @@
 #include "Debug.h"
 #include "Iterator.h"
+//#include "XMLPort.h"
 
 namespace orxonox
@@ -151 +152 @@
             void setNetworkID(unsigned int id);
 
-            /** @brief Returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable @return The ConfigValueContainer */
-            inline ConfigValueContainer* getConfigValueContainer(const std::string& varname)
-                { return this->configValues_[varname]; }
-
-            /** @brief Sets the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variablee @param container The container */
-            inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
-                { this->configValues_[varname] = container; }
+            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
+            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
+
+            virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
+            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
 
             static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
@@ -236 +235 @@
             inline const ObjectList<T>* getObjects() const { return this->objects_; }
 
+            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
+            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
+
         private:
             ClassIdentifier();
@@ -243 +245 @@
             ObjectList<T>* objects_;    //!< The ObjectList, containing all objects of type T
             bool bSetName_;             //!< True if the name is set
+            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;
     };
 
@@ -317 +320 @@
         for (Iterator<T> it = this->objects_->start(); it;)
             delete *(it++);
+    }
+
+    template <class T>
+    XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
+    {
+        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
+        if (it != xmlportParamContainers_.end())
+            return (XMLPortParamContainer*)((*it).second);
+        else
+            return 0;
+    }
+
+    template <class T>
+    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
     }
 

code/branches/core/src/orxonox/core/Language.cc

@@ -145 +145 @@
         {
             LanguageEntry* newEntry = new LanguageEntry(entry);
-            newEntry->setName(label);
+            newEntry->setLabel(label);
             this->languageEntries_[label] = newEntry;
             return newEntry;
@@ -332 +332 @@
         for (Iterator<LanguageEntry> it = ObjectList<LanguageEntry>::start(); it; ++it)
         {
-            file << it->getName() << "=" << it->getDefault() << std::endl;
+            file << it->getLabel() << "=" << it->getDefault() << std::endl;
         }
 

code/branches/core/src/orxonox/core/Language.h

@@ -51 +51 @@
 #include "OrxonoxClass.h"
 
+
+#define AddLanguageEntry(label, fallbackstring) \
+    orxonox::Language::getLanguage().addEntry(label, fallbackstring)
+
+#define GetLocalisation(label) \
+    orxonox::Language::getLanguage().getLocalisation(label)
+
+
 namespace orxonox
 {
@@ -78 +86 @@
                 { return this->fallbackEntry_; }
 
+            /**
+                @brief Sets the label of this entry.
+                @param label The label
+            */
+            inline void setLabel(const LanguageEntryLabel& label)
+                { this->label_ = label; }
+
+            /**
+                @brief Returns the label of this entry.
+                @return The label
+            */
+            inline const LanguageEntryLabel& getLabel() const
+                { return this->label_; }
+
         private:
-            std::string fallbackEntry_;                             //!< The default entry: Used, if no translation is available or no language configured
-            std::string localisedEntry_;                            //!< The localised entry in the configured language
-            bool bLocalisationSet_;                                 //!< True if the translation was set
+            LanguageEntryLabel label_;              //!< The label of the entry
+            std::string fallbackEntry_;             //!< The default entry: Used, if no translation is available or no language configured
+            std::string localisedEntry_;            //!< The localised entry in the configured language
+            bool bLocalisationSet_;                 //!< True if the translation was set
     };
 
@@ -118 +141 @@
 }
 
-#define AddLanguageEntry(label, fallbackstring) \
-    orxonox::Language::getLanguage().addEntry(label, fallbackstring)
-
-#define GetLocalisation(label) \
-    orxonox::Language::getLanguage().getLocalisation(label)
-
 #endif /* _Language_H__ */

code/branches/core/src/orxonox/core/Loader.cc

@@ -121 +121 @@
                     COUT(4) << "  fabricating " << child->Value() << "..." << std::endl;
                     BaseObject* newObject = identifier->fabricate();
+                    newObject->XMLPort(*child, true);
                 }
                 else

code/branches/core/src/orxonox/core/OrxonoxClass.cc

@@ -42 +42 @@
         this->identifier_ = 0;
         this->parents_ = 0;
-
-        this->bActive_ = true;
-        this->bVisible_ = true;
     }
 

code/branches/core/src/orxonox/core/OrxonoxClass.h

@@ -155 +155 @@
                 { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
 
-
-            /** @brief Sets the name of the object. @param name The name */
-            inline virtual void setName(const std::string& name) { this->name_ = name; }
-
-            /** @brief Returns the name of the object. @return The name */
-            inline const std::string& getName() const { return this->name_; }
-
-            /** @brief Sets the state of the objects activity. @param bActive True = active */
-            inline virtual void setActive(bool bActive) { this->bActive_ = bActive; }
-
-            /** @brief Returns the state of the objects activity. @return The state of the activity */
-            inline const bool isActive() const { return this->bActive_; }
-
-            /** @brief Sets the state of the objects visibility. @param bVisible True = visible */
-            inline virtual void setVisible(bool bVisible) { this->bVisible_ = bVisible; }
-
-            /** @brief Returns the state of the objects visibility. @return The state of the visibility */
-            inline const bool isVisible() const { return this->bVisible_; }
-
         private:
             Identifier* identifier_;                    //!< The Identifier of the object
             std::list<const Identifier*>* parents_;     //!< List of all parents of the object
             MetaObjectList metaList_;                   //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
-
-            std::string name_;                          //!< The name of the object
-            bool bActive_;                              //!< True = the object is active
-            bool bVisible_;                             //!< True = the object is visible
     };
 }