[−][src]Struct left_right::ReadHandle
A read handle to a left-right guarded data structure.
To use a handle, first call enter
to acquire a ReadGuard
. This is similar
to acquiring a Mutex
, except that no exclusive lock is taken. All reads of the underlying
data structure can then happen through the ReadGuard
(which implements Deref<Target = T>
).
Reads through a ReadHandle
only see the changes up until the last time
WriteHandle::publish
was called. That is, even if a writer performs a number of
modifications to the underlying data, those changes are not visible to reads until the writer
calls publish
.
ReadHandle
is not Sync
, which means that you cannot share a ReadHandle
across many
threads. This is because the coordination necessary to do so would significantly hamper the
scalability of reads. If you had many reads go through one ReadHandle
, they would need to
coordinate among themselves for every read, which would lead to core contention and poor
multi-core performance. By having ReadHandle
not be Sync
, you are forced to keep a
ReadHandle
per reader, which guarantees that you do not accidentally ruin your performance.
You can create a new, independent ReadHandle
either by cloning an existing handle or by using
a ReadHandleFactory
. Note, however, that creating a new handle through either of these
mechanisms does take a lock, and may therefore become a bottleneck if you do it frequently.
Implementations
impl<T> ReadHandle<T>
[src]
pub fn enter(&self) -> Option<ReadGuard<'_, T>>
[src]
Take out a guarded live reference to the read copy of the T
.
While the guard lives, the WriteHandle
cannot proceed with a call to
WriteHandle::publish
, so no queued operations will become visible to any reader.
If the WriteHandle
has been dropped, this function returns None
.
pub fn was_dropped(&self) -> bool
[src]
Returns true if the WriteHandle
has been dropped.
pub fn raw_handle(&self) -> Option<NonNull<T>>
[src]
Returns a raw pointer to the read copy of the data.
Note that it is only safe to read through this pointer if you know that the writer will
not start writing into it. This is most likely only the case if you are calling this method
from inside a method that holds &mut WriteHandle
.
Casting this pointer to &mut
is never safe.
Trait Implementations
impl<T> Clone for ReadHandle<T>
[src]
pub fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T> Debug for ReadHandle<T>
[src]
impl<T> Drop for ReadHandle<T>
[src]
impl<T> Send for ReadHandle<T> where
T: Sync,
[src]
T: Sync,
Auto Trait Implementations
impl<T> !RefUnwindSafe for ReadHandle<T>
[src]
impl<T> !Sync for ReadHandle<T>
[src]
impl<T> Unpin for ReadHandle<T>
[src]
impl<T> UnwindSafe for ReadHandle<T> where
T: RefUnwindSafe,
[src]
T: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,