Struct flatgeobuf::FgbWriter

pub struct FgbWriter<'a> { /* private fields */ }

FlatGeobuf dataset writer

Usage example:

use flatgeobuf::*;
use geozero::geojson::GeoJsonReader;
use geozero::GeozeroDatasource;

let mut fgb = FgbWriter::create("countries", GeometryType::MultiPolygon)?;
let mut fin = BufReader::new(File::open("countries.geojson")?);
let mut reader = GeoJsonReader(&mut fin);
reader.process(&mut fgb)?;
let mut fout = BufWriter::new(File::create("countries.fgb")?);
fgb.write(&mut fout)?;

Implementations

impl FgbWriter<'_>

pub fn add_feature(&mut self, feature: impl GeozeroDatasource) -> Result<()>

Add a new feature.

Usage example:

use geozero::geojson::GeoJson;
let geojson = GeoJson(r#"{"type": "Feature", "properties": {"fid": 42, "name": "New Zealand"}, "geometry": {"type": "Point", "coordinates": [1, 1]}}"#);
fgb.add_feature(geojson).ok();

pub fn add_feature_geom<F>( &mut self, geom: impl GeozeroGeometry, cfgfn: F ) -> Result<()>

where F: FnOnce(&mut FeatureWriter<'_>),

Add a new feature from a GeozeroGeometry.

Usage example:

use geozero::geojson::GeoJson;
use geozero::{ColumnValue, PropertyProcessor};
let geom = GeoJson(r#"{"type": "Point", "coordinates": [1, 1]}"#);
fgb.add_feature_geom(geom, |feat| {
    feat.property(0, "fid", &ColumnValue::Long(43)).unwrap();
    feat.property(1, "name", &ColumnValue::String("South Africa"))
        .unwrap();
})
.ok();

impl<'a> FgbWriter<'a>

pub fn create(name: &str, geometry_type: GeometryType) -> Result<Self>

Configure FlatGeobuf headers for creating a new file with default options

Usage example:

let mut fgb = FgbWriter::create("countries", GeometryType::MultiPolygon).unwrap();

pub fn create_with_options( name: &str, geometry_type: GeometryType, options: FgbWriterOptions<'_> ) -> Result<Self>

Configure FlatGeobuf headers for creating a new file

Usage example:

let mut fgb = FgbWriter::create_with_options(
    "countries",
    GeometryType::MultiPolygon,
    FgbWriterOptions {
        description: Some("Country polygons"),
        write_index: false,
        crs: FgbCrs {
            code: 4326,
            ..Default::default()
        },
        ..Default::default()
    },
)
.unwrap();

pub fn add_column<F>(&mut self, name: &str, col_type: ColumnType, cfgfn: F)

where F: FnOnce(&mut FlatBufferBuilder<'a>, &mut ColumnArgs<'_>),

Add a new column.

Usage example:

fgb.add_column("fid", ColumnType::ULong, |_fbb, col| {
    col.nullable = false;
});

pub fn write(self, out: impl Write) -> Result<()>

Write the FlatGeobuf dataset (Hilbert sorted)

Trait Implementations

impl FeatureProcessor for FgbWriter<'_>

fn feature_end(&mut self, _idx: u64) -> Result<()>

End of feature processing

fn dataset_begin(&mut self, name: Option<&str>) -> Result<(), GeozeroError>

Begin of dataset processing

fn dataset_end(&mut self) -> Result<(), GeozeroError>

End of dataset processing

fn feature_begin(&mut self, idx: u64) -> Result<(), GeozeroError>

Begin of feature processing

fn properties_begin(&mut self) -> Result<(), GeozeroError>

Begin of feature property processing

fn properties_end(&mut self) -> Result<(), GeozeroError>

End of feature property processing

fn geometry_begin(&mut self) -> Result<(), GeozeroError>

Begin of feature geometry processing

fn geometry_end(&mut self) -> Result<(), GeozeroError>

End of feature geometry processing

impl GeomProcessor for FgbWriter<'_>

fn xy(&mut self, x: f64, y: f64, idx: usize) -> Result<()>

Process coordinate with x,y dimensions

fn coordinate( &mut self, x: f64, y: f64, z: Option<f64>, m: Option<f64>, t: Option<f64>, tm: Option<u64>, idx: usize ) -> Result<()>

Process coordinate with all requested dimensions

fn point_begin(&mut self, idx: usize) -> Result<()>

Begin of Point processing

fn point_end(&mut self, idx: usize) -> Result<()>

End of Point processing

fn multipoint_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of MultiPoint processing

fn multipoint_end(&mut self, idx: usize) -> Result<()>

End of MultiPoint processing

fn linestring_begin( &mut self, tagged: bool, size: usize, idx: usize ) -> Result<()>

Begin of LineString processing

fn linestring_end(&mut self, tagged: bool, idx: usize) -> Result<()>

End of LineString processing

fn multilinestring_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of MultiLineString processing

fn multilinestring_end(&mut self, idx: usize) -> Result<()>

End of MultiLineString processing

fn polygon_begin(&mut self, tagged: bool, size: usize, idx: usize) -> Result<()>

Begin of Polygon processing

fn polygon_end(&mut self, tagged: bool, idx: usize) -> Result<()>

End of Polygon processing

fn multipolygon_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of MultiPolygon processing

fn multipolygon_end(&mut self, idx: usize) -> Result<()>

End of MultiPolygon processing

fn circularstring_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of CircularString processing

fn circularstring_end(&mut self, idx: usize) -> Result<()>

End of CircularString processing

fn compoundcurve_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of CompoundCurve processing

fn compoundcurve_end(&mut self, idx: usize) -> Result<()>

End of CompoundCurve processing

fn curvepolygon_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of CurvePolygon processing

fn curvepolygon_end(&mut self, idx: usize) -> Result<()>

End of CurvePolygon processing

fn multicurve_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of MultiCurve processing

fn multicurve_end(&mut self, idx: usize) -> Result<()>

End of MultiCurve processing

fn multisurface_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of MultiSurface processing

fn multisurface_end(&mut self, idx: usize) -> Result<()>

End of MultiSurface processing

fn triangle_begin( &mut self, tagged: bool, size: usize, idx: usize ) -> Result<()>

Begin of Triangle processing

fn triangle_end(&mut self, tagged: bool, idx: usize) -> Result<()>

End of Triangle processing

fn polyhedralsurface_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of PolyhedralSurface processing

fn polyhedralsurface_end(&mut self, idx: usize) -> Result<()>

End of PolyhedralSurface processing

fn tin_begin(&mut self, size: usize, idx: usize) -> Result<()>

Begin of Tin processing

fn tin_end(&mut self, idx: usize) -> Result<()>

End of Tin processing

fn dimensions(&self) -> CoordDimensions

Additional dimensions requested when processing coordinates

fn multi_dim(&self) -> bool

Request additional dimensions for coordinate processing

fn srid(&mut self, srid: Option<i32>) -> Result<(), GeozeroError>

SRID of geometries

fn empty_point(&mut self, idx: usize) -> Result<(), GeozeroError>

Process empty coordinates, like WKT’s POINT EMPTY

fn geometrycollection_begin( &mut self, size: usize, idx: usize ) -> Result<(), GeozeroError>

Begin of GeometryCollection processing

fn geometrycollection_end(&mut self, idx: usize) -> Result<(), GeozeroError>

End of GeometryCollection processing

impl PropertyProcessor for FgbWriter<'_>

fn property( &mut self, i: usize, colname: &str, colval: &ColumnValue<'_> ) -> Result<bool>

Process property value. Abort processing, if return value is true.