q66 pushed a commit to branch master.
http://git.enlightenment.org/core/efl.git/commit/?id=656d280e6a6e9bbf8d83a67afc4659aaf151c2c3
commit 656d280e6a6e9bbf8d83a67afc4659aaf151c2c3
Author: Savio Sena <savio.s...@acm.org>
Date: Fri Jun 20 01:00:13 2014 +0100
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 | 12 +++++----
src/bindings/eina_cxx/eina_inlist.hh | 23 +++++++++++++++--
src/bindings/eina_cxx/eina_ptrlist.hh | 1 +
src/tests/eina_cxx/eina_cxx_test_inarray.cc | 22 ++++++++++++++++
src/tests/eina_cxx/eina_cxx_test_inlist.cc | 32 +++++++++++++++++++++++
src/tests/eina_cxx/eina_cxx_test_ptrarray.cc | 13 ++++++++++
src/tests/eina_cxx/eina_cxx_test_ptrlist.cc | 38 ++++++++++++++++++++++++++++
7 files changed, 134 insertions(+), 7 deletions(-)
diff --git a/src/bindings/eina_cxx/eina_inarray.hh
b/src/bindings/eina_cxx/eina_inarray.hh
index ae593e4..dabfc89 100644
--- a/src/bindings/eina_cxx/eina_inarray.hh
+++ b/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)
diff --git a/src/bindings/eina_cxx/eina_inlist.hh
b/src/bindings/eina_cxx/eina_inlist.hh
index 4d83632..644d8c1 100644
--- a/src/bindings/eina_cxx/eina_inlist.hh
+++ b/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.
@@ -427,6 +428,13 @@ struct _inlist_common_base
: _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.
*/
_inlist_common_base()
@@ -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. */
@@ -530,6 +541,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.
* @param t Value to be copied to each element.
diff --git a/src/bindings/eina_cxx/eina_ptrlist.hh
b/src/bindings/eina_cxx/eina_ptrlist.hh
index f723f61..5dafed2 100644
--- a/src/bindings/eina_cxx/eina_ptrlist.hh
+++ b/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>
diff --git a/src/tests/eina_cxx/eina_cxx_test_inarray.cc
b/src/tests/eina_cxx/eina_cxx_test_inarray.cc
index 062a5e7..3f48bef 100644
--- a/src/tests/eina_cxx/eina_cxx_test_inarray.cc
+++ b/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);
}
diff --git a/src/tests/eina_cxx/eina_cxx_test_inlist.cc
b/src/tests/eina_cxx/eina_cxx_test_inlist.cc
index b5ff8a4..04feed0 100644
--- a/src/tests/eina_cxx/eina_cxx_test_inlist.cc
+++ b/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);
}
diff --git a/src/tests/eina_cxx/eina_cxx_test_ptrarray.cc
b/src/tests/eina_cxx/eina_cxx_test_ptrarray.cc
index d9c848e..0d5f9ac 100644
--- a/src/tests/eina_cxx/eina_cxx_test_ptrarray.cc
+++ b/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);
}
diff --git a/src/tests/eina_cxx/eina_cxx_test_ptrlist.cc
b/src/tests/eina_cxx/eina_cxx_test_ptrlist.cc
index 6b3466c..f422cde 100644
--- a/src/tests/eina_cxx/eina_cxx_test_ptrlist.cc
+++ b/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);
}
--
