asyncio/
buffers.rs

1use error::eof;
2
3use std::io;
4use std::cmp;
5use std::ffi::CString;
6
7fn length_error() -> io::Error {
8    io::Error::new(io::ErrorKind::Other, "Length error")
9}
10
11/// Automatically resizing buffer.
12#[derive(Clone, Debug)]
13pub struct StreamBuf {
14    buf: Vec<u8>,
15    max: usize,
16    cur: usize,
17    beg: usize,
18}
19
20impl StreamBuf {
21    /// Returns a new `StreamBuf`.
22    ///
23    /// Equivalent to `with_max_len(usize::max_len())`
24    ///
25    /// # Examples
26    ///
27    /// ```
28    /// use asyncio::StreamBuf;
29    ///
30    /// let mut sbuf = StreamBuf::new();
31    /// ```
32    pub fn new() -> StreamBuf {
33        Self::with_max_len(usize::max_value())
34    }
35
36    /// Returns a new `StreamBuf` with the max length of the allocatable size.
37    ///
38    /// # Examples
39    ///
40    /// ```
41    /// use asyncio::StreamBuf;
42    ///
43    /// let mut sbuf = StreamBuf::with_max_len(1024);
44    /// ```
45    pub fn with_max_len(max: usize) -> StreamBuf {
46        StreamBuf {
47            buf: Vec::new(),
48            max: max,
49            cur: 0,
50            beg: 0,
51        }
52    }
53
54    /// Returns an allocated size of the buffer.
55    ///
56    /// # Examples
57    ///
58    /// ```
59    /// use asyncio::StreamBuf;
60    ///
61    /// let mut sbuf = StreamBuf::new();
62    /// assert_eq!(sbuf.capacity(), 0);
63    /// ```
64    pub fn capacity(&self) -> usize {
65        self.buf.capacity()
66    }
67
68    /// Clears the buffer, removing all values.
69    ///
70    /// # Examples
71    ///
72    /// ```
73    /// use asyncio::StreamBuf;
74    ///
75    /// let mut sbuf = StreamBuf::from(vec![1,2,3]);
76    /// sbuf.clear();
77    /// assert_eq!(sbuf.is_empty(), true);
78    /// ```
79    pub fn clear(&mut self) {
80        self.buf.clear();
81        self.cur = 0;
82        self.beg = 0;
83    }
84
85    /// Remove characters from the input sequence.
86    ///
87    /// # Examples
88    ///
89    /// ```
90    /// use asyncio::StreamBuf;
91    ///
92    /// let mut sbuf = StreamBuf::from(vec![1,2,3]);
93    /// assert_eq!(sbuf.len(), 3);
94    /// sbuf.consume(3);
95    /// assert_eq!(sbuf.len(), 0);
96    /// ```
97    pub fn consume(&mut self, len: usize) {
98        if len >= self.len() {
99            self.clear()
100        } else {
101            self.beg += len;
102        }
103    }
104
105    /// Move characters from the output sequence to the input sequence.
106    ///
107    /// # Examples
108    ///
109    /// ```
110    /// use asyncio::StreamBuf;
111    ///
112    /// let mut sbuf = StreamBuf::new();
113    /// let _ = sbuf.prepare(256);
114    /// assert_eq!(sbuf.len(), 0);
115    /// sbuf.commit(3);
116    /// assert_eq!(sbuf.len(), 3);
117    /// ```
118    pub fn commit(&mut self, len: usize) {
119        self.cur = cmp::min(self.cur + len, self.buf.len());
120    }
121
122    /// Returns `true` if the empty buffer.
123    ///
124    /// # Examples
125    ///
126    /// ```
127    /// use asyncio::StreamBuf;
128    ///
129    /// let sbuf = StreamBuf::new();
130    /// assert!(sbuf.is_empty());
131    /// ```
132    pub fn is_empty(&self) -> bool {
133        self.buf.is_empty()
134    }
135
136    /// Returns a length of the input sequence.
137    ///
138    /// # Examples
139    ///
140    /// ```
141    /// use asyncio::StreamBuf;
142    ///
143    /// let sbuf = StreamBuf::from(vec![1,2,3]);
144    /// assert_eq!(sbuf.len(), 3);
145    /// ```
146    pub fn len(&self) -> usize {
147        self.cur - self.beg
148    }
149
150    /// Returns a maximum length of the `StreamBuf`.
151    ///
152    /// # Examples
153    ///
154    /// ```
155    /// use asyncio::StreamBuf;
156    ///
157    /// let sbuf = StreamBuf::new();
158    /// assert_eq!(sbuf.max_len(), usize::max_value());
159    /// ```
160    pub fn max_len(&self) -> usize {
161        self.max
162    }
163
164    /// Returns a `&mut [u8]` that represents a output sequence.
165    ///
166    /// # Examples
167    ///
168    /// ```
169    /// use asyncio::StreamBuf;
170    ///
171    /// let mut sbuf = StreamBuf::with_max_len(8);
172    /// assert_eq!(sbuf.prepare(5).unwrap().len(), 5);
173    /// sbuf.commit(5);
174    /// assert_eq!(sbuf.prepare(5).unwrap().len(), 3);
175    /// ```
176    pub fn prepare(&mut self, len: usize) -> io::Result<&mut [u8]> {
177        if self.cur + len <= self.max {
178            self.buf.reserve(self.cur + len);
179            unsafe { self.buf.set_len(self.cur + len) };
180            Ok(&mut self.buf[self.cur..])
181        } else if self.beg >= len {
182            self.buf.drain(..self.beg);
183            self.cur -= self.beg;
184            unsafe { self.buf.set_len(len) };
185            Ok(&mut self.buf[self.cur..])
186        } else if self.len() < self.max {
187            self.buf.drain(..self.beg);
188            self.buf.reserve(self.max);
189            self.cur -= self.beg;
190            unsafe { self.buf.set_len(self.max) };
191            Ok(&mut self.buf[self.cur..])
192        } else {
193            Err(length_error())
194        }
195    }
196
197    /// Returns a `&mut [u8]` that represents a output sequence.
198    ///
199    /// # Examples
200    ///
201    /// ```
202    /// use asyncio::StreamBuf;
203    ///
204    /// let mut sbuf = StreamBuf::with_max_len(8);
205    /// assert_eq!(sbuf.prepare_exact(5).unwrap().len(), 5);
206    /// sbuf.commit(5);
207    /// assert!(sbuf.prepare_exact(5).is_err());
208    /// ```
209    pub fn prepare_exact(&mut self, len: usize) -> io::Result<&mut [u8]> {
210        if self.cur + len <= self.max {
211            self.buf.reserve(self.cur + len);
212            unsafe { self.buf.set_len(self.cur + len) };
213            Ok(&mut self.buf[self.cur..])
214        } else if self.beg >= len {
215            self.buf.drain(..self.beg);
216            self.cur -= self.beg;
217            unsafe { self.buf.set_len(len) };
218            Ok(&mut self.buf[self.cur..])
219        } else {
220            Err(length_error())
221        }
222    }
223
224    /// Returns a `&[u8]` that represents the input sequence.
225    pub fn as_slice(&self) -> &[u8] {
226        &self.buf[self.beg..self.cur]
227    }
228
229    /// Returns a `&mut [u8]` that represents the input sequence.
230    pub fn as_mut_slice(&mut self) -> &mut [u8] {
231        &mut self.buf[self.beg..self.cur]
232    }
233}
234
235impl Default for StreamBuf {
236    fn default() -> Self {
237        StreamBuf::new()
238    }
239}
240
241impl AsRef<StreamBuf> for StreamBuf {
242    fn as_ref(&self) -> &StreamBuf {
243        self
244    }
245}
246
247impl AsMut<StreamBuf> for StreamBuf {
248    fn as_mut(&mut self) -> &mut StreamBuf {
249        self
250    }
251}
252
253impl AsRef<[u8]> for StreamBuf {
254    fn as_ref(&self) -> &[u8] {
255        self.as_slice()
256    }
257}
258
259impl AsMut<[u8]> for StreamBuf {
260    fn as_mut(&mut self) -> &mut [u8] {
261        self.as_mut_slice()
262    }
263}
264
265impl From<Vec<u8>> for StreamBuf {
266    fn from(buf: Vec<u8>) -> Self {
267        let len = buf.len();
268        StreamBuf {
269            buf: buf,
270            max: usize::max_value(),
271            cur: len,
272            beg: 0,
273        }
274    }
275}
276
277impl From<CString> for StreamBuf {
278    fn from(buf: CString) -> Self {
279        StreamBuf::from(Vec::from(buf))
280    }
281}
282
283impl<'a> From<&'a [u8]> for StreamBuf {
284    fn from(buf: &'a [u8]) -> Self {
285        StreamBuf::from(Vec::from(buf))
286    }
287}
288
289impl<'a> From<&'a str> for StreamBuf {
290    fn from(buf: &'a str) -> Self {
291        StreamBuf::from(Vec::from(buf))
292    }
293}
294
295impl io::Read for StreamBuf {
296    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
297        let len = cmp::min(self.len(), buf.len());
298        if len > 0 {
299            buf[..len].clone_from_slice(&self.buf[self.beg..self.beg + len]);
300            self.consume(len);
301            Ok(len)
302        } else {
303            Err(eof())
304        }
305    }
306}
307
308impl io::Write for StreamBuf {
309    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
310        let len = buf.len();
311        try!(self.prepare_exact(len)).clone_from_slice(&buf[..len]);
312        self.commit(len);
313        Ok(len)
314    }
315
316    fn flush(&mut self) -> io::Result<()> {
317        Ok(())
318    }
319}
320
321#[test]
322fn test_streambuf() {
323    let sbuf = StreamBuf::with_max_len(100);
324    assert_eq!(sbuf.len(), 0);
325    assert_eq!(sbuf.max_len(), 100);
326}
327
328#[test]
329fn test_streambuf_prepare() {
330    let mut sbuf = StreamBuf::with_max_len(100);
331    assert_eq!(sbuf.prepare(100).unwrap().len(), 100);
332    sbuf.commit(70);
333    assert_eq!(sbuf.len(), 70);
334    assert_eq!(sbuf.prepare(70).unwrap().len(), 30);
335    sbuf.commit(70);
336    assert_eq!(sbuf.len(), 100);
337}
338
339#[test]
340fn test_streambuf_prepare_exact() {
341    let mut sbuf = StreamBuf::with_max_len(100);
342    assert_eq!(sbuf.prepare_exact(70).unwrap().len(), 70);
343    sbuf.commit(70);
344    assert_eq!(sbuf.len(), 70);
345    assert!(sbuf.prepare_exact(70).is_err());
346    sbuf.commit(70);
347    assert_eq!(sbuf.len(), 70);
348}
349
350#[test]
351fn test_streambuf_as_slice() {
352    let mut sbuf = StreamBuf::new();
353    sbuf.prepare(1000).unwrap();
354    sbuf.commit(100);
355    assert_eq!(sbuf.as_slice().len(), 100);
356    sbuf.commit(10);
357    assert_eq!(sbuf.as_mut_slice().len(), 110);
358}
359
360#[test]
361fn test_streambuf_consume() {
362    let mut sbuf = StreamBuf::with_max_len(100);
363    assert_eq!(sbuf.prepare(1).unwrap().len(), 1);
364    assert_eq!(sbuf.prepare(100).unwrap().len(), 100);
365    assert_eq!(sbuf.len(), 0);
366    sbuf.commit(1);
367    assert_eq!(sbuf.len(), 1);
368    assert!(sbuf.prepare_exact(100).is_err());
369    sbuf.consume(1);
370    assert_eq!(sbuf.len(), 0);
371    assert!(sbuf.prepare_exact(100).is_ok());
372}
373
374#[test]
375fn test_streambuf_from_vec() {
376    let mut sbuf = StreamBuf::from(vec![1,2,3,4,5,6,7,8,9,10]);
377    assert_eq!(sbuf.len(), 10);
378    sbuf.consume(9);
379    assert_eq!(sbuf.as_slice()[0], 10);
380}
381
382#[test]
383fn test_streambuf_read() {
384    use std::io::Read;
385
386    let mut sbuf = StreamBuf::from(vec![1,2,3,4,5,6,7,8,9]);
387    let mut buf = [0; 5];
388    assert_eq!(sbuf.read(&mut buf).unwrap(), 5);
389    assert_eq!(buf, [1,2,3,4,5]);
390    assert_eq!(sbuf.read(&mut buf).unwrap(), 4);
391    assert_eq!(buf, [6,7,8,9,5]);
392    assert!(sbuf.read(&mut buf).is_err());
393}
394
395#[test]
396fn test_streambuf_write() {
397    use std::io::Write;
398
399    let mut sbuf = StreamBuf::with_max_len(9);
400    assert_eq!(sbuf.write(&[1,2,3,4,5]).unwrap(), 5);
401    assert_eq!(sbuf.as_slice(), &[1,2,3,4,5]);
402    assert_eq!(sbuf.write(&[6,7,8,9]).unwrap(), 4);
403    assert_eq!(sbuf.as_slice(), &[1,2,3,4,5,6,7,8,9]);
404    assert!(sbuf.write(&[1]).is_err());
405}
asyncio/buffers.rs

asyncio/
buffers.rs
