Changeset 8733ce2a in mainline

Timestamp:

2018-07-05T21:41:21Z (6 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f62f1ee

Parents:

73066e61

git-author:

Dzejrou <dzejrou@…> (2018-04-20 14:47:17)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:21)

Message:

cpp: added list iterators

File:

• uspace/lib/cpp/include/impl/list.hpp (modified) (8 diffs)

uspace/lib/cpp/include/impl/list.hpp

@@ -90 +90 @@
 
         template<class T>
-        class list_const_iterator;
+        class list_const_iterator
+        {
+            public:
+                using value_type = typename list<T>::value_type;
+                using reference  = typename list<T>::const_reference;
+
+                using iterator_category = forward_iterator_tag;
+
+                list_const_iterator(list_node<value_type>* node = nullptr,
+                                    list_node<value_type>* head = nullptr)
+                    : current_{node}, head_{head}
+                { /* DUMMY BODY */ }
+
+                list_const_iterator(const list_const_iterator&) = default;
+                list_const_iterator& operator=(const list_const_iterator&) = default;
+                list_const_iterator(list_const_iterator&&) = default;
+                list_const_iterator& operator=(list_const_iterator&&) = default;
+
+                reference operator*() const
+                {
+                    return current_->value;
+                }
+
+                list_const_iterator& operator++()
+                {
+                    if (current_)
+                    {
+                        if (current_->next == head_)
+                            current_ = nullptr;
+                        else
+                            current_ = current_->next;
+                    }
+
+                    return *this;
+                }
+
+                list_const_iterator operator++(int)
+                {
+                    auto bckp = current_;
+
+                    if (current_)
+                    {
+                        if (current_->next == head_)
+                            current_ = nullptr;
+                        else
+                            current_ = current_->next;
+                    }
+
+                    return list_const_iterator{bckp};
+                }
+
+                list_node<value_type>* node()
+                {
+                    return current_;
+                }
+
+                const list_node<value_type>* node() const
+                {
+                    return current_;
+                }
+
+            private:
+                list_node<value_type>* current_;
+                list_node<value_type>* head_;
+        };
+
+        template<class T>
+        bool operator==(const list_const_iterator<T>& lhs, const list_const_iterator<T>& rhs)
+        {
+            return lhs.node() == rhs.node();
+        }
+
+        template<class T>
+        bool operator!=(const list_const_iterator<T>& lhs, const list_const_iterator<T>& rhs)
+        {
+            return !(lhs == rhs);
+        }
 
         template<class T>
@@ -96 +172 @@
         {
             public:
-                using reference = typename list<T>::reference;
-
-                list_iterator(list_node<T>* node = nullptr)
-                    : current_{node}
+                using value_type = typename list<T>::value_type;
+                using reference  = typename list<T>::reference;
+
+                using iterator_category = forward_iterator_tag;
+
+                list_iterator(list_node<value_type>* node = nullptr,
+                              list_node<value_type>* head = nullptr)
+                    : current_{node}, head_{head}
                 { /* DUMMY BODY */ }
 
+                list_iterator(const list_iterator&) = default;
+                list_iterator& operator=(const list_iterator&) = default;
+                list_iterator(list_iterator&&) = default;
+                list_iterator& operator=(list_iterator&&) = default;
+
                 reference operator*()
                 {
@@ -110 +195 @@
                 {
                     if (current_)
-                        current_ = current_->next;
+                    {
+                        if (current_->next == head_)
+                            current_ = nullptr;
+                        else
+                            current_ = current_->next;
+                    }
 
                     return *this;
@@ -120 +210 @@
 
                     if (current_)
-                        current_ = current_->next;
+                    {
+                        if (current_->next == head_)
+                            current_ = nullptr;
+                        else
+                            current_ = current_->next;
+                    }
 
                     return list_iterator{bckp};
                 }
 
-                list_iterator& operator--()
-                {
-                    if (current_)
-                        current_ = current_->prev;
-
-                    return *this;
-                }
-
-                list_iterator operator--(int)
-                {
-                    auto bckp = current_;
-
-                    if (current_)
-                        current_ = current_->prev;
-
-                    return list_iterator{bckp};
-                }
-
-                list_node<T>* node()
+                list_node<value_type>* node()
                 {
                     return current_;
+                }
+
+                const list_node<value_type>* node() const
+                {
+                    return current_;
+                }
+
+                operator list_const_iterator<T>() const
+                {
+                    return list_const_iterator{current_};
                 }
 
             private:
                 list_node<T>* current_;
+                list_node<value_type>* head_;
         };
 
-        // TODO: const iterator, iterator must be convertible to const iterator
+        template<class T>
+        bool operator==(const list_iterator<T>& lhs, const list_iterator<T>& rhs)
+        {
+            return lhs.node() == rhs.node();
+        }
+
+        template<class T>
+        bool operator!=(const list_iterator<T>& lhs, const list_iterator<T>& rhs)
+        {
+            return !(lhs == rhs);
+        }
     }
 
@@ -316 +414 @@
             iterator begin() noexcept
             {
-                return iterator{head_};
+                return iterator{head_, head_};
             }
 
@@ -326 +424 @@
             iterator end() noexcept
             {
-                return iterator{};
+                return iterator{nullptr, head_};
             }
 
@@ -356 +454 @@
             const_iterator cbegin() const noexcept
             {
-                return const_iterator{head_};
+                return const_iterator{head_, head_};
             }
 
             const_iterator cend() const noexcept
             {
-                return const_iterator{};
+                return const_iterator{nullptr, head_};
             }
 
@@ -510 +608 @@
             }
 
+            template<class... Args>
+            iterator emplace(const_iterator position, Args&&... args)
+            {
+                // TODO: implement
+            }
+
         /* private: */
             allocator_type allocator_;