using _base_type::native_handle;
};
+/**
+ * @internal
+ */
+struct _eo_list_access_traits : _ptr_list_access_traits
+{
+ template <typename T>
+ struct iterator
+ {
+ typedef _ptr_eo_list_iterator<T> type;
+ };
+ template <typename T>
+ struct const_iterator : iterator<T const> {};
+ template <typename T>
+ static T& back(Eina_List* list)
+ {
+ return *static_cast<T*>(static_cast<void*>(&eina_list_last(list)->data));
+ }
+ template <typename T>
+ static T const& back(Eina_List const* list)
+ {
+ return _eo_list_access_traits::back<T>(const_cast<Eina_List*>(list));
+ }
+ template <typename T>
+ static T& front(Eina_List* list)
+ {
+ return *static_cast<T*>(static_cast<void*>(&list->data));
+ }
+ template <typename T>
+ static T const& front(Eina_List const* list)
+ {
+ return _eo_list_access_traits::front<T>(const_cast<Eina_List*>(list));
+ }
+ template <typename T>
+ static typename iterator<T>::type begin(Eina_List* list)
+ {
+ return typename iterator<T>::type(list, list);
+ }
+ template <typename T>
+ static typename iterator<T>::type end(Eina_List* list)
+ {
+ return typename iterator<T>::type(list, nullptr);
+ }
+ template <typename T>
+ static typename const_iterator<T>::type begin(Eina_List const* list)
+ {
+ return _eo_list_access_traits::begin<T>(const_cast<Eina_List*>(list));
+ }
+ template <typename T>
+ static typename const_iterator<T>::type end(Eina_List const* list)
+ {
+ return _eo_list_access_traits::end<T>(const_cast<Eina_List*>(list));
+ }
+ template <typename T>
+ static std::reverse_iterator<typename iterator<T>::type> rbegin(Eina_List* list)
+ {
+ return std::reverse_iterator<typename iterator<T>::type>(_eo_list_access_traits::end<T>(list));
+ }
+ template <typename T>
+ static std::reverse_iterator<typename iterator<T>::type> rend(Eina_List* list)
+ {
+ return std::reverse_iterator<typename iterator<T>::type>(_eo_list_access_traits::begin<T>(list));
+ }
+ template <typename T>
+ static std::reverse_iterator<typename const_iterator<T>::type> rbegin(Eina_List const* list)
+ {
+ return _eo_list_access_traits::rbegin<T>(const_cast<Eina_List*>(list));
+ }
+ template <typename T>
+ static std::reverse_iterator<typename const_iterator<T>::type> rend(Eina_List const* list)
+ {
+ return _eo_list_access_traits::rend<T>(const_cast<Eina_List*>(list));
+ }
+ template <typename T>
+ static typename const_iterator<T>::type cbegin(Eina_List const* list)
+ {
+ return _eo_list_access_traits::begin<T>(list);
+ }
+ template <typename T>
+ static typename const_iterator<T>::type cend(Eina_List const* list)
+ {
+ return _eo_list_access_traits::end<T>(list);
+ }
+ template <typename T>
+ static std::reverse_iterator<typename const_iterator<T>::type> crbegin(Eina_List const* list)
+ {
+ return _eo_list_access_traits::rbegin<T>(list);
+ }
+ template <typename T>
+ static std::reverse_iterator<typename const_iterator<T>::type> crend(Eina_List const* list)
+ {
+ return _eo_list_access_traits::rend<T>(list);
+ }
+};
+
template <typename T, typename CloneAllocator = default_clone_allocator_placeholder, typename Enable = void>
class list : ptr_list<T, typename std::conditional
<std::is_same<CloneAllocator, default_clone_allocator_placeholder>::value
reference front()
{
- return *static_cast<pointer>(static_cast<void*>(&native_handle()->data));
+ return _eo_list_access_traits::front<value_type>(native_handle());
}
reference back()
{
- return *static_cast<pointer>(static_cast<void*>(&eina_list_last(native_handle())->data));
+ return _eo_list_access_traits::back<value_type>(native_handle());
}
const_reference front() const { return const_cast<_self_type*>(this)->front(); }
const_reference back() const { return const_cast<_self_type*>(this)->back(); }
iterator begin()
{
- return iterator(native_handle(), native_handle());
+ return _eo_list_access_traits::begin<value_type>(native_handle());
}
iterator end()
{
- return iterator(native_handle(), nullptr);
+ return _eo_list_access_traits::end<value_type>(native_handle());
}
const_iterator begin() const
{
}
reverse_iterator rbegin()
{
- return reverse_iterator(end());
+ return _eo_list_access_traits::rbegin<value_type>(native_handle());
}
reverse_iterator rend()
{
- return reverse_iterator(begin());
+ return _eo_list_access_traits::rend<value_type>(native_handle());
}
const_reverse_iterator rbegin() const
{
{
return !(rhs == lhs);
}
+
+template <typename T, typename Enable = void>
+class range_list : range_ptr_list<T>
+{
+ typedef range_ptr_list<T> _base_type;
+public:
+ typedef typename _base_type::value_type value_type;
+ typedef typename _base_type::reference reference;
+ typedef typename _base_type::const_reference const_reference;
+ typedef typename _base_type::const_iterator const_iterator;
+ typedef typename _base_type::iterator iterator;
+ typedef typename _base_type::pointer pointer;
+ typedef typename _base_type::const_pointer const_pointer;
+ typedef typename _base_type::size_type size_type;
+ typedef typename _base_type::difference_type difference_type;
+ typedef typename _base_type::clone_allocator_type clone_allocator_type;
+
+ typedef typename _base_type::reverse_iterator reverse_iterator;
+ typedef typename _base_type::const_reverse_iterator const_reverse_iterator;
+
+ using _base_type::_base_type;
+ using _base_type::clear;
+ using _base_type::size;
+ using _base_type::empty;
+ using _base_type::get_clone_allocator;
+ using _base_type::push_back;
+ using _base_type::push_front;
+ using _base_type::pop_back;
+ using _base_type::pop_front;
+ using _base_type::insert;
+ using _base_type::erase;
+ using _base_type::assign;
+ using _base_type::back;
+ using _base_type::front;
+ using _base_type::begin;
+ using _base_type::end;
+ using _base_type::rbegin;
+ using _base_type::rend;
+ using _base_type::cbegin;
+ using _base_type::cend;
+ using _base_type::crbegin;
+ using _base_type::crend;
+ using _base_type::ibegin;
+ using _base_type::iend;
+ using _base_type::cibegin;
+ using _base_type::ciend;
+ using _base_type::swap;
+ using _base_type::max_size;
+ using _base_type::native_handle;
+ using _base_type::accessor;
+};
+
+template <typename T>
+class range_list<T, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>::type>
+ : range_ptr_list<Eo>
+{
+ typedef range_ptr_list<Eo> _base_type;
+ typedef range_list<T> _self_type;
+public:
+ typedef T value_type;
+ typedef value_type& reference;
+ typedef value_type const& const_reference;
+ typedef _ptr_eo_list_iterator<value_type const> const_iterator;
+ typedef _ptr_eo_list_iterator<value_type> iterator;
+ typedef value_type* pointer;
+ typedef value_type const* const_pointer;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ explicit range_list(Eina_List* handle)
+ : _base_type(handle) {}
+ range_list() {}
+ range_list(range_list<T> const& other)
+ : _base_type(other.native_handle())
+ {
+ }
+ range_list<T>& operator=(range_list<T>const& other)
+ {
+ _base_type::_handle = other._handle;
+ return *this;
+ }
+
+ using _base_type::size;
+ using _base_type::empty;
+
+ reference front()
+ {
+ return _eo_list_access_traits::front<value_type>(native_handle());
+ }
+ reference back()
+ {
+ return _eo_list_access_traits::back<value_type>(native_handle());
+ }
+ const_reference front() const { return const_cast<_self_type*>(this)->front(); }
+ const_reference back() const { return const_cast<_self_type*>(this)->back(); }
+ iterator begin()
+ {
+ return _eo_list_access_traits::begin<value_type>(native_handle());
+ }
+ iterator end()
+ {
+ return _eo_list_access_traits::end<value_type>(native_handle());
+ }
+ const_iterator begin() const
+ {
+ return const_cast<_self_type*>(this)->begin();
+ }
+ const_iterator end() const
+ {
+ return const_cast<_self_type*>(this)->end();
+ }
+ const_iterator cbegin() const
+ {
+ return begin();
+ }
+ const_iterator cend() const
+ {
+ return end();
+ }
+ reverse_iterator rbegin()
+ {
+ return _eo_list_access_traits::rbegin<value_type>(native_handle());
+ }
+ reverse_iterator rend()
+ {
+ return _eo_list_access_traits::rend<value_type>(native_handle());
+ }
+ const_reverse_iterator rbegin() const
+ {
+ return const_cast<_self_type*>(this)->rbegin();
+ }
+ const_reverse_iterator rend() const
+ {
+ return const_cast<_self_type*>(this)->rend();
+ }
+ const_reverse_iterator crbegin() const
+ {
+ return rbegin();
+ }
+ const_reverse_iterator crend() const
+ {
+ return rend();
+ }
+ using _base_type::swap;
+ using _base_type::native_handle;
+
+ friend bool operator==(range_list<T> const& rhs, range_list<T> const& lhs)
+ {
+ return rhs.size() == lhs.size() && std::equal(rhs.begin(), rhs.end(), lhs.begin());
+ }
+};
} }
/**
* @internal
*/
-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::end<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::begin<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*)
+struct _ptr_list_access_traits
{
- 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>
-static eina::iterator<T const> ciend(Eina_List const* list)
-{
- return _ptr_list_access_traits::iend<T>(list);
-}
-template <typename T>
-static std::size_t size(Eina_List const* list)
-{
- return eina_list_count(list);
-}
-template <typename T>
-static bool empty(Eina_List const* list)
-{
- return _ptr_list_access_traits::size<T>(list) == 0u;
-}
-
-};
-
-/**
- * @internal
- */
-template <typename T>
-struct _const_range_ptr_list
-{
- typedef _ptr_list_iterator<T const> const_iterator;
- typedef const_iterator iterator;
- typedef T value_type;
- typedef T& reference;
- typedef T const& const_reference;
- typedef T* pointer;
- typedef T const* const_pointer;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
- typedef const_reverse_iterator reverse_iterator;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
-
- typedef Eina_List const* native_handle_type;
- typedef _const_range_ptr_list<T> _self_type;
-
- _const_range_ptr_list(native_handle_type list)
- : _list(list) {}
-
- native_handle_type native_handle() const { return _list; }
- value_type const& back() const
+ 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 _ptr_list_access_traits::back<value_type>(_list);
+ return const_cast<Eina_List*>(list);
}
- value_type const& front() const
+ template <typename T>
+ static T& back(Eina_List* list)
{
- return _ptr_list_access_traits::front<value_type>(_list);
+ return *static_cast<T*>(eina_list_data_get(eina_list_last(list)));
}
- const_iterator begin() const
+ template <typename T>
+ static T const& back(Eina_List const* list)
{
- return _ptr_list_access_traits::begin<value_type>(_list);
+ return _ptr_list_access_traits::back<T>(const_cast<Eina_List*>(list));
}
- const_iterator end() const
+ template <typename T>
+ static T& front(Eina_List* list)
{
- return _ptr_list_access_traits::end<value_type>(_list);
+ return *static_cast<T*>(eina_list_data_get(list));
}
- const_reverse_iterator rbegin() const
+ template <typename T>
+ static T const& front(Eina_List const* list)
{
- return _ptr_list_access_traits::rbegin<value_type>(_list);
+ return _ptr_list_access_traits::front<T>(const_cast<Eina_List*>(list));
}
- const_reverse_iterator rend() const
+ template <typename T>
+ static _ptr_list_iterator<T> begin(Eina_List* list)
{
- return _ptr_list_access_traits::rend<value_type>(_list);
+ return _ptr_list_iterator<T>(list, list);
}
- const_iterator cbegin() const
+ template <typename T>
+ static _ptr_list_iterator<T> end(Eina_List* list)
{
- return _ptr_list_access_traits::cbegin<value_type>(_list);
+ return _ptr_list_iterator<T>(list, 0);
}
- const_iterator cend() const
+ template <typename T>
+ static _ptr_list_iterator<T const> begin(Eina_List const* list)
{
- return _ptr_list_access_traits::cend<value_type>(_list);
+ return _ptr_list_access_traits::begin<T>(const_cast<Eina_List*>(list));
}
- const_reverse_iterator crbegin() const
+ template <typename T>
+ static _ptr_list_iterator<T const> end(Eina_List const* list)
{
- return _ptr_list_access_traits::crbegin<value_type>(_list);
+ return _ptr_list_access_traits::end<T>(const_cast<Eina_List*>(list));
}
- const_reverse_iterator crend() const
+ template <typename T>
+ static std::reverse_iterator<_ptr_list_iterator<T> > rbegin(Eina_List* list)
{
- return _ptr_list_access_traits::crend<value_type>(_list);
+ return std::reverse_iterator<_ptr_list_iterator<T> >(_ptr_list_access_traits::end<T>(list));
}
- void swap(_self_type& other)
+ template <typename T>
+ static std::reverse_iterator<_ptr_list_iterator<T> > rend(Eina_List* list)
{
- std::swap(_list, other._list);
+ return std::reverse_iterator<_ptr_list_iterator<T> >(_ptr_list_access_traits::begin<T>(list));
}
- bool empty() const
+ template <typename T>
+ static std::reverse_iterator<_ptr_list_iterator<T const> > rbegin(Eina_List const* list)
{
- return _ptr_list_access_traits::empty<T>(_list);
+ return _ptr_list_access_traits::rbegin<T>(const_cast<Eina_List*>(list));
}
- size_type size() const
+ template <typename T>
+ static std::reverse_iterator<_ptr_list_iterator<T const> > rend(Eina_List const* list)
{
- return _ptr_list_access_traits::size<T>(_list);
+ return _ptr_list_access_traits::rend<T>(const_cast<Eina_List*>(list));
}
-
- native_handle_type _list;
-};
-
-/**
- * @internal
- */
-template <typename T>
-void swap(_const_range_ptr_list<T>& lhs, _const_range_ptr_list<T>& rhs)
-{
- lhs.swap(rhs);
-}
-
-/**
- * @internal
- */
-template <typename T>
-struct _mutable_range_ptr_list : _const_range_ptr_list<T>
-{
- typedef _const_range_ptr_list<T> _base_type;
- typedef T value_type;
- typedef _ptr_list_iterator<T> iterator;
- typedef T& reference;
- typedef T* pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef typename _base_type::const_iterator const_iterator;
- typedef typename _base_type::const_reference const_reference;
- typedef typename _base_type::const_pointer const_pointer;
- typedef typename _base_type::const_reverse_iterator const_reverse_iterator;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
-
- typedef Eina_List* native_handle_type;
- typedef _mutable_range_ptr_list<T> _self_type;
-
- _mutable_range_ptr_list(native_handle_type list)
- : _base_type(list) {}
-
- native_handle_type native_handle() const
+ 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 const_cast<native_handle_type>(_base_type::native_handle());
+ return eina::iterator<T>();
}
- value_type& back() const
+ template <typename T>
+ static eina::iterator<T const> ibegin(Eina_List const* list)
{
- return _ptr_list_access_traits::back<value_type>(native_handle());
+ return eina::iterator<T const>( ::eina_list_iterator_new(list) );
}
- value_type& front() const
+ template <typename T>
+ static eina::iterator<T const> iend(Eina_List const*)
{
- return _ptr_list_access_traits::front<value_type>(native_handle());
+ return eina::iterator<T const>();
}
- iterator begin() const
+ template <typename T>
+ static eina::iterator<T const> cibegin(Eina_List const* list)
{
- return _ptr_list_access_traits::begin<value_type>(native_handle());
+ return _ptr_list_access_traits::ibegin<T>(list);
}
- iterator end() const
+ template <typename T>
+ static eina::iterator<T const> ciend(Eina_List const* list)
{
- return _ptr_list_access_traits::end<value_type>(native_handle());
+ return _ptr_list_access_traits::iend<T>(list);
}
- reverse_iterator rbegin() const
+ template <typename T>
+ static std::size_t size(Eina_List const* list)
{
- return _ptr_list_access_traits::rbegin<value_type>(native_handle());
+ return eina_list_count(list);
}
- reverse_iterator rend() const
+ template <typename T>
+ static bool empty(Eina_List const* list)
{
- return _ptr_list_access_traits::rend<value_type>(native_handle());
+ return _ptr_list_access_traits::size<T>(list) == 0u;
}
};