Rust Adapter

cargo add zinc-core

cargo add zinc-core --path /path/to/zinc/core

use zinc_core::SharedRegion;

let region = SharedRegion::create("my-data", 4096)?;

let region = SharedRegion::open("my-data")?;

let ptr = region.as_ptr();
unsafe { *ptr = 42 };

let cap = region.capacity();

region.notify();

match region.wait(1000) {
    Ok(()) => println!("data available"),
    Err(ZincError::TimedOut) => println!("no update within 1s"),
    Err(e) => eprintln!("error: {e}"),
}

{
    let region = SharedRegion::create("temp", 4096)?;
    // region is active here
}
// region is closed and unlinked

use zinc_core::SharedRegion;
use std::thread;
use std::time::Duration;

// Producer
let producer = thread::spawn(|| -> Result<(), zinc_core::ZincError> {
    let r = SharedRegion::create("pipeline", 65536)?;
    let ptr = r.as_ptr();
    for i in 0..10 {
        unsafe { std::ptr::write(ptr as *mut u64, i); }
        r.notify();
        thread::sleep(Duration::from_millis(10));
    }
    Ok(())
});

// Consumer
let consumer = thread::spawn(|| -> Result<(), zinc_core::ZincError> {
    let r = SharedRegion::open("pipeline")?;
    let ptr = r.as_ptr() as *const u64;
    loop {
        match r.wait(5000) {
            Ok(()) => {
                let val = unsafe { std::ptr::read(ptr) };
                println!("received: {val}");
            }
            Err(zinc_core::ZincError::TimedOut) => break,
            Err(e) => return Err(e),
        }
    }
    Ok(())
});

producer.join().unwrap()?;
consumer.join().unwrap()?;