void* TypedArray::Validate(Handle<Object> obj, GDALDataType type, int min_length){
//validate array
NanEscapableScope();
if(!obj->HasIndexedPropertiesInExternalArrayData()) {
NanThrowError("Object has no external array data");
return NULL;
}
GDALDataType src_type = TypedArray::Identify(obj);
if(type == GDT_Unknown) {
NanThrowTypeError("Unable to identify GDAL datatype of passed array object");
return NULL;
}
if(src_type != type) {
std::ostringstream ss;
ss << "Array type does not match band data type ("
<< "array: " << GDALGetDataTypeName(src_type)
<< " band: " << GDALGetDataTypeName(type) << ")";
NanThrowTypeError(ss.str().c_str());
return NULL;
}
if(TypedArray::Length(obj) < min_length) {
std::ostringstream ss;
ss << "Array length must be greater than or equal to " << min_length;
NanThrowError(ss.str().c_str());
return NULL;
}
return TypedArray::Data(obj);
}
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);
}
static NAN_METHOD(New) {
NanScope();
if (args.Length() != 1) {
EIGENJS_THROW_ERROR_INVALID_ARGUMENT()
NanReturnUndefined();
}
if (!args.IsConstructCall()) {
v8::Local<v8::Value> argv[] ={ args[0] };
NanReturnValue(
base_type::new_instance(
args
, sizeof(argv) / sizeof(v8::Local<v8::Value>)
, argv
)
);
}
if (Matrix::is_matrix(args[0])) {
const Matrix* const& rhs_obj =
node::ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
const typename Matrix::value_type& rhs_matrix = **rhs_obj;
if (rhs_matrix.rows() != rhs_matrix.cols()) {
NanThrowError("PartialPivLU is only for square "
"(and moreover invertible) matrices");
NanReturnUndefined();
}
PartialPivLU* obj = new PartialPivLU(rhs_matrix);
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (MatrixBlock::is_matrixblock(args[0])) {
const MatrixBlock* const& rhs_obj =
node::ObjectWrap::Unwrap<MatrixBlock>(args[0]->ToObject());
const typename MatrixBlock::value_type& rhs_matrixblock = **rhs_obj;
if (rhs_matrixblock.rows() != rhs_matrixblock.cols()) {
NanThrowError("PartialPivLU is only for square "
"(and moreover invertible) matrices");
NanReturnUndefined();
}
PartialPivLU* obj = new PartialPivLU(rhs_matrixblock);
obj->Wrap(args.This());
NanReturnValue(args.This());
}
EIGENJS_THROW_ERROR_INVALID_ARGUMENT()
NanReturnUndefined();
}
static inline NAN_METHOD(register_fonts)
{
NanScope();
try
{
if (args.Length() == 0 || !args[0]->IsString())
{
NanThrowTypeError("first argument must be a path to a directory of fonts");
NanReturnUndefined();
}
bool found = false;
std::vector<std::string> const names_before = mapnik::freetype_engine::face_names();
// option hash
if (args.Length() == 2){
if (!args[1]->IsObject())
{
NanThrowTypeError("second argument is optional, but if provided must be an object, eg. { recurse:Boolean }");
NanReturnUndefined();
}
Local<Object> options = args[1].As<Object>();
if (options->Has(NanNew("recurse")))
{
Local<Value> recurse_opt = options->Get(NanNew("recurse"));
if (!recurse_opt->IsBoolean())
{
NanThrowTypeError("'recurse' must be a Boolean");
NanReturnUndefined();
}
bool recurse = recurse_opt->BooleanValue();
std::string path = TOSTR(args[0]);
found = mapnik::freetype_engine::register_fonts(path,recurse);
}
}
else
{
std::string path = TOSTR(args[0]);
found = mapnik::freetype_engine::register_fonts(path);
}
std::vector<std::string> const& names_after = mapnik::freetype_engine::face_names();
if (names_after.size() == names_before.size())
found = false;
NanReturnValue(NanNew(found));
}
catch (std::exception const& ex)
{
NanThrowError(ex.what());
NanReturnUndefined();
}
}
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::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());
}
}
static void describe_datasource(Local<Object> description, mapnik::datasource_ptr ds)
{
NanScope();
try
{
// type
if (ds->type() == mapnik::datasource::Raster)
{
description->Set(NanNew("type"), NanNew<String>("raster"));
}
else
{
description->Set(NanNew("type"), NanNew<String>("vector"));
}
mapnik::layer_descriptor ld = ds->get_descriptor();
// encoding
description->Set(NanNew("encoding"), NanNew<String>(ld.get_encoding().c_str()));
// field names and types
Local<Object> fields = NanNew<Object>();
std::vector<mapnik::attribute_descriptor> const& desc = ld.get_descriptors();
std::vector<mapnik::attribute_descriptor>::const_iterator itr = desc.begin();
std::vector<mapnik::attribute_descriptor>::const_iterator end = desc.end();
while (itr != end)
{
unsigned field_type = itr->get_type();
std::string type("");
if (field_type == mapnik::Integer) type = "Number";
else if (field_type == mapnik::Float) type = "Number";
else if (field_type == mapnik::Double) type = "Number";
else if (field_type == mapnik::String) type = "String";
else if (field_type == mapnik::Boolean) type = "Boolean";
else if (field_type == mapnik::Geometry) type = "Geometry";
else if (field_type == mapnik::Object) type = "Object";
else type = "Unknown";
fields->Set(NanNew(itr->get_name().c_str()), NanNew(type.c_str()));
fields->Set(NanNew(itr->get_name().c_str()), NanNew(type.c_str()));
++itr;
}
description->Set(NanNew("fields"), fields);
Local<String> js_type = NanNew<String>("unknown");
if (ds->type() == mapnik::datasource::Raster)
{
js_type = NanNew<String>("raster");
}
else
{
boost::optional<mapnik::datasource::geometry_t> geom_type = ds->get_geometry_type();
if (geom_type)
{
mapnik::datasource::geometry_t g_type = *geom_type;
switch (g_type)
{
case mapnik::datasource::Point:
{
js_type = NanNew<String>("point");
break;
}
case mapnik::datasource::LineString:
{
js_type = NanNew<String>("linestring");
break;
}
case mapnik::datasource::Polygon:
{
js_type = NanNew<String>("polygon");
break;
}
case mapnik::datasource::Collection:
{
js_type = NanNew<String>("collection");
break;
}
default:
{
break;
}
}
}
}
description->Set(NanNew("geometry_type"), js_type);
for (auto const& param : ld.get_extra_parameters())
{
node_mapnik::params_to_object(description,param.first, param.second);
}
}
catch (std::exception const& ex)
{
NanThrowError(ex.what());
}
catch (...)
{
NanThrowError("unknown exception happened when calling describe_datasource, please file bug");
}
}