void Msg_Struct::build_http_msg_buffer(Isolate* isolate, v8::Local<v8::Object> object, std::string &str) { std::stringstream stream; for(std::vector<Field_Info>::const_iterator iter = field_vec().begin(); iter != field_vec().end(); iter++) { stream.str(""); stream << "\"" << iter->field_name << "\":"; Local<Value> value = object->Get(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, iter->field_name.c_str(), NewStringType::kNormal).ToLocalChecked()).ToLocalChecked(); if(iter->field_type == "int8" || iter->field_type == "int16" || iter->field_type == "int32") { int32_t val = 0; if (value->IsInt32()) { val = value->Int32Value(isolate->GetCurrentContext()).FromJust(); } stream << val << ","; } else if(iter->field_type == "int64") { int64_t val = 0; if (value->IsNumber()) { val = value->NumberValue(isolate->GetCurrentContext()).FromJust(); } stream << val << ","; } else if(iter->field_type == "double") { double val = 0; if (value->IsNumber()) { val = value->NumberValue(isolate->GetCurrentContext()).FromJust(); } stream << val << ","; } else if(iter->field_type == "bool") { bool val = 0; if (value->IsBoolean()) { val = value->BooleanValue(isolate->GetCurrentContext()).FromJust(); } stream << val << ","; } else if(iter->field_type == "string") { if (value->IsString()) { String::Utf8Value str(value->ToString(isolate->GetCurrentContext()).ToLocalChecked()); stream << "\"" << ToCString(str) << "\","; } else { stream << "\"\","; } } else { LOG_ERROR("Can not find the field_type:%s, struct_name:%s", iter->field_type.c_str(), struct_name().c_str()); } str += stream.str(); } }
void vectorTemplate::setVectorY(Local<String> property, Local<Value> value, const AccessorInfo &info){ Local<External> data = Local<External>::Cast(info.Data()); vector<double> *vect = reinterpret_cast<vector<double> *>(data->Value()); if(value->IsNumber()){ vect->y = value->ToNumber()->Value(); } }
Handle<Value> AddOne(const Arguments& args) { do_check_eq(args.Length(), 1); Local<Value> v = args[0]; do_check_true(v->IsNumber()); Local<Number> n = v->ToNumber(); return Number::New(n->Value() + 1.0); }
Handle<Value> Texture::On(const Arguments &args) { HandleScope scope; Local<Value> Event; Local<Value> Options; Local<Value> Callback; ClutterActor *instance = ObjectWrap::Unwrap<Texture>(args.This())->_actor; #if 0 /* Check arguments */ if (args.Length() == 2) { Event = args[0]; Callback = args[1]; } else if (args.Length() == 3) { Event = args[0]; Options = args[1]; Callback = args[2]; } else return args.This(); if (!Event->IsNumber()) { return ThrowException(Exception::TypeError( String::New("first argument must be integer"))); } if (!Callback->IsFunction()) { return ThrowException(Exception::TypeError( String::New("Second argument must be a callback function"))); } #endif Actor::On(args); return args.This(); }
/* Set the shared PRU RAM to an input array * Takes an integer array as input, writes it to PRU shared memory * Not much error checking here, don't pass in large arrays or seg faults will happen * TODO: error checking and allow user to select range to set */ Handle<Value> setSharedRAM(const Arguments& args) { HandleScope scope; //Check we have a single argument if (args.Length() != 1) { ThrowException(Exception::TypeError(String::New("Wrong number of arguments"))); return scope.Close(Undefined()); } //Check that it's an array if (!args[0]->IsArray()) { ThrowException(Exception::TypeError(String::New("Argument must be array"))); return scope.Close(Undefined()); } //Get array Local<Array> a = Array::Cast(*args[0]); //Iterate over array for (unsigned int i = 0; i<a->Length(); i++) { //Get element and check it's numeric Local<Value> element = a->Get(i); if (!element->IsNumber()) { ThrowException(Exception::TypeError(String::New("Array must be integer"))); return scope.Close(Undefined()); } //Set corresponding memory bytes sharedMem_int[OFFSET_SHAREDRAM + i] = (unsigned int) element->NumberValue(); } //Return nothing return scope.Close(Undefined()); };
bool ArgConverter::TryConvertToJavaLong(const Local<Value>& value, jlong& javaLong) { bool success = false; if (!value.IsEmpty()) { if (value->IsNumber() || value->IsNumberObject()) { javaLong = (jlong)value->IntegerValue(); success = true; } else if (value->IsObject()) { auto obj = Local<Object>::Cast(value); auto isJavaLongValue = obj->GetHiddenValue(V8StringConstants::GetJavaLong()); if (!isJavaLongValue.IsEmpty() && isJavaLongValue->BooleanValue()) { javaLong = (jlong)ConvertToJavaLong(value); success = true; } } } return success; }
Handle<Value> Dataset::setGeoTransform(const Arguments& args) { Dataset *ds = ObjectWrap::Unwrap<Dataset>(args.This()); if(!ds->this_) return NODE_THROW("Dataset object has already been destroyed"); Handle<Array> transform; NODE_ARG_ARRAY(0, "transform", transform); if (transform->Length() != 6) { return NODE_THROW("Transform array must have 6 elements") } double buffer[6]; for (int i = 0; i < 6; i++) { Local<Value> val = transform->Get(i); if (!val->IsNumber()) { return NODE_THROW("Transform array must only contain numbers"); } buffer[i] = val->NumberValue(); } CPLErr err = ds->this_->SetGeoTransform(buffer); if (err) return NODE_THROW_CPLERR(err); return Undefined(); }
void encodeArray(bson_buffer *bb, const char *name, const Local<Value> element) { Local<Array> a = Array::Cast(*element); bson_buffer *arr = bson_append_start_array(bb, name); for (int i = 0, l=a->Length(); i < l; i++) { Local<Value> val = a->Get(Number::New(i)); stringstream keybuf; string keyval; keybuf << i << endl; keybuf >> keyval; if (val->IsString()) { encodeString(arr, keyval.c_str(), val); } else if (val->IsInt32()) { encodeInteger(arr, keyval.c_str(), val); } else if (val->IsNumber()) { encodeNumber(arr, keyval.c_str(), val); } else if (val->IsBoolean()) { encodeBoolean(arr, keyval.c_str(), val); } else if (val->IsArray()) { encodeArray(arr, keyval.c_str(), val); } else if (val->IsObject()) { bson bson(encodeObject(val)); bson_append_bson(arr, keyval.c_str(), &bson); bson_destroy(&bson); } } bson_append_finish_object(arr); }
void test_BasicCall() { HandleScope handle_scope; Handle<ObjectTemplate> templ = ObjectTemplate::New(); Handle<FunctionTemplate> fnT = v8::FunctionTemplate::New(AddOne); templ->Set("AddOne", fnT); Persistent<Context> context = Context::New(NULL, templ); Context::Scope context_scope(context); Local<Value> addone = context->Global()->Get(String::New("AddOne")); do_check_true(!addone.IsEmpty()); do_check_true(!addone->IsUndefined()); do_check_true(addone->IsObject()); do_check_true(addone->IsFunction()); Local<Function> fn = addone.As<Function>(); do_check_eq(fn, fnT->GetFunction()); Local<Number> n = Number::New(0.5); Handle<Value> args[] = { n }; Local<Value> v = fn->Call(context->Global(), 1, args); do_check_true(!v.IsEmpty()); do_check_true(v->IsNumber()); Local<Number> n2 = v->ToNumber(); do_check_eq(n2->Value(), 1.5); context.Dispose(); }
void UiWindow::SetState(Local<String> property, Local<Value> value, const PropertyCallbackInfo<void>& info) { Isolate* isolate = Isolate::GetCurrent(); HandleScope scope(isolate); UiWindow* _this = Unwrap<UiWindow>(info.This()); if (value->IsNumber()) { WINDOW_STATE state = (WINDOW_STATE)value->Int32Value(); _this->SetState(state); } }
void ODBCResult::FetchModeSetter(Local<String> property, Local<Value> value, const AccessorInfo &info) { HandleScope scope; ODBCResult *obj = ObjectWrap::Unwrap<ODBCResult>(info.Holder()); if (value->IsNumber()) { obj->m_fetchMode = value->Int32Value(); } }
void BoxLayout::SpacingSetter(Local<String> name, Local<Value> value, const AccessorInfo& info) { HandleScope scope; if (value->IsNumber()) { ClutterActor *instance = ObjectWrap::Unwrap<BoxLayout>(info.This())->_actor; mx_box_layout_set_spacing(MX_BOX_LAYOUT(instance), value->ToInteger()->Value()); } }
void Texture::FilterQualitySetter(Local<String> name, Local<Value> value, const AccessorInfo& info) { HandleScope scope; if (value->IsNumber()) { ClutterActor *instance = ObjectWrap::Unwrap<Actor>(info.This())->_actor; clutter_texture_set_filter_quality(CLUTTER_TEXTURE(instance), (ClutterTextureQuality)value->ToInteger()->Value()); } }
void Image::ScaleModeSetter(Local<String> name, Local<Value> value, const AccessorInfo& info) { HandleScope scope; if (value->IsNumber()) { ClutterActor *instance = ObjectWrap::Unwrap<Image>(info.This())->_actor; mx_image_set_scale_mode(MX_IMAGE(instance), (MxImageScaleMode)value->ToInteger()->Value()); } }
void Table::ColumnSpacingSetter(Local<String> name, Local<Value> value, const AccessorInfo& info) { HandleScope scope; if (value->IsNumber()) { ClutterActor *instance = ObjectWrap::Unwrap<Table>(info.This())->_actor; mx_table_set_column_spacing(MX_TABLE(instance), value->ToInteger()->Value()); } }
Handle<Value> Feature::addAttributes(const Arguments& args) { HandleScope scope; Feature* fp = ObjectWrap::Unwrap<Feature>(args.This()); if (args.Length() > 0 ) { Local<Value> value = args[0]; if (value->IsNull() || value->IsUndefined()) { return ThrowException(Exception::TypeError(String::New("object expected"))); } else { Local<Object> attr = value->ToObject(); try { Local<Array> names = attr->GetPropertyNames(); uint32_t i = 0; uint32_t a_length = names->Length(); boost::scoped_ptr<mapnik::transcoder> tr(new mapnik::transcoder("utf8")); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); Local<Value> value = attr->Get(name); if (value->IsString()) { UnicodeString ustr = tr->transcode(TOSTR(value)); boost::put(*fp->get(),TOSTR(name),ustr); } else if (value->IsNumber()) { double num = value->NumberValue(); // todo - round if (num == value->IntegerValue()) { int integer = value->IntegerValue(); boost::put(*fp->get(),TOSTR(name),integer); } else { double dub_val = value->NumberValue(); boost::put(*fp->get(),TOSTR(name),dub_val); } } else { std::clog << "unhandled type for property: " << TOSTR(name) << "\n"; } i++; } } catch (const std::exception & ex ) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (...) { return ThrowException(Exception::Error( String::New("Unknown exception happended - please report bug"))); } } } return Undefined(); }
void Point::zSetter(Local<String> property, Local<Value> value, const AccessorInfo &info) { Point *geom = ObjectWrap::Unwrap<Point>(info.This()); if (!value->IsNumber()) { NODE_THROW("z must be a number"); return; } double z = value->NumberValue(); ((OGRPoint* )geom->this_)->setZ(z); }
void Grid::set_prop(Local<String> property, Local<Value> value, const AccessorInfo& info) { HandleScope scope; Grid* g = ObjectWrap::Unwrap<Grid>(info.Holder()); std::string a = TOSTR(property); if (a == "key") { if (!value->IsNumber()) ThrowException(Exception::TypeError( String::New("width must be an integer"))); g->get()->set_key(TOSTR(value)); } }
void ContactsPersonProxy::_setEmail(void* userContext, Handle<Value> value) { ContactsPersonProxy *obj = (ContactsPersonProxy*) userContext; if(!value->IsObject()) return; Handle<Object> emailObject = value->ToObject(); Local<Array> emailProperties = emailObject->GetPropertyNames(); for(int i = 0, len = emailProperties->Length(); i < len; i++) { Local<String> allEmailsKey = emailProperties->Get(i)->ToString(); Local<Value> allEmailsValue = emailObject->Get(allEmailsKey); AttributeSubKind::Type subKind = AttributeSubKind::Other; QString allEmailsKeyString = titanium::V8ValueToQString(allEmailsKey).toLower(); if(allEmailsKeyString == "work") { subKind = AttributeSubKind::Work; } else if(allEmailsKeyString == "personal") { subKind = AttributeSubKind::Personal; } else if(allEmailsKeyString == "home") { subKind = AttributeSubKind::Home; } if(!allEmailsValue->IsArray()) return; Local<Array> emails = Local<Array>::Cast(allEmailsValue); for(int i = 0, len = emails->Length(); i < len; i++) { Local<Value> emailValue = emails->Get(Number::New(i)); if(emailValue->IsString() || emailValue->IsNumber()) { obj->setContactDetails(AttributeKind::Email, subKind, emailValue); } else { // Something goes here, throw an error? } } } }
static void Set_DialogState_height(Local<String> property, Local<Value> value, const AccessorInfo& info) { HandleScope scope; Local<Object> self = info.Holder(); Local<External> wrap = Local<External>::Cast(self->GetInternalField(0)); if (wrap.IsEmpty()) return; DialogState *tmp = (DialogState *) wrap->Value(); if (tmp == NULL) return; if (!value.IsEmpty() && value->IsNumber()) tmp->setHeight(value->Int32Value()); }
bool JSWrapper::execute( const char *scr, JSWrapperData *data, const char *fileName ) { HandleScope handle_scope( m_isolate ); Local<String> source = String::NewFromUtf8( m_isolate, scr, NewStringType::kNormal ).ToLocalChecked(); ScriptOrigin origin( v8::String::NewFromUtf8( m_isolate, fileName ? fileName : "Unknown" ) ); MaybeLocal<Script> maybeScript = Script::Compile( m_context, source, &origin ); bool success=false; if ( !maybeScript.IsEmpty() ) { Local<Script> script = maybeScript.ToLocalChecked(); MaybeLocal<Value> maybeResult = script->Run(m_context); if ( !maybeResult.IsEmpty() ) { Local<Value> result = maybeResult.ToLocalChecked(); if ( data ) { if ( result->IsNumber() ) data->setNumber( result->ToNumber()->Value() ); else if ( result->IsString() ) { String::Utf8Value utf8( result ); data->setString( *utf8 ); } else if ( result->IsBoolean() ) data->setBoolean( result->ToBoolean()->Value() ); else if ( result->IsObject() ) data->setObject( new JSWrapperObject( m_isolate, result->ToObject() ) ); else if ( result->IsNull() ) data->setNull(); else data->setUndefined(); } success=true; } } return success; }
static GetdnsType getGetdnsType(Local<Value> value) { if (value->IsNumber() || value->IsNumberObject()) { return IntType; } else if (value->IsBoolean() || value->IsBooleanObject()) { return BoolType; } else if (value->IsString() || value->IsStringObject()) { return StringType; } else if (value->IsObject()) { // could be a node buffer or array if (node::Buffer::HasInstance(value)) { return BinDataType; } else if (value->IsArray()) { return ListType; } else if (GNUtil::isDictionaryObject(value)) { return DictType; } } return UnknownType; }
void Color::set_prop(Local<String> property, Local<Value> value, const AccessorInfo& info) { HandleScope scope; Color* c = ObjectWrap::Unwrap<Color>(info.This()); std::string a = TOSTR(property); if (!value->IsNumber()) ThrowException(Exception::TypeError( String::New("color channel value must be an integer"))); if (a == "a") { c->get()->set_alpha(value->IntegerValue()); } else if (a == "r") { c->get()->set_red(value->IntegerValue()); } else if (a == "g") { c->get()->set_green(value->IntegerValue()); } else if (a == "b") { c->get()->set_blue(value->IntegerValue()); } }
static double getNumber(Handle<Object> obj, QString key, double minValue, double defaultValue) { double result = defaultValue; Handle<String> cdtKey = String::New(key.toUtf8()); if (obj->Has(cdtKey)) { Local<Value> v = obj->Get(cdtKey); if (v->IsNumber() == false) { throw IllegalArgumentException("Expected " + key + " to be a number."); } result = v->NumberValue(); if (result < minValue) { throw IllegalArgumentException(QString("Expected %1 to be greater than %2.") .arg(key).arg(minValue)); } } return result; }
static double getNumber(Handle<Object> obj, QString key, double minValue, double defaultValue) { Isolate* current = v8::Isolate::GetCurrent(); HandleScope handleScope(current); double result = defaultValue; Handle<String> cdtKey = String::NewFromUtf8(current, key.toUtf8()); if (obj->Has(cdtKey)) { Local<Value> v = obj->Get(cdtKey); if (v->IsNumber() == false || ::qIsNaN(v->NumberValue())) { throw IllegalArgumentException("Expected " + key + " to be a number."); } result = v->NumberValue(); if (result < minValue) { throw IllegalArgumentException(QString("Expected %1 to be greater than %2.") .arg(key).arg(minValue)); } } return result; }
void PassArray(const FunctionCallbackInfo<Value>& args) { Isolate * isolate = args.GetIsolate(); Local<Array> array = Local<Array>::Cast(args[0]); if ( args.Length() < 1 || ! args[0]->IsArray()) { return; } if (array->Length() < 3) { return; } Local<String> prop = String::NewFromUtf8(isolate, "not_index"); if (array->Get(prop)->IsUndefined() ){ return; } for (unsigned int i = 0; i < 3; i++ ) { if (array->Has(i)) { Local<Value> v = array->Get(i); if ( !v->IsNumber()) return; double value = v->NumberValue(); array->Set(i, Number::New(isolate, value + 1)); } else { return; } } Local<Array> a = Array::New(isolate); a->Set(0, array->Get(0)); a->Set(1, array->Get(prop)); a->Set(2, array->Get(2)); args.GetReturnValue().Set(a); }
Handle<Value> Session::Request(const Arguments& args) { HandleScope scope; if (args.Length() < 1 || !args[0]->IsString()) { return ThrowException(Exception::Error(String::New( "Service URI string must be provided as first parameter."))); } if (args.Length() < 2 || !args[1]->IsString()) { return ThrowException(Exception::Error(String::New( "String request name must be provided as second parameter."))); } if (args.Length() < 3 || !args[2]->IsObject()) { return ThrowException(Exception::Error(String::New( "Object containing request parameters must be provided " "as third parameter."))); } if (args.Length() < 4 || !args[3]->IsInt32()) { return ThrowException(Exception::Error(String::New( "Integer correlation identifier must be provided " "as fourth parameter."))); } if (args.Length() >= 5 && !args[4]->IsUndefined() && !args[4]->IsString()) { return ThrowException(Exception::Error(String::New( "Optional request label must be a string."))); } if (args.Length() > 5) { return ThrowException(Exception::Error(String::New( "Function expects at most five arguments."))); } int cidi = args[3]->Int32Value(); Session* session = ObjectWrap::Unwrap<Session>(args.This()); BLPAPI_EXCEPTION_TRY Local<String> uri = args[0]->ToString(); String::AsciiValue uriv(uri); blpapi::Service service = session->d_session->getService(*uriv); Local<String> name = args[1]->ToString(); String::Utf8Value namev(name); blpapi::Request request = service.createRequest(*namev); // Loop over object properties, appending/setting into the request. Local<Object> obj = args[2]->ToObject(); Local<Array> props = obj->GetPropertyNames(); for (std::size_t i = 0; i < props->Length(); ++i) { // Process the key. Local<Value> keyval = props->Get(i); Local<String> key = keyval->ToString(); String::Utf8Value keyv(key); // Process the value. // // The values present on the outer object are marshalled into the // blpapi::Request by setting values using 'set'. Arrays indicate // values which should be marshalled using 'append'. Local<Value> val = obj->Get(keyval); if (val->IsString()) { Local<String> s = val->ToString(); String::Utf8Value valv(s); request.set(*keyv, *valv); } else if (val->IsBoolean()) { request.set(*keyv, val->BooleanValue()); } else if (val->IsNumber()) { request.set(*keyv, val->NumberValue()); } else if (val->IsInt32()) { request.set(*keyv, val->Int32Value()); } else if (val->IsUint32()) { request.set(*keyv, static_cast<blpapi::Int64>(val->Uint32Value())); } else if (val->IsDate()) { blpapi::Datetime dt; mkdatetime(&dt, val); request.set(*keyv, dt); } else if (val->IsArray()) { // Arrays are marshalled into the blpapi::Request by appending // value types using the key of the array in the outer object. Local<Object> subarray = val->ToObject(); int jmax = Array::Cast(*val)->Length(); for (int j = 0; j < jmax; ++j) { Local<Value> subval = subarray->Get(j); // Only strings, booleans, and numbers are marshalled. if (subval->IsString()) { Local<String> s = subval->ToString(); String::Utf8Value subvalv(s); request.append(*keyv, *subvalv); } else if (subval->IsBoolean()) { request.append(*keyv, subval->BooleanValue()); } else if (subval->IsNumber()) { request.append(*keyv, subval->NumberValue()); } else if (subval->IsInt32()) { request.append(*keyv, subval->Int32Value()); } else if (subval->IsUint32()) { request.append(*keyv, static_cast<blpapi::Int64>(subval->Uint32Value())); } else if (subval->IsDate()) { blpapi::Datetime dt; mkdatetime(&dt, subval); request.append(*keyv, dt); } else { return ThrowException(Exception::Error(String::New( "Array contains invalid value type."))); } } } else { return ThrowException(Exception::Error(String::New( "Object contains invalid value type."))); } } blpapi::CorrelationId cid(cidi); if (args.Length() == 5) { String::Utf8Value labelv(args[4]->ToString()); session->d_session->sendRequest(request, session->d_identity, cid, 0, *labelv, labelv.length()); } else { session->d_session->sendRequest(request, session->d_identity, cid); } BLPAPI_EXCEPTION_CATCH_RETURN return scope.Close(Integer::New(cidi)); }
static bool check_number(Local<Value> obj) { return obj->IsNumber(); }
bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index) { bool success = false; stringstream s; JEnv env; Type returnType = JType::getClassType(m_return_type); if (arg.IsEmpty()) { s << "Cannot convert empty JavaScript object"; success = false; } else if (arg->IsInt32() && (returnType == Type::Int || returnType == Type::Null)) { jint value = arg->Int32Value(); JniLocalRef javaObject(JType::NewInt(env, value)); SetConvertedObject(env, index, javaObject); success = true; } else if (arg->IsNumber() || arg->IsNumberObject()) { double d = arg->NumberValue(); int64_t i = (int64_t)d; bool isInteger = d == i; if (isInteger) { jobject obj; //if returnType is long it will cast to long //if there is no return type specified it will cast to int //because default return type is null (ref type) if ((INT_MIN <= i) && (i <= INT_MAX) && (returnType == Type::Int || returnType == Type::Null)) { obj = JType::NewInt(env, (jint)d); } else /*isLong*/ { obj = JType::NewLong(env, (jlong)d); } JniLocalRef javaObject(obj); SetConvertedObject(env, index, javaObject); success = true; } else { jobject obj; //if returnType is double it will cast to double //if there is no return type specified it will cast to float //because default return type is null (ref type) if((FLT_MIN <= d) && (d <= FLT_MAX) && (returnType == Type::Float || returnType == Type::Null)) { obj = JType::NewFloat(env, (jfloat)d); } else {/*isDouble*/ obj = JType::NewDouble(env, (jdouble)d); } JniLocalRef javaObject(obj); SetConvertedObject(env, index, javaObject); success = true; } } else if (arg->IsBoolean()) { jboolean value = arg->BooleanValue(); JniLocalRef javaObject(JType::NewBoolean(env, value)); SetConvertedObject(env, index, javaObject); success = true; } else if (arg->IsBooleanObject()) { auto boolObj = Local<BooleanObject>::Cast(arg); jboolean value = boolObj->BooleanValue() ? JNI_TRUE : JNI_FALSE; JniLocalRef javaObject(JType::NewBoolean(env, value)); SetConvertedObject(env, index, javaObject); success = true; } else if (arg->IsString() || arg->IsStringObject()) { JniLocalRef stringObject(ConvertToJavaString(arg)); SetConvertedObject(env, index, stringObject); success = true; } else if (arg->IsObject()) { auto objectWithHiddenID = arg->ToObject(); auto hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsLong()); if (!hidden.IsEmpty()) { jlong value = 0; if (hidden->IsString()) { auto strValue = ConvertToString(hidden->ToString()); value = atoll(strValue.c_str()); } else if (hidden->IsInt32()) { value = hidden->ToInt32()->Int32Value(); } JniLocalRef javaObject(JType::NewLong(env, value)); SetConvertedObject(env, index, javaObject); return true; } hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsByte()); if (!hidden.IsEmpty()) { jbyte value = 0; if (hidden->IsString()) { string value = ConvertToString(hidden->ToString()); int byteArg = atoi(value.c_str()); value = (jbyte)byteArg; } else if (hidden->IsInt32()) { int byteArg = hidden->ToInt32()->Int32Value(); value = (jbyte)byteArg; } JniLocalRef javaObject(JType::NewByte(env, value)); SetConvertedObject(env, index, javaObject); return true; } hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsShort()); if (!hidden.IsEmpty()) { jshort value = 0; if (hidden->IsString()) { string value = ConvertToString(hidden->ToString()); int shortArg = atoi(value.c_str()); value = (jshort)shortArg; } else if (hidden->IsInt32()) { jlong shortArg = hidden->ToInt32()->Int32Value(); value = (jshort)shortArg; } JniLocalRef javaObject(JType::NewShort(env, value)); SetConvertedObject(env, index, javaObject); return true; } hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsDouble()); if (!hidden.IsEmpty()) { jdouble value = 0; if (hidden->IsNumber()) { double doubleArg = hidden->ToNumber()->NumberValue(); value = (jdouble)doubleArg; } JniLocalRef javaObject(JType::NewDouble(env, value)); SetConvertedObject(env, index, javaObject); return true; } hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsFloat()); if (!hidden.IsEmpty()) { jfloat value = 0; if (hidden->IsNumber()) { double floatArg = hidden->ToNumber()->NumberValue(); value = (jfloat)floatArg; } JniLocalRef javaObject(JType::NewFloat(env, value)); SetConvertedObject(env, index, javaObject); return true; } hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsChar()); if (!hidden.IsEmpty()) { jchar value = '\0'; if (hidden->IsString()) { string str = ConvertToString(hidden->ToString()); value = (jchar)str[0]; } JniLocalRef javaObject(JType::NewChar(env, value)); SetConvertedObject(env, index, javaObject); return true; } jweak obj = ObjectManager::GetJavaObjectByJsObjectStatic(objectWithHiddenID); success = obj != nullptr; if (success) { SetConvertedObject(env, index, obj, true); } else { s << "Cannot convert JavaScript object with id " << objectWithHiddenID->GetIdentityHash() << " at index " << index; } } else if (arg->IsUndefined() || arg->IsNull()) { SetConvertedObject(env, index, nullptr); success = true; } else { s << "Cannot convert JavaScript object at index " << index; success = false; } if (!success) { m_error.index = index; m_error.msg = s.str(); } return success; }
mapnik::feature_ptr next() { HandleScope scope; TryCatch try_catch; Local<Value> argv[2] = { Integer::New(feature_id_), obj_ }; Local<Value> val = ds_->cb_->Call(Context::GetCurrent()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } else { if (!val->IsUndefined()) { if (val->IsObject()) { Local<Object> obj = val->ToObject(); if (obj->Has(String::New("x")) && obj->Has(String::New("y"))) { Local<Value> x = obj->Get(String::New("x")); Local<Value> y = obj->Get(String::New("y")); if (!x->IsUndefined() && x->IsNumber() && !y->IsUndefined() && y->IsNumber()) { mapnik::geometry_type * pt = new mapnik::geometry_type(mapnik::Point); pt->move_to(x->NumberValue(),y->NumberValue()); mapnik::feature_ptr feature(mapnik::feature_factory::create(feature_id_)); ++feature_id_; feature->add_geometry(pt); if (obj->Has(String::New("properties"))) { Local<Value> props = obj->Get(String::New("properties")); if (props->IsObject()) { Local<Object> p_obj = props->ToObject(); Local<Array> names = p_obj->GetPropertyNames(); uint32_t i = 0; uint32_t a_length = names->Length(); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); // if name in q.property_names() ? Local<Value> value = p_obj->Get(name); if (value->IsString()) { UnicodeString ustr = tr_->transcode(TOSTR(value)); boost::put(*feature,TOSTR(name),ustr); } else if (value->IsNumber()) { double num = value->NumberValue(); // todo - round if (num == value->IntegerValue()) { int integer = value->IntegerValue(); boost::put(*feature,TOSTR(name),integer); } else { double dub_val = value->NumberValue(); boost::put(*feature,TOSTR(name),dub_val); } } i++; } } } return feature; } } } } } return mapnik::feature_ptr(); }