Struct left_right::WriteHandle

pub struct WriteHandle<T, O> where
    T: Absorb<O>,  { /* fields omitted */ }

A writer handle to a left-right guarded data structure.

All operations on the underlying data should be enqueued as operations of type O using append. The effect of this operations are only exposed to readers once publish is called.

Reading through a WriteHandle

WriteHandle allows access to a ReadHandle through Deref<Target = ReadHandle>. Note that since the reads go through a ReadHandle, those reads are subject to the same visibility restrictions as reads that do not go through the WriteHandle: they only see the effects of operations prior to the last call to publish.

Implementations

impl<T, O> WriteHandle<T, O> where
    T: Absorb<O>, 

pub fn publish(&mut self) -> &mut Self

Publish all operations append to the log to reads.

This method needs to wait for all readers to move to the "other" copy of the data so that it can replay the operational log onto the stale copy the readers used to use. This can take some time, especially if readers are executing slow operations, or if there are many of them.

pub fn has_pending_operations(&self) -> bool

Returns true if there are operations in the operational log that have not yet been exposed to readers.

pub fn append(&mut self, op: O) -> &mut Self

Append the given operation to the operational log.

Its effects will not be exposed to readers until you call publish.

pub fn raw_write_handle(&mut self) -> NonNull<T>

Returns a raw pointer to the write copy of the data (the one readers are not accessing).

Note that it is only safe to mutate through this pointer if you know that there are no readers still present in this copy. This is not normally something you know; even after calling publish, readers may still be in the write copy for some time. In general, the only time you know this is okay is before the first call to publish (since no readers ever entered the write copy).

Methods from Deref<Target = ReadHandle<T>>

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

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

Returns true if the WriteHandle has been dropped.

Trait Implementations

impl<T, O> Debug for WriteHandle<T, O> where
    T: Absorb<O> + Debug,
    O: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, O> Deref for WriteHandle<T, O> where
    T: Absorb<O>, 

type Target = ReadHandle<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, O> Drop for WriteHandle<T, O> where
    T: Absorb<O>, 

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T, O> Send for WriteHandle<T, O> where
    T: Absorb<O>,
    T: Send,
    O: Send,
    ReadHandle<T>: Send,