Struct dbase::TableWriter

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

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};
use std::convert::TryFrom;
use std::io::{Cursor, Write};

struct User {
    first_name: String,
}

impl WritableRecord for User {
    fn write_using<'a, W: Write>(&self,field_writer: &mut FieldWriter<'a, W>) -> Result<(), FieldIOError> {
        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)

Trait Implementations

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

fn drop(&mut self)

Executes the destructor for this type.