static napi_value Test(napi_env env, napi_callback_info info) { size_t argc = 1; napi_value args[1]; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments"); napi_valuetype valuetype0; NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); NAPI_ASSERT(env, valuetype0 == napi_number, "Wrong type of arguments. Expects a number as first argument."); double input; NAPI_CALL(env, napi_get_value_double(env, args[0], &input)); napi_value output; NAPI_CALL(env, napi_create_double(env, input, &output)); return output; }
napi_value NewWithLength(napi_env env, napi_callback_info info) { size_t argc = 1; napi_value args[1]; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments"); napi_valuetype valuetype0; NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); NAPI_ASSERT(env, valuetype0 == napi_number, "Wrong type of arguments. Expects an integer the first argument."); int32_t array_length; NAPI_CALL(env, napi_get_value_int32(env, args[0], &array_length)); napi_value ret; NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret)); return ret; }
napi_value Utf8Length(napi_env env, napi_callback_info info) { size_t argc = 1; napi_value args[1]; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments"); napi_valuetype valuetype; NAPI_CALL(env, napi_typeof(env, args[0], &valuetype)); NAPI_ASSERT(env, valuetype == napi_string, "Wrong type of argment. Expects a string."); size_t length; NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], NULL, 0, &length)); napi_value output; NAPI_CALL(env, napi_create_number(env, (double)length, &output)); return output; }
static napi_value MakeCallback(napi_env env, napi_callback_info info) { size_t argc = MAX_ARGUMENTS; size_t n; napi_value args[MAX_ARGUMENTS]; // NOLINTNEXTLINE (readability/null_usage) NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_ASSERT(env, argc > 0, "Wrong number of arguments"); napi_value recv = args[0]; napi_value func = args[1]; napi_value argv[MAX_ARGUMENTS - 2]; for (n = 2; n < argc; n += 1) { argv[n - 2] = args[n]; } napi_valuetype func_type; NAPI_CALL(env, napi_typeof(env, func, &func_type)); napi_value resource_name; NAPI_CALL(env, napi_create_string_utf8( env, "test", NAPI_AUTO_LENGTH, &resource_name)); napi_async_context context; NAPI_CALL(env, napi_async_init(env, func, resource_name, &context)); napi_value result; if (func_type == napi_function) { NAPI_CALL(env, napi_make_callback( env, context, recv, func, argc - 2, argv, &result)); } else { NAPI_ASSERT(env, false, "Unexpected argument type"); } NAPI_CALL(env, napi_async_destroy(env, context)); return result; }
static napi_value testNapiTypeof(napi_env env, napi_callback_info info) { size_t argc = 1; napi_value args[1]; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); napi_valuetype argument_type; NAPI_CALL(env, napi_typeof(env, args[0], &argument_type)); napi_value result = NULL; if (argument_type == napi_number) { NAPI_CALL(env, napi_create_string_utf8( env, "number", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_string) { NAPI_CALL(env, napi_create_string_utf8( env, "string", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_function) { NAPI_CALL(env, napi_create_string_utf8( env, "function", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_object) { NAPI_CALL(env, napi_create_string_utf8( env, "object", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_boolean) { NAPI_CALL(env, napi_create_string_utf8( env, "boolean", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_undefined) { NAPI_CALL(env, napi_create_string_utf8( env, "undefined", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_symbol) { NAPI_CALL(env, napi_create_string_utf8( env, "symbol", NAPI_AUTO_LENGTH, &result)); } else if (argument_type == napi_null) { NAPI_CALL(env, napi_create_string_utf8( env, "null", NAPI_AUTO_LENGTH, &result)); } return result; }
napi_value Multiply(napi_env env, napi_callback_info info) { size_t argc = 2; napi_value args[2]; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_ASSERT(env, argc == 2, "Wrong number of arguments"); napi_valuetype valuetype0; NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); NAPI_ASSERT(env, valuetype0 == napi_object, "Wrong type of argments. Expects a typed array as first argument."); napi_value input_array = args[0]; bool is_typedarray; NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray)); NAPI_ASSERT(env, is_typedarray, "Wrong type of argments. Expects a typed array as first argument."); napi_valuetype valuetype1; NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1)); NAPI_ASSERT(env, valuetype1 == napi_number, "Wrong type of argments. Expects a number as second argument."); double multiplier; NAPI_CALL(env, napi_get_value_double(env, args[1], &multiplier)); napi_typedarray_type type; napi_value input_buffer; size_t byte_offset; size_t i, length; NAPI_CALL(env, napi_get_typedarray_info( env, input_array, &type, &length, NULL, &input_buffer, &byte_offset)); void* data; size_t byte_length; NAPI_CALL(env, napi_get_arraybuffer_info( env, input_buffer, &data, &byte_length)); napi_value output_buffer; void* output_ptr = NULL; NAPI_CALL(env, napi_create_arraybuffer( env, byte_length, &output_ptr, &output_buffer)); napi_value output_array; NAPI_CALL(env, napi_create_typedarray( env, type, length, output_buffer, byte_offset, &output_array)); if (type == napi_uint8_array) { uint8_t* input_bytes = (uint8_t*)(data) + byte_offset; uint8_t* output_bytes = (uint8_t*)(output_ptr); for (i = 0; i < length; i++) { output_bytes[i] = (uint8_t)(input_bytes[i] * multiplier); } } else if (type == napi_float64_array) { double* input_doubles = (double*)((uint8_t*)(data) + byte_offset); double* output_doubles = (double*)(output_ptr); for (i = 0; i < length; i++) { output_doubles[i] = input_doubles[i] * multiplier; } } else { napi_throw_error(env, NULL, "Typed array was of a type not expected by test."); return NULL; } return output_array; }
static napi_value CreateTypedArray(napi_env env, napi_callback_info info) { size_t argc = 4; napi_value args[4]; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_ASSERT(env, argc == 2 || argc == 4, "Wrong number of arguments"); napi_value input_array = args[0]; napi_valuetype valuetype0; NAPI_CALL(env, napi_typeof(env, input_array, &valuetype0)); NAPI_ASSERT(env, valuetype0 == napi_object, "Wrong type of arguments. Expects a typed array as first argument."); bool is_typedarray; NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray)); NAPI_ASSERT(env, is_typedarray, "Wrong type of arguments. Expects a typed array as first argument."); napi_valuetype valuetype1; napi_value input_buffer = args[1]; NAPI_CALL(env, napi_typeof(env, input_buffer, &valuetype1)); NAPI_ASSERT(env, valuetype1 == napi_object, "Wrong type of arguments. Expects an array buffer as second argument."); bool is_arraybuffer; NAPI_CALL(env, napi_is_arraybuffer(env, input_buffer, &is_arraybuffer)); NAPI_ASSERT(env, is_arraybuffer, "Wrong type of arguments. Expects an array buffer as second argument."); napi_typedarray_type type; napi_value in_array_buffer; size_t byte_offset; size_t length; NAPI_CALL(env, napi_get_typedarray_info( env, input_array, &type, &length, NULL, &in_array_buffer, &byte_offset)); if (argc == 4) { napi_valuetype valuetype2; NAPI_CALL(env, napi_typeof(env, args[2], &valuetype2)); NAPI_ASSERT(env, valuetype2 == napi_number, "Wrong type of arguments. Expects a number as third argument."); uint32_t uint32_length; NAPI_CALL(env, napi_get_value_uint32(env, args[2], &uint32_length)); length = uint32_length; napi_valuetype valuetype3; NAPI_CALL(env, napi_typeof(env, args[3], &valuetype3)); NAPI_ASSERT(env, valuetype3 == napi_number, "Wrong type of arguments. Expects a number as third argument."); uint32_t uint32_byte_offset; NAPI_CALL(env, napi_get_value_uint32(env, args[3], &uint32_byte_offset)); byte_offset = uint32_byte_offset; } napi_value output_array; NAPI_CALL(env, napi_create_typedarray( env, type, length, input_buffer, byte_offset, &output_array)); return output_array; }
void Test(napi_env env, napi_callback_info info) { napi_status status; size_t argc; status = napi_get_cb_args_length(env, info, &argc); if (status != napi_ok) return; if (argc < 2) { napi_throw_type_error(env, "Wrong number of arguments"); return; } napi_value args[2]; status = napi_get_cb_args(env, info, args, 2); if (status != napi_ok) return; napi_valuetype valuetype0; status = napi_typeof(env, args[0], &valuetype0); if (status != napi_ok) return; if (valuetype0 != napi_object) { napi_throw_type_error( env, "Wrong type of argments. Expects an array as first argument."); return; } napi_valuetype valuetype1; status = napi_typeof(env, args[1], &valuetype1); if (status != napi_ok) return; if (valuetype1 != napi_number) { napi_throw_type_error( env, "Wrong type of argments. Expects an integer as second argument."); return; } napi_value array = args[0]; int index; status = napi_get_value_int32(env, args[1], &index); if (status != napi_ok) return; bool isarray; status = napi_is_array(env, array, &isarray); if (status != napi_ok) return; if (isarray) { uint32_t size; status = napi_get_array_length(env, array, &size); if (status != napi_ok) return; if (index >= (int)(size)) { napi_value str; status = napi_create_string_utf8(env, "Index out of bound!", -1, &str); if (status != napi_ok) return; status = napi_set_return_value(env, info, str); if (status != napi_ok) return; } else if (index < 0) { napi_throw_type_error(env, "Invalid index. Expects a positive integer."); } else { napi_value ret; status = napi_get_element(env, array, index, &ret); if (status != napi_ok) return; status = napi_set_return_value(env, info, ret); if (status != napi_ok) return; } } }