Iterator

Author: Ohjurot

08_CatsAndDogs/LinkedList.hpp

@@ -17,18 +17,115 @@ namespace FuselUtil
                 {}
 
                 Element* next = nullptr;
+                Element* prev = nullptr;
                 T storage;
             };
 
         public:
+            class Iterator
+            {
+                public:
+                    Iterator() = default;
+                    Iterator(Element* element) :
+                        m_element(element)
+                    {}
+
+                    inline void Fwd() 
+                    {
+                        m_element = m_element->next;
+                    }
+                    inline void Bwd()
+                    {
+                        m_element = m_element->prev;
+                    }
+                    inline T& Data()
+                    {
+                        return m_element->storage;
+                    }
+                    inline const T& Data() const
+                    {
+                        return m_element->storage;
+                    }
+
+                    T& operator*()
+                    {
+                        return Data();
+                    }
+                    const T& operator*() const
+                    {
+                        return Data();
+                    }
+
+                    friend static bool operator==(const Iterator& lhs, const Iterator& rhs)
+                    {
+                        return lhs.m_element == rhs.m_element;
+                    }
+
+                    Iterator& operator++()
+                    {
+                        Fwd();
+                        return *this;
+                    }
+                    Iterator operator++(int)
+                    {
+                        auto copy = *this;
+                        Fwd();
+                        return copy;
+                    }
+
+                    Iterator& operator--()
+                    {
+                        Bwd();
+                        return *this;
+                    }
+                    Iterator operator--(int)
+                    {
+                        auto copy = *this;
+                        Bwd();
+                        return copy;
+                    }
+
+                private:
+                    Element* m_element = nullptr;
+            };
+
+        public:
+            LinkedList() = default;
+            LinkedList(const LinkedList& other)
+            {
+                for (auto* element = other.m_first; element; element = element->next)
+                {
+                    Append(element->storage);
+                }
+            }
+            LinkedList(LinkedList&& other) noexcept :
+                m_first(other.m_first), m_count(other.m_count)
+            {
+                other.m_first = nullptr;
+                other.m_count = 0;
+            }
             ~LinkedList()
             {
-                Element* next;
-                for (Element* element = m_first; element; element = next)
+                Clear();
+            }
+
+            LinkedList& operator=(const LinkedList& other)
+            {
+                if (this != &other)
                 {
-                    next = element->next;
-                    delete element;
+                    this->~LinkedList();
+                    new(this)LinkedList(other);
+                }
+                return *this;
+            }
+            LinkedList& operator=(LinkedList&& other) noexcept
+            {
+                if (this != &other)
+                {
+                    this->~LinkedList();
+                    new(this)LinkedList(std::move(other));
                 }
+                return *this;
             }
 
             void Append(const T& element)
@@ -42,17 +139,39 @@ namespace FuselUtil
 
             void Erase(size_t index)
             {
+                // Seek element
                 Element** element = &m_first;
                 for(size_t i = 0; i < index; i++)
                 {
                     element = &(*element)->next;
                 }
+                // Getting next pointer
                 Element* next = (*element)->next;
+                // Fixing backward linking of next element
+                if (next)
+                {
+                    next->prev = (*element)->prev;
+                }
+                // Deletion of element
                 delete *element;
+                // Fixing forward linking
                 (*element) = next;
+
                 m_count--;
             }
 
+            void Clear()
+            {
+                Element* next;
+                for (Element* element = m_first; element; element = next)
+                {
+                    next = element->next;
+                    delete element;
+                }
+                m_first = nullptr;
+                m_count = 0;
+            }
+
             T& At(size_t index)
             {
                 Element* element = m_first;
@@ -73,6 +192,15 @@ namespace FuselUtil
                 return element->storage;
             }
 
+            inline Iterator begin()
+            {
+                return Iterator(m_first);
+            }
+            inline Iterator end()
+            {
+                return Iterator();
+            }
+
             inline size_t Count() const noexcept
             {
                 return m_count;
@@ -93,14 +221,15 @@ namespace FuselUtil
                 Element** insertionPosition = &m_first;
                 while (*insertionPosition)
                 {
+                    element->prev = *insertionPosition;
                     insertionPosition = &(*insertionPosition)->next;
                 }
                 *insertionPosition = element;
                 m_count++;
             }
 
         private:
-            Element* m_first = nullptr;
+            mutable Element* m_first = nullptr;
             size_t m_count = 0;
     };
 }

08_CatsAndDogs/main.cpp

@@ -12,23 +12,20 @@ int main()
     Cat tabby("Tabby");
     Dog oscar("Oscar");
 
-    LinkedList<int> myInts;
-    for (int i = 0; i < 1024; i++) myInts.Append(i);
+    LinkedList<Pet*> pets;
+    pets.Append(&tabby); 
+    pets.Append(&oscar);
 
-    LinkedList<PetManager::Pet*> ll;
-    ll.Append(&tabby);
-    ll.Append(&oscar);
-
-    for (size_t i = 0; i < ll.Count(); i++)
+    for (const Pet* pet : pets)
     {
-        std::cout << (i + 1) << ". " << *ll[i] << std::endl;
+        std::cout << *pet << std::endl;
     }
 
-    ll.Erase(ll.Count() - 1);
+    pets.Erase(pets.Count() - 1);
 
-    for (size_t i = 0; i < ll.Count(); i++)
+    for (const Pet* pet : pets)
     {
-        std::cout << (i + 1) << ". " << *ll[i] << std::endl;
+        std::cout << *pet << std::endl;
     }
 
     ToyBone bone;