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

```rust use rwcell::mwsr::rwcell; fn main() { let (w0, mut r) = rwcell(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);

} ```