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 finalize(&mut self) -> Result<(), Error>

Finalize the writer

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

Calling finalize on an already finalize writer is a no-op

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

👎Deprecated: Use finalize instead

Trait Implementations

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

fn drop(&mut self)

Executes the destructor for this type.