jitterbug/examples/demo.rs

use std::sync::Arc;
use std::task::{Wake, Waker};

use safe_executor::Executor;

fn spawn(runtime: &Executor) {
    println!("Spawning futures");

    let task1 = runtime.spawn(async move {
        println!("Henlo from first spawn");
        "A"
    });

    let task2 = runtime.spawn(async move {
        println!("Henlo from second spawn");
        "B"
    });

    let run2m = runtime.clone();

    runtime.spawn(async move {
        let res1 = task1.await;
        let res2 = task2.await;
        println!("Henlo from third spawn, {:?}, {:?}", res1, res2);

        let res3 = run2m
            .spawn(async move {
                println!("Henlo from inner spawn");
                "D"
            })
            .await;

        println!("Henlo again from third spawn, {:?}", res3);
    });
}

struct DummyWaker;
impl Wake for DummyWaker {
    fn wake(self: std::sync::Arc<Self>) {}
    fn wake_by_ref(self: &Arc<Self>) {}
}

fn main() {
    let runtime = Executor::new();

    // This creates 3 new tasks
    spawn(&runtime);

    let waker: Waker = Arc::new(DummyWaker).into();

    while runtime.any_woken() {
        println!("Ticking");
        runtime.tick(&waker);
    }

    // This reclaims the first 3 tasks
    println!("Pruning");
    runtime.prune();

    // This creates 3 new tasks
    spawn(&runtime);
    while runtime.any_woken() {
        println!("Ticking");
        runtime.tick(&waker);
    }

    // This re-uses the 3 tasks created prior
    spawn(&runtime);

    // This doesn't reclaim any tasks, since we've spawned 3 more futures
    println!("Pruning");
    runtime.prune();

    while runtime.any_woken() {
        println!("Ticking");
        runtime.tick(&waker);

        // This reclaims tasks as their futures resolve on each tick
        println!("Pruning");
        runtime.prune();
    }

    println!("Hewwo Mr Obama");
}