Index: code/branches/objecthierarchie/src/orxonox/objects/BaseObject.cc
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/BaseObject.cc	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/BaseObject.cc	(revision 255)
@@ -0,0 +1,15 @@
+#include "BaseObject.h"
+
+namespace orxonox
+{
+    CreateFactory(BaseObject);
+
+    BaseObject::BaseObject()
+    {
+        RegisterRootObject(BaseObject);
+    }
+
+    BaseObject::~BaseObject()
+    {
+    }
+}
Index: code/branches/objecthierarchie/src/orxonox/objects/BaseObject.h
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/BaseObject.h	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/BaseObject.h	(revision 255)
@@ -0,0 +1,55 @@
+#ifndef _BaseObject_H__
+#define _BaseObject_H__
+
+#include "IdentifierIncludes.h"
+
+namespace orxonox
+{
+    class BaseObject : virtual public OrxonoxClass
+    {
+        public:
+            BaseObject();
+            virtual ~BaseObject();
+
+            inline bool isA(const Identifier* identifier)
+                { this->getIdentifier()->isA(identifier); }
+            inline bool isDirectlyA(const Identifier* identifier)
+                { this->getIdentifier()->isDirectlyA(identifier); }
+            inline bool isChildOf(const Identifier* identifier)
+                { this->getIdentifier()->isChildOf(identifier); }
+            inline bool isParentOf(const Identifier* identifier)
+                { this->getIdentifier()->isParentOf(identifier); }
+
+            inline bool isA(const SubclassIdentifier<class B>* identifier)
+                { this->getIdentifier()->isA(identifier->getIdentifier()); }
+            inline bool isDirectlyA(const SubclassIdentifier<class B>* identifier)
+                { this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
+            inline bool isChildOf(const SubclassIdentifier<class B>* identifier)
+                { this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
+            inline bool isParentOf(const SubclassIdentifier<class B>* identifier)
+                { this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
+
+            inline bool isA(const SubclassIdentifier<class B> identifier)
+                { this->getIdentifier()->isA(identifier.getIdentifier()); }
+            inline bool isDirectlyA(const SubclassIdentifier<class B> identifier)
+                { this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
+            inline bool isChildOf(const SubclassIdentifier<class B> identifier)
+                { this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
+            inline bool isParentOf(const SubclassIdentifier<class B> identifier)
+                { this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
+
+            inline bool isA(const OrxonoxClass* object)
+                { this->getIdentifier()->isA(object->getIdentifier()); }
+            inline bool isDirectlyA(const OrxonoxClass* object)
+                { this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
+            inline bool isChildOf(const OrxonoxClass* object)
+                { this->getIdentifier()->isChildOf(object->getIdentifier()); }
+            inline bool isParentOf(const OrxonoxClass* object)
+                { this->getIdentifier()->isParentOf(object->getIdentifier()); }
+
+            std::string name_; // test
+
+    };
+}
+
+#endif
Index: code/branches/objecthierarchie/src/orxonox/objects/Test.h
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/Test.h	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/Test.h	(revision 255)
@@ -0,0 +1,149 @@
+#ifndef _Test_H__
+#define _Test_H__
+
+#include "BaseObject.h"
+#include "IdentifierIncludes.h"
+
+namespace orxonox
+{
+    class Interface1 : virtual public OrxonoxClass
+    {
+        protected:
+            Interface1() { RegisterRootObject(Interface1); }
+    };
+
+    class Interface2 : virtual public OrxonoxClass
+    {
+        protected:
+            Interface2() { RegisterRootObject(Interface2); }
+    };
+
+    class A1 : public BaseObject
+    {
+        public:
+            A1() { RegisterObject(A1); }
+    };
+
+    class A2 : public BaseObject
+    {
+        public:
+            A2() { RegisterObject(A2); }
+    };
+
+    class A3: public BaseObject, public Interface1
+    {
+        public:
+            A3() { RegisterObject(A3); }
+    };
+
+    class A1B1 : public A1
+    {
+        public:
+            A1B1() { RegisterObject(A1B1); }
+    };
+
+    class A1B2 : public A1
+    {
+        public:
+            A1B2() { RegisterObject(A1B2); }
+    };
+
+    class A2B1 : public A2
+    {
+        public:
+            A2B1() { RegisterObject(A2B1); }
+    };
+
+    class A2B2 : public A2, Interface1
+    {
+        public:
+            A2B2() { RegisterObject(A2B2); }
+    };
+
+    class A3B1 : public A3
+    {
+        public:
+            A3B1() { RegisterObject(A3B1); }
+    };
+
+    class A3B2 : public A3, Interface2
+    {
+        public:
+            A3B2() { RegisterObject(A3B2); }
+    };
+
+    class A1B1C1 : public A1B1
+    {
+        public:
+            A1B1C1() { RegisterObject(A1B1C1); }
+    };
+
+    class A1B1C2 : public A1B1
+    {
+        public:
+            A1B1C2() { RegisterObject(A1B1C2); }
+    };
+
+    class A1B2C1 : public A1B2
+    {
+        public:
+            A1B2C1() { RegisterObject(A1B2C1); }
+    };
+
+    class A2B1C1 : public A2B1, Interface2
+    {
+        public:
+            A2B1C1() { RegisterObject(A2B1C1); }
+    };
+
+    class A2B2C1 : public A2B2
+    {
+        public:
+            A2B2C1() { RegisterObject(A2B2C1); }
+    };
+
+    class A3B1C1 : public A3B1
+    {
+        public:
+            A3B1C1() { RegisterObject(A3B1C1); }
+    };
+
+    class A3B1C2 : public A3B1, Interface2
+    {
+        public:
+            A3B1C2() { RegisterObject(A3B1C2); }
+    };
+
+    class A3B2C1 : public A3B2
+    {
+        public:
+            A3B2C1() { RegisterObject(A3B2C1); }
+    };
+
+    class A3B2C2 : public A3B2
+    {
+        public:
+            A3B2C2() { RegisterObject(A3B2C2); }
+    };
+
+    CreateFactory(A1);
+    CreateFactory(A2);
+    CreateFactory(A3);
+    CreateFactory(A1B1);
+    CreateFactory(A1B2);
+    CreateFactory(A2B1);
+    CreateFactory(A2B2);
+    CreateFactory(A3B1);
+    CreateFactory(A3B2);
+    CreateFactory(A1B1C1);
+    CreateFactory(A1B1C2);
+    CreateFactory(A1B2C1);
+    CreateFactory(A2B1C1);
+    CreateFactory(A2B2C1);
+    CreateFactory(A3B1C1);
+    CreateFactory(A3B1C2);
+    CreateFactory(A3B2C1);
+    CreateFactory(A3B2C2);
+}
+
+#endif
Index: code/branches/objecthierarchie/src/orxonox/objects/test1.cc
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/test1.cc	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/test1.cc	(revision 255)
@@ -0,0 +1,63 @@
+#include "test1.h"
+#include "test2.h"
+#include "test3.h"
+
+namespace orxonox
+{
+    CreateFactory(Test1);
+
+    Test1::Test1()
+    {
+        RegisterObject(Test1);
+
+        this->usefullClass1_ = Class(Test1);
+        this->usefullClass2_ = Class(Test2);
+        this->usefullClass3_ = Class(Test3);
+    }
+
+    Test1::~Test1()
+    {
+    }
+
+    bool Test1::usefullClass1isA(Identifier* identifier)
+    {
+        return this->usefullClass1_->isA(identifier);
+    }
+
+    bool Test1::usefullClass2isA(Identifier* identifier)
+    {
+        return this->usefullClass2_->isA(identifier);
+    }
+
+    bool Test1::usefullClass3isA(Identifier* identifier)
+    {
+        return this->usefullClass3_.isA(identifier);
+    }
+
+    void Test1::setUsefullClass1(Identifier* identifier)
+    {
+        std::cout << "\n";
+        std::cout << "Test1: usefullClass1->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
+        std::cout << "Test1: usefullClass1->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
+        std::cout << "Test1: usefullClass1->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        this->usefullClass1_ = identifier;
+    }
+
+    void Test1::setUsefullClass2(Identifier* identifier)
+    {
+        std::cout << "\n";
+        std::cout << "Test1: usefullClass2->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
+        std::cout << "Test1: usefullClass2->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
+        std::cout << "Test1: usefullClass2->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        this->usefullClass2_ = identifier;
+    }
+
+    void Test1::setUsefullClassOfTypeTest3(Identifier* identifier)
+    {
+        std::cout << "\n";
+        std::cout << "Test1: usefullClass3->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
+        std::cout << "Test1: usefullClass3->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
+        std::cout << "Test1: usefullClass3->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        this->usefullClass3_ = identifier;
+    }
+}
Index: code/branches/objecthierarchie/src/orxonox/objects/test1.h
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/test1.h	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/test1.h	(revision 255)
@@ -0,0 +1,30 @@
+#ifndef _Test1_H__
+#define _Test1_H__
+
+#include "BaseObject.h"
+#include "test3.h"
+
+namespace orxonox
+{
+    class Test1 : public BaseObject
+    {
+        public:
+            Test1();
+            virtual ~Test1();
+
+            bool usefullClass1isA(Identifier* identifier);
+            bool usefullClass2isA(Identifier* identifier);
+            bool usefullClass3isA(Identifier* identifier);
+            void setUsefullClass1(Identifier* identifier);
+            void setUsefullClass2(Identifier* identifier);
+            void setUsefullClassOfTypeTest3(Identifier* identifier);
+
+        private:
+            Identifier* usefullClass1_;
+            Identifier* usefullClass2_;
+            SubclassIdentifier<Test3> usefullClass3_;
+
+    };
+}
+
+#endif
Index: code/branches/objecthierarchie/src/orxonox/objects/test2.cc
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/test2.cc	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/test2.cc	(revision 255)
@@ -0,0 +1,63 @@
+#include "test1.h"
+#include "test2.h"
+#include "test3.h"
+
+namespace orxonox
+{
+    CreateFactory(Test2);
+
+    Test2::Test2()
+    {
+        RegisterObject(Test2);
+
+        this->usefullClass1_ = Class(Test1);
+        this->usefullClass2_ = Class(Test2);
+        this->usefullClass3_ = Class(Test3);
+    }
+
+    Test2::~Test2()
+    {
+    }
+
+    bool Test2::usefullClass1isA(Identifier* identifier)
+    {
+        return this->usefullClass1_->isA(identifier);
+    }
+
+    bool Test2::usefullClass2isA(Identifier* identifier)
+    {
+        return this->usefullClass2_->isA(identifier);
+    }
+
+    bool Test2::usefullClass3isA(Identifier* identifier)
+    {
+        return this->usefullClass3_.isA(identifier);
+    }
+
+    void Test2::setUsefullClass1(Identifier* identifier)
+    {
+        std::cout << "\n";
+        std::cout << "Test2: usefullClass1->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
+        std::cout << "Test2: usefullClass1->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
+        std::cout << "Test2: usefullClass1->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        this->usefullClass1_ = identifier;
+    }
+
+    void Test2::setUsefullClass2(Identifier* identifier)
+    {
+        std::cout << "\n";
+        std::cout << "Test2: usefullClass2->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
+        std::cout << "Test2: usefullClass2->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
+        std::cout << "Test2: usefullClass2->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        this->usefullClass2_ = identifier;
+    }
+
+    void Test2::setUsefullClassOfTypeTest3(Identifier* identifier)
+    {
+        std::cout << "\n";
+        std::cout << "Test2: usefullClass3->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
+        std::cout << "Test2: usefullClass3->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
+        std::cout << "Test2: usefullClass3->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        this->usefullClass3_ = identifier;
+    }
+}
Index: code/branches/objecthierarchie/src/orxonox/objects/test2.h
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/test2.h	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/test2.h	(revision 255)
@@ -0,0 +1,31 @@
+#ifndef _Test2_H__
+#define _Test2_H__
+
+#include "BaseObject.h"
+
+namespace orxonox
+{
+    class Test3;
+
+    class Test2 : public BaseObject
+    {
+        public:
+            Test2();
+            virtual ~Test2();
+
+            bool usefullClass1isA(Identifier* identifier);
+            bool usefullClass2isA(Identifier* identifier);
+            bool usefullClass3isA(Identifier* identifier);
+            void setUsefullClass1(Identifier* identifier);
+            void setUsefullClass2(Identifier* identifier);
+            void setUsefullClassOfTypeTest3(Identifier* identifier);
+
+        private:
+            Identifier* usefullClass1_;
+            Identifier* usefullClass2_;
+            SubclassIdentifier<Test3> usefullClass3_;
+
+    };
+}
+
+#endif
Index: code/branches/objecthierarchie/src/orxonox/objects/test3.cc
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/test3.cc	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/test3.cc	(revision 255)
@@ -0,0 +1,53 @@
+#include "test1.h"
+#include "test2.h"
+#include "test3.h"
+
+namespace orxonox
+{
+    CreateFactory(Test3);
+
+    Test3::Test3()
+    {
+        RegisterObject(Test3);
+    }
+
+    Test3::~Test3()
+    {
+    }
+        #define testandcout(code) \
+          std::cout << #code << " " << code << "\n"
+
+    bool Test3::usefullClassesIsATest(Test1* test1)
+    {
+        std::cout << "\n";
+        std::cout << "Test1:\n";
+        testandcout(test1->usefullClass1isA(Class(Test1)));
+        testandcout(test1->usefullClass1isA(Class(Test2)));
+        testandcout(test1->usefullClass1isA(Class(Test3)));
+        std::cout << "\n";
+        testandcout(test1->usefullClass2isA(Class(Test1)));
+        testandcout(test1->usefullClass2isA(Class(Test2)));
+        testandcout(test1->usefullClass2isA(Class(Test3)));
+        std::cout << "\n";
+        testandcout(test1->usefullClass3isA(Class(Test1)));
+        testandcout(test1->usefullClass3isA(Class(Test2)));
+        testandcout(test1->usefullClass3isA(Class(Test3)));
+    }
+
+    bool Test3::usefullClassesIsATest(Test2* test2)
+    {
+        std::cout << "\n";
+        std::cout << "Test2:\n";
+        testandcout(test2->usefullClass1isA(Class(Test1)));
+        testandcout(test2->usefullClass1isA(Class(Test2)));
+        testandcout(test2->usefullClass1isA(Class(Test3)));
+        std::cout << "\n";
+        testandcout(test2->usefullClass2isA(Class(Test1)));
+        testandcout(test2->usefullClass2isA(Class(Test2)));
+        testandcout(test2->usefullClass2isA(Class(Test3)));
+        std::cout << "\n";
+        testandcout(test2->usefullClass3isA(Class(Test1)));
+        testandcout(test2->usefullClass3isA(Class(Test2)));
+        testandcout(test2->usefullClass3isA(Class(Test3)));
+    }
+}
Index: code/branches/objecthierarchie/src/orxonox/objects/test3.h
===================================================================
--- code/branches/objecthierarchie/src/orxonox/objects/test3.h	(revision 255)
+++ code/branches/objecthierarchie/src/orxonox/objects/test3.h	(revision 255)
@@ -0,0 +1,22 @@
+#ifndef _Test3_H__
+#define _Test3_H__
+
+#include "BaseObject.h"
+
+namespace orxonox
+{
+    class Test1;
+    class Test2;
+
+    class Test3 : public BaseObject
+    {
+        public:
+            Test3();
+            virtual ~Test3();
+
+            bool usefullClassesIsATest(Test1* test1);
+            bool usefullClassesIsATest(Test2* test2);
+    };
+}
+
+#endif
