status-im
/
realm-js
mirror of https://github.com/status-im/realm-js.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Revert "Fix Node.js 10 support (#1937)" 

This reverts commit b5d7d8ceab.
This commit is contained in:
Yavor Georgiev 2018-07-25 15:35:06 +03:00
parent f1c9f8fe88
commit 5de2600133
No known key found for this signature in database
GPG Key ID: 83FC145DA0CCA9C3
15 changed files with 1529 additions and 788 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1754
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

2
package.json
View File

@ -83,7 +83,7 @@
"deepmerge": "2.1.0", "deepmerge": "2.1.0",
"fs-extra": "^4.0.2", "fs-extra": "^4.0.2",
"ini": "^1.3.4", "ini": "^1.3.4",
"nan": "^2.10.0", "nan": "2.8.0",
"node-fetch": "^1.6.3", "node-fetch": "^1.6.3",
"node-pre-gyp": "^0.6.36", "node-pre-gyp": "^0.6.36",
"progress": "^2.0.0", "progress": "^2.0.0",

23
src/js_class.hpp
View File

@ -27,6 +27,12 @@
namespace realm { namespace realm {
namespace js { namespace js {
template<typename T>
using ConstructorType = void(typename T::Context, typename T::Object, size_t, const typename T::Value[]);
template<typename T>
using MethodType = void(typename T::Context, typename T::Function, typename T::Object, size_t, const typename T::Value[], ReturnValue<T> &);
template<typename T> template<typename T>
struct Arguments { struct Arguments {
const typename T::Context ctx; const typename T::Context ctx;
@ -46,24 +52,15 @@ struct Arguments {
} }
} }
void validate_count(size_t expected) const { void validate_count(size_t actual) const {
if (count != expected) { if (count != actual) {
throw std::invalid_argument(util::format("Invalid arguments: %1 expected, but %2 supplied.", expected, count)); throw std::invalid_argument(util::format("Invalid arguments: %1 expected, but %s supplied.", actual, count));
}
}
void validate_between(size_t min, size_t max) const {
if (count < min || count > max) {
throw std::invalid_argument(util::format("Invalid arguments: expected between %1 and %2, but %3 supplied.", min, max, count));
} }
} }
}; };
template<typename T> template<typename T>
using ConstructorType = void(typename T::Context, typename T::Object, Arguments<T> &); using ArgumentsMethodType = void(typename T::Context, typename T::Object, Arguments<T>, ReturnValue<T> &);
template<typename T>
using ArgumentsMethodType = void(typename T::Context, typename T::Object, Arguments<T> &, ReturnValue<T> &);
template<typename T> template<typename T>
struct PropertyType { struct PropertyType {

56
src/js_list.hpp
View File

@ -65,22 +65,22 @@ struct ListClass : ClassDefinition<T, realm::js::List<T>, CollectionClass<T>> {
static bool set_index(ContextType, ObjectType, uint32_t, ValueType); static bool set_index(ContextType, ObjectType, uint32_t, ValueType);
// methods // methods
static void push(ContextType, ObjectType, Arguments &, ReturnValue &); static void push(ContextType, ObjectType, Arguments, ReturnValue &);
static void pop(ContextType, ObjectType, Arguments &, ReturnValue &); static void pop(ContextType, ObjectType, Arguments, ReturnValue &);
static void unshift(ContextType, ObjectType, Arguments &, ReturnValue &); static void unshift(ContextType, ObjectType, Arguments, ReturnValue &);
static void shift(ContextType, ObjectType, Arguments &, ReturnValue &); static void shift(ContextType, ObjectType, Arguments, ReturnValue &);
static void splice(ContextType, ObjectType, Arguments &, ReturnValue &); static void splice(ContextType, ObjectType, Arguments, ReturnValue &);
static void snapshot(ContextType, ObjectType, Arguments &, ReturnValue &); static void snapshot(ContextType, ObjectType, Arguments, ReturnValue &);
static void filtered(ContextType, ObjectType, Arguments &, ReturnValue &); static void filtered(ContextType, ObjectType, Arguments, ReturnValue &);
static void sorted(ContextType, ObjectType, Arguments &, ReturnValue &); static void sorted(ContextType, ObjectType, Arguments, ReturnValue &);
static void is_valid(ContextType, ObjectType, Arguments &, ReturnValue &); static void is_valid(ContextType, ObjectType, Arguments, ReturnValue &);
static void is_empty(ContextType, ObjectType, Arguments &, ReturnValue &); static void is_empty(ContextType, ObjectType, Arguments, ReturnValue &);
static void index_of(ContextType, ObjectType, Arguments &, ReturnValue &); static void index_of(ContextType, ObjectType, Arguments, ReturnValue &);
// observable // observable
static void add_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void add_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_all_listeners(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_all_listeners(ContextType, ObjectType, Arguments, ReturnValue &);
std::string const name = "List"; std::string const name = "List";
@ -157,7 +157,7 @@ bool ListClass<T>::set_index(ContextType ctx, ObjectType object, uint32_t index,
} }
template<typename T> template<typename T>
void ListClass<T>::push(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::push(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
for (size_t i = 0; i < args.count; i++) { for (size_t i = 0; i < args.count; i++) {
validate_value(ctx, *list, args[i]); validate_value(ctx, *list, args[i]);
@ -172,7 +172,7 @@ void ListClass<T>::push(ContextType ctx, ObjectType this_object, Arguments &args
} }
template<typename T> template<typename T>
void ListClass<T>::pop(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::pop(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
@ -188,7 +188,7 @@ void ListClass<T>::pop(ContextType ctx, ObjectType this_object, Arguments &args,
} }
template<typename T> template<typename T>
void ListClass<T>::unshift(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::unshift(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
for (size_t i = 0; i < args.count; i++) { for (size_t i = 0; i < args.count; i++) {
validate_value(ctx, *list, args[i]); validate_value(ctx, *list, args[i]);
@ -203,7 +203,7 @@ void ListClass<T>::unshift(ContextType ctx, ObjectType this_object, Arguments &a
} }
template<typename T> template<typename T>
void ListClass<T>::shift(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::shift(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
@ -218,7 +218,7 @@ void ListClass<T>::shift(ContextType ctx, ObjectType this_object, Arguments &arg
} }
template<typename T> template<typename T>
void ListClass<T>::splice(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::splice(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
size_t size = list->size(); size_t size = list->size();
long index = std::min<long>(Value::to_number(ctx, args[0]), size); long index = std::min<long>(Value::to_number(ctx, args[0]), size);
@ -251,36 +251,36 @@ void ListClass<T>::splice(ContextType ctx, ObjectType this_object, Arguments &ar
} }
template<typename T> template<typename T>
void ListClass<T>::snapshot(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::snapshot(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
return_value.set(ResultsClass<T>::create_instance(ctx, list->snapshot())); return_value.set(ResultsClass<T>::create_instance(ctx, list->snapshot()));
} }
template<typename T> template<typename T>
void ListClass<T>::filtered(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::filtered(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
return_value.set(ResultsClass<T>::create_filtered(ctx, *list, args)); return_value.set(ResultsClass<T>::create_filtered(ctx, *list, args));
} }
template<typename T> template<typename T>
void ListClass<T>::sorted(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::sorted(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
return_value.set(ResultsClass<T>::create_instance(ctx, list->sort(ResultsClass<T>::get_keypaths(ctx, args)))); return_value.set(ResultsClass<T>::create_instance(ctx, list->sort(ResultsClass<T>::get_keypaths(ctx, args))));
} }
template<typename T> template<typename T>
void ListClass<T>::is_valid(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::is_valid(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
return_value.set(get_internal<T, ListClass<T>>(this_object)->is_valid()); return_value.set(get_internal<T, ListClass<T>>(this_object)->is_valid());
} }
template<typename T> template<typename T>
void ListClass<T>::is_empty(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::is_empty(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
return_value.set(get_internal<T, ListClass<T>>(this_object)->size() == 0); return_value.set(get_internal<T, ListClass<T>>(this_object)->size() == 0);
} }
template<typename T> template<typename T>
void ListClass<T>::index_of(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::index_of(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto fn = [&](auto&& row) { auto fn = [&](auto&& row) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
NativeAccessor<T> accessor(ctx, *list); NativeAccessor<T> accessor(ctx, *list);
@ -290,19 +290,19 @@ void ListClass<T>::index_of(ContextType ctx, ObjectType this_object, Arguments &
} }
template<typename T> template<typename T>
void ListClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
ResultsClass<T>::add_listener(ctx, *list, this_object, args); ResultsClass<T>::add_listener(ctx, *list, this_object, args);
} }
template<typename T> template<typename T>
void ListClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
ResultsClass<T>::remove_listener(ctx, *list, this_object, args); ResultsClass<T>::remove_listener(ctx, *list, this_object, args);
} }
template<typename T> template<typename T>
void ListClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ListClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto list = get_internal<T, ListClass<T>>(this_object); auto list = get_internal<T, ListClass<T>>(this_object);
list->m_notification_tokens.clear(); list->m_notification_tokens.clear();

102
src/js_realm.hpp
View File

@ -218,25 +218,25 @@ public:
static FunctionType create_constructor(ContextType); static FunctionType create_constructor(ContextType);
// methods // methods
static void objects(ContextType, ObjectType, Arguments &, ReturnValue &); static void objects(ContextType, ObjectType, Arguments, ReturnValue &);
static void object_for_primary_key(ContextType, ObjectType, Arguments &, ReturnValue &); static void object_for_primary_key(ContextType, ObjectType, Arguments, ReturnValue &);
static void create(ContextType, ObjectType, Arguments &, ReturnValue &); static void create(ContextType, ObjectType, Arguments, ReturnValue &);
static void delete_one(ContextType, ObjectType, Arguments &, ReturnValue &); static void delete_one(ContextType, ObjectType, Arguments, ReturnValue &);
static void delete_all(ContextType, ObjectType, Arguments &, ReturnValue &); static void delete_all(ContextType, ObjectType, Arguments, ReturnValue &);
static void write(ContextType, ObjectType, Arguments &, ReturnValue &); static void write(ContextType, ObjectType, Arguments, ReturnValue &);
static void begin_transaction(ContextType, ObjectType, Arguments &, ReturnValue&); static void begin_transaction(ContextType, ObjectType, Arguments, ReturnValue&);
static void commit_transaction(ContextType, ObjectType, Arguments &, ReturnValue&); static void commit_transaction(ContextType, ObjectType, Arguments, ReturnValue&);
static void cancel_transaction(ContextType, ObjectType, Arguments &, ReturnValue&); static void cancel_transaction(ContextType, ObjectType, Arguments, ReturnValue&);
static void add_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void add_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void wait_for_download_completion(ContextType, ObjectType, Arguments &, ReturnValue &); static void wait_for_download_completion(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_all_listeners(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_all_listeners(ContextType, ObjectType, Arguments, ReturnValue &);
static void close(ContextType, ObjectType, Arguments &, ReturnValue &); static void close(ContextType, ObjectType, Arguments, ReturnValue &);
static void compact(ContextType, ObjectType, Arguments &, ReturnValue &); static void compact(ContextType, ObjectType, Arguments, ReturnValue &);
static void writeCopyTo(ContextType, ObjectType, Arguments &, ReturnValue &); static void writeCopyTo(ContextType, ObjectType, Arguments, ReturnValue &);
static void delete_model(ContextType, ObjectType, Arguments &, ReturnValue &); static void delete_model(ContextType, ObjectType, Arguments, ReturnValue &);
static void object_for_object_id(ContextType, ObjectType, Arguments &, ReturnValue&); static void object_for_object_id(ContextType, ObjectType, Arguments, ReturnValue&);
static void privileges(ContextType, ObjectType, Arguments &, ReturnValue&); static void privileges(ContextType, ObjectType, Arguments, ReturnValue&);
// properties // properties
static void get_empty(ContextType, ObjectType, ReturnValue &); static void get_empty(ContextType, ObjectType, ReturnValue &);
@ -252,13 +252,13 @@ public:
#endif #endif
// static methods // static methods
static void constructor(ContextType, ObjectType, Arguments &); static void constructor(ContextType, ObjectType, size_t, const ValueType[]);
static SharedRealm create_shared_realm(ContextType, realm::Realm::Config, bool, ObjectDefaultsMap &&, ConstructorMap &&); static SharedRealm create_shared_realm(ContextType, realm::Realm::Config, bool, ObjectDefaultsMap &&, ConstructorMap &&);
static void schema_version(ContextType, ObjectType, Arguments &, ReturnValue &); static void schema_version(ContextType, ObjectType, Arguments, ReturnValue &);
static void clear_test_state(ContextType, ObjectType, Arguments &, ReturnValue &); static void clear_test_state(ContextType, ObjectType, Arguments, ReturnValue &);
static void copy_bundled_realm_files(ContextType, ObjectType, Arguments &, ReturnValue &); static void copy_bundled_realm_files(ContextType, ObjectType, Arguments, ReturnValue &);
static void delete_file(ContextType, ObjectType, Arguments &, ReturnValue &); static void delete_file(ContextType, ObjectType, Arguments, ReturnValue &);
// static properties // static properties
static void get_default_path(ContextType, ObjectType, ReturnValue &); static void get_default_path(ContextType, ObjectType, ReturnValue &);
@ -434,17 +434,17 @@ static inline void convert_outdated_datetime_columns(const SharedRealm &realm) {
} }
template<typename T> template<typename T>
void RealmClass<T>::constructor(ContextType ctx, ObjectType this_object, Arguments &args) { void RealmClass<T>::constructor(ContextType ctx, ObjectType this_object, size_t argc, const ValueType arguments[]) {
realm::Realm::Config config; realm::Realm::Config config;
ObjectDefaultsMap defaults; ObjectDefaultsMap defaults;
ConstructorMap constructors; ConstructorMap constructors;
bool schema_updated = false; bool schema_updated = false;
if (args.count == 0) { if (argc == 0) {
config.path = default_path(); config.path = default_path();
} }
else if (args.count == 1) { else if (argc == 1) {
ValueType value = args[0]; ValueType value = arguments[0];
if (Value::is_string(ctx, value)) { if (Value::is_string(ctx, value)) {
config.path = Value::validated_to_string(ctx, value, "path"); config.path = Value::validated_to_string(ctx, value, "path");
} }
@ -628,7 +628,7 @@ SharedRealm RealmClass<T>::create_shared_realm(ContextType ctx, realm::Realm::Co
} }
template<typename T> template<typename T>
void RealmClass<T>::schema_version(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::schema_version(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(2); args.validate_maximum(2);
realm::Realm::Config config; realm::Realm::Config config;
@ -649,19 +649,19 @@ void RealmClass<T>::schema_version(ContextType ctx, ObjectType this_object, Argu
template<typename T> template<typename T>
void RealmClass<T>::clear_test_state(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::clear_test_state(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
js::clear_test_state(); js::clear_test_state();
} }
template<typename T> template<typename T>
void RealmClass<T>::copy_bundled_realm_files(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::copy_bundled_realm_files(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
realm::copy_bundled_realm_files(); realm::copy_bundled_realm_files();
} }
template<typename T> template<typename T>
void RealmClass<T>::delete_file(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::delete_file(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
ValueType value = args[0]; ValueType value = args[0];
@ -692,7 +692,7 @@ void RealmClass<T>::delete_file(ContextType ctx, ObjectType this_object, Argumen
} }
template<typename T> template<typename T>
void RealmClass<T>::delete_model(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::delete_model(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
ValueType value = args[0]; ValueType value = args[0];
@ -772,7 +772,7 @@ void RealmClass<T>::get_sync_session(ContextType ctx, ObjectType object, ReturnV
#if REALM_ENABLE_SYNC #if REALM_ENABLE_SYNC
template<typename T> template<typename T>
void RealmClass<T>::wait_for_download_completion(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::wait_for_download_completion(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(2); args.validate_maximum(2);
auto callback_function = Value::validated_to_function(ctx, args[0 + (args.count == 2)]); auto callback_function = Value::validated_to_function(ctx, args[0 + (args.count == 2)]);
@ -840,7 +840,7 @@ void RealmClass<T>::wait_for_download_completion(ContextType ctx, ObjectType thi
#endif #endif
template<typename T> template<typename T>
void RealmClass<T>::objects(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::objects(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -849,7 +849,7 @@ void RealmClass<T>::objects(ContextType ctx, ObjectType this_object, Arguments &
} }
template<typename T> template<typename T>
void RealmClass<T>::object_for_primary_key(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::object_for_primary_key(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(2); args.validate_maximum(2);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -867,7 +867,7 @@ void RealmClass<T>::object_for_primary_key(ContextType ctx, ObjectType this_obje
} }
template<typename T> template<typename T>
void RealmClass<T>::create(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::create(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(3); args.validate_maximum(3);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -890,7 +890,7 @@ void RealmClass<T>::create(ContextType ctx, ObjectType this_object, Arguments &a
} }
template<typename T> template<typename T>
void RealmClass<T>::delete_one(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::delete_one(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -938,7 +938,7 @@ void RealmClass<T>::delete_one(ContextType ctx, ObjectType this_object, Argument
} }
template<typename T> template<typename T>
void RealmClass<T>::delete_all(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::delete_all(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -960,7 +960,7 @@ void RealmClass<T>::delete_all(ContextType ctx, ObjectType this_object, Argument
} }
template<typename T> template<typename T>
void RealmClass<T>::write(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::write(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -980,7 +980,7 @@ void RealmClass<T>::write(ContextType ctx, ObjectType this_object, Arguments &ar
} }
template<typename T> template<typename T>
void RealmClass<T>::begin_transaction(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::begin_transaction(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -988,7 +988,7 @@ void RealmClass<T>::begin_transaction(ContextType ctx, ObjectType this_object, A
} }
template<typename T> template<typename T>
void RealmClass<T>::commit_transaction(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::commit_transaction(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -996,7 +996,7 @@ void RealmClass<T>::commit_transaction(ContextType ctx, ObjectType this_object,
} }
template<typename T> template<typename T>
void RealmClass<T>::cancel_transaction(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::cancel_transaction(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -1004,7 +1004,7 @@ void RealmClass<T>::cancel_transaction(ContextType ctx, ObjectType this_object,
} }
template<typename T> template<typename T>
void RealmClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(2); args.validate_maximum(2);
auto name = validated_notification_name(ctx, args[0]); auto name = validated_notification_name(ctx, args[0]);
@ -1021,7 +1021,7 @@ void RealmClass<T>::add_listener(ContextType ctx, ObjectType this_object, Argume
} }
template<typename T> template<typename T>
void RealmClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(2); args.validate_maximum(2);
auto name = validated_notification_name(ctx, args[0]); auto name = validated_notification_name(ctx, args[0]);
@ -1038,7 +1038,7 @@ void RealmClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arg
} }
template<typename T> template<typename T>
void RealmClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
std::string name = "change"; std::string name = "change";
if (args.count) { if (args.count) {
@ -1056,7 +1056,7 @@ void RealmClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object
} }
template<typename T> template<typename T>
void RealmClass<T>::close(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::close(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -1064,7 +1064,7 @@ void RealmClass<T>::close(ContextType ctx, ObjectType this_object, Arguments &ar
} }
template<typename T> template<typename T>
void RealmClass<T>::compact(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::compact(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object); SharedRealm realm = *get_internal<T, RealmClass<T>>(this_object);
@ -1076,7 +1076,7 @@ void RealmClass<T>::compact(ContextType ctx, ObjectType this_object, Arguments &
} }
template<typename T> template<typename T>
void RealmClass<T>::writeCopyTo(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::writeCopyTo(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(2); args.validate_maximum(2);
if (args.count == 0) { if (args.count == 0) {
@ -1106,7 +1106,7 @@ void RealmClass<T>::writeCopyTo(ContextType ctx, ObjectType this_object, Argumen
} }
template<typename T> template<typename T>
void RealmClass<T>::object_for_object_id(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue& return_value) { void RealmClass<T>::object_for_object_id(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue& return_value) {
args.validate_count(2); args.validate_count(2);
#if REALM_ENABLE_SYNC #if REALM_ENABLE_SYNC
@ -1129,7 +1129,7 @@ void RealmClass<T>::object_for_object_id(ContextType ctx, ObjectType this_object
} }
template<typename T> template<typename T>
void RealmClass<T>::privileges(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void RealmClass<T>::privileges(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
using Privilege = realm::ComputedPrivileges; using Privilege = realm::ComputedPrivileges;

34
src/js_realm_object.hpp
View File

@ -50,13 +50,13 @@ struct RealmObjectClass : ClassDefinition<T, realm::Object> {
static bool set_property(ContextType, ObjectType, const String &, ValueType); static bool set_property(ContextType, ObjectType, const String &, ValueType);
static std::vector<String> get_property_names(ContextType, ObjectType); static std::vector<String> get_property_names(ContextType, ObjectType);
static void is_valid(ContextType, ObjectType, Arguments &, ReturnValue &); static void is_valid(ContextType, FunctionType, ObjectType, size_t, const ValueType [], ReturnValue &);
static void get_object_schema(ContextType, ObjectType, Arguments &, ReturnValue &); static void get_object_schema(ContextType, FunctionType, ObjectType, size_t, const ValueType [], ReturnValue &);
static void linking_objects(ContextType, ObjectType, Arguments &, ReturnValue &); static void linking_objects(ContextType, FunctionType, ObjectType, size_t, const ValueType [], ReturnValue &);
static void linking_objects_count(ContextType, ObjectType, Arguments &, ReturnValue &); static void linking_objects_count(ContextType, FunctionType, ObjectType, size_t, const ValueType [], ReturnValue &);
static void get_object_id(ContextType, ObjectType, Arguments &, ReturnValue &); static void get_object_id(ContextType, ObjectType, Arguments, ReturnValue &);
static void is_same_object(ContextType, ObjectType, Arguments &, ReturnValue &); static void is_same_object(ContextType, ObjectType, Arguments, ReturnValue &);
static void set_link(ContextType, ObjectType, Arguments &, ReturnValue &); static void set_link(ContextType, ObjectType, Arguments, ReturnValue &);
const std::string name = "RealmObject"; const std::string name = "RealmObject";
@ -78,12 +78,12 @@ struct RealmObjectClass : ClassDefinition<T, realm::Object> {
}; };
template<typename T> template<typename T>
void RealmObjectClass<T>::is_valid(ContextType, ObjectType this_object, Arguments &, ReturnValue &return_value) { void RealmObjectClass<T>::is_valid(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
return_value.set(get_internal<T, RealmObjectClass<T>>(this_object)->is_valid()); return_value.set(get_internal<T, RealmObjectClass<T>>(this_object)->is_valid());
} }
template<typename T> template<typename T>
void RealmObjectClass<T>::get_object_schema(ContextType ctx, ObjectType this_object, Arguments &, ReturnValue &return_value) { void RealmObjectClass<T>::get_object_schema(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
auto object = get_internal<T, RealmObjectClass<T>>(this_object); auto object = get_internal<T, RealmObjectClass<T>>(this_object);
return_value.set(Schema<T>::object_for_object_schema(ctx, object->get_object_schema())); return_value.set(Schema<T>::object_for_object_schema(ctx, object->get_object_schema()));
} }
@ -143,7 +143,7 @@ bool RealmObjectClass<T>::set_property(ContextType ctx, ObjectType object, const
} }
template<typename T> template<typename T>
void RealmObjectClass<T>::set_link(ContextType ctx, ObjectType object, Arguments &args, ReturnValue& return_value) { void RealmObjectClass<T>::set_link(ContextType ctx, ObjectType object, Arguments args, ReturnValue& return_value) {
args.validate_count(2); args.validate_count(2);
auto realm_object = get_internal<T, RealmObjectClass<T>>(object); auto realm_object = get_internal<T, RealmObjectClass<T>>(object);
@ -208,7 +208,7 @@ std::vector<String<T>> RealmObjectClass<T>::get_property_names(ContextType ctx,
} }
template<typename T> template<typename T>
void RealmObjectClass<T>::get_object_id(ContextType ctx, ObjectType object, Arguments &args, ReturnValue& return_value) { void RealmObjectClass<T>::get_object_id(ContextType ctx, ObjectType object, Arguments args, ReturnValue& return_value) {
args.validate_maximum(0); args.validate_maximum(0);
#if REALM_ENABLE_SYNC #if REALM_ENABLE_SYNC
@ -226,7 +226,7 @@ void RealmObjectClass<T>::get_object_id(ContextType ctx, ObjectType object, Argu
} }
template<typename T> template<typename T>
void RealmObjectClass<T>::is_same_object(ContextType ctx, ObjectType object, Arguments &args, ReturnValue& return_value) { void RealmObjectClass<T>::is_same_object(ContextType ctx, ObjectType object, Arguments args, ReturnValue& return_value) {
args.validate_count(1); args.validate_count(1);
ObjectType otherObject = Value::validated_to_object(ctx, args[0]); ObjectType otherObject = Value::validated_to_object(ctx, args[0]);
@ -253,7 +253,7 @@ void RealmObjectClass<T>::is_same_object(ContextType ctx, ObjectType object, Arg
} }
template<typename T> template<typename T>
void RealmObjectClass<T>::linking_objects_count(ContextType, ObjectType object, Arguments &, ReturnValue &return_value) { void RealmObjectClass<T>::linking_objects_count(ContextType ctx, FunctionType, ObjectType object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
auto realm_object = get_internal<T, RealmObjectClass<T>>(object); auto realm_object = get_internal<T, RealmObjectClass<T>>(object);
const Row& row = realm_object->row(); const Row& row = realm_object->row();
@ -268,11 +268,11 @@ void RealmObjectClass<T>::linking_objects_count(ContextType, ObjectType object,
#include "js_results.hpp" #include "js_results.hpp"
template<typename T> template<typename T>
void realm::js::RealmObjectClass<T>::linking_objects(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void realm::js::RealmObjectClass<T>::linking_objects(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_count(2); validate_argument_count(argc, 2);
std::string object_type = Value::validated_to_string(ctx, args[0], "objectType"); std::string object_type = Value::validated_to_string(ctx, arguments[0], "objectType");
std::string property_name = Value::validated_to_string(ctx, args[1], "property"); std::string property_name = Value::validated_to_string(ctx, arguments[1], "property");
auto object = get_internal<T, RealmObjectClass<T>>(this_object); auto object = get_internal<T, RealmObjectClass<T>>(this_object);

70
src/js_results.hpp
View File

@ -74,40 +74,40 @@ struct ResultsClass : ClassDefinition<T, realm::js::Results<T>, CollectionClass<
static ObjectType create_instance(ContextType, SharedRealm, const std::string &object_type); static ObjectType create_instance(ContextType, SharedRealm, const std::string &object_type);
template<typename U> template<typename U>
static ObjectType create_filtered(ContextType, const U &, Arguments &); static ObjectType create_filtered(ContextType, const U &, Arguments);
static std::vector<std::pair<std::string, bool>> get_keypaths(ContextType, Arguments &); static std::vector<std::pair<std::string, bool>> get_keypaths(ContextType, Arguments);
static void get_length(ContextType, ObjectType, ReturnValue &); static void get_length(ContextType, ObjectType, ReturnValue &);
static void get_type(ContextType, ObjectType, ReturnValue &); static void get_type(ContextType, ObjectType, ReturnValue &);
static void get_optional(ContextType, ObjectType, ReturnValue &); static void get_optional(ContextType, ObjectType, ReturnValue &);
static void get_index(ContextType, ObjectType, uint32_t, ReturnValue &); static void get_index(ContextType, ObjectType, uint32_t, ReturnValue &);
static void snapshot(ContextType, ObjectType, Arguments &, ReturnValue &); static void snapshot(ContextType, ObjectType, Arguments, ReturnValue &);
static void filtered(ContextType, ObjectType, Arguments &, ReturnValue &); static void filtered(ContextType, ObjectType, Arguments, ReturnValue &);
static void sorted(ContextType, ObjectType, Arguments &, ReturnValue &); static void sorted(ContextType, ObjectType, Arguments, ReturnValue &);
static void is_valid(ContextType, ObjectType, Arguments &, ReturnValue &); static void is_valid(ContextType, ObjectType, Arguments, ReturnValue &);
static void is_empty(ContextType, ObjectType, Arguments &, ReturnValue &); static void is_empty(ContextType, ObjectType, Arguments, ReturnValue &);
#if REALM_ENABLE_SYNC #if REALM_ENABLE_SYNC
static void subscribe(ContextType, ObjectType, Arguments &, ReturnValue &); static void subscribe(ContextType, ObjectType, Arguments, ReturnValue &);
#endif #endif
static void index_of(ContextType, ObjectType, Arguments &, ReturnValue &); static void index_of(ContextType, ObjectType, Arguments, ReturnValue &);
template<typename Fn> template<typename Fn>
static void index_of(ContextType, Fn&, Arguments &, ReturnValue &); static void index_of(ContextType, Fn&, Arguments, ReturnValue &);
static void update(ContextType, ObjectType, Arguments &, ReturnValue &); static void update(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
// observable // observable
static void add_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void add_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_all_listeners(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_all_listeners(ContextType, ObjectType, Arguments, ReturnValue &);
template<typename U> template<typename U>
static void add_listener(ContextType, U&, ObjectType, Arguments &); static void add_listener(ContextType, U&, ObjectType, Arguments);
template<typename U> template<typename U>
static void remove_listener(ContextType, U&, ObjectType, Arguments &); static void remove_listener(ContextType, U&, ObjectType, Arguments);
std::string const name = "Results"; std::string const name = "Results";
@ -171,7 +171,7 @@ inline void alias_backlinks(parser::KeyPathMapping &mapping, const realm::Shared
template<typename T> template<typename T>
template<typename U> template<typename U>
typename T::Object ResultsClass<T>::create_filtered(ContextType ctx, const U &collection, Arguments &args) { typename T::Object ResultsClass<T>::create_filtered(ContextType ctx, const U &collection, Arguments args) {
if (collection.get_type() != realm::PropertyType::Object) { if (collection.get_type() != realm::PropertyType::Object) {
throw std::runtime_error("Filtering non-object Lists and Results is not yet implemented."); throw std::runtime_error("Filtering non-object Lists and Results is not yet implemented.");
} }
@ -196,7 +196,7 @@ typename T::Object ResultsClass<T>::create_filtered(ContextType ctx, const U &co
template<typename T> template<typename T>
std::vector<std::pair<std::string, bool>> std::vector<std::pair<std::string, bool>>
ResultsClass<T>::get_keypaths(ContextType ctx, Arguments &args) { ResultsClass<T>::get_keypaths(ContextType ctx, Arguments args) {
args.validate_maximum(2); args.validate_maximum(2);
std::vector<std::pair<std::string, bool>> sort_order; std::vector<std::pair<std::string, bool>> sort_order;
@ -262,37 +262,37 @@ void ResultsClass<T>::get_index(ContextType ctx, ObjectType object, uint32_t ind
} }
template<typename T> template<typename T>
void ResultsClass<T>::snapshot(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::snapshot(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
return_value.set(ResultsClass<T>::create_instance(ctx, results->snapshot())); return_value.set(ResultsClass<T>::create_instance(ctx, results->snapshot()));
} }
template<typename T> template<typename T>
void ResultsClass<T>::filtered(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::filtered(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
return_value.set(create_filtered(ctx, *results, args)); return_value.set(create_filtered(ctx, *results, args));
} }
template<typename T> template<typename T>
void ResultsClass<T>::sorted(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::sorted(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
return_value.set(ResultsClass<T>::create_instance(ctx, results->sort(ResultsClass<T>::get_keypaths(ctx, args)))); return_value.set(ResultsClass<T>::create_instance(ctx, results->sort(ResultsClass<T>::get_keypaths(ctx, args))));
} }
template<typename T> template<typename T>
void ResultsClass<T>::is_valid(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::is_valid(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
return_value.set(get_internal<T, ResultsClass<T>>(this_object)->is_valid()); return_value.set(get_internal<T, ResultsClass<T>>(this_object)->is_valid());
} }
template<typename T> template<typename T>
void ResultsClass<T>::is_empty(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::is_empty(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
return_value.set(get_internal<T, ResultsClass<T>>(this_object)->size() == 0); return_value.set(get_internal<T, ResultsClass<T>>(this_object)->size() == 0);
} }
#if REALM_ENABLE_SYNC #if REALM_ENABLE_SYNC
template<typename T> template<typename T>
void ResultsClass<T>::subscribe(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::subscribe(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
@ -314,7 +314,7 @@ void ResultsClass<T>::subscribe(ContextType ctx, ObjectType this_object, Argumen
template<typename T> template<typename T>
template<typename Fn> template<typename Fn>
void ResultsClass<T>::index_of(ContextType ctx, Fn& fn, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::index_of(ContextType ctx, Fn& fn, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
size_t ndx; size_t ndx;
@ -337,10 +337,10 @@ void ResultsClass<T>::index_of(ContextType ctx, Fn& fn, Arguments &args, ReturnV
} }
template<typename T> template<typename T>
void ResultsClass<T>::update(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::update(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_maximum(2); validate_argument_count(argc, 2);
std::string property = Value::validated_to_string(ctx, args[0], "property"); std::string property = Value::validated_to_string(ctx, arguments[0], "property");
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
auto schema = results->get_object_schema(); auto schema = results->get_object_schema();
@ -358,13 +358,13 @@ void ResultsClass<T>::update(ContextType ctx, ObjectType this_object, Arguments
for (auto i = results->size(); i > 0; i--) { for (auto i = results->size(); i > 0; i--) {
auto realm_object = realm::Object(realm, schema, results->get(i - 1)); auto realm_object = realm::Object(realm, schema, results->get(i - 1));
auto obj = RealmObjectClass<T>::create_instance(ctx, realm_object); auto obj = RealmObjectClass<T>::create_instance(ctx, realm_object);
RealmObjectClass<T>::set_property(ctx, obj, property, args[1]); RealmObjectClass<T>::set_property(ctx, obj, property, arguments[1]);
} }
} }
template<typename T> template<typename T>
void ResultsClass<T>::index_of(ContextType ctx, ObjectType this_object, void ResultsClass<T>::index_of(ContextType ctx, ObjectType this_object,
Arguments &args, ReturnValue &return_value) { Arguments args, ReturnValue &return_value) {
auto fn = [&](auto&& row) { auto fn = [&](auto&& row) {
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
NativeAccessor<T> accessor(ctx, *results); NativeAccessor<T> accessor(ctx, *results);
@ -375,7 +375,7 @@ void ResultsClass<T>::index_of(ContextType ctx, ObjectType this_object,
template<typename T> template<typename T>
template<typename U> template<typename U>
void ResultsClass<T>::add_listener(ContextType ctx, U& collection, ObjectType this_object, Arguments &args) { void ResultsClass<T>::add_listener(ContextType ctx, U& collection, ObjectType this_object, Arguments args) {
args.validate_maximum(1); args.validate_maximum(1);
auto callback = Value::validated_to_function(ctx, args[0]); auto callback = Value::validated_to_function(ctx, args[0]);
@ -395,14 +395,14 @@ void ResultsClass<T>::add_listener(ContextType ctx, U& collection, ObjectType th
} }
template<typename T> template<typename T>
void ResultsClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
add_listener(ctx, *results, this_object, args); add_listener(ctx, *results, this_object, args);
} }
template<typename T> template<typename T>
template<typename U> template<typename U>
void ResultsClass<T>::remove_listener(ContextType ctx, U& collection, ObjectType this_object, Arguments &args) { void ResultsClass<T>::remove_listener(ContextType ctx, U& collection, ObjectType this_object, Arguments args) {
args.validate_maximum(1); args.validate_maximum(1);
auto callback = Value::validated_to_function(ctx, args[0]); auto callback = Value::validated_to_function(ctx, args[0]);
@ -416,13 +416,13 @@ void ResultsClass<T>::remove_listener(ContextType ctx, U& collection, ObjectType
} }
template<typename T> template<typename T>
void ResultsClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);
remove_listener(ctx, *results, this_object, args); remove_listener(ctx, *results, this_object, args);
} }
template<typename T> template<typename T>
void ResultsClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void ResultsClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto results = get_internal<T, ResultsClass<T>>(this_object); auto results = get_internal<T, ResultsClass<T>>(this_object);

128
src/js_sync.hpp
View File

@ -89,9 +89,9 @@ public:
{"isAdminToken", {wrap<is_admin_token>, nullptr}}, {"isAdminToken", {wrap<is_admin_token>, nullptr}},
}; };
static void create_user(ContextType, ObjectType, Arguments &, ReturnValue &); static void create_user(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void admin_user(ContextType, ObjectType, Arguments &, ReturnValue &); static void admin_user(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void get_existing_user(ContextType, ObjectType, Arguments &, ReturnValue&); static void get_existing_user(ContextType, ObjectType, Arguments, ReturnValue&);
MethodMap<T> const static_methods = { MethodMap<T> const static_methods = {
{"createUser", wrap<create_user>}, {"createUser", wrap<create_user>},
@ -100,15 +100,15 @@ public:
}; };
/*static void current_user(ContextType ctx, ObjectType object, ReturnValue &return_value);*/ /*static void current_user(ContextType ctx, ObjectType object, ReturnValue &return_value);*/
static void all_users(ContextType ctx, ObjectType object, ReturnValue &); static void all_users(ContextType ctx, ObjectType object, ReturnValue &return_value);
PropertyMap<T> const static_properties = { PropertyMap<T> const static_properties = {
/*{"current", {wrap<current_user>, nullptr}},*/ /*{"current", {wrap<current_user>, nullptr}},*/
{"all", {wrap<all_users>, nullptr}}, {"all", {wrap<all_users>, nullptr}},
}; };
static void logout(ContextType, ObjectType, Arguments &, ReturnValue &); static void logout(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void session_for_on_disk_path(ContextType, ObjectType, Arguments &, ReturnValue &); static void session_for_on_disk_path(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
MethodMap<T> const methods = { MethodMap<T> const methods = {
{"_logout", wrap<logout>}, {"_logout", wrap<logout>},
@ -145,39 +145,39 @@ void UserClass<T>::is_admin_token(ContextType ctx, ObjectType object, ReturnValu
} }
template<typename T> template<typename T>
void UserClass<T>::create_user(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void UserClass<T>::create_user(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_between(3, 5); validate_argument_count(argc, 3, 5);
SyncUserIdentifier userIdentifier { SyncUserIdentifier userIdentifier {
Value::validated_to_string(ctx, args[1], "identity"), Value::validated_to_string(ctx, arguments[1], "identity"),
Value::validated_to_string(ctx, args[0], "authServerUrl") Value::validated_to_string(ctx, arguments[0], "authServerUrl")
}; };
SharedUser *user = new SharedUser(syncManagerShared().get_user( SharedUser *user = new SharedUser(syncManagerShared().get_user(
userIdentifier, userIdentifier,
Value::validated_to_string(ctx, args[2], "refreshToken") Value::validated_to_string(ctx, arguments[2], "refreshToken")
)); ));
if (args.count == 5) { if (argc == 5) {
(*user)->set_is_admin(Value::validated_to_boolean(ctx, args[4], "isAdmin")); (*user)->set_is_admin(Value::validated_to_boolean(ctx, arguments[4], "isAdmin"));
} }
return_value.set(create_object<T, UserClass<T>>(ctx, user)); return_value.set(create_object<T, UserClass<T>>(ctx, user));
} }
template<typename T> template<typename T>
void UserClass<T>::admin_user(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void UserClass<T>::admin_user(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_count(2); validate_argument_count(argc, 2, 2);
SharedUser *user = new SharedUser(syncManagerShared().get_admin_token_user( SharedUser *user = new SharedUser(syncManagerShared().get_admin_token_user(
Value::validated_to_string(ctx, args[0], "authServerUrl"), Value::validated_to_string(ctx, arguments[0], "authServerUrl"),
Value::validated_to_string(ctx, args[1], "refreshToken") Value::validated_to_string(ctx, arguments[1], "refreshToken")
)); ));
return_value.set(create_object<T, UserClass<T>>(ctx, user)); return_value.set(create_object<T, UserClass<T>>(ctx, user));
} }
template<typename T> template<typename T>
void UserClass<T>::get_existing_user(ContextType ctx, ObjectType, Arguments &args, ReturnValue &return_value) { void UserClass<T>::get_existing_user(ContextType ctx, ObjectType, Arguments arguments, ReturnValue& return_value) {
args.validate_count(2); arguments.validate_count(2);
if (auto user = syncManagerShared().get_existing_logged_in_user(SyncUserIdentifier{ if (auto user = syncManagerShared().get_existing_logged_in_user(SyncUserIdentifier{
Value::validated_to_string(ctx, args[1], "identity"), Value::validated_to_string(ctx, arguments[1], "identity"),
Value::validated_to_string(ctx, args[0], "authServerUrl")})) { Value::validated_to_string(ctx, arguments[0], "authServerUrl")})) {
return_value.set(create_object<T, UserClass<T>>(ctx, new SharedUser(std::move(user)))); return_value.set(create_object<T, UserClass<T>>(ctx, new SharedUser(std::move(user))));
} }
} }
@ -194,7 +194,7 @@ void UserClass<T>::all_users(ContextType ctx, ObjectType object, ReturnValue &re
} }
template<typename T> template<typename T>
void UserClass<T>::logout(ContextType, ObjectType this_object, Arguments &, ReturnValue &) { void UserClass<T>::logout(ContextType ctx, FunctionType, ObjectType this_object, size_t, const ValueType[], ReturnValue &) {
get_internal<T, UserClass<T>>(this_object)->get()->log_out(); get_internal<T, UserClass<T>>(this_object)->get()->log_out();
} }
@ -221,12 +221,12 @@ public:
static void get_url(ContextType, ObjectType, ReturnValue &); static void get_url(ContextType, ObjectType, ReturnValue &);
static void get_state(ContextType, ObjectType, ReturnValue &); static void get_state(ContextType, ObjectType, ReturnValue &);
static void simulate_error(ContextType, ObjectType, Arguments &, ReturnValue &); static void simulate_error(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void refresh_access_token(ContextType, ObjectType, Arguments &, ReturnValue &); static void refresh_access_token(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void add_progress_notification(ContextType, ObjectType, Arguments &, ReturnValue &); static void add_progress_notification(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &);
static void remove_progress_notification(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_progress_notification(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &);
static void override_server(ContextType, ObjectType, Arguments &, ReturnValue &); static void override_server(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue&);
PropertyMap<T> const properties = { PropertyMap<T> const properties = {
{"config", {wrap<get_config>, nullptr}}, {"config", {wrap<get_config>, nullptr}},
@ -383,10 +383,9 @@ private:
}; };
template<typename T> template<typename T>
void UserClass<T>::session_for_on_disk_path(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void UserClass<T>::session_for_on_disk_path(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_count(1);
auto user = *get_internal<T, UserClass<T>>(this_object); auto user = *get_internal<T, UserClass<T>>(this_object);
if (auto session = user->session_for_on_disk_path(Value::validated_to_string(ctx, args[0]))) { if (auto session = user->session_for_on_disk_path(Value::validated_to_string(ctx, arguments[0]))) {
return_value.set(create_object<T, SessionClass<T>>(ctx, new WeakSession(session))); return_value.set(create_object<T, SessionClass<T>>(ctx, new WeakSession(session)));
} else { } else {
return_value.set_undefined(); return_value.set_undefined();
@ -456,38 +455,38 @@ void SessionClass<T>::get_state(ContextType ctx, ObjectType object, ReturnValue
} }
template<typename T> template<typename T>
void SessionClass<T>::simulate_error(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &) { void SessionClass<T>::simulate_error(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &) {
args.validate_count(2); validate_argument_count(argc, 2);
if (auto session = get_internal<T, SessionClass<T>>(this_object)->lock()) { if (auto session = get_internal<T, SessionClass<T>>(this_object)->lock()) {
std::error_code error_code(Value::validated_to_number(ctx, args[0]), realm::sync::protocol_error_category()); std::error_code error_code(Value::validated_to_number(ctx, arguments[0]), realm::sync::protocol_error_category());
std::string message = Value::validated_to_string(ctx, args[1]); std::string message = Value::validated_to_string(ctx, arguments[1]);
SyncSession::OnlyForTesting::handle_error(*session, SyncError(error_code, message, false)); SyncSession::OnlyForTesting::handle_error(*session, SyncError(error_code, message, false));
} }
} }
template<typename T> template<typename T>
void SessionClass<T>::refresh_access_token(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &) { void SessionClass<T>::refresh_access_token(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &) {
args.validate_count(3); validate_argument_count(argc, 3);
if (auto session = get_internal<T, SessionClass<T>>(this_object)->lock()) { if (auto session = get_internal<T, SessionClass<T>>(this_object)->lock()) {
std::string sync_label = Value::validated_to_string(ctx, args[2], "syncLabel"); std::string sync_label = Value::validated_to_string(ctx, arguments[2], "syncLabel");
session->set_multiplex_identifier(std::move(sync_label)); session->set_multiplex_identifier(std::move(sync_label));
std::string access_token = Value::validated_to_string(ctx, args[0], "accessToken"); std::string access_token = Value::validated_to_string(ctx, arguments[0], "accessToken");
std::string realm_url = Value::validated_to_string(ctx, args[1], "realmUrl"); std::string realm_url = Value::validated_to_string(ctx, arguments[1], "realmUrl");
session->refresh_access_token(std::move(access_token), std::move(realm_url)); session->refresh_access_token(std::move(access_token), std::move(realm_url));
} }
} }
template<typename T> template<typename T>
void SessionClass<T>::add_progress_notification(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SessionClass<T>::add_progress_notification(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_count(3); validate_argument_count(argc, 3);
if (auto session = get_internal<T, SessionClass<T>>(this_object)->lock()) { if (auto session = get_internal<T, SessionClass<T>>(this_object)->lock()) {
std::string direction = Value::validated_to_string(ctx, args[0], "direction"); std::string direction = Value::validated_to_string(ctx, arguments[0], "direction");
std::string mode = Value::validated_to_string(ctx, args[1], "mode"); std::string mode = Value::validated_to_string(ctx, arguments[1], "mode");
SyncSession::NotifierType notifierType; SyncSession::NotifierType notifierType;
if (direction == "download") { if (direction == "download") {
notifierType = SyncSession::NotifierType::download; notifierType = SyncSession::NotifierType::download;
@ -510,7 +509,7 @@ void SessionClass<T>::add_progress_notification(ContextType ctx, ObjectType this
throw std::invalid_argument("Invalid argument 'mode'. Only 'reportIndefinitely' and 'forCurrentlyOutstandingWork' progress notification modes are supported"); throw std::invalid_argument("Invalid argument 'mode'. Only 'reportIndefinitely' and 'forCurrentlyOutstandingWork' progress notification modes are supported");
} }
auto callback_function = Value::validated_to_function(ctx, args[2], "callback"); auto callback_function = Value::validated_to_function(ctx, arguments[2], "callback");
Protected<FunctionType> protected_callback(ctx, callback_function); Protected<FunctionType> protected_callback(ctx, callback_function);
Protected<ObjectType> protected_this(ctx, this_object); Protected<ObjectType> protected_this(ctx, this_object);
@ -537,9 +536,9 @@ void SessionClass<T>::add_progress_notification(ContextType ctx, ObjectType this
} }
template<typename T> template<typename T>
void SessionClass<T>::remove_progress_notification(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SessionClass<T>::remove_progress_notification(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_count(1); validate_argument_count(argc, 1);
auto callback_function = Value::validated_to_function(ctx, args[0], "callback"); auto callback_function = Value::validated_to_function(ctx, arguments[0], "callback");
auto syncSessionProp = Object::get_property(ctx, callback_function, "_syncSession"); auto syncSessionProp = Object::get_property(ctx, callback_function, "_syncSession");
if (Value::is_undefined(ctx, syncSessionProp) || Value::is_null(ctx, syncSessionProp)) { if (Value::is_undefined(ctx, syncSessionProp) || Value::is_null(ctx, syncSessionProp)) {
return; return;
@ -555,7 +554,7 @@ void SessionClass<T>::remove_progress_notification(ContextType ctx, ObjectType t
} }
template<typename T> template<typename T>
void SessionClass<T>::override_server(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue&) { void SessionClass<T>::override_server(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue&) {
args.validate_count(2); args.validate_count(2);
std::string address = Value::validated_to_string(ctx, args[0], "address"); std::string address = Value::validated_to_string(ctx, args[0], "address");
@ -603,10 +602,10 @@ public:
static void get_state(ContextType, ObjectType, ReturnValue &); static void get_state(ContextType, ObjectType, ReturnValue &);
static void get_error(ContextType, ObjectType, ReturnValue &); static void get_error(ContextType, ObjectType, ReturnValue &);
static void unsubscribe(ContextType, ObjectType, Arguments &, ReturnValue &); static void unsubscribe(ContextType, ObjectType, Arguments, ReturnValue &);
static void add_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void add_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_listener(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_listener(ContextType, ObjectType, Arguments, ReturnValue &);
static void remove_all_listeners(ContextType, ObjectType, Arguments &, ReturnValue &); static void remove_all_listeners(ContextType, ObjectType, Arguments, ReturnValue &);
PropertyMap<T> const properties = { PropertyMap<T> const properties = {
{"state", {wrap<get_state>, nullptr}}, {"state", {wrap<get_state>, nullptr}},
@ -649,7 +648,7 @@ void SubscriptionClass<T>::get_error(ContextType ctx, ObjectType object, ReturnV
} }
template<typename T> template<typename T>
void SubscriptionClass<T>::unsubscribe(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SubscriptionClass<T>::unsubscribe(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto subscription = get_internal<T, SubscriptionClass<T>>(this_object); auto subscription = get_internal<T, SubscriptionClass<T>>(this_object);
partial_sync::unsubscribe(*subscription); partial_sync::unsubscribe(*subscription);
@ -657,7 +656,7 @@ void SubscriptionClass<T>::unsubscribe(ContextType ctx, ObjectType this_object,
} }
template<typename T> template<typename T>
void SubscriptionClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SubscriptionClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
auto subscription = get_internal<T, SubscriptionClass<T>>(this_object); auto subscription = get_internal<T, SubscriptionClass<T>>(this_object);
@ -679,7 +678,7 @@ void SubscriptionClass<T>::add_listener(ContextType ctx, ObjectType this_object,
} }
template<typename T> template<typename T>
void SubscriptionClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SubscriptionClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(1); args.validate_maximum(1);
auto subscription = get_internal<T, SubscriptionClass<T>>(this_object); auto subscription = get_internal<T, SubscriptionClass<T>>(this_object);
@ -694,7 +693,7 @@ void SubscriptionClass<T>::remove_listener(ContextType ctx, ObjectType this_obje
} }
template<typename T> template<typename T>
void SubscriptionClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SubscriptionClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments args, ReturnValue &return_value) {
args.validate_maximum(0); args.validate_maximum(0);
auto subscription = get_internal<T, SubscriptionClass<T>>(this_object); auto subscription = get_internal<T, SubscriptionClass<T>>(this_object);
subscription->m_notification_tokens.clear(); subscription->m_notification_tokens.clear();
@ -712,15 +711,14 @@ class SyncClass : public ClassDefinition<T, void*> {
using Value = js::Value<T>; using Value = js::Value<T>;
using Function = js::Function<T>; using Function = js::Function<T>;
using ReturnValue = js::ReturnValue<T>; using ReturnValue = js::ReturnValue<T>;
using Arguments = js::Arguments<T>;
public: public:
std::string const name = "Sync"; std::string const name = "Sync";
static FunctionType create_constructor(ContextType); static FunctionType create_constructor(ContextType);
static void set_sync_log_level(ContextType, ObjectType, Arguments &, ReturnValue &); static void set_sync_log_level(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void initiate_client_reset(ContextType, ObjectType, Arguments &, ReturnValue &); static void initiate_client_reset(ContextType, FunctionType, ObjectType, size_t, const ValueType[], ReturnValue &);
// private // private
static std::function<SyncBindSessionHandler> session_bind_callback(ContextType ctx, ObjectType sync_constructor); static std::function<SyncBindSessionHandler> session_bind_callback(ContextType ctx, ObjectType sync_constructor);
@ -748,18 +746,18 @@ inline typename T::Function SyncClass<T>::create_constructor(ContextType ctx) {
} }
template<typename T> template<typename T>
void SyncClass<T>::initiate_client_reset(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue & return_value) { void SyncClass<T>::initiate_client_reset(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue & return_value) {
args.validate_count(1); validate_argument_count(argc, 1);
std::string path = Value::validated_to_string(ctx, args[0]); std::string path = Value::validated_to_string(ctx, arguments[0]);
if (!SyncManager::shared().immediately_run_file_actions(std::string(path))) { if (!SyncManager::shared().immediately_run_file_actions(std::string(path))) {
throw std::runtime_error(util::format("Realm was not configured correctly. Client Reset could not be run for Realm at: %1", path)); throw std::runtime_error(util::format("Realm was not configured correctly. Client Reset could not be run for Realm at: %1", path));
} }
} }
template<typename T> template<typename T>
void SyncClass<T>::set_sync_log_level(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) { void SyncClass<T>::set_sync_log_level(ContextType ctx, FunctionType, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
args.validate_count(1); validate_argument_count(argc, 1);
std::string log_level = Value::validated_to_string(ctx, args[0]); std::string log_level = Value::validated_to_string(ctx, arguments[0]);
std::istringstream in(log_level); // Throws std::istringstream in(log_level); // Throws
in.imbue(std::locale::classic()); // Throws in.imbue(std::locale::classic()); // Throws
in.unsetf(std::ios_base::skipws); in.unsetf(std::ios_base::skipws);

2
src/js_util.hpp
View File

@ -85,7 +85,7 @@ static inline void validate_argument_count_at_least(size_t count, size_t expecte
template<typename T, AggregateFunc func> template<typename T, AggregateFunc func>
void compute_aggregate_on_collection(typename T::ContextType ctx, typename T::ObjectType this_object, void compute_aggregate_on_collection(typename T::ContextType ctx, typename T::ObjectType this_object,
typename T::Arguments &args, typename T::ReturnValue &return_value) { typename T::Arguments args, typename T::ReturnValue &return_value) {
auto list = get_internal<typename T::Type, T>(this_object); auto list = get_internal<typename T::Type, T>(this_object);

27
src/jsc/jsc_class.hpp
View File

@ -31,6 +31,7 @@ using ClassDefinition = js::ClassDefinition<Types, T>;
using ConstructorType = js::ConstructorType<Types>; using ConstructorType = js::ConstructorType<Types>;
using ArgumentsMethodType = js::ArgumentsMethodType<Types>; using ArgumentsMethodType = js::ArgumentsMethodType<Types>;
using MethodType = js::MethodType<Types>;
using Arguments = js::Arguments<Types>; using Arguments = js::Arguments<Types>;
using PropertyType = js::PropertyType<Types>; using PropertyType = js::PropertyType<Types>;
using IndexPropertyType = js::IndexPropertyType<Types>; using IndexPropertyType = js::IndexPropertyType<Types>;
@ -228,9 +229,8 @@ inline JSValueRef ObjectWrap<ClassType>::call(JSContextRef ctx, JSObjectRef func
// Classes without a constructor should still be subclassable. // Classes without a constructor should still be subclassable.
if (reinterpret_cast<void*>(s_class.constructor)) { if (reinterpret_cast<void*>(s_class.constructor)) {
jsc::Arguments args{ctx, argc, arguments};
try { try {
s_class.constructor(ctx, this_object, args); s_class.constructor(ctx, this_object, argc, arguments);
} }
catch (std::exception &e) { catch (std::exception &e) {
*exception = jsc::Exception::value(ctx, e); *exception = jsc::Exception::value(ctx, e);
@ -249,9 +249,8 @@ inline JSObjectRef ObjectWrap<ClassType>::construct(JSContextRef ctx, JSObjectRe
} }
JSObjectRef this_object = create_instance(ctx); JSObjectRef this_object = create_instance(ctx);
jsc::Arguments args{ctx, argc, arguments};
try { try {
s_class.constructor(ctx, this_object, args); s_class.constructor(ctx, this_object, argc, arguments);
} }
catch (std::exception &e) { catch (std::exception &e) {
*exception = jsc::Exception::value(ctx, e); *exception = jsc::Exception::value(ctx, e);
@ -382,12 +381,24 @@ namespace js {
template<typename ClassType> template<typename ClassType>
class ObjectWrap<jsc::Types, ClassType> : public jsc::ObjectWrap<ClassType> {}; class ObjectWrap<jsc::Types, ClassType> : public jsc::ObjectWrap<ClassType> {};
template<jsc::ArgumentsMethodType F> template<jsc::MethodType F>
JSValueRef wrap(JSContextRef ctx, JSObjectRef, JSObjectRef this_object, size_t argc, const JSValueRef arguments[], JSValueRef* exception) { JSValueRef wrap(JSContextRef ctx, JSObjectRef function, JSObjectRef this_object, size_t argc, const JSValueRef arguments[], JSValueRef* exception) {
jsc::Arguments args{ctx, argc, arguments};
jsc::ReturnValue return_value(ctx); jsc::ReturnValue return_value(ctx);
try { try {
F(ctx, this_object, args, return_value); F(ctx, function, this_object, argc, arguments, return_value);
return return_value;
}
catch (std::exception &e) {
*exception = jsc::Exception::value(ctx, e);
return nullptr;
}
}
template<jsc::ArgumentsMethodType F>
JSValueRef wrap(JSContextRef ctx, JSObjectRef, JSObjectRef this_object, size_t argc, const JSValueRef arguments[], JSValueRef* exception) {
jsc::ReturnValue return_value(ctx);
try {
F(ctx, this_object, jsc::Arguments{ctx, argc, arguments}, return_value);
return return_value; return return_value;
} }
catch (std::exception &e) { catch (std::exception &e) {

81
src/node/node_class.hpp
View File

@ -30,6 +30,7 @@ template<typename T>
using ClassDefinition = js::ClassDefinition<Types, T>; using ClassDefinition = js::ClassDefinition<Types, T>;
using ConstructorType = js::ConstructorType<Types>; using ConstructorType = js::ConstructorType<Types>;
using MethodType = js::MethodType<Types>;
using ArgumentsMethodType = js::ArgumentsMethodType<Types>; using ArgumentsMethodType = js::ArgumentsMethodType<Types>;
using Arguments = js::Arguments<Types>; using Arguments = js::Arguments<Types>;
using PropertyType = js::PropertyType<Types>; using PropertyType = js::PropertyType<Types>;
@ -50,7 +51,7 @@ class ObjectWrap : public Nan::ObjectWrap {
return Nan::New(js_template); return Nan::New(js_template);
} }
static void construct(const Nan::FunctionCallbackInfo<v8::Value>&); static void construct(const v8::FunctionCallbackInfo<v8::Value>&);
static bool has_instance(v8::Isolate* isolate, const v8::Local<v8::Value> &value) { static bool has_instance(v8::Isolate* isolate, const v8::Local<v8::Value> &value) {
return get_template()->HasInstance(value); return get_template()->HasInstance(value);
@ -76,26 +77,26 @@ class ObjectWrap : public Nan::ObjectWrap {
static v8::Local<v8::FunctionTemplate> create_template(); static v8::Local<v8::FunctionTemplate> create_template();
static void setup_method(v8::Local<v8::FunctionTemplate>, const std::string &, Nan::FunctionCallback); static void setup_method(v8::Local<v8::FunctionTemplate>, const std::string &, v8::FunctionCallback);
static void setup_static_method(v8::Local<v8::FunctionTemplate>, const std::string &, Nan::FunctionCallback); static void setup_static_method(v8::Local<v8::FunctionTemplate>, const std::string &, v8::FunctionCallback);
template<typename TargetType> template<typename TargetType>
static void setup_property(v8::Local<TargetType>, const std::string &, const PropertyType &); static void setup_property(v8::Local<TargetType>, const std::string &, const PropertyType &);
static void get_indexes(const Nan::PropertyCallbackInfo<v8::Array>&); static void get_indexes(const v8::PropertyCallbackInfo<v8::Array>&);
static void set_property(v8::Local<v8::String>, v8::Local<v8::Value>, const Nan::PropertyCallbackInfo<v8::Value>&); static void set_property(v8::Local<v8::String>, v8::Local<v8::Value>, const v8::PropertyCallbackInfo<v8::Value>&);
static void set_readonly_property(v8::Local<v8::String> property, v8::Local<v8::Value> value, const Nan::PropertyCallbackInfo<void>& info) { static void set_readonly_property(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) {
std::string message = std::string("Cannot assign to read only property '") + std::string(String(property)) + "'"; std::string message = std::string("Cannot assign to read only property '") + std::string(String(property)) + "'";
Nan::ThrowError(message.c_str()); Nan::ThrowError(message.c_str());
} }
static void set_readonly_index(uint32_t index, v8::Local<v8::Value> value, const Nan::PropertyCallbackInfo<v8::Value>& info) { static void set_readonly_index(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info) {
std::string message = std::string("Cannot assign to read only index ") + util::to_string(index); std::string message = std::string("Cannot assign to read only index ") + util::to_string(index);
Nan::ThrowError(message.c_str()); Nan::ThrowError(message.c_str());
} }
static void get_nonexistent_property(v8::Local<v8::String>, const Nan::PropertyCallbackInfo<v8::Value>&) { static void get_nonexistent_property(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>&) {
// Do nothing. This function exists only to prevent a crash where it is used. // Do nothing. This function exists only to prevent a crash where it is used.
} }
}; };
@ -111,7 +112,7 @@ class ObjectWrap<void> {
}; };
// This helper function is needed outside the scope of the ObjectWrap class as well. // This helper function is needed outside the scope of the ObjectWrap class as well.
static inline std::vector<v8::Local<v8::Value>> get_arguments(const Nan::FunctionCallbackInfo<v8::Value> &info) { static inline std::vector<v8::Local<v8::Value>> get_arguments(const v8::FunctionCallbackInfo<v8::Value> &info) {
int count = info.Length(); int count = info.Length();
std::vector<v8::Local<v8::Value>> arguments; std::vector<v8::Local<v8::Value>> arguments;
arguments.reserve(count); arguments.reserve(count);
@ -158,7 +159,7 @@ template<typename ClassType>
inline v8::Local<v8::FunctionTemplate> ObjectWrap<ClassType>::create_template() { inline v8::Local<v8::FunctionTemplate> ObjectWrap<ClassType>::create_template() {
Nan::EscapableHandleScope scope; Nan::EscapableHandleScope scope;
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(construct); v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), construct);
v8::Local<v8::ObjectTemplate> instance_tpl = tpl->InstanceTemplate(); v8::Local<v8::ObjectTemplate> instance_tpl = tpl->InstanceTemplate();
v8::Local<v8::String> name = Nan::New(s_class.name).ToLocalChecked(); v8::Local<v8::String> name = Nan::New(s_class.name).ToLocalChecked();
@ -183,21 +184,21 @@ inline v8::Local<v8::FunctionTemplate> ObjectWrap<ClassType>::create_template()
if (s_class.index_accessor.getter) { if (s_class.index_accessor.getter) {
auto &index_accessor = s_class.index_accessor; auto &index_accessor = s_class.index_accessor;
Nan::SetIndexedPropertyHandler(instance_tpl, index_accessor.getter, index_accessor.setter ? index_accessor.setter : set_readonly_index, 0, 0, get_indexes); instance_tpl->SetIndexedPropertyHandler(index_accessor.getter, index_accessor.setter ? index_accessor.setter : set_readonly_index, 0, 0, get_indexes);
} }
if (s_class.string_accessor.getter || s_class.index_accessor.getter || s_class.index_accessor.setter) { if (s_class.string_accessor.getter || s_class.index_accessor.getter || s_class.index_accessor.setter) {
// Use our own wrapper for the setter since we want to throw for negative indices. // Use our own wrapper for the setter since we want to throw for negative indices.
auto &string_accessor = s_class.string_accessor; auto &string_accessor = s_class.string_accessor;
Nan::SetNamedPropertyHandler(instance_tpl, string_accessor.getter ? string_accessor.getter : get_nonexistent_property, set_property, 0, 0, string_accessor.enumerator); instance_tpl->SetNamedPropertyHandler(string_accessor.getter ? string_accessor.getter : get_nonexistent_property, set_property, 0, 0, string_accessor.enumerator);
} }
return scope.Escape(tpl); return scope.Escape(tpl);
} }
template<typename ClassType> template<typename ClassType>
inline void ObjectWrap<ClassType>::setup_method(v8::Local<v8::FunctionTemplate> tpl, const std::string &name, Nan::FunctionCallback callback) { inline void ObjectWrap<ClassType>::setup_method(v8::Local<v8::FunctionTemplate> tpl, const std::string &name, v8::FunctionCallback callback) {
v8::Local<v8::Signature> signature = Nan::New<v8::Signature>(tpl); v8::Local<v8::Signature> signature = Nan::New<v8::Signature>(tpl);
v8::Local<v8::FunctionTemplate> fn_tpl = Nan::New<v8::FunctionTemplate>(callback, v8::Local<v8::Value>(), signature); v8::Local<v8::FunctionTemplate> fn_tpl = v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), callback, v8::Local<v8::Value>(), signature);
v8::Local<v8::String> fn_name = Nan::New(name).ToLocalChecked(); v8::Local<v8::String> fn_name = Nan::New(name).ToLocalChecked();
// The reason we use this rather than Nan::SetPrototypeMethod is DontEnum. // The reason we use this rather than Nan::SetPrototypeMethod is DontEnum.
@ -206,8 +207,8 @@ inline void ObjectWrap<ClassType>::setup_method(v8::Local<v8::FunctionTemplate>
} }
template<typename ClassType> template<typename ClassType>
inline void ObjectWrap<ClassType>::setup_static_method(v8::Local<v8::FunctionTemplate> tpl, const std::string &name, Nan::FunctionCallback callback) { inline void ObjectWrap<ClassType>::setup_static_method(v8::Local<v8::FunctionTemplate> tpl, const std::string &name, v8::FunctionCallback callback) {
v8::Local<v8::FunctionTemplate> fn_tpl = Nan::New<v8::FunctionTemplate>(callback); v8::Local<v8::FunctionTemplate> fn_tpl = v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), callback);
v8::Local<v8::String> fn_name = Nan::New(name).ToLocalChecked(); v8::Local<v8::String> fn_name = Nan::New(name).ToLocalChecked();
tpl->Set(fn_name, fn_tpl, v8::PropertyAttribute::DontEnum); tpl->Set(fn_name, fn_tpl, v8::PropertyAttribute::DontEnum);
@ -220,18 +221,17 @@ inline void ObjectWrap<ClassType>::setup_property(v8::Local<TargetType> target,
v8::Local<v8::String> prop_name = Nan::New(name).ToLocalChecked(); v8::Local<v8::String> prop_name = Nan::New(name).ToLocalChecked();
v8::PropertyAttribute attributes = v8::PropertyAttribute(v8::DontEnum | v8::DontDelete); v8::PropertyAttribute attributes = v8::PropertyAttribute(v8::DontEnum | v8::DontDelete);
Nan::SetAccessor(target, prop_name, property.getter, property.setter ? property.setter : set_readonly_property, v8::Local<v8::Value>(), v8::DEFAULT, attributes); target->SetAccessor(prop_name, property.getter, property.setter ? property.setter : set_readonly_property, v8::Local<v8::Value>(), v8::DEFAULT, attributes);
} }
template<typename ClassType> template<typename ClassType>
inline void ObjectWrap<ClassType>::construct(const Nan::FunctionCallbackInfo<v8::Value>& info) { inline void ObjectWrap<ClassType>::construct(const v8::FunctionCallbackInfo<v8::Value>& info) {
if (!info.IsConstructCall()) { if (!info.IsConstructCall()) {
Nan::ThrowError("Constructor must be called with new"); Nan::ThrowError("Constructor must be called with new");
} }
if (reinterpret_cast<void*>(s_class.constructor)) { if (reinterpret_cast<void*>(s_class.constructor)) {
auto isolate = info.GetIsolate(); auto isolate = info.GetIsolate();
auto arguments = get_arguments(info); auto arguments = get_arguments(info);
node::Arguments args{isolate, arguments.size(), arguments.data()};
v8::Local<v8::Object> this_object = info.This(); v8::Local<v8::Object> this_object = info.This();
info.GetReturnValue().Set(this_object); info.GetReturnValue().Set(this_object);
@ -239,7 +239,7 @@ inline void ObjectWrap<ClassType>::construct(const Nan::FunctionCallbackInfo<v8:
wrap->Wrap(this_object); wrap->Wrap(this_object);
try { try {
s_class.constructor(isolate, this_object, args); s_class.constructor(isolate, this_object, arguments.size(), arguments.data());
} }
catch (std::exception &e) { catch (std::exception &e) {
Nan::ThrowError(node::Exception::value(isolate, e)); Nan::ThrowError(node::Exception::value(isolate, e));
@ -251,7 +251,7 @@ inline void ObjectWrap<ClassType>::construct(const Nan::FunctionCallbackInfo<v8:
} }
template<typename ClassType> template<typename ClassType>
inline void ObjectWrap<ClassType>::get_indexes(const Nan::PropertyCallbackInfo<v8::Array>& info) { inline void ObjectWrap<ClassType>::get_indexes(const v8::PropertyCallbackInfo<v8::Array>& info) {
uint32_t length; uint32_t length;
try { try {
length = Object::validated_get_length(info.GetIsolate(), info.This()); length = Object::validated_get_length(info.GetIsolate(), info.This());
@ -270,7 +270,7 @@ inline void ObjectWrap<ClassType>::get_indexes(const Nan::PropertyCallbackInfo<v
} }
template<typename ClassType> template<typename ClassType>
inline void ObjectWrap<ClassType>::set_property(v8::Local<v8::String> property, v8::Local<v8::Value> value, const Nan::PropertyCallbackInfo<v8::Value>& info) { inline void ObjectWrap<ClassType>::set_property(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info) {
if (s_class.index_accessor.getter || s_class.index_accessor.setter) { if (s_class.index_accessor.getter || s_class.index_accessor.setter) {
try { try {
// Negative indices are passed into this string property interceptor, so check for them here. // Negative indices are passed into this string property interceptor, so check for them here.
@ -296,15 +296,28 @@ namespace js {
template<typename ClassType> template<typename ClassType>
class ObjectWrap<node::Types, ClassType> : public node::ObjectWrap<ClassType> {}; class ObjectWrap<node::Types, ClassType> : public node::ObjectWrap<ClassType> {};
template<node::ArgumentsMethodType F> template<node::MethodType F>
void wrap(const Nan::FunctionCallbackInfo<v8::Value>& info) { void wrap(const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
auto arguments = node::get_arguments(info);
node::Arguments args{isolate, arguments.size(), arguments.data()};
node::ReturnValue return_value(info.GetReturnValue()); node::ReturnValue return_value(info.GetReturnValue());
auto arguments = node::get_arguments(info);
try { try {
F(isolate, info.This(), args, return_value); F(isolate, info.Callee(), info.This(), arguments.size(), arguments.data(), return_value);
}
catch (std::exception &e) {
Nan::ThrowError(node::Exception::value(isolate, e));
}
}
template<node::ArgumentsMethodType F>
void wrap(const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate();
node::ReturnValue return_value(info.GetReturnValue());
auto arguments = node::get_arguments(info);
try {
F(isolate, info.This(), node::Arguments{isolate, arguments.size(), arguments.data()}, return_value);
} }
catch (std::exception &e) { catch (std::exception &e) {
Nan::ThrowError(node::Exception::value(isolate, e)); Nan::ThrowError(node::Exception::value(isolate, e));
@ -313,7 +326,7 @@ void wrap(const Nan::FunctionCallbackInfo<v8::Value>& info) {
template<node::PropertyType::GetterType F> template<node::PropertyType::GetterType F>
void wrap(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info) { void wrap(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
node::ReturnValue return_value(info.GetReturnValue()); node::ReturnValue return_value(info.GetReturnValue());
try { try {
@ -325,7 +338,7 @@ void wrap(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Va
} }
template<node::PropertyType::SetterType F> template<node::PropertyType::SetterType F>
void wrap(v8::Local<v8::String> property, v8::Local<v8::Value> value, const Nan::PropertyCallbackInfo<void>& info) { void wrap(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
try { try {
F(isolate, info.This(), value); F(isolate, info.This(), value);
@ -336,7 +349,7 @@ void wrap(v8::Local<v8::String> property, v8::Local<v8::Value> value, const Nan:
} }
template<node::IndexPropertyType::GetterType F> template<node::IndexPropertyType::GetterType F>
void wrap(uint32_t index, const Nan::PropertyCallbackInfo<v8::Value>& info) { void wrap(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
node::ReturnValue return_value(info.GetReturnValue()); node::ReturnValue return_value(info.GetReturnValue());
try { try {
@ -352,7 +365,7 @@ void wrap(uint32_t index, const Nan::PropertyCallbackInfo<v8::Value>& info) {
} }
template<node::IndexPropertyType::SetterType F> template<node::IndexPropertyType::SetterType F>
void wrap(uint32_t index, v8::Local<v8::Value> value, const Nan::PropertyCallbackInfo<v8::Value>& info) { void wrap(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
try { try {
if (F(isolate, info.This(), index, value)) { if (F(isolate, info.This(), index, value)) {
@ -366,7 +379,7 @@ void wrap(uint32_t index, v8::Local<v8::Value> value, const Nan::PropertyCallbac
} }
template<node::StringPropertyType::GetterType F> template<node::StringPropertyType::GetterType F>
void wrap(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Value>& info) { void wrap(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
node::ReturnValue return_value(info.GetReturnValue()); node::ReturnValue return_value(info.GetReturnValue());
try { try {
@ -378,7 +391,7 @@ void wrap(v8::Local<v8::String> property, const Nan::PropertyCallbackInfo<v8::Va
} }
template<node::StringPropertyType::SetterType F> template<node::StringPropertyType::SetterType F>
void wrap(v8::Local<v8::String> property, v8::Local<v8::Value> value, const Nan::PropertyCallbackInfo<v8::Value>& info) { void wrap(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate(); v8::Isolate* isolate = info.GetIsolate();
try { try {
if (F(isolate, info.This(), property, value)) { if (F(isolate, info.This(), property, value)) {
@ -392,7 +405,7 @@ void wrap(v8::Local<v8::String> property, v8::Local<v8::Value> value, const Nan:
} }
template<node::StringPropertyType::EnumeratorType F> template<node::StringPropertyType::EnumeratorType F>
void wrap(const Nan::PropertyCallbackInfo<v8::Array>& info) { void wrap(const v8::PropertyCallbackInfo<v8::Array>& info) {
auto names = F(info.GetIsolate(), info.This()); auto names = F(info.GetIsolate(), info.This());
int count = (int)names.size(); int count = (int)names.size();
v8::Local<v8::Array> array = Nan::New<v8::Array>(count); v8::Local<v8::Array> array = Nan::New<v8::Array>(count);

4
src/node/node_return_value.hpp
View File

@ -25,10 +25,10 @@ namespace js {
template<> template<>
class ReturnValue<node::Types> { class ReturnValue<node::Types> {
Nan::ReturnValue<v8::Value> m_value; v8::ReturnValue<v8::Value> m_value;
public: public:
ReturnValue(Nan::ReturnValue<v8::Value> value) : m_value(value) {} ReturnValue(v8::ReturnValue<v8::Value> value) : m_value(value) {}
void set(const v8::Local<v8::Value> &value) { void set(const v8::Local<v8::Value> &value) {
m_value.Set(value); m_value.Set(value);

18
src/node/node_types.hpp
View File

@ -43,15 +43,15 @@ struct Types {
using String = v8::Local<v8::String>; using String = v8::Local<v8::String>;
using Function = v8::Local<v8::Function>; using Function = v8::Local<v8::Function>;
using ConstructorCallback = Nan::FunctionCallback; using ConstructorCallback = v8::FunctionCallback;
using FunctionCallback = Nan::FunctionCallback; using FunctionCallback = v8::FunctionCallback;
using PropertyGetterCallback = Nan::GetterCallback; using PropertyGetterCallback = v8::AccessorGetterCallback;
using PropertySetterCallback = Nan::SetterCallback; using PropertySetterCallback = v8::AccessorSetterCallback;
using IndexPropertyGetterCallback = Nan::IndexGetterCallback; using IndexPropertyGetterCallback = v8::IndexedPropertyGetterCallback;
using IndexPropertySetterCallback = Nan::IndexSetterCallback; using IndexPropertySetterCallback = v8::IndexedPropertySetterCallback;
using StringPropertyGetterCallback = Nan::PropertyGetterCallback; using StringPropertyGetterCallback = v8::NamedPropertyGetterCallback;
using StringPropertySetterCallback = Nan::PropertySetterCallback; using StringPropertySetterCallback = v8::NamedPropertySetterCallback;
using StringPropertyEnumeratorCallback = Nan::PropertyEnumeratorCallback; using StringPropertyEnumeratorCallback = v8::NamedPropertyEnumeratorCallback;
}; };
template<typename ClassType> template<typename ClassType>

14
src/rpc.cpp
View File

@ -365,10 +365,10 @@ RPCServer::~RPCServer() {
JSGlobalContextRelease(m_context); JSGlobalContextRelease(m_context);
} }
JSValueRef RPCServer::run_callback(JSContextRef ctx, JSObjectRef function, JSObjectRef this_object, size_t argc, const JSValueRef arguments[], JSValueRef* exception) { void RPCServer::run_callback(JSContextRef ctx, JSObjectRef function, JSObjectRef this_object, size_t argc, const JSValueRef arguments[], jsc::ReturnValue &return_value) {
RPCServer* server = get_rpc_server(JSContextGetGlobalContext(ctx)); RPCServer* server = get_rpc_server(JSContextGetGlobalContext(ctx));
if (!server) { if (!server) {
return JSValueMakeUndefined(ctx); return;
} }
u_int64_t counter = server->m_callback_call_counter++; u_int64_t counter = server->m_callback_call_counter++;
@ -419,15 +419,11 @@ JSValueRef RPCServer::run_callback(JSContextRef ctx, JSObjectRef function, JSObj
assert(callback_id == resultCallbackId.get<RPCObjectID>()); assert(callback_id == resultCallbackId.get<RPCObjectID>());
if (!error.is_null()) { if (!error.is_null()) {
JSStringRef message = JSStringCreateWithUTF8CString(error.get<std::string>().c_str()); throw jsc::Exception(ctx, error.get<std::string>());
JSValueRef arguments[] { JSValueMakeString(ctx, message) };
JSStringRelease(message);
*exception = JSObjectMakeError(ctx, 1, arguments, nullptr);
} }
return server->deserialize_json_value(results["result"]); return_value.set(server->deserialize_json_value(results["result"]));
} }
@ -653,7 +649,7 @@ JSValueRef RPCServer::deserialize_json_value(const json dict) {
RPCObjectID callback_id = value.get<RPCObjectID>(); RPCObjectID callback_id = value.get<RPCObjectID>();
if (!m_callbacks.count(callback_id)) { if (!m_callbacks.count(callback_id)) {
JSObjectRef callback = JSObjectMakeFunctionWithCallback(m_context, nullptr, run_callback); JSObjectRef callback = JSObjectMakeFunctionWithCallback(m_context, nullptr, js::wrap<run_callback>);
m_callbacks.emplace(callback_id, js::Protected<JSObjectRef>(m_context, callback)); m_callbacks.emplace(callback_id, js::Protected<JSObjectRef>(m_context, callback));
m_callback_ids.emplace(callback, callback_id); m_callback_ids.emplace(callback, callback_id);
} }

2
src/rpc.hpp
View File

@ -83,7 +83,7 @@ class RPCServer {
RPCWorker m_worker; RPCWorker m_worker;
u_int64_t m_callback_call_counter; u_int64_t m_callback_call_counter;
static JSValueRef run_callback(JSContextRef, JSObjectRef, JSObjectRef, size_t, const JSValueRef[], JSValueRef *exception); static void run_callback(JSContextRef, JSObjectRef, JSObjectRef, size_t, const JSValueRef[], jsc::ReturnValue &);
RPCObjectID store_object(JSObjectRef object); RPCObjectID store_object(JSObjectRef object);