Example #1
0
Handle<Value> Geometry::New(const Arguments& args)
{
	HandleScope scope;
	Geometry *f;

	if (!args.IsConstructCall()) {
		return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
	}

	if (args[0]->IsExternal()) {
		Local<External> ext = Local<External>::Cast(args[0]);
		void* ptr = ext->Value();
		f = static_cast<Geometry *>(ptr);

	} else {
		return NODE_THROW("Geometry doesnt have a constructor, use Geometry.createFromWkt(), Geometry.create() or type-specific constructor. ie. new ogr.Point()");
		OGRwkbGeometryType geometry_type;
		NODE_ARG_ENUM(0, "geometry type", OGRwkbGeometryType, geometry_type);
		OGRGeometry *geom = OGRGeometryFactory::createGeometry(geometry_type);
		f = new Geometry(geom);
	}

	f->Wrap(args.This());
	return args.This();
}
Example #2
0
void FieldDefn::justificationSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
	HandleScope scope;
	FieldDefn *def = ObjectWrap::Unwrap<FieldDefn>(info.This());
	

	OGRJustification justification;
	std::string str = TOSTR(value);
	if(value->IsString()){
		if(str == "Left") {
			justification = OJLeft;
		} else if (str == "Right") {
			justification = OJRight;
		} else if (str == "Undefined") {
			justification = OJUndefined; 
		} else {
			NODE_THROW("Unrecognized justification");
			return;
		}
	} else if (value->IsNull() || value->IsUndefined()){
		justification = OJUndefined;
	} else {
		NODE_THROW("justification must be a string or undefined");
		return;
	}
	
	def->this_->SetJustify(justification);
}
Example #3
0
Handle<Value> Polygon::New(const Arguments& args)
{
	HandleScope scope;
	Polygon *f;

	if (!args.IsConstructCall()) {
		return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
	}

	if (args[0]->IsExternal()) {
		Local<External> ext = Local<External>::Cast(args[0]);
		void* ptr = ext->Value();
		f = static_cast<Polygon *>(ptr);

	} else {
		if (args.Length() != 0) {
			return NODE_THROW("Polygon constructor doesn't take any arguments");
		}
		f = new Polygon(new OGRPolygon());
	}

	Handle<Value> rings = PolygonRings::New(args.This()); 
	args.This()->SetHiddenValue(String::NewSymbol("rings_"), rings); 

	f->Wrap(args.This());
	return args.This();
}
Example #4
0
Handle<Value> LayerFields::getNames(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Layer *layer = ObjectWrap::Unwrap<Layer>(parent);
	if (!layer->get()) {
		return NODE_THROW("Layer object already destroyed");
	}

	OGRFeatureDefn *def = layer->get()->GetLayerDefn();
	if (!def) {
		return NODE_THROW("Layer has no layer definition set");
	}

	int n = def->GetFieldCount();
	Handle<Array> result = Array::New(n);

	for (int i = 0; i < n;  i++) {
		OGRFieldDefn *field_def = def->GetFieldDefn(i);
		result->Set(i, SafeString::New(field_def->GetNameRef()));
	}

	return scope.Close(result);
}
Example #5
0
Handle<Value> LayerFields::remove(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Layer *layer = ObjectWrap::Unwrap<Layer>(parent);
	if (!layer->get()) {
		return NODE_THROW("Layer object already destroyed");
	}

	if (args.Length() < 1) {
		return NODE_THROW("Field index or name must be given");
	}

	OGRFeatureDefn *def = layer->get()->GetLayerDefn();
	if (!def) {
		return NODE_THROW("Layer has no layer definition set");
	}

	int field_index;
	ARG_FIELD_ID(0, def, field_index);

	int err = layer->get()->DeleteField(field_index);
	if (err) {
		return NODE_THROW_OGRERR(err);
	}

	return Undefined();
}
Handle<Value> FeatureDefn::New(const Arguments& args)
{
	HandleScope scope;
	FeatureDefn *f;

	if (!args.IsConstructCall()) {
		return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
	}

	if (args[0]->IsExternal()) {
		Local<External> ext = Local<External>::Cast(args[0]);
		void* ptr = ext->Value();
		f = static_cast<FeatureDefn *>(ptr);
	} else {
		if (args.Length() != 0) {
			return NODE_THROW("FeatureDefn constructor doesn't take any arguments");
		}
		f = new FeatureDefn(new OGRFeatureDefn());
		f->this_->Reference();
	}

	Handle<Value> fields = FeatureDefnFields::New(args.This()); 
	args.This()->SetHiddenValue(String::NewSymbol("fields_"), fields);
	
	f->Wrap(args.This());
	return args.This();
}
Example #7
0
Handle<Value> FieldDefn::New(const Arguments& args)
{
	HandleScope scope;

	if (!args.IsConstructCall()) {
		return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
	}

	if (args[0]->IsExternal()) {
		Local<External> ext = Local<External>::Cast(args[0]);
		void* ptr = ext->Value();
		FieldDefn *f = static_cast<FieldDefn *>(ptr);
		f->Wrap(args.This());
		return args.This();
	} else {
		std::string field_name("");
		std::string type_name("string");

		NODE_ARG_STR(0, "field name", field_name);
		NODE_ARG_STR(1, "field type", type_name);

		int field_type = getFieldTypeByName(type_name);
		if (field_type < 0) {
			return NODE_THROW("Unrecognized field type");
		}

		FieldDefn* def = new FieldDefn(new OGRFieldDefn(field_name.c_str(), static_cast<OGRFieldType>(field_type)));
		def->owned_ = true;
		def->Wrap(args.This());
	}

	return args.This();
}
Example #8
0
Handle<Value> DatasetBands::get(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Dataset *ds = ObjectWrap::Unwrap<Dataset>(parent);
	
	if (ds->uses_ogr){
		OGRDataSource* raw = ds->getDatasource();
		if (!raw) {
			return NODE_THROW("Dataset object has already been destroyed");
		}
		return Null();
	} else {
		GDALDataset* raw = ds->getDataset();
		if (!raw) {
			return NODE_THROW("Dataset object has already been destroyed");
		}
		int band_id;
		NODE_ARG_INT(0, "band id", band_id);
	
		GDALRasterBand *band = raw->GetRasterBand(band_id);

		return scope.Close(RasterBand::New(band));
	}
}
Example #9
0
Handle<Value> Dataset::setGeoTransform(const Arguments& args)
{
	Dataset *ds = ObjectWrap::Unwrap<Dataset>(args.This());
	if(!ds->this_) return NODE_THROW("Dataset object has already been destroyed");

	Handle<Array> transform;
	NODE_ARG_ARRAY(0, "transform", transform);

	if (transform->Length() != 6) {
		return NODE_THROW("Transform array must have 6 elements")
	}

	double buffer[6];
	for (int i = 0; i < 6; i++) {
		Local<Value> val = transform->Get(i);
		if (!val->IsNumber()) {
			return NODE_THROW("Transform array must only contain numbers");
		}
		buffer[i] = val->NumberValue();
	}

	CPLErr err = ds->this_->SetGeoTransform(buffer);
	if (err) return NODE_THROW_CPLERR(err);

	return Undefined();
}
Example #10
0
Handle<Value> MultiPoint::New(const Arguments& args)
{
	HandleScope scope;
	MultiPoint *f;

	if (!args.IsConstructCall()) {
		return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
	}

	if (args[0]->IsExternal()) {
		Local<External> ext = Local<External>::Cast(args[0]);
		void* ptr = ext->Value();
		f = static_cast<MultiPoint *>(ptr);

	} else {
		if (args.Length() != 0) {
			return NODE_THROW("MultiPoint constructor doesn't take any arguments");
		}
		f = new MultiPoint(new OGRMultiPoint());
	}

	Handle<Value> children = GeometryCollectionChildren::New(args.This()); 
	args.This()->SetHiddenValue(String::NewSymbol("children_"), children); 

	f->Wrap(args.This());
	return args.This();
}
Example #11
0
Handle<Value> DatasetBands::create(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Dataset *ds = ObjectWrap::Unwrap<Dataset>(parent);
	
	if (ds->uses_ogr){
		return NODE_THROW("Dataset does not support getting creating bands");
	} 

	GDALDataset* raw = ds->getDataset();
	if (!raw) {
		return NODE_THROW("Dataset object has already been destroyed");
	}

	GDALDataType type;
	Handle<Array> band_options = Array::New(0);
	char **options = NULL;
	std::string *options_str = NULL;

	//NODE_ARG_ENUM(0, "data type", GDALDataType, type);
	if(args.Length() < 1) {
		return NODE_THROW("data type argument needed");
	}
	if(args[0]->IsString()){
		std::string type_name = TOSTR(args[0]);
		type = GDALGetDataTypeByName(type_name.c_str());
	} else if (args[0]->IsNull() || args[0]->IsUndefined()) {
		type = GDT_Unknown;
	} else {
		return NODE_THROW("data type must be string or undefined");
	}

	NODE_ARG_ARRAY_OPT(1, "band creation options", band_options);

	if (band_options->Length() > 0) {
		options     = new char* [band_options->Length()];
		options_str = new std::string [band_options->Length()];
		for (unsigned int i = 0; i < band_options->Length(); ++i) {
			options_str[i] = TOSTR(band_options->Get(i));
			options[i] = (char*) options_str[i].c_str();
		}
	}

	CPLErr err = raw->AddBand(type, options);

	if(options)	    delete [] options;
	if(options_str)	delete [] options_str;

	if (err) {
		return NODE_THROW_CPLERR(err);
	}

	return scope.Close(RasterBand::New(raw->GetRasterBand(raw->GetRasterCount()), raw));
}
Example #12
0
Handle<Value> Geometry::exportToWKB(const Arguments& args)
{
	HandleScope scope;

	Geometry *geom = ObjectWrap::Unwrap<Geometry>(args.This());
	
	int size = geom->this_->WkbSize();
	unsigned char *data = (unsigned char*) malloc(size);
	
	//byte order 
	OGRwkbByteOrder byte_order;
	std::string order = "MSB";
	NODE_ARG_OPT_STR(0, "byte order", order);
	if (order == "MSB") {
		byte_order = wkbXDR;
	} else if (order == "LSB") {
		byte_order = wkbNDR;
	} else {
		return NODE_THROW("byte order must be 'MSB' or 'LSB'");
	}

	#if GDAL_VERSION_NUM > 1100000 
	//wkb variant
	OGRwkbVariant wkb_variant;
	std::string variant = "OGC";
	NODE_ARG_OPT_STR(1, "wkb variant", variant);
	if (variant == "OGC") {
		wkb_variant = wkbVariantOgc;
	} else if (order == "ISO") {
		wkb_variant = wkbVariantIso;
	} else {
		return NODE_THROW("byte order must be 'OGC' or 'ISO'");
	}
	OGRErr err = geom->this_->exportToWkb(byte_order, data, wkb_variant);
	#else
	OGRErr err = geom->this_->exportToWkb(byte_order, data);
	#endif

	//^^ export to wkb and fill buffer ^^
	//TODO: avoid extra memcpy in FastBuffer::New and have exportToWkb write directly into buffer

	if (err) {
		free(data);
		return NODE_THROW_OGRERR(err);
	}

	Handle<Value> result = FastBuffer::New(data, size);
	free(data);

	return scope.Close(result);
	
}
Example #13
0
Handle<Value> LayerFields::reorder(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Layer *layer = ObjectWrap::Unwrap<Layer>(parent);
	if (!layer->get()) {
		return NODE_THROW("Layer object already destroyed");
	}

	OGRFeatureDefn *def = layer->get()->GetLayerDefn();
	if (!def) {
		return NODE_THROW("Layer has no layer definition set");
	}

	Handle<Array> field_map = Array::New(0);
	NODE_ARG_ARRAY(0, "field map", field_map);

	int n = def->GetFieldCount();
	OGRErr err = 0;

	if ((int)field_map->Length() != n) {
		return NODE_THROW("Array length must match field count");
	}

	int *field_map_array = new int[n];

	for (int i = 0; i < n; i++) {
		Handle<Value> val = field_map->Get(i);
		if (!val->IsNumber()) {
			delete [] field_map_array;
			return NODE_THROW("Array must only contain integers");
		}

		int key = val->IntegerValue();
		if (key < 0 || key >= n) {
			delete [] field_map_array;
			return NODE_THROW("Values must be between 0 and field count - 1");
		}

		field_map_array[i] = key;
	}

	err = layer->get()->ReorderFields(field_map_array);

	delete [] field_map_array;

	if (err) {
		return NODE_THROW_OGRERR(err);
	}
	return Undefined();
}
Example #14
0
Handle<Value> Dataset::addBand(const Arguments& args)
{
	HandleScope scope;

	Dataset *ds = ObjectWrap::Unwrap<Dataset>(args.This());
	if(!ds->this_) return NODE_THROW("Dataset object has already been destroyed");

	GDALDataType type;
	Handle<Array> band_options = Array::New(0);
	char **options = NULL;

	NODE_ARG_ENUM(0, "data type", GDALDataType, type);
	NODE_ARG_ARRAY_OPT(1, "band creation options", band_options);

	if (band_options->Length() > 0) {
		options = new char* [band_options->Length()];
		for (unsigned int i = 0; i < band_options->Length(); ++i) {
			options[i] = TOSTR(band_options->Get(i));
		}
	}

	CPLErr err = ds->this_->AddBand(type, options);

	if (options) {
		delete [] options;
	}

	if(err) return NODE_THROW_CPLERR(err);

	return scope.Close(RasterBand::New(ds->this_->GetRasterBand(ds->this_->GetRasterCount())));
}
Example #15
0
Handle<Value> Geometry::getArea(const Arguments& args)
{
  HandleScope scope;
  Geometry *geom = ObjectWrap::Unwrap<Geometry>(args.This());

  Handle<Value> area = Undefined();

  switch (geom->this_->getGeometryType()) {
    case wkbPolygon:
      area = Number::New(((OGRPolygon *)geom->this_)->get_Area());
      break;

    case wkbMultiPolygon:
      area = Number::New(((OGRMultiPolygon *)geom->this_)->get_Area());
      break;

    case wkbLinearRing:
      area = Number::New(((OGRLinearRing *)geom->this_)->get_Area());
      break;

    case wkbGeometryCollection:
      area = Number::New(((OGRGeometryCollection *)geom->this_)->get_Area());
      break;

    default:
      area = NODE_THROW("geometry must be either a polygon, multi-polygon, linear ring, or a geometry collection to use the area function.");
      break;
  }

  return scope.Close(area);
}
Example #16
0
Handle<Value> Dataset::getGCPs(const Arguments& args)
{
	HandleScope scope;

	Dataset *ds = ObjectWrap::Unwrap<Dataset>(args.This());
	if(!ds->this_) return NODE_THROW("Dataset object has already been destroyed");

	int n = ds->this_->GetGCPCount();
	const GDAL_GCP *gcps = ds->this_->GetGCPs();

	Handle<Array> results = Array::New(0);

	if (!gcps) {
		return scope.Close(results);
	}

	for (int i = 0; i < n; i++) {
		GDAL_GCP gcp = gcps[i];
		Local<Object> obj = Object::New();
		obj->Set(String::NewSymbol("pszId"), String::New(gcp.pszId));
		obj->Set(String::NewSymbol("pszInfo"), String::New(gcp.pszInfo));
		obj->Set(String::NewSymbol("dfGCPPixel"), Number::New(gcp.dfGCPPixel));
		obj->Set(String::NewSymbol("dfGCPLine"), Number::New(gcp.dfGCPLine));
		obj->Set(String::NewSymbol("dfGCPX"), Number::New(gcp.dfGCPX));
		obj->Set(String::NewSymbol("dfGCPY"), Number::New(gcp.dfGCPY));
		obj->Set(String::NewSymbol("dfGCPZ"), Number::New(gcp.dfGCPZ));
		results->Set(i, obj);
	}

	return scope.Close(results);
}
Example #17
0
Handle<Value> Geometry::createFromWkb(const Arguments &args)
{
	HandleScope scope;

	std::string wkb_string;
	SpatialReference *srs = NULL;

	Handle<Object> wkb_obj; 
	NODE_ARG_OBJECT(0, "wkb", wkb_obj);
	NODE_ARG_WRAPPED_OPT(1, "srs", SpatialReference, srs);

	std::string obj_type = TOSTR(wkb_obj->GetConstructorName());

	if(obj_type != "Buffer"){
		return NODE_THROW("Argument must be a buffer object");
	}

	unsigned char* data = (unsigned char *) Buffer::Data(wkb_obj);
	size_t length = Buffer::Length(wkb_obj);

	OGRGeometry *geom = NULL;
	OGRSpatialReference *ogr_srs = NULL;
	if (srs) {
		ogr_srs = srs->get();
	}

	OGRErr err = OGRGeometryFactory::createFromWkb(data, ogr_srs, &geom, length);
	if (err) {
		return NODE_THROW_OGRERR(err);
	}

	return scope.Close(Geometry::New(geom, true));
}
Example #18
0
Handle<Value> Geometry::New(OGRGeometry *geom, bool owned)
{
	HandleScope scope;

	if (!geom) {
		return Null();
	}

	switch(getGeometryType_fixed(geom)) {
	case wkbPoint              :
		return scope.Close(Point::New(static_cast<OGRPoint*>(geom), owned));
	case wkbLineString         :
		return scope.Close(LineString::New(static_cast<OGRLineString*>(geom), owned));
	case wkbLinearRing         :
		return scope.Close(LinearRing::New(static_cast<OGRLinearRing*>(geom), owned));
	case wkbPolygon            :
		return scope.Close(Polygon::New(static_cast<OGRPolygon*>(geom), owned));
	case wkbGeometryCollection :
		return scope.Close(GeometryCollection::New(static_cast<OGRGeometryCollection*>(geom), owned));
	case wkbMultiPoint         :
		return scope.Close(MultiPoint::New(static_cast<OGRMultiPoint*>(geom), owned));
	case wkbMultiLineString    :
		return scope.Close(MultiLineString::New(static_cast<OGRMultiLineString*>(geom), owned));
	case wkbMultiPolygon       :
		return scope.Close(MultiPolygon::New(static_cast<OGRMultiPolygon*>(geom), owned));
	default                    :
		return NODE_THROW("Tried to create unsupported geometry type");
	}
}
Example #19
0
Handle<Value> DatasetBands::New(const Arguments& args)
{
	HandleScope scope;

	if (!args.IsConstructCall()) {
		return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
	}
	if (args[0]->IsExternal()) {
		Local<External> ext = Local<External>::Cast(args[0]);
		void* ptr = ext->Value();
		DatasetBands *f =  static_cast<DatasetBands *>(ptr);
		f->Wrap(args.This());
		return args.This();
	} else {
		return NODE_THROW("Cannot create DatasetBands directly");
	}
}
Example #20
0
void FieldDefn::typeSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
	HandleScope scope;
	FieldDefn *def = ObjectWrap::Unwrap<FieldDefn>(info.This());
	if(!value->IsString()){
		NODE_THROW("type must be a string");
		return;
	}
	std::string name = TOSTR(value);
	int type = getFieldTypeByName(name);
	if(type < 0){
		NODE_THROW("Unrecognized field type");
	} else {
		def->this_->SetType(OGRFieldType(type));
	}
	
}
Example #21
0
Handle<Value> Dataset::getRasterBand(const Arguments& args)
{
	HandleScope scope;
	GDALRasterBand *poBand;
	int band_id;
	NODE_ARG_INT(0, "band id", band_id);

	Dataset *ds = ObjectWrap::Unwrap<Dataset>(args.This());
	if(!ds->this_) return NODE_THROW("Dataset object has already been destroyed");
	poBand = ds->this_->GetRasterBand(band_id);

	if (poBand == NULL) {
		return NODE_THROW("Specified band not found");
	}

	return scope.Close(RasterBand::New(poBand));
}
Example #22
0
Handle<Value> LayerFields::count(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Layer *layer = ObjectWrap::Unwrap<Layer>(parent);
	if (!layer->get()) {
		return NODE_THROW("Layer object already destroyed");
	}

	OGRFeatureDefn *def = layer->get()->GetLayerDefn();
	if (!def) {
		return NODE_THROW("Layer has no layer definition set");
	}

	return scope.Close(Integer::New(def->GetFieldCount()));
}
Example #23
0
Handle<Value> LayerFields::add(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Layer *layer = ObjectWrap::Unwrap<Layer>(parent);
	if (!layer->get()) {
		return NODE_THROW("Layer object already destroyed");
	}
	if (args.Length() < 1) {
		return NODE_THROW("field definition(s) must be given");
	}

	FieldDefn *field_def;
	int err;
	bool approx = true;
	NODE_ARG_BOOL_OPT(1, "approx", approx);

	if (args[0]->IsArray()) {
		Handle<Array> array = Handle<Array>::Cast(args[0]);
		int n = array->Length();
		for (int i = 0; i < n; i++) {
			Handle<Value> element = array->Get(i);
			if (IS_WRAPPED(element, FieldDefn)) {
				field_def = ObjectWrap::Unwrap<FieldDefn>(element->ToObject());
				err = layer->get()->CreateField(field_def->get(), approx);
				if (err) {
					return NODE_THROW_OGRERR(err);
				}
			} else {
				return NODE_THROW("All array elements must be FieldDefn objects");
			}
		}
	} else if (IS_WRAPPED(args[0], FieldDefn)) {
		field_def = ObjectWrap::Unwrap<FieldDefn>(args[0]->ToObject());
		err = layer->get()->CreateField(field_def->get(), approx);
		if (err) {
			return NODE_THROW_OGRERR(err);
		}
	} else {
		return NODE_THROW("field definition(s) must be a FieldDefn object or array of FieldDefn objects");
	}

	return Undefined();
}
Example #24
0
Handle<Value> Dataset::close(const Arguments& args)
{
	Dataset *ds = ObjectWrap::Unwrap<Dataset>(args.This());
	if(!ds->this_) return NODE_THROW("Dataset object has already been destroyed");
	
	ds->dispose();
	
	return Undefined();
}
Example #25
0
void FeatureDefn::geomTypeSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
	HandleScope scope;
	FeatureDefn *def = ObjectWrap::Unwrap<FeatureDefn>(info.This());
	if(!value->IsInt32()){
		NODE_THROW("geomType must be an integer");
		return;
	}
	def->this_->SetGeomType(OGRwkbGeometryType(value->IntegerValue()));
}
Example #26
0
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());
}
Example #27
0
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());
}
Example #28
0
void FieldDefn::precisionSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
	HandleScope scope;
	FieldDefn *def = ObjectWrap::Unwrap<FieldDefn>(info.This());
	if(!value->IsInt32()){
		NODE_THROW("precision must be an integer");
		return;
	}
	def->this_->SetPrecision(value->IntegerValue());
}
Example #29
0
void FieldDefn::nameSetter(Local<String> property, Local<Value> value, const AccessorInfo &info)
{
	HandleScope scope;
	FieldDefn *def = ObjectWrap::Unwrap<FieldDefn>(info.This());
	if(!value->IsString()){
		NODE_THROW("Name must be string");
		return;
	}
	def->this_->SetName(TOSTR(value));
}
Example #30
0
Handle<Value> LayerFields::indexOf(const Arguments& args)
{
	HandleScope scope;

	Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
	Layer *layer = ObjectWrap::Unwrap<Layer>(parent);
	if (!layer->get()) {
		return NODE_THROW("Layer object already destroyed");
	}

	OGRFeatureDefn *def = layer->get()->GetLayerDefn();
	if (!def) {
		return NODE_THROW("Layer has no layer definition set");
	}

	std::string name("");
	NODE_ARG_STR(0, "field name", name);

	return scope.Close(Integer::New(def->GetFieldIndex(name.c_str())));
}