Struct fixed_width::Reader

pub struct Reader<R> {
    pub record_width: usize,
    pub linebreak: LineBreak,
    // some fields omitted
}

A fixed width data reader. It parses fixed width data and provides the data via iterators.

Example

Parsing fixed width data into a struct;

#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate fixed_width;

use fixed_width::{Field, FixedWidth, Reader};
use serde::Deserialize;
use std::result;

#[derive(Deserialize)]
struct Foo {
    name: String,
    age: usize,
}

// can be derived using the `fixed_width_derive` crate.
impl FixedWidth for Foo {
    fn fields() -> Vec<Field> {
        vec![
            Field::default().range(0..6),
            Field::default().range(6..10),
        ]
    }
}

fn main() {
    let data = "foobar1234foobaz6789";
    let mut reader = Reader::from_string(data).width(10);

    for row in reader.byte_reader().filter_map(result::Result::ok) {
        let record: Foo = fixed_width::from_bytes(&row).unwrap();

        println!("{}", record.name);
        println!("{}", record.age);
    }
}

Example

Parsing fixed width data into a HashMap<String, String>:

extern crate serde;
extern crate fixed_width;

use fixed_width::{Field, FixedWidth, Deserializer, Reader};
use std::collections::HashMap;
use serde::Deserialize;

fn main() {
    let data = "foobar1234foobaz6789";
    let mut reader = Reader::from_string(data).width(10);
    let fields = vec![
        Field::default().range(0..6).name(Some("name")),
        Field::default().range(6..10).name(Some("age")),
    ];

    for row in reader.byte_reader() {
        let bytes = row.unwrap();
        let mut de = Deserializer::new(&bytes, fields.clone());
        let record: HashMap<String, String> = HashMap::deserialize(&mut de).unwrap();

        println!("{}", record.get("name").unwrap());
        println!("{}", record.get("age").unwrap());
    }
}

Example

Parsing fixed width data into Vec<String>:

use fixed_width::Reader;

let data = "foobar1234foobaz6789";

let mut reader = Reader::from_string(data).width(10);

for row in reader.string_reader() {
    println!("{:?}", row);
}

Example

Parsing fixed width data into Vec<Vec<u8>>:

use fixed_width::Reader;

let data = "foobar1234foobaz6789";

let mut reader = Reader::from_string(data).width(10);

for row in reader.byte_reader() {
    println!("{:?}", row);
}

Example

Read each line without copying:

use fixed_width::Reader;

let data = "foobar1234foobaz6789";

let mut reader = Reader::from_string(data).width(10);

if let Some(Ok(row)) = reader.next_record() {
    assert_eq!(row, b"foobar1234");
}

if let Some(Ok(row)) = reader.next_record() {
    assert_eq!(row, b"foobaz6789");
}

Fields

record_width: usize

The width in bytes of the record. Required in order to parse.

linebreak: LineBreak

The line break that occurs between each record. Defaults to LineBreak::None

Methods

impl<R> Reader<R> where
    R: Read, 

pub fn from_reader(rdr: R) -> Self

Creates a new reader from any type that implements io::Read.

Important traits for StringReader<'a, R>

impl<'a, R> Iterator for StringReader<'a, R> where
    R: Read,  type Item = Result<String>;

pub fn string_reader(&mut self) -> StringReader<R>

Reads each record of the data as a String. If the data is not valid UTF-8, then you should use byte_reader instead.

Example

use fixed_width::Reader;

let mut reader = Reader::from_string("abcd1234").width(8);

for record in reader.string_reader() {
    assert_eq!(record.unwrap(), "abcd1234")
}

Important traits for ByteReader<'a, R>

impl<'a, R> Iterator for ByteReader<'a, R> where
    R: Read,  type Item = Result<Vec<u8>>;

pub fn byte_reader(&mut self) -> ByteReader<R>

Reads each record of the data as a Vec<u8>.

Example

use fixed_width::Reader;

let mut reader = Reader::from_bytes("abcd1234".as_bytes()).width(8);

for record in reader.byte_reader() {
    assert_eq!(record.unwrap(), b"abcd1234".to_vec())
}

pub fn next_record(&mut self) -> Option<Result<&[u8]>>

Reads the next record as a byte slice

Example

use fixed_width::Reader;

let data = "foobar1234foobaz6789";

let mut reader = Reader::from_string(data).width(10);

if let Some(Ok(row)) = reader.next_record() {
    assert_eq!(row, b"foobar1234");
}

if let Some(Ok(row)) = reader.next_record() {
    assert_eq!(row, b"foobaz6789");
}

pub fn width(self, width: usize) -> Self

Defines the width of each record in the file. It is required to set prior to reading since fixed width data is not self describing. Consumers must tell the reader how many bytes to read for each field. Do not include linebreaks in the width, you should only define a width to be the number of bytes in the record data itself.

Example

use fixed_width::Reader;
use std::result;

let data = "foobar";
let mut reader = Reader::from_string(data).width(3);
let records: Vec<String> = reader.string_reader().filter_map(result::Result::ok).collect();

assert_eq!(records, vec!["foo".to_string(), "bar".to_string()]);

Example

With a LineBreak specified:

use fixed_width::{LineBreak, Reader};
use std::result;

let data = "foo\nbar";
let mut reader = Reader::from_string(data).width(3).linebreak(LineBreak::Newline);
let records: Vec<String> = reader.string_reader().filter_map(result::Result::ok).collect();

assert_eq!(records, vec!["foo".to_string(), "bar".to_string()]);

pub fn linebreak(self, linebreak: LineBreak) -> Self

Defines the linebreak to use while reading data. Defaults to LineBreak::None, which means there are no bytes between records.

Example

use fixed_width::{LineBreak, Reader};
use std::result;

let data = "foo\r\nbar";
let mut reader = Reader::from_string(data).width(3).linebreak(LineBreak::CRLF);
let records: Vec<String> = reader.string_reader().filter_map(result::Result::ok).collect();

assert_eq!(records, vec!["foo".to_string(), "bar".to_string()]);

impl Reader<File>

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self>

Creates a new reader from a filepath. Will return an io::Error if there are any issues opening the file.

impl Reader<Cursor<Vec<u8>>>

pub fn from_bytes<T>(bytes: T) -> Self where
    T: Into<Vec<u8>>, 

Creates a new reader from a series of bytes.

pub fn from_string<T>(s: T) -> Self where
    T: Into<String>, 

Creates a new reader from a String or &str.

Trait Implementations

impl<R> Read for Reader<R> where
    R: Read, 

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.