pbcodec 0.0.8

An asynchronous encoder/decoder for Protocol Buffers
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

use std::io::{self, Write};
use futures::{Async, Future, Poll};

use {Error, ErrorKind};

#[derive(Debug)]
pub struct WriteByte<W> {
    writer: Option<W>,
    byte: u8,
}
impl<W> WriteByte<W> {
    pub fn new(writer: W, byte: u8) -> Self {
        WriteByte {
            byte,
            writer: Some(writer),
        }
    }
}
impl<W: Write> Future for WriteByte<W> {
    type Item = W;
    type Error = Error<W>;
    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        let mut writer = self.writer.take().expect("Cannot poll WriteByte twice");
        match writer.write(&[self.byte][..]) {
            Err(e) => {
                if e.kind() != io::ErrorKind::WouldBlock {
                    failed_by_error!(writer, ErrorKind::Other, e);
                }
                Ok(Async::NotReady)
            }
            Ok(0) => failed!(writer, ErrorKind::UnexpectedEos),
            Ok(_) => Ok(Async::Ready(writer)),
        }
    }
}

#[derive(Debug)]
pub struct WriteBytes<W, B> {
    writer: Option<W>,
    bytes: B,
    offset: usize,
}
impl<W, B> WriteBytes<W, B> {
    pub fn new(writer: W, bytes: B) -> Self {
        WriteBytes {
            writer: Some(writer),
            bytes,
            offset: 0,
        }
    }
}
impl<W: Write, B: AsRef<[u8]>> Future for WriteBytes<W, B> {
    type Item = W;
    type Error = Error<W>;
    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        let mut writer = self.writer.take().expect("Cannot poll WriteBytes twice");
        loop {
            match writer.write(&self.bytes.as_ref()[self.offset..]) {
                Err(e) => {
                    if e.kind() != io::ErrorKind::WouldBlock {
                        failed_by_error!(writer, ErrorKind::Other, e);
                    }
                    return Ok(Async::NotReady);
                }
                Ok(written_size) => {
                    self.offset += written_size;
                    if self.offset == self.bytes.as_ref().len() {
                        return Ok(Async::Ready(writer));
                    }
                    if written_size == 0 {
                        failed!(writer, ErrorKind::UnexpectedEos)
                    }
                }
            }
        }
    }
}