JsSprite::JsSprite(Isolate * isolate, Local<Object> handle) : ObjectWrap(handle), _texture(nullptr), _sprite() { assert(handle->InternalFieldCount() > 1); handle->SetInternalField(0, External::New(isolate, &_sprite)); handle->SetInternalField(1, External::New(isolate, this)); }
v8::Local<v8::Object> JSZAttribute::createInstance(v8::Isolate *isolate, std::shared_ptr<ZCLAttribute> &zclAttribute) { if (zclAttribute->getZCLType() != getZCLType()) { throw JSExceptionInvalidAttributeType(getName(), zclAttribute->getZCLType(), getZCLType()); } Local<ObjectTemplate> zAttributeT = Local<FunctionTemplate>::New(isolate, functionTemplate)->InstanceTemplate(); Local<Object> zAttributeInstance = zAttributeT->NewInstance(); zAttributeInstance->SetInternalField(0, External::New(isolate, zclAttribute.get())); zAttributeInstance->SetInternalField(1, External::New(isolate, this)); return zAttributeInstance; }
Local<Object> ItemObject::createInstance() { HandleScope handleScope; // Create the function template Local<FunctionTemplate> functionTemplate = FunctionTemplate::New(); functionTemplate->SetClassName(String::New("Item")); // Create the object template Local<ObjectTemplate> objectTemplate = functionTemplate->InstanceTemplate(); objectTemplate->SetInternalFieldCount(1); // Create an object instance Local<Object> objectInstance = objectTemplate->NewInstance(); objectInstance->SetInternalField(0, External::New(this)); // Add functions to object instance /* Local<FunctionTemplate> printTemplate = FunctionTemplate::New(print); Local<Function> printFunction = printTemplate->GetFunction(); objectInstance->Set(String::New("print"), printFunction); Local<FunctionTemplate> inputTemplate = FunctionTemplate::New(input); Local<Function> inputFunction = inputTemplate->GetFunction(); objectInstance->Set(String::New("input"), inputFunction); */ return handleScope.Close(objectInstance); }
void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jclass clazz) { auto isolate = Isolate::GetCurrent(); DEBUG_WRITE("Linking js object: %d and java instance id: %d", object->GetIdentityHash(), javaObjectID); JEnv env; auto jsInstanceInfo = new JSInstanceInfo(); jsInstanceInfo->JavaObjectID = javaObjectID; jsInstanceInfo->clazz = clazz; auto objectHandle = new Persistent<Object>(isolate, object); auto state = new ObjectWeakCallbackState(this, jsInstanceInfo, objectHandle); objectHandle->SetWeak(state, JSObjectWeakCallbackStatic); auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo); bool alreadyLinked = !object->GetInternalField(jsInfoIdx)->IsUndefined(); //ASSERT_MESSAGE(alreadyLinked, "object should not have been linked before"); auto jsInfo = External::New(isolate, jsInstanceInfo); object->SetInternalField(jsInfoIdx, jsInfo); idToObject.insert(make_pair(javaObjectID, objectHandle)); }
Image *Image::New(FIBITMAP* dib) { HandleScope scope; Local<Value> arg = Integer::NewFromUnsigned(0); Local<Object> obj = constructor_template->GetFunction()->NewInstance(1, &arg); Image *image = ObjectWrap::Unwrap<Image>(obj); image->dib = dib; int w,h,pitch; FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib); obj->SetInternalField(0, External::New(dib)); obj->Set(JS_STR("width"), JS_INT(w=FreeImage_GetWidth(dib))); obj->Set(JS_STR("height"), JS_INT(h=FreeImage_GetHeight(dib))); obj->Set(JS_STR("bpp"), JS_INT((int)FreeImage_GetBPP(dib))); obj->Set(JS_STR("pitch"), JS_INT(pitch=FreeImage_GetPitch(dib))); obj->Set(JS_STR("type"), JS_INT(type)); obj->Set(JS_STR("redMask"), JS_INT((int)FreeImage_GetRedMask(dib))); obj->Set(JS_STR("greenMask"), JS_INT((int)FreeImage_GetGreenMask(dib))); obj->Set(JS_STR("blueMask"), JS_INT((int)FreeImage_GetBlueMask(dib))); BYTE *bits=FreeImage_GetBits(dib); node::Buffer *buf = node::Buffer::New((char*)bits,h*pitch); obj->Set(JS_STR("buffer"), buf->handle_); return image; }
/** * Utility function that wraps a C++ http request object in a * JavaScript object. */ Local<Object> JsHttpRequestProcessor::WrapRequest(HttpRequest* request) { // Local scope for temporary handles. EscapableHandleScope handle_scope(GetIsolate()); // Fetch the template for creating JavaScript http request wrappers. // It only has to be created once, which we do on demand. if (request_template_.IsEmpty()) { Local<ObjectTemplate> raw_template = MakeRequestTemplate(GetIsolate()); request_template_.Reset(GetIsolate(), raw_template); } Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(GetIsolate(), request_template_); // Create an empty http request wrapper. Local<Object> result = templ->NewInstance(GetIsolate()->GetCurrentContext()).ToLocalChecked(); // Wrap the raw C++ pointer in an External so it can be referenced // from within JavaScript. Local<External> request_ptr = External::New(GetIsolate(), request); // Store the request pointer in the JavaScript wrapper. result->SetInternalField(0, request_ptr); // Return the result through the current handle scope. Since each // of these handles will go away when the handle scope is deleted // we need to call Close to let one, the result, escape into the // outer handle scope. return handle_scope.Escape(result); }
void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jclass clazz) { int internalFieldCound = NativeScriptExtension::GetInternalFieldCount(object); const int count = static_cast<int>(MetadataNodeKeys::END); if (internalFieldCound != count) { string errMsg("Trying to link invalid 'this' to a Java object"); throw NativeScriptException(errMsg); } auto isolate = Isolate::GetCurrent(); DEBUG_WRITE("Linking js object: %d and java instance id: %d", object->GetIdentityHash(), javaObjectID); auto jsInstanceInfo = new JSInstanceInfo(); jsInstanceInfo->JavaObjectID = javaObjectID; jsInstanceInfo->clazz = clazz; auto objectHandle = new Persistent<Object>(isolate, object); auto state = new ObjectWeakCallbackState(this, jsInstanceInfo, objectHandle); objectHandle->SetWeak(state, JSObjectWeakCallbackStatic); auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo); bool alreadyLinked = !object->GetInternalField(jsInfoIdx)->IsUndefined(); //TODO: fail if alreadyLinked is true? auto jsInfo = External::New(isolate, jsInstanceInfo); object->SetInternalField(jsInfoIdx, jsInfo); idToObject.insert(make_pair(javaObjectID, objectHandle)); }
Handle<Value> BGJSView::startJS(const char* fnName, const char* configJson, Handle<Value> uiObj, long configId) { HandleScope scope; Handle<Value> config; if (configJson) { config = String::New(configJson); } else { config = v8::Undefined(); } // bgjsgl->Set(String::New("log"), FunctionTemplate::New(BGJSGLModule::log)); Local<Object> objInstance = this->jsViewOT->NewInstance(); objInstance->SetInternalField(0, External::New(this)); // Local<Object> instance = bgjsglft->GetFunction()->NewInstance(); this->_jsObj = Persistent<Object>::New(objInstance); Handle<Value> argv[4] = { uiObj, this->_jsObj, config, Number::New(configId) }; Handle<Value> res = this->_jsContext->callFunction(_jsContext->_context->Global(), fnName, 4, argv); if (res->IsNumber()) { _contentObj = res->ToNumber()->Value(); #ifdef DEBUG LOGD ("startJS return id %d", _contentObj); #endif } else { LOGI ("Did not receive a return id from startJS"); } return scope.Close(res); }
// Wraps 'this' in a Javascript object. Handle<Object> JsContext::wrap() { // Handle scope for temporary handles. EscapableHandleScope handleScope(fGlobal->getIsolate()); // Fetch the template for creating JavaScript JsContext wrappers. // It only has to be created once, which we do on demand. if (gContextTemplate.IsEmpty()) { Local<ObjectTemplate> localTemplate = ObjectTemplate::New(); // Add a field to store the pointer to a JsContext instance. localTemplate->SetInternalFieldCount(1); this->addAttributesAndMethods(localTemplate); gContextTemplate.Reset(fGlobal->getIsolate(), localTemplate); } Handle<ObjectTemplate> templ = Local<ObjectTemplate>::New(fGlobal->getIsolate(), gContextTemplate); // Create an empty JsContext wrapper. Local<Object> result = templ->NewInstance(); // Wrap the raw C++ pointer in an External so it can be referenced // from within JavaScript. Handle<External> contextPtr = External::New(fGlobal->getIsolate(), this); // Store the context pointer in the JavaScript wrapper. result->SetInternalField(0, contextPtr); // Return the result through the current handle scope. Since each // of these handles will go away when the handle scope is deleted // we need to call Close to let one, the result, escape into the // outer handle scope. return handleScope.Escape(result); }
Image *Image::New(FIBITMAP* dib) { NanScope(); Local<Value> arg = NanNew<Integer>(0); Local<Object> obj = NanNew<FunctionTemplate>(constructor_template)->GetFunction()->NewInstance(1, &arg); Image *image = ObjectWrap::Unwrap<Image>(obj); int w,h,pitch; FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib); obj->SetInternalField(0, NanNew<External>(dib)); obj->Set(NanNew<String>("width"), NanNew<Integer>(w=FreeImage_GetWidth(dib))); obj->Set(NanNew<String>("height"), NanNew<Integer>(h=FreeImage_GetHeight(dib))); obj->Set(NanNew<String>("bpp"), NanNew<Integer>((int)FreeImage_GetBPP(dib))); obj->Set(NanNew<String>("pitch"), NanNew<Integer>(pitch=FreeImage_GetPitch(dib))); obj->Set(NanNew<String>("type"), NanNew<Integer>(type)); obj->Set(NanNew<String>("redMask"), NanNew<Integer>((int)FreeImage_GetRedMask(dib))); obj->Set(NanNew<String>("greenMask"), NanNew<Integer>((int)FreeImage_GetGreenMask(dib))); obj->Set(NanNew<String>("blueMask"), NanNew<Integer>((int)FreeImage_GetBlueMask(dib))); BYTE *bits = FreeImage_GetBits(dib); obj->Set(NanNew<String>("buffer"), NanNewBufferHandle((char*) bits, h * pitch)); return image; }
// Defines a Point() JS Object void PointConstructor( const FunctionCallbackInfo<v8::Value>& args ) { //Locker lock; HandleScope scope; Handle<ObjectTemplate> t = v8::ObjectTemplate::New(); //The JavaScript point object only has 1 C++ object t->SetInternalFieldCount(1); // Create x and y members with starting values of 0 //t->Set(String::New("x"), Number::New(0)); t->SetAccessor(String::New("x"), (AccessorGetterCallback)GetPointX, (AccessorSetterCallback)SetPointX); //t->Set(String::New("y"), Number::New(0)); t->SetAccessor(String::New("y"), (AccessorGetterCallback)GetPointY, (AccessorSetterCallback)SetPointY); // Create a mul(number) function that scales the point t->Set(String::New("mul"), FunctionTemplate::New(MulCallback)); // for use in the if statement Point *p = NULL; Local<Object> obj; // If Point(x, y) ctor was passed in values assign them if(!args[0].IsEmpty() && args[0]->IsNumber() && !args[1].IsEmpty() && args[1]->IsNumber()) { //t->Set(String::New("x"), args[0]); //t->Set(String::New("y"), args[1]); p = new Point(args[0]->Int32Value(), args[1]->Int32Value()); obj = t->NewInstance(); obj->SetInternalField(0, External::New(p)); } else { /** * Wrap a point object */ p = new Point(0, 0); obj = t->NewInstance(); obj->SetInternalField(0, External::New(p)); } // Return this newly created object args.GetReturnValue().Set(obj); }
v8::Local<v8::Object> JSZCluster::createInstance(v8::Isolate *isolate, const ExtAddress &extAddress, EndpointID endpointId, ClusterID clusterId) { if (!zDevices->exists(extAddress)) { throw JSExceptionNoDevice(extAddress); } auto zDevice = zDevices->getDevice(extAddress); NwkAddr nwkAddress = zDevice->getNwkAddr(); Key key(nwkAddress, endpointId, clusterId); if (usedCluster.count(key) > 0) { return Local<Object>::New(isolate, usedCluster[key].get<0>()); } if (!zDevice->isEndpointPresents(endpointId)) { throw JSExceptionNoEndpoint(extAddress, endpointId); } ZEndpoint zEndpoint = zDevice->getEndpoint(endpointId); if (!zEndpoint.hasInCluster(clusterId)) { throw JSExceptionNoInCluster(extAddress, endpointId, clusterId); } Local<ObjectTemplate> zClusterTemplate = Local<FunctionTemplate>::New(isolate, functionTemplate)->InstanceTemplate(); Local<Object> zClusterInstance = zClusterTemplate->NewInstance(); zClusterInstance->SetInternalField(0, External::New(isolate, this)); std::shared_ptr<Cluster> cluster = clusterFactory->getCluster(clusterId, zigbeeDevice, endpointId, zDevice->getNwkAddr()); zClusterInstance->SetInternalField(1, External::New(isolate, cluster.get())); std::shared_ptr<ExtAddress> usedAddr = getPersistenceExtAddress(extAddress); zClusterInstance->SetInternalField(2, External::New(isolate, usedAddr.get())); Value value{}; value.get<0>().Reset(isolate, zClusterInstance); boost::get<1>(value) = cluster; usedCluster.insert({key, value}); return zClusterInstance; }
void makeLine(const v8::FunctionCallbackInfo<v8::Value>& args) { if(args.Length() != 4) { args.GetReturnValue().Set(Boolean::New(Isolate::GetCurrent(), false)); return; } Local<External> shapeManagerExternal = Local<External>::Cast(args.Callee()->Get(String::NewFromUtf8(Isolate::GetCurrent(), shapeManagerStr.c_str()))); ShapeManager2d* shapeManager = static_cast<ShapeManager2d*>(shapeManagerExternal->Value()); Point2d p1{args[0]->NumberValue(), args[1]->NumberValue()}; Point2d p2{args[2]->NumberValue(), args[3]->NumberValue()}; Local<Object> obj = initShape()->NewInstance(); unsigned int shape = shapeManager->makeLine(p1, p2); obj->SetInternalField(0, shapeManagerExternal); obj->SetInternalField(1, Integer::NewFromUnsigned(Isolate::GetCurrent(), shape)); args.GetReturnValue().Set(obj); }
bool ObjectManager::CloneLink(const Local<Object>& src, const Local<Object>& dest) { auto jsInfo = GetJSInstanceInfo(src); auto success = jsInfo != nullptr; if (success) { auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo); auto jsInfo = src->GetInternalField(jsInfoIdx); dest->SetInternalField(jsInfoIdx, jsInfo); } return success; }
void CanvasRenderingContext2D::Create(const v8::FunctionCallbackInfo<v8::Value>& args) { auto isolate = args.GetIsolate(); HandleScope scope(isolate); Local<ObjectTemplate> contextTemplate = ObjectTemplate::New(isolate); contextTemplate->SetInternalFieldCount(1); contextTemplate->Set(ConvertToV8String("__draw"), FunctionTemplate::New(isolate, &Draw)); contextTemplate->Set(ConvertToV8String("__sizeChanged"), FunctionTemplate::New(isolate, &SizeChanged)); contextTemplate->SetAccessor(ConvertToV8String("fillStyle"), &GetFillStyle, &SetFillStyle); contextTemplate->SetAccessor(ConvertToV8String("strokeStyle"), &GetStrokeStyle, &SetStrokeStyle); contextTemplate->Set(ConvertToV8String("arc"), FunctionTemplate::New(isolate, &Arc)); contextTemplate->Set(ConvertToV8String("beginPath"), FunctionTemplate::New(isolate, &BeginPath)); contextTemplate->Set(ConvertToV8String("bezierCurveTo"), FunctionTemplate::New(isolate, &BezierCurveTo)); contextTemplate->Set(ConvertToV8String("clearRect"), FunctionTemplate::New(isolate, &ClearRect)); contextTemplate->Set(ConvertToV8String("closePath"), FunctionTemplate::New(isolate, &ClosePath)); contextTemplate->Set(ConvertToV8String("drawImage"), FunctionTemplate::New(isolate, &DrawImage)); contextTemplate->Set(ConvertToV8String("fill"), FunctionTemplate::New(isolate, &Fill)); contextTemplate->Set(ConvertToV8String("fillRect"), FunctionTemplate::New(isolate, &FillRect)); contextTemplate->Set(ConvertToV8String("fillText"), FunctionTemplate::New(isolate, &FillText)); contextTemplate->Set(ConvertToV8String("getImageData"), FunctionTemplate::New(isolate, &GetImageData)); contextTemplate->Set(ConvertToV8String("lineTo"), FunctionTemplate::New(isolate, &LineTo)); contextTemplate->Set(ConvertToV8String("measureText"), FunctionTemplate::New(isolate, &MeasureText)); contextTemplate->Set(ConvertToV8String("moveTo"), FunctionTemplate::New(isolate, &MoveTo)); contextTemplate->Set(ConvertToV8String("quadraticCurveTo"), FunctionTemplate::New(isolate, &QuadraticCurveTo)); contextTemplate->Set(ConvertToV8String("restore"), FunctionTemplate::New(isolate, &Restore)); contextTemplate->Set(ConvertToV8String("rotate"), FunctionTemplate::New(isolate, &Rotate)); contextTemplate->Set(ConvertToV8String("save"), FunctionTemplate::New(isolate, &Save)); contextTemplate->Set(ConvertToV8String("stroke"), FunctionTemplate::New(isolate, &Stroke)); contextTemplate->Set(ConvertToV8String("translate"), FunctionTemplate::New(isolate, &Translate)); Local<Object> newContext = contextTemplate->NewInstance(); newContext->ForceSet(ConvertToV8String("canvas"), args[0]); newContext->ForceSet(ConvertToV8String("__kind"), ConvertToV8String("2d")); auto nativeContext = new CanvasRenderingContext2D(); newContext->SetInternalField(0, External::New(isolate, nativeContext)); Persistent<Object> persistentHandle(isolate, newContext); persistentHandle.SetWeak(nativeContext, &Deallocate); args.GetReturnValue().Set(newContext); }
Local<Object> MetadataNode::CreateExtendedJSWrapper(Isolate *isolate, const string& proxyClassName) { Local<Object> extInstance; auto cacheData = GetCachedExtendedClassData(isolate, proxyClassName); if (cacheData.node != nullptr) { extInstance = s_objectManager->GetEmptyObject(isolate); extInstance->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate)); auto extdCtorFunc = Local<Function>::New(isolate, *cacheData.extendedCtorFunction); extInstance->SetPrototype(extdCtorFunc->Get(ConvertToV8String("prototype"))); SetInstanceMetadata(isolate, extInstance, cacheData.node); } return extInstance; }
Handle<Value> ItemObject::constructor(const Arguments &args) { HandleScope handleScope; // Make sure the constructor is called with the new keyword if (!args.IsConstructCall()) { Local<String> message = String::New("Cannot call constructor as a function"); return ThrowException(Exception::SyntaxError(message)); } // Instantiate a new ScriptTemplate ItemObject *itemObject = new ItemObject(); Local<Object> itemInstance = itemObject->createInstance(); itemInstance->SetInternalField(0, External::New(itemObject)); return handleScope.Close(itemInstance); }
Handle<Object> SUIPictureBox::GetV8Obj() { Isolate* isolate = SPV8ScriptEngine::GetSingleton()->GetIsolate(); if (!v8Obj) { Local<Object> obj = Handle<Object>(); Handle<ObjectTemplate> handleTempl = SV8ScriptManager::GetSingleton()->GetPictureBoxTemplate(); obj = handleTempl->NewInstance(); if(!obj.IsEmpty()) { obj->SetInternalField(0, External::New(this)); v8Obj = new Persistent<Object>(isolate, obj); } } return Handle<Object>::New(isolate, *v8Obj); }
Local<Object> NaObject::WrapObject(Isolate *isolate, NaObject * pObject) { // Local scope for temporary handles. EscapableHandleScope handle_scope(isolate); // Fetch the template for creating JavaScript map wrappers. // It only has to be created once, which we do on demand. Global<ObjectTemplate> &_ObjectTemplate = pObject->GetObjectTemplate(); if (_ObjectTemplate.IsEmpty()) { Local<ObjectTemplate> RawTemplate = pObject->MakeObjectTemplate(isolate); _ObjectTemplate.Reset(isolate, RawTemplate); } Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, _ObjectTemplate); // Create an empty NaObject wrapper. Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked(); // Wrap the raw C++ pointer in an External so it can be referenced from within JavaScript. Local<External> obj_ptr = External::New(isolate, pObject); // Store the NaObject pointer in the JavaScript wrapper. result->SetInternalField(0, obj_ptr); pObject->AddRef(); // Make weak Local<Object> handle = v8::Local<v8::Object>::New(isolate, pObject->m_Persistent); pObject->m_Persistent.Reset(isolate, result); pObject->MakeWeak(); // Return the result through the current handle scope. Since each // of these handles will go away when the handle scope is deleted // we need to call Close to let one, the result, escape into the // outer handle scope. return handle_scope.Escape(result); }
void Server::Init(){ JS_SCOPE(_isolate) JS_CONTEXT(_isolate,_context) Local<ObjectTemplate> sampjs_templ = ObjectTemplate::New(_isolate); sampjs_templ->SetInternalFieldCount(1); Local<Object> sampjs = sampjs_templ->NewInstance(); sampjs->SetInternalField(0, External::New(_isolate, this)); SetGlobalObject("$sampjs", sampjs); Local<ObjectTemplate> module_templ = ObjectTemplate::New(_isolate); Local<ObjectTemplate> cache_templ = ObjectTemplate::New(_isolate); module_templ->Set(String::NewFromUtf8(_isolate, "_cache"), cache_templ->NewInstance()); Local<Object> module = module_templ->NewInstance(); SetGlobalFunction("memory", Server::JS_GetMemory); SetGlobalFunction("require", Server::Require); SetGlobalFunction("include", Server::Include); SetGlobalFunction("CallNative", Server::CallNative); SetGlobalFunction("SetTimer", Server::SetTimer); SetGlobalFunction("CancelTimer", Server::CancelTimer); SetGlobalFunction("load", Server::JS_LoadScript); SetGlobalFunction("unload", Server::JS_UnloadScript); SetGlobalFunction("reload", Server::JS_ReloadScript); SetGlobalObject("$modules", module); _eventManager = make_shared<Events>(shared_from_this()); }
v8::Handle<v8::Object> WrapElementDocument(v8::Handle<v8::Context> context, Rocket::Core::ElementDocument* v) { v8::HandleScope handle_scope; Handle<FunctionTemplate> templt = GetScriptSystem()->GetTemplateBySID(s_elementDocumentWrapper); if(templt.IsEmpty()) { templt = FunctionTemplate::New(); templt->Inherit(GetElementTemplate()); templt->SetClassName(String::New("ElementDocument")); templt->InstanceTemplate()->SetInternalFieldCount(1); templt->InstanceTemplate()->SetNamedPropertyHandler( ELNamedPropertyGetter, ELNamedPropertySetter, ELNamedPropertyQuery, ELNamedPropertyDeleter, ELNamedPropertyEnumerator ); Handle<ObjectTemplate> proto = templt->PrototypeTemplate(); proto->Set("hide", FunctionTemplate::New(EDHide)); proto->Set("toString", FunctionTemplate::New(EDToString)); proto->Set("show", FunctionTemplate::New(EDShow)); proto->Set("hide", FunctionTemplate::New(EDHide)); proto->Set("close", FunctionTemplate::New(EDClose)); GetScriptSystem()->SetTemplateBySID(s_elementDocumentWrapper, templt); } Local<Object> instance = templt->GetFunction()->NewInstance(); instance->SetInternalField(0, External::New(v)); return handle_scope.Close(instance); }
Local<Object> AudioObject::createInstance() { HandleScope handleScope; Local<FunctionTemplate> functionTemplate = createClass("Audio"); Local<ObjectTemplate> prototypeTemplate = functionTemplate->PrototypeTemplate(); // Create the methods addPrototypeMethod(prototypeTemplate, playMusic, "playMusic"); addPrototypeMethod(prototypeTemplate, stopMusic, "stopMusic"); // Create the object template Local<ObjectTemplate> objectTemplate = functionTemplate->InstanceTemplate(); objectTemplate->SetInternalFieldCount(1); // Create an object instance Local<Object> objectInstance = objectTemplate->NewInstance(); objectInstance->SetInternalField(0, External::New(this)); return handleScope.Close(objectInstance); }
static Handle<ObjectTemplate> initShape() { HandleScope handleScope(Isolate::GetCurrent()); auto getColor = [](Local<String> property, const v8::PropertyCallbackInfo<v8::Value>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; Local<Object> obj = initColor()->NewInstance(); obj->SetInternalField(0, External::New(Isolate::GetCurrent(), static_cast<void*>(&shape.color()))); info.GetReturnValue().Set(obj); }; auto setColor = [](Local<String> property, Local<Value> value, const v8::PropertyCallbackInfo<void>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); Local<External> colorWrap = Local<External>::Cast(value); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; Color* newColor = static_cast<Color*>(colorWrap->Value()); shape.setColor(*newColor); }; auto getOffset = [](Local<String> property, const v8::PropertyCallbackInfo<v8::Value>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; Local<Object> obj = initPoint()->NewInstance(); obj->SetInternalField(0, External::New(Isolate::GetCurrent(), static_cast<void*>(&shape.offset()))); info.GetReturnValue().Set(obj); }; auto setOffset = [](Local<String> property, Local<Value> value, const v8::PropertyCallbackInfo<void>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); Local<External> pointWrap = Local<External>::Cast(value); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; Point2d* newOffset = static_cast<Point2d*>(pointWrap->Value()); shape.setOffset(*newOffset); }; auto getRotation = [](Local<String> property, const v8::PropertyCallbackInfo<v8::Value>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; info.GetReturnValue().Set(Number::New(Isolate::GetCurrent(), shape.rotation())); }; auto setRotation = [](Local<String> property, Local<Value> value, const v8::PropertyCallbackInfo<void>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; shape.setRotation(value->NumberValue()); }; auto getPoint = [](unsigned int index, const v8::PropertyCallbackInfo<v8::Value>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; Local<Object> obj = initPoint()->NewInstance(); obj->SetInternalField(0, External::New(Isolate::GetCurrent(), static_cast<void*>(&shape[index]))); info.GetReturnValue().Set(obj); }; auto setPoint = [](unsigned int index, Local<Value > value, const v8::PropertyCallbackInfo<v8::Value>& info) { Local<Object> self = info.Holder(); Local<External> managerWrap = Local<External>::Cast(self->GetInternalField(0)); Local<Integer> shapeWrap = Local<Integer>::Cast(self->GetInternalField(1)); Local<External> pointWrap = Local<External>::Cast(value); ShapeManager2d* manager = static_cast<ShapeManager2d*>(managerWrap->Value()); Shape2d& shape = (*manager)[shapeWrap->Value()]; Point2d* newOffset = static_cast<Point2d*>(pointWrap->Value()); shape.setPoint(index, *newOffset); //Returns to indicate that the access was intercepted. //info.GetReturnValue() = value; }; //Workaround (i think) Handle<FunctionTemplate> func_tmpl = FunctionTemplate::New(Isolate::GetCurrent()); Handle<ObjectTemplate> shape_tmpl = func_tmpl->InstanceTemplate(); shape_tmpl->SetAccessor(String::NewFromUtf8(Isolate::GetCurrent(), "color"), getColor, setColor); shape_tmpl->SetAccessor(String::NewFromUtf8(Isolate::GetCurrent(), "offset"), getOffset, setOffset); shape_tmpl->SetAccessor(String::NewFromUtf8(Isolate::GetCurrent(), "rotation"), getRotation, setRotation); shape_tmpl->SetIndexedPropertyHandler(getPoint, setPoint); shape_tmpl->SetInternalFieldCount(2); //Local<Object> o = shape_tmpl->NewInstance(); //std::cout << o->InternalFieldCount() << std::endl; return shape_tmpl; }
void CanvasContextV8Bindings::loadScript(const std::string& _filename, OgreCanvas::CanvasContext* _canvasContext, OgreCanvas::CanvasLogger* _console) { CanvasContextV8Bindings::context2D = _canvasContext; HandleScope handle_scope; //Console : //template Handle<FunctionTemplate> consoleTemplate = FunctionTemplate::New(); consoleTemplate->SetClassName(v8::String::New("Console")); CanvasContextV8Bindings::consoleTemplate = Persistent<FunctionTemplate>::New(consoleTemplate); //prototype Handle<ObjectTemplate> consolePrototype = consoleTemplate->PrototypeTemplate(); //attaching method consolePrototype->Set("log", FunctionTemplate::New(log)); //creating instance Handle<ObjectTemplate> consoleInstance = consoleTemplate->InstanceTemplate(); consoleInstance->SetInternalFieldCount(1); //Image : //template Handle<FunctionTemplate> imageTemplate = FunctionTemplate::New(); imageTemplate->SetClassName(v8::String::New("Image")); CanvasContextV8Bindings::imageTemplate = Persistent<FunctionTemplate>::New(imageTemplate); //prototype Handle<ObjectTemplate> imagePrototype = imageTemplate->PrototypeTemplate(); //creating instance Handle<ObjectTemplate> imageInstance = imageTemplate->InstanceTemplate(); imageInstance->SetInternalFieldCount(1); //Canvas gradient : //template Handle<FunctionTemplate> canvasGradientTemplate = FunctionTemplate::New(); canvasGradientTemplate->SetClassName(v8::String::New("CanvasGradient")); CanvasContextV8Bindings::canvasGradientTemplate = Persistent<FunctionTemplate>::New(canvasGradientTemplate); //prototype Handle<ObjectTemplate> canvasGradientPrototype = canvasGradientTemplate->PrototypeTemplate(); //creating instance Handle<ObjectTemplate> canvasGradientInstance = canvasGradientTemplate->InstanceTemplate(); canvasGradientInstance->SetInternalFieldCount(1); //attaching method canvasGradientPrototype->Set("addColorStop", FunctionTemplate::New(addColorStop)); //Canvas Pattern : //template Handle<FunctionTemplate> canvasPatternTemplate = FunctionTemplate::New(); canvasPatternTemplate->SetClassName(v8::String::New("CanvasPattern")); CanvasContextV8Bindings::canvasPatternTemplate = Persistent<FunctionTemplate>::New(canvasPatternTemplate); //prototype Handle<ObjectTemplate> canvasPatternPrototype = canvasPatternTemplate->PrototypeTemplate(); //creating instance Handle<ObjectTemplate> canvasPatternInstance = canvasPatternTemplate->InstanceTemplate(); canvasPatternInstance->SetInternalFieldCount(1); //Canvas context : //template Handle<FunctionTemplate> canvasContextTemplate = FunctionTemplate::New(); canvasContextTemplate->SetClassName(v8::String::New("CanvasContext")); //prototype Handle<ObjectTemplate> canvasContextPrototype = canvasContextTemplate->PrototypeTemplate(); //attaching method //2D Context canvasContextPrototype->Set("save", FunctionTemplate::New(save)); canvasContextPrototype->Set("restore", FunctionTemplate::New(restore)); //Transformation canvasContextPrototype->Set("scale", FunctionTemplate::New(scale)); canvasContextPrototype->Set("rotate", FunctionTemplate::New(rotate)); canvasContextPrototype->Set("translate", FunctionTemplate::New(translate)); canvasContextPrototype->Set("transform", FunctionTemplate::New(transform)); canvasContextPrototype->Set("setTransform", FunctionTemplate::New(setTransform)); //Image drawing canvasContextPrototype->Set("drawImage", FunctionTemplate::New(drawImage)); //Colors, styles and shadows canvasContextPrototype->Set("createLinearGradient", FunctionTemplate::New(createLinearGradient)); canvasContextPrototype->Set("createRadialGradient", FunctionTemplate::New(createRadialGradient)); canvasContextPrototype->Set("createPattern", FunctionTemplate::New(createPattern)); //Paths canvasContextPrototype->Set("beginPath", FunctionTemplate::New(beginPath)); canvasContextPrototype->Set("closePath", FunctionTemplate::New(closePath)); canvasContextPrototype->Set("fill", FunctionTemplate::New(fill)); canvasContextPrototype->Set("stroke", FunctionTemplate::New(stroke)); canvasContextPrototype->Set("clip", FunctionTemplate::New(clip)); canvasContextPrototype->Set("moveTo", FunctionTemplate::New(moveTo)); canvasContextPrototype->Set("lineTo", FunctionTemplate::New(lineTo)); canvasContextPrototype->Set("quadraticCurveTo", FunctionTemplate::New(quadraticCurveTo)); canvasContextPrototype->Set("bezierCurveTo", FunctionTemplate::New(bezierCurveTo)); canvasContextPrototype->Set("arcTo", FunctionTemplate::New(arcTo)); canvasContextPrototype->Set("arc", FunctionTemplate::New(arc)); canvasContextPrototype->Set("rect", FunctionTemplate::New(rect)); canvasContextPrototype->Set("isPointInPath", FunctionTemplate::New(isPointInPath)); //Text canvasContextPrototype->Set("fillText", FunctionTemplate::New(fillText)); canvasContextPrototype->Set("strokeText", FunctionTemplate::New(strokeText)); canvasContextPrototype->Set("measureText", FunctionTemplate::New(measureText)); //Rectangles canvasContextPrototype->Set("clearRect", FunctionTemplate::New(clearRect)); canvasContextPrototype->Set("fillRect", FunctionTemplate::New(fillRect)); canvasContextPrototype->Set("strokeRect", FunctionTemplate::New(strokeRect)); //New canvasContextPrototype->Set("saveToPNG", FunctionTemplate::New(saveToPNG)); canvasContextPrototype->Set("clear", FunctionTemplate::New(clear)); //creating instance Handle<ObjectTemplate> canvasContextInstance = canvasContextTemplate->InstanceTemplate(); canvasContextInstance->SetInternalFieldCount(1); //attaching properties //Compositing canvasContextInstance->SetAccessor(v8::String::New("globalAlpha"), getterGlobalAlpha, setterGlobalAlpha); canvasContextInstance->SetAccessor(v8::String::New("globalCompositeOperation"), getterGlobalCompositeOperation, setterGlobalCompositeOperation); //Line styles canvasContextInstance->SetAccessor(v8::String::New("lineWidth"), getterLineWidth, setterLineWidth); canvasContextInstance->SetAccessor(v8::String::New("lineCap"), getterLineCap, setterLineCap); canvasContextInstance->SetAccessor(v8::String::New("lineJoin"), getterLineJoin, setterLineJoin); canvasContextInstance->SetAccessor(v8::String::New("miterLimit"), getterMiterLimit, setterMiterLimit); canvasContextInstance->SetAccessor(v8::String::New("lineDash"), getterLineDash, setterLineDash); //Colors, styles and shadows canvasContextInstance->SetAccessor(v8::String::New("fillStyle"), getterFillStyle, setterFillStyle); canvasContextInstance->SetAccessor(v8::String::New("strokeStyle"), getterStrokeStyle, setterStrokeStyle); canvasContextInstance->SetAccessor(v8::String::New("shadowOffsetX"), getterShadowOffsetX, setterShadowOffsetX); canvasContextInstance->SetAccessor(v8::String::New("shadowOffsetY"), getterShadowOffsetY, setterShadowOffsetY); canvasContextInstance->SetAccessor(v8::String::New("shadowBlur"), getterShadowBlur, setterShadowBlur); canvasContextInstance->SetAccessor(v8::String::New("shadowColor"), getterShadowColor, setterShadowColor); //Text canvasContextInstance->SetAccessor(v8::String::New("font"), getterFont, setterFont); canvasContextInstance->SetAccessor(v8::String::New("textAlign"), getterTextAlign, setterTextAlign); canvasContextInstance->SetAccessor(v8::String::New("textBaseline"), getterTextBaseline, setterTextBaseline); //New canvasContextInstance->SetAccessor(v8::String::New("antialiasing"), getterAntiAliasing, setterAntiAliasing); //Image Handle<ObjectTemplate> global = ObjectTemplate::New(); global->Set(String::New("loadImage"), FunctionTemplate::New(loadImage)); Persistent<Context> context = Context::New(NULL, global); CanvasContextV8Bindings::contextV8 = context; Context::Scope context_scope(context); //building link between js 'ctx' variable and c++ _canvasContext variable Handle<Function> canvasContextConstructor = canvasContextTemplate->GetFunction(); Local<Object> obj = canvasContextConstructor->NewInstance(); obj->SetInternalField(0, External::New(_canvasContext)); context->Global()->Set(v8::String::New("ctx"), obj); //building link between js 'console' variable and c++ _console variable Handle<Function> consoleConstructor = consoleTemplate->GetFunction(); Local<Object> obj2 = consoleConstructor->NewInstance(); obj2->SetInternalField(0, External::New(_console)); context->Global()->Set(v8::String::New("console"), obj2); Handle<v8::String> source = v8::String::New(readScript(_filename).c_str()); Handle<Script> script = Script::Compile(source); Handle<Value> result = script->Run(); /* CanvasContextV8Bindings::canvasGradientTemplate.Dispose(); CanvasContextV8Bindings::canvasPatternTemplate.Dispose(); CanvasContextV8Bindings::imageTemplate.Dispose(); */ }
Handle<Object> WrapComponent(Handle<Object> wrappedes, ScriptSystem* scriptsys, dtEntity::EntityId eid, dtEntity::Component* v) { HandleScope handle_scope; Handle<Object> wrapped = scriptsys->GetFromComponentMap(v->GetType(), eid); if(!wrapped.IsEmpty()) { return wrapped; } Handle<FunctionTemplate> templt = GetScriptSystem()->GetTemplateBySID(s_componentWrapper); if(templt.IsEmpty()) { templt = FunctionTemplate::New(); templt->SetClassName(String::New("Component")); templt->InstanceTemplate()->SetInternalFieldCount(1); Handle<ObjectTemplate> proto = templt->PrototypeTemplate(); proto->Set("equals", FunctionTemplate::New(COEquals)); proto->Set("getType", FunctionTemplate::New(COGetType)); proto->Set("properties", FunctionTemplate::New(COProperties)); proto->Set("toString", FunctionTemplate::New(COToString)); proto->Set("finished", FunctionTemplate::New(COFinished)); proto->Set("copyPropertyValues", FunctionTemplate::New(COCopyPropertyValues)); GetScriptSystem()->SetTemplateBySID(s_componentWrapper, templt); } Local<Object> instance = templt->GetFunction()->NewInstance(); instance->SetInternalField(0, External::New(v)); instance->SetHiddenValue(scriptsys->GetEntityIdString(), Uint32::New(eid)); // GetStringFromSID and conversion to v8::String is costly, create a // hidden value in entity system wrapper that stores // strings and their string ids as name=>value pairs Handle<Value> propnamesval = wrappedes->GetHiddenValue(scriptsys->GetPropertyNamesString()); if(propnamesval.IsEmpty()) { Handle<Object> names = Object::New(); dtEntity::PropertyGroup::const_iterator i; const dtEntity::PropertyGroup& props = v->Get(); for(i = props.begin(); i != props.end(); ++i) { dtEntity::StringId sid = i->first; std::string propname = dtEntity::GetStringFromSID(sid); names->Set(String::New(propname.c_str()), WrapSID(sid)); } wrappedes->SetHiddenValue(scriptsys->GetPropertyNamesString(), names); propnamesval = names; } Handle<Object> propnames = Handle<Object>::Cast(propnamesval); Handle<Array> keys = propnames->GetPropertyNames(); for(unsigned int i = 0; i < keys->Length(); ++i) { Handle<String> str = keys->Get(i)->ToString(); dtEntity::StringId sid = UnwrapSID(propnames->Get(str)); dtEntity::Property* prop = v->Get(sid); if(prop == NULL) { LOG_ERROR("Could not find property in component: " << ToStdString(str)); continue; } Handle<External> ext = v8::External::New(static_cast<void*>(prop)); instance->SetAccessor(str, COPropertyGetter, COPropertySetter, ext); } // store wrapped component to script system scriptsys->AddToComponentMap(v->GetType(), eid, instance); return handle_scope.Close(instance); }
Local<v8::Object> mongoToV8( const BSONObj& m , bool array, bool readOnly ){ // handle DBRef. needs to come first. isn't it? (metagoto) static string ref = "$ref"; if ( ref == m.firstElement().fieldName() ) { const BSONElement& id = m["$id"]; if (!id.eoo()) { // there's no check on $id exitence in sm implementation. risky ? v8::Function* dbRef = getNamedCons( "DBRef" ); v8::Handle<v8::Value> argv[2]; argv[0] = mongoToV8Element(m.firstElement()); argv[1] = mongoToV8Element(m["$id"]); return dbRef->NewInstance(2, argv); } } Local< v8::ObjectTemplate > readOnlyObjects; // Hoping template construction is fast... Local< v8::ObjectTemplate > internalFieldObjects = v8::ObjectTemplate::New(); internalFieldObjects->SetInternalFieldCount( 1 ); Local<v8::Object> o; if ( array ) { // NOTE Looks like it's impossible to add interceptors to non array objects in v8. o = v8::Array::New(); } else if ( !readOnly ) { o = v8::Object::New(); } else { // NOTE Our readOnly implemention relies on undocumented ObjectTemplate // functionality that may be fragile, but it still seems like the best option // for now -- fwiw, the v8 docs are pretty sparse. I've determined experimentally // that when property handlers are set for an object template, they will attach // to objects previously created by that template. To get this to work, though, // it is necessary to initialize the template's property handlers before // creating objects from the template (as I have in the following few lines // of code). // NOTE In my first attempt, I configured the permanent property handlers before // constructiong the object and replaced the Set() calls below with ForceSet(). // However, it turns out that ForceSet() only bypasses handlers for named // properties and not for indexed properties. readOnlyObjects = v8::ObjectTemplate::New(); // NOTE This internal field will store type info for special db types. For // regular objects the field is unnecessary - for simplicity I'm creating just // one readOnlyObjects template for objects where the field is & isn't necessary, // assuming that the overhead of an internal field is slight. readOnlyObjects->SetInternalFieldCount( 1 ); readOnlyObjects->SetNamedPropertyHandler( 0 ); readOnlyObjects->SetIndexedPropertyHandler( 0 ); o = readOnlyObjects->NewInstance(); } mongo::BSONObj sub; for ( BSONObjIterator i(m); i.more(); ) { const BSONElement& f = i.next(); Local<Value> v; switch ( f.type() ){ case mongo::Code: o->Set( v8::String::New( f.fieldName() ), newFunction( f.valuestr() ) ); break; case CodeWScope: if ( f.codeWScopeObject().isEmpty() ) log() << "warning: CodeWScope doesn't transfer to db.eval" << endl; o->Set( v8::String::New( f.fieldName() ), newFunction( f.codeWScopeCode() ) ); break; case mongo::String: o->Set( v8::String::New( f.fieldName() ) , v8::String::New( f.valuestr() ) ); break; case mongo::jstOID: { v8::Function * idCons = getObjectIdCons(); v8::Handle<v8::Value> argv[1]; argv[0] = v8::String::New( f.__oid().str().c_str() ); o->Set( v8::String::New( f.fieldName() ) , idCons->NewInstance( 1 , argv ) ); break; } case mongo::NumberDouble: case mongo::NumberInt: o->Set( v8::String::New( f.fieldName() ) , v8::Number::New( f.number() ) ); break; case mongo::Array: case mongo::Object: sub = f.embeddedObject(); o->Set( v8::String::New( f.fieldName() ) , mongoToV8( sub , f.type() == mongo::Array, readOnly ) ); break; case mongo::Date: o->Set( v8::String::New( f.fieldName() ) , v8::Date::New( f.date() ) ); break; case mongo::Bool: o->Set( v8::String::New( f.fieldName() ) , v8::Boolean::New( f.boolean() ) ); break; case mongo::jstNULL: case mongo::Undefined: // duplicate sm behavior o->Set( v8::String::New( f.fieldName() ) , v8::Null() ); break; case mongo::RegEx: { v8::Function * regex = getNamedCons( "RegExp" ); v8::Handle<v8::Value> argv[2]; argv[0] = v8::String::New( f.regex() ); argv[1] = v8::String::New( f.regexFlags() ); o->Set( v8::String::New( f.fieldName() ) , regex->NewInstance( 2 , argv ) ); break; } case mongo::BinData: { Local<v8::Object> b = readOnly ? readOnlyObjects->NewInstance() : internalFieldObjects->NewInstance(); int len; const char *data = f.binData( len ); v8::Function* binData = getNamedCons( "BinData" ); v8::Handle<v8::Value> argv[3]; argv[0] = v8::Number::New( len ); argv[1] = v8::Number::New( f.binDataType() ); argv[2] = v8::String::New( data, len ); o->Set( v8::String::New( f.fieldName() ), binData->NewInstance(3, argv) ); break; } case mongo::Timestamp: { Local<v8::Object> sub = readOnly ? readOnlyObjects->NewInstance() : internalFieldObjects->NewInstance(); sub->Set( v8::String::New( "time" ) , v8::Date::New( f.timestampTime() ) ); sub->Set( v8::String::New( "i" ) , v8::Number::New( f.timestampInc() ) ); sub->SetInternalField( 0, v8::Uint32::New( f.type() ) ); o->Set( v8::String::New( f.fieldName() ) , sub ); break; } case mongo::NumberLong: { Local<v8::Object> sub = readOnly ? readOnlyObjects->NewInstance() : internalFieldObjects->NewInstance(); unsigned long long val = f.numberLong(); v8::Function* numberLong = getNamedCons( "NumberLong" ); v8::Handle<v8::Value> argv[2]; argv[0] = v8::Integer::New( val >> 32 ); argv[1] = v8::Integer::New( (unsigned long)(val & 0x00000000ffffffff) ); o->Set( v8::String::New( f.fieldName() ), numberLong->NewInstance(2, argv) ); break; } case mongo::MinKey: { Local<v8::Object> sub = readOnly ? readOnlyObjects->NewInstance() : internalFieldObjects->NewInstance(); sub->Set( v8::String::New( "$MinKey" ), v8::Boolean::New( true ) ); sub->SetInternalField( 0, v8::Uint32::New( f.type() ) ); o->Set( v8::String::New( f.fieldName() ) , sub ); break; } case mongo::MaxKey: { Local<v8::Object> sub = readOnly ? readOnlyObjects->NewInstance() : internalFieldObjects->NewInstance(); sub->Set( v8::String::New( "$MaxKey" ), v8::Boolean::New( true ) ); sub->SetInternalField( 0, v8::Uint32::New( f.type() ) ); o->Set( v8::String::New( f.fieldName() ) , sub ); break; } case mongo::DBRef: { v8::Function* dbPointer = getNamedCons( "DBPointer" ); v8::Handle<v8::Value> argv[2]; argv[0] = v8::String::New( f.dbrefNS() ); argv[1] = newId( f.dbrefOID() ); o->Set( v8::String::New( f.fieldName() ), dbPointer->NewInstance(2, argv) ); break; } default: cout << "can't handle type: "; cout << f.type() << " "; cout << f.toString(); cout << endl; break; } } if ( !array && readOnly ) { readOnlyObjects->SetNamedPropertyHandler( 0, NamedReadOnlySet, 0, NamedReadOnlyDelete ); readOnlyObjects->SetIndexedPropertyHandler( 0, IndexedReadOnlySet, 0, IndexedReadOnlyDelete ); } return o; }
Handle<v8::Value> mongoToV8Element( const BSONElement &f ) { Local< v8::ObjectTemplate > internalFieldObjects = v8::ObjectTemplate::New(); internalFieldObjects->SetInternalFieldCount( 1 ); switch ( f.type() ){ case mongo::Code: return newFunction( f.valuestr() ); case CodeWScope: if ( f.codeWScopeObject().isEmpty() ) log() << "warning: CodeWScope doesn't transfer to db.eval" << endl; return newFunction( f.codeWScopeCode() ); case mongo::String: return v8::String::New( f.valuestr() ); case mongo::jstOID: return newId( f.__oid() ); case mongo::NumberDouble: case mongo::NumberInt: return v8::Number::New( f.number() ); case mongo::Array: case mongo::Object: return mongoToV8( f.embeddedObject() , f.type() == mongo::Array ); case mongo::Date: return v8::Date::New( f.date() ); case mongo::Bool: return v8::Boolean::New( f.boolean() ); case mongo::EOO: case mongo::jstNULL: case mongo::Undefined: // duplicate sm behavior return v8::Null(); case mongo::RegEx: { v8::Function * regex = getNamedCons( "RegExp" ); v8::Handle<v8::Value> argv[2]; argv[0] = v8::String::New( f.regex() ); argv[1] = v8::String::New( f.regexFlags() ); return regex->NewInstance( 2 , argv ); break; } case mongo::BinData: { int len; const char *data = f.binData( len ); v8::Function* binData = getNamedCons( "BinData" ); v8::Handle<v8::Value> argv[3]; argv[0] = v8::Number::New( len ); argv[1] = v8::Number::New( f.binDataType() ); argv[2] = v8::String::New( data, len ); return binData->NewInstance( 3, argv ); }; case mongo::Timestamp: { Local<v8::Object> sub = internalFieldObjects->NewInstance(); sub->Set( v8::String::New( "time" ) , v8::Date::New( f.timestampTime() ) ); sub->Set( v8::String::New( "i" ) , v8::Number::New( f.timestampInc() ) ); sub->SetInternalField( 0, v8::Uint32::New( f.type() ) ); return sub; } case mongo::NumberLong: { Local<v8::Object> sub = internalFieldObjects->NewInstance(); unsigned long long val = f.numberLong(); v8::Function* numberLong = getNamedCons( "NumberLong" ); v8::Handle<v8::Value> argv[2]; argv[0] = v8::Integer::New( val >> 32 ); argv[1] = v8::Integer::New( (unsigned long)(val & 0x00000000ffffffff) ); return numberLong->NewInstance( 2, argv ); } case mongo::MinKey: { Local<v8::Object> sub = internalFieldObjects->NewInstance(); sub->Set( v8::String::New( "$MinKey" ), v8::Boolean::New( true ) ); sub->SetInternalField( 0, v8::Uint32::New( f.type() ) ); return sub; } case mongo::MaxKey: { Local<v8::Object> sub = internalFieldObjects->NewInstance(); sub->Set( v8::String::New( "$MaxKey" ), v8::Boolean::New( true ) ); sub->SetInternalField( 0, v8::Uint32::New( f.type() ) ); return sub; } case mongo::DBRef: { v8::Function* dbPointer = getNamedCons( "DBPointer" ); v8::Handle<v8::Value> argv[2]; argv[0] = v8::String::New( f.dbrefNS() ); argv[1] = newId( f.dbrefOID() ); return dbPointer->NewInstance(2, argv); } default: cout << "can't handle type: "; cout << f.type() << " "; cout << f.toString(); cout << endl; break; } return v8::Undefined(); }