Struct futures_concurrency::future::FutureGroup

pub struct FutureGroup<F> { /* private fields */ }

A growable group of futures which act as a single unit.

Example

Basic example

use futures_concurrency::future::FutureGroup;
use futures_lite::StreamExt;
use std::future;

let mut group = FutureGroup::new();
group.insert(future::ready(2));
group.insert(future::ready(4));

let mut out = 0;
while let Some(num) = group.next().await {
    out += num;
}
assert_eq!(out, 6);

Update the group on every iteration

use futures_concurrency::future::FutureGroup;
use lending_stream::prelude::*;
use std::future;

let mut group = FutureGroup::new();
group.insert(future::ready(4));

let mut index = 3;
let mut out = 0;
let mut group = group.lend_mut();
while let Some((group, num)) = group.next().await {
    if index != 0 {
        group.insert(future::ready(index));
        index -= 1;
    }
    out += num;
}
assert_eq!(out, 10);

Implementations

impl<F> FutureGroup<F>

pub fn new() -> Self

Create a new instance of FutureGroup.

Example

use futures_concurrency::future::FutureGroup;

let group = FutureGroup::new();

pub fn with_capacity(capacity: usize) -> Self

Create a new instance of FutureGroup with a given capacity.

Example

use futures_concurrency::future::FutureGroup;

let group = FutureGroup::with_capacity(2);

pub fn len(&self) -> usize

Return the number of futures currently active in the group.

Example

use futures_concurrency::future::FutureGroup;
use futures_lite::StreamExt;
use std::future;

let mut group = FutureGroup::with_capacity(2);
assert_eq!(group.len(), 0);
group.insert(future::ready(12));
assert_eq!(group.len(), 1);

pub fn capacity(&self) -> usize

Return the capacity of the FutureGroup.

Example

use futures_concurrency::future::FutureGroup;
use futures_lite::stream;

let group = FutureGroup::with_capacity(2);
assert_eq!(group.capacity(), 2);

pub fn is_empty(&self) -> bool

Returns true if there are no futures currently active in the group.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::with_capacity(2);
assert!(group.is_empty());
group.insert(future::ready(12));
assert!(!group.is_empty());

pub fn remove(&mut self, key: Key) -> bool

Removes a stream from the group. Returns whether the value was present in the group.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::new();
let key = group.insert(future::ready(4));
assert_eq!(group.len(), 1);
group.remove(key);
assert_eq!(group.len(), 0);

pub fn contains_key(&mut self, key: Key) -> bool

Returns true if the FutureGroup contains a value for the specified key.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::new();
let key = group.insert(future::ready(4));
assert!(group.contains_key(key));
group.remove(key);
assert!(!group.contains_key(key));

pub fn reserve(&mut self, additional: usize)

Reserves capacity for additional more futures to be inserted. Does nothing if the capacity is already sufficient.

Example

use futures_concurrency::future::FutureGroup;
use std::future::Ready;
let mut group: FutureGroup<Ready<usize>> = FutureGroup::with_capacity(0);
assert_eq!(group.capacity(), 0);
group.reserve(10);
assert_eq!(group.capacity(), 10);

// does nothing if capacity is sufficient
group.reserve(5);
assert_eq!(group.capacity(), 10);

impl<F: Future> FutureGroup<F>

pub fn insert(&mut self, future: F) -> Key

where F: Future,

Insert a new future into the group.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::with_capacity(2);
group.insert(future::ready(12));

pub fn keyed(self) -> Keyed<F>

Create a stream which also yields the key of each item.

Example

use futures_concurrency::future::FutureGroup;
use futures_lite::StreamExt;
use std::future;

let mut group = FutureGroup::new();
group.insert(future::ready(2));
group.insert(future::ready(4));

let mut out = 0;
let mut group = group.keyed();
while let Some((_key, num)) = group.next().await {
    out += num;
}
assert_eq!(out, 6);

Trait Implementations

impl<T: Debug> Debug for FutureGroup<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for FutureGroup<T>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Future> Extend<F> for FutureGroup<F>

fn extend<T: IntoIterator<Item = F>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<F: Future> FromIterator<F> for FutureGroup<F>

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

Creates a value from an iterator.

impl<F: Future> Stream for FutureGroup<F>

type Item = <F as Future>::Output

Values yielded by the stream.

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

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.

impl<'pin, F> Unpin for FutureGroup<F>

where __FutureGroup<'pin, F>: Unpin,