Skip to content
Snippets Groups Projects
Commit 5c18d894 authored by Cheng Zhao's avatar Cheng Zhao
Browse files

Reimplement callback.h with C++11

parent 2ff104d0
No related merge requests found
Hide whitespace changes
Inline Side-by-side
atom/common/native_mate_converters/callback.h
+ 27
− 377
View file @ 5c18d894
......@@ -2,6 +2,8 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include <vector>
#include "base/bind.h"
#include "base/callback.h"
#include "native_mate/function_template.h"
......@@ -14,407 +16,55 @@ namespace internal {
typedef scoped_refptr<RefCountedPersistent<v8::Function> > SafeV8Function;
// This set of templates invokes a V8::Function by converting the C++ types.
template<typename Sig>
struct V8FunctionInvoker;
template<typename V>
struct V8FunctionInvoker<v8::Local<V>()> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> val(holder->Call(holder, 0, NULL));
return handle_scope.Escape(val);
}
};
template<typename R>
struct V8FunctionInvoker<R()> {
static R Go(v8::Isolate* isolate, SafeV8Function function) {
R ret;
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> val(holder->Call(holder, 0, NULL));
Converter<R>::FromV8(isolate, val, &ret);
return ret;
}
};
template<>
struct V8FunctionInvoker<void()> {
static void Go(v8::Isolate* isolate, SafeV8Function function) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
holder->Call(holder, 0, NULL);
}
};
template<typename V, typename P1>
struct V8FunctionInvoker<v8::Local<V>(P1)> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
return handle_scope.Escape(val);
}
};
template<typename R, typename P1>
struct V8FunctionInvoker<R(P1)> {
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1) {
R ret;
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
Converter<R>::FromV8(isolate, val, &ret);
return ret;
}
};
template<typename P1>
struct V8FunctionInvoker<void(P1)> {
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
};
holder->Call(holder, arraysize(args), args);
}
};
template<typename V, typename P1, typename P2>
struct V8FunctionInvoker<v8::Local<V>(P1, P2)> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
P2 a2) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
return handle_scope.Escape(val);
}
};
template<typename R, typename P1, typename P2>
struct V8FunctionInvoker<R(P1, P2)> {
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2) {
R ret;
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
Converter<R>::FromV8(isolate, val, &ret);
return ret;
}
};
template<typename P1, typename P2>
struct V8FunctionInvoker<void(P1, P2)> {
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
};
holder->Call(holder, arraysize(args), args);
}
};
template<typename V, typename P1, typename P2, typename P3>
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3)> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
P2 a2, P3 a3) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
return handle_scope.Escape(val);
}
};
template<typename R, typename P1, typename P2, typename P3>
struct V8FunctionInvoker<R(P1, P2, P3)> {
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3) {
R ret;
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
Converter<R>::FromV8(isolate, val, &ret);
return ret;
}
};
template<typename P1, typename P2, typename P3>
struct V8FunctionInvoker<void(P1, P2, P3)> {
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
};
holder->Call(holder, arraysize(args), args);
}
};
template<typename V, typename P1, typename P2, typename P3, typename P4>
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3, P4)> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
P2 a2, P3 a3, P4 a4) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
return handle_scope.Escape(val);
}
};
template<typename R, typename P1, typename P2, typename P3, typename P4>
struct V8FunctionInvoker<R(P1, P2, P3, P4)> {
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3, P4 a4) {
R ret;
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
Converter<R>::FromV8(isolate, val, &ret);
return ret;
}
};
template<typename P1, typename P2, typename P3, typename P4>
struct V8FunctionInvoker<void(P1, P2, P3, P4)> {
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3, P4 a4) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
};
holder->Call(holder, arraysize(args), args);
}
};
template <typename Sig>
struct V8FunctionInvoker {};
template<typename V, typename P1, typename P2, typename P3, typename P4,
typename P5>
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3, P4, P5)> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
P2 a2, P3 a3, P4 a4, P5 a5) {
template <typename... ArgTypes>
struct V8FunctionInvoker<v8::Local<v8::Value>(ArgTypes...)> {
static v8::Local<v8::Value> Go(v8::Isolate* isolate, SafeV8Function function,
ArgTypes... raw) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
ConvertToV8(isolate, a5),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
return handle_scope.Escape(val);
std::vector<v8::Local<v8::Value>> args = { ConvertToV8(isolate, raw)... };
v8::Local<v8::Value> ret(holder->Call(holder, args.size(), &args.front()));
return handle_scope.Escape(ret);
}
};
template<typename R, typename P1, typename P2, typename P3, typename P4,
typename P5>
struct V8FunctionInvoker<R(P1, P2, P3, P4, P5)> {
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3, P4 a4, P5 a5) {
R ret;
template <typename... ArgTypes>
struct V8FunctionInvoker<void(ArgTypes...)> {
static void Go(v8::Isolate* isolate, SafeV8Function function,
ArgTypes... raw) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
ConvertToV8(isolate, a5),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
Converter<R>::FromV8(isolate, val, &ret);
return ret;
std::vector<v8::Local<v8::Value>> args = { ConvertToV8(isolate, raw)... };
holder->Call(holder, args.size(), &args.front());
}
};
template<typename P1, typename P2, typename P3, typename P4, typename P5>
struct V8FunctionInvoker<void(P1, P2, P3, P4, P5)> {
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3, P4 a4, P5 a5) {
template <typename ReturnType, typename... ArgTypes>
struct V8FunctionInvoker<ReturnType(ArgTypes...)> {
static ReturnType Go(v8::Isolate* isolate, SafeV8Function function,
ArgTypes... raw) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
ConvertToV8(isolate, a5),
};
holder->Call(holder, arraysize(args), args);
}
};
template<typename V, typename P1, typename P2, typename P3, typename P4,
typename P5, typename P6>
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3, P4, P5, P6)> {
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) {
Locker locker(isolate);
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
ConvertToV8(isolate, a5),
ConvertToV8(isolate, a6),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
return handle_scope.Escape(val);
}
};
template<typename R, typename P1, typename P2, typename P3, typename P4,
typename P5, typename P6>
struct V8FunctionInvoker<R(P1, P2, P3, P4, P5, P6)> {
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3, P4 a4, P5 a5, P6 a6) {
R ret;
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
ConvertToV8(isolate, a5),
ConvertToV8(isolate, a6),
};
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
Converter<R>::FromV8(isolate, val, &ret);
ReturnType ret;
std::vector<v8::Local<v8::Value>> args = { ConvertToV8(isolate, raw)... };
v8::Local<v8::Value> val(holder->Call(holder, args.size(), &args.front()));
Converter<ReturnType>::FromV8(isolate, val, &ret);
return ret;
}
};
template<typename P1, typename P2, typename P3, typename P4, typename P5,
typename P6>
struct V8FunctionInvoker<void(P1, P2, P3, P4, P5, P6)> {
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
P3 a3, P4 a4, P5 a5, P6 a6) {
Locker locker(isolate);
MATE_HANDLE_SCOPE(isolate);
v8::Local<v8::Function> holder = function->NewHandle();
v8::Local<v8::Context> context = holder->CreationContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> args[] = {
ConvertToV8(isolate, a1),
ConvertToV8(isolate, a2),
ConvertToV8(isolate, a3),
ConvertToV8(isolate, a4),
ConvertToV8(isolate, a5),
ConvertToV8(isolate, a6),
};
holder->Call(holder, arraysize(args), args);
}
};
} // namespace internal
template<typename Sig>
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment