Skip to content

Generic converters for sequence containers, mappings, strings #160

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
pmed merged 5 commits into from
Jul 25, 2021
Merged

Generic converters for sequence containers, mappings, strings #160

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
f194191
v8pp::convert for std::{unordered_}{multi}map
pmed Mar 15, 2021
6183a58
generic v8pp::convert for strings
pmed Mar 15, 2021
fa57cd6
generic v8pp::convert for sequences
pmed Mar 19, 2021
b2bfbe5
add `detail::is_shared_ptr<T>` metafunction
pmed Mar 19, 2021
bd2b8d1
cleanup `detail::is_*` metafunctions
pmed Mar 19, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 12 additions & 0 deletions test/test.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -181,6 +181,18 @@ void check_eq(v8pp::string_view msg, T actual, U expected)
}
}

template<typename T>
void check_eq(v8pp::string_view msg, T actual, v8pp::u16string_view expected)
{
check(msg, actual == expected);
}

template<typename T>
void check_eq(v8pp::string_view msg, T actual, v8pp::wstring_view expected)
{
check(msg, actual == expected);
}

template<typename Ex, typename F>
void check_ex(v8pp::string_view msg, F&& f)
{
Expand Down
38 changes: 23 additions & 15 deletions test/test_convert.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,12 +13,20 @@
#include <vector>
#include <map>

template<typename T, typename U>
void test_conv(v8::Isolate* isolate, T value, U expected)
{
auto const obtained = v8pp::from_v8<U>(isolate, v8pp::to_v8(isolate, value));
check_eq(v8pp::detail::type_id<T>().name(), obtained, expected);

auto const obtained2 = v8pp::from_v8<T>(isolate, v8pp::to_v8(isolate, expected));
check_eq(v8pp::detail::type_id<U>().name(), obtained2, value);
}

template<typename T>
void test_conv(v8::Isolate* isolate, T value)
{
v8::Local<v8::Value> v8_value = v8pp::to_v8(isolate, value);
auto const value2 = v8pp::from_v8<T>(isolate, v8_value);
check(v8pp::detail::type_id<T>().name(), value2 == value);
test_conv(isolate, value, value);
}

template<typename Char, size_t N>
Expand Down Expand Up @@ -154,30 +162,30 @@ void test_convert()
test_string_conv(isolate, L"qaz");
#endif

using int_vector = std::vector<int>;

int_vector vector = { 1, 2, 3 };
const std::vector<int> vector{ 1, 2, 3 };
test_conv(isolate, vector);
test_conv(isolate, std::deque<unsigned>{ 1, 2, 3 }, vector);
test_conv(isolate, std::list<int>{ 1, 2, 3 }, vector);

std::map<char, int> map = { { 'a', 1 }, { 'b', 2 }, { 'c', 3 } };
test_conv(isolate, map);

std::array<int, 3> array = { { 1, 2, 3 } };
const std::array<int, 3> array{ 1, 2, 3 };
test_conv(isolate, array);

check_ex<std::runtime_error>("wrong array length", [isolate, &array]()
{
v8::Local<v8::Array> arr = v8pp::to_v8(isolate, array);
v8pp::from_v8<std::array<int, 2>>(isolate, arr);
});

test_conv(isolate, std::map<char, int>{ { 'a', 1 }, { 'b', 2 }, { 'c', 3 } });
test_conv(isolate, std::multimap<int, int>{ { 1, -1 }, { 2, -2 }});
test_conv(isolate, std::unordered_map<char, std::string>{ { 'x', "1" }, { 'y', "2" }});
test_conv(isolate, std::unordered_multimap<std::string, int>{ { "a", 1 }, { "b", 2 }});

check_eq("initializer list to array",
v8pp::from_v8<int_vector>(isolate, v8pp::to_v8(isolate,
{ 1, 2, 3 })), vector);
v8pp::from_v8<std::vector<int>>(isolate, v8pp::to_v8(isolate, { 1, 2, 3 })), vector);

std::list<int> list = { 1, 2, 3 };
check_eq("pair of iterators to array", v8pp::from_v8<int_vector>(isolate,
v8pp::to_v8(isolate, list.begin(), list.end())), vector);
check_eq("pair of iterators to array",
v8pp::from_v8<std::vector<int>>(isolate, v8pp::to_v8(isolate, list.begin(), list.end())), vector);

person p;
p.name = "Al"; p.age = 33;
Expand Down
78 changes: 78 additions & 0 deletions test/test_utility.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,9 @@
#include "v8pp/utility.hpp"
#include "test.hpp"

#include <map>
#include <unordered_map>

template<typename Ret, typename F>
void test_ret(F&&)
{
Expand Down Expand Up @@ -177,11 +180,86 @@ void test_is_callable()
static_assert(!is_callable<Y>::value, "Y is not callable");
}

void test_type_traits()
{
static_assert(v8pp::detail::is_string<std::string>::value, "std::string");
static_assert(!v8pp::detail::is_sequence<std::string>::value, "std::string");
static_assert(!v8pp::detail::is_mapping<std::string>::value, "std::string");
static_assert(!v8pp::detail::is_array<std::string>::value, "std::string");

static_assert(v8pp::detail::is_string<v8pp::string_view>::value, "std::string_view");
static_assert(v8pp::detail::is_string<std::u16string>::value, "std::u16string");
static_assert(v8pp::detail::is_string<v8pp::u16string_view>::value, "std::u16string_view");
static_assert(v8pp::detail::is_string<std::u32string>::value, "std::u32string");
static_assert(v8pp::detail::is_string<v8pp::u32string_view>::value, "std::u32string_view");
static_assert(v8pp::detail::is_string<std::wstring>::value, "std::wstring");
static_assert(v8pp::detail::is_string<v8pp::wstring_view>::value, "std::wstring_view");
static_assert(v8pp::detail::is_string<char const*>::value, "char const*");
static_assert(v8pp::detail::is_string<char16_t const*>::value, "char16_t const*");
static_assert(v8pp::detail::is_string<char32_t const*>::value, "char32_t const*");
static_assert(v8pp::detail::is_string<wchar_t const*>::value, "wchar_t const*");

static_assert(!v8pp::detail::is_string<std::array<int, 1>>::value, "std::array");
static_assert(!v8pp::detail::is_mapping<std::array<int, 1>>::value, "std::array");
static_assert(!v8pp::detail::is_sequence<std::array<int, 1>>::value, "std::array");
static_assert(!v8pp::detail::is_sequence<std::array<int, 1>>::value, "std::array");
static_assert(v8pp::detail::is_array<std::array<int, 1>>::value, "std::array");
static_assert(!v8pp::detail::has_reserve<std::array<int, 1>>::value, "std::array");

static_assert(!v8pp::detail::is_string<std::vector<char>>::value, "std::vector");
static_assert(!v8pp::detail::is_mapping<std::vector<char>>::value, "std::vector");
static_assert(v8pp::detail::is_sequence<std::vector<char>>::value, "std::vector");
static_assert(!v8pp::detail::is_array<std::vector<char>>::value, "std::vector");
static_assert(v8pp::detail::has_reserve<std::vector<char>>::value, "std::vector");

static_assert(!v8pp::detail::is_string<std::deque<int>>::value, "std::deque");
static_assert(!v8pp::detail::is_mapping<std::deque<int>>::value, "std::deque");
static_assert(v8pp::detail::is_sequence<std::deque<int>>::value, "std::deque");
static_assert(!v8pp::detail::is_array<std::deque<int>>::value, "std::deque");
static_assert(!v8pp::detail::has_reserve<std::deque<int>>::value, "std::deque");

static_assert(!v8pp::detail::is_string<std::list<bool>>::value, "std::list");
static_assert(!v8pp::detail::is_mapping<std::list<bool>>::value, "std::list");
static_assert(v8pp::detail::is_sequence<std::list<bool>>::value, "std::list");
static_assert(!v8pp::detail::is_array<std::list<bool>>::value, "std::list");
static_assert(!v8pp::detail::has_reserve<std::list<bool>>::value, "std::list");

static_assert(!v8pp::detail::is_string<std::tuple<int, char>>::value, "std::tuple");
static_assert(!v8pp::detail::is_mapping<std::tuple<int, char>>::value, "std::tuple");
static_assert(!v8pp::detail::is_sequence<std::tuple<int, char>>::value, "std::tuple");
static_assert(!v8pp::detail::is_array<std::tuple<int, char>>::value, "std::tuple");
static_assert(v8pp::detail::is_tuple<std::tuple<int, char>>::value, "std::tuple");

static_assert(!v8pp::detail::is_string<std::map<int, float>>::value, "std::map");
static_assert(v8pp::detail::is_mapping<std::map<int, float>>::value, "std::map");
static_assert(!v8pp::detail::is_sequence<std::map<int, char>>::value, "std::map");
static_assert(!v8pp::detail::is_array<std::map<int, char>>::value, "std::map");

static_assert(!v8pp::detail::is_string<std::multimap<int, char>>::value, "std::multimap");
static_assert(v8pp::detail::is_mapping<std::multimap<bool, std::string, std::greater<>>>::value, "std::multimap");
static_assert(!v8pp::detail::is_sequence<std::multimap<int, char>>::value, "std::multimap");
static_assert(!v8pp::detail::is_array<std::multimap<int, char>>::value, "std::multimap");

static_assert(!v8pp::detail::is_string<std::unordered_map<int, char>>::value, "std::unordered_map");
static_assert(v8pp::detail::is_mapping<std::unordered_map<std::string, std::string>>::value, "std::unordered_map");
static_assert(!v8pp::detail::is_sequence<std::unordered_map<int, char>>::value, "std::unordered_map");
static_assert(!v8pp::detail::is_array<std::unordered_map<int, char>>::value, "std::unordered_map");

static_assert(!v8pp::detail::is_array<std::unordered_multimap<int, char>>::value, "std::unordered_multimap");
static_assert(v8pp::detail::is_mapping<std::unordered_multimap<char, std::string>>::value, "std::unordered_multimap");
static_assert(!v8pp::detail::is_sequence<std::unordered_multimap<int, char>>::value, "std::unordered_multimap");
static_assert(!v8pp::detail::is_array<std::unordered_multimap<int, char>>::value, "std::unordered_multimap");

static_assert(!v8pp::detail::is_shared_ptr<int>::value, "int");
static_assert(v8pp::detail::is_shared_ptr<std::shared_ptr<int>>::value, "int");
}

struct some_struct {};
namespace test { class some_class {}; }

void test_utility()
{
test_type_traits();
test_function_traits();
test_tuple_tail();
test_is_callable();
Expand Down
Loading