Ticket #8749: map_iterator2.patch

common/hashmap.h

@@ -85 +85 @@
  */
 template <class Key, class Val, class HashFunc = Hash<Key>, class EqualFunc = EqualTo<Key> >
 class HashMap {
-        friend class const_iterator;
 private:
 #if defined (PALMOS_MODE)
 public:
@@ -96 +95 @@
         struct Node {
                 const Key _key;
                 Val _value;
-                Node(const Key &key) : _key(key) {}
+                Node(const Key &key) : _key(key), _value() {}
         };
 
         Node **_arr;    // hashtable of size arrsize.
@@ -117 +116 @@
         int lookupAndCreateIfMissing(const Key &key);
         void expand_array(uint newsize);
 
-public:
-        class const_iterator {
-                typedef const HashMap<Key, Val, HashFunc, EqualFunc> * hashmap_t;
+        template <class NodeType>
+        class Iterator {
+                typedef const HashMap<Key, Val, HashFunc, EqualFunc> *hashmap_t;
                 friend class HashMap<Key, Val, HashFunc, EqualFunc>;
         protected:
                 uint _idx;
                 hashmap_t _hashmap;
-                const_iterator(uint idx, hashmap_t hashmap) : _idx(idx), _hashmap(hashmap) {}
+                Iterator(uint idx, hashmap_t hashmap) : _idx(idx), _hashmap(hashmap) {}
 
-                const Node *deref() const {
+                NodeType *deref() const {
                         assert(_hashmap != 0);
-                        Node *node = _hashmap->_arr[_idx];
+                        NodeType *node = _hashmap->_arr[_idx];
                         assert(node != 0);
                         return node;
                 }
 
         public:
-                const_iterator() : _idx(0), _hashmap(0) {}
+                Iterator() : _idx(0), _hashmap(0) {}
+                // HACK: to allow non const/const begin, end and find to work
+                Iterator(const Iterator<Node> &iter) : _idx(iter._idx), _hashmap(iter._hashmap) {}
 
-                const Node &operator *() const { return *deref(); }
-                const Node *operator->() const { return deref(); }
-                bool operator ==(const const_iterator &iter) const { return _idx == iter._idx && _hashmap == iter._hashmap; }
-                bool operator !=(const const_iterator &iter) const { return !(*this == iter); }
-                const_iterator operator ++() {
+                NodeType &operator *() const { return *deref(); }
+                NodeType *operator->() const { return deref(); }
+
+                bool operator ==(const Iterator &iter) const { return _idx == iter._idx && _hashmap == iter._hashmap; }
+                bool operator !=(const Iterator &iter) const { return !(*this == iter); }
+
+                Iterator &operator ++() {
                         assert(_hashmap);
                         do {
                                 _idx++;
@@ -150 +153 @@
 
                         return *this;
                 }
+
+                Iterator operator ++(int) {
+                        Iterator old = *this;
+                        operator ++();
+                        return old;
+                }
         };
 
+public:
+        typedef Iterator<Node> iterator;
+        typedef Iterator<const Node> const_iterator;
+
         HashMap();
         HashMap(const HM_t& map);
         ~HashMap();
@@ -183 +196 @@
 
         uint size() const { return _nele; }
 
+        iterator        begin() {
+                // Find and return the _key non-empty entry
+                for (uint ctr = 0; ctr < _arrsize; ++ctr) {
+                        if (_arr[ctr])
+                                return iterator(ctr, this);
+                }
+                return end();
+        }
+        iterator        end() {
+                return iterator((uint)-1, this);
+        }
+
         const_iterator  begin() const {
                 // Find and return the first non-empty entry
                 for (uint ctr = 0; ctr < _arrsize; ++ctr) {
@@ -195 +220 @@
                 return const_iterator((uint)-1, this);
         }
 
+        iterator        find(const Key &key) {
+                uint ctr = lookup(key);
+                if (_arr[ctr])
+                        return iterator(ctr, this);
+                return end();
+        }
+
         const_iterator  find(const Key &key) const {
                 uint ctr = lookup(key);
                 if (_arr[ctr])