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

Timestamp:

Oct 27, 2008, 4:08:51 AM (16 years ago)

Author:

landauf

Message:

many changes, most important: BaseObject takes now a pointer to it's creator which is needed to build a level hierarchy (with different scenes)

Location:

code/branches/objecthierarchy/src/core

Files:

• BaseObject.cc (modified) (4 diffs)
• BaseObject.h (modified) (4 diffs)
• ClassFactory.h (modified) (4 diffs)
• Factory.cc (modified) (1 diff)
• Factory.h (modified) (1 diff)
• Functor.h (modified) (1 diff)
• Identifier.cc (modified) (1 diff)
• Identifier.h (modified) (3 diffs)
• Loader.cc (modified) (1 diff)
• Namespace.cc (modified) (1 diff)
• Namespace.h (modified) (1 diff)
• Template.cc (modified) (2 diffs)
• Template.h (modified) (1 diff)
• XMLPort.h (modified) (2 diffs)

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

@@ -47 +47 @@
         @brief Constructor: Registers the object in the BaseObject-list.
     */
-    BaseObject::BaseObject() : bInitialized_(false)
+    BaseObject::BaseObject(BaseObject* creator) : bInitialized_(false)
     {
         RegisterRootObject(BaseObject);
@@ -55 +55 @@
         this->bActive_ = true;
         this->bVisible_ = true;
+        this->oldGametype_ = 0;
 
-        this->file_ = 0;
-        this->namespace_ = 0;
+        this->setCreator(creator);
+        if (this->creator_)
+        {
+            this->setFile(this->creator_->getFile());
+            this->setNamespace(this->creator_->getNamespace());
+            this->setScene(this->creator_->getScene());
+            this->setGametype(this->creator_->getGametype());
+        }
+        else
+        {
+            this->file_ = 0;
+            this->namespace_ = 0;
+            this->scene_ = 0;
+            this->gametype_ = 0;
+        }
     }
 
@@ -79 +93 @@
         XMLPortParam(BaseObject, "active", setActive, isActive, xmlelement, mode);
 
-        XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, const std::string&);
+        XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
     }
 
@@ -91 +105 @@
             return this->file_->getFilename();
         else
-            return blankString;
+            return BLANKSTRING;
     }
 

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

@@ -45 +45 @@
 namespace orxonox
 {
+    class Scene;
+    class Gametype;
+
     //! The BaseObject is the parent of all classes representing an instance in the game.
     class _CoreExport BaseObject : virtual public OrxonoxClass
@@ -51 +54 @@
 
         public:
-            BaseObject();
+            BaseObject(BaseObject* creator);
             virtual ~BaseObject();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
@@ -96 +99 @@
             inline Namespace* getNamespace() const { return this->namespace_; }
 
+            inline void setCreator(BaseObject* creator) { this->creator_ = creator; }
+            inline BaseObject* getCreator() const { return this->creator_; }
+
+            inline void setScene(Scene* scene) { this->scene_ = scene; }
+            inline Scene* getScene() const { return this->scene_; }
+
+            inline void setGametype(Gametype* gametype) { this->oldGametype_ = this->gametype_; this->gametype_ = gametype; this->changedGametype(); }
+            inline Gametype* getGametype() const { return this->gametype_; }
+            inline Gametype* getOldGametype() const { return this->oldGametype_; }
+            virtual inline void changedGametype() {}
+
             /** @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; }
@@ -110 +124 @@
             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_;
+            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_;
     };

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

@@ -56 +56 @@
         public:
             static bool create(const std::string& name, bool bLoadable = true);
-            BaseObject* fabricate();
+            BaseObject* fabricate(BaseObject* creator);
 
         private:
@@ -63 +63 @@
             virtual ~ClassFactory() {}                      // Don't delete
 
-            static T* createNewObject();
+            static T* createNewObject(BaseObject* creator);
     };
 
@@ -88 +88 @@
     */
     template <class T>
-    BaseObject* ClassFactory<T>::fabricate()
+    BaseObject* ClassFactory<T>::fabricate(BaseObject* creator)
     {
-        return ClassFactory<T>::createNewObject();
+        return ClassFactory<T>::createNewObject(creator);
     }
 
@@ -98 +98 @@
     */
     template <class T>
-    T* ClassFactory<T>::createNewObject()
+    T* ClassFactory<T>::createNewObject(BaseObject* creator)
     {
-        return new T;
+        return new T(creator);
     }
 }

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

@@ -104 +104 @@
         {
             // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
-            BaseObject* temp = (*it).second->fabricate();
+            BaseObject* temp = (*it).second->fabricate(0);
             delete temp;
         }

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

@@ -93 +93 @@
     {
         public:
-            virtual BaseObject* fabricate() = 0;
+            virtual BaseObject* fabricate(BaseObject* creator) = 0;
             virtual ~BaseFactory() {};
     };

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

@@ -106 +106 @@
             inline const MultiType& getReturnvalue() const { return this->returnedValue_; }
 
-            const std::string& getTypenameParam(unsigned int param) const { return (param < 5) ? this->typeParam_[param] : blankString; }
+            const std::string& getTypenameParam(unsigned int param) const { return (param < 5) ? this->typeParam_[param] : BLANKSTRING; }
             const std::string& getTypenameReturnvalue() const { return this->typeReturnvalue_; }
 

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

@@ -214 +214 @@
         @return The new object
     */
-    BaseObject* Identifier::fabricate()
+    BaseObject* Identifier::fabricate(BaseObject* creator)
     {
         if (this->factory_)
         {
-            return this->factory_->fabricate(); // We have to return a BaseObject, because we don't know the exact type.
+            return this->factory_->fabricate(creator); // We have to return a BaseObject, because we don't know the exact type.
         }
         else

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

@@ -100 +100 @@
             inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
 
-            BaseObject* fabricate();
+            BaseObject* fabricate(BaseObject* creator);
             bool isA(const Identifier* identifier) const;
             bool isExactlyA(const Identifier* identifier) const;
@@ -502 +502 @@
                 @brief Overloading of the * operator: returns the assigned identifier.
             */
-            inline Identifier* operator*()
+            inline Identifier* operator*() const
             {
                 return this->identifier_;
@@ -527 +527 @@
                 @return The new object
             */
-            T* fabricate()
-            {
-                BaseObject* newObject = this->identifier_->fabricate();
+            T* fabricate(BaseObject* creator) const
+            {
+                BaseObject* newObject = this->identifier_->fabricate(creator);
 
                 // Check if the creation was successful

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

@@ -144 +144 @@
 
             COUT(4) << "  creating root-namespace..." << std::endl;
-            Namespace* rootNamespace = new Namespace();
+            Namespace* rootNamespace = new Namespace(0);
             rootNamespace->setLoaderIndentation("    ");
             rootNamespace->setFile(file);

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

@@ -37 +37 @@
     CreateFactory(Namespace);
 
-    Namespace::Namespace() :
+    Namespace::Namespace(BaseObject* creator) : BaseObject(creator),
       bAutogeneratedFileRootNamespace_(false),
       bRoot_(false),

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

@@ -42 +42 @@
     {
         public:
-            Namespace();
+            Namespace(BaseObject* creator);
             virtual ~Namespace();
 

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

@@ -38 +38 @@
     CreateFactory(Template);
 
-    Template::Template() : xmlelement_("")
+    Template::Template(BaseObject* creator) : BaseObject(creator), xmlelement_("")
     {
         RegisterObject(Template);
@@ -59 +59 @@
         XMLPortParam(Template, "baseclass", setBaseclass, getBaseclass, xmlelement, mode);
 
-        this->setXMLElement(*dynamic_cast<TiXmlElement*>(xmlelement.FirstChildElement(false)->GetTiXmlPointer()));
+        Element* element = xmlelement.FirstChildElement(false);
+        if (element)
+        {
+            TiXmlElement* tixmlelement = dynamic_cast<TiXmlElement*>(element->GetTiXmlPointer());
+            if (tixmlelement)
+                this->setXMLElement(*tixmlelement);
+        }
     }
 

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

@@ -42 +42 @@
     {
         public:
-            Template();
+            Template(BaseObject* creator);
             virtual ~Template();
 

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

@@ -479 +479 @@
                                                 COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::endl;
 
-                                                BaseObject* newObject = identifier->fabricate();
+                                                BaseObject* newObject = identifier->fabricate((BaseObject*)object);
                                                 newObject->setLoaderIndentation(((BaseObject*)object)->getLoaderIndentation() + "  ");
-                                                newObject->setFile(((BaseObject*)object)->getFile());
-                                                newObject->setNamespace(((BaseObject*)object)->getNamespace());
+//                                                newObject->setFile(((BaseObject*)object)->getFile());
+//                                                newObject->setNamespace(((BaseObject*)object)->getNamespace());
 
                                                 if (this->bLoadBefore_)
@@ -515 +515 @@
                                 else
                                 {
-                                    COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::endl;
+                                    if (this->sectionname_ != "")
+                                    {
+                                        COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::endl;
+                                    }
+                                    else
+                                    {
+                                        // It's probably just another subsection
+                                    }
                                 }
                             }