Ticket #9278: ReverseIterator.patch

common/list_intern.h

@@ -102 +102 @@
         };
 
         template<typename T>
+        struct ReverseIterator {
+                typedef ReverseIterator<T>      Self;
+                typedef Node<T> *       NodePtr;
+                typedef T &                     ValueRef;
+                typedef T *                     ValuePtr;
+                typedef T                       ValueType;
+
+                NodeBase *_node;
+
+                ReverseIterator() : _node(0) {}
+                explicit ReverseIterator(NodeBase *node) : _node(node) {}
+
+                // Prefix inc
+                Self &operator++() {
+                        if (_node)
+                                _node = _node->_prev;
+                        return *this;
+                }
+                // Postfix inc
+                Self operator++(int) {
+                        Self tmp(_node);
+                        ++(*this);
+                        return tmp;
+                }
+                // Prefix dec
+                Self &operator--() {
+                        if (_node)
+                                _node = _node->_next;
+                        return *this;
+                }
+                // Postfix dec
+                Self operator--(int) {
+                        Self tmp(_node);
+                        --(*this);
+                        return tmp;
+                }
+                ValueRef operator*() const {
+                        assert(_node);
+                        return static_cast<NodePtr>(_node)->_data;
+                }
+                ValuePtr operator->() const {
+                        return &(operator*());
+                }
+
+                bool operator==(const Self &x) const {
+                        return _node == x._node;
+                }
+
+                bool operator!=(const Self &x) const {
+                        return _node != x._node;
+                }
+        };
+
+        template<typename T>
         struct ConstIterator {
                 typedef ConstIterator<T>        Self;
                 typedef const Node<T> * NodePtr;
@@ -165 +219 @@
         bool operator!=(const Iterator<T>& a, const ConstIterator<T>& b) {
                 return a._node != b._node;
         }
+
+        template<typename T>
+        bool operator==(const ReverseIterator<T>& a, const ConstIterator<T>& b) {
+                return a._node == b._node;
+        }
+
+        template<typename T>
+        bool operator!=(const ReverseIterator<T>& a, const ConstIterator<T>& b) {
+                return a._node != b._node;
+        }
 }