peroxide/util/
writer.rs

1//! More convenient matrix writer
2
3pub use self::ToWriter::{Data, Header, Path, Round};
4use std::collections::HashMap;
5//use std::fs::File;
6//use std::io::Write;
7//use std::process::exit;
8use crate::structure::matrix::Matrix;
9
10#[derive(Debug, Clone, Copy, Hash, PartialOrd, PartialEq, Eq)]
11pub enum ToWriter {
12    Header,
13    Round,
14    Data,
15    Path,
16}
17
18#[derive(Debug, Clone, Copy)]
19pub enum Queue {
20    Matrix,
21    Vector,
22}
23
24/// Simple Matrix Writer
25///
26/// # Necessary Fields
27/// * `data: Vec<Matrix>`
28/// * `path: String`
29///
30/// # Option
31/// * `header: Vec<String>`
32/// * `round: u8`
33#[derive(Debug, Clone)]
34pub struct SimpleWriter {
35    header: Vec<String>,
36    round: u8,
37    matrices: Vec<Matrix>,
38    vectors: Vec<Vec<f64>>,
39    path: String,
40    queue: Vec<Queue>,
41    to_write: HashMap<ToWriter, bool>,
42}
43
44impl SimpleWriter {
45    pub fn new() -> SimpleWriter {
46        let mut default_to_write: HashMap<ToWriter, bool> = HashMap::new();
47        default_to_write.insert(Header, false);
48        default_to_write.insert(Round, false);
49        default_to_write.insert(Data, false);
50        default_to_write.insert(Path, false);
51
52        SimpleWriter {
53            header: vec![],
54            round: 0,
55            matrices: vec![],
56            vectors: vec![],
57            path: "".to_string(),
58            queue: vec![],
59            to_write: default_to_write,
60        }
61    }
62
63    pub fn insert_header(&mut self, head: Vec<&str>) -> &mut Self {
64        if let Some(x) = self.to_write.get_mut(&Header) {
65            *x = true
66        }
67        self.header = head
68            .into_iter()
69            .map(|t| t.to_owned())
70            .collect::<Vec<String>>();
71        self
72    }
73
74    pub fn set_round_level(&mut self, nth: u8) -> &mut Self {
75        if let Some(x) = self.to_write.get_mut(&Round) {
76            *x = true
77        }
78        self.round = nth;
79        self
80    }
81
82    pub fn insert_matrix(&mut self, mat: Matrix) -> &mut Self {
83        if let Some(x) = self.to_write.get_mut(&Data) {
84            *x = true
85        }
86        self.matrices.push(mat);
87        self.queue.push(Queue::Matrix);
88        self
89    }
90
91    pub fn insert_vector(&mut self, vec: Vec<f64>) -> &mut Self {
92        if let Some(x) = self.to_write.get_mut(&Data) {
93            *x = true
94        }
95        self.vectors.push(vec);
96        self.queue.push(Queue::Vector);
97        self
98    }
99
100    pub fn set_path(&mut self, path: &str) -> &mut Self {
101        if let Some(x) = self.to_write.get_mut(&Path) {
102            *x = true
103        }
104        self.path = path.to_owned();
105        self
106    }
107
108    pub fn write_csv(self) {
109        unimplemented!()
110    }
111
112    // pub fn write_pickle(&self) {
113    //     let mut writer: Box<dyn Write>;
114
115    //     // Error handling - Path
116    //     if let Some(p) = self.to_write.get(&Path) {
117    //         assert!(*p, "No determined path!");
118    //     }
119
120    //     // Error handling - Data
121    //     if let Some(dat) = self.to_write.get(&Data) {
122    //         assert!(*dat, "No inserted data!");
123    //     }
124
125    //     match File::create(self.path.clone()) {
126    //         Ok(p) => writer = Box::new(p),
127    //         Err(e) => {
128    //             println!("{:?}", e);
129    //             exit(1);
130    //         }
131    //     }
132
133    //     if let Some(head) = self.to_write.get(&Header) {
134    //         if *head {
135    //             serde_pickle::to_writer(&mut writer, &self.header, true)
136    //                 .expect("Can't write header to pickle");
137    //         }
138    //     }
139
140    //     let mut queued = self.queue.clone().into_iter();
141    //     let mut matrices = self.matrices.clone().into_iter();
142    //     let mut vectors = self.vectors.clone().into_iter();
143
144    //     loop {
145    //         match queued.next() {
146    //             Some(Queue::Matrix) => {
147    //                 let mat = matrices.next().unwrap();
148    //                 mat.write_pickle(&mut writer)
149    //                     .expect("Can't insert matrices");
150    //             }
151    //             Some(Queue::Vector) => {
152    //                 let vec = vectors.next().unwrap();
153    //                 vec.write_pickle(&mut writer).expect("Can't insert vectors");
154    //             }
155    //             None => return,
156    //         }
157    //     }
158    // }
159}
peroxide/util/writer.rs

peroxide/util/
writer.rs
