void Client::Cas(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 5, "5")
CHECK_N_ARGS_IS_A_STRING(info, 0, "0")
CHECK_N_ARGS_IS_A_STRING(info, 1, "1")
CHECK_N_ARGS_IS_A_NUMBER(info, 2, "2")
CHECK_N_ARGS_IS_A_STRING(info, 3, "3")
CHECK_N_ARGS_IS_A_FUNCTION(info, 4, "4")
const string memcached_key = GET_STRING_FROM_PARAM(info[0]);
const string memcached_value = GET_STRING_FROM_PARAM(info[1]);
time_t ttl = info[2]->NumberValue();
// String to uint64_t
const string casString = GET_STRING_FROM_PARAM(info[3]);
uint64_t cas;
sscanf(casString.c_str(), "%" PRIu64, &cas);
Callback* callback = GET_CALLBACK_FROM_PARAM(info[4]);
JobBase* job = new CasJob(callback, memcached_key, memcached_value, ttl, cas);
job->setDebug(memClient->debug);
memClient->jobs.insert(job);
info.GetReturnValue().Set(Nan::Undefined());
}
void MeCab_Tagger::DictionaryInfo(const Nan::FunctionCallbackInfo<v8::Value>& info) {
MeCab_Tagger* obj = ObjectWrap::Unwrap<MeCab_Tagger>(info.Holder());
v8::Local<v8::Function> callback = info[0].As<v8::Function>();
const MeCab::DictionaryInfo *dic = obj->tagger->dictionary_info();
std::vector<v8::Local<v8::Object>> info_list;
for (; dic; dic = dic->next) {
v8::Local<v8::Object> obj = Nan::New<v8::Object>();
obj->Set(Nan::New("filename").ToLocalChecked(), Nan::New(dic->filename).ToLocalChecked());
obj->Set(Nan::New("charset").ToLocalChecked(), Nan::New(dic->charset).ToLocalChecked());
obj->Set(Nan::New("size").ToLocalChecked(), Nan::New(dic->size));
obj->Set(Nan::New("type").ToLocalChecked(), Nan::New(dic->type));
obj->Set(Nan::New("lsize").ToLocalChecked(), Nan::New(dic->lsize));
obj->Set(Nan::New("rsize").ToLocalChecked(), Nan::New(dic->rsize));
obj->Set(Nan::New("version").ToLocalChecked(), Nan::New(dic->version));
info_list.push_back(obj);
}
v8::Local<v8::Array> results = Nan::New<v8::Array>(info_list.size());
for(unsigned int i = 0; i < results->Length(); ++i) {
results->Set(i, info_list.at(i));
}
const unsigned argc = 2;
v8::Local<v8::Value> argv[] = {
Nan::Null(),
results
};
Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
}
void Client::Debug(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 1, "1")
CHECK_N_ARGS_IS_A_BOOLEAN(info, 0, "0")
memClient->debug = info[0]->ToBoolean()->Value();
info.GetReturnValue().Set(Nan::Undefined());
}
void Client::Stop(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 1, "1")
CHECK_N_ARGS_IS_A_FUNCTION(info, 0, "0")
Callback* callback = new Callback(info[0].As<v8::Function>());
memClient->progressWorker->setCallback(callback);
memClient->isRunning = false;
}
void MeCab_Tagger::Parse(const Nan::FunctionCallbackInfo<v8::Value>& info) {
MeCab_Tagger* mecabTagger = ObjectWrap::Unwrap<MeCab_Tagger>(info.Holder());
v8::String::Utf8Value input(info[0]);
v8::Local<v8::Function> callback = info[1].As<v8::Function>();
const char *result = mecabTagger->tagger->parse(*input);
const unsigned argc = 2;
v8::Local<v8::Value> argv[] = {
Nan::Null(),
Nan::New(result).ToLocalChecked()
};
Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
}
void Client::FetchResult(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 1, "1")
CHECK_N_ARGS_IS_A_FUNCTION(info, 0, "0")
Callback* callback = GET_CALLBACK_FROM_PARAM(info[0]);
JobBase* job = new FetchResultJob(callback);
job->setDebug(memClient->debug);
memClient->jobs.insert(job);
info.GetReturnValue().Set(Nan::Undefined());
}
void Client::Exist(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 2, "2")
CHECK_N_ARGS_IS_A_STRING(info, 0, "0")
CHECK_N_ARGS_IS_A_FUNCTION(info, 1, "1")
const string memcached_key = GET_STRING_FROM_PARAM(info[0]);
Callback* callback = GET_CALLBACK_FROM_PARAM(info[1]);
JobBase* job = new ExistJob(callback, memcached_key);
job->setDebug(memClient->debug);
memClient->jobs.insert(job);
info.GetReturnValue().Set(Nan::Undefined());
}
void Client::Delete(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 3, "3")
CHECK_N_ARGS_IS_A_STRING(info, 0, "0")
CHECK_N_ARGS_IS_AN_UNSIGNED_INTEGER(info, 1, "1")
CHECK_N_ARGS_IS_A_FUNCTION(info, 2, "2")
const string memcached_key = GET_STRING_FROM_PARAM(info[0]);
uint32_t expirationTime = (uint32_t) GET_NUMBER_FROM_PARAM(info[1]);
Callback* callback = GET_CALLBACK_FROM_PARAM(info[2]);
JobBase* job = new DeleteJob(callback, memcached_key, expirationTime);
job->setDebug(memClient->debug);
memClient->jobs.insert(job);
info.GetReturnValue().Set(Nan::Undefined());
}
void Client::Replace(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 4, "4")
CHECK_N_ARGS_IS_A_STRING(info, 0, "0")
CHECK_N_ARGS_IS_A_STRING(info, 1, "1")
CHECK_N_ARGS_IS_A_NUMBER(info, 2, "2")
CHECK_N_ARGS_IS_A_FUNCTION(info, 3, "3")
const string memcached_key = GET_STRING_FROM_PARAM(info[0]);
const string memcached_value = GET_STRING_FROM_PARAM(info[1]);
time_t ttl = (time_t) GET_NUMBER_FROM_PARAM(info[2]);
Callback* callback = GET_CALLBACK_FROM_PARAM(info[3]);
JobBase* job = new ReplaceJob(callback, memcached_key, memcached_value, ttl);
job->setDebug(memClient->debug);
memClient->jobs.insert(job);
info.GetReturnValue().Set(Nan::Undefined());
}
void MeCab_Tagger::ParseToNode(const Nan::FunctionCallbackInfo<v8::Value>& info) {
MeCab_Tagger* mecabTagger = ObjectWrap::Unwrap<MeCab_Tagger>(info.Holder());
v8::String::Utf8Value input(info[0]);
v8::Local<v8::Function> callback = info[1].As<v8::Function>();
std::vector<v8::Local<v8::Object>> node_list;
const MeCab::Node* node = mecabTagger->tagger->parseToNode(*input);
for (; node; node = node->next) {
v8::Local<v8::Object> obj = Nan::New<v8::Object>();
obj->Set(Nan::New("word").ToLocalChecked(), Nan::New(std::string(node->surface, node->length)).ToLocalChecked());
obj->Set(Nan::New("id").ToLocalChecked(), Nan::New(node->id));
obj->Set(Nan::New("surface").ToLocalChecked(), Nan::New(node->surface).ToLocalChecked());
obj->Set(Nan::New("feature").ToLocalChecked(), Nan::New(node->feature).ToLocalChecked());
obj->Set(Nan::New("len").ToLocalChecked(), Nan::New(node->length));
obj->Set(Nan::New("rcAttr").ToLocalChecked(), Nan::New(node->rcAttr));
obj->Set(Nan::New("lcAttr").ToLocalChecked(), Nan::New(node->lcAttr));
obj->Set(Nan::New("posid").ToLocalChecked(), Nan::New(node->posid));
obj->Set(Nan::New("char_type").ToLocalChecked(), Nan::New(node->char_type));
obj->Set(Nan::New("stat").ToLocalChecked(), Nan::New(node->stat));
obj->Set(Nan::New("isbest").ToLocalChecked(), Nan::New(node->isbest));
obj->Set(Nan::New("alpha").ToLocalChecked(), Nan::New(node->alpha));
obj->Set(Nan::New("beta").ToLocalChecked(), Nan::New(node->beta));
obj->Set(Nan::New("prob").ToLocalChecked(), Nan::New(node->prob));
obj->Set(Nan::New("cost").ToLocalChecked(), Nan::New((int)node->cost));
node_list.push_back(obj);
}
v8::Local<v8::Array> results = Nan::New<v8::Array>(node_list.size());
for(unsigned int i = 0; i < results->Length(); ++i) {
results->Set(i, node_list.at(i));
}
const unsigned argc = 2;
v8::Local<v8::Value> argv[] = {
Nan::Null(),
results
};
Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
}
void Client::MGetAndFetchAll(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
CHECK_ARGUMENT_LENGTH(info, 2, "2")
CHECK_N_ARGS_IS_AN_ARRAY(info, 0, "0")
CHECK_N_ARGS_IS_A_FUNCTION(info, 1, "1")
v8::Local<v8::Object> arr = info[0]->ToObject();
size_t number_of_keys = arr->GetOwnPropertyNames()->Length();
memClient->debug && printf("%s %lu %s\n", "Array with", number_of_keys, "keys");
std::vector<string> keys;
for(size_t i = 0; i < number_of_keys; i++) {
keys.push_back(GET_STRING_FROM_PARAM(arr->Get(i)));
}
Callback* callback = GET_CALLBACK_FROM_PARAM(info[1]);
JobBase* job = new MGetAndFetchAllJob(callback, keys);
job->setDebug(memClient->debug);
memClient->jobs.insert(job);
info.GetReturnValue().Set(Nan::Undefined());
}
void Client::Start(const Nan::FunctionCallbackInfo<v8::Value>& info) {
Client* memClient = ObjectWrap::Unwrap<Client>(info.Holder());
memClient->isRunning = true;
memClient->progressWorker = new MemcachedAsyncProgressWorker(memClient, new Callback());
Nan::AsyncQueueWorker(memClient->progressWorker);
}
inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
ParameterParser argsToParams,
ServiceMemFn service,
bool requires_multiple_coordinates)
{
auto params = argsToParams(info, requires_multiple_coordinates);
if (!params)
return;
auto pluginParams = argumentsToPluginParameters(info);
BOOST_ASSERT(params->IsValid());
if (!info[info.Length() - 1]->IsFunction())
return Nan::ThrowTypeError("last argument must be a callback function");
auto *const self = Nan::ObjectWrap::Unwrap<Engine>(info.Holder());
using ParamPtr = decltype(params);
struct Worker final : Nan::AsyncWorker
{
using Base = Nan::AsyncWorker;
Worker(std::shared_ptr<osrm::OSRM> osrm_,
ParamPtr params_,
ServiceMemFn service,
Nan::Callback *callback,
PluginParameters pluginParams_)
: Base(callback), osrm{std::move(osrm_)}, service{std::move(service)},
params{std::move(params_)}, pluginParams{std::move(pluginParams_)}
{
}
void Execute() override try
{
const auto status = ((*osrm).*(service))(*params, result);
ParseResult(status, result);
}
catch (const std::exception &e)
{
SetErrorMessage(e.what());
}
void HandleOKCallback() override
{
Nan::HandleScope scope;
const constexpr auto argc = 2u;
v8::Local<v8::Value> argv[argc] = {Nan::Null(), render(result)};
callback->Call(argc, argv);
}
// Keeps the OSRM object alive even after shutdown until we're done with callback
std::shared_ptr<osrm::OSRM> osrm;
ServiceMemFn service;
const ParamPtr params;
const PluginParameters pluginParams;
std::string result;
};
auto *callback = new Nan::Callback{info[info.Length() - 1].As<v8::Function>()};
Nan::AsyncQueueWorker(
new Worker{self->this_, std::move(params), service, callback, std::move(pluginParams)});
}