lib improvements

.gitignore

@@ -40,3 +40,5 @@ cmake-build
 # vim swap files
 **/.*.swp
 **/.*.swo
+.ccls-cache
+.cache/

Lib/DArray.hpp

@@ -191,6 +191,8 @@ class DArray
   } // ensure
 
 
+  void reset() { ensure(0); }
+
   /**
    * Set array's size to @b s and that its capacity is at least @b s.
    * If the capacity is smaller, the array will expand, and all old

Lib/Map.hpp

@@ -64,6 +64,13 @@ class Map
         value().~Val();
       }
     }
+    void reset() {
+      if (occupied()) {
+        key().~Key();
+        value().~Val();
+      }
+      code = 0;
+    }
 
   private:
     /** Create a new entry */
@@ -515,6 +522,7 @@ class Map
     return true;
   }
 
+
   void clear()
   {
     if (_entries) {
@@ -528,6 +536,20 @@ class Map
     _maxEntries  = 0;
   }
 
+  /**
+   * resets every entry in the map keeping the memory of _entries allocated
+   */
+  void reset()
+  {
+    CALL("Map::deleteAll");
+
+    for (int i = _capacity-1;i >= 0;i--) {
+      _entries[i].reset();
+    }
+    _noOfEntries = 0;
+  } // reset
+
+
   /**
    * Delete all entries.
    * @since 07/08/2005 Redmond

Lib/Metaiterators.hpp

@@ -2125,16 +2125,16 @@ auto dropElementType(Iterator iter)
 { return iterTraits(std::move(iter)).map([](auto _) { return make_tuple(); }); }
 
 template<class Array>
-auto arrayIter(Array const& x) 
-{ return iterTraits(getArrayishObjectIterator<const_ref_t>(x)); }
+auto arrayIter(Array const& a) 
+{ return range(0, a.size()).map([&](auto i) -> decltype(auto) { return a[i]; }); }
 
 template<class Array>
-auto arrayIter(Array      & x) 
-{ return iterTraits(getArrayishObjectIterator<mut_ref_t>(x)); }
+auto arrayIter(Array      & a) 
+{ return range(0, a.size()).map([&](auto i) -> decltype(auto) { return a[i]; }); }
 
 template<class Array>
-auto arrayIter(Array     && x) 
-{ return iterTraits(ownedArrayishIterator(std::move(x))); }
+auto arrayIter(Array     && a) 
+{ return range(0, a.size()).map([a = std::move(a)](auto i) { return std::move(a[i]); }); }
 
 template<class Iter> 
 class BoxedIter {

Lib/Recycled.hpp

@@ -193,6 +193,10 @@ class Recycled
   T& operator* () { return  self(); }
   T* operator->() { return &self(); }
 
+  auto size() const { return self().size(); }
+  template<class Idx> auto operator[](Idx idx) const { return self()[idx]; }
+  template<class Idx> auto operator[](Idx idx)       { return self()[idx]; }
+
   friend std::ostream& operator<<(std::ostream& out, Recycled const& self)
   { if (self.alive())return out << self.self(); else return out << "Recycled(NULL)"; }
 };
@@ -202,4 +206,17 @@ bool Recycled<T, Reset, Keep>::memAlive = true;
 
 };
 
+template<class T>
+Recycled<Stack<T>> recycledStack() 
+{ return Recycled<Stack<T>>(); }
+
+
+template<class T, class... Ts>
+Recycled<Stack<T>> recycledStack(T t, Ts... ts) 
+{
+  Recycled<Stack<T>> out;
+  out->pushMany(std::move(t), std::move(ts)...);
+  return out;
+}
+
 #endif /*__Recycled__*/