Index: code/branches/console/src/core/OrxonoxClass.h
===================================================================
--- code/branches/console/src/core/OrxonoxClass.h	(revision 1117)
+++ code/branches/console/src/core/OrxonoxClass.h	(revision 1313)
@@ -43,7 +43,4 @@
 #include <string>
 
-#include "MetaObjectList.h"
-#include "Iterator.h"
-
 namespace orxonox
 {
@@ -75,90 +72,39 @@
 
             /** @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_; }
+            inline MetaObjectList& getMetaList() { return (*this->metaList_); }
 
 
-            /** @brief Returns true if the objects class is of the given type or a derivative. */
-            inline bool isA(const Identifier* identifier)
-                { return this->getIdentifier()->isA(identifier); }
-            /** @brief Returns true if the objects class is exactly of the given type. */
-            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); }
+            bool isA(const Identifier* identifier);
+            bool isExactlyA(const Identifier* identifier);
+            bool isChildOf(const Identifier* identifier);
+            bool isDirectChildOf(const Identifier* identifier);
+            bool isParentOf(const Identifier* identifier);
+            bool isDirectParentOf(const Identifier* identifier);
 
+            bool isA(const SubclassIdentifier<class B>* identifier);
+            bool isExactlyA(const SubclassIdentifier<class B>* identifier);
+            bool isChildOf(const SubclassIdentifier<class B>* identifier);
+            bool isDirectChildOf(const SubclassIdentifier<class B>* identifier);
+            bool isParentOf(const SubclassIdentifier<class B>* identifier);
+            bool isDirectParentOf(const SubclassIdentifier<class B>* identifier);
 
-            /** @brief Returns true if the objects class is of the given type or a derivative. */
-            inline bool isA(const SubclassIdentifier<class B>* identifier)
-                { return this->getIdentifier()->isA(identifier->getIdentifier()); }
-            /** @brief Returns true if the objects class is exactly of the given type. */
-            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()); }
+            bool isA(const SubclassIdentifier<class B> identifier);
+            bool isExactlyA(const SubclassIdentifier<class B> identifier);
+            bool isChildOf(const SubclassIdentifier<class B> identifier);
+            bool isDirectChildOf(const SubclassIdentifier<class B> identifier);
+            bool isParentOf(const SubclassIdentifier<class B> identifier);
+            bool isDirectParentOf(const SubclassIdentifier<class B> identifier);
 
-
-            /** @brief Returns true if the objects class is of the given type or a derivative. */
-            inline bool isA(const SubclassIdentifier<class B> identifier)
-                { return this->getIdentifier()->isA(identifier.getIdentifier()); }
-            /** @brief Returns true if the objects class is exactly of the given type. */
-            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()); }
-
-
-            /** @brief Returns true if the objects class is of the given type or a derivative. */
-            inline bool isA(const OrxonoxClass* object)
-                { return this->getIdentifier()->isA(object->getIdentifier()); }
-            /** @brief Returns true if the objects class is exactly of the given type. */
-            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()); }
+            bool isA(const OrxonoxClass* object);
+            bool isExactlyA(const OrxonoxClass* object);
+            bool isChildOf(const OrxonoxClass* object);
+            bool isDirectChildOf(const OrxonoxClass* object);
+            bool isParentOf(const OrxonoxClass* object);
+            bool isDirectParentOf(const OrxonoxClass* object);
 
         private:
-            Identifier* identifier_;                    //!< The Identifier of the object
+            Identifier* identifier_;                   //!< The Identifier of the object
             std::set<const Identifier*>* parents_;     //!< List of all parents of the object
-            MetaObjectList metaList_;                   //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
+            MetaObjectList* metaList_;                 //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
     };
 }
