Struct Writer

pub struct Writer<W> { /* private fields */ }

A writer for SMC messages.

Consumes an futures::io::AsyncWrite to which messages will be written.

Implementations

impl<W> Writer<W>

where W: AsyncWrite + Unpin,

pub fn new(writer: W) -> Self

Create a new message writer.

Examples found in repository

examples/tcp.rs (line 113)

fn create_from_stream(tcp_stream: TcpStream) -> (Reader<CloneableStream>, Writer<CloneableStream>) {
    let stream = CloneableStream(Arc::new(tcp_stream));
    let reader = Reader::new(stream.clone());
    let writer = Writer::new(stream.clone());
    (reader, writer)
}

examples/send.rs (line 10)

async fn send() -> io::Result<()> {
    let stdout = io::stdout().lock().await;
    let mut writer = Writer::new(stdout);
    for i in 0..3 {
        let message = Message::new(i, 1, "hi".as_bytes().to_vec());
        print_msg(&message);
        writer.send(message).await?;
    }
    Ok(())
}

examples/echo_upper.rs (line 18)

async fn echo() -> Result<(), io::Error> {
    let stdin = io::stdin().lock().await;
    let stdout = io::stdout().lock().await;
    let mut reader = Reader::new(stdin);
    let mut writer = Writer::new(stdout);
    while let Some(msg) = reader.next().await {
        let msg = msg?;
        let resp = Message {
            channel: msg.channel,
            typ: msg.typ + 1,
            message: to_upper(&msg.message),
        };
        writer.send(resp).await?;
    }
    Ok(())
}

pub async fn send(&mut self, message: Message) -> Result<(), Error>

Send a message.

This encodes the message, writes it and flushes the writer.

Examples found in repository

examples/send.rs (line 14)

async fn send() -> io::Result<()> {
    let stdout = io::stdout().lock().await;
    let mut writer = Writer::new(stdout);
    for i in 0..3 {
        let message = Message::new(i, 1, "hi".as_bytes().to_vec());
        print_msg(&message);
        writer.send(message).await?;
    }
    Ok(())
}

examples/tcp.rs (line 92)

async fn handle_incoming(stream: TcpStream) -> Result<()> {
    let (mut reader, mut writer) = create_from_stream(stream);
    while let Some(msg) = reader.try_next().await? {
        eprintln!("received: {}", format_msg(&msg));
        let resp = Message {
            channel: msg.channel,
            typ: 2,
            message: to_upper(&msg.message),
        };
        writer.send(resp).await?;
    }
    Ok(())
}

async fn handle_outgoing(stream: TcpStream) -> Result<()> {
    let (mut reader, mut writer) = create_from_stream(stream);

    let hello_msg = Message::new(1, 1, "hi".as_bytes().to_vec());
    writer.send(hello_msg).await?;

    while let Some(msg) = reader.try_next().await? {
        eprintln!("received: {}", format_msg(&msg));
    }

    Ok(())
}

examples/echo_upper.rs (line 26)

async fn echo() -> Result<(), io::Error> {
    let stdin = io::stdin().lock().await;
    let stdout = io::stdout().lock().await;
    let mut reader = Reader::new(stdin);
    let mut writer = Writer::new(stdout);
    while let Some(msg) = reader.next().await {
        let msg = msg?;
        let resp = Message {
            channel: msg.channel,
            typ: msg.typ + 1,
            message: to_upper(&msg.message),
        };
        writer.send(resp).await?;
    }
    Ok(())
}

pub async fn send_batch(&mut self, messages: Vec<Message>) -> Result<(), Error>

Send a batch of messages.

This works like Writer::send but flushes after all messages are written.