Struct Writer

pub struct Writer<T: Write + Seek> { /* private fields */ }

The Writer writes a complete shapefile that is, it writes the 3 mandatory files (.shp, .shx, .dbf)

The recommended way to create a new shapefile is via the Writer::from_path or Writer::from_path_with_info associated functions.

Examples

To create a Writer that writes a .dbf file that has the same structure as .dbf read earlier you will have to do:

let mut reader = shapefile::Reader::from_path("tests/data/multipatch.shp")?;
let shape_records = reader.read()?;
let table_info = reader.into_table_info();

let writer = shapefile::Writer::from_path_with_info("new_multipatch.shp", table_info);

Implementations

impl<T: Write + Seek> Writer<T>

pub fn new(shape_writer: ShapeWriter<T>, dbase_writer: TableWriter<T>) -> Self

Creates a new writer using the provided ShapeWriter and TableWriter

Example

Creating a Writer that writes to in memory buffers.

use std::convert::TryInto;
let mut shp_dest = std::io::Cursor::new(Vec::<u8>::new());
let mut shx_dest = std::io::Cursor::new(Vec::<u8>::new());
let mut dbf_dest = std::io::Cursor::new(Vec::<u8>::new());

let shape_writer = shapefile::ShapeWriter::with_shx(&mut shp_dest, &mut shx_dest);
let dbase_writer = dbase::TableWriterBuilder::new()
    .add_character_field("Name".try_into().unwrap(), 50)
    .build_with_dest(&mut dbf_dest);

let shape_writer = shapefile::Writer::new(shape_writer, dbase_writer);

pub fn write_shape_and_record<S: EsriShape, R: WritableRecord>( &mut self, shape: &S, record: &R, ) -> Result<(), Error>

Examples found in repository

examples/create.rs (line 34)

fn example_1() {
    const FILE_NAME: &str = "hello_shape_1.shp";

    let square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 1.0),
        Point::new(1.0, 1.0),
        Point::new(1.0, 0.0),
    ]);

    let bigger_square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 10.0),
        Point::new(10.0, 10.0),
        Point::new(10.0, 0.0),
    ]);

    // Create the builder for the accompanying dbase (.dbf) file
    // For this simple example we will only have a single field
    // "Name", with 55 chars max
    let table_builder =
        TableWriterBuilder::new().add_character_field("Name".try_into().unwrap(), 55);

    {
        let mut writer = Writer::from_path(FILE_NAME, table_builder)
            .expect("Failed to create the shapefile writer");

        let mut first_record = dbase::Record::default();
        first_record.insert("Name".to_string(), "Square".to_string().into());
        writer
            .write_shape_and_record(&square, &first_record)
            .expect("Failed to write first record");

        let mut second_record = dbase::Record::default();
        second_record.insert("Name".to_string(), "Big Square".to_string().into());
        writer
            .write_shape_and_record(&bigger_square, &second_record)
            .expect("Failed to write second record");
    }

    println!("File created, you can use `cargo run --example print-content {FILE_NAME}`");
}

fn example_2() {
    dbase_record!(
        #[derive(Debug)]
        struct UserRecord {
            first_name: String,
            last_name: String,
        }
    );

    const FILE_NAME: &str = "hello_shape_2.shp";

    let square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 1.0),
        Point::new(1.0, 1.0),
        Point::new(1.0, 0.0),
    ]);

    let bigger_square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 10.0),
        Point::new(10.0, 10.0),
        Point::new(10.0, 0.0),
    ]);

    // Create the builder for the accompanying dbase (.dbf) file
    let table_builder = TableWriterBuilder::new()
        .add_character_field("FirstName".try_into().unwrap(), 55)
        .add_character_field("LastName".try_into().unwrap(), 55);

    {
        let mut writer = Writer::from_path(FILE_NAME, table_builder)
            .expect("Failed to create the shapefile writer");

        let first_record = UserRecord {
            first_name: "Yoshi".to_string(),
            last_name: "Green".to_string(),
        };

        writer
            .write_shape_and_record(&square, &first_record)
            .expect("Failed to write first record");

        let second_record = UserRecord {
            first_name: "Yoshi".to_string(),
            last_name: "Red".to_string(),
        };
        writer
            .write_shape_and_record(&bigger_square, &second_record)
            .expect("Failed to write second record");
    }

    println!("File created, you can use `cargo run --example print-content {FILE_NAME}`");
}

pub fn write_shapes_and_records<'a, S: EsriShape + 'a, R: WritableRecord + 'a, C: IntoIterator<Item = (&'a S, &'a R)>>( self, container: C, ) -> Result<(), Error>

impl Writer<BufWriter<File>>

pub fn from_path<P: AsRef<Path>>( path: P, table_builder: TableWriterBuilder, ) -> Result<Self, Error>

Creates all the files needed for the shapefile to be complete (.shp, .shx, .dbf)

use std::convert::TryInto;
let table_builder = dbase::TableWriterBuilder::new()
    .add_character_field("name".try_into().unwrap(), 50);
let writer = shapefile::Writer::from_path("new_cities.shp", table_builder)?;

Examples found in repository

examples/create.rs (line 28)

fn example_1() {
    const FILE_NAME: &str = "hello_shape_1.shp";

    let square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 1.0),
        Point::new(1.0, 1.0),
        Point::new(1.0, 0.0),
    ]);

    let bigger_square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 10.0),
        Point::new(10.0, 10.0),
        Point::new(10.0, 0.0),
    ]);

    // Create the builder for the accompanying dbase (.dbf) file
    // For this simple example we will only have a single field
    // "Name", with 55 chars max
    let table_builder =
        TableWriterBuilder::new().add_character_field("Name".try_into().unwrap(), 55);

    {
        let mut writer = Writer::from_path(FILE_NAME, table_builder)
            .expect("Failed to create the shapefile writer");

        let mut first_record = dbase::Record::default();
        first_record.insert("Name".to_string(), "Square".to_string().into());
        writer
            .write_shape_and_record(&square, &first_record)
            .expect("Failed to write first record");

        let mut second_record = dbase::Record::default();
        second_record.insert("Name".to_string(), "Big Square".to_string().into());
        writer
            .write_shape_and_record(&bigger_square, &second_record)
            .expect("Failed to write second record");
    }

    println!("File created, you can use `cargo run --example print-content {FILE_NAME}`");
}

fn example_2() {
    dbase_record!(
        #[derive(Debug)]
        struct UserRecord {
            first_name: String,
            last_name: String,
        }
    );

    const FILE_NAME: &str = "hello_shape_2.shp";

    let square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 1.0),
        Point::new(1.0, 1.0),
        Point::new(1.0, 0.0),
    ]);

    let bigger_square = Polyline::new(vec![
        Point::new(0.0, 0.0),
        Point::new(0.0, 10.0),
        Point::new(10.0, 10.0),
        Point::new(10.0, 0.0),
    ]);

    // Create the builder for the accompanying dbase (.dbf) file
    let table_builder = TableWriterBuilder::new()
        .add_character_field("FirstName".try_into().unwrap(), 55)
        .add_character_field("LastName".try_into().unwrap(), 55);

    {
        let mut writer = Writer::from_path(FILE_NAME, table_builder)
            .expect("Failed to create the shapefile writer");

        let first_record = UserRecord {
            first_name: "Yoshi".to_string(),
            last_name: "Green".to_string(),
        };

        writer
            .write_shape_and_record(&square, &first_record)
            .expect("Failed to write first record");

        let second_record = UserRecord {
            first_name: "Yoshi".to_string(),
            last_name: "Red".to_string(),
        };
        writer
            .write_shape_and_record(&bigger_square, &second_record)
            .expect("Failed to write second record");
    }

    println!("File created, you can use `cargo run --example print-content {FILE_NAME}`");
}

pub fn from_path_with_info<P: AsRef<Path>>( path: P, table_info: TableInfo, ) -> Result<Self, Error>