void EIO_AfterList(uv_work_t* req) { NanScope(); ListBaton* data = static_cast<ListBaton*>(req->data); v8::Handle<v8::Value> argv[2]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); argv[1] = NanUndefined(); } else { v8::Local<v8::Array> results = NanNew<v8::Array>(); int i = 0; for(std::list<ListResultItem*>::iterator it = data->results.begin(); it != data->results.end(); ++it, i++) { v8::Local<v8::Object> item = NanNew<v8::Object>(); item->Set(NanNew<v8::String>("comName"), NanNew<v8::String>((*it)->comName.c_str())); item->Set(NanNew<v8::String>("manufacturer"), NanNew<v8::String>((*it)->manufacturer.c_str())); item->Set(NanNew<v8::String>("serialNumber"), NanNew<v8::String>((*it)->serialNumber.c_str())); item->Set(NanNew<v8::String>("pnpId"), NanNew<v8::String>((*it)->pnpId.c_str())); item->Set(NanNew<v8::String>("locationId"), NanNew<v8::String>((*it)->locationId.c_str())); item->Set(NanNew<v8::String>("vendorId"), NanNew<v8::String>((*it)->vendorId.c_str())); item->Set(NanNew<v8::String>("productId"), NanNew<v8::String>((*it)->productId.c_str())); results->Set(i, item); } argv[0] = NanUndefined(); argv[1] = results; } data->callback->Call(2, argv); delete data->callback; for(std::list<ListResultItem*>::iterator it = data->results.begin(); it != data->results.end(); ++it) { delete *it; } delete data; delete req; }
void EIO_AfterOpen(uv_work_t* req) { NanScope(); OpenBaton* data = static_cast<OpenBaton*>(req->data); v8::Handle<v8::Value> argv[2]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); argv[1] = NanUndefined(); // not needed for AfterOpenSuccess delete data->dataCallback; delete data->errorCallback; delete data->disconnectedCallback; } else { argv[0] = NanUndefined(); argv[1] = NanNew<v8::Int32>(data->result); AfterOpenSuccess(data->result, data->dataCallback, data->disconnectedCallback, data->errorCallback); } data->callback->Call(2, argv); delete data->callback; delete data; delete req; }
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); }
void EIO_AfterWrite(uv_work_t* req) { NanScope(); QueuedWrite* queuedWrite = static_cast<QueuedWrite*>(req->data); WriteBaton* data = static_cast<WriteBaton*>(queuedWrite->baton); v8::Handle<v8::Value> argv[2]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); argv[1] = NanUndefined(); } else { argv[0] = NanUndefined(); argv[1] = NanNew<v8::Int32>(data->result); } data->callback->Call(2, argv); if (data->offset < data->bufferLength && !data->errorString[0]) { // We're not done with this baton, so throw it right back onto the queue. // Don't re-push the write in the event loop if there was an error; because same error could occur again! // TODO: Add a uv_poll here for unix... //fprintf(stderr, "Write again...\n"); uv_queue_work(uv_default_loop(), req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite); return; } int fd = data->fd; _WriteQueue *q = qForFD(fd); if(!q) { NanThrowTypeError("There's no write queue for that file descriptor (after write)!"); return; } q->lock(); QueuedWrite &write_queue = q->get(); // remove this one from the list queuedWrite->remove(); // If there are any left, start a new thread to write the next one. if (!write_queue.empty()) { // Always pull the next work item from the head of the queue QueuedWrite* nextQueuedWrite = write_queue.next; uv_queue_work(uv_default_loop(), &nextQueuedWrite->req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite); } q->unlock(); NanDisposePersistent(data->buffer); delete data->callback; delete data; delete queuedWrite; }
static void DNSSD_API OnServiceRegistered(DNSServiceRef sdRef, DNSServiceFlags flags, DNSServiceErrorType errorCode, const char * name, const char * serviceType, const char * domain, void * context) { if ( ! context) return; NanScope(); ServiceRef * serviceRef = static_cast<ServiceRef*>(context); Handle<Function> callback = serviceRef->GetCallback(); Handle<Object> this_ = serviceRef->GetThis(); if ( ! callback.IsEmpty() && ! this_.IsEmpty()) { const size_t argc(7); Local<Value> args[argc]; args[0] = NanObjectWrapHandle(serviceRef); args[1] = NanNew<Integer>(flags); args[2] = NanNew<Integer>(errorCode); args[3] = stringOrUndefined(name); args[4] = stringOrUndefined(serviceType); args[5] = stringOrUndefined(domain); if (serviceRef->GetContext().IsEmpty()) { args[6] = NanUndefined(); } else { args[6] = NanNew<Value>(serviceRef->GetContext()); } NanMakeCallback(this_, callback, argc, args); } }
/* DESCRIPTION Callback function of Get Connection method PARAMETERS: UV queue work block NOTES: Connection handle is formed and handed over to JS. */ void Oracledb::Async_AfterGetConnection (uv_work_t *req) { NanScope(); connectionBaton *connBaton = (connectionBaton*)req->data; v8::TryCatch tc; Handle<Value> argv[2]; if( !(connBaton->error).empty() ) { argv[0] = v8::Exception::Error(NanNew<v8::String>( (connBaton->error).c_str() )); argv[1] = NanNull(); } else { argv[0] = NanUndefined(); Local<FunctionTemplate> lft = NanNew(Connection::connectionTemplate_s); Handle<Object> connection = lft->GetFunction()-> NewInstance(); (ObjectWrap::Unwrap<Connection> (connection))-> setConnection( connBaton->dpiconn, connBaton->oracledb ); argv[1] = connection; } Local<Function> callback = NanNew(connBaton->cb); delete connBaton; NanMakeCallback( NanGetCurrentContext()->Global(), callback, 2, argv ); if(tc.HasCaught()) node::FatalException(tc); }
Local<Value> Grid::_clearSync(_NAN_METHOD_ARGS) { NanEscapableScope(); Grid* g = node::ObjectWrap::Unwrap<Grid>(args.Holder()); g->get()->clear(); return NanEscapeScope(NanUndefined()); }
void HandleOKCallback() { NanScope(); static const int argc = 2; Local<Value> argv[2] = { NanUndefined(), v8Value(selectResultsPtr) }; callback->Call(argc, argv); }
void DNSSD_API OnResolve(DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char * fullname, const char * hosttarget, uint16_t port, uint16_t txtLen, const unsigned char * txtRecord, void * context) { NanScope(); ServiceRef * serviceRef = static_cast<ServiceRef*>(context); Handle<Function> callback = serviceRef->GetCallback(); Handle<Object> this_ = serviceRef->GetThis(); const size_t argc(9); Local<Value> args[argc]; args[0] = NanObjectWrapHandle(serviceRef); args[1] = NanNew<Integer>(flags); args[2] = NanNew<Uint32>(interfaceIndex); args[3] = NanNew<Integer>(errorCode); args[4] = stringOrUndefined(fullname); args[5] = stringOrUndefined(hosttarget); args[6] = NanNew<Integer>( ntohs(port) ); Local<Object> buffer = NanNewBufferHandle(txtLen); memcpy(Buffer::Data(buffer), txtRecord, txtLen); args[7] = buffer; if (serviceRef->GetContext().IsEmpty()) { args[8] = NanUndefined(); } else { args[8] = NanNew<Value>(serviceRef->GetContext()); } NanMakeCallback(this_, callback, argc, args); }
v8::Local<v8::Value> ErrorMessage::getErrorMessage(int errorCode, char *customMessage) { switch (errorCode) { case NRF_SUCCESS: return NanUndefined(); case NRF_ERROR_SVC_HANDLER_MISSING: case NRF_ERROR_SOFTDEVICE_NOT_ENABLED: case NRF_ERROR_INTERNAL: case NRF_ERROR_NO_MEM: case NRF_ERROR_NOT_FOUND: case NRF_ERROR_NOT_SUPPORTED: case NRF_ERROR_INVALID_PARAM: case NRF_ERROR_INVALID_STATE: case NRF_ERROR_INVALID_LENGTH: case NRF_ERROR_INVALID_FLAGS: case NRF_ERROR_INVALID_DATA: case NRF_ERROR_DATA_SIZE: case NRF_ERROR_TIMEOUT: case NRF_ERROR_NULL: case NRF_ERROR_FORBIDDEN: case NRF_ERROR_INVALID_ADDR: case NRF_ERROR_BUSY: default: { std::ostringstream errorStringStream; errorStringStream << "Error occured when " << customMessage << ". " << "Errorcode: " << ConversionUtility::valueToString(errorCode, error_message_name_map) << " (" << errorCode << ")" << std::endl; return v8::Exception::Error(NanNew<v8::String>(errorStringStream.str())); } } }
static void DNSSD_API OnServiceChanged(DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char * serviceName, const char * serviceType, const char * replyDomain, void * context) { NanScope(); ServiceRef * serviceRef = static_cast<ServiceRef*>(context); Handle<Function> callback = serviceRef->GetCallback(); Handle<Object> this_ = serviceRef->GetThis(); const size_t argc(8); Local<Value> args[argc]; args[0] = NanObjectWrapHandle(serviceRef); args[1] = NanNew<Integer>(flags); args[2] = NanNew<Uint32>(interfaceIndex); args[3] = NanNew<Integer>(errorCode); args[4] = stringOrUndefined(serviceName); args[5] = stringOrUndefined(serviceType); args[6] = stringOrUndefined(replyDomain); if (serviceRef->GetContext().IsEmpty()) { args[7] = NanUndefined(); } else { args[7] = NanNew<Value>(serviceRef->GetContext()); } NanMakeCallback(this_, callback, argc, args); }
void EIO_AfterClose(uv_work_t* req) { NanScope(); CloseBaton* data = static_cast<CloseBaton*>(req->data); v8::Handle<v8::Value> argv[1]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); } else { argv[0] = NanUndefined(); // We don't have an error, so clean up the write queue for that fd _WriteQueue *q = qForFD(data->fd); if (q) { q->lock(); QueuedWrite &write_queue = q->get(); while (!write_queue.empty()) { QueuedWrite *del_q = write_queue.next; NanDisposePersistent(del_q->baton->buffer); del_q->remove(); } q->unlock(); deleteQForFD(data->fd); } } data->callback->Call(1, argv); delete data->callback; delete data; delete req; }
// Any new return statements added here should call MakeWeak() on bufferHandle_, // if it is not empty. void CallbackOverride(SQLRETURN ret) { EOS_DEBUG_METHOD(); if (!SQL_SUCCEEDED(ret) && ret != SQL_NO_DATA) { if (!bufferHandle_.IsEmpty()) NanDisposePersistent(bufferHandle_); return CallbackErrorOverride(ret); } EOS_DEBUG(L"Final Result: %hi\n", ret); Handle<Value> argv[4]; argv[0] = NanUndefined(); if (totalLength_ != SQL_NO_TOTAL) argv[2] = NanNew<Number>(totalLength_); else argv[2] = NanUndefined(); argv[3] = NanNew<Boolean>(totalLength_ > bufferLength_ || (totalLength_ == SQL_NO_TOTAL && ret == SQL_SUCCESS_WITH_INFO)); if (ret == SQL_NO_DATA) argv[1] = NanUndefined(); else if (totalLength_ == SQL_NULL_DATA) argv[1] = NanNull(); else if (raw_) { assert(!bufferHandle_.IsEmpty()); argv[1] = NanNew(bufferHandle_); } else if (cType_ == SQL_C_BINARY) { if (totalLength_ >= bufferLength_) argv[1] = NanNew(bufferHandle_); else argv[1] = JSBuffer::Slice(NanNew(bufferHandle_), 0, totalLength_); } else { argv[1] = Eos::ConvertToJS(buffer_, totalLength_, bufferLength_, cType_); if (argv[1]->IsUndefined()) argv[0] = OdbcError("Unable to interpret contents of result buffer"); } // Can we Dispose() things that JS-land is referencing? We'll soon find out! if (!bufferHandle_.IsEmpty()) NanDisposePersistent(bufferHandle_); MakeCallback(argv); }
void EIO_AfterDrain(uv_work_t* req) { NanScope(); DrainBaton* data = static_cast<DrainBaton*>(req->data); v8::Handle<v8::Value> argv[2]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); argv[1] = NanUndefined(); } else { argv[0] = NanUndefined(); argv[1] = NanNew<v8::Int32>(data->result); } data->callback->Call(2, argv); delete data->callback; delete data; delete req; }
void VisaEmitter::EIO_AfterAll(uv_work_t* req) { NanScope(); GenericBaton* baton = static_cast<GenericBaton*>(req->data); Handle<Value> argv[2]; if(baton->errorString[0]) { argv[0] = Exception::Error(NanNew<String>(baton->errorString)); argv[1] = NanUndefined(); } else if (baton->bufferLength > 0) { argv[0] = NanUndefined(); argv[1] = NanNewBufferHandle(baton->buffer, baton->bufferLength); } else { argv[0] = NanUndefined(); argv[1] = NanNew(baton->result); } baton->callback->Call(2, argv); delete baton->buffer; delete baton->callback; delete baton; }
void OracleClient::EIO_AfterConnect(uv_work_t* req, int status) { UNI_SCOPE(scope); ConnectBaton* baton = static_cast<ConnectBaton*>(req->data); baton->client->Unref(); Handle<Value> argv[2]; if(baton->error) { argv[0] = Exception::Error(NanNew<String>(baton->error->c_str())); argv[1] = NanUndefined(); } else { argv[0] = NanUndefined(); Handle<Object> connection = uni::Deref(Connection::constructorTemplate)->GetFunction()->NewInstance(); (node::ObjectWrap::Unwrap<Connection>(connection))->setConnection(baton->client->m_environment, baton->connection); argv[1] = connection; } NanMakeCallback(NanGetCurrentContext()->Global(), uni::Deref(baton->callback), 2, argv); delete baton; delete req; }
void EIO_AfterWrite(uv_work_t* req) { NanScope(); QueuedWrite* queuedWrite = static_cast<QueuedWrite*>(req->data); WriteBaton* data = static_cast<WriteBaton*>(queuedWrite->baton); v8::Handle<v8::Value> argv[2]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); argv[1] = NanUndefined(); } else { argv[0] = NanUndefined(); argv[1] = NanNew<v8::Int32>(data->result); } data->callback->Call(2, argv); if (data->offset < data->bufferLength && !data->errorString[0]) { // We're not done with this baton, so throw it right back onto the queue. // Don't re-push the write in the event loop if there was an error; because same error could occur again! // TODO: Add a uv_poll here for unix... uv_queue_work(uv_default_loop(), req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite); return; } uv_mutex_lock(&write_queue_mutex); QUEUE_REMOVE(&queuedWrite->queue); if (!QUEUE_EMPTY(&write_queue)) { // Always pull the next work item from the head of the queue QUEUE* head = QUEUE_HEAD(&write_queue); QueuedWrite* nextQueuedWrite = QUEUE_DATA(head, QueuedWrite, queue); uv_queue_work(uv_default_loop(), &nextQueuedWrite->req, EIO_Write, (uv_after_work_cb)EIO_AfterWrite); } uv_mutex_unlock(&write_queue_mutex); NanDisposePersistent(data->buffer); delete data->callback; delete data; delete queuedWrite; }
Handle<Value> FeatureFields::getFieldAsBinary(OGRFeature* feature, int field_index) { NanEscapableScope(); int count_of_bytes = 0; unsigned char *data = (unsigned char*) feature->GetFieldAsBinary(field_index, &count_of_bytes); if (count_of_bytes > 0) { return NanEscapeScope(FastBuffer::New(data, count_of_bytes)); } return NanEscapeScope(NanUndefined()); }
/* DESCRIPTION Worker Function of CreatePool. PARAMETERS: UV queue work block NOTES: Pool handle is created and handed over to JS. */ void Oracledb::Async_AfterCreatePool (uv_work_t *req) { NanScope() ; connectionBaton *poolBaton = (connectionBaton *)req->data; v8::TryCatch tc; Handle<Value> argv[2]; if (!poolBaton->error.empty()) { argv[0] = v8::Exception::Error(NanNew<v8::String>(( poolBaton->error).c_str() )); argv[1] = NanUndefined(); } else { argv[0] = NanUndefined (); Handle<Object> njsPool = NanNew(Pool::poolTemplate_s)-> GetFunction() ->NewInstance(); (ObjectWrap::Unwrap<Pool> (njsPool))-> setPool ( poolBaton->dpipool, poolBaton->oracledb, poolBaton->poolMax, poolBaton->poolMin, poolBaton->poolIncrement, poolBaton->poolTimeout, poolBaton->stmtCacheSize, poolBaton->lobPrefetchSize); argv[1] = njsPool; } Local<Function> callback = NanNew(poolBaton->cb); delete poolBaton; NanMakeCallback ( NanGetCurrentContext()->Global(), callback, 2, argv); if(tc.HasCaught()) { node::FatalException (tc); } }
void EIO_AfterClose(uv_work_t* req) { NanScope(); CloseBaton* data = static_cast<CloseBaton*>(req->data); v8::Handle<v8::Value> argv[1]; if(data->errorString[0]) { argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString)); } else { argv[0] = NanUndefined(); } data->callback->Call(1, argv); delete data->callback; delete data; delete req; }
Handle<Value> Layer::New(OGRLayer *raw, OGRDataSource *raw_parent, bool result_set) #endif { NanEscapableScope(); if (!raw) { return NanEscapeScope(NanNull()); } if (cache.has(raw)) { return NanEscapeScope(NanNew(cache.get(raw))); } Layer *wrapped = new Layer(raw); wrapped->is_result_set = result_set; Handle<Value> ext = NanNew<External>(wrapped); Handle<Object> obj = NanNew(Layer::constructor)->GetFunction()->NewInstance(1, &ext); cache.add(raw, obj); //add reference to datasource so datasource doesnt get GC'ed while layer is alive if (raw_parent) { Handle<Value> ds; #if GDAL_VERSION_MAJOR >= 2 if (Dataset::dataset_cache.has(raw_parent)) { ds = NanNew(Dataset::dataset_cache.get(raw_parent)); } #else if (Dataset::datasource_cache.has(raw_parent)) { ds = NanNew(Dataset::datasource_cache.get(raw_parent)); } #endif else { LOG("Layer's parent dataset disappeared from cache (layer = %p, dataset = %p)", raw, raw_parent); NanThrowError("Layer's parent dataset disappeared from cache"); return NanEscapeScope(NanUndefined()); //ds = Dataset::New(raw_parent); //should never happen } wrapped->parent_ds = raw_parent; obj->SetHiddenValue(NanNew("ds_"), ds); } return NanEscapeScope(obj); }
Handle<Value> FeatureFields::getFieldAsDateTime(OGRFeature* feature, int field_index) { NanEscapableScope(); int year, month, day, hour, minute, second, timezone; year = month = day = hour = minute = second = timezone = 0; int result = feature->GetFieldAsDateTime(field_index, &year, &month, &day, &hour, &minute, &second, &timezone); if (result == TRUE) { Local<Object> hash = NanNew<Object>(); if (year) { hash->Set(NanNew("year"), NanNew<Integer>(year)); } if (month) { hash->Set(NanNew("month"), NanNew<Integer>(month)); } if (day) { hash->Set(NanNew("day"), NanNew<Integer>(day)); } if (hour) { hash->Set(NanNew("hour"), NanNew<Integer>(hour)); } if (minute) { hash->Set(NanNew("minute"), NanNew<Integer>(minute)); } if (second) { hash->Set(NanNew("second"), NanNew<Integer>(second)); } if (timezone) { hash->Set(NanNew("timezone"), NanNew<Integer>(timezone)); } return NanEscapeScope(hash); } else { return NanEscapeScope(NanUndefined()); } }
uni::CallbackType OracleClient::Connect(const uni::FunctionCallbackInfo& args) { UNI_SCOPE(scope); REQ_OBJECT_ARG(0, settings); REQ_FUN_ARG(1, callback); OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This()); ConnectBaton* baton = new ConnectBaton(client, client->m_environment, &callback); OBJ_GET_STRING(settings, "hostname", baton->hostname); OBJ_GET_STRING(settings, "user", baton->user); OBJ_GET_STRING(settings, "password", baton->password); OBJ_GET_STRING(settings, "database", baton->database); OBJ_GET_NUMBER(settings, "port", baton->port, 1521); OBJ_GET_STRING(settings, "tns", baton->tns); client->Ref(); uv_work_t* req = new uv_work_t(); req->data = baton; uv_queue_work(uv_default_loop(), req, EIO_Connect, (uv_after_work_cb)EIO_AfterConnect); UNI_RETURN(scope, args, NanUndefined()); }
Handle<Value> FeatureFields::get(OGRFeature *f, int field_index) { //#throws : caller must check if return_val.IsEmpty() and bail out if true NanEscapableScope(); if(!f->IsFieldSet(field_index)) return NanEscapeScope(NanNull()); OGRFieldDefn *field_def = f->GetFieldDefnRef(field_index); switch(field_def->GetType()) { case OFTInteger: return NanEscapeScope(NanNew<Integer>(f->GetFieldAsInteger(field_index))); #if defined(GDAL_VERSION_MAJOR) && (GDAL_VERSION_MAJOR >= 2) case OFTInteger64: return NanEscapeScope(NanNew<Number>(f->GetFieldAsInteger64(field_index))); #endif case OFTReal: return NanEscapeScope(NanNew<Number>(f->GetFieldAsDouble(field_index))); case OFTString: return NanEscapeScope(SafeString::New(f->GetFieldAsString(field_index))); case OFTIntegerList: return NanEscapeScope(getFieldAsIntegerList(f, field_index)); case OFTRealList: return NanEscapeScope(getFieldAsDoubleList(f, field_index)); case OFTStringList: return NanEscapeScope(getFieldAsStringList(f, field_index)); case OFTBinary: return NanEscapeScope(getFieldAsBinary(f, field_index)); case OFTDate: case OFTTime: case OFTDateTime: return NanEscapeScope(getFieldAsDateTime(f, field_index)); default: NanThrowError("Unsupported field type"); return NanEscapeScope(NanUndefined()); } }