Overview

rw_cell provides the ability to securely write data from one location of application and read it from another even if Writer and Reader located in different threads without copying/cloning and blocking access to data.

Example

use rw_cell::mwsr::rw_cell;
fn main() {
    let (w0, mut r) = rw_cell(vec!["_"; 1000]);

    let w1 = w0.clone();
    let w2 = w0.clone();
    let w3 = w0.clone();

    std::thread::spawn(move || loop {
        w0.write(vec!["F"; 1001])
    });

    std::thread::spawn(move || loop {
        w1.write(vec!["u"; 1002])
    });

    std::thread::spawn(move || loop {
        w2.write(vec!["c"; 1003])
    });

    std::thread::spawn(move || loop {
        w3.write(vec!["k"; 1004])
    });

    let mut count__ = 0;
    let mut count_f = 0;
    let mut count_u = 0;
    let mut count_c = 0;
    let mut count_k = 0;

    for _ in 0..10000000usize {
        match r.read() {
            val if val.first() == Some(&"_") => count__ += 1,
            val if val.first() == Some(&"F") => count_f += 1,
            val if val.first() == Some(&"u") => count_u += 1,
            val if val.first() == Some(&"c") => count_c += 1,
            val if val.first() == Some(&"k") => count_k += 1,
            val => println!("len: {:?}, Not good, but ok", val.first())
        }
    }

    println!("count__: {}", count__);
    println!("count_F: {}", count_f);
    println!("count_u: {}", count_u);
    println!("count_c: {}", count_c);
    println!("count_k: {}", count_k);
}