Struct Repeater 

pub struct Repeater<E>
where
    E: RepeaterEntry + Clone + Unpin + Send,
{ /* private fields */ }

Repeats structs after user defined Duration.

Implementations

impl<E> Repeater<E>

where E: RepeaterEntry + Clone + Unpin + Send + Sync,

pub fn with_capacity(capacity: usize) -> Self

Create a new repeater with given capacity

Examples found in repository

examples/simple.rs (line 36)

async fn main() {
    let callback = |entry, _| async move { println!("Popped {entry:?}") };

    // create and start the repeater
    let handle = async_repeater::Repeater::with_capacity(25).run_with_async_callback(callback);

    // create entries with the same interval
    let dur = Duration::from_secs(5);
    let repetition = vec![Entry::new(0, dur), Entry::new(1, dur), Entry::new(2, dur)];

    // insert the entries into the repeater with 1 second delay in between
    for repetition in repetition {
        handle.insert(repetition).await.unwrap();
        tokio::time::sleep(Duration::from_secs(1)).await;
    }

    // wait for a ctrl-c.
    // If this wasn't there, the program would exit immidiatly without running
    // a single repetition
    tokio::signal::ctrl_c().await.unwrap();
    handle.stop().await.unwrap();
    println!("Stopping cycler");
}

examples/stream_impl.rs (line 37)

async fn main() {
    // create but not start the repeater
    let mut repeater = Repeater::<Entry>::with_capacity(7);

    // create entries as a stream
    let repetitions = tokio_stream::iter(vec![
        Entry::new(0, Duration::from_millis(3000)),
        Entry::new(1, Duration::from_millis(1000)),
        Entry::new(2, Duration::from_millis(2000)),
    ]);
    tokio::pin!(repetitions);

    // select either an element from the stream or
    // an element from the repeater or
    // from the ctrl-c signal
    loop {
        tokio::select! {
            Some(item) = repeater.next() => {
                println!("Popped: {item:?}");
                repeater.insert(item);
            }
            Some(item) = repetitions.next() => {
                repeater.insert(item);
            }
            _ = tokio::signal::ctrl_c() => {
                break
            }
        }
    }
}

pub fn insert(&mut self, e: E)

Insert entry into repeater

If entry with same key already exists, it will be replaced. Replacement will also reset the repetition.

Insertion respects the delay() call

Examples found in repository

examples/stream_impl.rs (line 54)

async fn main() {
    // create but not start the repeater
    let mut repeater = Repeater::<Entry>::with_capacity(7);

    // create entries as a stream
    let repetitions = tokio_stream::iter(vec![
        Entry::new(0, Duration::from_millis(3000)),
        Entry::new(1, Duration::from_millis(1000)),
        Entry::new(2, Duration::from_millis(2000)),
    ]);
    tokio::pin!(repetitions);

    // select either an element from the stream or
    // an element from the repeater or
    // from the ctrl-c signal
    loop {
        tokio::select! {
            Some(item) = repeater.next() => {
                println!("Popped: {item:?}");
                repeater.insert(item);
            }
            Some(item) = repetitions.next() => {
                repeater.insert(item);
            }
            _ = tokio::signal::ctrl_c() => {
                break
            }
        }
    }
}

pub fn remove(&mut self, key: &E::Key)

Remove entry with key from repeater

pub fn clear(&mut self)

Clear the repeater. This removes all entries.

pub fn len(&self) -> usize

Number of entries in the repeater

pub fn is_empty(&self) -> bool

Return true if repeater is empty

pub fn run_with_async_callback<F, Fut>(self, callback: F) -> RepeaterHandle<E>

where F: FnOnce(E, RepeaterHandle<E>) -> Fut + Send + 'static + Clone, Fut: Future<Output = ()> + Send + 'static,

Starts the repeater in a background task

This consumes the repeater and returns a RepeaterHandle which allows communication with the background task.

Examples found in repository

examples/simple.rs (line 36)

async fn main() {
    let callback = |entry, _| async move { println!("Popped {entry:?}") };

    // create and start the repeater
    let handle = async_repeater::Repeater::with_capacity(25).run_with_async_callback(callback);

    // create entries with the same interval
    let dur = Duration::from_secs(5);
    let repetition = vec![Entry::new(0, dur), Entry::new(1, dur), Entry::new(2, dur)];

    // insert the entries into the repeater with 1 second delay in between
    for repetition in repetition {
        handle.insert(repetition).await.unwrap();
        tokio::time::sleep(Duration::from_secs(1)).await;
    }

    // wait for a ctrl-c.
    // If this wasn't there, the program would exit immidiatly without running
    // a single repetition
    tokio::signal::ctrl_c().await.unwrap();
    handle.stop().await.unwrap();
    println!("Stopping cycler");
}

Trait Implementations

impl<E> Stream for Repeater<E>

where E: RepeaterEntry + Clone + Unpin + Send + Sync,

type Item = E

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<<Self as Stream>::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.