Eina-Cxx: Added native type constructors and examples.

Summary:
This patch allows us to construct efl::eina:: types from
their respective C types.

Reviewers: cedric, felipealmeida, q66

Reviewed By: q66

CC: smohanty, woohyun, raster, cedric

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

src/bindings/eina_cxx/eina_inarray.hh

@@ -363,7 +363,7 @@ struct _inarray_common_base
    * @warning It is important to note that the created array object
    * gains ownership of the handle, deallocating it at destruction time.
    */
-  explicit _inarray_common_base(Eina_Inarray* array)
+  explicit _inarray_common_base(native_handle_type array)
     : _array(array) {}
 
   /**
@@ -439,7 +439,7 @@ struct _inarray_common_base
    * @internal
    * Member variable that holds the native @c Eina_Inarray handle.
    */
-  Eina_Inarray* _array;
+  native_handle_type _array;
 private:
   /** Disabled copy constructor. */
   _inarray_common_base(_inarray_common_base const& other);
@@ -503,7 +503,7 @@ public:
    * @warning It is important to note that the created object gains
    * ownership of the handle, deallocating it at destruction time.
    */
-  _pod_inarray(Eina_Inarray* array)
+  _pod_inarray(native_handle_type array)
     : _base_type(array) {}
 
   /**
@@ -607,6 +607,7 @@ public:
   void push_back(T const& value)
   {
     size_type s = size();
+    static_cast<void>(s);
     eina_inarray_push(_array, &value);
     assert(size() != s);
     assert(size() == s + 1u);
@@ -1019,7 +1020,7 @@ public:
    * @warning It is important to take care when using it, since the
    * handle will be automatically release upon object destruction.
    */
-  Eina_Inarray* native_handle()
+  native_handle_type native_handle()
   {
     return this->_array;
   }
@@ -1033,7 +1034,7 @@ public:
    *
    * @see native_handle()
    */
-  Eina_Inarray const* native_handle() const
+  const_native_handle_type native_handle() const
   {
     return this->_array;
   }
@@ -1286,6 +1287,7 @@ public:
         for(size_type j = 0;j != n;++j)
           new (&*first++) T(t);
         std::size_t diff = last - first;
+        static_cast<void>(diff);
         assert(diff == _array->len - index - n);
         static_cast<void>(diff);
         while(first != last)

src/bindings/eina_cxx/eina_inlist.hh

@@ -418,6 +418,7 @@ struct _inlist_common_base
   typedef typename Allocator::template rebind<_inlist_node<T> >::other node_allocator_type; /**< Type for the allocator of the node. */
   typedef Allocator allocator_type; /**< Type for the allocator. */
   typedef _inlist_node<T> node_type; /**< Type for the list node.  */
+  typedef Eina_Inlist* native_handle_type; /**< Native type. */
 
   /**
    * @brief Creates a list with the given allocator.
@@ -426,6 +427,13 @@ struct _inlist_common_base
   _inlist_common_base(Allocator allocator)
     : _impl(allocator) {}
 
+  /**
+   * @brief Wraps the native object.
+   * @param inlist The native inlist object (Eina_Inlist*).
+   */
+  _inlist_common_base(native_handle_type inlist)
+    : _impl(inlist) {}
+
   /**
    * @brief Creates an empty inline list.
    */
@@ -477,9 +485,11 @@ struct _inlist_common_base
     _inlist_impl(Allocator allocator)
       : node_allocator_type(allocator), _list(0)
     {}
+     explicit _inlist_impl(native_handle_type list)
+       : _list(list)
+     {}
     _inlist_impl() : _list(0) {}
-
-    Eina_Inlist* _list;
+    native_handle_type _list;
   };
 
   _inlist_impl _impl; /**< @internal */
@@ -518,6 +528,7 @@ public:
   typedef typename allocator_type::const_pointer const_pointer; /**< Type for a constant pointer for an element. */
   typedef std::size_t size_type; /**< Type for size information. */
   typedef std::ptrdiff_t difference_type; /**< Type to represent the distance between two iterators. */
+  typedef typename _base_type::native_handle_type native_handle_type; /**< The native handle type. */
 
   typedef std::reverse_iterator<iterator> reverse_iterator; /**< Type for reverse iterator for this kind of container. */
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator; /**< Type for constant reverse iterator for this kind of container. */
@@ -529,6 +540,14 @@ public:
    */
   inlist() {}
 
+  /**
+   * @brief Construct an inlist from a native object.
+   * @param list The native object.
+   */
+  inlist(native_handle_type list)
+    : _inlist_common_base<T, Allocator>(list)
+  {}
+
   /**
    * @brief Construct an inline list object with @p n copies of @p t.
    * @param n Number of elements.

src/bindings/eina_cxx/eina_ptrlist.hh

@@ -6,6 +6,7 @@
 #include <eina_lists_auxiliary.hh>
 #include <eina_type_traits.hh>
 #include <eina_accessor.hh>
+#include <eina_iterator.hh>
 
 #include <memory>
 #include <iterator>

src/tests/eina_cxx/eina_cxx_test_inarray.cc

@@ -419,6 +419,27 @@ START_TEST(eina_cxx_range_inarray)
 }
 END_TEST
 
+START_TEST(eina_cxx_inarray_from_c)
+{
+  efl::eina::eina_init eina_init;
+
+  Eina_Inarray *c_array = nullptr;
+  int values[] = { 11, 22, 33 };
+
+  c_array = ::eina_inarray_new(sizeof(int), sizeof(values)/sizeof(int));
+  ck_assert(!!c_array);
+
+  eina_inarray_push(c_array, &values[0]);
+  eina_inarray_push(c_array, &values[1]);
+  eina_inarray_push(c_array, &values[2]);
+  {
+      efl::eina::range_inarray<int> range_array(c_array);
+  }
+  ck_assert(eina_inarray_count(c_array) == 3);
+  efl::eina::inarray<int> array(c_array);
+}
+END_TEST
+
 void
 eina_test_inarray(TCase *tc)
 {
@@ -433,4 +454,5 @@ eina_test_inarray(TCase *tc)
   tcase_add_test(tc, eina_cxx_inarray_nonpod_erase);
   tcase_add_test(tc, eina_cxx_inarray_nonpod_constructors);
   tcase_add_test(tc, eina_cxx_range_inarray);
+  tcase_add_test(tc, eina_cxx_inarray_from_c);
 }

src/tests/eina_cxx/eina_cxx_test_inlist.cc

@@ -6,6 +6,12 @@
 
 #include <check.h>
 
+struct Eina_Test_Inlist
+{
+   int i;
+   EINA_INLIST;
+};
+
 START_TEST(eina_cxx_inlist_push_back)
 {
   efl::eina::eina_init eina_init;
@@ -242,6 +248,31 @@ START_TEST(eina_cxx_inlist_range)
 }
 END_TEST
 
+START_TEST(eina_cxx_inlist_from_c)
+{
+  efl::eina::eina_init eina_init;
+
+  Eina_Inlist *c_list = nullptr;
+  Eina_Test_Inlist arr[3] = { {11}, {22}, {33} };
+
+  c_list = eina_inlist_append(c_list, EINA_INLIST_GET(&arr[0]));
+  ck_assert(!!c_list);
+
+  c_list = eina_inlist_append(c_list, EINA_INLIST_GET(&arr[1]));
+  ck_assert(!!c_list);
+
+  c_list = eina_inlist_append(c_list, EINA_INLIST_GET(&arr[2]));
+  ck_assert(!!c_list);
+
+  efl::eina::range_inlist<int const> const_range_inlist(c_list);
+  efl::eina::range_inlist<int> range_inlist(c_list);
+
+  c_list = eina_inlist_first(c_list);
+   while (c_list)
+      c_list = eina_inlist_remove(c_list, c_list);
+}
+END_TEST
+
 void
 eina_test_inlist(TCase *tc)
 {
@@ -253,4 +284,5 @@ eina_test_inlist(TCase *tc)
   tcase_add_test(tc, eina_cxx_inlist_erase);
   tcase_add_test(tc, eina_cxx_inlist_constructors);
   tcase_add_test(tc, eina_cxx_inlist_range);
+  tcase_add_test(tc, eina_cxx_inlist_from_c);
 }

src/tests/eina_cxx/eina_cxx_test_ptrarray.cc

@@ -212,6 +212,18 @@ START_TEST(eina_cxx_ptrarray_range)
 }
 END_TEST
 
+START_TEST(eina_cxx_ptrarray_from_c)
+{
+  efl::eina::eina_init eina_init;
+
+  Eina_Array *c_array = eina_array_new(3);
+  ck_assert(!!c_array);
+  efl::eina::range_ptr_array<int> range_array(c_array);
+
+  eina_array_free(c_array);
+}
+END_TEST
+
 void
 eina_test_ptrarray(TCase* tc)
 {
@@ -221,4 +233,5 @@ eina_test_ptrarray(TCase* tc)
   tcase_add_test(tc, eina_cxx_ptrarray_constructors);
   tcase_add_test(tc, eina_cxx_ptrarray_erase);
   tcase_add_test(tc, eina_cxx_ptrarray_range);
+  tcase_add_test(tc, eina_cxx_ptrarray_from_c);
 }

src/tests/eina_cxx/eina_cxx_test_ptrlist.cc

@@ -255,6 +255,43 @@ START_TEST(eina_cxx_ptrlist_range)
 }
 END_TEST
 
+START_TEST(eina_cxx_ptrlist_from_c)
+{
+  efl::eina::eina_init eina_init;
+  Eina_List *c_list = nullptr;
+
+  int values[] = { 11, 22, 33 };
+
+  c_list = ::eina_list_append(c_list, &values[0]);
+  ck_assert(!!c_list);
+
+  c_list = ::eina_list_append(c_list, &values[1]);
+  ck_assert(!!c_list);
+
+  c_list = ::eina_list_append(c_list, &values[2]);
+  ck_assert(!!c_list);
+
+  const Eina_List* const_c_list = c_list;
+  const Eina_List* const_c_list_const_ptr = c_list;
+
+  efl::eina::range_ptr_list<int> r0(c_list);
+  const efl::eina::range_ptr_list<int> r1(c_list);
+
+  efl::eina::range_ptr_list<int const> r2(c_list);
+  efl::eina::range_ptr_list<int const> r3(const_c_list);
+  efl::eina::range_ptr_list<int const> r4(const_c_list_const_ptr);
+
+  const efl::eina::range_ptr_list<int const> r5(c_list);
+  const efl::eina::range_ptr_list<int const> r6(const_c_list);
+  const efl::eina::range_ptr_list<int const> r7(const_c_list_const_ptr);
+
+  const efl::eina::range_ptr_list<int> r8(c_list);
+
+  c_list = ::eina_list_free(c_list);
+  ck_assert(!c_list);
+}
+END_TEST
+
 void
 eina_test_ptrlist(TCase* tc)
 {
@@ -267,4 +304,5 @@ eina_test_ptrlist(TCase* tc)
   tcase_add_test(tc, eina_cxx_ptrlist_erase);
   tcase_add_test(tc, eina_cxx_ptrlist_range);
   tcase_add_test(tc, eina_cxx_ptrlist_malloc_clone_allocator);
+  tcase_add_test(tc, eina_cxx_ptrlist_from_c);
 }