Struct ReadGuard 

pub struct ReadGuard<'a, T: Sized> { /* private fields */ }

Implementations

impl<'a, T> ReadGuard<'a, T>

pub fn try_to_write(self) -> LockResult<WriteGuard<'a, T>>

Same as Self::to_write but instead of blocking thread, if a lock can not be obtained when called a LockError::WouldBlock is returned

pub fn to_write(self) -> LockResult<WriteGuard<'a, T>>

use manual_rwlock::MrwLock;
let mrw_lock = MrwLock::new(10);
let read = mrw_lock.read().unwrap();
let mut write = read.to_write().unwrap();
*write = 5;
let read = write.to_read();
assert_eq!(*read, 5)

pub unsafe fn early_release(&self)

Releases lock without dropping object. This can allow for a write lock to obtained and do some work after which the lock must be reobtained

Safety

Do not access contents before reobtaining lock with either reobtain or try_reobtain

Examples

  use manual_rwlock::MrwLock;

 let rwlock = MrwLock::new(5);
 let read_rw = rwlock.read().unwrap();
 unsafe { read_rw.early_release() };
 {
     let mut write = rwlock.write().unwrap();
     *write += 5;
 }
 unsafe { read_rw.reobtain().unwrap() };
 assert_eq!(*read_rw, 10);

pub unsafe fn reobtain(&self) -> Result<(), LockError>

block until lock can be reobtained

Safety

do not use unless early release has been called. Only call at most once after each early release

pub unsafe fn try_reobtain(&self) -> Result<(), LockError>

attempt to reobtain lock, if not possible at this time return LockError:WouldBlock

Safety

do not use unless early release has been called. Only call at most once after each early release

Trait Implementations

impl<'a, T> Clone for ReadGuard<'a, T>

 use manual_rwlock::MrwLock;

let rwlock = MrwLock::new(5);
let read = rwlock.read().unwrap();
let read2 = read.clone();
assert_eq!(*read2, 5);

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Deref for ReadGuard<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T> Drop for ReadGuard<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> Send for ReadGuard<'a, T>

impl<'a, T> Sync for ReadGuard<'a, T>