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());
}
}
