Type Definition unicycle::StreamsUnordered

type StreamsUnordered<T> = Unordered<T, Streams>;

A container for an unordered collection of Streams.

Examples

use tokio::{net::TcpListener, stream::StreamExt as _, time};
use tokio_util::codec::{Framed, LengthDelimitedCodec};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let mut listener = TcpListener::bind("127.0.0.1:8080").await?;
    let mut clients = unicycle::StreamsUnordered::new();

    loop {
        tokio::select! {
            result = listener.accept() => {
                let (stream, _) = result?;
                clients.push(Framed::new(stream, LengthDelimitedCodec::new()));
            },
            Some(frame) = clients.next() => {
                println!("received frame: {:?}", frame);
            }
        }
    }
}

Methods

impl<T> StreamsUnordered<T>

pub fn new() -> Self

Construct a new, empty StreamsUnordered.

Examples

use unicycle::StreamsUnordered;
use tokio::stream::{StreamExt as _, iter};

#[tokio::main]
async fn main() {
    let mut streams = StreamsUnordered::new();
    assert!(streams.is_empty());

    streams.push(iter(vec![1, 2, 3, 4]));
    streams.push(iter(vec![5, 6, 7, 8]));

    let mut received = Vec::new();

    while let Some(value) = streams.next().await {
        received.push(value);
    }

    assert_eq!(vec![1, 5, 2, 6, 3, 7, 4, 8], received);
}

Trait Implementations

impl<T> FromIterator<T> for StreamsUnordered<T> where
    T: Stream, 

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.