Changeset 221

Timestamp:

Nov 20, 2007, 2:57:59 AM (17 years ago)

Author:

landauf

Message:

• made ObjectList double-linked to allow forward- and backward-iterating. its now a LI(F/L)O list.

• added an iterator to iterate through object-lists. you can iterate forwards and backwards.

iterating forwards is easy: you get "0 1 2 … last"
iterating backwards is a bit tricky: you still get "0" first, but then "last … 2 1".
thats caused by the structure of the for-loop: you get the first element before the iterator knows if you'll increase or decrease it

Location:

code/branches/objecthierarchie/src

Files:

• BaseObject.h (modified) (1 diff)
• CMakeLists.txt (modified) (1 diff)
• Identifier.cc (modified) (1 diff)
• Identifier.h (modified) (4 diffs)
• IdentifierIncludes.h (modified) (1 diff)
• Iterator.h (added)
• ObjectList.cc (modified) (3 diffs)
• ObjectList.h (modified) (2 diffs)
• orxonox.cc (modified) (2 diffs)

code/branches/objecthierarchie/src/BaseObject.h

@@ -64 +64 @@
                 { this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
 
+            std::string name_; // test
+
     };
 }

code/branches/objecthierarchie/src/CMakeLists.txt

@@ -3 +3 @@
 # create a few variables to simplify life
 SET(SRC_FILES orxonox.cc IdentifierList.cc ObjectList.cc Identifier.cc Factory.cc OrxonoxClass.cc BaseObject.cc test1.cc test2.cc test3.cc)
-SET(INC_FILES IdentifierIncludes.h Identifier.h Factory.h IdentifierList.h ObjectList.h OrxonoxClass.h BaseObject.h Test.h test1.h test2.h test3.h)
+SET(INC_FILES IdentifierIncludes.h Identifier.h Factory.h IdentifierList.h ObjectList.h Iterator.h OrxonoxClass.h BaseObject.h Test.h test1.h test2.h test3.h)
 
 #Creates an executable

code/branches/objecthierarchie/src/Identifier.cc

@@ -84 +84 @@
     void Identifier::removeObject(OrxonoxClass* object)
     {
-        std::cout << "*** Removed object from " << this->name_ << "-list.\n";
-        this->objects_.remove(object);
+        bool bIterateForwards = !Identifier::isCreatingHierarchy();
+
+        if (bIterateForwards)
+            std::cout << "*** Removed object from " << this->name_ << "-list, iterating forwards.\n";
+        else
+            std::cout << "*** Removed object from " << this->name_ << "-list, iterating backwards.\n";
+
+        this->objects_.remove(object, bIterateForwards);
 
         IdentifierListElement* temp = this->directParents_.first_;

code/branches/objecthierarchie/src/Identifier.h

@@ -35 +35 @@
         friend class BaseIdentifier;
 
+        template <class T>
+        friend class Iterator;
+
         public:
             void addObject(OrxonoxClass* object);
@@ -172 +175 @@
             Identifier::startCreatingHierarchy();
             T* temp = new T();
+            delete temp;
             Identifier::stopCreatingHierarchy();
-            delete temp;
         }
 
@@ -186 +189 @@
             BaseIdentifier();
 
-            BaseIdentifier<B>& operator= (Identifier* identifier)
+            BaseIdentifier<B>& operator=(Identifier* identifier)
             {
                 if (!identifier->isA(ClassIdentifier<B>::getIdentifier()))
@@ -199 +202 @@
             }
 
-            Identifier* operator* ()
+            Identifier* operator*()
             {
                 return this->identifier_;
             }
 
-            Identifier* operator-> () const
+            Identifier* operator->() const
             {
                 return this->identifier_;

code/branches/objecthierarchie/src/IdentifierIncludes.h

@@ -3 +3 @@
 #include "IdentifierList.h"
 #include "ObjectList.h"
+#include "Iterator.h"
 #include "OrxonoxClass.h"
 

code/branches/objecthierarchie/src/ObjectList.cc

@@ -9 +9 @@
     {
         this->first_ = 0;
+        this->last_ = 0;
     }
 
@@ -24 +25 @@
     void ObjectList::add(OrxonoxClass* object)
     {
-        ObjectListElement* temp = this->first_;
-        this->first_ = new ObjectListElement(object);
-        this->first_->next_ = temp;
+        if (!this->last_)
+        {
+            this->last_ = new ObjectListElement(object);
+            this->first_ = this->last_;
+        }
+        else
+        {
+            ObjectListElement* temp = this->last_;
+            this->last_ = new ObjectListElement(object);
+            this->last_->prev_ = temp;
+            temp->next_ = this->last_;
+        }
     }
 
-    void ObjectList::remove(OrxonoxClass* object)
+    void ObjectList::remove(OrxonoxClass* object, bool bIterateForwards)
     {
-        if (!object)
+        if (!object || !this->first_ || !this->last_)
             return;
 
-        if (this->first_->object_ == object)
+        if (this->first_ == this->last_)
         {
-            ObjectListElement* temp = this->first_->next_;
-            delete this->first_;
-            this->first_ = temp;
+            if (this->first_->object_ == object)
+            {
+                delete this->first_;
+                this->first_ = 0;
+                this->last_ = 0;
+            }
 
             return;
         }
 
-        ObjectListElement* temp = this->first_;
-        while (temp->next_)
+        if (bIterateForwards)
         {
-            if (temp->next_->object_ == object)
+            if (this->first_->object_ == object)
             {
-                ObjectListElement* temp2 = temp->next_->next_;
-                delete temp->next_;
-                temp->next_ = temp2;
+                ObjectListElement* temp = this->first_->next_;
+                delete this->first_;
+                this->first_ = temp;
 
                 return;
             }
 
-            temp = temp->next_;
+            ObjectListElement* temp = this->first_;
+            while (temp->next_)
+            {
+                if (temp->next_->object_ == object)
+                {
+                    ObjectListElement* temp2 = temp->next_->next_;
+                    delete temp->next_;
+                    temp->next_ = temp2;
+                    temp2->prev_ = temp;
+
+                    return;
+                }
+
+                temp = temp->next_;
+            }
+        }
+        else
+        {
+            if (this->last_->object_ == object)
+            {
+                ObjectListElement* temp = this->last_->prev_;
+                delete this->last_;
+                this->last_ = temp;
+
+                return;
+            }
+
+            ObjectListElement* temp = this->last_;
+            while (temp->prev_)
+            {
+                if (temp->prev_->object_ == object)
+                {
+                    ObjectListElement* temp2 = temp->prev_->prev_;
+                    delete temp->prev_;
+                    temp->prev_ = temp2;
+                    temp2->next_ = temp;
+
+                    return;
+                }
+
+                temp = temp->prev_;
+            }
         }
     }
@@ -67 +120 @@
         this->object_ = object;
         this->next_ = 0;
+        this->prev_ = 0;
     }
 

code/branches/objecthierarchie/src/ObjectList.h

@@ -14 +14 @@
             OrxonoxClass* object_;
             ObjectListElement* next_;
+            ObjectListElement* prev_;
     };
 
@@ -22 +23 @@
             ~ObjectList();
             void add(OrxonoxClass* object);
-            void remove(OrxonoxClass* object);
+            void remove(OrxonoxClass* object, bool bIterateForwards = true);
 
             ObjectListElement* first_;
+            ObjectListElement* last_;
     };
 }

code/branches/objecthierarchie/src/orxonox.cc

@@ -500 +500 @@
         delete test8_03;
 */
-
+/*
         std::cout << "Test 9\n";
         std::cout << "1\n";
@@ -526 +526 @@
         delete test9_05;
         delete test9_06;
+*/
+        std::cout << "Test 10\n";
+        Identifier* test9_01 = Class(A1B2);
+        Identifier* test9_02 = Class(A2);
+        Identifier* test9_03 = Class(A3B1C1);
+
+
+        BaseObject* test9_04 = test9_01->fabricate();
+        BaseObject* test9_05 = test9_02->fabricate();
+        BaseObject* test9_06 = test9_03->fabricate();
+
+        BaseObject* test9_07;
+        for (int i = 0; i < 10; i++)
+            test9_07 = Factory("A1B1C1");
+
+        std::cout << "1\n";
+        int count = 0;
+        for (Iterator<BaseObject> it; it != 0; it++)
+            count++;
+        std::cout << "Anzahl BaseObjects: " << count << "\n";
+
+        count = 0;
+        for (Iterator<A1> it; it != 0; it++)
+            count++;
+        std::cout << "Anzahl A1: " << count << "\n";
+
+        count = 0;
+        for (Iterator<A1B1> it; it; it++)
+            count++;
+        std::cout << "Anzahl A1B1: " << count << "\n";
+
+        count = 0;
+        for (Iterator<A1B1C1> it; it; it++)
+            count++;
+        std::cout << "Anzahl A1B1C1: " << count << "\n";
+
+        count = 0;
+        for (Iterator<A2> it; it; it++)
+            count++;
+        std::cout << "Anzahl A2: " << count << "\n";
+
+
+        std::cout << "2\n";
+        BaseObject* test9_08;
+        for (int i = 0; i < 10; i++)
+        {
+            test9_08 = Factory("A2B1C1");
+            test9_08->name_ = "A2B1C1#";
+            test9_08->name_ += ('0' + i);
+        }
+
+        for (Iterator<A2B1C1> it; it; it++)
+            std::cout << "Name: " << it->name_ << "\n";
+
+        std::cout << "3\n";
+        for (Iterator<A2B1C1> it; it; it--)
+            std::cout << "Name: " << it->name_ << "\n";
+
+        std::cout << "4\n";
 
       }