Struct TableWriter

pub struct TableWriter<W: Write + Seek> { /* private fields */ }

Structs that writes dBase records to a destination

The only way to create a TableWriter is to use its TableWriterBuilder

Implementations

impl<W: Write + Seek> TableWriter<W>

pub fn write_record<R: WritableRecord>( &mut self, record: &R, ) -> Result<(), Error>

Writes a record the inner destination

Example

use std::convert::TryFrom;

let mut writer = dbase::TableWriterBuilder::new()
    .add_character_field(dbase::FieldName::try_from("First Name").unwrap(), 50)
    .build_with_file_dest("records.dbf")?;

let mut record = dbase::Record::default();
record.insert("First Name".to_string(), dbase::FieldValue::Character(Some("Yoshi".to_string())));

writer.write_record(&record)?;

Ok(())

pub fn write_records<'a, R: WritableRecord + 'a, C: IntoIterator<Item = &'a R>>( self, records: C, ) -> Result<(), Error>

Writes the records to the inner destination

Values for which the number of bytes written would exceed the specified field_length (if it had to be specified) will be truncated

Example

use dbase::{TableWriterBuilder, FieldName, WritableRecord, FieldWriter, ErrorKind, FieldIOError, Encoding};
use std::convert::TryFrom;
use std::io::{Cursor, Write};

struct User {
    first_name: String,
}

impl WritableRecord for User {
    fn write_using<'a, W>(&self,field_writer: &mut FieldWriter<'a, W>) -> Result<(), FieldIOError>
        where W: Write {
        field_writer.write_next_field_value(&self.first_name)
    }
}

let mut cursor = Cursor::new(Vec::<u8>::new());
let writer = TableWriterBuilder::new()
    .add_character_field(FieldName::try_from("First Name").unwrap(), 50)
    .build_with_dest(&mut cursor);

let records = vec![
    User {
        first_name: "Yoshi".to_owned(),
    }
];
writer.write_records(&records).unwrap();
assert_eq!(cursor.position(), 117)

pub fn close(&mut self) -> Result<(), Error>

Close the writer

Automatically closed when the writer is dropped, use it if you want to handle error that can happen when the writer is closing

Calling close on an already closed writer is a no-op

Trait Implementations

impl<T: Write + Seek> Drop for TableWriter<T>

fn drop(&mut self)

Executes the destructor for this type.