Struct FuturesUnorderedIter 

pub struct FuturesUnorderedIter<T, F>
where
    F: Future,
    T: Iterator<Item = F>,
{ /* private fields */ }

Bounded FuturesUnordered from an iterator.

This struct consumes an iterator where each item is a future. By using an iterator, we need no additional state, or additional queues to store the excess of futures.

This should be always preferred over FuturesUnorderedBounded, as it’s more performant and adds basically ZERO overhead on top of the normal FuturesUnordered.

Implementations

impl<T, F> FuturesUnorderedIter<T, F>

where F: Future, T: Iterator<Item = F>,

pub fn new<I: IntoIterator<IntoIter = T>>( max_concurrent: usize, tasks: I, ) -> Self

Creates a new bounded FuturesUnordered from an iterator. This option is as efficient as it gets since it completely avoids allocating a new vector to store the excess of futures.

Since iterators are lazily evaluated, futures will be created on the fly as well.

Panics if max_concurrent is 0.

use futures_ratelimit::unordered::FuturesUnorderedIter;
use futures_ratelimit::common::Passthrough;
use futures::StreamExt;

async fn dummy() -> u64{
    42
}

let tasks = (0..100).into_iter().map(|_| dummy());
let mut fut_unordered = FuturesUnorderedIter::new(5, tasks);

// The internal FuturesUnorderedBounded will have 5 futures at most.
// The rest of futures will be pulled from the iterator as needed.

tokio_test::block_on(async move{
    assert_eq!(fut_unordered.borrow_inner().len(), 5);

    while let Some(value) = fut_unordered.next().await {
        println!("{}", value);
        assert!(fut_unordered.borrow_inner().len() <= 5);
    }

    assert_eq!(fut_unordered.borrow_inner().len(), 0);
    assert!(fut_unordered.borrow_inner().is_empty());

});

Trait Implementations

impl<T, F> Passthrough<F> for FuturesUnorderedIter<T, F>

where T: Iterator<Item = F>, F: Future,

type FuturesHolder = FuturesUnordered<F>

The type of the inner Stream. This can be either FuturesUnordered or FuturesOrdered.

fn set_max_concurrent(&mut self, max_concurrent: usize)

Change the internal max_concurrent capacity at runtime.

fn borrow_inner(&self) -> &FuturesUnordered<F>

Borrow the inner Stream.

fn borrow_mut_inner(&mut self) -> &mut FuturesUnordered<F>

Mutably borrow the inner Stream. Note that this library might not work reliably if you modify the underlying Stream.

fn into_inner(self) -> FuturesUnordered<F>

where Self: Sized,

Consume the iterator and return the inner Stream.

impl<T, F> Stream for FuturesUnorderedIter<T, F>

where T: Iterator<Item = F>, F: Future,

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

Call the poll() method on the underlying FuturesUnordered.

type Item = <F as Future>::Output

Values yielded by the stream.

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

Returns the bounds on the remaining length of the stream.

impl<'pin, T, F> Unpin for FuturesUnorderedIter<T, F>

where F: Future, T: Iterator<Item = F>, PinnedFieldsOf<__FuturesUnorderedIter<'pin, T, F>>: Unpin,