datapipe 0.1.4

Stream data from here to there
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

/// This struct gives all the parameters needed to start a datapipe instance
use crate::datapipe_types::DatapipeError;
use crate::encryption::{StreamDecryptor, StreamEncryptor};
use crate::reader::Reader;
use crate::writer::Writer;
use log::error;

/// Parameters needed to run datapipe
pub struct Parameters {
    pub reader: Reader,
    pub maybe_decryptor: Option<StreamDecryptor>,
    pub maybe_encryptor: Option<StreamEncryptor>,
    pub writers: Vec<Writer>,
}

impl std::default::Default for Parameters {
    fn default() -> Self {
        Self {
            reader: Reader::default(),
            maybe_decryptor: None,
            maybe_encryptor: None,
            writers: vec![Writer::default()],
        }
    }
}

#[test]
fn test_parameters_builder_build() {
    use crate::stdin_reader::StdinReader;
    use crate::stdout_writer::StdoutWriter;

    let _parameters = ParametersBuilder::new()
        .reader(Reader::from(StdinReader::new()))
        .writer(Writer::from(StdoutWriter::new()))
        .build()
        .unwrap();
}

/// Builder for Parameters
pub struct ParametersBuilder {
    maybe_reader: Option<Reader>,
    maybe_decryptor: Option<StreamDecryptor>,
    maybe_encryptor: Option<StreamEncryptor>,
    writers: Vec<Writer>,
}

impl ParametersBuilder {
    pub fn new() -> Self {
        Self {
            maybe_reader: None,
            maybe_decryptor: None,
            maybe_encryptor: None,
            writers: Vec::new(),
        }
    }

    pub fn reader(mut self, reader: Reader) -> Self {
        self.maybe_reader = Some(reader);
        self
    }

    pub fn decryptor(mut self, decryptor: StreamDecryptor) -> Self {
        self.maybe_decryptor = Some(decryptor);
        self
    }

    pub fn encryptor(mut self, encryptor: StreamEncryptor) -> Self {
        self.maybe_encryptor = Some(encryptor);
        self
    }

    pub fn writer(mut self, writer: Writer) -> Self {
        self.writers.push(writer);
        self
    }

    pub fn build(self) -> Result<Parameters, DatapipeError> {
        if self.maybe_reader.is_none() {
            let error_message =
                "No input source!  Please configure a Reader to provide input.".to_string();
            error!("{error_message}");
            return Err(DatapipeError::ValidationError(error_message));
        }
        if self.writers.is_empty() {
            let error_message =
                "No output destination!  Please configure a Writer for output.".to_string();
            error!("{error_message}");
            return Err(DatapipeError::ValidationError(error_message));
        }
        Ok(Parameters {
            reader: self.maybe_reader.unwrap(),
            maybe_decryptor: self.maybe_decryptor,
            maybe_encryptor: self.maybe_encryptor,
            writers: self.writers,
        })
    }
}

impl Default for ParametersBuilder {
    fn default() -> Self {
        Self::new()
    }
}