tokio-io 0.1.3

Core I/O primitives for asynchronous I/O in Rust.
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

extern crate tokio_io;
extern crate bytes;
extern crate futures;

use futures::{Stream, Future};
use std::io::{self, Read};
use tokio_io::codec::{Framed, FramedParts, Decoder, Encoder};
use tokio_io::AsyncRead;
use bytes::{BytesMut, Buf, BufMut, IntoBuf, BigEndian};

const INITIAL_CAPACITY: usize = 8 * 1024;

struct U32Codec;

impl Decoder for U32Codec {
    type Item = u32;
    type Error = io::Error;

    fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u32>> {
        if buf.len() < 4 {
            return Ok(None);
        }

        let n = buf.split_to(4).into_buf().get_u32::<BigEndian>();
        Ok(Some(n))
    }
}

impl Encoder for U32Codec {
    type Item = u32;
    type Error = io::Error;

    fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
        // Reserve space
        dst.reserve(4);
        dst.put_u32::<BigEndian>(item);
        Ok(())
    }
}

struct DontReadIntoThis;

impl Read for DontReadIntoThis {
    fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
        Err(io::Error::new(io::ErrorKind::Other,
                           "Read into something you weren't supposed to."))
    }
}

impl AsyncRead for DontReadIntoThis {}

#[test]
fn can_read_from_existing_buf() {
    let parts = FramedParts {
        inner: DontReadIntoThis,
        readbuf: vec![0, 0, 0, 42].into(),
        writebuf: BytesMut::with_capacity(0),
    };
    let framed = Framed::from_parts(parts, U32Codec);

    let num = framed
        .into_future()
        .map(|(first_num, _)| {
            first_num.unwrap()
        })
        .wait()
        .map_err(|e| e.0)
        .unwrap();
    assert_eq!(num, 42);
}

#[test]
fn external_buf_grows_to_init() {
    let parts = FramedParts {
        inner: DontReadIntoThis,
        readbuf: vec![0, 0, 0, 42].into(),
        writebuf: BytesMut::with_capacity(0),
    };
    let framed = Framed::from_parts(parts, U32Codec);
    let FramedParts { readbuf, .. } = framed.into_parts();

    assert_eq!(readbuf.capacity(), INITIAL_CAPACITY);
}

#[test]
fn external_buf_does_not_shrink() {
    let parts = FramedParts {
        inner: DontReadIntoThis,
        readbuf: vec![0; INITIAL_CAPACITY * 2].into(),
        writebuf: BytesMut::with_capacity(0),
    };
    let framed = Framed::from_parts(parts, U32Codec);
    let FramedParts { readbuf, .. } = framed.into_parts();

    assert_eq!(readbuf.capacity(), INITIAL_CAPACITY * 2);
}