Struct Writer

pub struct Writer<T> { /* private fields */ }

Write side of the triple buffer.

Implementations

impl<T> Writer<T>

pub fn write_new(&mut self, write_op: impl FnMut(&T, &mut T))

Write the next state into the buffer.

The closure takes two arguments:

• The first is a reference to the previous state.
• The second is a mutable reference to some unspecified T value that should be overwritten with the new state.

The Reader is not blocked while this function runs. It is possible for multiple independent reads to happen while a single write is in process.

Example

let (mut writer, mut reader) = simple_triple_buffer::new_clone(0);
writer.write_new(|old, new| *new = *old + 1);
assert_eq!(*reader.read_newest(), 1);

Examples found in repository

examples/counter.rs (lines 17-19)

fn main() {
    let (mut w, mut r) = new_with(State { v: 0 }, |s| {
        println!("Cloned state!");
        s.clone()
    });

    let tw = std::thread::spawn(move || loop {
        w.write_new(|last, new| {
            new.v = last.v + 1;
        });
    });

    let tr = std::thread::spawn(move || {
        let mut last = 0;
        loop {
            let state = r.read_newest();
            println!("Value: {} (+{})", state.v, state.v - last);
            last = state.v;
            std::thread::sleep(Duration::from_millis(20));
        }
    });

    tw.join().unwrap();
    tr.join().unwrap();
}