micro-http 0.3.0

the async micro http server
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

use crate::codec::ResponseEncoder;
use crate::protocol::{Message, PayloadSize, ResponseHead, SendError};
use bytes::{Buf, BytesMut};
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio_util::codec::Encoder;

#[derive(Debug)]
pub struct MessageWriter<W> {
    writer: W,
    buffer: BytesMut,
    encoder: ResponseEncoder,
}

impl<W> MessageWriter<W>
where
    W: AsyncWrite + Unpin,
{
    pub fn with_capacity(writer: W, buffer_size: usize) -> Self {
        Self { writer, buffer: BytesMut::with_capacity(buffer_size), encoder: ResponseEncoder::new() }
    }

    #[inline]
    pub fn get_mut(&mut self) -> &mut W {
        &mut self.writer
    }

    pub fn clear_buf(&mut self) {
        self.buffer.clear();
    }

    #[inline]
    pub fn write<D>(&mut self, item: Message<(ResponseHead, PayloadSize), D>) -> Result<(), SendError>
    where
        D: Buf,
    {
        self.encoder.encode(item, &mut self.buffer)
    }

    #[inline]
    pub async fn flush(&mut self) -> Result<(), SendError> {
        if self.buffer.is_empty() {
            return Ok(());
        }

        self.writer.write_all(self.buffer.as_ref()).await?;
        Ok(self.writer.flush().await?)
    }
}