int Interface::UserInvoke(JNIEnv *jniEnv, Handle<Object> target, int opIdx, jobjectArray jArgs, jobject *jResult) { HandleScope scope; TryCatch tryCatch; Operation *op = operations->addr(opIdx); int result = OK; for(int i = 0; result == OK && i < op->argCount; i++) { result = conv->ToV8Value(jniEnv, jniEnv->GetObjectArrayElement(jArgs, i), op->argTypes[i], &op->vArgs[i]); } if(result == OK) { Handle<Value> vRes; if(target->IsFunction() && parent == 0 && operations->getLength() == 1) { /* invoke as function if target is a function, and interface delcares only one operation */ vRes = (Handle<Function>::Cast(target))->Call(target, op->argCount, op->vArgs); } else { /* locate the method and invoke that */ Handle<Value> vMethod = target->Get(op->name); if(!vMethod.IsEmpty() && vMethod->IsFunction()) { vRes = Handle<Function>::Cast(vMethod)->Call(target, op->argCount, op->vArgs); } } if(!vRes.IsEmpty() && op->type != TYPE_UNDEFINED) { jobject ob; result = conv->ToJavaObject(jniEnv, vRes, op->type, &ob); if(result == OK) { *jResult = ob; } } } if(tryCatch.HasCaught()) { result = ErrorJS; tryCatch.Reset(); } return result; }
// parse string returned by $self->to_js() into function void V8Context::fixup_prototype(Handle<Object> prototype) { Handle<Value> val = prototype->Get(string_to_js); if (val.IsEmpty() || !val->IsFunction()) return; TryCatch try_catch; Handle<Value> to_js = Handle<Function>::Cast(val)->Call(context->Global(), 0, NULL); Handle<Script> script = Script::Compile(to_js->ToString()); if (try_catch.HasCaught()) { set_perl_error(try_catch); } else { Handle<Value> val = script->Run(); if (val.IsEmpty() || !val->IsFunction()) { set_perl_error(try_catch); } else { prototype->Set(string_to_js, val); } } }
Handle<Value> TypedArray::New(GDALDataType type, unsigned int length) { NanEscapableScope(); Handle<Value> val; Handle<Function> constructor; Local<Object> global = NanGetCurrentContext()->Global(); const char *name; switch(type) { case GDT_Byte: name = "Uint8Array"; break; case GDT_Int16: name = "Int16Array"; break; case GDT_UInt16: name = "Uint16Array"; break; case GDT_Int32: name = "Int32Array"; break; case GDT_UInt32: name = "Uint32Array"; break; case GDT_Float32: name = "Float32Array"; break; case GDT_Float64: name = "Float64Array"; break; default: NanThrowError("Unsupported array type"); return NanEscapeScope(NanUndefined()); } // make ArrayBuffer val = global->Get(NanNew("ArrayBuffer")); if(val.IsEmpty() || !val->IsFunction()) { NanThrowError("Error getting ArrayBuffer constructor"); return NanEscapeScope(NanUndefined()); } constructor = val.As<Function>(); Local<Value> size = NanNew<Integer>(length * GDALGetDataTypeSize(type) / 8); Local<Value> array_buffer = constructor->NewInstance(1, &size); if(array_buffer.IsEmpty() || !array_buffer->IsObject()) { NanThrowError("Error allocating ArrayBuffer"); return NanEscapeScope(NanUndefined()); } // make TypedArray val = global->Get(NanNew(name)); if(val.IsEmpty() || !val->IsFunction()) { NanThrowError("Error getting typed array constructor"); return NanEscapeScope(NanUndefined()); } constructor = val.As<Function>(); Local<Object> array = constructor->NewInstance(1, &array_buffer); if(array.IsEmpty() || !array->IsObject()) { NanThrowError("Error creating TypedArray"); return NanEscapeScope(NanUndefined()); } return NanEscapeScope(array); }
Handle<Value> ScriptMatch::_callGetMatchFeatureDetails(const ConstOsmMapPtr& map) const { Isolate* current = v8::Isolate::GetCurrent(); EscapableHandleScope handleScope(current); Context::Scope context_scope(_script->getContext(current)); Handle<Object> plugin = Handle<Object>::Cast( _script->getContext(current)->Global()->Get(String::NewFromUtf8(current, "plugin"))); Handle<Value> value = plugin->Get(String::NewFromUtf8(current, "getMatchFeatureDetails")); Handle<Function> func = Handle<Function>::Cast(value); Handle<Value> jsArgs[3]; if (func.IsEmpty() || func->IsFunction() == false) { throw IllegalArgumentException("getMatchFeatureDetails must be a valid function."); } Handle<Object> mapObj = OsmMapJs::create(map); int argc = 0; jsArgs[argc++] = mapObj; jsArgs[argc++] = ElementJs::New(map->getElement(_eid1)); jsArgs[argc++] = ElementJs::New(map->getElement(_eid2)); TryCatch trycatch; Handle<Value> result = func->Call(plugin, argc, jsArgs); HootExceptionJs::checkV8Exception(result, trycatch); return handleScope.Escape(result); }
IOBasicTypes::LongBufferSizeType ObjectByteWriterWithPosition::Write(const IOBasicTypes::Byte* inBuffer,IOBasicTypes::LongBufferSizeType inBufferSize) { HandleScope handle; Handle<Object> anArray = Array::New((int)inBufferSize); for(int i=0;i<(int)inBufferSize;++i) anArray->Set(Number::New(i),Number::New(inBuffer[i])); Handle<Value> value = mObject->Get(String::New("write")); if(value->IsUndefined() || !value->IsFunction()) { ThrowException(Exception::TypeError(String::New("write is not a function, it should be you know..."))); return 0; } Handle<Function> func = Handle<Function>::Cast(value); Handle<Value> args[1]; args[0] = anArray; Handle<Value> result = func->Call(mObject, 1, args); if(result.IsEmpty()) { ThrowException(Exception::TypeError(String::New("wrong return value. it's empty. return the number of written characters"))); return 0; } else if(result->IsNumber()) { return result->ToNumber()->Uint32Value(); } else { ThrowException(Exception::TypeError(String::New("wrong return value. write should return the number of written characters"))); return 0; } }
Handle<Value> ScriptMatch::_call(const ConstOsmMapPtr& map, Handle<Object> plugin) { HandleScope handleScope; Context::Scope context_scope(_script->getContext()); plugin = Handle<Object>::Cast(_script->getContext()->Global()->Get(String::New("plugin"))); Handle<v8::Value> value = plugin->Get(String::New("matchScore")); Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value); Handle<Value> jsArgs[3]; if (func.IsEmpty() || func->IsFunction() == false) { throw IllegalArgumentException("matchScore must be a valid function."); } Handle<Object> mapObj = OsmMapJs::create(map); int argc = 0; jsArgs[argc++] = mapObj; jsArgs[argc++] = ElementJs::New(map->getElement(_eid1)); jsArgs[argc++] = ElementJs::New(map->getElement(_eid2)); TryCatch trycatch; Handle<Value> result = func->Call(plugin, argc, jsArgs); HootExceptionJs::checkV8Exception(result, trycatch); return handleScope.Close(result); }
/* static */ void V8Runtime::bootstrap(Local<Object> global) { EventEmitter::Initialize(); krollGlobalObject = Persistent<Object>::New(Object::New()); DEFINE_METHOD(krollGlobalObject, "log", krollLog); DEFINE_METHOD(krollGlobalObject, "binding", KrollBindings::getBinding); DEFINE_TEMPLATE(krollGlobalObject, "EventEmitter", EventEmitter::constructorTemplate); krollGlobalObject->Set(String::NewSymbol("runtime"), String::New("v8")); LOG_TIMER(TAG, "Executing kroll.js"); TryCatch tryCatch; Handle<Value> result = V8Util::executeString(KrollBindings::getMainSource(), String::New("kroll.js")); if (tryCatch.HasCaught()) { V8Util::reportException(tryCatch, true); } if (!result->IsFunction()) { LOGF(TAG, "kroll.js result is not a function"); V8Util::reportException(tryCatch, true); } Handle<Function> mainFunction = Handle<Function>::Cast(result); Local<Value> args[] = { Local<Value>::New(krollGlobalObject) }; mainFunction->Call(global, 1, args); if (tryCatch.HasCaught()) { V8Util::reportException(tryCatch, true); LOGE(TAG, "Caught exception while bootstrapping Kroll"); } }
int V8Scope::type( const char *field ){ V8_SIMPLE_HEADER Handle<Value> v = get( field ); if ( v->IsNull() ) return jstNULL; if ( v->IsUndefined() ) return Undefined; if ( v->IsString() ) return String; if ( v->IsFunction() ) return Code; if ( v->IsArray() ) return Array; if ( v->IsBoolean() ) return Bool; if ( v->IsInt32() ) return NumberInt; if ( v->IsNumber() ) return NumberDouble; if ( v->IsExternal() ){ uassert( 10230 , "can't handle external yet" , 0 ); return -1; } if ( v->IsDate() ) return Date; if ( v->IsObject() ) return Object; throw UserException( 12509, (string)"don't know what this is: " + field ); }
ClrFuncInvokeContext::ClrFuncInvokeContext(Handle<v8::Value> callbackOrSync) : _this(0), callback(0), uv_edge_async(0) { static MonoClassField* field; static MonoClassField* syncField; if (!field) field = mono_class_get_field_from_name(GetClrFuncInvokeContextClass(), "native"); if (!syncField) syncField = mono_class_get_field_from_name(GetClrFuncInvokeContextClass(), "Sync"); MonoObject* obj = mono_object_new(mono_domain_get(), GetClrFuncInvokeContextClass()); ClrFuncInvokeContext* thisPointer = this; mono_field_set_value(obj, field, &thisPointer); this->_this = mono_gchandle_new(obj, FALSE); // released in destructor DBG("ClrFuncInvokeContext::ClrFuncInvokeContext"); if (callbackOrSync->IsFunction()) { this->callback = new Persistent<Function>(); // released in destructor *(this->callback) = Persistent<Function>::New(Handle<Function>::Cast(callbackOrSync)); this->Sync(FALSE); } else { this->Sync(callbackOrSync->BooleanValue()); } }
void Susi::JS::Engine::RegisterProcessor(const v8::FunctionCallbackInfo<v8::Value>& args) { if (args.Length() < 2) return; Handle<Value> callbackValue = args[1]; if(callbackValue->IsFunction()){ Handle<Value> topicValue = args[0]; std::string topic{Susi::JS::Engine::convertFromJS(topicValue).toString()}; std::shared_ptr<Persistent<Function>> jsCallback{new Persistent<Function>(Isolate::GetCurrent(),Handle<Function>::Cast(callbackValue))}; Susi::Events::Processor callback = [jsCallback](Susi::Events::EventPtr event){ Local<Function> func = Local<Function>::New(Isolate::GetCurrent(),*jsCallback); Handle<Value> callbackArguments[1]; callbackArguments[0] = Susi::JS::Engine::convertFromCPP(event->toAny()); TryCatch trycatch; auto res = func->Call(func,1,callbackArguments); if (res.IsEmpty()) { Handle<Value> exception = trycatch.Exception(); String::Utf8Value exception_str(exception); std::cout<<*exception_str<<std::endl; } }; long id = Susi::JS::engine->susi_client.subscribe(topic,callback); args.GetReturnValue().Set((double)id); }else{ args.GetReturnValue().Set(false); } }
JNIEXPORT void JNICALL Java_org_appcelerator_kroll_runtime_v8_V8Object_nativeSetWindow (JNIEnv *env, jobject javaKrollWindow, jlong ptr, jobject javaWindow) { ENTER_V8(V8Runtime::globalContext); titanium::JNIScope jniScope(env); Handle<Object> jsKrollWindow; if (ptr != 0) { jsKrollWindow = Persistent<Object>((Object *) ptr); } else { jsKrollWindow = TypeConverter::javaObjectToJsValue(env, javaKrollWindow)->ToObject(); } Handle<Value> setWindowValue = jsKrollWindow->Get(String::New("setWindow")); if (!setWindowValue->IsFunction()) { return; } Handle<Function> setWindow = Handle<Function>::Cast(setWindowValue->ToObject()); Handle<Value> jsWindow = TypeConverter::javaObjectToJsValue(env, javaWindow); TryCatch tryCatch; if (!jsWindow->IsNull()) { Handle<Value> args[] = { jsWindow }; setWindow->Call(jsKrollWindow, 1, args); } if (tryCatch.HasCaught()) { V8Util::openJSErrorDialog(tryCatch); V8Util::reportException(tryCatch); } }
/* * This is meant to run one time when the match creator is initialized. */ void customScriptInit() { Context::Scope context_scope(_script->getContext()); HandleScope handleScope; Persistent<Object> plugin = getPlugin(); Handle<String> initStr = String::New("init"); if (plugin->Has(initStr) == false) { throw HootException("Error finding 'init' function."); } Handle<v8::Value> value = plugin->Get(initStr); if (value->IsFunction() == false) { throw HootException("init is not a function."); } Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value); Handle<Value> jsArgs[1]; int argc = 0; HandleScope scope; assert(_map.get()); OsmMapPtr copiedMap(new OsmMap(_map)); jsArgs[argc++] = OsmMapJs::create(copiedMap); func->Call(plugin, argc, jsArgs); //this is meant to have been set externally in a js rules file _searchRadius = getNumber(plugin, "searchRadius", -1.0, 15.0); }
bool isMatchCandidate(ConstElementPtr e) { Context::Scope context_scope(_script->getContext()); HandleScope handleScope; Persistent<Object> plugin = getPlugin(); Handle<String> isMatchCandidateStr = String::New("isMatchCandidate"); if (plugin->Has(isMatchCandidateStr) == false) { throw HootException("Error finding 'isMatchCandidate' function."); } Handle<v8::Value> value = plugin->Get(isMatchCandidateStr); if (value->IsFunction() == false) { throw HootException("isMatchCandidate is not a function."); } Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value); Handle<Value> jsArgs[2]; int argc = 0; jsArgs[argc++] = OsmMapJs::create(_map); jsArgs[argc++] = ElementJs::New(e); Handle<Value> f = func->Call(plugin, argc, jsArgs); return f->BooleanValue(); }
void key::Window::setOnWindowResize(Handle<Value> value) { HandleScope handle_scope; if (value->IsFunction()) { auto func = Handle<Function>::Cast(value); this->onWindowResize = Persistent<Function>::New(func); } else cout << "Warning! Tried to set non-function as onWindowResize event callback!" << endl; }
int Conv::GetNaturalType(Handle<Object> val) { if(val.IsEmpty()) return TYPE_INVALID; if(val->IsDate()) return TYPE_DATE; if(val->IsFunction()) return TYPE_FUNCTION; if(val->IsArray()) return TYPE_ARRAY; if(val->IsObject()) return TYPE_OBJECT; return TYPE_INVALID; }
bool WeechatJsV8::functionExists(const char *function) { Context::Scope context_scope(this->context); Handle<Object> global = this->context->Global(); Handle<Value> value = global->Get(String::New(function)); return value->IsFunction(); }
void setPersistentFunc(Persistent<Function>& pf,Handle<Value>& v){ if(v->IsFunction()){ if(!pf.IsEmpty()) pf.Dispose(); pf = Persistent<Function>::New(Handle<Function>::Cast(v)); }else if(v->IsNull()||v->IsUndefined()){ if(pf.IsEmpty()) return; pf.Dispose(); pf.Clear(); } }
static Local<Value> ConstructError(const char *name, Handle<String> message) { // XXX: this probably isn't correct in all cases Handle<Context> ctx = Context::GetCurrent(); Handle<Object> global = ctx->Global(); Handle<Value> ctor = global->Get(String::New(name)); if (ctor.IsEmpty() || !ctor->IsFunction()) return Local<Value>(); Handle<Function> fn = ctor.As<Function>(); Handle<Value> args[] = { Handle<Value>(message) }; return Local<Value>::New(fn->NewInstance(1, args)); }
int NativeTCPSocketObject::setAcceptedCallback(TiObject* obj, void* userContext) { Handle<Value> value = obj->getValue(); if (value->IsFunction()) { TiTCPSocketObject* context = (TiTCPSocketObject*)userContext; Handle<Object> source = Handle<Object>::Cast(context->getValue()); TiV8Event* acceptEvent = TiV8Event::createEvent(tetACCEPTED, Handle<Function>::Cast(value), source); setEventHandler(tetACCEPTED, acceptEvent); events_[tetACCEPTED]->container->setV8ValueProperty("socket", context->getValue()); acceptEvent->release(); return NATIVE_ERROR_OK; } return NATIVE_ERROR_INVALID_ARG; }
JNIEXPORT jboolean JNICALL Java_org_appcelerator_kroll_runtime_v8_V8Object_nativeFireEvent (JNIEnv *env, jobject jEmitter, jlong ptr, jstring event, jobject data) { ENTER_V8(V8Runtime::globalContext); JNIScope jniScope(env); Handle<Value> jsEvent = TypeConverter::javaStringToJsString(event); #ifdef TI_DEBUG String::Utf8Value eventName(jsEvent); LOGV(TAG, "firing event \"%s\"", *eventName); #endif Handle<Object> emitter; if (ptr != 0) { emitter = Persistent<Object>((Object *) ptr); } else { emitter = TypeConverter::javaObjectToJsValue(jEmitter)->ToObject(); } Handle<Value> fireEventValue = emitter->Get(EventEmitter::emitSymbol); if (!fireEventValue->IsFunction()) { return JNI_FALSE; } Handle<Function> fireEvent = Handle<Function>::Cast(fireEventValue->ToObject()); Handle<Value> jsData = TypeConverter::javaObjectToJsValue(data); Handle<Value> result; TryCatch tryCatch; if (jsData->IsNull()) { Handle<Value> args[] = { jsEvent }; result = fireEvent->Call(emitter, 1, args); } else { Handle<Value> args[] = { jsEvent, jsData }; result = fireEvent->Call(emitter, 2, args); } if (tryCatch.HasCaught()) { V8Util::openJSErrorDialog(tryCatch); V8Util::reportException(tryCatch); } else if (result->IsTrue()) { return JNI_TRUE; } return JNI_FALSE; }
ClrFuncInvokeContext::ClrFuncInvokeContext(Handle<v8::Value> callbackOrSync) { DBG("ClrFuncInvokeContext::ClrFuncInvokeContext"); if (callbackOrSync->IsFunction()) { this->callback = new Persistent<Function>; *(this->callback) = Persistent<Function>::New(Handle<Function>::Cast(callbackOrSync)); this->Sync = false; } else { this->Sync = callbackOrSync->BooleanValue(); } this->uv_edge_async = NULL; }
void CallJSFunction(JavaScriptCompiler &jsc, JavaScriptSource *source, const char *name) { HandleScope scope(jsc.GetIsolate()); Local<Context> ctx = Local<Context>::New(jsc.GetIsolate(), source->ctx_); Context::Scope context_scope(ctx); Handle<Value> rewriteFuncValue = ctx->Global()->Get(String::NewSymbol(name)); if (!rewriteFuncValue.IsEmpty() && rewriteFuncValue->IsFunction()) { const int argc = 0; Handle<Function> initFunc = Handle<Function>::Cast(rewriteFuncValue); Handle<Value> ret = initFunc->Call(ctx->Global(), argc, NULL); String::AsciiValue ascii(ret); ASSERT_STREQ("OK", *ascii); } }
int Conv::ToJavaString(JNIEnv *jniEnv, Handle<Value> val, jstring *jVal) { Handle<String> vString; Handle<Value> empty, vRes; jstring ob; char buf[64]; switch(GetNaturalType(val)) { default: { if(val->IsObject()) { /* call ToString() in javascript */ Handle<Object> oVal = val->ToObject(); Handle<Value> vToString = oVal->Get(sToString); if(!vToString.IsEmpty() && vToString->IsFunction()) { Handle<Function> fToString = Handle<Function>::Cast(vToString); vRes = fToString->CallAsFunction(oVal, 0, &empty); if(!vRes.IsEmpty() && (vRes->IsString() || vRes->IsStringObject())) { return ToJavaString(jniEnv, vRes->ToString(), jVal); } } } return ErrorType; } case TYPE_UNDEFINED: case TYPE_NULL: *jVal = 0; return OK; case TYPE_BOOL: return ToJavaString(jniEnv, (val->BooleanValue() ? "true" : "false"), jVal); case TYPE_INT: sprintf(buf, "%d", val->Int32Value()); return ToJavaString(jniEnv, buf, jVal); case TYPE_LONG: sprintf(buf, "%lld", val->IntegerValue()); return ToJavaString(jniEnv, buf, jVal); case TYPE_DOUBLE: sprintf(buf, "%g", val->NumberValue()); return ToJavaString(jniEnv, buf, jVal); case TYPE_STRING: return ToJavaString(jniEnv, val->ToString(), (jstring *)jVal); } if(ob) { *jVal = ob; return OK; } if(jniEnv->ExceptionCheck()) jniEnv->ExceptionClear(); return ErrorVM; }
ClrFuncInvokeContext::ClrFuncInvokeContext(Handle<v8::Value> callbackOrSync) { DBG("ClrFuncInvokeContext::ClrFuncInvokeContext"); if (callbackOrSync->IsFunction()) { this->callback = new Persistent<Function>; Local<Function> callbackOrSyncFunction = Handle<Function>::Cast(callbackOrSync); (this->callback)->Reset(Isolate::GetCurrent(), callbackOrSyncFunction); this->Sync = false; } else { this->Sync = callbackOrSync->BooleanValue(); } this->uv_edge_async = NULL; }
TEST(JavaScriptCompiler, Load) { JavaScriptCompiler jsc; jsc.Load(DRAGON_TEST_PATH, "testJavaScriptCompiler/subdir"); SourceMap &source= jsc.GetSource(); JavaScriptSource *source1 = source["1"]; HandleScope scope(jsc.GetIsolate()); Local<Context> ctx = Local<Context>::New(jsc.GetIsolate(), source1->ctx_); Context::Scope context_scope(ctx); Handle<Value> rewriteFuncValue = ctx->Global()->Get(String::NewSymbol("test1")); if (!rewriteFuncValue.IsEmpty() && rewriteFuncValue->IsFunction()) { const int argc = 0; Handle<Function> initFunc = Handle<Function>::Cast(rewriteFuncValue); Handle<Value> ret = initFunc->Call(ctx->Global(), argc, NULL); String::AsciiValue ascii(ret); ASSERT_STREQ("OK1", *ascii); } }
void test_obj_getprop() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); Handle<Object> obj = Object::New(); Handle<Value> k = String::New("toString"); Handle<Value> v = obj->Get(k); do_check_true(v->IsFunction()); context.Dispose(); }
ScriptingFunction V8Scope::_createFunction( const char * raw ){ string code = raw; if ( code.find( "function" ) == string::npos ){ if ( code.find( "\n" ) == string::npos && code.find( "return" ) == string::npos && ( code.find( ";" ) == string::npos || code.find( ";" ) == code.size() - 1 ) ){ code = "return " + code; } code = "function(){ " + code + "}"; } int num = _funcs.size() + 1; string fn; { stringstream ss; ss << "_funcs" << num; fn = ss.str(); } code = fn + " = " + code; TryCatch try_catch; Handle<Script> script = v8::Script::Compile( v8::String::New( code.c_str() ) , v8::String::New( fn.c_str() ) ); if ( script.IsEmpty() ){ _error = (string)"compile error: " + toSTLString( &try_catch ); log() << _error << endl; return 0; } Local<Value> result = script->Run(); if ( result.IsEmpty() ){ _error = (string)"compile error: " + toSTLString( &try_catch ); log() << _error << endl; return 0; } Handle<Value> f = _global->Get( v8::String::New( fn.c_str() ) ); uassert( "not a func" , f->IsFunction() ); _funcs.push_back( f ); return num; }
int NativeTCPSocketObject::setConnectedCallback(TiObject* obj, void* userContext) { if (socketState_ != SOCKET_STATE_INITIALIZED) { throw NativeException(Native::Msg::Invalid_socket_state); } Handle<Value> value = obj->getValue(); if (value->IsFunction()) { TiTCPSocketObject* context = (TiTCPSocketObject*)userContext; Handle<Object> source = Handle<Object>::Cast(context->getValue()); TiV8Event* connectEvent = TiV8Event::createEvent(tetCONNECTED, Handle<Function>::Cast(value), source); setEventHandler(tetCONNECTED, connectEvent); events_[tetCONNECTED]->container->setV8ValueProperty("socket", context->getValue()); connectEvent->release(); return NATIVE_ERROR_OK; } return NATIVE_ERROR_INVALID_ARG; }
ScriptMatchVisitor(const ConstOsmMapPtr& map, vector<const Match*>& result, ConstMatchThresholdPtr mt, boost::shared_ptr<PluginContext> script, ElementCriterionPtr filter = ElementCriterionPtr()) : _map(map), _result(result), _mt(mt), _script(script), _filter(filter), _customSearchRadius(-1.0) { _neighborCountMax = -1; _neighborCountSum = 0; _elementsEvaluated = 0; _maxGroupSize = 0; _numElementsVisited = 0; _numMatchCandidatesVisited = 0; _taskStatusUpdateInterval = ConfigOptions().getTaskStatusUpdateInterval(); Isolate* current = v8::Isolate::GetCurrent(); HandleScope handleScope(current); Context::Scope context_scope(_script->getContext(current)); Handle<Object> plugin = getPlugin(); _candidateDistanceSigma = getNumber(plugin, "candidateDistanceSigma", 0.0, 1.0); //this is meant to have been set externally in a js rules file _customSearchRadius = getNumber(plugin, "searchRadius", -1.0, 15.0); LOG_VART(_customSearchRadius); Handle<Value> value = plugin->Get(toV8("getSearchRadius")); if (value->IsUndefined()) { // pass } else if (value->IsFunction() == false) { throw HootException("getSearchRadius is not a function."); } else { _getSearchRadius.Reset(current, Handle<Function>::Cast(value)); } }
ScriptMatchVisitor(const ConstOsmMapPtr& map, vector<const Match*>& result, ConstMatchThresholdPtr mt, shared_ptr<PluginContext> script) : _map(map), _result(result), _mt(mt), _script(script), _searchRadius(-1.0) { _neighborCountMax = -1; _neighborCountSum = 0; _elementsEvaluated = 0; _maxGroupSize = 0; HandleScope handleScope; Context::Scope context_scope(_script->getContext()); Handle<Object> plugin = getPlugin(); _candidateDistanceSigma = getNumber(plugin, "candidateDistanceSigma", 0.0, 1.0); //this is meant to have been set externally in a js rules file _searchRadius = getNumber(plugin, "searchRadius", -1.0, 15.0); Handle<v8::Value> value = plugin->Get(toV8("getSearchRadius")); if (value->IsUndefined()) { // pass } else if (value->IsFunction() == false) { throw HootException("getSearchRadius is not a function."); } else { _getSearchRadius = Persistent<Function>::New(Handle<Function>::Cast(value)); } SmWorstCircularErrorVisitor v(*this); map->visitRo(v); _worstCircularError = v.getWorstCircularError(); }