Changeset 98a2b1dc

Timestamp:

Feb 2, 2023, 4:10:15 PM (22 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, master

Children:

85dd381

Parents:

ccf1d99

Message:

Updated ScopedMap? to use the layout of ErasableScopedMap?; putting the iterator details at the end of the file.

Location:

src

Files:

• Common/ScopedMap.h (modified) (3 diffs)
• GenPoly/ErasableScopedMap.h (modified) (1 diff)

src/Common/ScopedMap.h

@@ -37 +37 @@
                 template<typename N>
                 Scope(N && n) : map(), note(std::forward<N>(n)) {}
-                
+
                 Scope() = default;
                 Scope(const Scope &) = default;
@@ -58 +58 @@
         typedef typename MapType::const_pointer const_pointer;
 
-        class iterator : public std::iterator< std::bidirectional_iterator_tag, value_type > {
-        friend class ScopedMap;
-        friend class const_iterator;
-                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
-                typedef typename ScopedMap::ScopeList scope_list;
-                typedef typename scope_list::size_type size_type;
-
-                /// Checks if this iterator points to a valid item
-                bool is_valid() const {
-                        return it != (*scopes)[level].map.end();
-                }
-
-                /// Increments on invalid
-                iterator & next_valid() {
-                        if ( ! is_valid() ) { ++(*this); }
-                        return *this;
-                }
-
-                /// Decrements on invalid
-                iterator & prev_valid() {
-                        if ( ! is_valid() ) { --(*this); }
-                        return *this;
-                }
-
-                iterator(scope_list & _scopes, const wrapped_iterator & _it, size_type inLevel)
-                        : scopes(&_scopes), it(_it), level(inLevel) {}
-        public:
-                iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
-                iterator & operator= (const iterator & that) {
-                        scopes = that.scopes; level = that.level; it = that.it;
-                        return *this;
-                }
-
-                reference operator* () { return *it; }
-                pointer operator-> () const { return it.operator->(); }
-
-                iterator & operator++ () {
-                        if ( it == (*scopes)[level].map.end() ) {
-                                if ( level == 0 ) return *this;
-                                --level;
-                                it = (*scopes)[level].map.begin();
-                        } else {
-                                ++it;
-                        }
-                        return next_valid();
-                }
-                iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
-
-                iterator & operator-- () {
-                        // may fail if this is the begin iterator; allowed by STL spec
-                        if ( it == (*scopes)[level].map.begin() ) {
-                                ++level;
-                                it = (*scopes)[level].map.end();
-                        }
-                        --it;
-                        return prev_valid();
-                }
-                iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
-
-                bool operator== (const iterator & that) const {
-                        return scopes == that.scopes && level == that.level && it == that.it;
-                }
-                bool operator!= (const iterator & that) const { return !( *this == that ); }
-
-                size_type get_level() const { return level; }
-
-                Note & get_note() { return (*scopes)[level].note; }
-                const Note & get_note() const { return (*scopes)[level].note; }
-
-        private:
-                scope_list *scopes;
-                wrapped_iterator it;
-                size_type level;
-        };
-
-        class const_iterator : public std::iterator< std::bidirectional_iterator_tag,
-                                                     value_type > {
-        friend class ScopedMap;
-                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
-                typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
-                typedef typename ScopedMap::ScopeList scope_list;
-                typedef typename scope_list::size_type size_type;
-
-                /// Checks if this iterator points to a valid item
-                bool is_valid() const {
-                        return it != (*scopes)[level].map.end();
-                }
-
-                /// Increments on invalid
-                const_iterator & next_valid() {
-                        if ( ! is_valid() ) { ++(*this); }
-                        return *this;
-                }
-
-                /// Decrements on invalid
-                const_iterator & prev_valid() {
-                        if ( ! is_valid() ) { --(*this); }
-                        return *this;
-                }
-
-                const_iterator(scope_list const & _scopes, const wrapped_const_iterator & _it, size_type inLevel)
-                        : scopes(&_scopes), it(_it), level(inLevel) {}
-        public:
-                const_iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
-                const_iterator(const const_iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
-                const_iterator & operator= (const iterator & that) {
-                        scopes = that.scopes; level = that.level; it = that.it;
-                        return *this;
-                }
-                const_iterator & operator= (const const_iterator & that) {
-                        scopes = that.scopes; level = that.level; it = that.it;
-                        return *this;
-                }
-
-                const_reference operator* () { return *it; }
-                const_pointer operator-> () { return it.operator->(); }
-
-                const_iterator & operator++ () {
-                        if ( it == (*scopes)[level].map.end() ) {
-                                if ( level == 0 ) return *this;
-                                --level;
-                                it = (*scopes)[level].map.begin();
-                        } else {
-                                ++it;
-                        }
-                        return next_valid();
-                }
-                const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
-
-                const_iterator & operator-- () {
-                        // may fail if this is the begin iterator; allowed by STL spec
-                        if ( it == (*scopes)[level].map.begin() ) {
-                                ++level;
-                                it = (*scopes)[level].map.end();
-                        }
-                        --it;
-                        return prev_valid();
-                }
-                const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
-
-                bool operator== (const const_iterator & that) const {
-                        return scopes == that.scopes && level == that.level && it == that.it;
-                }
-                bool operator!= (const const_iterator & that) const { return !( *this == that ); }
-
-                size_type get_level() const { return level; }
-
-                const Note & get_note() const { return (*scopes)[level].note; }
-
-        private:
-                scope_list const *scopes;
-                wrapped_const_iterator it;
-                size_type level;
-        };
+        // Both iterator types are complete bidrectional iterators, see below.
+        class iterator;
+        class const_iterator;
 
         /// Starts a new scope
@@ -345 +194 @@
 };
 
+template<typename Key, typename Value, typename Note>
+class ScopedMap<Key, Value, Note>::iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        friend class const_iterator;
+        typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+        typedef typename ScopedMap::ScopeList scope_list;
+        typedef typename scope_list::size_type size_type;
+
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[level].map.end();
+        }
+
+        /// Increments on invalid
+        iterator & next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+
+        /// Decrements on invalid
+        iterator & prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+
+        iterator(scope_list & _scopes, const wrapped_iterator & _it, size_type inLevel)
+                : scopes(&_scopes), it(_it), level(inLevel) {}
+public:
+        iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        iterator & operator= (const iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+
+        reference operator* () { return *it; }
+        pointer operator-> () const { return it.operator->(); }
+
+        iterator & operator++ () {
+                if ( it == (*scopes)[level].map.end() ) {
+                        if ( level == 0 ) return *this;
+                        --level;
+                        it = (*scopes)[level].map.begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+
+        iterator & operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[level].map.begin() ) {
+                        ++level;
+                        it = (*scopes)[level].map.end();
+                }
+                --it;
+                return prev_valid();
+        }
+        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+
+        bool operator== (const iterator & that) const {
+                return scopes == that.scopes && level == that.level && it == that.it;
+        }
+        bool operator!= (const iterator & that) const { return !( *this == that ); }
+
+        size_type get_level() const { return level; }
+
+        Note & get_note() { return (*scopes)[level].note; }
+        const Note & get_note() const { return (*scopes)[level].note; }
+
+private:
+        scope_list *scopes;
+        wrapped_iterator it;
+        size_type level;
+};
+
+template<typename Key, typename Value, typename Note>
+class ScopedMap<Key, Value, Note>::const_iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+        typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
+        typedef typename ScopedMap::ScopeList scope_list;
+        typedef typename scope_list::size_type size_type;
+
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[level].map.end();
+        }
+
+        /// Increments on invalid
+        const_iterator & next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+
+        /// Decrements on invalid
+        const_iterator & prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+
+        const_iterator(scope_list const & _scopes, const wrapped_const_iterator & _it, size_type inLevel)
+                : scopes(&_scopes), it(_it), level(inLevel) {}
+public:
+        const_iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        const_iterator(const const_iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        const_iterator & operator= (const iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+        const_iterator & operator= (const const_iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+
+        const_reference operator* () { return *it; }
+        const_pointer operator-> () { return it.operator->(); }
+
+        const_iterator & operator++ () {
+                if ( it == (*scopes)[level].map.end() ) {
+                        if ( level == 0 ) return *this;
+                        --level;
+                        it = (*scopes)[level].map.begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+
+        const_iterator & operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[level].map.begin() ) {
+                        ++level;
+                        it = (*scopes)[level].map.end();
+                }
+                --it;
+                return prev_valid();
+        }
+        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+
+        bool operator== (const const_iterator & that) const {
+                return scopes == that.scopes && level == that.level && it == that.it;
+        }
+        bool operator!= (const const_iterator & that) const { return !( *this == that ); }
+
+        size_type get_level() const { return level; }
+
+        const Note & get_note() const { return (*scopes)[level].note; }
+
+private:
+        scope_list const *scopes;
+        wrapped_const_iterator it;
+        size_type level;
+};
+
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ErasableScopedMap.h

@@ -51 +51 @@
         typedef typename Scope::const_pointer const_pointer;
 
-        // Both iterator types are complete bidirection iterators, defined below.
+        // Both iterator types are complete bidirectional iterators, see below.
         class iterator;
         class const_iterator;