Merge lp:~abreu-alexandre/v8-cpp/set-list-convert into lp:v8-cpp

[Alexandre Abreu]

Add list/set overloads for convert funcs

Add list/set overloads for convert funcs

[Marcus Tomlinson (marcustomlinson)]

Could you please add checks for list and set to the conversion_errors test in tests/errors/test.cpp:150.

Left a few inline comments as well.

review: Needs Fixing

[lp:~abreu-alexandre/v8-cpp/set-list-convert]

36. By Alexandre Abreu on 2015-10-19

Fixes

[Alexandre Abreu (abreu-alexandre)]

updated

[Marcus Tomlinson (marcustomlinson)]

Awesome, thanks!

review: Approve

=== modified file 'src/internal/convert.h'
--- src/internal/convert.h	2015-10-09 10:43:41 +0000
+++ src/internal/convert.h	2015-10-19 13:21:02 +0000
@@ -19,9 +19,11 @@
 #pragma once
 
 #include <climits>
-#include <vector>
+#include <list>
 #include <map>
 #include <memory>
+#include <set>
+#include <vector>
 
 #include <v8.h>
 
@@ -276,6 +278,98 @@
     }
 };
 
+// List converter
+template <typename T, typename Alloc>
+struct Convert<std::list<T, Alloc>>
+{
+    using FromType = std::list<T, Alloc>;
+    using ToType = v8::Local<v8::Array>;
+
+    static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
+    {
+        return !value.IsEmpty() && value->IsArray();
+    }
+
+    static FromType from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value)
+    {
+        if (!is_valid(isolate, value))
+        {
+            throw std::invalid_argument("expected list value");
+        }
+
+        v8::HandleScope scope(isolate);
+        v8::Local<v8::Array> array = value.As<v8::Array>();
+
+        FromType result;
+        for (uint32_t i = 0, count = array->Length(); i < count; ++i)
+        {
+            result.push_back(Convert<T>::from_v8(isolate, array->Get(i)));
+        }
+        return result;
+    }
+
+    static ToType to_v8(v8::Isolate* isolate, FromType const& value)
+    {
+        v8::EscapableHandleScope scope(isolate);
+
+        uint32_t size = static_cast<uint32_t>(value.size());
+        v8::Local<v8::Array> result = v8::Array::New(isolate, size);
+        size_t i = 0;
+        for (auto & e: value)
+        {
+            result->Set(i, Convert<T>::to_v8(isolate, e));
+            ++i;
+        }
+        return scope.Escape(result);
+    }
+};
+
+// Set converter
+template <typename T, typename Alloc>
+struct Convert<std::set<T, Alloc>>
+{
+    using FromType = std::set<T, Alloc>;
+    using ToType = v8::Local<v8::Array>;
+
+    static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
+    {
+        return !value.IsEmpty() && value->IsArray();
+    }
+
+    static FromType from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value)
+    {
+        if (!is_valid(isolate, value))
+        {
+            throw std::invalid_argument("expected set value");
+        }
+
+        v8::HandleScope scope(isolate);
+        v8::Local<v8::Array> array = value.As<v8::Array>();
+
+        FromType result;
+        for (uint32_t i = 0, count = array->Length(); i < count; ++i)
+        {
+            result.insert(Convert<T>::from_v8(isolate, array->Get(i)));
+        }
+        return result;
+    }
+
+    static ToType to_v8(v8::Isolate* isolate, FromType const& value)
+    {
+        v8::EscapableHandleScope scope(isolate);
+
+        uint32_t size = static_cast<uint32_t>(value.size());
+        v8::Local<v8::Array> result = v8::Array::New(isolate, size);
+        size_t i = 0;
+        for (auto & e: value)
+        {
+            result->Set(i, Convert<T>::to_v8(isolate, e));
+            ++i;
+        }
+        return scope.Escape(result);
+    }
+};
+
 // Map converter
 template <typename Key, typename Value, typename Less, typename Alloc>
 struct Convert<std::map<Key, Value, Less, Alloc>>
@@ -384,6 +478,12 @@
 template <typename T, typename Alloc>
 struct IsExportedClass<std::vector<T, Alloc>> : std::false_type {};
 
+template <typename T, typename Alloc>
+struct IsExportedClass<std::list<T, Alloc>> : std::false_type {};
+
+template <typename T, typename Alloc>
+struct IsExportedClass<std::set<T, Alloc>> : std::false_type {};
+
 template <typename Key, typename Value, typename Less, typename Alloc>
 struct IsExportedClass<std::map<Key, Value, Less, Alloc>> : std::false_type {};
 

=== modified file 'tests/errors/test.cpp'
--- tests/errors/test.cpp	2015-10-09 10:43:41 +0000
+++ tests/errors/test.cpp	2015-10-19 13:21:02 +0000
@@ -213,6 +213,22 @@
     {
         EXPECT_STREQ(e.what(), "expected an exported object");
     }
+    try
+    {
+        v8cpp::run_script<std::list<char>>("1");
+    }
+    catch (std::exception const& e)
+    {
+        EXPECT_STREQ(e.what(), "expected list value");
+    }
+    try
+    {
+        v8cpp::run_script<std::set<char>>("1");
+    }
+    catch (std::exception const& e)
+    {
+        EXPECT_STREQ(e.what(), "expected set value");
+    }
 }
 
 TEST(Test, throw_from_module)

=== modified file 'tests/functions/module.cpp'
--- tests/functions/module.cpp	2015-10-09 10:43:41 +0000
+++ tests/functions/module.cpp	2015-10-19 13:21:02 +0000
@@ -18,6 +18,10 @@
 
 #include "test.h"
 
+#include <set>
+#include <vector>
+#include <list>
+
 #include <v8-cpp.h>
 
 using namespace v8;
@@ -45,7 +49,10 @@
     module.add_class("TestCaller", testcaller);
     module.add_class("Shared", shared);
     module.add_function("simple_function", &simple_function);
+
+    module.add_function("complex_list_function", &complex_list_function);
     module.add_function("complex_function", &complex_function);
+    module.add_function("complex_set_function", &complex_set_function);
 
     exports->SetPrototype(module.create_prototype());
 }

=== modified file 'tests/functions/test.cpp'
--- tests/functions/test.cpp	2015-10-09 10:43:41 +0000
+++ tests/functions/test.cpp	2015-10-19 13:21:02 +0000
@@ -81,4 +81,31 @@
     EXPECT_FLOAT_EQ(result2[1], 3);
     EXPECT_FLOAT_EQ(result2[2], 2.1);
     EXPECT_FLOAT_EQ(result2[3], 0);
+
+    auto result3 = v8cpp::run_script<std::list<float>>(
+    R"(
+        var module = require("./test-functions-module");
+        module.complex_list_function(4, "3", 2.1, false);
+    )");
+
+    ASSERT_EQ(result3.size(), 4);
+    EXPECT_FLOAT_EQ(result3.front(), 4);
+    result3.pop_front();
+    EXPECT_FLOAT_EQ(result3.front(), 3);
+    result3.pop_front();
+    EXPECT_FLOAT_EQ(result3.front(), 2.1);
+    result3.pop_front();
+    EXPECT_FLOAT_EQ(result3.front(), 0);
+    result3.pop_front();
+
+    auto result4 = v8cpp::run_script<std::set<std::string>>(
+    R"(
+        var module = require("./test-functions-module");
+        module.complex_set_function(4, "3", false);
+    )");
+
+    ASSERT_EQ(result4.size(), 3);
+    EXPECT_FLOAT_EQ(result4.count("4"), 1);
+    EXPECT_FLOAT_EQ(result4.count("3"), 1);
+    EXPECT_FLOAT_EQ(result4.count("0"), 1);
 }

=== modified file 'tests/functions/test.h'
--- tests/functions/test.h	2015-10-09 10:43:41 +0000
+++ tests/functions/test.h	2015-10-19 13:21:02 +0000
@@ -82,3 +82,31 @@
     num_list.push_back(forth);
     return num_list;
 }
+
+std::list<float> complex_list_function(int first, std::string const& second, float third, bool forth)
+{
+    EXPECT_EQ(first, 4);
+    EXPECT_EQ(second, "3");
+    EXPECT_FLOAT_EQ(third, 2.1);
+    EXPECT_EQ(forth, false);
+
+    std::list<float> nums;
+    nums.push_back(first);
+    nums.push_back(stoi(second));
+    nums.push_back(third);
+    nums.push_back(forth);
+    return nums;
+}
+
+std::set<std::string> complex_set_function(int first, std::string const& second, bool third)
+{
+    EXPECT_EQ(first, 4);
+    EXPECT_EQ(second, "3");
+    EXPECT_EQ(third, false);
+
+    std::set<std::string> nums;
+    nums.insert(std::to_string(first));
+    nums.insert(second);
+    nums.insert(std::to_string(third));
+    return nums;
+}