Struct RepeaterHandle 

pub struct RepeaterHandle<E>
where
    E: RepeaterEntry + Clone + Unpin + 'static,
{ /* private fields */ }

Used to communicate with the repeater task

Returned after the call to Repeater::run_with_async_callback

Implementations

impl<E> RepeaterHandle<E>

where E: RepeaterEntry + Clone + Unpin + 'static,

pub async fn insert(&self, e: E) -> Result<(), ConnectionLost>

Insert entry into Repeater

Examples found in repository

examples/simple.rs (line 44)

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");
}

pub async fn remove(&self, key: E::Key) -> Result<(), ConnectionLost>

Remove entry from Repeater

pub async fn clear(&self) -> Result<(), ConnectionLost>

Remove all entries from Repeater

pub async fn stop(self) -> Result<(), ConnectionLost>

Stop a Repeater

Examples found in repository

examples/simple.rs (line 52)

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");
}

pub async fn len(self) -> Result<usize, ConnectionLost>

Return the number of entries in Repeater

pub async fn is_empty(self) -> Result<bool, ConnectionLost>

Return true if no entries are inside of Repeater

Trait Implementations

impl<E> Clone for RepeaterHandle<E>

where E: RepeaterEntry + Clone + Unpin + 'static + Clone,

fn clone(&self) -> RepeaterHandle<E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E> Debug for RepeaterHandle<E>

where E: RepeaterEntry + Clone + Unpin + 'static + Debug,

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

Formats the value using the given formatter.