static gboolean
gum_v8_exception_handler_on_exception (GumExceptionDetails * details,
gpointer user_data)
{
GumV8ExceptionHandler * handler = (GumV8ExceptionHandler *) user_data;
GumV8Core * core = handler->core;
ScriptScope scope (core->script);
Isolate * isolate = core->isolate;
Local<Function> callback (Local<Function>::New (isolate, *handler->callback));
Local<Object> ex, context;
_gum_v8_parse_exception_details (details, ex, context, core);
Handle<Value> argv[] = { ex };
Local<Value> result = callback->Call (Null (isolate), 1, argv);
_gum_v8_cpu_context_free_later (
new GumPersistent<Object>::type (isolate, context),
core);
if (!result.IsEmpty () && result->IsBoolean ())
{
bool handled = result.As<Boolean> ()->Value ();
return handled ? TRUE : FALSE;
}
return FALSE;
}
static gboolean
gum_v8_module_filter_matches (const GumModuleDetails * details,
GumV8ModuleFilter * self)
{
auto core = self->module->core;
auto isolate = core->isolate;
auto context = isolate->GetCurrentContext ();
auto module = _gum_v8_module_value_new (details, self->module);
auto callback (Local<Function>::New (isolate, *self->callback));
auto recv = Undefined (isolate);
Handle<Value> argv[] = { module };
Local<Value> result;
if (callback->Call (context, recv, G_N_ELEMENTS (argv), argv)
.ToLocal (&result))
{
return result->IsBoolean () && result.As<Boolean> ()->Value ();
}
else
{
core->current_scope->ProcessAnyPendingException ();
return FALSE;
}
}
void
encodeArray(bson_buffer *bb, const char *name, const Local<Value> element) {
Local<Array> a = Array::Cast(*element);
bson_buffer *arr = bson_append_start_array(bb, name);
for (int i = 0, l=a->Length(); i < l; i++) {
Local<Value> val = a->Get(Number::New(i));
stringstream keybuf;
string keyval;
keybuf << i << endl;
keybuf >> keyval;
if (val->IsString()) {
encodeString(arr, keyval.c_str(), val);
}
else if (val->IsInt32()) {
encodeInteger(arr, keyval.c_str(), val);
}
else if (val->IsNumber()) {
encodeNumber(arr, keyval.c_str(), val);
}
else if (val->IsBoolean()) {
encodeBoolean(arr, keyval.c_str(), val);
}
else if (val->IsArray()) {
encodeArray(arr, keyval.c_str(), val);
}
else if (val->IsObject()) {
bson bson(encodeObject(val));
bson_append_bson(arr, keyval.c_str(), &bson);
bson_destroy(&bson);
}
}
bson_append_finish_object(arr);
}
void Toggle::ActiveSetter(Local<String> name, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
if (value->IsBoolean()) {
ClutterActor *instance = ObjectWrap::Unwrap<Toggle>(info.This())->_actor;
mx_toggle_set_active(MX_TOGGLE(instance), value->ToBoolean()->Value());
}
}
void FeatureDefn::geomIgnoredSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
HandleScope scope;
FeatureDefn *def = ObjectWrap::Unwrap<FeatureDefn>(info.This());
if(!value->IsBoolean()){
NODE_THROW("geomIgnored must be a boolean");
return;
}
def->this_->SetGeometryIgnored(value->IntegerValue());
}
void BoxLayout::EnableAnimationsSetter(Local<String> name, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
if (value->IsBoolean()) {
ClutterActor *instance = ObjectWrap::Unwrap<BoxLayout>(info.This())->_actor;
mx_box_layout_set_enable_animations(MX_BOX_LAYOUT(instance), value->ToBoolean()->Value());
}
}
void FieldDefn::ignoredSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
HandleScope scope;
FieldDefn *def = ObjectWrap::Unwrap<FieldDefn>(info.This());
if(!value->IsBoolean()){
NODE_THROW("ignored must be a boolean");
return;
}
def->this_->SetIgnored(value->BooleanValue());
}
void Widget::DisabledSetter(Local<String> name, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
if (value->IsBoolean()) {
ClutterActor *instance = ObjectWrap::Unwrap<Actor>(info.This())->_actor;
mx_widget_set_disabled(MX_WIDGET(instance), value->ToBoolean()->Value());
}
}
void BoxLayout::ScrollToFocusedSetter(Local<String> name, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
if (value->IsBoolean()) {
ClutterActor *instance = ObjectWrap::Unwrap<BoxLayout>(info.This())->_actor;
mx_box_layout_set_scroll_to_focused(MX_BOX_LAYOUT(instance), value->ToBoolean()->Value());
}
}
void Texture::RepeatYSetter(Local<String> name, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
if (value->IsBoolean()) {
ClutterActor *instance = ObjectWrap::Unwrap<Actor>(info.This())->_actor;
g_object_set(G_OBJECT(instance), "repeat-y", value->ToBoolean()->Value(), NULL);
}
}
void Msg_Struct::build_http_msg_buffer(Isolate* isolate, v8::Local<v8::Object> object, std::string &str) {
std::stringstream stream;
for(std::vector<Field_Info>::const_iterator iter = field_vec().begin();
iter != field_vec().end(); iter++) {
stream.str("");
stream << "\"" << iter->field_name << "\":";
Local<Value> value = object->Get(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, iter->field_name.c_str(), NewStringType::kNormal).ToLocalChecked()).ToLocalChecked();
if(iter->field_type == "int8" || iter->field_type == "int16" ||
iter->field_type == "int32") {
int32_t val = 0;
if (value->IsInt32()) {
val = value->Int32Value(isolate->GetCurrentContext()).FromJust();
}
stream << val << ",";
}
else if(iter->field_type == "int64") {
int64_t val = 0;
if (value->IsNumber()) {
val = value->NumberValue(isolate->GetCurrentContext()).FromJust();
}
stream << val << ",";
}
else if(iter->field_type == "double") {
double val = 0;
if (value->IsNumber()) {
val = value->NumberValue(isolate->GetCurrentContext()).FromJust();
}
stream << val << ",";
}
else if(iter->field_type == "bool") {
bool val = 0;
if (value->IsBoolean()) {
val = value->BooleanValue(isolate->GetCurrentContext()).FromJust();
}
stream << val << ",";
}
else if(iter->field_type == "string") {
if (value->IsString()) {
String::Utf8Value str(value->ToString(isolate->GetCurrentContext()).ToLocalChecked());
stream << "\"" << ToCString(str) << "\",";
} else {
stream << "\"\",";
}
}
else {
LOG_ERROR("Can not find the field_type:%s, struct_name:%s", iter->field_type.c_str(), struct_name().c_str());
}
str += stream.str();
}
}
static void Set_FontState_strikeOut(Local<String> property, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
Local<Object> self = info.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
if (wrap.IsEmpty())
return;
FontState *tmp = (FontState *) wrap->Value();
if (tmp == NULL)
return;
if (!value.IsEmpty() && value->IsBoolean())
tmp->setStrikeOut(value->BooleanValue());
}
bool JSWrapper::execute( const char *scr, JSWrapperData *data, const char *fileName )
{
HandleScope handle_scope( m_isolate );
Local<String> source = String::NewFromUtf8( m_isolate, scr, NewStringType::kNormal ).ToLocalChecked();
ScriptOrigin origin( v8::String::NewFromUtf8( m_isolate, fileName ? fileName : "Unknown" ) );
MaybeLocal<Script> maybeScript = Script::Compile( m_context, source, &origin );
bool success=false;
if ( !maybeScript.IsEmpty() )
{
Local<Script> script = maybeScript.ToLocalChecked();
MaybeLocal<Value> maybeResult = script->Run(m_context);
if ( !maybeResult.IsEmpty() )
{
Local<Value> result = maybeResult.ToLocalChecked();
if ( data )
{
if ( result->IsNumber() )
data->setNumber( result->ToNumber()->Value() );
else
if ( result->IsString() )
{
String::Utf8Value utf8( result );
data->setString( *utf8 );
} else
if ( result->IsBoolean() )
data->setBoolean( result->ToBoolean()->Value() );
else
if ( result->IsObject() )
data->setObject( new JSWrapperObject( m_isolate, result->ToObject() ) );
else
if ( result->IsNull() )
data->setNull();
else data->setUndefined();
}
success=true;
}
}
return success;
}
static GetdnsType getGetdnsType(Local<Value> value) {
if (value->IsNumber() || value->IsNumberObject()) {
return IntType;
} else if (value->IsBoolean() || value->IsBooleanObject()) {
return BoolType;
} else if (value->IsString() || value->IsStringObject()) {
return StringType;
} else if (value->IsObject()) {
// could be a node buffer or array
if (node::Buffer::HasInstance(value)) {
return BinDataType;
} else if (value->IsArray()) {
return ListType;
} else if (GNUtil::isDictionaryObject(value)) {
return DictType;
}
}
return UnknownType;
}
void ScrollView::PolicyVerticalSetter(Local<String> name, Local<Value> value, const AccessorInfo& info)
{
HandleScope scope;
MxScrollPolicy policy;
if (value->IsBoolean()) {
ClutterActor *instance = ObjectWrap::Unwrap<ScrollView>(info.This())->_actor;
policy = mx_scroll_view_get_scroll_policy(MX_SCROLL_VIEW(instance));
if (value->ToBoolean()->Value()) {
if (policy == MX_SCROLL_POLICY_HORIZONTAL)
mx_scroll_view_set_scroll_policy(MX_SCROLL_VIEW(instance), MX_SCROLL_POLICY_BOTH);
else if (policy == MX_SCROLL_POLICY_NONE)
mx_scroll_view_set_scroll_policy(MX_SCROLL_VIEW(instance), MX_SCROLL_POLICY_VERTICAL);
} else {
if (policy == MX_SCROLL_POLICY_VERTICAL)
mx_scroll_view_set_scroll_policy(MX_SCROLL_VIEW(instance), MX_SCROLL_POLICY_NONE);
else if (policy == MX_SCROLL_POLICY_BOTH)
mx_scroll_view_set_scroll_policy(MX_SCROLL_VIEW(instance), MX_SCROLL_POLICY_HORIZONTAL);
}
}
}
/**
0 - namespace
1 - query
2 - fields
3 - limit
4 - skip
*/
Handle<Value> mongoFind(const Arguments& args){
jsassert( args.Length() == 5 , "find needs 5 args" );
jsassert( args[1]->IsObject() , "needs to be an object" );
DBClientConnection * conn = getConnection( args );
GETNS;
BSONObj q = v8ToMongo( args[1]->ToObject() );
DDD( "query:" << q );
BSONObj fields;
bool haveFields = args[2]->IsObject() && args[2]->ToObject()->GetPropertyNames()->Length() > 0;
if ( haveFields )
fields = v8ToMongo( args[2]->ToObject() );
Local<v8::Object> mongo = args.This();
Local<v8::Value> slaveOkVal = mongo->Get( String::New( "slaveOk" ) );
jsassert( slaveOkVal->IsBoolean(), "slaveOk member invalid" );
bool slaveOk = slaveOkVal->BooleanValue();
try {
auto_ptr<mongo::DBClientCursor> cursor;
int nToReturn = (int)(args[3]->ToNumber()->Value());
int nToSkip = (int)(args[4]->ToNumber()->Value());
{
v8::Unlocker u;
cursor = conn->query( ns, q , nToReturn , nToSkip , haveFields ? &fields : 0, slaveOk ? Option_SlaveOk : 0 );
}
v8::Function * cons = (v8::Function*)( *( mongo->Get( String::New( "internalCursor" ) ) ) );
Local<v8::Object> c = cons->NewInstance();
// NOTE I don't believe the cursor object will ever be freed.
c->Set( v8::String::New( "cursor" ) , External::New( cursor.release() ) );
return c;
}
catch ( ... ){
return v8::ThrowException( v8::String::New( "socket error on query" ) );
}
}
void setFlagFromValue(int *flags, int flag, const char *name, bool defaultValue, Local<Object> options) {
Local<Value> opt = options->Get(Nan::New<String>(name).ToLocalChecked());
if (opt->IsBoolean() ? opt->BooleanValue() : defaultValue) {
*flags |= flag;
}
}
bool CQueryParameter::TransformParameter( Isolate* isolate, Local< Value > value, sBindParameter** pOutParam )
{
HandleScope scope( isolate );
Local< Context > context = isolate->GetCurrentContext( );
sBindParameter* pParameter = *pOutParam;
if( value->IsNull( ) )
{
pParameter->SetNull( );
}
else if( value->IsString( ) )
{
pParameter->SetString( value.As<String>( ) );
}
else if( value->IsBoolean( ) )
{
pParameter->SetBool( value->BooleanValue( context ).FromJust( ) );
}
else if( value->IsInt32( ) )
{
pParameter->SetInt( value->Int32Value( context ).FromJust( ) );
}
else if( value->IsUint32( ) )
{
pParameter->SetUInt( value->Uint32Value( context ).FromJust( ) );
}
else if( value->IsNumber( ) )
{
double d = value->NumberValue( context ).FromJust( );
if( _isnan( d ) || !_finite( d ) )
{
return false;
}
else if( d == floor( d ) &&
d >= std::numeric_limits<int64_t>::min( ) &&
d <= std::numeric_limits<int64_t>::max( )
)
{
pParameter->SetInt64( value->IntegerValue( context ).FromJust( ) );
}
else
{
pParameter->SetDouble( value->NumberValue( context ).FromJust( ) );
}
}
else if( value->IsDate( ) )
{
Local<Date> dateObject = value.As<Date>( );
pParameter->SetDate( dateObject->NumberValue( context ).FromJust( ) );
}
else if( value->IsObject( ) )
{
Local<Object> objValue = value.As<Object>( );
if( node::Buffer::HasInstance( value ) )
{
pParameter->SetBuffer( isolate, objValue );
}
else
{
Local< String > strId = String::NewFromUtf8( isolate, "_objId", NewStringType::kNormal ).ToLocalChecked( );
if( objValue->HasRealNamedProperty( context, strId ).FromJust( ) )
{
Local< Uint32 > numTypeId = objValue->Get( context, strId ).ToLocalChecked( ).As< Uint32 >( );
uint32_t nType = numTypeId->Int32Value( context ).FromJust( );
switch( nType )
{
case ID_INPUT_STREAM:
{
Local<Value> type = objValue->Get(
context, String::NewFromUtf8( isolate, "type", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> stream = objValue->Get(
context, String::NewFromUtf8( isolate, "stream", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> length = objValue->Get(
context, String::NewFromUtf8( isolate, "length", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
pParameter->SetStream( isolate, type->Uint32Value( context ).FromJust( ), stream, static_cast< SQLUINTEGER >( length->IntegerValue( context ).FromJust( ) ) );
break;
}
case ID_NUMERIC_VALUE:
{
Local< Value > precision = objValue->Get(
context, String::NewFromUtf8( isolate, "precision", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> scale = objValue->Get(
context, String::NewFromUtf8( isolate, "scale", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> sign = objValue->Get(
context, String::NewFromUtf8( isolate, "sign", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> value = objValue->Get(
context, String::NewFromUtf8( isolate, "value", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local< Uint32 > numPrecision = precision.As<Uint32>( );
Local< Uint32 > numScale = scale.As<Uint32>( );
Local< Boolean > boolSign = sign.As<Boolean>( );
Local< ArrayBuffer > arrBuffer = ( value.As<Uint8Array>( ) )->Buffer( );
ArrayBuffer::Contents contents = arrBuffer->GetContents( );
if( contents.ByteLength( ) > SQL_MAX_NUMERIC_LEN )
{
return false;
}
pParameter->SetNumeric( numPrecision->Uint32Value( context ).FromJust( ),
numScale->Uint32Value( context ).FromJust( ),
boolSign->BooleanValue( context ).FromJust( ),
contents.Data( ),
contents.ByteLength( )
);
break;
}
default:
{
return false;
}
}
}
else
{
return false;
}
}
}
else
{
return false;
}
return true;
}
Handle<Value>
Session::Request(const Arguments& args)
{
HandleScope scope;
if (args.Length() < 1 || !args[0]->IsString()) {
return ThrowException(Exception::Error(String::New(
"Service URI string must be provided as first parameter.")));
}
if (args.Length() < 2 || !args[1]->IsString()) {
return ThrowException(Exception::Error(String::New(
"String request name must be provided as second parameter.")));
}
if (args.Length() < 3 || !args[2]->IsObject()) {
return ThrowException(Exception::Error(String::New(
"Object containing request parameters must be provided "
"as third parameter.")));
}
if (args.Length() < 4 || !args[3]->IsInt32()) {
return ThrowException(Exception::Error(String::New(
"Integer correlation identifier must be provided "
"as fourth parameter.")));
}
if (args.Length() >= 5 && !args[4]->IsUndefined() && !args[4]->IsString()) {
return ThrowException(Exception::Error(String::New(
"Optional request label must be a string.")));
}
if (args.Length() > 5) {
return ThrowException(Exception::Error(String::New(
"Function expects at most five arguments.")));
}
int cidi = args[3]->Int32Value();
Session* session = ObjectWrap::Unwrap<Session>(args.This());
BLPAPI_EXCEPTION_TRY
Local<String> uri = args[0]->ToString();
String::AsciiValue uriv(uri);
blpapi::Service service = session->d_session->getService(*uriv);
Local<String> name = args[1]->ToString();
String::Utf8Value namev(name);
blpapi::Request request = service.createRequest(*namev);
// Loop over object properties, appending/setting into the request.
Local<Object> obj = args[2]->ToObject();
Local<Array> props = obj->GetPropertyNames();
for (std::size_t i = 0; i < props->Length(); ++i) {
// Process the key.
Local<Value> keyval = props->Get(i);
Local<String> key = keyval->ToString();
String::Utf8Value keyv(key);
// Process the value.
//
// The values present on the outer object are marshalled into the
// blpapi::Request by setting values using 'set'. Arrays indicate
// values which should be marshalled using 'append'.
Local<Value> val = obj->Get(keyval);
if (val->IsString()) {
Local<String> s = val->ToString();
String::Utf8Value valv(s);
request.set(*keyv, *valv);
} else if (val->IsBoolean()) {
request.set(*keyv, val->BooleanValue());
} else if (val->IsNumber()) {
request.set(*keyv, val->NumberValue());
} else if (val->IsInt32()) {
request.set(*keyv, val->Int32Value());
} else if (val->IsUint32()) {
request.set(*keyv,
static_cast<blpapi::Int64>(val->Uint32Value()));
} else if (val->IsDate()) {
blpapi::Datetime dt;
mkdatetime(&dt, val);
request.set(*keyv, dt);
} else if (val->IsArray()) {
// Arrays are marshalled into the blpapi::Request by appending
// value types using the key of the array in the outer object.
Local<Object> subarray = val->ToObject();
int jmax = Array::Cast(*val)->Length();
for (int j = 0; j < jmax; ++j) {
Local<Value> subval = subarray->Get(j);
// Only strings, booleans, and numbers are marshalled.
if (subval->IsString()) {
Local<String> s = subval->ToString();
String::Utf8Value subvalv(s);
request.append(*keyv, *subvalv);
} else if (subval->IsBoolean()) {
request.append(*keyv, subval->BooleanValue());
} else if (subval->IsNumber()) {
request.append(*keyv, subval->NumberValue());
} else if (subval->IsInt32()) {
request.append(*keyv, subval->Int32Value());
} else if (subval->IsUint32()) {
request.append(*keyv,
static_cast<blpapi::Int64>(subval->Uint32Value()));
} else if (subval->IsDate()) {
blpapi::Datetime dt;
mkdatetime(&dt, subval);
request.append(*keyv, dt);
} else {
return ThrowException(Exception::Error(String::New(
"Array contains invalid value type.")));
}
}
} else {
return ThrowException(Exception::Error(String::New(
"Object contains invalid value type.")));
}
}
blpapi::CorrelationId cid(cidi);
if (args.Length() == 5) {
String::Utf8Value labelv(args[4]->ToString());
session->d_session->sendRequest(request, session->d_identity,
cid, 0, *labelv, labelv.length());
} else {
session->d_session->sendRequest(request, session->d_identity, cid);
}
BLPAPI_EXCEPTION_CATCH_RETURN
return scope.Close(Integer::New(cidi));
}
Handle<Value> Database::Query(const Arguments& args) {
HandleScope scope;
REQ_STR_ARG(0, sql);
Local<Function> cb;
int paramCount = 0;
Parameter* params;
Database* dbo = ObjectWrap::Unwrap<Database>(args.This());
struct query_request *prep_req = (struct query_request *)
calloc(1, sizeof(struct query_request));
if (!prep_req) {
V8::LowMemoryNotification();
return ThrowException(Exception::Error(String::New("Could not allocate enough memory")));
}
// populate prep_req->params if parameters were supplied
//
if (args.Length() > 2)
{
if ( !args[1]->IsArray() )
{
return ThrowException(Exception::TypeError(
String::New("Argument 1 must be an Array"))
);
}
else if ( !args[2]->IsFunction() )
{
return ThrowException(Exception::TypeError(
String::New("Argument 2 must be a Function"))
);
}
Local<Array> values = Local<Array>::Cast(args[1]);
cb = Local<Function>::Cast(args[2]);
prep_req->paramCount = paramCount = values->Length();
prep_req->params = params = new Parameter[paramCount];
for (int i = 0; i < paramCount; i++)
{
Local<Value> value = values->Get(i);
params[i].size = 0;
params[i].length = NULL;
params[i].buffer_length = 0;
if (value->IsString())
{
String::Utf8Value string(value);
params[i].c_type = SQL_C_CHAR;
params[i].type = SQL_VARCHAR;
params[i].length = SQL_NTS;
params[i].buffer = malloc(string.length() + 1);
params[i].buffer_length = string.length() + 1;
params[i].size = string.length() + 1;
strcpy((char*)params[i].buffer, *string);
}
else if (value->IsNull())
{
params[i].c_type = SQL_C_DEFAULT;
params[i].type = SQL_NULL_DATA;
params[i].length = SQL_NULL_DATA;
}
else if (value->IsInt32())
{
int64_t *number = new int64_t(value->IntegerValue());
params[i].c_type = SQL_C_LONG;
params[i].type = SQL_INTEGER;
params[i].buffer = number;
}
else if (value->IsNumber())
{
double *number = new double(value->NumberValue());
params[i].c_type = SQL_C_DOUBLE;
params[i].type = SQL_DECIMAL;
params[i].buffer = number;
}
else if (value->IsBoolean())
{
bool *boolean = new bool(value->BooleanValue());
params[i].c_type = SQL_C_BIT;
params[i].type = SQL_BIT;
params[i].buffer = boolean;
}
}
}
else
{
if ( !args[1]->IsFunction() )
{
return ThrowException(Exception::TypeError(
String::New("Argument 1 must be a Function"))
);
}
cb = Local<Function>::Cast(args[1]);
prep_req->paramCount = 0;
}
prep_req->sql = (char *) malloc(sql.length() +1);
prep_req->catalog = NULL;
prep_req->schema = NULL;
prep_req->table = NULL;
prep_req->type = NULL;
prep_req->column = NULL;
prep_req->cb = Persistent<Function>::New(cb);
strcpy(prep_req->sql, *sql);
prep_req->dbo = dbo;
eio_custom(EIO_Query, EIO_PRI_DEFAULT, EIO_AfterQuery, prep_req);
ev_ref(EV_DEFAULT_UC);
dbo->Ref();
scope.Close(Undefined());
return Undefined();
}
Parameter* ODBC::GetParametersFromArray (Local<Array> values, int *paramCount) {
DEBUG_PRINTF("ODBC::GetParametersFromArray\n");
*paramCount = values->Length();
Parameter* params = (Parameter *) malloc(*paramCount * sizeof(Parameter));
for (int i = 0; i < *paramCount; i++) {
Local<Value> value = values->Get(i);
params[i].size = 0;
params[i].length = SQL_NULL_DATA;
params[i].buffer_length = 0;
params[i].decimals = 0;
DEBUG_PRINTF("ODBC::GetParametersFromArray - ¶m[%i].length = %X\n",
i, ¶ms[i].length);
if (value->IsString()) {
Local<String> string = value->ToString();
int length = string->Length();
params[i].c_type = SQL_C_TCHAR;
#ifdef UNICODE
params[i].type = (length >= 8000) ? SQL_WLONGVARCHAR : SQL_WVARCHAR;
params[i].buffer_length = (length * sizeof(uint16_t)) + sizeof(uint16_t);
#else
params[i].type = (length >= 8000) ? SQL_LONGVARCHAR : SQL_VARCHAR;
params[i].buffer_length = string->Utf8Length() + 1;
#endif
params[i].buffer = malloc(params[i].buffer_length);
params[i].size = params[i].buffer_length;
params[i].length = SQL_NTS;//params[i].buffer_length;
#ifdef UNICODE
string->Write((uint16_t *) params[i].buffer);
#else
string->WriteUtf8((char *) params[i].buffer);
#endif
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsString(): params[%i] "
"c_type=%i type=%i buffer_length=%i size=%i length=%i "
"value=%s\n", i, params[i].c_type, params[i].type,
params[i].buffer_length, params[i].size, params[i].length,
(char*) params[i].buffer);
}
else if (value->IsNull()) {
params[i].c_type = SQL_C_DEFAULT;
params[i].type = SQL_VARCHAR;
params[i].length = SQL_NULL_DATA;
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsNull(): params[%i] "
"c_type=%i type=%i buffer_length=%i size=%i length=%i\n",
i, params[i].c_type, params[i].type,
params[i].buffer_length, params[i].size, params[i].length);
}
else if (value->IsInt32()) {
int64_t *number = new int64_t(value->IntegerValue());
params[i].c_type = SQL_C_SBIGINT;
params[i].type = SQL_BIGINT;
params[i].buffer = number;
params[i].length = 0;
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsInt32(): params[%i] "
"c_type=%i type=%i buffer_length=%i size=%i length=%i "
"value=%lld\n", i, params[i].c_type, params[i].type,
params[i].buffer_length, params[i].size, params[i].length,
*number);
}
else if (value->IsNumber()) {
double *number = new double(value->NumberValue());
params[i].c_type = SQL_C_DOUBLE;
params[i].type = SQL_DECIMAL;
params[i].buffer = number;
params[i].buffer_length = sizeof(double);
params[i].length = params[i].buffer_length;
params[i].decimals = 7;
params[i].size = sizeof(double);
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsNumber(): params[%i] "
"c_type=%i type=%i buffer_length=%i size=%i length=%i "
"value=%f\n",
i, params[i].c_type, params[i].type,
params[i].buffer_length, params[i].size, params[i].length,
*number);
}
else if (value->IsBoolean()) {
bool *boolean = new bool(value->BooleanValue());
params[i].c_type = SQL_C_BIT;
params[i].type = SQL_BIT;
params[i].buffer = boolean;
params[i].length = 0;
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsBoolean(): params[%i] "
"c_type=%i type=%i buffer_length=%i size=%i length=%i\n",
i, params[i].c_type, params[i].type,
params[i].buffer_length, params[i].size, params[i].length);
}
}
return params;
}
bool JsArgToArrayConverter::ConvertArg(const Local<Value>& arg, int index)
{
bool success = false;
stringstream s;
JEnv env;
Type returnType = JType::getClassType(m_return_type);
if (arg.IsEmpty())
{
s << "Cannot convert empty JavaScript object";
success = false;
}
else if (arg->IsInt32() && (returnType == Type::Int || returnType == Type::Null))
{
jint value = arg->Int32Value();
JniLocalRef javaObject(JType::NewInt(env, value));
SetConvertedObject(env, index, javaObject);
success = true;
}
else if (arg->IsNumber() || arg->IsNumberObject())
{
double d = arg->NumberValue();
int64_t i = (int64_t)d;
bool isInteger = d == i;
if (isInteger)
{
jobject obj;
//if returnType is long it will cast to long
//if there is no return type specified it will cast to int
//because default return type is null (ref type)
if ((INT_MIN <= i) && (i <= INT_MAX) && (returnType == Type::Int || returnType == Type::Null))
{
obj = JType::NewInt(env, (jint)d);
}
else /*isLong*/
{
obj = JType::NewLong(env, (jlong)d);
}
JniLocalRef javaObject(obj);
SetConvertedObject(env, index, javaObject);
success = true;
}
else
{
jobject obj;
//if returnType is double it will cast to double
//if there is no return type specified it will cast to float
//because default return type is null (ref type)
if((FLT_MIN <= d) && (d <= FLT_MAX) && (returnType == Type::Float || returnType == Type::Null)) {
obj = JType::NewFloat(env, (jfloat)d);
}
else {/*isDouble*/
obj = JType::NewDouble(env, (jdouble)d);
}
JniLocalRef javaObject(obj);
SetConvertedObject(env, index, javaObject);
success = true;
}
}
else if (arg->IsBoolean())
{
jboolean value = arg->BooleanValue();
JniLocalRef javaObject(JType::NewBoolean(env, value));
SetConvertedObject(env, index, javaObject);
success = true;
}
else if (arg->IsBooleanObject())
{
auto boolObj = Local<BooleanObject>::Cast(arg);
jboolean value = boolObj->BooleanValue() ? JNI_TRUE : JNI_FALSE;
JniLocalRef javaObject(JType::NewBoolean(env, value));
SetConvertedObject(env, index, javaObject);
success = true;
}
else if (arg->IsString() || arg->IsStringObject())
{
JniLocalRef stringObject(ConvertToJavaString(arg));
SetConvertedObject(env, index, stringObject);
success = true;
}
else if (arg->IsObject())
{
auto objectWithHiddenID = arg->ToObject();
auto hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsLong());
if (!hidden.IsEmpty())
{
jlong value = 0;
if (hidden->IsString())
{
auto strValue = ConvertToString(hidden->ToString());
value = atoll(strValue.c_str());
}
else if (hidden->IsInt32())
{
value = hidden->ToInt32()->Int32Value();
}
JniLocalRef javaObject(JType::NewLong(env, value));
SetConvertedObject(env, index, javaObject);
return true;
}
hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsByte());
if (!hidden.IsEmpty())
{
jbyte value = 0;
if (hidden->IsString())
{
string value = ConvertToString(hidden->ToString());
int byteArg = atoi(value.c_str());
value = (jbyte)byteArg;
}
else if (hidden->IsInt32())
{
int byteArg = hidden->ToInt32()->Int32Value();
value = (jbyte)byteArg;
}
JniLocalRef javaObject(JType::NewByte(env, value));
SetConvertedObject(env, index, javaObject);
return true;
}
hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsShort());
if (!hidden.IsEmpty())
{
jshort value = 0;
if (hidden->IsString())
{
string value = ConvertToString(hidden->ToString());
int shortArg = atoi(value.c_str());
value = (jshort)shortArg;
}
else if (hidden->IsInt32())
{
jlong shortArg = hidden->ToInt32()->Int32Value();
value = (jshort)shortArg;
}
JniLocalRef javaObject(JType::NewShort(env, value));
SetConvertedObject(env, index, javaObject);
return true;
}
hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsDouble());
if (!hidden.IsEmpty())
{
jdouble value = 0;
if (hidden->IsNumber())
{
double doubleArg = hidden->ToNumber()->NumberValue();
value = (jdouble)doubleArg;
}
JniLocalRef javaObject(JType::NewDouble(env, value));
SetConvertedObject(env, index, javaObject);
return true;
}
hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsFloat());
if (!hidden.IsEmpty())
{
jfloat value = 0;
if (hidden->IsNumber())
{
double floatArg = hidden->ToNumber()->NumberValue();
value = (jfloat)floatArg;
}
JniLocalRef javaObject(JType::NewFloat(env, value));
SetConvertedObject(env, index, javaObject);
return true;
}
hidden = objectWithHiddenID->GetHiddenValue(V8StringConstants::GetMarkedAsChar());
if (!hidden.IsEmpty())
{
jchar value = '\0';
if (hidden->IsString())
{
string str = ConvertToString(hidden->ToString());
value = (jchar)str[0];
}
JniLocalRef javaObject(JType::NewChar(env, value));
SetConvertedObject(env, index, javaObject);
return true;
}
jweak obj = ObjectManager::GetJavaObjectByJsObjectStatic(objectWithHiddenID);
success = obj != nullptr;
if (success)
{
SetConvertedObject(env, index, obj, true);
}
else
{
s << "Cannot convert JavaScript object with id " << objectWithHiddenID->GetIdentityHash() << " at index " << index;
}
}
else if (arg->IsUndefined() || arg->IsNull())
{
SetConvertedObject(env, index, nullptr);
success = true;
}
else
{
s << "Cannot convert JavaScript object at index " << index;
success = false;
}
if (!success)
{
m_error.index = index;
m_error.msg = s.str();
}
return success;
}
bool QueryOperation::BindParameters( Handle<Array> node_params )
{
uint32_t count = node_params->Length();
if( count > 0 ) {
for( uint32_t i = 0; i < count; ++i ) {
Local<Value> p = node_params->Get( i );
ParamBinding binding;
if( p->IsNull() ) {
binding.js_type = ParamBinding::JS_NULL;
binding.c_type = SQL_C_CHAR;
binding.sql_type = SQL_CHAR;
binding.param_size = 1;
binding.digits = 0;
binding.buffer = NULL;
binding.buffer_len = 0;
binding.indptr = SQL_NULL_DATA;
}
else if( p->IsString() ) {
binding.js_type = ParamBinding::JS_STRING;
binding.c_type = SQL_C_WCHAR;
binding.sql_type = SQL_WVARCHAR;
Local<String> str_param = p->ToString();
int str_len = str_param->Length();
binding.buffer = new uint16_t[ str_len + 1 ]; // null terminator
str_param->Write( static_cast<uint16_t*>( binding.buffer ));
if( str_len > 4000 ) {
binding.param_size = 0; // max types require 0 precision
}
else {
binding.param_size = str_len;
}
binding.buffer_len = str_len * sizeof( uint16_t );
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
else if( p->IsBoolean() ) {
binding.js_type = ParamBinding::JS_BOOLEAN;
binding.c_type = SQL_C_BIT;
binding.sql_type = SQL_BIT;
binding.buffer = new uint16_t;
binding.buffer_len = sizeof( uint16_t );
*static_cast<uint16_t*>( binding.buffer ) = p->BooleanValue();
binding.param_size = 1;
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
else if( p->IsInt32()) {
binding.js_type = ParamBinding::JS_INT;
binding.c_type = SQL_C_SLONG;
binding.sql_type = SQL_INTEGER;
binding.buffer = new int32_t;
binding.buffer_len = sizeof( int32_t );
*static_cast<int32_t*>( binding.buffer ) = p->Int32Value();
binding.param_size = sizeof( int32_t );
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
else if( p->IsUint32()) {
binding.js_type = ParamBinding::JS_UINT;
binding.c_type = SQL_C_ULONG;
binding.sql_type = SQL_BIGINT;
binding.buffer = new uint32_t;
binding.buffer_len = sizeof( uint32_t );
*static_cast<int32_t*>( binding.buffer ) = p->Uint32Value();
binding.param_size = sizeof( uint32_t );
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
else if( p->IsNumber()) {
// numbers can be either integers or doubles. We attempt to determine which it is through a simple
// cast and equality check
double d = p->NumberValue();
if( _isnan( d ) || !_finite( d ) ) {
return ParameterErrorToUserCallback( i, "Invalid number parameter" );
}
else if( d == floor( d ) &&
d >= std::numeric_limits<int64_t>::min() &&
d <= std::numeric_limits<int64_t>::max() ) {
binding.js_type = ParamBinding::JS_NUMBER;
binding.c_type = SQL_C_SBIGINT;
binding.sql_type = SQL_BIGINT;
binding.buffer = new int64_t;
binding.buffer_len = sizeof( int64_t );
*static_cast<int64_t*>( binding.buffer ) = p->IntegerValue();
binding.param_size = sizeof( int64_t );
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
else {
binding.js_type = ParamBinding::JS_NUMBER;
binding.c_type = SQL_C_DOUBLE;
binding.sql_type = SQL_DOUBLE;
binding.buffer = new double;
binding.buffer_len = sizeof( double );
*static_cast<double*>( binding.buffer ) = p->NumberValue();
binding.param_size = sizeof( double );
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
}
else if( p->IsDate() ) {
// Since JS dates have no timezone context, all dates are assumed to be UTC
Handle<Date> dateObject = Handle<Date>::Cast<Value>( p );
assert( !dateObject.IsEmpty() );
// dates in JS are stored internally as ms count from Jan 1, 1970
double d = dateObject->NumberValue();
SQL_SS_TIMESTAMPOFFSET_STRUCT* sql_tm = new SQL_SS_TIMESTAMPOFFSET_STRUCT;
TimestampColumn sql_date( d );
sql_date.ToTimestampOffset( *sql_tm );
binding.js_type = ParamBinding::JS_DATE;
binding.c_type = SQL_C_BINARY;
// TODO: Determine proper SQL type based on version of server we're talking to
binding.sql_type = SQL_SS_TIMESTAMPOFFSET;
binding.buffer = sql_tm;
binding.buffer_len = sizeof( SQL_SS_TIMESTAMPOFFSET_STRUCT );
// TODO: Determine proper precision and size based on version of server we're talking to
binding.param_size = SQL_SERVER_2008_DEFAULT_DATETIME_PRECISION;
binding.digits = SQL_SERVER_2008_DEFAULT_DATETIME_SCALE;
binding.indptr = binding.buffer_len;
}
else if( p->IsObject() && node::Buffer::HasInstance( p )) {
// TODO: Determine if we need something to keep the Buffer object from going
// away while we use it we could just copy the data, but with buffers being
// potentially very large, that could be problematic
Local<Object> o = p.As<Object>();
binding.js_type = ParamBinding::JS_BUFFER;
binding.c_type = SQL_C_BINARY;
binding.sql_type = SQL_VARBINARY;
binding.buffer = node::Buffer::Data( o );
binding.buffer_len = node::Buffer::Length( o );
binding.param_size = binding.buffer_len;
binding.digits = 0;
binding.indptr = binding.buffer_len;
}
else {
return ParameterErrorToUserCallback( i, "Invalid parameter type" );
}
params.push_back( move( binding ));
}
}
return true;
}
/*-----------------------------------------------------------------------------
* Parse options
*/
bool ConnectParseOptions(Local<Object> options, ConnectRequest* request)
{
// Get options data
std::vector<std::string> optionNames = cvv8::CastFromJS<std::vector<std::string> >(options->GetPropertyNames());
for (size_t i = 0; i < optionNames.size(); i++)
{
char* optionName = (char*)(optionNames[i].c_str());
Local<Value> optionValue = options->Get(String::NewSymbol(optionName));
if (optionValue->IsUndefined())
{
continue;
}
if (tva_str_casecmp(optionName, "username") == 0)
{
String::AsciiValue val(optionValue->ToString());
request->username = strdup(*val);
}
else if (tva_str_casecmp(optionName, "password") == 0)
{
String::AsciiValue val(optionValue->ToString());
request->password = strdup(*val);
}
else if (tva_str_casecmp(optionName, "tmx") == 0)
{
if (optionValue->IsString())
{
String::AsciiValue val(optionValue->ToString());
request->primaryTmx = strdup(*val);
}
else if (optionValue->IsArray())
{
Handle<Array> tmxs = Handle<Array>::Cast(optionValue);
char** p_tmx = &request->primaryTmx;
Local<Value> element;
element = tmxs->Get(0);
if (!element->IsUndefined())
{
String::AsciiValue tmx(element->ToString());
*p_tmx = strdup(*tmx);
p_tmx = &request->secondaryTmx;
}
if (tmxs->Length() > 1)
{
element = tmxs->Get(1);
if (!element->IsUndefined())
{
String::AsciiValue tmx(element->ToString());
*p_tmx = strdup(*tmx);
}
}
}
}
else if (tva_str_casecmp(optionName, "name") == 0)
{
String::AsciiValue val(optionValue->ToString());
request->gdClientName = strdup(*val);
}
else if (tva_str_casecmp(optionName, "timeout") == 0)
{
request->timeout = optionValue->Int32Value() * 1000;
}
else if (tva_str_casecmp(optionName, "gdMaxOut") == 0)
{
request->gdMaxOut = optionValue->Int32Value();
}
else if (tva_str_casecmp(optionName, "config") == 0)
{
if (optionValue->IsObject())
{
Local<Object> config = Local<Object>::Cast(optionValue);
std::vector<std::string> configNames = cvv8::CastFromJS<std::vector<std::string> >(config->GetPropertyNames());
for (size_t j = 0; j < configNames.size(); j++)
{
char* configName = (char*)(configNames[j].c_str());
Local<Value> configValue = config->Get(String::NewSymbol(configName));
if (configValue->IsUndefined())
{
continue;
}
for (size_t c = 0; c < NUM_PARAMS; c++)
{
ConnectConfigParam* cp = &g_connectConfig[c];
if (tva_str_casecmp(configName, cp->jsName) == 0)
{
switch (cp->configType)
{
case ConfigTypeBool:
{
bool bVal;
if (configValue->IsBoolean())
{
bVal = configValue->BooleanValue();
}
else if (configValue->IsNumber())
{
bVal = (configValue->NumberValue() != 0);
}
else if (configValue->IsString())
{
String::AsciiValue bStrVal(config->ToString());
bVal = (tva_str_casecmp(*bStrVal, "true") == 0);
}
tvaAppCfgSet(cp->tvaParam, &bVal, (TVA_INT32)sizeof(bVal));
}
break;
case ConfigTypeInt:
{
int intVal = configValue->Int32Value();
tvaAppCfgSet(cp->tvaParam, &intVal, (TVA_INT32)sizeof(intVal));
}
break;
case ConfigTypeString:
{
String::AsciiValue strVal(configValue->ToString());
tvaAppCfgSet(cp->tvaParam, *strVal, (TVA_INT32)strlen(*strVal));
}
break;
case ConfigTypeCustom:
if (cp->tvaParam == TVA_APPCFG_DATA_TRANSPORT_TYPE)
{
TVA_DATATRANSPORT_TYPE transportType = TVA_DATATRANSPORT_UDP;
if (configValue->IsString())
{
String::AsciiValue strVal(config->ToString());
if (tva_str_casecmp(*strVal, "TCP"))
{
transportType = TVA_DATATRANSPORT_TCP;
}
else if (tva_str_casecmp(*strVal, "SSL"))
{
transportType = TVA_DATATRANSPORT_SSL;
}
}
else if (configValue->IsNumber())
{
int numVal = (int)configValue->NumberValue();
if ((numVal == TVA_DATATRANSPORT_TCP) || (numVal == TVA_DATATRANSPORT_SSL))
{
transportType = (TVA_DATATRANSPORT_TYPE)numVal;
}
}
tvaAppCfgSet(cp->tvaParam, &transportType, (TVA_INT32)sizeof(transportType));
}
break;
}
break;
}
}
}
}
}
}
// Make sure required arguments were specified
if (!request->username || !request->password || !request->primaryTmx)
{
return false;
}
return true;
}
Parameter* ODBC::GetParametersFromArray (Local<Array> values, int *paramCount) {
DEBUG_PRINTF("ODBC::GetParametersFromArray\n");
*paramCount = values->Length();
Parameter* params = NULL;
if (*paramCount > 0) {
params = (Parameter *) malloc(*paramCount * sizeof(Parameter));
}
for (int i = 0; i < *paramCount; i++) {
Local<Value> value = values->Get(i);
params[i].ColumnSize = 0;
params[i].StrLen_or_IndPtr = SQL_NULL_DATA;
params[i].BufferLength = 0;
params[i].DecimalDigits = 0;
DEBUG_PRINTF("ODBC::GetParametersFromArray - param[%i].length = %lli\n",
i, params[i].StrLen_or_IndPtr);
if (value->IsString()) {
Local<String> string = value->ToString();
int length = string->Length();
params[i].ValueType = SQL_C_TCHAR;
params[i].ColumnSize = 0; //SQL_SS_LENGTH_UNLIMITED
#ifdef UNICODE
params[i].ParameterType = SQL_WVARCHAR;
params[i].BufferLength = (length * sizeof(uint16_t)) + sizeof(uint16_t);
#else
params[i].ParameterType = SQL_VARCHAR;
params[i].BufferLength = string->Utf8Length() + 1;
#endif
params[i].ParameterValuePtr = malloc(params[i].BufferLength);
params[i].StrLen_or_IndPtr = SQL_NTS;//params[i].BufferLength;
#ifdef UNICODE
string->Write((uint16_t *) params[i].ParameterValuePtr);
#else
string->WriteUtf8((char *) params[i].ParameterValuePtr);
#endif
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsString(): params[%i] c_type=%i type=%i buffer_length=%lli size=%lli length=%lli value=%s\n",
i, params[i].ValueType, params[i].ParameterType,
params[i].BufferLength, params[i].ColumnSize, params[i].StrLen_or_IndPtr,
(char*) params[i].ParameterValuePtr);
}
else if (value->IsNull()) {
params[i].ValueType = SQL_C_DEFAULT;
params[i].ParameterType = SQL_VARCHAR;
params[i].StrLen_or_IndPtr = SQL_NULL_DATA;
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsNull(): params[%i] c_type=%i type=%i buffer_length=%lli size=%lli length=%lli\n",
i, params[i].ValueType, params[i].ParameterType,
params[i].BufferLength, params[i].ColumnSize, params[i].StrLen_or_IndPtr);
}
else if (value->IsInt32()) {
int64_t *number = new int64_t(value->IntegerValue());
params[i].ValueType = SQL_C_SBIGINT;
params[i].ParameterType = SQL_BIGINT;
params[i].ParameterValuePtr = number;
params[i].StrLen_or_IndPtr = 0;
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsInt32(): params[%i] c_type=%i type=%i buffer_length=%lli size=%lli length=%lli value=%lld\n",
i, params[i].ValueType, params[i].ParameterType,
params[i].BufferLength, params[i].ColumnSize, params[i].StrLen_or_IndPtr,
*number);
}
else if (value->IsNumber()) {
double *number = new double(value->NumberValue());
params[i].ValueType = SQL_C_DOUBLE;
params[i].ParameterType = SQL_DECIMAL;
params[i].ParameterValuePtr = number;
params[i].BufferLength = sizeof(double);
params[i].StrLen_or_IndPtr = params[i].BufferLength;
params[i].DecimalDigits = 7;
params[i].ColumnSize = sizeof(double);
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsNumber(): params[%i] c_type=%i type=%i buffer_length=%lli size=%lli length=%lli value=%f\n",
i, params[i].ValueType, params[i].ParameterType,
params[i].BufferLength, params[i].ColumnSize, params[i].StrLen_or_IndPtr,
*number);
}
else if (value->IsBoolean()) {
bool *boolean = new bool(value->BooleanValue());
params[i].ValueType = SQL_C_BIT;
params[i].ParameterType = SQL_BIT;
params[i].ParameterValuePtr = boolean;
params[i].StrLen_or_IndPtr = 0;
DEBUG_PRINTF("ODBC::GetParametersFromArray - IsBoolean(): params[%i] c_type=%i type=%i buffer_length=%lli size=%lli length=%lli\n",
i, params[i].ValueType, params[i].ParameterType,
params[i].BufferLength, params[i].ColumnSize, params[i].StrLen_or_IndPtr);
}
}
return params;
}
bool Settings::getBoolean(const char* property, bool defaultValue = false) {
Local<Value> tmp = get(property);
return (tmp->IsBoolean())? tmp->BooleanValue() : defaultValue;
}
