// --------------------------------------------------------
Handle<Value> NodeOpenALStream::Buffer(const Arguments& args) {
HandleScope scope;
NodeOpenALStream* obj = ObjectWrap::Unwrap<NodeOpenALStream>(args.This());
if (args.Length() < 1) {
ThrowException(Exception::TypeError(String::New("Wrong number of arguments")));
return scope.Close( Undefined() );
}
Local<Value> buffer = args[0];
size_t size = node::Buffer::Length( buffer->ToObject() );
char* bufferdata = node::Buffer::Data( buffer->ToObject() );
obj->buffer(size, bufferdata);
return scope.Close(v8::Undefined());
}
void setKeysInOp(Handle<Object> spec, KeyOperation & op) {
Local<Value> v;
Local<Object> o;
v = spec->Get(HELPER_KEY_BUFFER);
if(! v->IsNull()) {
o = v->ToObject();
op.key_buffer = node::Buffer::Data(o);
}
v = spec->Get(HELPER_KEY_RECORD);
if(! v->IsNull()) {
o = v->ToObject();
op.key_record = unwrapPointer<const Record *>(o);
}
}
void ParamRsaPSS::FromV8(Local<Value> v8Value) {
try {
Nan::HandleScope();
if (!v8Value->IsObject()) {
THROW_ERROR("Parameter 1 MUST be Object", NULL);
}
Local<Object> v8Params = v8Value->ToObject();
// Check data
if (!check_param_number(v8Params, STR_MGF))
THROW_ERROR("Attribute 'mgf' MUST be NUMBER", NULL);
if (!check_param_number(v8Params, STR_SALT_LEN))
THROW_ERROR("Attribute 'saltLen' MUST be NUMBER", NULL);
if (!check_param_number(v8Params, STR_HASH_ALG))
THROW_ERROR("Attribute 'hashAlg' MUST be NUMBER", NULL);
Free();
Init();
param.sLen = Nan::To<v8::Number>(v8Params->Get(Nan::New(STR_SALT_LEN).ToLocalChecked())).ToLocalChecked()->Uint32Value();
param.mgf = Nan::To<v8::Number>(v8Params->Get(Nan::New(STR_MGF).ToLocalChecked())).ToLocalChecked()->Uint32Value();
param.hashAlg = Nan::To<v8::Number>(v8Params->Get(Nan::New(STR_HASH_ALG).ToLocalChecked())).ToLocalChecked()->Uint32Value();
}
CATCH_ERROR;
}
void DBOperationHelper_VO(Handle<Object> spec, KeyOperation & op) {
DEBUG_MARKER(UDEB_DETAIL);
Local<Value> v;
Local<Object> o;
Local<Object> valueObj;
v = spec->Get(HELPER_VALUE_OBJECT);
valueObj = v->ToObject();
NdbRecordObject * nro = unwrapPointer<NdbRecordObject *>(valueObj);
/* Set the key record and key buffer from the helper spec */
setKeysInOp(spec, op);
/* Set the row record, row buffer, and mask from the VO */
op.row_record = nro->getRecord();
op.row_buffer = nro->getBuffer();
/* A persist operation must write all columns.
A save operation must write all columns only if the PK has changed.
Other operations only write columns that have changed since being read.
*/
if(op.opcode == 2)
op.setRowMask(op.row_record->getAllColumnMask());
else if(op.opcode == 8 && (nro->getMaskValue() & op.row_record->getPkColumnMask()))
op.setRowMask(op.row_record->getAllColumnMask());
else
op.setRowMask(nro->getMaskValue());
op.nblobs = nro->createBlobWriteHandles(op);
DEBUG_PRINT(" VO %s -- mask: %u lobs: %d", op.getOperationName(),
op.u.maskvalue, op.nblobs);
nro->resetMask();
}
// Unfortunately native modules don't get a reference
// to require.cache as this happens in Module._compile()
// and native modules aren't compiled, they are loaded
// directly by NativeModule.require() (in Module._load())
// So we need to get it from Module._cache instead (by
// executing require('module')._cache)
static Local<Object> getRequireCache(Handle<Object> module) {
Nan::EscapableHandleScope scope;
Handle<Value> args[] = { Nan::New<String>("module").ToLocalChecked() };
Local<Value> m = module->Get(Nan::New<String>("require").ToLocalChecked())->ToObject()->CallAsFunction(Nan::GetCurrentContext()->Global(), 1, args);
Local<Object> cache = m->ToObject()->Get(Nan::New<String>("_cache").ToLocalChecked())->ToObject();
return scope.Escape(cache);
}
/* JS QueryOperation.create(ndbRootProjection, keyBuffer, depth)
*/
void createQueryOperation(const Arguments & args) {
DEBUG_MARKER(UDEB_DEBUG);
REQUIRE_ARGS_LENGTH(3);
Isolate * isolate = Isolate::GetCurrent();
int size = args[2]->Int32Value();
QueryOperation * queryOperation = new QueryOperation(size);
const NdbQueryOperationDef * root, * current;
Local<Value> v;
Local<Object> spec = args[0]->ToObject();
setRowBuffers(queryOperation, spec);
current = root = createTopLevelQuery(queryOperation, spec,
args[1]->ToObject());
while(! (v = spec->Get(GET_KEY(K_next)))->IsNull()) {
spec = v->ToObject();
current = createNextLevel(queryOperation, spec, current);
assert(current->getOpNo() == spec->Get(GET_KEY(K_depth))->Uint32Value());
setRowBuffers(queryOperation, spec);
}
queryOperation->prepare(root);
args.GetReturnValue().Set(QueryOperation_Wrapper(queryOperation));
}
void ParseAsync(const Nan::FunctionCallbackInfo<Value> &args) {
Isolate *isolate = args.GetIsolate();
int args_length = args.Length();
if (args_length < 2) {
isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "Wrong number of arguments")));
return;
}
Local<Value> input = args[0];
if (!ValidateInput(input, isolate)) {
return;
}
if (!args[1]->IsFunction()) {
isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "Second parameter must be a callback")));
return;
}
Nan::Callback *callback = new Nan::Callback(args[1].As<Function>());
anitomyJs::Worker *worker = new anitomyJs::Worker(callback);
if (args_length >= 3) {
Local<Value> options = args[2];
if (!ValidateOptions(options, isolate) ||
!worker->GetAnitomy()->SetOptions(options->ToObject(isolate->GetCurrentContext()).ToLocalChecked(), isolate)) {
return;
}
}
worker->GetAnitomy()->SetInput(input, isolate);
Nan::AsyncQueueWorker(worker);
args.GetReturnValue().Set(Nan::Undefined());
}
void ParseSync(const Nan::FunctionCallbackInfo<Value> &args) {
Isolate *isolate = args.GetIsolate();
int args_length = args.Length();
if (args_length < 1) {
isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate, "Wrong number of arguments")));
return;
}
Local<Value> input = args[0];
if (!ValidateInput(input, isolate)) {
return;
}
anitomyJs::AnitomyJs anitomy;
if (args_length >= 2) {
Local<Value> options = args[1];
if (!ValidateOptions(options, isolate) ||
!anitomy.SetOptions(options->ToObject(isolate->GetCurrentContext()).ToLocalChecked(), isolate)) {
return;
}
}
anitomy.SetInput(input, isolate);
anitomy.Parse();
args.GetReturnValue().Set(anitomy.ParsedResult(isolate));
}
getdns_list* GNUtil::convertToList(Local<Array> array) {
uint32_t len = array->Length();
getdns_list* result = getdns_list_create();
for (uint32_t i = 0; i < len; ++i) {
size_t idx = getdns_list_get_length(result, &idx);
Local<Value> val = array->Get(i);
GetdnsType type = getGetdnsType(val);
switch (type) {
case IntType:
getdns_list_set_int(result, idx, val->ToUint32()->Value());
break;
case BoolType:
if (val->IsTrue()) {
getdns_list_set_int(result, idx, GETDNS_EXTENSION_TRUE);
} else {
getdns_list_set_int(result, idx, GETDNS_EXTENSION_FALSE);
}
break;
case StringType:
{
struct getdns_bindata strdata;
String::Utf8Value utf8Str(val->ToString());
int len = utf8Str.length();
strdata.data = (uint8_t*) *utf8Str;
strdata.size = len;
getdns_list_set_bindata(result, idx, &strdata);
}
break;
case BinDataType:
{
struct getdns_bindata bdata;
bdata.data = (uint8_t*) node::Buffer::Data(val);
bdata.size = node::Buffer::Length(val);
getdns_list_set_bindata(result, idx, &bdata);
}
break;
case ListType:
{
Local<Array> subArray = Local<Array>::Cast(val);
struct getdns_list* sublist = GNUtil::convertToList(subArray);
getdns_list_set_list(result, idx, sublist);
getdns_list_destroy(sublist);
}
break;
case DictType:
{
Local<Object> subObj = val->ToObject();
struct getdns_dict* subdict = GNUtil::convertToDict(subObj);
if (subdict) {
getdns_list_set_dict(result, idx, subdict);
getdns_dict_destroy(subdict);
}
}
break;
default:
break;
}
}
return result;
}
const NdbQueryOperationDef * createNextLevel(QueryOperation *queryOp,
Handle<Object> spec,
const NdbQueryOperationDef * parent) {
NdbQueryBuilder *builder = queryOp->getBuilder();
/* Pull values out of the JavaScript object */
Local<Value> v;
const NdbDictionary::Table * table = 0;
const NdbDictionary::Index * index = 0;
int depth = spec->Get(K_depth)->Int32Value();
DEBUG_PRINT("Creating QueryOperationDef at level %d",depth);
v = spec->Get(K_tableHandler);
if(v->IsObject()) {
v = v->ToObject()->Get(K_dbTable);
if(v->IsObject()) {
table = unwrapPointer<const NdbDictionary::Table *>(v->ToObject());
}
}
bool isPrimaryKey = spec->Get(K_isPrimaryKey)->BooleanValue();
if(! isPrimaryKey) {
v = spec->Get(K_indexHandler);
if(v->IsObject()) {
v = v->ToObject()->Get(K_dbIndex);
if(v->IsObject()) {
index = unwrapPointer<const NdbDictionary::Index *> (v->ToObject());
}
}
assert(index);
}
v = spec->Get(K_joinTo);
Local<Array> joinColumns = Array::Cast(*v);
/* Build the key */
int nKeyParts = joinColumns->Length();
const NdbQueryOperand * key_parts[nKeyParts+1];
for(int i = 0 ; i < nKeyParts ; i++) {
String::AsciiValue column_name(joinColumns->Get(i));
key_parts[i] = builder->linkedValue(parent, *column_name);
}
key_parts[nKeyParts] = 0;
return queryOp->defineOperation(index, table, key_parts);
}
void DBOperationHelper_NonVO(Handle<Object> spec, KeyOperation & op) {
HandleScope scope;
Local<Value> v;
Local<Object> o;
setKeysInOp(spec, op);
v = spec->Get(HELPER_ROW_BUFFER);
if(! v->IsNull()) {
o = v->ToObject();
op.row_buffer = V8BINDER_UNWRAP_BUFFER(o);
}
v = spec->Get(HELPER_ROW_RECORD);
if(! v->IsNull()) {
o = v->ToObject();
const Record * record = unwrapPointer<const Record *>(o);
op.row_record = record;
v = spec->Get(HELPER_BLOBS);
if(v->IsObject()) {
if(op.opcode == 1) {
createBlobReadHandles(v->ToObject(), record, op);
} else {
createBlobWriteHandles(v->ToObject(), record, op);
}
}
}
v = spec->Get(HELPER_LOCK_MODE);
if(! v->IsNull()) {
int intLockMode = v->Int32Value();
op.lmode = static_cast<NdbOperation::LockMode>(intLockMode);
}
v = spec->Get(HELPER_COLUMN_MASK);
if(! v->IsNull()) {
Array *maskArray = Array::Cast(*v);
for(unsigned int m = 0 ; m < maskArray->Length() ; m++) {
Local<Value> colId = maskArray->Get(m);
op.useColumn(colId->Int32Value());
}
}
DEBUG_PRINT("Non-VO opcode: %d mask: %u", op.opcode, op.u.maskvalue);
}
txn_scope(Local<Value> arg, MDB_env *env) : _env(NULL), _txn(NULL), _readonly(false), _created(false), _commit(false) {
if (arg->IsObject()) {
_txn = node::ObjectWrap::Unwrap<txn>(arg->ToObject())->_txn;
} else {
_created = true;
mdb_txn_begin(env, NULL, 0, &_txn);
}
}
void PDFPageDriver::SetMediaBox(Local<String> property,Local<Value> value,const AccessorInfo &info)
{
HandleScope scope;
PDFPageDriver* pageDriver = ObjectWrap::Unwrap<PDFPageDriver>(info.Holder());
if(!value->IsArray())
ThrowException(Exception::TypeError(String::New("Media box is set to a value which is not a 4 numbers array")));
if(value->ToObject()->Get(v8::String::New("length"))->ToObject()->Uint32Value() != 4)
ThrowException(Exception::TypeError(String::New("Media box is set to a value which is not a 4 numbers array")));
pageDriver->mPDFPage->SetMediaBox(PDFRectangle(value->ToObject()->Get(0)->ToNumber()->Value(),
value->ToObject()->Get(1)->ToNumber()->Value(),
value->ToObject()->Get(2)->ToNumber()->Value(),
value->ToObject()->Get(3)->ToNumber()->Value()));
}
void setKeysInOp(Handle<Object> spec, Operation & op) {
HandleScope scope;
Local<Value> v;
Local<Object> o;
v = spec->Get(HELPER_KEY_BUFFER);
if(! v->IsNull()) {
o = v->ToObject();
op.key_buffer = V8BINDER_UNWRAP_BUFFER(o);
}
v = spec->Get(HELPER_KEY_RECORD);
if(! v->IsNull()) {
o = v->ToObject();
op.key_record = unwrapPointer<const Record *>(o);
}
}
Local<Object>
Array::CloneElementAt(JSUint32 index)
{
Local<Value> toBeCloned = Get(index);
if (!toBeCloned->IsObject()) {
return Local<Object>();
}
return toBeCloned->ToObject()->Clone();
}
txn_scope(Local<Value> arg, env *env) : _env(env), _txn(NULL), _readonly(true), _created(false), _commit(false) {
if (arg->IsObject()) {
_txn = node::ObjectWrap::Unwrap<txn>(arg->ToObject())->_txn;
}
else {
_created = true;
_txn = env->require_readlock();
}
}
Handle<Value> DBOperationHelper_NonVO(const Arguments &args) {
HandleScope scope;
Operation op;
const Local<Object> spec = args[0]->ToObject();
Local<Value> v;
Local<Object> o;
setKeysInOp(spec, op);
v = spec->Get(HELPER_ROW_BUFFER);
if(! v->IsNull()) {
o = v->ToObject();
op.row_buffer = V8BINDER_UNWRAP_BUFFER(o);
}
v = spec->Get(HELPER_ROW_RECORD);
if(! v->IsNull()) {
o = v->ToObject();
op.row_record = unwrapPointer<const Record *>(o);
}
v = spec->Get(HELPER_LOCK_MODE);
if(! v->IsNull()) {
int intLockMode = v->Int32Value();
op.lmode = static_cast<NdbOperation::LockMode>(intLockMode);
}
v = spec->Get(HELPER_COLUMN_MASK);
if(! v->IsNull()) {
Array *maskArray = Array::Cast(*v);
for(unsigned int m = 0 ; m < maskArray->Length() ; m++) {
Local<Value> colId = maskArray->Get(m);
op.useColumn(colId->Int32Value());
}
}
int opcode = args[1]->Int32Value();
NdbTransaction *tx = unwrapPointer<NdbTransaction *>(args[2]->ToObject());
DEBUG_PRINT("Non-VO opcode: %d mask: %u", opcode, op.u.maskvalue);
return scope.Close(buildNdbOperation(op, opcode, tx));
}
void Mutate(const FunctionCallbackInfo<Value>& args) {
Isolate * isolate = args.GetIsolate();
Local<Object> target = Local<Object>::New(isolate, persist);
Local<String> key = String::NewFromUtf8(isolate, "x");
// pull the current value of prop x out of the object
double current = target->ToObject()->Get(key)->NumberValue();
// increment prop x by 42
target->Set(key, Number::New(isolate, current + 42));
}
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();
}
Handle<Value> CreateExternalArrayBuffer(Local<Value> ba) {
Handle<Value> buffer;
Bytes *bytes = BYTES_FROM_BIN(ba->ToObject());
ASSERT_PIN(bytes, "Cannot create an external buffer from an invalid Bytes object");
bytes->setResizable(false);
buffer = CreateExternalArrayBuffer(bytes->getLength(), bytes->getBytes());
buffer->ToObject()->SetHiddenValue(String::New(kRefByteArrayPropName), ba);
buffer->ToObject()->Set(String::New("externalBuffer"), True(), ReadOnly);
return buffer;
}
void
encodeObjectID(bson_buffer *bb, const char *name, const Local<Value> element) {
// get at the delicious wrapped object centre
Local<Object> obj = element->ToObject();
assert(!obj.IsEmpty());
assert(obj->InternalFieldCount() > 0);
ObjectID *o = static_cast<ObjectID*>(Handle<External>::Cast(
obj->GetInternalField(0))->Value());
bson_oid_t oid;
char oid_hex[25];
o->str(oid_hex);
bson_oid_from_string(&oid, oid_hex);
bson_append_oid(bb, name, &oid);
}
void ReportException(TryCatch &try_catch, bool show_line, std::string& err_msg) {
HandleScope scope;
if (show_line) DisplayExceptionLine(try_catch, err_msg);
String::Utf8Value trace(try_catch.StackTrace());
// range errors have a trace member set to undefined
if (trace.length() > 0 && !try_catch.StackTrace()->IsUndefined()) {
fprintf(stderr, "%s\n", *trace);
err_msg += *trace;
err_msg += "\n";
} else {
// this really only happens for RangeErrors, since they're the only
// kind that won't have all this info in the trace, or when non-Error
// objects are thrown manually.
Local<Value> er = try_catch.Exception();
bool isErrorObject = er->IsObject() &&
!(er->ToObject()->Get(String::New("message"))->IsUndefined()) &&
!(er->ToObject()->Get(String::New("name"))->IsUndefined());
if (isErrorObject) {
String::Utf8Value name(er->ToObject()->Get(String::New("name")));
fprintf(stderr, "%s: ", *name);
err_msg += *name;
err_msg += ": ";
}
String::Utf8Value msg(!isErrorObject ? er
: er->ToObject()->Get(String::New("message")));
fprintf(stderr, "%s\n", *msg);
err_msg += *msg;
err_msg += "\n";
}
fflush(stderr);
}
bson encodeObject(const Local<Value> element) {
HandleScope scope;
bson_buffer bb;
bson_buffer_init(&bb);
Local<Object> object = element->ToObject();
Local<Array> properties = object->GetPropertyNames();
for (int i = 0; i < properties->Length(); i++) {
// get the property name and value
Local<Value> prop_name = properties->Get(Integer::New(i));
Local<Value> prop_val = object->Get(prop_name->ToString());
// convert the property name to a c string
String::Utf8Value n(prop_name);
const char *pname = ToCString(n);
// append property using appropriate appender
if (prop_val->IsString()) {
encodeString(&bb, pname, prop_val);
}
else if (prop_val->IsInt32()) {
encodeInteger(&bb, pname, prop_val);
}
else if (prop_val->IsNumber()) {
encodeNumber(&bb, pname, prop_val);
}
else if (prop_val->IsBoolean()) {
encodeBoolean(&bb, pname, prop_val);
}
else if (prop_val->IsArray()) {
encodeArray(&bb, pname, prop_val);
}
else if (prop_val->IsObject()
&& ObjectID::constructor_template->HasInstance(prop_val)) {
encodeObjectID(&bb, pname, prop_val);
}
else if (prop_val->IsObject()) {
bson bson(encodeObject(prop_val));
bson_append_bson(&bb, pname, &bson);
bson_destroy(&bson);
}
}
bson bson;
bson_from_buffer(&bson, &bb);
return bson;
}
void
Image::SetSource(Local<String>, Local<Value> val, const AccessorInfo &info) {
HandleScope scope;
Image *img = ObjectWrap::Unwrap<Image>(info.This());
cairo_status_t status = CAIRO_STATUS_READ_ERROR;
// url string
if (val->IsString()) {
String::AsciiValue src(val);
if (img->filename) free(img->filename);
img->filename = strdup(*src);
// status = img->load();
// Load from assets directory
uint8_t* buf;
int len;
JSG::loadAsset(img->filename, (unsigned char**) &buf, &len);
if (buf) {
status = img->loadFromBuffer(buf, len);
free(buf);
}
// Buffer
} else if (Buffer::HasInstance(val)) {
uint8_t *buf = (uint8_t *) Buffer::Data(val->ToObject());
unsigned len = Buffer::Length(val->ToObject());
status = img->loadFromBuffer(buf, len);
}
// check status
if (status) {
img->error(Canvas::Error(status));
} else {
img->loaded();
}
}
Handle<Value> PDFPageDriver::NewInstance(PDFPage* inPage)
{
HandleScope scope;
Local<Object> instance;
Handle<Value> argv[1] = {Boolean::New(false)};
instance = constructor->NewInstance(1,argv);
// this version links to a page and does not own it!
PDFPageDriver* driver = ObjectWrap::Unwrap<PDFPageDriver>(instance->ToObject());
driver->mPDFPage = inPage;
driver->mOwnsPage = false;
return scope.Close(instance);
}
void TiRootObject::createStringMethods()
{
Local<Value> str = context_->Global()->Get(String::New("String"));
if (!str->IsObject())
{
// This should never happen
ThrowException(String::New(Ti::Msg::INTERNAL__Global_String_symbol_is_not_an_object));
}
Local<Object> strObj = str->ToObject();
const NativeStringInterface* nsi = objectFactory_->getNativeStringInterface();
strObj->Set(String::New("format"), FunctionTemplate::New(nsi->format)->GetFunction());
strObj->Set(String::New("formatCurrency"), FunctionTemplate::New(nsi->formatCurrency)->GetFunction());
strObj->Set(String::New("formatDate"), FunctionTemplate::New(nsi->formatDate)->GetFunction());
strObj->Set(String::New("formatDecimal"), FunctionTemplate::New(nsi->formatDecimal)->GetFunction());
strObj->Set(String::New("formatTime"), FunctionTemplate::New(nsi->formatTime)->GetFunction());
}
void Geometry::srsSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
HandleScope scope;
Geometry *geom = ObjectWrap::Unwrap<Geometry>(info.This());
OGRSpatialReference *srs = NULL;
if (SpatialReference::constructor->HasInstance(value)) {
SpatialReference *srs_obj = ObjectWrap::Unwrap<SpatialReference>(value->ToObject());
srs = srs_obj->get();
} else if (!value->IsNull() && !value->IsUndefined()) {
NODE_THROW("srs must be SpatialReference object");
return;
}
geom->this_->assignSpatialReference(srs);
}
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 Local<Value> convertType(TiAppPropertiesObject::PropertyType type, Local<Value> value) {
switch (type) {
case TiAppPropertiesObject::BoolProperty:
return value->ToBoolean();
case TiAppPropertiesObject::DoubleProperty:
case TiAppPropertiesObject::IntProperty:
return value->ToNumber();
case TiAppPropertiesObject::ObjectProperty:
return value->ToObject();
case TiAppPropertiesObject::ListProperty:
return value;
case TiAppPropertiesObject::StringProperty:
return value->ToString();
default:
return Local<Value>();
}
}
MarkderDetectionTask(Local<Value> imageBuffer, Local<Value> callback)
: m_imageProcessed(false)
{
HandleScope scope;
Local<Object> imageBufferObject = Local<Object>::New(imageBuffer->ToObject());
m_callback = Persistent<Function>::New(Handle<Function>::Cast(callback));
char * bufferData = Buffer::Data(imageBufferObject);
size_t bufferLength = Buffer::Length(imageBufferObject);
m_imageData = std::vector<char>(bufferData, bufferData + bufferLength);
// This creates the work request struct.
m_request = new uv_work_t();
m_request->data = this;
}