Changeset 817

Timestamp:

Feb 16, 2008, 7:31:18 PM (16 years ago)

Author:

landauf

Message:

big update:

• reimplemented direct-child and direct-parent list and several related functions (get-iterator, get-list)
• reimplemented isDirectChildOf- and isDirectParentOf-functions in Identifier, SubclassIdentifier and OrxonoxClass
• renamed isDirectlyA to isExactlyA in Identifier, SubclassIdentifier and OrxonoxClass

• ClassTreeMask works now with interfaces and has more possibilities (parameters for overwriting of previous rules and cleaning after adding a new function)

• ObjectList's begin() and end() functions use ClassManager to avoid problems with libraries
• the Factory got functions to return begin() and end() iterator for the identifier-map
• overloaded << operator to put identifier-lists on the stream

Location:

code/branches/core/src/orxonox

Files:

• Orxonox.cc (modified) (25 diffs)
• core/ClassTreeMask.cc (modified) (18 diffs)
• core/ClassTreeMask.h (modified) (7 diffs)
• core/Factory.cc (modified) (1 diff)
• core/Factory.h (modified) (1 diff)
• core/Identifier.cc (modified) (9 diffs)
• core/Identifier.h (modified) (13 diffs)
• core/ObjectList.h (modified) (4 diffs)
• core/OrxonoxClass.h (modified) (5 diffs)
• objects/Test.h (modified) (3 diffs)
• orxonox_from_oh.cc (deleted)

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

@@ -78 +78 @@
 #include "core/ClassTreeMask.h"
 #include "objects/WorldEntity.h"
+#include "core/DebugLevel.h"
 #include "core/BaseObject.h"
 #include "objects/Test.h"
@@ -231 +232 @@
       break;
     }
-
         #define testandcout(code) \
           std::cout << #code << " " << code << "\n"
-
 /*
         std::cout << "Test 1\n";
@@ -259 +258 @@
         test4 = new A3();
         test4 = new A3();
-*/
-/*
+
+
         std::cout << "Test 5\n";
         A1* test5_01 = new A1();
@@ -280 +279 @@
         A3B2C1* test5_17 = new A3B2C1();
         A3B2C2* test5_18 = new A3B2C2();
-
-        OrxonoxClass* test5;
+*/
+/*
+        OrxonoxClass* test5 = 0;
         for (int i = 0; i <= 18; i++)
         {
@@ -305 +305 @@
 
           std::cout << "\n";
-          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): parents:     " << test5->getIdentifier()->getParents().toString() << "\n";
-          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): children:    " << test5->getIdentifier()->getChildren().toString() << "\n";
+          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): parents:         " << test5->getIdentifier()->getParents() << "\n";
+          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): children:        " << test5->getIdentifier()->getChildren() << "\n";
+          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): direct parents:  " << test5->getIdentifier()->getDirectParents() << "\n";
+          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): direct children: " << test5->getIdentifier()->getDirectChildren() << "\n";
         }
-
-        std::cout << "Class with ID 0: " << ID(0) << " " << ID(0)->getName() << "\n";
-        std::cout << "Class with ID 1: " << ID(1) << " " << ID(1)->getName() << "\n";
-        std::cout << "Class with ID 2: " << ID(2) << " " << ID(2)->getName() << "\n";
-        std::cout << "Class with ID 3: " << ID(3) << " " << ID(3)->getName() << "\n";
-        std::cout << "Class with ID 4: " << ID(4) << " " << ID(4)->getName() << "\n";
+*/
+/*
+        for (std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryBegin(); it != Factory::getFactoryEnd(); ++it)
+            std::cout << "Class with ID " << (*it).second->getNetworkID() << ": " << ID((*it).second->getNetworkID()) << " / " << ID((*it).second->getNetworkID())->getName() << std::endl;
+
         std::cout << "Class with ID 100: " << ID(100) << "\n";
         std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
@@ -360 +361 @@
         std::cout << "isDirectA(XYZ)-Test:\n";
         std::cout << "test5_01 = A1, Erwartet: 1 0 0 0 0\n";
-        testandcout(test5_01->isDirectlyA(Class(A1)));
-        testandcout(test5_01->isDirectlyA(Class(A2)));
-        testandcout(test5_01->isDirectlyA(Class(A1B1)));
-        testandcout(test5_01->isDirectlyA(Class(BaseObject)));
-        testandcout(test5_01->isDirectlyA(Class(Interface1)));
+        testandcout(test5_01->isExactlyA(Class(A1)));
+        testandcout(test5_01->isExactlyA(Class(A2)));
+        testandcout(test5_01->isExactlyA(Class(A1B1)));
+        testandcout(test5_01->isExactlyA(Class(BaseObject)));
+        testandcout(test5_01->isExactlyA(Class(Interface1)));
 
         std::cout << "\n";
         std::cout << "test5_02 = A2, Erwartet: 0 1 0 0 0\n";
-        testandcout(test5_02->isDirectlyA(Class(A1)));
-        testandcout(test5_02->isDirectlyA(Class(A2)));
-        testandcout(test5_02->isDirectlyA(Class(A1B1)));
-        testandcout(test5_02->isDirectlyA(Class(BaseObject)));
-        testandcout(test5_02->isDirectlyA(Class(Interface1)));
+        testandcout(test5_02->isExactlyA(Class(A1)));
+        testandcout(test5_02->isExactlyA(Class(A2)));
+        testandcout(test5_02->isExactlyA(Class(A1B1)));
+        testandcout(test5_02->isExactlyA(Class(BaseObject)));
+        testandcout(test5_02->isExactlyA(Class(Interface1)));
 
         std::cout << "\n";
         std::cout << "test5_03 = A3, Erwartet: 0 0 0 0 0\n";
-        testandcout(test5_03->isDirectlyA(Class(A1)));
-        testandcout(test5_03->isDirectlyA(Class(A2)));
-        testandcout(test5_03->isDirectlyA(Class(A1B1)));
-        testandcout(test5_03->isDirectlyA(Class(BaseObject)));
-        testandcout(test5_03->isDirectlyA(Class(Interface1)));
+        testandcout(test5_03->isExactlyA(Class(A1)));
+        testandcout(test5_03->isExactlyA(Class(A2)));
+        testandcout(test5_03->isExactlyA(Class(A1B1)));
+        testandcout(test5_03->isExactlyA(Class(BaseObject)));
+        testandcout(test5_03->isExactlyA(Class(Interface1)));
 
         std::cout << "\n";
@@ -431 +432 @@
 
         std::cout << "\n";
+        std::cout << "isDirectChildOf(XYZ)-Test:\n";
+        std::cout << "test5_04 = A1B1, Erwartet: 1 0 0 0 0 0 0\n";
+        testandcout(test5_04->isDirectChildOf(Class(A1)));
+        testandcout(test5_04->isDirectChildOf(Class(A2)));
+        testandcout(test5_04->isDirectChildOf(Class(BaseObject)));
+        testandcout(test5_04->isDirectChildOf(Class(Interface1)));
+        testandcout(test5_04->isDirectChildOf(Class(Interface2)));
+        testandcout(test5_04->isDirectChildOf(Class(A1B1C2)));
+        testandcout(test5_04->isDirectChildOf(Class(A1B1)));
+
+        std::cout << "\n";
+        std::cout << "test5_06 = A2B1, Erwartet: 0 1 0 0 0 0 0\n";
+        testandcout(test5_06->isDirectChildOf(Class(A1)));
+        testandcout(test5_06->isDirectChildOf(Class(A2)));
+        testandcout(test5_06->isDirectChildOf(Class(BaseObject)));
+        testandcout(test5_06->isDirectChildOf(Class(Interface1)));
+        testandcout(test5_06->isDirectChildOf(Class(Interface2)));
+        testandcout(test5_06->isDirectChildOf(Class(A1B1C2)));
+        testandcout(test5_06->isDirectChildOf(Class(A1B1)));
+
+        std::cout << "\n";
+        std::cout << "test5_07 = A2B2, Erwartet: 0 1 0 1 0 0\n";
+        testandcout(test5_07->isDirectChildOf(Class(A1)));
+        testandcout(test5_07->isDirectChildOf(Class(A2)));
+        testandcout(test5_07->isDirectChildOf(Class(BaseObject)));
+        testandcout(test5_07->isDirectChildOf(Class(Interface1)));
+        testandcout(test5_07->isDirectChildOf(Class(Interface2)));
+        testandcout(test5_07->isDirectChildOf(Class(A1B1C2)));
+
+        std::cout << "\n";
+        std::cout << "test5_08 = A3B1, Erwartet: 0 0 0 0 0 0\n";
+        testandcout(test5_08->isDirectChildOf(Class(A1)));
+        testandcout(test5_08->isDirectChildOf(Class(A2)));
+        testandcout(test5_08->isDirectChildOf(Class(BaseObject)));
+        testandcout(test5_08->isDirectChildOf(Class(Interface1)));
+        testandcout(test5_08->isDirectChildOf(Class(Interface2)));
+        testandcout(test5_08->isDirectChildOf(Class(A1B1C2)));
+
+        std::cout << "\n";
+        std::cout << "test5_09 = A3B2, Erwartet: 0 0 0 0 1 0\n";
+        testandcout(test5_09->isDirectChildOf(Class(A1)));
+        testandcout(test5_09->isDirectChildOf(Class(A2)));
+        testandcout(test5_09->isDirectChildOf(Class(BaseObject)));
+        testandcout(test5_09->isDirectChildOf(Class(Interface1)));
+        testandcout(test5_09->isDirectChildOf(Class(Interface2)));
+        testandcout(test5_09->isDirectChildOf(Class(A1B1C2)));
+
+        std::cout << "\n";
+
         std::cout << "isParentOf(XYZ)-Test:\n";
         std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 1 1 1\n";
@@ -460 +510 @@
         testandcout(Class(Interface1)->isParentOf(Class(A2B2)));
         testandcout(Class(Interface1)->isParentOf(Class(A3B1C2)));
+
+        std::cout << "\n";
+        std::cout << "isDirectParentOf(XYZ)-Test:\n";
+        std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 0 0 0\n";
+        testandcout(test1->isDirectParentOf(Class(BaseObject)));
+        testandcout(test1->isDirectParentOf(Class(Interface1)));
+        testandcout(test1->isDirectParentOf(Class(A1)));
+        testandcout(test1->isDirectParentOf(Class(A2)));
+        testandcout(test1->isDirectParentOf(Class(A1B1)));
+        testandcout(test1->isDirectParentOf(Class(A2B2)));
+        testandcout(test1->isDirectParentOf(Class(A3B1C2)));
+
+        std::cout << "\n";
+        std::cout << "test5_01 = A1, Erwartet: 0 0 0 0 1 0 0\n";
+        testandcout(test5_01->isDirectParentOf(Class(BaseObject)));
+        testandcout(test5_01->isDirectParentOf(Class(Interface1)));
+        testandcout(test5_01->isDirectParentOf(Class(A1)));
+        testandcout(test5_01->isDirectParentOf(Class(A2)));
+        testandcout(test5_01->isDirectParentOf(Class(A1B1)));
+        testandcout(test5_01->isDirectParentOf(Class(A2B2)));
+        testandcout(test5_01->isDirectParentOf(Class(A3B1C2)));
+
+        std::cout << "\n";
+        std::cout << "Interface1, Erwartet: 0 0 0 0 0 1 0\n";
+        testandcout(Class(Interface1)->isDirectParentOf(Class(BaseObject)));
+        testandcout(Class(Interface1)->isDirectParentOf(Class(Interface1)));
+        testandcout(Class(Interface1)->isDirectParentOf(Class(A1)));
+        testandcout(Class(Interface1)->isDirectParentOf(Class(A2)));
+        testandcout(Class(Interface1)->isDirectParentOf(Class(A1B1)));
+        testandcout(Class(Interface1)->isDirectParentOf(Class(A2B2)));
+        testandcout(Class(Interface1)->isDirectParentOf(Class(A3B1C2)));
 */
 /*
         std::cout << "Test 6\n";
-        std::cout << "1:\n";
+        std::cout << "1\n";
         Identifier* test6_01 = Class(A1B1);
-        std::cout << "2:\n";
+        std::cout << "2\n";
         Identifier* test6_02 = Class(A1B1);
-        std::cout << "3:\n";
+        std::cout << "3\n";
         Identifier* test6_03 = Class(A1);
-        std::cout << "4:\n";
+        std::cout << "4\n";
         Identifier* test6_04 = Class(A1B1C1);
-        std::cout << "5:\n";
+        std::cout << "5\n";
         Identifier* test6_05 = Class(A1B1);
-        std::cout << "6:\n";
+        std::cout << "6\n";
         Identifier* test6_06 = Class(A1B1C1);
 
-        std::cout << "\n";
-        std::cout << "BaseObject: parents:     " << Class(BaseObject)->getParents().toString() << "\n";
-        std::cout << "BaseObject: children:    " << Class(BaseObject)->getChildren().toString() << "\n";
-
-        std::cout << "\n";
-        std::cout << "A1: parents:     " << Class(A1)->getParents().toString() << "\n";
-        std::cout << "A1: children:    " << Class(A1)->getChildren().toString() << "\n";
-
-        std::cout << "\n";
-        std::cout << "A1B1: parents:     " << Class(A1B1)->getParents().toString() << "\n";
-        std::cout << "A1B1: children:    " << Class(A1B1)->getChildren().toString() << "\n";
-
-        std::cout << "\n";
-        std::cout << "A1B1C1: parents:     " << Class(A1B1C1)->getParents().toString() << "\n";
-        std::cout << "A1B1C1: children:    " << Class(A1B1C1)->getChildren().toString() << "\n";
-
-        std::cout << "\n";
-        std::cout << "A3B1C1 child of A3:  " << Class(A3B1C1)->isChildOf(Class(A3)) << "\n";
-        std::cout << "\n";
-        std::cout << "A2 parent of A2B1C1: " << Class(A2)->isParentOf(Class(A2B1C1)) << "\n";
+        std::cout << "7\n";
+
+        std::cout << "\n";
+        std::cout << "BaseObject: parents:         " << Class(BaseObject)->getParents() << "\n";
+        std::cout << "BaseObject: children:        " << Class(BaseObject)->getChildren() << "\n";
+        std::cout << "BaseObject: direct parents:  " << Class(BaseObject)->getDirectParents() << "\n";
+        std::cout << "BaseObject: direct children: " << Class(BaseObject)->getDirectChildren() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A1: parents:                 " << Class(A1)->getParents() << "\n";
+        std::cout << "A1: children:                " << Class(A1)->getChildren() << "\n";
+        std::cout << "A1: direct parents:          " << Class(A1)->getDirectParents() << "\n";
+        std::cout << "A1: direct children:         " << Class(A1)->getDirectChildren() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A1B1: parents:               " << Class(A1B1)->getParents() << "\n";
+        std::cout << "A1B1: children:              " << Class(A1B1)->getChildren() << "\n";
+        std::cout << "A1B1: direct parents:        " << Class(A1B1)->getDirectParents() << "\n";
+        std::cout << "A1B1: direct children:       " << Class(A1B1)->getDirectChildren() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A1B1C1: parents:             " << Class(A1B1C1)->getParents() << "\n";
+        std::cout << "A1B1C1: children:            " << Class(A1B1C1)->getChildren() << "\n";
+        std::cout << "A1B1C1: direct parents:      " << Class(A1B1C1)->getDirectParents() << "\n";
+        std::cout << "A1B1C1: direct children:     " << Class(A1B1C1)->getDirectChildren() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A3B1C1 child of A3:      " << Class(A3B1C1)->isChildOf(Class(A3)) << "\n";
+        std::cout << "\n";
+        std::cout << "A2 parent of A2B1C1:     " << Class(A2)->isParentOf(Class(A2B1C1)) << "\n";
+
+        std::cout << "8\n";
 */
 /*
@@ -510 +603 @@
 */
 /*
+// ## WARNING - CRASH! ##
         std::cout << "2\n";
 
@@ -520 +614 @@
         SubclassIdentifier<A1B1> test7_05;
         test7_05 = Class(A2);
+// ## END WARNING - CRASH! ##
 */
 /*
@@ -558 +653 @@
         delete test8_02;
         delete test8_03;
-
-
+*/
+/*
         std::cout << "Test 9\n";
         std::cout << "1\n";
@@ -603 +698 @@
         int count;
 
-        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
         std::cout << "Anzahl BaseObjects: " << count << "\n";
-        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
         std::cout << "Anzahl A1: " << count << "\n";
         count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
@@ -616 +711 @@
         std::cout << "2\n";
         BaseObject* test10_08;
-        BaseObject* test10_09;
-        BaseObject* test10_10;
+        BaseObject* test10_09 = 0;
+        BaseObject* test10_10 = 0;
         for (int i = 0; i < 10; i++)
         {
@@ -632 +727 @@
         }
 
-        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
         std::cout << "Anzahl BaseObjects: " << count << "\n";
-        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
         std::cout << "Anzahl A1: " << count << "\n";
         count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
@@ -653 +748 @@
         delete test10_08;
 
-        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
         std::cout << "Anzahl BaseObjects: " << count << "\n";
-        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
         std::cout << "Anzahl A1: " << count << "\n";
         count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
@@ -675 +770 @@
         delete test10_09;
 
-        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::end(); it != 0; --it) { count++; }
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::end(); it; --it) { count++; }
         std::cout << "Anzahl BaseObjects: " << count << "\n";
-        count = 0; for (Iterator<A1> it = ObjectList<A1>::end(); it != 0; --it) { count++; }
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::end(); it; --it) { count++; }
         std::cout << "Anzahl A1: " << count << "\n";
         count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::end(); it; --it) { count++; }
@@ -697 +792 @@
         delete test10_10;
 
-        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
         std::cout << "Anzahl BaseObjects: " << count << "\n";
-        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
         std::cout << "Anzahl A1: " << count << "\n";
         count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
@@ -721 +816 @@
         std::cout << "Test 11\n";
         std::cout << "1\n";
-        count = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count++; }
-        std::cout << "AnzahlTickable: " << count << "\n";
+        int count2 = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count2++; }
+        std::cout << "AnzahlTickable: " << count2 << "\n";
 
         Test1* test11_1;
@@ -728 +823 @@
             test11_1 = new Test1;
 
-        count = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count++; }
-        std::cout << "AnzahlTickable: " << count << "\n";
+        count2 = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count2++; }
+        std::cout << "AnzahlTickable: " << count2 << "\n";
 
         for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
@@ -736 +831 @@
         std::cout << "2\n";
         Test2* test11_2 = new Test2;
-*/
-/*
+
+
         std::cout << "3\n";
         Test3* test11_3 = new Test3;
@@ -834 +929 @@
         std::cout << "Mask 2:\n";
         TestClassTreeMask(test13_2);
-/*
+
+        std::cout << "2\n";
+
         ClassTreeMask test13_3;
-        test13_3.include(Class(A1));
-        test13_3.exclude(Class(A1B2));
-        test13_3.exclude(Class(A1B1C2));
-        test13_3.include(Class(A2));
-        test13_3.exclude(Class(A2B2));
-        test13_3.include(Class(A3B1));
-        test13_3.include(Class(A3B2));
-        test13_3.exclude(Class(A3B2C2));
+        test13_3.include(Class(A1), true, false);
+        test13_3.exclude(Class(A1B2), true, false);
+        test13_3.exclude(Class(A1B1C2), true, false);
+        test13_3.include(Class(A2), true, false);
+        test13_3.exclude(Class(A2B2), true, false);
+        test13_3.include(Class(A3B1), true, false);
+        test13_3.include(Class(A3B2), true, false);
+        test13_3.exclude(Class(A3B2C2), true, false);
         std::cout << std::endl;
         std::cout << "Mask 2 without excluded BaseObject:\n";
         TestClassTreeMask(test13_3);
-        test13_3.exclude(Class(BaseObject));
-        std::cout << std::endl;
-        std::cout << "Mask 2 with BaseObject excluded afterwards:\n";
+        test13_3.exclude(Class(BaseObject), false, false);
+        std::cout << std::endl;
+        std::cout << "Mask 2 with BaseObject excluded afterwards without overwrite:\n";
         TestClassTreeMask(test13_3);
-
-        ClassTreeMask test13_3_2;
-        test13_3_2.include(Class(A1));
-        test13_3_2.exclude(Class(A1B2));
-        test13_3_2.exclude(Class(A1B1C2));
-        test13_3_2.include(Class(A2));
-        test13_3_2.exclude(Class(A2B2));
-        test13_3_2.include(Class(A3B1));
-        test13_3_2.include(Class(A3B2));
-        test13_3_2.exclude(Class(A3B2C2));
-        test13_3_2.clean();
-        test13_3_2.exclude(Class(BaseObject));
-        std::cout << std::endl;
-        std::cout << "Mask 2 with BaseObject excluded afterwards, but cleaned before:\n";
-        TestClassTreeMask(test13_3_2);
-        test13_3_2.include(Class(BaseObject));
-        std::cout << std::endl;
-        std::cout << "Mask 2 from before, but BaseObject re-included without cleaning:\n";
-        TestClassTreeMask(test13_3_2);
+        test13_3.exclude(Class(BaseObject), true);
+        std::cout << std::endl;
+        std::cout << "Mask 2 with BaseObject excluded afterwards with overwrite:\n";
+        TestClassTreeMask(test13_3);
 
         ClassTreeMask test13_4;
@@ -882 +964 @@
         test13_4.include(Class(A1));
         std::cout << std::endl;
-        std::cout << "Mask 2 created in random order:\n";
+        std::cout << "Mask 2 created in random order with overwrite and clean:\n";
         TestClassTreeMask(test13_4);
 
-        std::cout << "2\n";
-
-        ClassTreeMask test13_5 = test13_1;
-        std::cout << std::endl;
-        std::cout << "Mask 1 assigned to a new ClassTestMask:\n";
-        TestClassTreeMask(test13_5);
+        ClassTreeMask test13_4_2;
+        test13_4_2.include(Class(A3B2), false, false);
+        test13_4_2.exclude(Class(A1B1C2), false, false);
+        test13_4_2.include(Class(A3B1), false, false);
+        test13_4_2.exclude(Class(A3B2C2), false, false);
+        test13_4_2.exclude(Class(BaseObject), false, false);
+        test13_4_2.include(Class(A2), false, false);
+        test13_4_2.exclude(Class(A1B2), false, false);
+        test13_4_2.exclude(Class(A2B2), false, false);
+        test13_4_2.include(Class(A1), false, false);
+        std::cout << std::endl;
+        std::cout << "Mask 2 created in random order without overwrite and without clean:\n";
+        TestClassTreeMask(test13_4_2);
 
         std::cout << "3\n";
@@ -929 +1018 @@
         std::cout << "8\n";
 
-        std::cout << std::endl;
-        ClassTreeMask test13_11(test13_1);
-        std::cout << std::endl;
-        std::cout << "Mask 1 assigned with copyconstructor + original mask 1:\n";
-        TestClassTreeMask(test13_11);
-        TestClassTreeMask(test13_1);
-
-        ClassTreeMask test13_12(!test13_11);
+        ClassTreeMask test13_12(!test13_1);
         std::cout << std::endl;
         std::cout << "Mask 1 inverted assigned with copyconstructor + the original from before:\n";
         TestClassTreeMask(test13_12);
-        TestClassTreeMask(test13_11);
-
-        ClassTreeMask test13_13;
-        test13_13 = test13_2;
-        std::cout << std::endl;
-        std::cout << "Mask 2 assigned with = operator + original mask 2:\n";
+        TestClassTreeMask(test13_1);
+
+
+        ClassTreeMask test13_13 = test13_1 + test13_2;
+        std::cout << std::endl;
+        std::cout << "Mask 1 + Mask 2 assigned with copyconstructor + originals from before:\n";
         TestClassTreeMask(test13_13);
+        TestClassTreeMask(test13_1);
         TestClassTreeMask(test13_2);
 
-        ClassTreeMask test13_14 = test13_11 + test13_13;
-        std::cout << std::endl;
-        std::cout << "Mask 1 + Mask 2 assigned with copyconstructor + originals from before:\n";
+        ClassTreeMask test13_14 = test13_1;
+        test13_14 += test13_2;
+        std::cout << std::endl;
+        std::cout << "Mask 1 + Mask 2 with += operator + original of mask 2 from before:\n";
         TestClassTreeMask(test13_14);
-        TestClassTreeMask(test13_11);
-        TestClassTreeMask(test13_13);
-
-        test13_11 += test13_13;
-        std::cout << std::endl;
-        std::cout << "Mask 1 + Mask 2 with += operator + original of mask 2 from before:\n";
-        TestClassTreeMask(test13_11);
-        TestClassTreeMask(test13_13);
+        TestClassTreeMask(test13_2);
 
         test13_1 = test13_1;
@@ -968 +1045 @@
 
         std::cout << "9\n";
-*/
-
+
+        ClassTreeMask test13_15;
+        test13_15.exclude(Class(Interface1));
+        std::cout << std::endl;
+        std::cout << "Mask with excluded Interface 1:\n";
+        TestClassTreeMask(test13_15);
+
+        ClassTreeMask test13_16 = test13_1;
+        test13_16.exclude(Class(Interface1));
+        std::cout << std::endl;
+        std::cout << "Mask 1 with excluded Interface 1 (overwrite):\n";
+        TestClassTreeMask(test13_16);
+
+        ClassTreeMask test13_17 = test13_1;
+        test13_17.exclude(Class(Interface1), false);
+        std::cout << std::endl;
+        std::cout << "Mask 1 with excluded Interface 1 (without overwrite):\n";
+        TestClassTreeMask(test13_17);
+
+        ClassTreeMask test13_18 = test13_2;
+        test13_18.exclude(Class(Interface1), false);
+        std::cout << std::endl;
+        std::cout << "Mask 2 with excluded Interface 1 (without overwrite):\n";
+        TestClassTreeMask(test13_18);
+
+        std::cout << "10\n";
+
+        ClassTreeMask test13_19;
+        test13_19.exclude(Class(Test1));
+        std::cout << std::endl;
+        std::cout << "Mask with excluded Test1:\n";
+        TestClassTreeMask(test13_19);
+
+        std::cout << "11\n";
+
+        ClassTreeMask test13_20;
+        test13_20.exclude(Class(DebugLevel));
+        std::cout << std::endl;
+        std::cout << "Mask with excluded DebugLevel:\n";
+        TestClassTreeMask(test13_20);
+
+        std::cout << "12\n";
+
+/*
         std::cout << "Test 14\n";
         std::cout << "1\n";
@@ -991 +1110 @@
         std::cout << test14_5.getIdentifier()->getName() << std::endl;
 
+        std::cout << "2\n";
+*/
 //    startRenderLoop();
   }

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

@@ -57 +57 @@
     {
         // Go through the list of all subnodes and delete them
+        this->deleteAllSubnodes();
+    }
+
+    /**
+        @brief Sets the rule for the node to "included".
+    */
+    void ClassTreeMaskNode::include(bool overwrite)
+    {
+        this->setIncluded(true, overwrite);
+    }
+
+    /**
+        @brief Sets the rule for the node to "excluded".
+    */
+    void ClassTreeMaskNode::exclude(bool overwrite)
+    {
+        this->setIncluded(false, overwrite);
+    }
+
+    /**
+        @brief Sets the rule for the node to a given value and erases all following rules.
+        @param bIncluded The rule: included (true) or excluded (false)
+    */
+    void ClassTreeMaskNode::setIncluded(bool bIncluded, bool overwrite)
+    {
+        if (overwrite)
+            this->deleteAllSubnodes();
+
+        this->bIncluded_ = bIncluded;
+    }
+
+    /**
+        @brief Adds a new subnode to the list of subnodes.
+        @param subnode The new subnode
+    */
+    void ClassTreeMaskNode::addSubnode(ClassTreeMaskNode* subnode)
+    {
+        this->subnodes_.insert(this->subnodes_.end(), subnode);
+    }
+
+    /**
+        @brief Tells if the rule is "included" or not.
+        @return The rule: true = included, false = excluded
+    */
+    bool ClassTreeMaskNode::isIncluded() const
+    {
+        return this->bIncluded_;
+    }
+
+    /**
+        @brief Tells if the rule is "excluded" or not.
+        @return The inverted rule: true = excluded, false = included
+    */
+    bool ClassTreeMaskNode::isExcluded() const
+    {
+        return (!this->bIncluded_);
+    }
+
+    /**
+        @brief Returns the Identifier of the class the rule refers to.
+        @return The Identifier representing the class
+    */
+    const Identifier* ClassTreeMaskNode::getClass() const
+    {
+        return this->subclass_;
+    }
+
+    /**
+        @brief Deletes all subnodes of this node.
+    */
+    void ClassTreeMaskNode::deleteAllSubnodes()
+    {
+        // Go through the list of all subnodes and delete them
         for (std::list<ClassTreeMaskNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); )
             delete (*(it++));
-    }
-
-    /**
-        @brief Sets the rule for the node to "included".
-    */
-    void ClassTreeMaskNode::include()
-    {
-        this->bIncluded_ = true;
-    }
-
-    /**
-        @brief Sets the rule for the node to "excluded".
-    */
-    void ClassTreeMaskNode::exclude()
-    {
-        this->bIncluded_ = false;
-    }
-
-    /**
-        @brief Sets the rule for the node to a given value.
-        @param bIncluded The rule: included (true) or excluded (false)
-    */
-    void ClassTreeMaskNode::setIncluded(bool bIncluded)
-    {
-        this->bIncluded_ = bIncluded;
-    }
-
-    /**
-        @brief Adds a new subnode to the list of subnodes.
-        @param subnode The new subnode
-    */
-    void ClassTreeMaskNode::addSubnode(ClassTreeMaskNode* subnode)
-    {
-        this->subnodes_.insert(this->subnodes_.end(), subnode);
-    }
-
-    /**
-        @brief Tells if the rule is "included" or not.
-        @return The rule: true = included, false = excluded
-    */
-    bool ClassTreeMaskNode::isIncluded() const
-    {
-        return this->bIncluded_;
-    }
-
-    /**
-        @brief Tells if the rule is "excluded" or not.
-        @return The inverted rule: true = excluded, false = included
-    */
-    bool ClassTreeMaskNode::isExcluded() const
-    {
-        return (!this->bIncluded_);
-    }
-
-    /**
-        @brief Returns the Identifier of the class the rule refers to.
-        @return The Identifier representing the class
-    */
-    const Identifier* ClassTreeMaskNode::getClass() const
-    {
-        return this->subclass_;
+
+        // Clear the list
+        this->subnodes_.clear();
     }
 
@@ -258 +273 @@
         this->root_ = new ClassTreeMaskNode(ClassManager<BaseObject>::getIdentifier(), true);
         for (ClassTreeMaskIterator it = other.root_; it; ++it)
-            this->add(it->getClass(), it->isIncluded());
+            this->add(it->getClass(), it->isIncluded(), false);
     }
 
@@ -273 +288 @@
         @param subclass The subclass
     */
-    void ClassTreeMask::include(const Identifier* subclass)
-    {
-        this->add(subclass, true);
+    void ClassTreeMask::include(const Identifier* subclass, bool overwrite, bool clean)
+    {
+        this->add(subclass, true, overwrite, clean);
     }
 
@@ -282 +297 @@
         @param subclass The subclass
     */
-    void ClassTreeMask::exclude(const Identifier* subclass)
-    {
-        this->add(subclass, false);
+    void ClassTreeMask::exclude(const Identifier* subclass, bool overwrite, bool clean)
+    {
+        this->add(subclass, false, overwrite, clean);
     }
 
@@ -292 +307 @@
         @param bInclude The rule: include (true) or exclude (false)
     */
-    void ClassTreeMask::add(const Identifier* subclass, bool bInclude)
-    {
+    void ClassTreeMask::add(const Identifier* subclass, bool bInclude, bool overwrite, bool clean)
+    {
+        // Check if the given subclass is a child of our root-class
         if (subclass->isA(this->root_->getClass()))
-            this->add(this->root_, subclass, bInclude);
+        {
+            // Yes it is: Just add the rule to the three
+            this->add(this->root_, subclass, bInclude, overwrite);
+        }
         else
         {
-
-        }
-
-        this->clean();
+            // No it's not: Search for classes inheriting from the given class and add the rules for them
+            for (std::list<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+                if ((*it)->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(*it))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, *it, bInclude, overwrite);
+        }
+
+        // Clean the rule-tree
+        if (clean)
+            this->clean();
     }
 
@@ -310 +335 @@
         @param bInclude The rule: include (true) or exclude (false)
     */
-    void ClassTreeMask::add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude)
+    void ClassTreeMask::add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude, bool overwrite)
     {
         // Check if the current node contains exactly the subclass we want to add
@@ -316 +341 @@
         {
             // We're at the right place, just change the mask and return
-            node->setIncluded(bInclude);
+            node->setIncluded(bInclude, overwrite);
             return;
         }
-        else
+        else if (subclass->isA(node->getClass()))
         {
             // Search for an already existing node, containing the subclass we want to add
@@ -327 +352 @@
                 {
                     // We've found an existing node -> delegate the work with a recursive function-call and return
-                    this->add(*it, subclass, bInclude);
+                    this->add(*it, subclass, bInclude, overwrite);
                     return;
                 }
@@ -335 +360 @@
             ClassTreeMaskNode* newnode = new ClassTreeMaskNode(subclass, bInclude);
 
-            // Search for nodes that should actually be subnodes of our new node
+            // Search for nodes that should actually be subnodes of our new node and erase them
             for (std::list<ClassTreeMaskNode*>::iterator it = node->subnodes_.begin(); it != node->subnodes_.end(); )
             {
                 if ((*it)->getClass()->isChildOf(subclass))
                 {
-                    // We've found a subnode: add it to the new node an erase it from the current node
-                    newnode->addSubnode(*it);
+                    // We've found a subnode: add it to the new node and erase it from the current node
+                    if (!overwrite)
+                        newnode->addSubnode(*it);
+                    else
+                        delete (*it);
+
                     node->subnodes_.erase(it++);
                 }
@@ -453 +482 @@
 
     /**
+        @brief Checks if a node for the given subclass exists.
+        @param subclass The Identifier of the subclass
+        @return True = the node exists
+    */
+    bool ClassTreeMask::nodeExists(const Identifier* subclass)
+    {
+        for (ClassTreeMaskIterator it = this->root_; it; ++it)
+            if ((*it)->getClass() == subclass)
+                return true;
+
+        return false;
+    }
+
+    /**
         @brief Assignment operator: Adds all rules of the other mask.
         @param other The other mask
@@ -467 +510 @@
         // Copy all rules from the other mask
         for (ClassTreeMaskIterator it = temp.root_; it; ++it)
-            this->add(it->getClass(), it->isIncluded());
+            this->add(it->getClass(), it->isIncluded(), false, false);
 
         // Return a reference to the mask itself
@@ -505 +548 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass), false, false);
         }
 
@@ -512 +555 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass), false, false);
         }
 
@@ -536 +579 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass), false, false);
         }
 
@@ -543 +586 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass), false, false);
         }
 
@@ -576 +619 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, !this->isIncluded(subclass));
+            newmask.add(subclass, !this->isIncluded(subclass), false, false);
         }
 
@@ -650 +693 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass), false, false);
         }
 
@@ -657 +700 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass), false, false);
         }
 

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

@@ -34 +34 @@
     Identifier of the class.
 
-    You can work with a ClassTreeMask in the sense of the set theory, meaning that you can create
+    You can work with a ClassTreeMask in the sense of the set-theory, meaning that you can create
     unions, intersections, complements and differences by using overloaded operators.
+
+
 
     The ClassTreeMask is internally represented by a tree. The nodes in the tree are
@@ -42 +44 @@
     nodes changing the mask. By adding new rules, the tree gets reordered dynamically.
 
-    You can manually add useless rules and they stay in the tree. That way you can add rules in
-    any order without changing information of the resulting mask. Example: A new mask includes all
-    classes. Now you explicitly include a subclass. This seems to be useless. But if you exclude a
-    baseclass of the formerly included subclass, the subclass stays included. You could create the
-    same mask by first excluding the baseclass and then including the subclass. You can drop
-    useless rules from the tree by calling clean().
+    Adding a new rule overwrites all rules assigned to inherited classes. Use overwrite = false
+    if you don't like this feature. Useless rules that don't change the information of the mask
+    aren't saved in the internal tree. Use clean = false if you wan't to save them.
+
+    With overwrite = false and clean = false it doesn't matter in which way you create the mask.
+    You can manually drop useless rules from the tree by calling clean().
+
+
 
     Because of the complicated shape of the internal tree, there is an iterator to iterate
@@ -91 +95 @@
             ~ClassTreeMaskNode();
 
-            void include();
-            void exclude();
-            void setIncluded(bool bIncluded);
+            void include(bool overwrite = true);
+            void exclude(bool overwrite = true);
+            void setIncluded(bool bIncluded, bool overwrite = true);
 
             void addSubnode(ClassTreeMaskNode* subnode);
@@ -103 +107 @@
 
         private:
+            void deleteAllSubnodes();
+
             const Identifier* subclass_;                //!< The Identifier of the subclass the rule refers to
             bool bIncluded_;                            //!< The rule: included or excluded
@@ -146 +152 @@
         With a ClassTreeMask, you can include or exclude subtrees of the class-tree, starting
         with a given subclass, described by the corresponding Identifier. To minimize the size
-        of the mask, the mask saves only relevant rules. But you are allowed to manually add
-        rules that don't change the information of the mask. This way you can create the same
-        mask by adding the same rules in a different way without changing the information. If
-        you want to drop useless rules, call the clean() function.
+        of the mask, the mask saves only relevant rules. But you can manually add rules that
+        don't change the information of the mask by using clean = false. If you want to drop
+        useless rules, call the clean() function.
     */
     class _CoreExport ClassTreeMask
@@ -158 +163 @@
             ~ClassTreeMask();
 
-            void include(const Identifier* subclass);
-            void exclude(const Identifier* subclass);
-            void add(const Identifier* subclass, bool bInclude);
+            void include(const Identifier* subclass, bool overwrite = true, bool clean = true);
+            void exclude(const Identifier* subclass, bool overwrite = true, bool clean = true);
+            void add(const Identifier* subclass, bool bInclude, bool overwrite = true, bool clean = true);
             void reset();
             void clean();
@@ -193 +198 @@
 
         private:
-            void add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude);
+            void add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude, bool overwrite = true);
             bool isIncluded(ClassTreeMaskNode* node, const Identifier* subclass) const;
             void clean(ClassTreeMaskNode* node);
+            bool nodeExists(const Identifier* subclass);
 
             ClassTreeMaskNode* root_;   //!< The root-node of the internal rule-tree, usually BaseObject

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

@@ -109 +109 @@
       return &theOneAndOnlyFactoryInstance;
     }
+
+    /**
+        @brief Returns the begin-iterator of the factory-map.
+        @return The begin-iterator
+    */
+    std::map<std::string, Identifier*>::const_iterator Factory::getFactoryBegin()
+    {
+        return Factory::getFactoryPointer()->identifierStringMap_.begin();
+    }
+
+    /**
+        @brief Returns the end-iterator of the factory-map.
+        @return The end-iterator
+    */
+    std::map<std::string, Identifier*>::const_iterator Factory::getFactoryEnd()
+    {
+        return Factory::getFactoryPointer()->identifierStringMap_.end();
+    }
 }

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

@@ -67 +67 @@
 
             static Factory* getFactoryPointer();    // avoid overriding order problem in the static intialisation process
+            static std::map<std::string, Identifier*>::const_iterator getFactoryBegin();
+            static std::map<std::string, Identifier*>::const_iterator getFactoryEnd();
 
         private:

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

@@ -30 +30 @@
     @brief Implementation of the Identifier class.
 */
+
+#include <ostream>
 
 #include "Identifier.h"
@@ -50 +52 @@
 
         this->children_ = new std::list<const Identifier*>();
+        this->directChildren_ = new std::list<const Identifier*>();
 
         // Use a static variable because the classID gets created before main() and that's why we should avoid static member variables
@@ -62 +65 @@
     {
         delete this->children_;
+        delete this->directChildren_;
     }
 
@@ -75 +79 @@
         if (parents)
         {
-            std::list<const Identifier*>::iterator temp1 = parents->begin();
-            while (temp1 != parents->end())
+            this->parents_ = (*parents);
+            this->directParents_ = (*parents);
+
+            // Iterate through all parents
+            for (std::list<const Identifier*>::iterator it = parents->begin(); it != parents->end(); ++it)
             {
-                this->parents_.insert(this->parents_.end(), *temp1);
-                (*temp1)->getChildren().insert((*temp1)->getChildren().end(), this); // We're a child of our parents
-
-                ++temp1;
+                // Tell the parent we're one of it's children
+                (*it)->getChildrenIntern().insert((*it)->getChildrenIntern().end(), this);
+
+                // Erase all parents of our parent from our direct-parent-list
+                for (std::list<const Identifier*>::const_iterator it1 = (*it)->getParents().begin(); it1 != (*it)->getParents().end(); ++it1)
+                {
+                    // Search for the parent's parent in our direct-parent-list
+                    for (std::list<const Identifier*>::iterator it2 = this->directParents_.begin(); it2 != this->directParents_.end(); ++it2)
+                    {
+                        if ((*it1) == (*it2))
+                        {
+                            // We've found a non-direct parent in our list: Erase it
+                            this->directParents_.erase(it2);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Now iterate through all direct parents
+            for (std::list<const Identifier*>::iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+            {
+                // Tell the parent we're one of it's direct children
+                (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
             }
         }
@@ -98 +125 @@
         else
         {
-            // Abstract classes don't have a factory and therefore can't create new objects
             COUT(1) << "An error occurred in Identifier:" << std::endl;
-            COUT(1) << "Error: Cannot create an object of type '" << this->name_ << "'. Class is abstract." << std::endl;
+            COUT(1) << "Error: Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << std::endl;
             COUT(1) << "Aborting..." << std::endl;
             abort();
@@ -130 +156 @@
         @param identifier The identifier to compare with
     */
-    bool Identifier::isDirectlyA(const Identifier* identifier) const
+    bool Identifier::isExactlyA(const Identifier* identifier) const
     {
         return (identifier == this);
@@ -145 +171 @@
 
     /**
+        @brief Returns true, if the assigned identifier is a direct child of the given identifier.
+        @param identifier The identifier to compare with
+    */
+    bool Identifier::isDirectChildOf(const Identifier* identifier) const
+    {
+        return this->identifierIsInList(identifier, this->directParents_);
+    }
+
+    /**
         @brief Returns true, if the assigned identifier is a parent of the given identifier.
         @param identifier The identifier to compare with
@@ -151 +186 @@
     {
         return this->identifierIsInList(identifier, *this->children_);
+    }
+
+    /**
+        @brief Returns true, if the assigned identifier is a direct parent of the given identifier.
+        @param identifier The identifier to compare with
+    */
+    bool Identifier::isDirectParentOf(const Identifier* identifier) const
+    {
+        return this->identifierIsInList(identifier, *this->directChildren_);
     }
 
@@ -167 +211 @@
         return false;
     }
+
+    std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list)
+    {
+        for (std::list<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+            out << (*it)->getName() << " ";
+
+        return out;
+    }
 }

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

@@ -39 +39 @@
 
     Every object has a pointer to the Identifier of its class. This allows the use isA(...),
-    isDirectlyA(...), isChildOf(...) and isParentOf(...).
+    isExactlyA(...), isChildOf(...) and isParentOf(...).
 
     To create the class-hierarchy, the Identifier has some intern functions and variables.
@@ -82 +82 @@
 
         Every object has a pointer to the Identifier of its class. This allows the use isA(...),
-        isDirectlyA(...), isChildOf(...) and isParentOf(...).
+        isExactlyA(...), isChildOf(...) and isParentOf(...).
 
         You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
@@ -102 +102 @@
             BaseObject* fabricate();
             bool isA(const Identifier* identifier) const;
-            bool isDirectlyA(const Identifier* identifier) const;
+            bool isExactlyA(const Identifier* identifier) const;
             bool isChildOf(const Identifier* identifier) const;
+            bool isDirectChildOf(const Identifier* identifier) const;
             bool isParentOf(const Identifier* identifier) const;
+            bool isDirectParentOf(const Identifier* identifier) const;
 
             /** @brief Removes all objects of the corresponding class. */
@@ -114 +116 @@
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
             inline const std::list<const Identifier*>& getParents() const { return this->parents_; }
-
             /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
-
             /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
 
+            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
+            inline const std::list<const Identifier*>& getChildren() const { return (*this->children_); }
             /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
-
             /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
+
+            /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
+            inline const std::list<const Identifier*>& getDirectParents() const { return this->directParents_; }
+            /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
+            /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
+
+            /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
+            inline const std::list<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
+            /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
+            /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
 
             /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
@@ -143 +158 @@
             inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
                 { this->configValues_[varname] = container; }
+
+            static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
 
         private:
@@ -150 +167 @@
             void initialize(std::list<const Identifier*>* parents);
 
-            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
-            inline std::list<const Identifier*>& getParents() { return this->parents_; }
-
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
-            inline std::list<const Identifier*>& getChildren() const { return (*this->children_); }
+            inline std::list<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
+            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
+            inline std::list<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
 
             /**
@@ -174 +190 @@
             }
 
-            static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
-
-            std::list<const Identifier*> parents_;                      //!< The Parents of the class the Identifier belongs to
-            std::list<const Identifier*>* children_;                    //!< The Children of the class the Identifier belongs to
+            std::list<const Identifier*> parents_;                      //!< The parents of the class the Identifier belongs to
+            std::list<const Identifier*>* children_;                    //!< The children of the class the Identifier belongs to
+
+            std::list<const Identifier*> directParents_;                //!< The direct parents of the class the Identifier belongs to
+            std::list<const Identifier*>* directChildren_;              //!< The direct children of the class the Identifier belongs to
 
             std::string name_;                                          //!< The name of the class the Identifier belongs to
@@ -188 +205 @@
     };
 
+    std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list);
+
 
     // ###############################
@@ -215 +234 @@
             void removeObjects() const;
             void setName(const std::string& name);
+            inline const ObjectList<T>* getObjects() const { return this->objects_; }
 
         private:
@@ -231 +251 @@
     ClassIdentifier<T>::ClassIdentifier()
     {
-        this->objects_ = ObjectList<T>::getList();
+//        this->objects_ = ObjectList<T>::getList();
+        this->objects_ = new ObjectList<T>();
         this->bSetName_ = false;
     }
@@ -294 +315 @@
     void ClassIdentifier<T>::removeObjects() const
     {
-        for (Iterator<T> it = ObjectList<T>::start(); it;)
+        for (Iterator<T> it = this->objects_->start(); it;)
             delete *(it++);
     }
+
 
     // ###############################
@@ -409 +431 @@
 
             /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
-            inline bool isDirectlyA(const Identifier* identifier) const
-                { return this->identifier_->isDirectlyA(identifier); }
+            inline bool isExactlyA(const Identifier* identifier) const
+                { return this->identifier_->isExactlyA(identifier); }
 
             /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
@@ -416 +438 @@
                 { return this->identifier_->isChildOf(identifier); }
 
+            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
+            inline bool isDirectChildOf(const Identifier* identifier) const
+                { return this->identifier_->isDirectChildOf(identifier); }
+
             /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
             inline bool isParentOf(const Identifier* identifier) const
                 { return this->identifier_->isParentOf(identifier); }
+
+            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
+            inline bool isDirectParentOf(const Identifier* identifier) const
+                { return this->identifier_->isDirectParentOf(identifier); }
 
         private:

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

@@ -40 +40 @@
 #include "CorePrereqs.h"
 #include "Iterator.h"
+#include "ClassManager.h"
 
 namespace orxonox
@@ -83 +84 @@
     {
         public:
-            static ObjectList<T>* getList();
+            ObjectList();
+            ~ObjectList();
 
             ObjectListElement<T>* add(T* object);
@@ -90 +92 @@
             /** @brief Returns the first element in the list. @return The first element */
             inline static Iterator<T> start()
-                { return Iterator<T>(getList()->first_); }
+                { return Iterator<T>(ClassManager<T>::getIdentifier()->getObjects()->first_); }
 
             /** @brief Returns the first element in the list. @return The first element */
             inline static Iterator<T> begin()
-                { return Iterator<T>(getList()->first_); }
+                { return Iterator<T>(ClassManager<T>::getIdentifier()->getObjects()->first_); }
 
             /** @brief Returns the last element in the list. @return The last element */
             inline static Iterator<T> end()
-                { return Iterator<T>(getList()->last_); }
+                { return Iterator<T>(ClassManager<T>::getIdentifier()->getObjects()->last_); }
 
             ObjectListElement<T>* first_;       //!< The first element in the list
             ObjectListElement<T>* last_;        //!< The last element in the list
-
-        private:
-            ObjectList();
-            ~ObjectList();
     };
 
@@ -131 +129 @@
             this->first_ = temp;
         }
-    }
-
-    /**
-        @brief Returns a pointer to the only existing instance for the given class T. @return The instance
-    */
-    template <class T>
-    ObjectList<T>* ObjectList<T>::getList()
-    {
-        static ObjectList<T> theOnlyObjectListObjectForClassT = ObjectList<T>();
-        return &theOnlyObjectListObjectForClassT;
     }
 

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

@@ -72 +72 @@
             inline void createParents() { this->parents_ = new std::list<const Identifier*>(); }
 
-//            /** @brief Sets the Parents of the object. Used by the RegisterObject-macro. */
-//            inline void setParents(std::list<const Identifier*>* parents) { this->parents_ = parents; }
-
             /** @brief Returns the MetaObjectList of the object, containing a link to all ObjectLists and ObjectListElements the object is registered in. @return The list */
             inline MetaObjectList& getMetaList() { return this->metaList_; }
@@ -83 +80 @@
                 { return this->getIdentifier()->isA(identifier); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const Identifier* identifier)
-                { return this->getIdentifier()->isDirectlyA(identifier); }
+            inline bool isExactlyA(const Identifier* identifier)
+                { return this->getIdentifier()->isExactlyA(identifier); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const Identifier* identifier)
                 { return this->getIdentifier()->isChildOf(identifier); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const Identifier* identifier)
+                { return this->getIdentifier()->isDirectChildOf(identifier); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const Identifier* identifier)
                 { return this->getIdentifier()->isParentOf(identifier); }
+            /** @brief Returns true if the objects class is a direct parent of the given type. */
+            inline bool isDirectParentOf(const Identifier* identifier)
+                { return this->getIdentifier()->isDirectParentOf(identifier); }
 
 
@@ -97 +100 @@
                 { return this->getIdentifier()->isA(identifier->getIdentifier()); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const SubclassIdentifier<class B>* identifier)
-                { return this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
+            inline bool isExactlyA(const SubclassIdentifier<class B>* identifier)
+                { return this->getIdentifier()->isExactlyA(identifier->getIdentifier()); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const SubclassIdentifier<class B>* identifier)
+                { return this->getIdentifier()->isDirectChildOf(identifier->getIdentifier()); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct parent of the given type. */
+            inline bool isDirectParentOf(const SubclassIdentifier<class B>* identifier)
+                { return this->getIdentifier()->isDirectParentOf(identifier->getIdentifier()); }
 
 
@@ -111 +120 @@
                 { return this->getIdentifier()->isA(identifier.getIdentifier()); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const SubclassIdentifier<class B> identifier)
-                { return this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
+            inline bool isExactlyA(const SubclassIdentifier<class B> identifier)
+                { return this->getIdentifier()->isExactlyA(identifier.getIdentifier()); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const SubclassIdentifier<class B> identifier)
+                { return this->getIdentifier()->isDirectChildOf(identifier.getIdentifier()); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct parent of the given type. */
+            inline bool isDirectParentOf(const SubclassIdentifier<class B> identifier)
+                { return this->getIdentifier()->isDirectParentOf(identifier.getIdentifier()); }
 
 
@@ -125 +140 @@
                 { return this->getIdentifier()->isA(object->getIdentifier()); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const OrxonoxClass* object)
-                { return this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
+            inline bool isExactlyA(const OrxonoxClass* object)
+                { return this->getIdentifier()->isExactlyA(object->getIdentifier()); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const OrxonoxClass* object)
                 { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const OrxonoxClass* object)
+                { return this->getIdentifier()->isDirectChildOf(object->getIdentifier()); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const OrxonoxClass* object)
                 { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectParentOf(const OrxonoxClass* object)
+                { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
 
 

code/branches/core/src/orxonox/objects/Test.h

@@ -74 +74 @@
         public:
             A1B2() { RegisterObject(A1B2); }
-            virtual void test() = 0;
+//            virtual void test() = 0;
     };
 
@@ -117 +117 @@
         public:
             A1B2C1() { RegisterObject(A1B2C1); }
-            void test() { std::cout << "test!\n"; }
+//            void test() { std::cout << "test!\n"; }
     };
 
@@ -160 +160 @@
     CreateFactory(A3);
     CreateFactory(A1B1);
-//    CreateFactory(A1B2);
+    CreateFactory(A1B2);
     CreateFactory(A2B1);
     CreateFactory(A2B2);