feco3 0.2.0

A library for working with FEC data
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

use super::base::{FileLineWriter, LineWriter, MultiFileLineWriter};
use crate::line::{Line, LineSchema};
use std::{fs::File, path::Path};

/// A [LineWriter] that writes to CSV format.
pub struct CSVLineWriter<W: std::io::Write> {
    csv_writer: csv::Writer<W>,
    schema: LineSchema,
    has_written_header: bool,
}

impl<W: std::io::Write> CSVLineWriter<W> {
    pub fn new(raw_writer: W, schema: &LineSchema) -> Self {
        let writer = csv::WriterBuilder::new()
            .has_headers(false) // We'll write the header ourselves
            .flexible(true)
            .from_writer(raw_writer);
        Self {
            csv_writer: writer,
            schema: schema.clone(),
            has_written_header: false,
        }
    }

    /// Write the header if it hasn't been written yet.
    fn maybe_write_header(&mut self) -> std::io::Result<()> {
        if self.has_written_header {
            return Ok(());
        }
        self.has_written_header = true;
        let fields = &self.schema.fields;
        let field_names = fields.iter().map(|f| f.name.as_str());
        self.csv_writer.write_record(field_names)?;
        Ok(())
    }
}

impl<W: std::io::Write> LineWriter for CSVLineWriter<W> {
    fn write_line(&mut self, line: &Line) -> std::io::Result<()> {
        self.maybe_write_header()?;
        // TODO: Check the length of values vs the schema
        let string_values = line.values.iter().map(|v| v.to_string());
        self.csv_writer.write_record(string_values)?;
        Ok(())
    }
}

/// A [CSVLineWriter] that writes to a file.
pub type CSVFileLineWriter = CSVLineWriter<File>;

impl FileLineWriter for CSVFileLineWriter {
    fn file_name(form_name: String) -> String {
        format!("{}.csv", form_name)
    }

    fn new(path: &Path, schema: &LineSchema) -> std::io::Result<Box<Self>> {
        let file = File::create(path)?;
        let writer = CSVLineWriter::new(file, schema);
        Ok(Box::new(writer))
    }
}

/// A [MultiFileWriter] that writes to CSV files.
pub type CSVMultiFileWriter = MultiFileLineWriter<CSVFileLineWriter>;