eina-cxx: Added range types for containers

Summary:
Added inarray, inlist, ptr_array and ptr_list's range types named: range_inarray, range_inlist, range_ptr_array and range_ptr_list.

Each has two "flavours": mutable and not mutable. The const versions are parameterized by a const parameter. For example: range_ptr_list<int const> and the mutable doesn't have the const, so: range_ptr_list<int>.

The difference between the two is that the const versions can't modify the elements from the sequence, while the mutable allows so. Also, the const receives a Eina_Array const* while the mutable must have a Eina_Array*.

Reviewers: cedric

CC: savio, cedric

Differential Revision: https://phab.enlightenment.org/D613

src/bindings/eina_cxx/eina_inarray.hh

@@ -3,6 +3,7 @@
 
 #include <Eina.h>
 #include <eina_type_traits.hh>
+#include <eina_range_types.hh>
 
 #include <iterator>
 #include <cstring>
@@ -10,10 +11,170 @@
 
 namespace efl { namespace eina {
 
+struct _inarray_access_traits {
+
+  template <typename T>
+  struct const_iterator
+  {
+    typedef T const* type;
+  };
+  template <typename T>
+  struct iterator
+  {
+    typedef T* type;
+  };
+  template <typename T>
+  struct const_native_handle
+  {
+    typedef Eina_Inarray const* type;
+  };
+  template <typename T>
+  struct native_handle
+  {
+    typedef Eina_Inarray* type;
+  };
+
+  template <typename T>
+  static Eina_Inarray* native_handle_from_const(Eina_Inarray const* array)
+  {
+    return const_cast<Eina_Inarray*>(array);
+  }
+template <typename T>
+static T& back(Eina_Inarray* raw)
+{
+  assert(!_inarray_access_traits::empty<T>(raw));
+  return *static_cast<T*>( ::eina_inarray_nth(raw, _inarray_access_traits::size<T>(raw)-1u));
+}
+template <typename T>
+static T const& back(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::back<T>(const_cast<Eina_Inarray*>(raw));
+}
+template <typename T>
+static T& front(Eina_Inarray* raw)
+{
+  assert(!empty<T>(raw));
+  return *static_cast<T*>( ::eina_inarray_nth(raw, 0u));
+}
+template <typename T>
+static T const& front(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::front<T>(const_cast<Eina_Inarray*>(raw));
+}
+template <typename T>
+static T* begin(Eina_Inarray* raw)
+{
+  return !raw->members ? 0 : static_cast<T*>( ::eina_inarray_nth(raw, 0u));
+}
+template <typename T>
+static T* end(Eina_Inarray* raw)
+{
+  return !raw->members ? 0
+    : static_cast<T*>( ::eina_inarray_nth(raw, _inarray_access_traits::size<T>(raw) -1)) + 1;
+}
+template <typename T>
+static T const* begin(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::begin<T>(const_cast<Eina_Inarray*>(raw));
+}
+template <typename T>
+static T const* end(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::end<T>(const_cast<Eina_Inarray*>(raw));
+}
+template <typename T>
+static std::reverse_iterator<T const*> rbegin(Eina_Inarray const* raw)
+{
+  return std::reverse_iterator<T const*>(_inarray_access_traits::begin<T>(raw));
+}
+template <typename T>
+static std::reverse_iterator<T const*> rend(Eina_Inarray const* raw)
+{
+  return std::reverse_iterator<T const*>(_inarray_access_traits::end<T>(raw));
+}
+template <typename T>
+static std::reverse_iterator<T*> rbegin(Eina_Inarray* raw)
+{
+  return std::reverse_iterator<T*>(_inarray_access_traits::begin<T>(raw));
+}
+template <typename T>
+static std::reverse_iterator<T*> rend(Eina_Inarray* raw)
+{
+  return std::reverse_iterator<T*>(_inarray_access_traits::end<T>(raw));
+}
+template <typename T>
+static T const* cbegin(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::begin<T>(raw);
+}
+template <typename T>
+static T const* cend(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::end<T>(raw);
+}
+template <typename T>
+static std::reverse_iterator<T const*> crbegin(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::rbegin<T const*>(raw);
+}
+template <typename T>
+static std::reverse_iterator<T const*> crend(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::rend<T const*>(raw);
+}
+template <typename T>
+static inline bool empty(Eina_Inarray const* raw)
+{
+  return _inarray_access_traits::size<T>(raw) == 0;
+}
+template <typename T>
+static inline std::size_t size(Eina_Inarray const* raw)
+{
+  return ::eina_inarray_count(raw);
+}
+template <typename T>
+static T const& index(Eina_Inarray const* raw, std::size_t i)
+{
+  return *(_inarray_access_traits::begin<T>(raw) + i);
+}
+template <typename T>
+static T& index(Eina_Inarray* raw, std::size_t i)
+{
+  return *(_inarray_access_traits::begin<T>(raw) + i);
+}
+
+};
+
+template <typename T>
+struct inarray;
+
+template <typename T>
+struct range_inarray : _range_template<T, _inarray_access_traits>
+{
+  typedef _range_template<T, _inarray_access_traits> _base_type;
+  typedef typename std::remove_const<T>::type value_type;
+
+  range_inarray(Eina_Inarray* array)
+    : _base_type(array)
+  {}
+  range_inarray(inarray<T>& array)
+    : _base_type(array.native_handle())
+  {}
+
+  value_type& operator[](std::size_t index) const
+  {
+    return _inarray_access_traits::index<T>(this->native_handle(), index);
+  }
+};
+
 struct _inarray_common_base
 {
   typedef std::size_t size_type;
+  typedef Eina_Inarray* native_handle_type;
+  typedef Eina_Inarray const* const_native_handle_type;
 
+  explicit _inarray_common_base(Eina_Inarray* array)
+    : _array(array) {}
   explicit _inarray_common_base(size_type member_size)
     : _array( ::eina_inarray_new(member_size, 0) )
   {
@@ -25,12 +186,14 @@ struct _inarray_common_base
   
   size_type size() const
   {
-    return ::eina_inarray_count(_array);
+    return _inarray_access_traits::size<void>(_array);
   }
   bool empty() const
   {
-    return size() == 0u;
+    return _inarray_access_traits::empty<void>(_array);
   }
+  native_handle_type native_handle() { return _array; }
+  const_native_handle_type native_handle() const { return _array; }
 
   Eina_Inarray* _array;
 private:
@@ -52,13 +215,18 @@ public:
   typedef const_pointer const_iterator;
   typedef std::size_t size_type;
   typedef std::ptrdiff_t difference_type;
+  typedef _base_type::native_handle_type native_handle_type;
+  typedef _base_type::const_native_handle_type const_native_handle_type;
 
   typedef std::reverse_iterator<iterator> reverse_iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
   using _base_type::size;
   using _base_type::empty;
+  using _base_type::native_handle;
 
+  _pod_inarray(Eina_Inarray* array)
+    : _base_type(array) {}
   _pod_inarray() : _base_type(sizeof(T))
   {
   }
@@ -98,7 +266,10 @@ public:
   }
   void push_back(T const& value)
   {
+    size_type s = size();
     eina_inarray_push(_array, &value);
+    assert(size() != s);
+    assert(size() == s + 1u);
   }
   void pop_back()
   {
@@ -166,71 +337,77 @@ public:
   void assign(InputIterator i, InputIterator j
               , typename eina::enable_if<!eina::is_integral<InputIterator>::value>::type* = 0);
   void assign(size_type n, value_type const& t);
+  value_type& operator[](size_type i)
+  {
+    return *(begin() + i);
+  }
+  value_type const& operator[](size_type i) const
+  {
+    return const_cast<inarray<T>&>(*this)[i];
+  }
   value_type& back()
   {
-    assert(!empty());
-    return *static_cast<value_type*>(eina_inarray_nth(_array, size()-1u));
+    return _inarray_access_traits::back<value_type>(_array);
   }
   value_type const& back() const
   {
-    return const_cast<_pod_inarray<T>&>(*this).back();
+    return _inarray_access_traits::back<value_type>(_array);
   }
   value_type& front()
   {
-    assert(!empty());
-    return *static_cast<value_type*>(eina_inarray_nth(_array, 0u));
+    return _inarray_access_traits::front<value_type>(_array);
   }
   value_type const& front() const
   {
-    return const_cast<_pod_inarray<T>&>(*this).front();
+    return _inarray_access_traits::front<value_type>(_array);
   }
   iterator begin()
   {
-    return !_array->members ? 0 : static_cast<iterator>(::eina_inarray_nth(_array, 0u));
+    return _inarray_access_traits::begin<value_type>(_array);
   }
   iterator end()
   {
-    return !_array->members ? 0 : static_cast<iterator>(::eina_inarray_nth(_array, size()-1)) + 1;
+    return _inarray_access_traits::end<value_type>(_array);
   }
   const_iterator begin() const
   {
-    return const_cast< _pod_inarray<T>&>(*this).begin();
+    return _inarray_access_traits::begin<value_type>(_array);
   }
   const_iterator end() const
   {
-    return const_cast< _pod_inarray<T>&>(*this).end();
+    return _inarray_access_traits::end<value_type>(_array);
   }
   const_reverse_iterator rbegin() const
   {
-    return const_reverse_iterator(begin());
+    return _inarray_access_traits::rbegin<value_type>(_array);
   }
   const_reverse_iterator rend() const
   {
-    return const_reverse_iterator(end());
+    return _inarray_access_traits::rend<value_type>(_array);
   }
   reverse_iterator rbegin()
   {
-    return reverse_iterator(begin());
+    return _inarray_access_traits::rbegin<value_type>(_array);
   }
   reverse_iterator rend()
   {
-    return reverse_iterator(end());
+    return _inarray_access_traits::rend<value_type>(_array);
   }
   const_iterator cbegin() const
   {
-    return begin();
+    return _inarray_access_traits::cbegin<value_type>(_array);
   }
   const_iterator cend() const
   {
-    return end();
+    return _inarray_access_traits::cend<value_type>(_array);
   }
   const_reverse_iterator crbegin() const
   {
-    return rbegin();
+    return _inarray_access_traits::crbegin<value_type>(_array);
   }
   const_reverse_iterator crend() const
   {
-    return rend();
+    return _inarray_access_traits::crend<value_type>(_array);
   }
   void swap(_pod_inarray<T>& other)
   {
@@ -269,6 +446,8 @@ public:
   using _base_type::size;
   using _base_type::empty;
 
+  _nonpod_inarray(Eina_Inarray* array)
+    : _base_type(array) {}
   _nonpod_inarray() : _base_type(sizeof(T))
   {
   }
@@ -419,71 +598,77 @@ public:
   void assign(InputIterator i, InputIterator j
               , typename eina::enable_if<!eina::is_integral<InputIterator>::value>::type* = 0);
   void assign(size_type n, value_type const& t);
+  value_type& operator[](size_type i)
+  {
+    return *(begin() + i);
+  }
+  value_type const& operator[](size_type i) const
+  {
+    return const_cast<inarray<T>&>(*this)[i];
+  }
   value_type& back()
   {
-    assert(!empty());
-    return *static_cast<value_type*>(eina_inarray_nth(_array, size()-1u));
+    return _inarray_access_traits::back<value_type>(_array);
   }
   value_type const& back() const
   {
-    return const_cast<_nonpod_inarray<T>&>(*this).back();
+    return _inarray_access_traits::back<value_type>(_array);
   }
   value_type& front()
   {
-    assert(!empty());
-    return *static_cast<value_type*>(eina_inarray_nth(_array, 0u));
+    return _inarray_access_traits::front<value_type>(_array);
   }
   value_type const& front() const
   {
-    return const_cast<_nonpod_inarray<T>&>(*this).front();
+    return _inarray_access_traits::front<value_type>(_array);
   }
   iterator begin()
   {
-    return static_cast<iterator>(_array->members);
+    return _inarray_access_traits::begin<value_type>(_array);
   }
   iterator end()
   {
-    return static_cast<iterator>(_array->members) + _array->len;
+    return _inarray_access_traits::end<value_type>(_array);
   }
   const_iterator begin() const
   {
-    return const_cast< _nonpod_inarray<T>&>(*this).begin();
+    return _inarray_access_traits::begin<value_type>(_array);
   }
   const_iterator end() const
   {
-    return const_cast< _nonpod_inarray<T>&>(*this).end();
+    return _inarray_access_traits::end<value_type>(_array);
   }
   const_reverse_iterator rbegin() const
   {
-    return const_reverse_iterator(begin());
+    return _inarray_access_traits::rbegin<value_type>(_array);
   }
   const_reverse_iterator rend() const
   {
-    return const_reverse_iterator(end());
+    return _inarray_access_traits::rend<value_type>(_array);
   }
   reverse_iterator rbegin()
   {
-    return reverse_iterator(begin());
+    return _inarray_access_traits::rbegin<value_type>(_array);
   }
   reverse_iterator rend()
   {
-    return reverse_iterator(end());
+    return _inarray_access_traits::rend<value_type>(_array);
   }
   const_iterator cbegin() const
   {
-    return begin();
+    return _inarray_access_traits::cbegin<value_type>(_array);
   }
   const_iterator cend() const
   {
-    return end();
+    return _inarray_access_traits::cend<value_type>(_array);
   }
   const_reverse_iterator crbegin() const
   {
-    return rbegin();
+    return _inarray_access_traits::crbegin<value_type>(_array);
   }
   const_reverse_iterator crend() const
   {
-    return rend();
+    return _inarray_access_traits::crend<value_type>(_array);
   }
   void swap(_nonpod_inarray<T>& other)
   {
@@ -508,6 +693,8 @@ class inarray : public eina::if_<eina::is_pod<T>, _pod_inarray<T>
   typedef typename eina::if_<eina::is_pod<T>, _pod_inarray<T>
                              , _nonpod_inarray<T> >::type _base_type;
 public:
+  inarray(Eina_Inarray* array)
+    : _base_type(array) {}
   inarray() : _base_type() {}
   inarray(typename _base_type::size_type n, typename _base_type::value_type const& t)
     : _base_type(n, t) {}
@@ -539,7 +726,6 @@ void swap(inarray<T>& lhs, inarray<T>& rhs)
 }
 
 
-
 } }
 
 #endif

src/bindings/eina_cxx/eina_inlist.hh

@@ -5,8 +5,10 @@
 #include <eina_lists_auxiliary.hh>
 #include <eina_type_traits.hh>
 #include <eina_accessor.hh>
+#include <eina_range_types.hh>
 
 #include <iterator>
+#include <algorithm>
 
 namespace efl { namespace eina {
 
@@ -47,19 +49,21 @@ Eina_Inlist const* _get_list(_inlist_node<T> const* n)
 template <typename T>
 struct _inlist_iterator
 {
-  typedef T value_type;
-  typedef T* pointer;
-  typedef T& reference;
+  typedef typename std::remove_const<T>::type value_type;
+  typedef value_type* pointer;
+  typedef value_type& reference;
   typedef std::ptrdiff_t difference_type;
   typedef std::bidirectional_iterator_tag iterator_category;
 
   _inlist_iterator() {}
-  explicit _inlist_iterator(_inlist_node<T>* list, _inlist_node<T>* node)
+  explicit _inlist_iterator(_inlist_node<value_type>* list, _inlist_node<value_type>* node)
     : _list(list), _node(node) {}
+  _inlist_iterator(_inlist_iterator<typename std::remove_const<T>::type> const& other)
+    : _list(other._list), _node(other._node) {}
 
   _inlist_iterator<T>& operator++()
   {
-    _node = _get_node<T>(_node->__in_list.next);
+    _node = _get_node<value_type>(_node->__in_list.next);
     return *this;
   }
   _inlist_iterator<T> operator++(int)
@@ -71,9 +75,9 @@ struct _inlist_iterator
   _inlist_iterator<T>& operator--()
   {
     if(_node)
-      _node = _get_node<T>(_node->__in_list.prev);
+      _node = _get_node<value_type>(_node->__in_list.prev);
     else
-      _node = _get_node<T>(_list->__in_list.last);
+      _node = _get_node<value_type>(_list->__in_list.last);
     return *this;
   }
   _inlist_iterator<T> operator--(int)
@@ -82,26 +86,28 @@ struct _inlist_iterator
     --*this;
     return tmp;
   }
-  T const& operator*() const
+  T& operator*() const
   {
     return _node->object;
   }
-  T const* operator->() const
+  T* operator->() const
   {
     return &_node->object;
   }
-  _inlist_node<T>* native_handle()
+  _inlist_node<value_type>* native_handle()
   {
     return _node;
   }
-  _inlist_node<T> const* native_handle() const
+  _inlist_node<value_type> const* native_handle() const
   {
     return _node;
   }
 private:
-  _inlist_node<T>* _list;
-  _inlist_node<T>* _node;
+  _inlist_node<value_type>* _list;
+  _inlist_node<value_type>* _node;
 
+  template <typename U>
+  friend struct _inlist_iterator;
   friend bool operator==(_inlist_iterator<T> lhs, _inlist_iterator<T> rhs)
   {
     return lhs._node == rhs._node;
@@ -114,6 +120,154 @@ bool operator!=(_inlist_iterator<T> lhs, _inlist_iterator<T> rhs)
   return !(lhs == rhs);
 }
 
+struct _inlist_access_traits {
+  template <typename T>
+  struct const_iterator
+  {
+    typedef _inlist_iterator<T const> type;
+  };
+  template <typename T>
+  struct iterator
+  {
+    typedef _inlist_iterator<T> type;
+  };
+  template <typename T>
+  struct const_native_handle
+  {
+    typedef Eina_Inlist const* type;
+  };
+  template <typename T>
+  struct native_handle
+  {
+    typedef Eina_Inlist* type;
+  };
+
+  template <typename T>
+  static Eina_Inlist* native_handle_from_const(Eina_Inlist const* list)
+  {
+    return const_cast<Eina_Inlist*>(list);
+  }
+  template <typename T>
+  static std::size_t size(Eina_Inlist const* list)
+  {
+    return ::eina_inlist_count(list);
+  }
+  template <typename T>
+  static bool empty(Eina_Inlist const* list)
+  {
+    return list == 0;
+  }
+  template <typename T>
+  static T& back(Eina_Inlist* list)
+  {
+    return _get_node<T>(list->last)->object;
+  }
+  template <typename T>
+  static T const& back(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::back<T>(const_cast<Eina_Inlist*>(list));
+  }
+  template <typename T>
+  static T& front(Eina_Inlist* list)
+  {
+    return _get_node<T>(list)->object;
+  }
+  template <typename T>
+  static T const& front(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::front<T>(const_cast<Eina_Inlist*>(list));
+  }
+  template <typename T>
+  static _inlist_iterator<T const> begin(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::begin<T>(const_cast<Eina_Inlist*>(list));
+  }
+  template <typename T>
+  static _inlist_iterator<T const> end(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::end<T>(const_cast<Eina_Inlist*>(list));
+  }
+  template <typename T>
+  static _inlist_iterator<T> begin(Eina_Inlist* list)
+  {
+    return _inlist_iterator<T>(_get_node<T>(list), _get_node<T>(list));
+  }
+  template <typename T>
+  static _inlist_iterator<T> end(Eina_Inlist* list)
+  {
+    return _inlist_iterator<T>(_get_node<T>(list), 0);
+  }
+  template <typename T>
+  static std::reverse_iterator<_inlist_iterator<T> > rbegin(Eina_Inlist* list)
+  {
+    return std::reverse_iterator<_inlist_iterator<T> >(_inlist_access_traits::begin<T>(list));
+  }
+  template <typename T>
+  static std::reverse_iterator<_inlist_iterator<T> > rend(Eina_Inlist* list)
+  {
+    return std::reverse_iterator<_inlist_iterator<T> >(_inlist_access_traits::end<T>(list));
+  }
+  template <typename T>
+  static std::reverse_iterator<_inlist_iterator<T const> > rbegin(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::rbegin<T>(const_cast<Eina_Inlist*>(list));
+  }
+  template <typename T>
+  static std::reverse_iterator<_inlist_iterator<T const> > rend(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::rend<T>(const_cast<Eina_Inlist*>(list));
+  }
+  template <typename T>
+  static _inlist_iterator<T const> cbegin(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::begin<T>(list);
+  }
+  template <typename T>
+  static _inlist_iterator<T const> cend(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::end<T>(list);
+  }
+  template <typename T>
+  static std::reverse_iterator<_inlist_iterator<T const> > crbegin(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::rbegin<T>(list);
+  }
+  template <typename T>
+  static std::reverse_iterator<_inlist_iterator<T const> > crend(Eina_Inlist const* list)
+  {
+    return _inlist_access_traits::rend<T>(list);
+  }
+};
+
+template <typename T, typename Allocator>
+struct inlist;
+
+template <typename T>
+struct range_inlist : _range_template<T, _inlist_access_traits>
+{
+  typedef _range_template<T, _inlist_access_traits> _base_type;
+  typedef typename _base_type::value_type value_type;
+
+  range_inlist(Eina_Inlist* list)
+    : _base_type(list) {}
+  template <typename Allocator>
+  range_inlist(inlist<value_type, Allocator>& list)
+    : _base_type(list.native_handle())
+  {}
+};
+
+template <typename T>
+bool operator==(range_inlist<T>const& lhs, range_inlist<T>const& rhs)
+{
+  return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+template <typename U>
+bool operator!=(range_inlist<U> const& lhs, range_inlist<U>const& rhs)
+{
+  return !(lhs == rhs);
+}
+
 template <typename T, typename Allocator>
 struct _inlist_common_base
 {
@@ -221,11 +375,11 @@ public:
   }
   size_type size() const
   {
-    return ::eina_inlist_count(this->_impl._list);
+    return _inlist_access_traits::size<T>(native_handle());
   }
   bool empty() const
   {
-    return this->_impl._list == 0;
+    return _inlist_access_traits::empty<T>(native_handle());
   }
   allocator_type get_allocator() const
   {
@@ -351,42 +505,41 @@ public:
     clear();
     insert(end(), n, t);
   }
-
   value_type& back()
   {
-    return _get_node<T>(this->_impl._list->last)->object;
+    return _inlist_access_traits::back<T>(native_handle());
   }
   value_type const& back() const
   {
-    return const_cast<inlist<T, Allocator>&>(*this).back();
+    return _inlist_access_traits::back<T>(native_handle());
   }
   value_type& front()
   {
-    return _get_node<T>(this->_impl._list)->object;
+    return _inlist_access_traits::front<T>(native_handle());
   }
   value_type const& front() const
   {
-    return const_cast<inlist<T, Allocator>&>(*this).front();
+    return _inlist_access_traits::front<T>(native_handle());
   }
   const_iterator begin() const
   {
-    return const_iterator(_get_node<T const>(this->_impl._list), _get_node<T const>(this->_impl._list));
+    return _inlist_access_traits::begin<T>(native_handle());
   }
   const_iterator end() const
   {
-    return const_iterator(_get_node<T const>(this->_impl._list), 0);
+    return _inlist_access_traits::end<T>(native_handle());
   }
   iterator begin()
   {
-    return iterator(_get_node<T>(this->_impl._list), _get_node<T>(this->_impl._list));
+    return _inlist_access_traits::begin<T>(native_handle());
   }
   iterator end()
   {
-    return iterator(_get_node<T>(this->_impl._list), 0);
+    return _inlist_access_traits::end<T>(native_handle());
   }
   const_reverse_iterator rbegin() const
   {
-    return const_reverse_iterator(begin());
+    return _inlist_access_traits::end<T>(this->_impl._list);
   }
   const_reverse_iterator rend() const
   {

src/bindings/eina_cxx/eina_ptrarray.hh

@@ -3,8 +3,8 @@
 
 #include <Eina.h>
 #include <eina_clone_allocators.hh>
-#include <eina_lists_auxiliary.hh>
 #include <eina_type_traits.hh>
+#include <eina_range_types.hh>
 
 #include <memory>
 #include <iterator>
@@ -13,18 +13,8 @@
 
 namespace efl { namespace eina {
 
-struct _ptr_array_iterator_base
-{
-  _ptr_array_iterator_base() : _ptr(0) {}
-  _ptr_array_iterator_base(void** ptr)
-    : _ptr(ptr)
-  {}
-
-  void** _ptr;
-};
-
 template <typename T>
-struct _ptr_array_iterator : protected _ptr_array_iterator_base
+struct _ptr_array_iterator
 {
   typedef T value_type;
   typedef value_type* pointer;
@@ -32,17 +22,16 @@ struct _ptr_array_iterator : protected _ptr_array_iterator_base
   typedef std::ptrdiff_t difference_type;
   typedef std::bidirectional_iterator_tag iterator_category;
 
-  _ptr_array_iterator() {}
+  _ptr_array_iterator() : _ptr(0) {}
   explicit _ptr_array_iterator(void** ptr)
-    : _ptr_array_iterator_base(ptr)
+    : _ptr(ptr)
 
   {
   }
   _ptr_array_iterator(_ptr_array_iterator<typename remove_cv<value_type>::type> const& other)
-    : _ptr_array_iterator_base(static_cast<_ptr_array_iterator_base const&>(other))
+    : _ptr(other._ptr)
   {
   }
-
   _ptr_array_iterator<T>& operator++()
   {
     ++_ptr;
@@ -77,6 +66,9 @@ struct _ptr_array_iterator : protected _ptr_array_iterator_base
   {
     return _ptr;
   }
+private:
+  template <typename U>
+  friend struct _ptr_array_iterator;
   friend inline bool operator==(_ptr_array_iterator<T> lhs, _ptr_array_iterator<T> rhs)
   {
     return lhs._ptr == rhs._ptr;
@@ -102,6 +94,190 @@ struct _ptr_array_iterator : protected _ptr_array_iterator_base
   {
     return lhs._ptr - rhs._ptr;
   }
+
+  void** _ptr;
+};
+
+struct _ptr_array_access_traits {
+
+template <typename T>
+
+struct iterator
+{
+  typedef _ptr_array_iterator<T> type;
+};
+template <typename T>
+struct const_iterator : iterator<T const>
+{
+};
+template <typename T>
+struct native_handle
+{
+  typedef Eina_Array* type;
+};
+template <typename T>
+struct const_native_handle
+{
+  typedef Eina_Array const* type;
+};
+template <typename T>
+static Eina_Array* native_handle_from_const(Eina_Array const* array)
+{
+  return const_cast<Eina_Array*>(array);
+}
+template <typename T>
+static T& back(Eina_Array* array)
+{
+  return *static_cast<T*>(array->data[size<T>(array)-1]);
+}
+template <typename T>
+static T const& back(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::back<T>(const_cast<Eina_Array*>(array));
+}
+template <typename T>
+static T& front(Eina_Array* array)
+{
+  return *static_cast<T*>(array->data[0]);
+}
+template <typename T>
+static T const& front(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::front<T>(const_cast<Eina_Array*>(array));
+}
+template <typename T>
+static T& index(Eina_Array* array, std::size_t index)
+{
+  return *static_cast<T*>(array->data[index]);
+}
+template <typename T>
+static T const& index(Eina_Array const* array, std::size_t index)
+{
+  return _ptr_array_access_traits::index<T>(const_cast<Eina_Array*>(array), index);
+}
+template <typename T>
+static _ptr_array_iterator<T> begin(Eina_Array* array)
+{
+  return _ptr_array_iterator<T>(array->data);
+}
+template <typename T>
+static _ptr_array_iterator<T> end(Eina_Array* array)
+{
+  return _ptr_array_iterator<T>(array->data + size<T>(array));
+}
+template <typename T>
+static _ptr_array_iterator<T> begin(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::begin<T>(const_cast<Eina_Array*>(array));
+}
+template <typename T>
+static _ptr_array_iterator<T> end(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::end<T>(const_cast<Eina_Array*>(array));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_array_iterator<T> > rbegin(Eina_Array* array)
+{
+  return std::reverse_iterator<_ptr_array_iterator<T> >(_ptr_array_access_traits::begin<T>(array));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_array_iterator<T> > rend(Eina_Array* array)
+{
+  return std::reverse_iterator<_ptr_array_iterator<T> >(_ptr_array_access_traits::end<T>(array));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_array_iterator<T const> > rbegin(Eina_Array const* array)
+{
+  return std::reverse_iterator<_ptr_array_iterator<T const> >(_ptr_array_access_traits::begin<T>(const_cast<Eina_Array*>(array)));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_array_iterator<T const> > rend(Eina_Array const* array)
+{
+  return std::reverse_iterator<_ptr_array_iterator<T const> >(_ptr_array_access_traits::end<T>(const_cast<Eina_Array*>(array)));
+}
+template <typename T>
+static _ptr_array_iterator<T const> cbegin(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::begin<T>(array);
+}
+template <typename T>
+static _ptr_array_iterator<T const> cend(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::end<T>(array);
+}
+template <typename T>
+static std::reverse_iterator<_ptr_array_iterator<T const> > crbegin(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::rbegin<T>(array);
+}
+template <typename T>
+static std::reverse_iterator<_ptr_array_iterator<T const> > crend(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::rend<T>(array);
+}
+template <typename T>
+static eina::iterator<T> ibegin(Eina_Array* array)
+{
+  return eina::iterator<T>( ::eina_array_iterator_new(array) );
+}
+template <typename T>
+static eina::iterator<T> iend(Eina_Array* array)
+{
+  return eina::iterator<T>();
+}
+template <typename T>
+static eina::iterator<T const> ibegin(Eina_Array const* array)
+{
+  return eina::iterator<T const>( ::eina_array_iterator_new(array) );
+}
+template <typename T>
+static eina::iterator<T const> iend(Eina_Array const* array)
+{
+  return eina::iterator<T const>();
+}
+template <typename T>
+static eina::iterator<T const> cibegin(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::ibegin<T>(array);
+}
+template <typename T>
+static eina::iterator<T const> ciend(Eina_Array const* array)
+{
+  return _ptr_array_access_traits::iend<T>(array);
+}
+template <typename T>
+static std::size_t size(Eina_Array const* array)
+{
+  return eina_array_count(array);
+}
+template <typename T>
+static bool empty(Eina_Array const* array)
+{
+  return size<T>(array) == 0u;
+}
+
+};
+
+template <typename T, typename Allocator>
+struct ptr_array;
+
+template <typename T>
+struct range_ptr_array : _range_template<T, _ptr_array_access_traits>
+{
+  typedef _range_template<T, _ptr_array_access_traits> _base_type;
+  typedef typename _base_type::value_type value_type;
+
+  range_ptr_array(Eina_Array* array)
+    : _base_type(array)
+  {}
+  template <typename Allocator>
+  range_ptr_array(ptr_array<value_type, Allocator>& array)
+    : _base_type(array.native_handle())
+  {}
+  value_type& operator[](std::size_t index) const
+  {
+    return _ptr_array_access_traits::index<T>(this->native_handle(), index);
+  }
 };
 
 template <typename T, typename CloneAllocator>
@@ -344,107 +520,101 @@ public:
     clear();
     insert(end(), n, t);
   }
-
   value_type& back()
   {
-    return *static_cast<pointer>(this->_impl._array->data[size()-1]);
+    return _ptr_array_access_traits::back<T>(this->_impl._array);
   }
   value_type const& back() const
   {
-    return const_cast<ptr_array<T, CloneAllocator>&>(*this).back();
+    return _ptr_array_access_traits::back<T>(this->_impl._array);
   }
   value_type& front()
   {
-    return *static_cast<pointer>(this->_impl._array->data[0]);
+    return _ptr_array_access_traits::front<T>(this->_impl._array);
   }
   value_type const& front() const
   {
-    return const_cast<ptr_array<T, CloneAllocator>&>(*this).front();
+    return _ptr_array_access_traits::front<T>(this->_impl._array);
   }
-
   const_reference operator[](size_type index) const
   {
-    pointer data = static_cast<pointer>
-      (this->_impl._array->data[index]);
-    return *data;
+    return _ptr_array_access_traits::index<T>(this->_impl._array, index);
   }
   reference operator[](size_type index)
   {
-    return const_cast<reference>
-      (const_cast<ptr_array<T, CloneAllocator>const&>(*this)[index]);
+    return _ptr_array_access_traits::index<T>(this->_impl._array, index);
   }
-
   const_iterator begin() const
   {
-    return const_iterator(this->_impl._array->data);
+    return _ptr_array_access_traits::begin<T>(this->_impl._array);
   }
   const_iterator end() const
   {
-    return const_iterator(this->_impl._array->data + size());
+    return _ptr_array_access_traits::end<T>(this->_impl._array);
   }
   iterator begin()
   {
-    return iterator(this->_impl._array->data);
+    return _ptr_array_access_traits::begin<T>(this->_impl._array);
   }
   iterator end()
   {
-    return iterator(this->_impl._array->data + size());
+    return _ptr_array_access_traits::end<T>(this->_impl._array);
   }
   const_reverse_iterator rbegin() const
   {
-    return const_reverse_iterator(begin());
+    return _ptr_array_access_traits::rbegin<T>(this->_impl._array);
   }
   const_reverse_iterator rend() const
   {
-    return const_reverse_iterator(end());
+    return _ptr_array_access_traits::rend<T>(this->_impl._array);
   }
   reverse_iterator rbegin()
   {
-    return reverse_iterator(begin());
+    return _ptr_array_access_traits::rbegin<T>(this->_impl._array);
   }
   reverse_iterator rend()
   {
-    return reverse_iterator(end());
+    return _ptr_array_access_traits::rend<T>(this->_impl._array);
   }
   const_iterator cbegin() const
   {
-    return begin();
+    return _ptr_array_access_traits::cbegin<T>(this->_impl._array);
   }
   const_iterator cend() const
   {
-    return end();
+    return _ptr_array_access_traits::cend<T>(this->_impl._array);
   }
   const_reverse_iterator crbegin() const
   {
-    return rbegin();
+    return _ptr_array_access_traits::crbegin<T>(this->_impl._array);
   }
   const_reverse_iterator crend() const
   {
-    return rend();
+    return _ptr_array_access_traits::crend<T>(this->_impl._array);
   }
   eina::iterator<T> ibegin()
   {
-    return eina::iterator<T>( ::eina_array_iterator_new(this->_impl._array) );
+    return _ptr_array_access_traits::ibegin<T>(this->_impl._array);
   }
   eina::iterator<T> iend()
   {
-    return eina::iterator<T>();
+    return _ptr_array_access_traits::iend<T>(this->_impl._array);
   }
   eina::iterator<T const> ibegin() const
   {
-    return eina::iterator<T const>( ::eina_array_iterator_new(this->_impl._array) );
+    return _ptr_array_access_traits::ibegin<T>(this->_impl._array);
   }
   eina::iterator<T const> iend() const
   {
-    return eina::iterator<T const>();
+    return _ptr_array_access_traits::iend<T>(this->_impl._array);
   }
   eina::iterator<T const> cibegin() const
   {
-    return ibegin();
+    return _ptr_array_access_traits::cibegin<T>(this->_impl._array);
   }
   eina::iterator<T const> ciend() const
   {
-    return iend();
+    return _ptr_array_access_traits::ciend<T>(this->_impl._array);
   }
   void swap(ptr_array<T, CloneAllocator>& other)
   {

src/bindings/eina_cxx/eina_ptrlist.hh

@@ -29,7 +29,7 @@ protected:
 template <typename T>
 struct _ptr_list_iterator : _ptr_list_iterator_base
 {
-  typedef T value_type;
+  typedef typename remove_cv<T>::type value_type;
   typedef value_type* pointer;
   typedef value_type& reference;
 
@@ -38,7 +38,7 @@ struct _ptr_list_iterator : _ptr_list_iterator_base
     : _ptr_list_iterator_base(list, node)
   {
   }
-  _ptr_list_iterator(_ptr_list_iterator<typename remove_cv<value_type>::type> const& other)
+  _ptr_list_iterator(_ptr_list_iterator<value_type> const& other)
     : _ptr_list_iterator_base(static_cast<_ptr_list_iterator_base const&>(other))
   {
   }
@@ -95,6 +95,308 @@ struct _ptr_list_iterator : _ptr_list_iterator_base
   }
 };
 
+struct _ptr_list_access_traits {
+
+template <typename T>
+struct iterator
+{
+  typedef _ptr_list_iterator<T> type;
+};
+template <typename T>
+struct const_iterator : iterator<T const> {};
+template <typename T>
+struct native_handle
+{
+  typedef Eina_List* type;
+};
+template <typename T>
+struct const_native_handle
+{
+  typedef Eina_List const* type;
+};
+template <typename T>
+static Eina_List* native_handle_from_const(Eina_List const* list)
+{
+  return const_cast<Eina_List*>(list);
+}
+template <typename T>
+static T& back(Eina_List* list)
+{
+  return *static_cast<T*>(eina_list_data_get(eina_list_last(list)));
+}
+template <typename T>
+static T const& back(Eina_List const* list)
+{
+  return _ptr_list_access_traits::back<T>(const_cast<Eina_List*>(list));
+}
+template <typename T>
+static T& front(Eina_List* list)
+{
+  return *static_cast<T*>(eina_list_data_get(list));
+}
+template <typename T>
+static T const& front(Eina_List const* list)
+{
+  return _ptr_list_access_traits::front<T>(const_cast<Eina_List*>(list));
+}
+template <typename T>
+static _ptr_list_iterator<T> begin(Eina_List* list)
+{
+  return _ptr_list_iterator<T>(list, list);
+}
+template <typename T>
+static _ptr_list_iterator<T> end(Eina_List* list)
+{
+  return _ptr_list_iterator<T>(list, 0);
+}
+template <typename T>
+static _ptr_list_iterator<T const> begin(Eina_List const* list)
+{
+  return _ptr_list_access_traits::begin<T>(const_cast<Eina_List*>(list));
+}
+template <typename T>
+static _ptr_list_iterator<T const> end(Eina_List const* list)
+{
+  return _ptr_list_access_traits::end<T>(const_cast<Eina_List*>(list));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_list_iterator<T> > rbegin(Eina_List* list)
+{
+  return std::reverse_iterator<_ptr_list_iterator<T> >(_ptr_list_access_traits::begin<T>(list));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_list_iterator<T> > rend(Eina_List* list)
+{
+  return std::reverse_iterator<_ptr_list_iterator<T> >(_ptr_list_access_traits::end<T>(list));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_list_iterator<T const> > rbegin(Eina_List const* list)
+{
+  return _ptr_list_access_traits::rbegin<T>(const_cast<Eina_List*>(list));
+}
+template <typename T>
+static std::reverse_iterator<_ptr_list_iterator<T const> > rend(Eina_List const* list)
+{
+  return _ptr_list_access_traits::rend<T>(const_cast<Eina_List*>(list));
+}
+template <typename T>
+static _ptr_list_iterator<T const> cbegin(Eina_List const* list)
+{
+  return _ptr_list_access_traits::begin<T>(list);
+}
+template <typename T>
+static _ptr_list_iterator<T const> cend(Eina_List const* list)
+{
+  return _ptr_list_access_traits::end<T>(list);
+}
+template <typename T>
+static std::reverse_iterator<_ptr_list_iterator<T const> > crbegin(Eina_List const* list)
+{
+  return _ptr_list_access_traits::rbegin<T>(list);
+}
+template <typename T>
+static std::reverse_iterator<_ptr_list_iterator<T const> > crend(Eina_List const* list)
+{
+  return _ptr_list_access_traits::rend<T>(list);
+}
+template <typename T>
+static eina::iterator<T> ibegin(Eina_List* list)
+{
+  return eina::iterator<T>( ::eina_list_iterator_new(list) );
+}
+template <typename T>
+static eina::iterator<T> iend(Eina_List*)
+{
+  return eina::iterator<T>();
+}
+template <typename T>
+static eina::iterator<T const> ibegin(Eina_List const* list)
+{
+  return eina::iterator<T const>( ::eina_list_iterator_new(list) );
+}
+template <typename T>
+static eina::iterator<T const> iend(Eina_List const* list)
+{
+  return eina::iterator<T const>();
+}
+template <typename T>
+static eina::iterator<T const> cibegin(Eina_List const* list)
+{
+  return _ptr_list_access_traits::ibegin<T>(list);
+}
+template <typename T>