Index: /code/branches/cpp11_v2/src/libraries/core/object/Iterator.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/Iterator.h	(revision 10735)
+++ /code/branches/cpp11_v2/src/libraries/core/object/Iterator.h	(revision 10736)
@@ -79,14 +79,9 @@
 
             /**
-                @brief Constructor: Sets this element to a given element
-                @param element The element
-            */
-            inline Iterator(ObjectListBaseElement* element) : IteratorBase<T, Iterator<T> >(element) {}
-
-            /**
                 @brief Constructor: Sets this element to the element of another Iterator.
                 @param other The other Iterator
             */
-            inline Iterator(const IteratorBase<T, Iterator<T> >& other) : IteratorBase<T, Iterator<T> >(other) {}
+            template <class OT, class OI>
+            inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T> >(other) {}
 
             /**
Index: /code/branches/cpp11_v2/src/libraries/core/object/IteratorBase.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/IteratorBase.h	(revision 10735)
+++ /code/branches/cpp11_v2/src/libraries/core/object/IteratorBase.h	(revision 10736)
@@ -54,10 +54,9 @@
         BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
 
-        protected:
+        public:
             /**
                 @brief Constructor: Sets the element, whereon the iterator points, to the given element.
-                This constructor is protected and only for internal usage (don't mess with the BaseElements directly).
-            */
-            inline IteratorBase(ObjectListBaseElement* element = NULL)
+            */
+            inline IteratorBase(ObjectListElement<T>* element = NULL)
             {
                 this->element_ = element;
@@ -65,34 +64,12 @@
             }
 
-
-        public:
-            /**
-                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
-            */
-            inline IteratorBase(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
-                this->registerIterator();
-            }
-
             /**
                 @brief Constructor: Sets the element, whereon the iterator points, to the given element of another type.
                 The element's type O must be a derivative of the Iterator's type T.
             */
-            template <class O>
-            inline IteratorBase(ObjectListElement<O>* element)
-            {
-                (void)static_cast<T*>((O*)NULL); // Check type: The element's type O must be a derivative of the Iterator's type T.
-                this->element_ = element;
-                this->registerIterator();
-            }
-
-            /**
-                @brief Constructor: Sets this element to the element of another Iterator.
-                @param other The other Iterator
-            */
-            inline IteratorBase(const IteratorBase& other)
-            {
-                this->element_ = other.element_;
+            template <class OT, class OI>
+            inline IteratorBase(const IteratorBase<OT, OI>& other)
+            {
+                this->element_ = other.getElement();
                 this->registerIterator();
             }
@@ -205,4 +182,9 @@
                 if (this->element_ == element)
                     this->operator++();
+            }
+
+            inline ObjectListBaseElement* getElement() const
+            {
+                return this->element_;
             }
 
Index: /code/branches/cpp11_v2/src/libraries/core/object/ObjectList.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/ObjectList.h	(revision 10735)
+++ /code/branches/cpp11_v2/src/libraries/core/object/ObjectList.h	(revision 10736)
@@ -84,8 +84,8 @@
 
             /// Returns an Iterator to the first element in the list (for the root context).
-            inline static ObjectListElement<T>* begin()
+            inline static ObjectListIterator<T> begin()
             {   return begin(Context::getRootContext());   }
             /// Returns an Iterator to the first element in the list.
-            inline static ObjectListElement<T>* begin(Context* context)
+            inline static ObjectListIterator<T> begin(Context* context)
             {
                 ObjectListBase* list = context->getObjectList<T>();
@@ -94,8 +94,8 @@
 
             /// Returns an Iterator to the element after the last element in the list (for the root context).
-            inline static ObjectListElement<T>* end()
+            inline static ObjectListIterator<T> end()
             {   return end(Context::getRootContext());   }
             /// Returns an Iterator to the element after the last element in the list.
-            inline static ObjectListElement<T>* end(Context* context)
+            inline static ObjectListIterator<T> end(Context* context)
             {
                 ObjectListBase* list = context->getObjectList<T>();
@@ -104,8 +104,8 @@
 
             /// Returns an Iterator to the last element in the list (for the root context).
-            inline static ObjectListElement<T>* rbegin()
+            inline static ObjectListIterator<T> rbegin()
             {   return rbegin(Context::getRootContext());   }
             /// Returns an Iterator to the last element in the list.
-            inline static ObjectListElement<T>* rbegin(Context* context)
+            inline static ObjectListIterator<T> rbegin(Context* context)
             {
                 ObjectListBase* list = context->getObjectList<T>();
@@ -114,8 +114,8 @@
 
             /// Returns an Iterator to the element before the first element in the list (for the root context).
-            inline static ObjectListElement<T>* rend()
+            inline static ObjectListIterator<T> rend()
             {   return rend(Context::getRootContext());   }
             /// Returns an Iterator to the element before the first element in the list.
-            inline static ObjectListElement<T>* rend(Context* context)
+            inline static ObjectListIterator<T> rend(Context* context)
             {
                 ObjectListBase* list = context->getObjectList<T>();
Index: /code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.h	(revision 10735)
+++ /code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.h	(revision 10736)
@@ -93,9 +93,4 @@
             }
 
-            operator T*()
-            {
-                return object_;
-            }
-
             T* object_;              //!< The object
     };
Index: /code/branches/cpp11_v2/src/libraries/core/object/ObjectListIterator.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/ObjectListIterator.h	(revision 10735)
+++ /code/branches/cpp11_v2/src/libraries/core/object/ObjectListIterator.h	(revision 10736)
@@ -86,5 +86,6 @@
                 @param other The other ObjectListIterator
             */
-            inline ObjectListIterator(const IteratorBase<T, ObjectListIterator<T> >& other) : IteratorBase<T, ObjectListIterator<T> >(other) {}
+            template <class OI>
+            inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T> >(other) {}
 
             /**
Index: /code/branches/cpp11_v2/test/core/CMakeLists.txt
===================================================================
--- /code/branches/cpp11_v2/test/core/CMakeLists.txt	(revision 10735)
+++ /code/branches/cpp11_v2/test/core/CMakeLists.txt	(revision 10736)
@@ -25,4 +25,5 @@
     object/ListableTest.cc
     object/ObjectListBaseTest.cc
+    object/ObjectListTest.cc
     object/ObjectListIteratorTest.cc
     object/StrongPtrTest.cc
Index: /code/branches/cpp11_v2/test/core/object/IteratorTest.cc
===================================================================
--- /code/branches/cpp11_v2/test/core/object/IteratorTest.cc	(revision 10735)
+++ /code/branches/cpp11_v2/test/core/object/IteratorTest.cc	(revision 10736)
@@ -80,3 +80,61 @@
             it->test();
     }
+
+    TEST_F(IteratorTest, CanIterateOverInterfaceListWithInterfaceIterator)
+    {
+        TestClass testClass;
+        TestInterface testInterface;
+
+        size_t i = 0;
+        for (Iterator<TestInterface> it = ObjectList<TestInterface>::begin(); it != ObjectList<TestInterface>::end(); ++it)
+        {
+            ++i;
+            if (i == 1u) EXPECT_EQ(&testClass, *it);
+            if (i == 2u) EXPECT_EQ(&testInterface, *it);
+        }
+        EXPECT_EQ(2u, i);
+    }
+
+    TEST_F(IteratorTest, CanIterateOverClassListWithClassIterator)
+    {
+        TestClass testClass;
+        TestInterface testInterface;
+
+        size_t i = 0;
+        for (Iterator<TestClass> it = ObjectList<TestClass>::begin(); it != ObjectList<TestClass>::end(); ++it)
+        {
+            ++i;
+            if (i == 1u) EXPECT_EQ(&testClass, *it);
+        }
+        EXPECT_EQ(1u, i);
+    }
+
+    TEST_F(IteratorTest, CanIterateOverInterfaceListWithClassIterator)
+    {
+        TestClass testClass;
+        TestInterface testInterface;
+
+        size_t i = 0;
+        for (Iterator<TestClass> it = ObjectList<TestInterface>::begin(); it != ObjectList<TestInterface>::end(); ++it)
+        {
+            ++i;
+            if (i == 1u) EXPECT_EQ(&testClass, *it);
+            if (i == 2u) EXPECT_EQ(NULL, *it);
+        }
+        EXPECT_EQ(2u, i);
+    }
+
+    TEST_F(IteratorTest, CanIterateOverClassListWithInterfaceIterator)
+    {
+        TestClass testClass;
+        TestInterface testInterface;
+
+        size_t i = 0;
+        for (Iterator<TestInterface> it = ObjectList<TestClass>::begin(); it != ObjectList<TestClass>::end(); ++it)
+        {
+            ++i;
+            if (i == 1u) EXPECT_EQ(&testClass, *it);
+        }
+        EXPECT_EQ(1u, i);
+    }
 }
Index: /code/branches/cpp11_v2/test/core/object/ObjectListIteratorTest.cc
===================================================================
--- /code/branches/cpp11_v2/test/core/object/ObjectListIteratorTest.cc	(revision 10735)
+++ /code/branches/cpp11_v2/test/core/object/ObjectListIteratorTest.cc	(revision 10736)
@@ -3,5 +3,6 @@
 
 #include "core/object/ObjectListIterator.h"
-#include "core/object/Listable.h"
+#include "core/class/OrxonoxClass.h"
+#include "core/class/OrxonoxInterface.h"
 #include "core/CoreIncludes.h"
 #include "core/module/ModuleInstance.h"
@@ -11,12 +12,19 @@
     namespace
     {
-        class ListableTest : public Listable
+        class TestInterface : virtual public OrxonoxInterface
         {
             public:
-                ListableTest() { RegisterObject(ListableTest); }
+            TestInterface() { RegisterObject(TestInterface); }
+        };
+
+        class TestClass : public OrxonoxClass, public TestInterface
+        {
+            public:
+                TestClass() { RegisterObject(TestClass); }
                 MOCK_METHOD0(test, void());
         };
 
-        RegisterClassNoArgs(ListableTest);
+        RegisterClassNoArgs(TestInterface);
+        RegisterClassNoArgs(TestClass);
 
         // Fixture
@@ -42,10 +50,10 @@
     TEST_F(ObjectListIteratorTest, CanCreateIterator)
     {
-        ObjectListIterator<ListableTest> it;
+        ObjectListIterator<TestClass> it;
     }
 
     TEST_F(ObjectListIteratorTest, CanAssignIterator)
     {
-        ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin();
+        ObjectListIterator<TestClass> it = ObjectList<TestClass>::begin();
     }
 
@@ -53,5 +61,5 @@
     {
         size_t i = 0;
-        for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
+        for (ObjectListIterator<TestClass> it = ObjectList<TestClass>::begin(); it != ObjectList<TestClass>::end(); ++it)
             ++i;
         EXPECT_EQ(0u, i);
@@ -60,10 +68,11 @@
     TEST_F(ObjectListIteratorTest, CanIterateOverFullList)
     {
-        ListableTest test1;
-        ListableTest test2;
-        ListableTest test3;
+        TestClass test1;
+        TestClass test2;
+        TestClass test3;
+        TestInterface interface;
 
         size_t i = 0;
-        for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
+        for (ObjectListIterator<TestClass> it = ObjectList<TestClass>::begin(); it != ObjectList<TestClass>::end(); ++it)
         {
             ++i;
@@ -77,10 +86,11 @@
     TEST_F(ObjectListIteratorTest, CanIterateReverseOverFullList)
     {
-        ListableTest test1;
-        ListableTest test2;
-        ListableTest test3;
+        TestClass test1;
+        TestClass test2;
+        TestClass test3;
+        TestInterface interface;
 
         size_t i = 0;
-        for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::rbegin(); it != ObjectList<ListableTest>::rend(); --it)
+        for (ObjectListIterator<TestClass> it = ObjectList<TestClass>::rbegin(); it != ObjectList<TestClass>::rend(); --it)
         {
             ++i;
@@ -94,7 +104,8 @@
     TEST_F(ObjectListIteratorTest, CanCallObjects)
     {
-        ListableTest test1;
-        ListableTest test2;
-        ListableTest test3;
+        TestClass test1;
+        TestClass test2;
+        TestClass test3;
+        TestInterface interface;
 
         EXPECT_CALL(test1, test());
@@ -102,5 +113,5 @@
         EXPECT_CALL(test3, test());
 
-        for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
+        for (ObjectListIterator<TestClass> it = ObjectList<TestClass>::begin(); it != ObjectList<TestClass>::end(); ++it)
             it->test();
     }
Index: /code/branches/cpp11_v2/test/core/object/ObjectListTest.cc
===================================================================
--- /code/branches/cpp11_v2/test/core/object/ObjectListTest.cc	(revision 10736)
+++ /code/branches/cpp11_v2/test/core/object/ObjectListTest.cc	(revision 10736)
@@ -0,0 +1,105 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "core/object/ObjectListIterator.h"
+#include "core/object/Listable.h"
+#include "core/CoreIncludes.h"
+#include "core/module/ModuleInstance.h"
+
+namespace orxonox
+{
+    namespace
+    {
+        class ListableTest : public Listable
+        {
+            public:
+                ListableTest() { RegisterObject(ListableTest); }
+                MOCK_METHOD0(test, void());
+        };
+
+        RegisterClassNoArgs(ListableTest);
+
+        // Fixture
+        class ObjectListTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    new IdentifierManager();
+                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::destroyRootContext();
+                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
+                    delete &IdentifierManager::getInstance();
+                }
+        };
+    }
+    
+    TEST_F(ObjectListTest, CanIterateOverEmptyList)
+    {
+        size_t i = 0;
+        for (ListableTest* object : ObjectList<ListableTest>())
+        {
+            ++i;
+            ((void*)object); // avoid warning about unused variable
+        }
+        EXPECT_EQ(0u, i);
+    }
+
+    TEST_F(ObjectListTest, CanIterateOverFullList)
+    {
+        ListableTest test1;
+        ListableTest test2;
+        ListableTest test3;
+
+        size_t i = 0;
+        for (ListableTest* object : ObjectList<ListableTest>())
+        {
+            ++i;
+            if (i == 1u) EXPECT_EQ(&test1, object);
+            if (i == 2u) EXPECT_EQ(&test2, object);
+            if (i == 3u) EXPECT_EQ(&test3, object);
+        }
+        EXPECT_EQ(3u, i);
+    }
+    
+    TEST_F(ObjectListTest, CanIterateOverFullList_Expanded)
+    {
+        ListableTest test1;
+        ListableTest test2;
+        ListableTest test3;
+
+        size_t i = 0;
+        ObjectList<ListableTest>&& __range = ObjectList<ListableTest>();
+        ObjectListIterator<ListableTest> __begin = __range.begin();
+        ObjectListIterator<ListableTest>__end = __range.end();
+        for (; __begin != __end; ++__begin)
+        {
+            ListableTest* object = *__begin;
+
+            ++i;
+            if (i == 1u) EXPECT_EQ(&test1, object);
+            if (i == 2u) EXPECT_EQ(&test2, object);
+            if (i == 3u) EXPECT_EQ(&test3, object);
+        }
+        EXPECT_EQ(3u, i);
+    }
+    
+    TEST_F(ObjectListTest, CanCallObjects)
+    {
+        ListableTest test1;
+        ListableTest test2;
+        ListableTest test3;
+
+        EXPECT_CALL(test1, test());
+        EXPECT_CALL(test2, test());
+        EXPECT_CALL(test3, test());
+
+        for (ListableTest* object : ObjectList<ListableTest>())
+            object->test();
+    }
+}
