A sort of an Arc-RwLock combination..
That aims to be simple and straightforward to use when sharing data
between threads.
An attempt at creating an Arc-RwLock combination that is straightforward
to use and no hassle , instead of worrying about being fast and lean.
- cloning referefences works like Arc
- made for sharing objects between threads without worry
- locking things works like RwLock with write() or read()
- it spins a few times and then queues if a lock is not obtained
- miri seems to be happy , so i trust it doesnt leak too much memory etc.
- requires that everything you stick into it is Send+Sync
- no need to constantly .unwrap() things instead it will just
block forever or blow up
Example
```rust
use cura::Cura;
trait Foo:Send+Sync
{
fn get(&self)->i32;
fn set(&mut self,i:i32);
}
[derive(Debug)]
struct FF{i:i32,};
struct BB{i:i32};
//!
impl Foo for FF{
fn get(&self)->i32{return self.i;}
fn set(&mut self,i:i32){self.i=i;}
}
//!
impl Foo for BB{
fn get(&self)->i32{return self.i;}
fn set(&mut self,i:i32){self.i=i;}
}
//!
let t=FF{i:1};
//!
// you can do straight "frombox" but currently its impossible to
// "alter" unsized types
let foo2:Cura=Cura::frombox(Box::new(FF{i:2}));
let foo:Cura>=Cura::new(Box::new(t));
let a=foo.clone();
let b=foo.clone();
//!
{
asserteq!(a.read().get(),1);
{
a.alter(|s|{
s.set(2);
Some(())
});
}
{
a.alter(|s|{ //this only works for Sized types
*s=Box::new(BB{i:2});
Some(())
});
}
let lock=a.read();
let v=lock;
asserteq!(v.get(),2)
}//lock dropped here
{
(b.write()).set(3); //lock dropped here i think
}
//!
assert_eq!((a.read()).get(),3);
//!
```