Struct Reader

pub struct Reader<R> { /* private fields */ }

A reader for SMC messages.

Takes any futures::io::AsyncRead and is a async_std::stream::Stream of Messages.

Example

use simple_message_channels::Reader;
let stdin = io::stdin().lock().await;
let mut reader = Reader::new(stdin);
while let Some(msg) = reader.next().await {
    let msg = msg?;
    println!("Received: ch {} typ {} msg {:?}", msg.channel, msg.typ, text);
}

Implementations

impl<R> Reader<R>

where R: AsyncRead + Send + Unpin + 'static,

pub fn new(reader: R) -> Self

Create a new message reader from any futures::io::AsyncRead.

Examples found in repository

examples/recv.rs (line 16)

async fn recv() -> Result<(), io::Error> {
    let stdin = io::stdin().lock().await;
    let mut reader = Reader::new(stdin);
    while let Some(msg) = reader.next().await {
        let msg = msg?;
        print_msg(&msg);
    }
    Ok(())
}

examples/tcp.rs (line 112)

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/echo_upper.rs (line 17)

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(())
}

Trait Implementations

impl<R> Stream for Reader<R>

where R: AsyncRead + Send + Unpin + 'static,

type Item = Result<Message, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Result<Message, Error>>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.