Changeset 35cd219 for src/Common/VectorMap.h

Timestamp:

Feb 14, 2017, 3:58:01 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

cf97ccb, efd60d67

Parents:

9bb90a86 (diff), e58dfb9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/Common/VectorMap.h (modified) (4 diffs)

src/Common/VectorMap.h

@@ -38 +38 @@
         typedef const const_value_type* const_pointer;
         
-        class iterator : public std::iterator< std::bidirectional_iterator_tag,
+        class iterator : public std::iterator< std::random_access_iterator_tag,
                                                value_type,
-                                                                                    difference_type,
-                                                                                        pointer,
-                                                                                        reference > {
+                                                                                   difference_type,
+                                                                                   pointer,
+                                                                                   reference > {
         friend class VectorMap;
         friend class const_iterator;
@@ -74 +74 @@
                 iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
 
+                iterator& operator+= (difference_type i) {
+                        // SHENANIGANS: same reasons as operator++
+                        new(&data) value_type{ (data.first + i), *(&data.second + i) };
+                        return *this;
+                }
+
+                iterator operator+ (difference_type i) const { iterator tmp = *this; return tmp += i; }
+
+                iterator& operator-= (difference_type i) {
+                        // SHENANIGANS: same reasons as operator++
+                        new(&data) value_type{ (data.first - i), *(&data.second - i) };
+                        return *this;
+                }
+
+                iterator operator- (difference_type i) const { iterator tmp = *this; return tmp -= i; }
+
+                difference_type operator- (const iterator& o) const { return data.first - o.data.first; }
+
+                value_type operator[] (difference_type i) const {
+                        // SHENANIGANS: same reasons as operator++
+                        return value_type{ (data.first + i), *(&data.second + i) };
+                }
+
                 bool operator== (const iterator& o) const {
                         return data.first == o.data.first && &data.second == &o.data.second;
                 }
+                
                 bool operator!= (const iterator& that) const { return !(*this == that); }
+
+                bool operator< (const iterator& o) const { return data.first < o.data.first; }
+
+                bool operator> (const iterator& o) const { return data.first > o.data.first; }
+
+                bool operator<= (const iterator& o) const { return data.first <= o.data.first; }
+
+                bool operator>= (const iterator& o) const { return data.first >= o.data.first; }
         };
 
@@ -118 +150 @@
                 const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
 
+                const_iterator& operator+= (difference_type i) {
+                        // SHENANIGANS: same reasons as iterator::operator++
+                        new(&data) const_value_type{ (data.first + i), *(&data.second + i) };
+                        return *this;
+                }
+
+                const_iterator operator+ (difference_type i) const {
+                        const_iterator tmp = *this; return tmp += i;
+                }
+
+                const_iterator& operator-= (difference_type i) {
+                        // SHENANIGANS: same reasons as iterator::operator++
+                        new(&data) const_value_type{ (data.first - i), *(&data.second - i) };
+                        return *this;
+                }
+
+                const_iterator operator- (difference_type i) const {
+                        const_iterator tmp = *this; return tmp -= i;
+                }
+
+                difference_type operator- (const const_iterator& o) const {
+                        return data.first - o.data.first;
+                }
+
+                const_value_type operator[] (difference_type i) const {
+                        // SHENANIGANS: same reasons as iterator::operator++
+                        return const_value_type{ (data.first + i), *(&data.second + i) };
+                }
+
                 bool operator== (const const_iterator& o) const {
                         return data.first == o.data.first && &data.second == &o.data.second;
                 }
+                
                 bool operator!= (const const_iterator& that) const { return !(*this == that); }
+
+                bool operator< (const const_iterator& o) const { return data.first < o.data.first; }
+
+                bool operator> (const const_iterator& o) const { return data.first > o.data.first; }
+
+                bool operator<= (const const_iterator& o) const { return data.first <= o.data.first; }
+
+                bool operator>= (const const_iterator& o) const { return data.first >= o.data.first; }
         };
 
@@ -163 +233 @@
 };
 
+template<typename T>
+typename VectorMap<T>::iterator operator+ (typename VectorMap<T>::difference_type i, 
+                                           const typename VectorMap<T>::iterator& it) {
+        return it + i;
+}
+
+template<typename T>
+typename VectorMap<T>::const_iterator operator+ (typename VectorMap<T>::difference_type i, 
+                                                 const typename VectorMap<T>::const_iterator& it) {
+        return it + i;
+}
+
 #endif // _VECTORMAP_H