arrays: fix bug in ellipsis when it is of size 0

- a(1,ellipsis()) for a an array<T,1> e.g.,
was not compiling.
- also added const_iterator for range to allow simple code :
  for (auto i : range {3,6}) ....-> i = 3,4,5 as in python

triqs/arrays/indexmaps/range.hpp

@@ -20,26 +20,34 @@
  ******************************************************************************/
 #ifndef TRIQS_ARRAYS_RANGE_H
 #define TRIQS_ARRAYS_RANGE_H
+#include <triqs/utility/first_include.hpp>
 #include <ostream>
+#include <boost/iterator/iterator_facade.hpp>
 
-namespace triqs { namespace arrays { 
+namespace triqs {
+namespace arrays {
 
  /**
   */
  class range {
   std::ptrdiff_t first_, last_, step_;
-  public:
 
+  public:
   typedef std::ptrdiff_t index_type;
 
-  range():first_(0),last_(-1),step_(1) {} // i.e. all
+  range() : first_(0), last_(-1), step_(1) {} // i.e. all
-  range(const range& r):first_(r.first_), last_(r.last_), step_(r.step_) {}
+  range(const range& r) : first_(r.first_), last_(r.last_), step_(r.step_) {}
-  range(std::ptrdiff_t first__, std::ptrdiff_t last__, std::ptrdiff_t step__=1):first_(first__), last_(last__), step_(step__) {}
+  range(std::ptrdiff_t first__, std::ptrdiff_t last__, std::ptrdiff_t step__ = 1)
+     : first_(first__), last_(last__), step_(step__) {}
 
-  std::ptrdiff_t first() const { return first_;}
+  std::ptrdiff_t first() const { return first_; }
-  std::ptrdiff_t last () const { return last_;}
+  std::ptrdiff_t last() const { return last_; }
-  std::ptrdiff_t step() const { return step_;}
+  std::ptrdiff_t step() const { return step_; }
-  size_t size() const { std::ptrdiff_t r = (last_ - first_ + 1)/step_; if (r<0) TRIQS_RUNTIME_ERROR <<" range with negative size"; return size_t(r);}
+  size_t size() const {
+   std::ptrdiff_t r = (last_ - first_ + 1) / step_;
+   if (r < 0) TRIQS_RUNTIME_ERROR << " range with negative size";
+   return size_t(r);
+  }
 
   range operator+(std::ptrdiff_t shift) const { return range(first_ + shift, last_ + shift, step_); }
 
@@ -47,15 +55,38 @@ namespace triqs { namespace arrays {
    os << "range(" << range.first() << "," << range.last() << "," << range.step() << ")";
    return os;
   }
+
+  class const_iterator : public boost::iterator_facade<const_iterator, const std::ptrdiff_t, boost::forward_traversal_tag, const std::ptrdiff_t> {
+   public:
+   const_iterator(range const* r, bool atEnd) {
+    last = r->last();
+    pos = (atEnd ? last : r->first());
+   }
+   private:
+   std::ptrdiff_t last, pos;
+   friend class boost::iterator_core_access;
+   void increment() { ++pos; }
+   bool equal(const_iterator const& other) const { return (other.pos == pos); }
+   std::ptrdiff_t dereference() const { return pos; }
+  };
+
+  const_iterator begin() const { return const_iterator(this, false); }
+  const_iterator end() const { return const_iterator(this, true); }
+  const_iterator cbegin() const { return const_iterator(this,false); }
+  const_iterator cend() const { return const_iterator(this, true); }
  };
 
  /**
   */
  class ellipsis : public range {
-  public :
+  public:
-   ellipsis( std::ptrdiff_t first__, std::ptrdiff_t last__, std::ptrdiff_t step__=1): range(first__, last__, step__) {}
+  ellipsis(std::ptrdiff_t first__, std::ptrdiff_t last__, std::ptrdiff_t step__ = 1) : range(first__, last__, step__) {}
-   ellipsis() : range() {}
+  ellipsis() : range() {}
  };
 
-}}//namespace triqs::arrays  
+ // for the case A(i, ellipsis) where A is of dim 1...
+ inline int operator*(ellipsis, int) { return 0; }
+ inline int operator*(int, ellipsis) { return 0; }
+}
+} // namespace triqs::arrays
 #endif