Fixed rbegin/rend implementation on the Eina C++ ranges.

Summary:
Fixed the rbegin/rend functions returning switched reverse iterators.
Added code to some unit tests for comparing elements in reverse order, in interest of
checking the correctness of the rbegin/rend functions.

Reviewers: felipealmeida, cedric, woohyun, smohanty, raster

Reviewed By: felipealmeida

CC: savio, cedric

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

src/bindings/eina_cxx/eina_inarray.hh

@@ -85,22 +85,22 @@ static T const* end(Eina_Inarray const* 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));
+  return std::reverse_iterator<T const*>(_inarray_access_traits::end<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));
+  return std::reverse_iterator<T const*>(_inarray_access_traits::begin<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));
+  return std::reverse_iterator<T*>(_inarray_access_traits::end<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));
+  return std::reverse_iterator<T*>(_inarray_access_traits::begin<T>(raw));
 }
 template <typename T>
 static T const* cbegin(Eina_Inarray const* raw)

src/bindings/eina_cxx/eina_inlist.hh

@@ -200,12 +200,12 @@ struct _inlist_access_traits {
   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));
+    return std::reverse_iterator<_inlist_iterator<T> >(_inlist_access_traits::end<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));
+    return std::reverse_iterator<_inlist_iterator<T> >(_inlist_access_traits::begin<T>(list));
   }
   template <typename T>
   static std::reverse_iterator<_inlist_iterator<T const> > rbegin(Eina_Inlist const* list)
@@ -540,19 +540,19 @@ public:
   }
   const_reverse_iterator rbegin() const
   {
-    return _inlist_access_traits::end<T>(this->_impl._list);
+    return reverse_iterator(end());
   }
   const_reverse_iterator rend() const
   {
-    return const_reverse_iterator(end());
+    return const_reverse_iterator(begin());
   }
   reverse_iterator rbegin()
   {
-    return reverse_iterator(begin());
+    return reverse_iterator(end());
   }
   reverse_iterator rend()
   {
-    return reverse_iterator(end());
+    return reverse_iterator(begin());
   }
   const_iterator cbegin() const
   {

src/bindings/eina_cxx/eina_ptrarray.hh

@@ -178,22 +178,22 @@ static _ptr_array_iterator<T> end(Eina_Array const* 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));
+  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> > rend(Eina_Array* array)
 {
-  return std::reverse_iterator<_ptr_array_iterator<T> >(_ptr_array_access_traits::end<T>(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 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)));
+  return std::reverse_iterator<_ptr_array_iterator<T const> >(_ptr_array_access_traits::end<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)));
+  return std::reverse_iterator<_ptr_array_iterator<T const> >(_ptr_array_access_traits::begin<T>(const_cast<Eina_Array*>(array)));
 }
 template <typename T>
 static _ptr_array_iterator<T const> cbegin(Eina_Array const* array)

src/bindings/eina_cxx/eina_ptrlist.hh

@@ -162,12 +162,12 @@ static _ptr_list_iterator<T const> end(Eina_List const* 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));
+  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::end<T>(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)

src/bindings/eina_cxx/eina_range_types.hh

@@ -43,7 +43,7 @@ struct _const_range_template
   }
   const_reverse_iterator crbegin() const
   {
-    return const_reverse_iterator(Traits::template begin<value_type>(_handle));
+    return const_reverse_iterator(Traits::template rbegin<value_type>(_handle));
   }
   const_reverse_iterator crend() const
   {

src/bindings/eina_cxx/eina_stringshare.hh

@@ -88,11 +88,11 @@ struct stringshare
 
   const_reverse_iterator rbegin() const
   {
-    return const_reverse_iterator(begin());
+    return const_reverse_iterator(end());
   }
   const_reverse_iterator rend() const
   {
-    return const_reverse_iterator(end());
+    return const_reverse_iterator(begin());
   }
 
   const_iterator cbegin() const

src/tests/eina_cxx/eina_cxx_test_inarray.cc

@@ -21,9 +21,11 @@ START_TEST(eina_cxx_inarray_pod_push_back)
   array.push_back(15);
 
   int result[] = {5, 10, 15};
+  int rresult[] = {15, 10, 5};
 
   ck_assert(array.size() == 3);
   ck_assert(std::equal(array.begin(), array.end(), result));
+  ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 }
 END_TEST
 
@@ -39,9 +41,11 @@ START_TEST(eina_cxx_inarray_pod_pop_back)
   array.pop_back();
 
   int result[] = {5, 10};
+  int rresult[] = {10, 5};
 
   ck_assert(array.size() == 2);
   ck_assert(std::equal(array.begin(), array.end(), result));
+  ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 }
 END_TEST
 
@@ -71,9 +75,11 @@ START_TEST(eina_cxx_inarray_pod_insert)
   array.insert(it, 20); // insert before the last element
 
   int result[] = {15, 5, 20, 10};
+  int rresult[] = {10, 20, 5, 15};
 
   ck_assert(array.size() == 4);
   ck_assert(std::equal(array.begin(), array.end(), result));
+  ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 
   efl::eina::inarray<int> array2;
   it = array2.insert(array2.end(), array.begin(), array.end());
@@ -206,9 +212,11 @@ START_TEST(eina_cxx_inarray_nonpod_push_back)
     array.push_back(15);
 
     int result[] = {5, 10, 15};
+    int rresult[] = {15, 10, 5};
 
     ck_assert(array.size() == 3);
     ck_assert(std::equal(array.begin(), array.end(), result));
+    ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
   }
   std::cout << "constructors called " << ::constructors_called
             << "\ndestructors called " << ::destructors_called << std::endl;
@@ -230,9 +238,11 @@ START_TEST(eina_cxx_inarray_nonpod_pop_back)
     array.pop_back();
 
     int result[] = {5, 10};
+    int rresult[] = {10, 5};
 
     ck_assert(array.size() == 2);
     ck_assert(std::equal(array.begin(), array.end(), result));
+    ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
   }
   std::cout << "constructors called " << ::constructors_called
             << "\ndestructors called " << ::destructors_called << std::endl;
@@ -268,9 +278,11 @@ START_TEST(eina_cxx_inarray_nonpod_insert)
     array.insert(it, 20); // insert before the last element
 
     int result[] = {15, 5, 20, 10};
+    int rresult[] = {10, 20, 5, 15};
 
     ck_assert(array.size() == 4);
     ck_assert(std::equal(array.begin(), array.end(), result));
+    ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 
     efl::eina::inarray<non_pod> array2;
     it = array2.insert(array2.end(), array.begin(), array.end());
@@ -384,20 +396,24 @@ START_TEST(eina_cxx_range_inarray)
   array.push_back(15);
 
   int result[] = {5, 10, 15};
+  int rresult[] = {15, 10, 5};
 
   efl::eina::range_inarray<int> range_array(array);
 
   ck_assert(range_array.size() == 3);
   ck_assert(std::equal(range_array.begin(), range_array.end(), result));
+  ck_assert(std::equal(range_array.rbegin(), range_array.rend(), rresult));
 
   ck_assert(range_array[0] == 5);
 
   *range_array.begin() = 0;
 
   int result1[] = {0, 10, 15};
+  int rresult1[] = {15, 10, 0};
 
   ck_assert(range_array.size() == 3);
   ck_assert(std::equal(range_array.begin(), range_array.end(), result1));
+  ck_assert(std::equal(range_array.rbegin(), range_array.rend(), rresult1));
 
   ck_assert(range_array[0] == 0);
 }

src/tests/eina_cxx/eina_cxx_test_inlist.cc

@@ -17,9 +17,11 @@ START_TEST(eina_cxx_inlist_push_back)
   list.push_back(15);
 
   int result[] = {5, 10, 15};
+  int rresult[] = {15, 10, 5};
 
   ck_assert(list.size() == 3);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -35,9 +37,11 @@ START_TEST(eina_cxx_inlist_pop_back)
   list.pop_back();
 
   int result[] = {5, 10};
+  int rresult[] = {10, 5};
 
   ck_assert(list.size() == 2);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -52,9 +56,11 @@ START_TEST(eina_cxx_inlist_push_front)
   list.push_front(15);
 
   int result[] = {15, 10, 5};
+  int rresult[] = {5, 10, 15};
 
   ck_assert(list.size() == 3);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -70,9 +76,11 @@ START_TEST(eina_cxx_inlist_pop_front)
   list.pop_front();
 
   int result[] = {10, 5};
+  int rresult[] = {5, 10};
 
   ck_assert(list.size() == 2);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -102,9 +110,11 @@ START_TEST(eina_cxx_inlist_insert)
   list.insert(it, 20); // insert before the last element
 
   int result[] = {15, 5, 20, 10};
+  int rresult[] = {10, 20, 5, 15};
 
   ck_assert(list.size() == 4);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 
   efl::eina::inlist<int> list2;
   it = list2.insert(list2.end(), list.begin(), list.end());
@@ -216,12 +226,15 @@ START_TEST(eina_cxx_inlist_range)
   ck_assert(range_list.size() == 6u);
 
   int result[] = {5, 10, 15, 20, 25, 30};
+  int rresult[] = {30, 25, 20, 15, 10, 5};
   ck_assert(std::equal(range_list.begin(), range_list.end(), result));
+  ck_assert(std::equal(range_list.rbegin(), range_list.rend(), rresult));
 
   efl::eina::range_inlist<int const> const_range_list(list);
 
   ck_assert(const_range_list.size() == 6u);
   ck_assert(std::equal(range_list.begin(), range_list.end(), result));
+  ck_assert(std::equal(range_list.rbegin(), range_list.rend(), rresult));
 
   *range_list.begin() = 0;
   ck_assert(*const_range_list.begin() == 0);

src/tests/eina_cxx/eina_cxx_test_ptrarray.cc

@@ -16,9 +16,11 @@ START_TEST(eina_cxx_ptrarray_push_back)
   array.push_back(new int(15));
 
   int result[] = {5, 10, 15};
+  int rresult[] = {15, 10, 5};
 
   ck_assert(array.size() == 3);
   ck_assert(std::equal(array.begin(), array.end(), result));
+  ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 }
 END_TEST
 
@@ -34,9 +36,11 @@ START_TEST(eina_cxx_ptrarray_pop_back)
   array.pop_back();
 
   int result[] = {5, 10};
+  int rresult[] = {10, 5};
 
   ck_assert(array.size() == 2);
   ck_assert(std::equal(array.begin(), array.end(), result));
+  ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 }
 END_TEST
 
@@ -46,6 +50,7 @@ START_TEST(eina_cxx_ptrarray_insert)
 
   efl::eina::ptr_array<int> array;
   ck_assert(std::distance(array.begin(), array.end()) == 0u);
+  ck_assert(std::distance(array.rbegin(), array.rend()) == 0u);
 
   efl::eina::ptr_array<int>::iterator it;
 
@@ -80,10 +85,13 @@ START_TEST(eina_cxx_ptrarray_insert)
   ck_assert(std::distance(array.begin(), array.end()) == 4u);
 
   int result[] = {15, 5, 20, 10};
+  int rresult[] = {10, 20, 5, 15};
 
   ck_assert(array.size() == 4);
   ck_assert(std::distance(array.begin(), array.end()) == 4u);
+  ck_assert(std::distance(array.rbegin(), array.rend()) == 4u);
   ck_assert(std::equal(array.begin(), array.end(), result));
+  ck_assert(std::equal(array.rbegin(), array.rend(), rresult));
 
   efl::eina::ptr_array<int, efl::eina::heap_copy_allocator> array2;
   it = array2.insert(array2.end(), array.begin(), array.end());
@@ -143,7 +151,9 @@ START_TEST(eina_cxx_ptrarray_erase)
   array1.push_back(new int(30));
 
   int result[] = {5, 10, 15, 20, 25, 30};
+  int rresult[] = {30, 25, 20, 15, 10, 5};
   ck_assert(std::equal(array1.begin(), array1.end(), result));
+  ck_assert(std::equal(array1.rbegin(), array1.rend(), rresult));
   
   efl::eina::ptr_array<int>::iterator it = array1.erase(array1.begin());
   ck_assert(it == array1.begin());
@@ -186,12 +196,15 @@ START_TEST(eina_cxx_ptrarray_range)
   ck_assert(range_array.size() == 6u);
 
   int result[] = {5, 10, 15, 20, 25, 30};
+  int rresult[] = {30, 25, 20, 15, 10, 5};
   ck_assert(std::equal(range_array.begin(), range_array.end(), result));
+  ck_assert(std::equal(range_array.rbegin(), range_array.rend(), rresult));
 
   efl::eina::range_ptr_array<int const> const_range_array(array);
 
   ck_assert(const_range_array.size() == 6u);
   ck_assert(std::equal(range_array.begin(), range_array.end(), result));
+  ck_assert(std::equal(range_array.rbegin(), range_array.rend(), rresult));
 
   *range_array.begin() = 0;
   ck_assert(*const_range_array.begin() == 0);

src/tests/eina_cxx/eina_cxx_test_ptrlist.cc

@@ -16,9 +16,11 @@ START_TEST(eina_cxx_ptrlist_push_back)
   list.push_back(new int(15));
 
   int result[] = {5, 10, 15};
+  int rresult[] = {15, 10, 5};
 
   ck_assert(list.size() == 3);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -34,9 +36,11 @@ START_TEST(eina_cxx_ptrlist_pop_back)
   list.pop_back();
 
   int result[] = {5, 10};
+  int rresult[] = {10, 5};
 
   ck_assert(list.size() == 2);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -51,9 +55,11 @@ START_TEST(eina_cxx_ptrlist_push_front)
   list.push_front(new int(15));
 
   int result[] = {15, 10, 5};
+  int rresult[] = {5, 10, 15};
 
   ck_assert(list.size() == 3);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -69,9 +75,11 @@ START_TEST(eina_cxx_ptrlist_pop_front)
   list.pop_front();
 
   int result[] = {10, 5};
+  int rresult[] = {5, 10};
 
   ck_assert(list.size() == 2);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 }
 END_TEST
 
@@ -101,9 +109,11 @@ START_TEST(eina_cxx_ptrlist_insert)
   list.insert(it, new int(20)); // insert before the last element
 
   int result[] = {15, 5, 20, 10};
+  int rresult[] = {10, 20, 5, 15};
 
   ck_assert(list.size() == 4);
   ck_assert(std::equal(list.begin(), list.end(), result));
+  ck_assert(std::equal(list.rbegin(), list.rend(), rresult));
 
   efl::eina::ptr_list<int, efl::eina::heap_copy_allocator> list2;
   it = list2.insert(list2.end(), list.begin(), list.end());
@@ -229,12 +239,15 @@ START_TEST(eina_cxx_ptrlist_range)
   ck_assert(range_list.size() == 6u);
 
   int result[] = {5, 10, 15, 20, 25, 30};
+  int rresult[] = {30, 25, 20, 15, 10, 5};
   ck_assert(std::equal(range_list.begin(), range_list.end(), result));
+  ck_assert(std::equal(range_list.rbegin(), range_list.rend(), rresult));
 
   efl::eina::range_ptr_list<int const> const_range_list(list);
 
   ck_assert(const_range_list.size() == 6u);
   ck_assert(std::equal(range_list.begin(), range_list.end(), result));
+  ck_assert(std::equal(range_list.rbegin(), range_list.rend(), rresult));
 
   *range_list.begin() = 0;
   ck_assert(*const_range_list.begin() == 0);

src/tests/eina_cxx/eina_cxx_test_stringshare.cc

@@ -25,8 +25,27 @@ START_TEST(eina_cxx_stringshare_constructors)
 }
 END_TEST
 
+START_TEST(eina_cxx_stringshare_iterators)
+{
+  efl::eina::eina_init eina_init;
+
+  const char str[] = "string";
+  const char rstr[] = "gnirts";
+
+  efl::eina::stringshare string(str);
+  ck_assert(string.size() == 6);
+  ck_assert(string == str);
+
+  ck_assert(std::equal(string.begin(), string.end(), str));
+  ck_assert(std::equal(string.rbegin(), string.rend(), rstr));
+  ck_assert(std::equal(string.cbegin(), string.cend(), str));
+  ck_assert(std::equal(string.crbegin(), string.crend(), rstr));
+}
+END_TEST
+
 void
 eina_test_stringshare(TCase *tc)
 {
   tcase_add_test(tc, eina_cxx_stringshare_constructors);
+  tcase_add_test(tc, eina_cxx_stringshare_iterators);
 }