oneringbuf 0.7.0

extern crate alloc;

#[cfg(all(feature = "async", feature = "alloc"))]
#[tokio::main]
async fn main() {
    use oneringbuf::AsyncHeapRBMut;
    use oneringbuf::iterators::async_iterators::AsyncIterator;

    const BUFFER_SIZE: usize = 4095;

    let buf = AsyncHeapRBMut::from(vec![0; BUFFER_SIZE + 1]);
    let (mut as_prod, mut as_work, mut as_cons) = buf.split_async_mut();

    as_prod.push(1).await;

    if let Some(res) = as_work.get_mut().await {
        *res += 1;
        unsafe {
            as_work.advance(1);
        }
    }

    let res = as_cons.peek_ref().await.unwrap();
    assert_eq!(res, &2);
    unsafe {
        as_cons.advance(1);
    }

    let slice: Vec<i32> = (0..BUFFER_SIZE as i32 / 2).collect();
    as_prod.push_slice(&slice).await;

    #[cfg(not(all(feature = "vmem", unix)))]
    if let Some((h, t)) = as_work.get_mut_slice_avail().await {
        let len = h.len() + t.len();

        for x in h.iter_mut().chain(t) {
            *x += 1;
        }

        unsafe {
            as_work.advance(len);
        }
    }

    if let Some((h, t)) = as_cons.peek_available().await {
        for (x, y) in h.iter().chain(t).zip(&slice) {
            assert_eq!(*x, y + 1);
        }
    }

    drop(as_prod);
    assert_eq!(as_cons.alive_iters(), 2);
    drop(as_work);
    assert_eq!(as_cons.alive_iters(), 1);

    println!("OK");
}

#[cfg(any(not(feature = "async"), not(feature = "alloc")))]
fn main() {
    eprintln!("To run this example, please, use the following command:");
    println!("cargo run --example simple_async --features async");
}