quick_csv/
columns.rs

1//! Column management module
2//! 
3//! Provides convenient or fast column conversions
4//! Deserialize columns into a `Decodable` type
5
6use std::str::FromStr;
7use rustc_serialize as serialize;
8use error::{Result, Error};
9use std::slice::Iter;
10
11/// Iterator over bytes slice of columns
12pub struct BytesColumns<'a> {
13    pos: usize,
14    line: &'a [u8],
15    iter: Iter<'a, usize>,
16}
17
18impl<'a> Iterator for BytesColumns<'a> {
19    type Item = &'a [u8];
20
21    fn next(&mut self) -> Option<&'a [u8]> {
22        self.iter.next().map(|p| {
23            let s = &self.line[self.pos..*p];
24            self.pos = *p + 1;
25            if s.starts_with(&[b'\"']) { &s[1..s.len() - 1] } else { s }
26        })
27    }
28
29    fn size_hint(&self) -> (usize, Option<usize>) {
30        self.iter.size_hint()
31    }
32
33}
34
35impl<'a> ExactSizeIterator for BytesColumns<'a> {
36    fn len(&self) -> usize {
37        self.iter.len()
38    }
39}
40
41impl<'a> BytesColumns<'a> {
42
43    /// Creates a new BytesColumns iterator
44    pub fn new(line: &'a [u8], cols: &'a [usize]) -> BytesColumns<'a> {
45        BytesColumns {
46            pos: 0,
47            line: line,
48            iter: cols.iter(),
49        }
50    }
51
52}
53
54/// &str iterator on columns
55pub struct Columns<'a> {
56    pos: usize,
57    line: &'a str,
58    iter: Iter<'a, usize>,
59}
60
61impl<'a> Iterator for Columns<'a> {
62    type Item = &'a str;
63
64    fn next(&mut self) -> Option<&'a str> {
65        self.iter.next().map(|p| {
66            let s = &self.line[self.pos..*p];
67            self.pos = *p + 1;
68            if s.starts_with('\"') { &s[1..s.len() - 1] } else { s }
69        })
70    }
71
72    fn size_hint(&self) -> (usize, Option<usize>) {
73        self.iter.size_hint()
74    }
75
76}
77
78impl<'a> ExactSizeIterator for Columns<'a> {
79    fn len(&self) -> usize {
80        self.iter.len()
81    }
82}
83
84impl<'a> Columns<'a> {
85
86    /// Creates a new Columns iterator
87    pub fn new(line: &'a str, cols: &'a [usize]) -> Columns<'a> {
88        Columns {
89            pos: 0,
90            line: line,
91            iter: cols.iter(),
92        }
93    }
94
95    fn peek(&self) -> Option<&'a str> {
96        self.iter.clone().next().map(|p| {
97            let s = &self.line[self.pos..*p];
98            if s.starts_with('\"') { &s[1..s.len() - 1] } else { s }
99        })
100    }
101
102    fn next_str<T>(&mut self) -> Result<T>
103        where T: FromStr + ::std::fmt::Debug, 
104              T::Err: ::std::fmt::Debug
105    {
106        self.next().ok_or(Error::EOL).and_then(|col|
107            FromStr::from_str(col).map_err(|e|
108                Error::Decode(format!("Failed converting {}th column (\'{}\'):\n\t{:?}", 
109                    self.len(), col, e))))
110    }
111
112    /// Deserializes a Columns iterator into any Decodable type
113    pub fn decode<T: serialize::Decodable>(&mut self) -> Result<T> {
114        serialize::Decodable::decode(self)
115    }
116
117}
118
119impl<'a> serialize::Decoder for Columns<'a> {
120    type Error = Error;
121
122    fn error(&mut self, err: &str) -> Error {
123        Error::Decode(err.into())
124    }
125    fn read_nil(&mut self) -> Result<()> { unimplemented!() }
126    fn read_usize(&mut self) -> Result<usize> { self.next_str() }
127    fn read_u64(&mut self) -> Result<u64> { self.next_str() }
128    fn read_u32(&mut self) -> Result<u32> { self.next_str() }
129    fn read_u16(&mut self) -> Result<u16> { self.next_str() }
130    fn read_u8(&mut self) -> Result<u8> { self.next_str() }
131    fn read_isize(&mut self) -> Result<isize> { self.next_str() }
132    fn read_i64(&mut self) -> Result<i64> { self.next_str() }
133    fn read_i32(&mut self) -> Result<i32> { self.next_str() }
134    fn read_i16(&mut self) -> Result<i16> { self.next_str() }
135    fn read_i8(&mut self) -> Result<i8> { self.next_str() }
136    fn read_bool(&mut self) -> Result<bool> { self.next_str() }
137    fn read_f64(&mut self) -> Result<f64> { self.next_str() }
138    fn read_f32(&mut self) -> Result<f32> { self.next_str() }
139    fn read_char(&mut self) -> Result<char> {
140        let col = try!(self.next().ok_or(Error::EOL));
141        if col.len() != 1 {
142            return Err(Error::Decode(format!(
143                "Expected a single char, found {} chars", col.len())));
144        }
145        Ok(col.chars().next().unwrap())
146    }
147    fn read_str(&mut self) -> Result<String> { self.next_str() }
148    fn read_enum<T, F>(&mut self, _: &str, f: F) -> Result<T>
149            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
150        f(self)
151    }
152
153    fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> Result<T>
154            where F: FnMut(&mut Columns<'a>, usize) -> Result<T> {
155        let i = try!(self
156            .peek()
157            .and_then(|name| names.iter().position(|&n| n == name))
158            .ok_or(Error::Decode(format!(
159                "Could not load value into any variant in {:?}", names))));
160        let _ = self.next();
161        f(self, i)
162    }
163
164    fn read_enum_variant_arg<T, F>(&mut self, _: usize, f: F) -> Result<T>
165            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
166        f(self)
167    }
168    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T>
169            where F: FnMut(&mut Columns<'a>, usize) -> Result<T> {
170        self.read_enum_variant(names, f)
171    }
172    fn read_enum_struct_variant_field<T, F>(&mut self, _: &str,
173                                            f_idx: usize, f: F) -> Result<T>
174            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
175        self.read_enum_variant_arg(f_idx, f)
176    }
177    fn read_struct<T, F>(&mut self, _: &str, _: usize, f: F) -> Result<T>
178            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
179        f(self)
180    }
181    fn read_struct_field<T, F>(&mut self, _: &str, _: usize, f: F) -> Result<T>
182            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
183        f(self)
184    }
185    fn read_tuple<T, F>(&mut self, _: usize, f: F) -> Result<T>
186            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
187        f(self)
188    }
189    fn read_tuple_arg<T, F>(&mut self, _: usize, f: F) -> Result<T>
190            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
191        f(self)
192    }
193    fn read_tuple_struct<T, F>(&mut self, _: &str, _: usize, _: F) -> Result<T>
194            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
195        unimplemented!()
196    }
197    fn read_tuple_struct_arg<T, F>(&mut self, _: usize, _: F) -> Result<T>
198            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
199        unimplemented!()
200    }
201
202    fn read_option<T, F>(&mut self, mut f: F) -> Result<T>
203            where F: FnMut(&mut Columns<'a>, bool) -> Result<T> {
204        let col = try!(self.peek().ok_or(Error::EOL));
205        if col.is_empty() {
206            let _ = self.iter.next();
207            f(self, false)
208        } else {
209            f(self, true).or_else(|_| f(self, false))
210        }
211    }
212
213    fn read_seq<T, F>(&mut self, f: F) -> Result<T>
214            where F: FnOnce(&mut Columns<'a>, usize) -> Result<T> {
215        let len = self.iter.clone().count();
216        f(self, len)
217    }
218    fn read_seq_elt<T, F>(&mut self, _: usize, f: F) -> Result<T>
219            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
220        f(self)
221    }
222    fn read_map<T, F>(&mut self, _: F) -> Result<T>
223            where F: FnOnce(&mut Columns<'a>, usize) -> Result<T> {
224        unimplemented!()
225    }
226    fn read_map_elt_key<T, F>(&mut self, _: usize, _: F) -> Result<T>
227            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
228        unimplemented!()
229    }
230    fn read_map_elt_val<T, F>(&mut self, _: usize, _: F) -> Result<T>
231            where F: FnOnce(&mut Columns<'a>) -> Result<T> {
232        unimplemented!()
233    }
234}
quick_csv/columns.rs

quick_csv/
columns.rs
