feco3 0.3.0

A library for working with .fec files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::fs::File;
use std::io::Read;
use std::mem::take;
use std::path::PathBuf;

use crate::cover::{parse_cover_line, Cover};
use crate::csv::{CsvReader, Sep};
use crate::header::{parse_header, Header};
use crate::Error;

/// A FEC file, the core data structure of this crate.
///
/// You create a FecFile from a stream of bytes (e.g. a file, an HTTP stream,
/// a python callback function, or some other custom source).
///
/// All methods are lazy and streaming, so nothing is read from the source
/// until you call a method that requires it.
pub struct FecFile {
    /// The source of raw bytes
    reader: Option<Box<dyn Read + Send>>,
    header: Option<Header>,
    cover: Option<Cover>,
    sep: Option<Sep>,
    /// After reading the header, this contains the CSV reader
    /// that will be used to read the rest of the file.
    csv_reader: Option<CsvReader<Box<dyn Read + Send>>>,
}

impl FecFile {
    pub fn from_reader(reader: Box<dyn Read + Send>) -> Self {
        Self {
            reader: Some(reader),
            header: None,
            cover: None,
            sep: None,
            csv_reader: None,
        }
    }

    pub fn from_path(path: &PathBuf) -> Result<Self, Error> {
        let file = File::open(path)?;
        Ok(Self::from_reader(Box::new(file)))
    }

    pub fn get_header(&mut self) -> Result<&Header, Error> {
        self.parse_header()?;
        Ok(self.header.as_ref().expect("header should be set"))
    }

    // TODO: should this not return a reference?
    pub fn get_cover(&mut self) -> Result<&Cover, Error> {
        self.parse_cover()?;
        Ok(self.cover.as_ref().expect("cover should be set"))
    }

    // panics if the header hasn't been parsed yet
    fn fec_version(&self) -> String {
        self.header.as_ref().expect("No header").fec_version.clone()
    }

    pub fn next_line(&mut self) -> Option<Result<Vec<String>, Error>> {
        match self.parse_cover() {
            Err(e) => return Some(Err(e)),
            Ok(_) => (),
        }
        let p = self.csv_reader.as_mut().expect("No row parser");
        match p.next_line() {
            None => return None,
            Some(Ok(line)) => Some(Ok(line)),
            Some(Err(e)) => return Some(Err(Error::RecordParseError(e.to_string()))),
        }
    }

    pub fn lines(&mut self) -> LineIter {
        LineIter { fec_file: self }
    }

    fn parse_header(&mut self) -> Result<(), Error> {
        if self.header.is_some() {
            return Ok(());
        }
        let reader = self.reader.as_mut().expect("no reader");
        let header_parsing = parse_header(reader).map_err(Error::HeaderParseError)?;
        self.header = Some(header_parsing.header.clone());
        self.sep = Some(header_parsing.sep.clone());
        Ok(())
    }

    fn parse_cover(&mut self) -> Result<(), Error> {
        if self.cover.is_some() {
            return Ok(());
        }
        self.make_csv_parser()?;
        let fec_version = &self.fec_version().clone();
        let p = self.csv_reader.as_mut().expect("No row parser");
        let line = match p.next_line() {
            None => return Err(Error::CoverParseError("no cover record".to_string())),
            Some(Ok(record)) => record,
            Some(Err(e)) => return Err(Error::CoverParseError(e.to_string())),
        };
        self.cover = Some(parse_cover_line(fec_version, &mut line.iter())?);
        Ok(())
    }

    fn make_csv_parser(&mut self) -> Result<(), Error> {
        if self.csv_reader.is_some() {
            return Ok(());
        }
        self.parse_header()?;
        let sep = self.sep.as_ref().expect("No sep");
        if self.csv_reader.is_none() {
            // Hand off the reader ownership to the row parser.
            let reader = take(&mut self.reader).expect("no reader");
            self.csv_reader = Some(CsvReader::new(reader, sep));
        }
        Ok(())
    }
}

pub struct LineIter<'a> {
    fec_file: &'a mut FecFile,
}

impl<'a> Iterator for LineIter<'a> {
    type Item = Result<Vec<String>, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        self.fec_file.next_line()
    }
}