Struct dbase::File

pub struct File<T> { /* private fields */ }

Handle to a dBase File.

A File, allows to both read and write, it also allows to do modifications on an existing file, and enables to only read/modify parts of a file without first having to fully read it.

Example

let mut file = dbase::File::open_read_only("tests/data/stations.dbf")?;

assert_eq!(file.num_records(), 86);

let name_idx = file.field_index("name").unwrap();
let marker_color_idx = file.field_index("marker-col").unwrap();
let marker_symbol_idx = file.field_index("marker-sym").unwrap();

// Test manually reading fields (not in correct order) to FieldValue
let mut rh = file.record(3).unwrap();
let marker_color = rh.field(marker_color_idx).unwrap().read()?;
assert_eq!(
   marker_color,
   dbase::FieldValue::Character(Some("#ff0000".to_string()))
);
let name = rh.field(name_idx).unwrap().read()?;
assert_eq!(
   name,
   dbase::FieldValue::Character(Some("Judiciary Sq".to_string()))
);
let marker_symbol = rh.field(marker_symbol_idx).unwrap().read()?;
assert_eq!(
   marker_symbol,
   dbase::FieldValue::Character(Some("rail-metro".to_string()))
);

Implementations

impl<T> File<T>

pub fn fields(&self) -> &[FieldInfo]

Returns the information about fields present in the records

pub fn field_index(&self, name: &str) -> Option<FieldIndex>

Returns the field index that corresponds to the given name

pub fn num_records(&self) -> usize

Returns the number of records in the file

pub fn set_options(&mut self, options: ReadingOptions)

impl<T: Read + Seek> File<T>

pub fn open(source: T) -> Result<Self, Error>

creates of File using source as the storage space.

pub fn record(&mut self, index: usize) -> Option<RecordRef<'_, T>>

Returns a reference to the record at the given index.

Returns None if no record exist for the given index

pub fn records(&mut self) -> FileRecordIterator<'_, T>

Returns an iterator over the records in the file.

Always starts at the first record

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

pub fn create_new(dst: T, table_info: TableInfo) -> Result<Self, Error>

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

where R: WritableRecord,

pub fn append_records<R>(&mut self, records: &[R]) -> Result<(), Error>

where R: WritableRecord,

pub fn sync_all(&mut self) -> Result<()>

impl File<BufReadWriteFile>

pub fn open_with_options<P: AsRef<Path>>( path: P, options: OpenOptions ) -> Result<Self, Error>

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

Opens an existing dBase file in read only mode

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

Opens an existing dBase file in write only mode

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

Opens an existing dBase file in read and write mode

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

This function will create a file if it does not exist, and will truncate it if it does.