From 8c3794a1680e07b9548b036fdc1879b0abf4ac1e Mon Sep 17 00:00:00 2001
From: Sam Hocevar <sam@hocevar.net>
Date: Wed, 11 Jun 2014 14:42:58 +0000
Subject: [PATCH] base: support range-based for loops in lol::Array.

---
 src/lol/algorithm/portal.h | 31 +++++++++---------
 src/lol/base/array.h       | 64 ++++++++++++++++++++++++++++++++++++++
 test/unit/quat.cpp         |  6 ++--
 test/unit/real.cpp         |  4 +--
 4 files changed, 83 insertions(+), 22 deletions(-)

diff --git a/src/lol/algorithm/portal.h b/src/lol/algorithm/portal.h
index ea8ea9a1..ace79b5d 100644
--- a/src/lol/algorithm/portal.h
+++ b/src/lol/algorithm/portal.h
@@ -257,8 +257,8 @@ public:
     }
     ~PortalRoom()
     {
-        for (int i = 0; i < m_doors.Count(); i++)
-            m_doors[i]->DisconnectRoom(this);
+        for (auto door : m_doors)
+            door->DisconnectRoom(this);
         m_doors.Empty();
     }
 
@@ -289,10 +289,10 @@ class PortalSet
 public:
     ~PortalSet()
     {
-        for (int i = 0; i < m_doors.Count(); i++)
-            delete m_doors[i];
-        for (int i = 0; i < m_rooms.Count(); i++)
-            delete m_rooms[i];
+        for (auto door : m_doors)
+            delete door;
+        for (auto room : m_rooms)
+            delete room;
         m_doors.Empty();
         m_rooms.Empty();
     }
@@ -303,21 +303,19 @@ public:
         Array<PortalDoor<TE>*> ignore_doors;
         GetVisibleRooms(see_through, start_room, visible_rooms, ignore_doors);
     #if LOL_BUILD_DEBUG
-        for (int j = 0; j < visible_rooms.Count(); j++)
+        for (auto room : visible_rooms)
         {
             vec4 tmp = vec4::zero;
-            for (int i = 0; i < visible_rooms[j]->m_doors.Count(); i++)
+            for (auto port : room->m_doors)
             {
-                PortalDoor<TE>* port = visible_rooms[j]->m_doors[i];
                 Debug::Draw(*port, Color::cyan);
                 tmp += vec4(port->m_center, 1.f);
             }
             tmp /= tmp.w;
             Debug::DrawBox(tmp.xyz - vec3(1.f), tmp.xyz + vec3(1.f), Color::yellow);
         }
-        for (int i = 0; i < ignore_doors.Count(); i++)
+        for (auto port : ignore_doors)
         {
-            PortalDoor<TE>* port = ignore_doors[i];
             Debug::Draw(*port, Color::magenta);
             Debug::DrawViewProj(port->m_view, port->m_proj, Color::magenta);
         }
@@ -326,9 +324,8 @@ public:
 private:
     void GetVisibleRooms(PortalDoor<TE>* see_through, PortalRoom<TE>* start_room, Array<PortalRoom<TE>*>& visible_rooms, Array<PortalDoor<TE>*>& ignore_doors)
     {
-        for (int i = 0; i < start_room->m_doors.Count(); i++)
+        for (auto door : start_room->m_doors)
         {
-            PortalDoor<TE>* door = start_room->m_doors[i];
             if (door == see_through || ignore_doors.Find(door) != INDEX_NONE)
                 continue;
 
@@ -351,15 +348,15 @@ public:
     PortalSet<TE>& operator<<(class PortalRoom<TE>* room)
     {
         m_rooms.PushUnique(room);
-        for (int i = 0; i < room->m_doors.Count(); i++)
-            m_doors.PushUnique(room->m_doors[i]);
+        for (auto door : room->m_doors)
+            m_doors.PushUnique(door);
         return *this;
     }
     //--
     PortalSet<TE>& operator>>(class PortalRoom<TE>* room)
     {
-        for (int i = 0; i < room->m_doors.Count(); i++)
-            *this >> room->m_doors[i];
+        for (auto door : room->m_doors)
+            *this >> door;
         m_rooms.RemoveItem(room);
         return *this;
     }
diff --git a/src/lol/base/array.h b/src/lol/base/array.h
index e23d51ce..06594ae4 100644
--- a/src/lol/base/array.h
+++ b/src/lol/base/array.h
@@ -399,6 +399,70 @@ public:
     void Sort(int sort);
     void SortQuickSwap(int start, int stop);
 
+    /* Support C++11 range-based for loops */
+    class ConstIterator
+    {
+    public:
+        ConstIterator(ArrayBase const *array, int pos)
+          : m_pos(pos),
+            m_array(array)
+        { }
+
+        bool operator !=(const ConstIterator& that) const
+        {
+            return m_pos != that.m_pos;
+        }
+
+        Element const & operator *() const
+        {
+            return (*m_array)[m_pos];
+        }
+
+        ConstIterator const & operator ++()
+        {
+            ++m_pos;
+            return *this;
+        }
+
+    private:
+        int m_pos;
+        ArrayBase const *m_array;
+    };
+
+    class Iterator
+    {
+    public:
+        Iterator(ArrayBase *array, int pos)
+          : m_pos(pos),
+            m_array(array)
+        { }
+
+        bool operator !=(const Iterator& that) const
+        {
+            return m_pos != that.m_pos;
+        }
+
+        Element operator *()
+        {
+            return (*m_array)[m_pos];
+        }
+
+        Iterator const & operator ++()
+        {
+            ++m_pos;
+            return *this;
+        }
+
+    private:
+        int m_pos;
+        ArrayBase *m_array;
+    };
+
+    ConstIterator begin() const { return ConstIterator(this, 0); }
+    ConstIterator end() const { return ConstIterator(this, m_count); }
+    Iterator begin() { return Iterator(this, 0); }
+    Iterator end() { return Iterator(this, m_count); }
+
 public:
     inline int Count() const { return m_count; }
     inline int Bytes() const { return m_count * sizeof(Element); }
diff --git a/test/unit/quat.cpp b/test/unit/quat.cpp
index 3542dd24..e67827e3 100644
--- a/test/unit/quat.cpp
+++ b/test/unit/quat.cpp
@@ -204,10 +204,10 @@ LOLUNIT_FIXTURE(QuaternionTest)
 
     LOLUNIT_TEST(FromTwoVectors)
     {
-        for (int i = 0; i < m_vectorpairs.Count(); ++i)
+        for (auto pair : m_vectorpairs)
         {
-            vec3 a = m_vectorpairs[i].m1;
-            vec3 b = m_vectorpairs[i].m2;
+            vec3 a = pair.m1;
+            vec3 b = pair.m2;
             vec3 da = normalize(a);
             vec3 db = normalize(b);
 
diff --git a/test/unit/real.cpp b/test/unit/real.cpp
index b558af44..6f26a77b 100644
--- a/test/unit/real.cpp
+++ b/test/unit/real.cpp
@@ -290,9 +290,9 @@ LOLUNIT_FIXTURE(RealTest)
             0.0, 1.0, 511.0, 512.0, 513.0, 1023.0, 1024.0
         };
 
-        for (unsigned int n = 0; n < sizeof(tests) / sizeof(*tests); n++)
+        for (double test : tests)
         {
-            double a = tests[n] / 1024;
+            double a = test / 1024;
             double b = sin(asin((real)a));
             double c = cos(acos((real)a));