Struct Cura 

pub struct Cura<T: Sync + Send + ?Sized> { /* private fields */ }

a sort of an Arc that will both readwrite lock , be easy to handle and is cloneable

use cura::Cura;
let s=Cura::new(1);
let a=s.clone();

Implementations

impl<T: Sync + Send> Cura<T>

Cura public interface

pub fn new(t: T) -> Cura<T>

constructor for a Cura

    use cura::Cura;
    let t=1;
    let foo=Cura::new(t); //instead of Arc::new(Mutex::new(t));

impl<T: Sync + Send + ?Sized> Cura<T>

Cura public interface

pub fn from_box(v: Box<T>) -> Cura<T>

convert from box to Cura

pub fn read(&self) -> ReadGuard<'_, T>

readlock a ‘Cura’,returning a guard that can be dereferenced for read-only operations

pub fn write(&self) -> Guard<'_, T>

writelock a ‘Cura’ , returning a guard that can be dereferenced for write-operations.

pub fn alter(&self, f: fn(&mut T) -> Option<()>) -> Option<()>

transparently take a writelock, attempt to mutate the value and then release the lock

use cura::Cura;
let t=Cura::new(1);
let res=t.alter(|x|{ //this is a mutable ref, can be altered that way
    if(*x==1){
        *x=2;
        Some(()) //signal alteration
    }else{
        None  //signal not altered
    }
 });
match res {
    None=>{/* no change made*/},
    Some(_)=>{/*change made*/},
}

Trait Implementations

impl<T: Sync + Send + ?Sized> Clone for Cura<T>

deref to make use simpler, this should also transparently read-lock clone to make new references of the object

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Sync + Send + ?Sized> Drop for Cura<T>

drop to clean up references

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send + Sync + ?Sized> Send for Cura<T>

implement send and sync since thats all we want

impl<T: Send + Sync + ?Sized> Sync for Cura<T>