Struct cycler::rw_lock_cycler::RwLockCyclerWriter

pub struct RwLockCyclerWriter<T> where
    T: 'static,  { /* fields omitted */ }

The writer to an RwLockCycler

Trait Implementations

impl<T> CyclerWriter<T> for RwLockCyclerWriter<T> where
    T: WriteAccess, 

impl<T> CyclerWriterDefault<T> for RwLockCyclerWriter<T> where
    T: Clone + WriteAccess, 

fn write_next(&mut self)

Moves the writer to the next block cloning the previously written block using a default function.

impl<T> CyclerWriterFn<T> for RwLockCyclerWriter<T> where
    T: WriteAccess, 

fn write_next_fn(&mut self, clone_fn: fn(_: &mut T, _: &T))

Moves the writer to the next block cloning using an fn pointer. Arguments are (to, from) This function uses an fn pointer so has no additional runtime cost and can be called on a trait object.

fn write_next_fn_impl(&mut self, clone_fn: impl FnOnce(&mut T, &T)) where
    Self: Sized, 

Moves the writer to the next block cloning using an FnOnce impl Arguments are (to, from) This function is generic over the function reducing runtime cost but cannot be called on trait objects.

fn write_next_fn_dyn(&mut self, clone_fn: &mut dyn FnMut(&mut T, &T))

Moves the writer to the next block cloning using an FnMut dynamic reference. Arguments are (to, from) This function takes a dyn pointer so a v-table lookup is necessary. write_next_fn is preferred if the function can be an fn pointer or write_next_fn_impl is preferred if self is sized.

fn write_next_fn_dyn_boxed(&mut self, clone_fn: Box<dyn FnOnce(&mut T, &T)>)

Moves the writer to the next block cloning using a boxed FnOnce Arguments are (to, from) This function takes a boxed dyn pointer so a v-table lookup is necessary. write_next_fn_dyn is preferred if the function can be coerced into an FnMut as no heap allocation will be necessary.

impl<T> CyclerWriterMutFn<T> for RwLockCyclerWriter<T> where
    T: WriteAccess, 

fn write_next_mut_fn(&mut self, clone_fn: fn(_: &mut T, _: &mut T))

Moves the writer to the next block cloning using an fn pointer. Arguments are (to, from) This function uses an fn pointer so has no additional runtime cost and can be called on a trait object.

fn write_next_mut_fn_impl(&mut self, clone_fn: impl FnOnce(&mut T, &mut T)) where
    Self: Sized, 

Moves the writer to the next block cloning using an FnOnce impl Arguments are (to, from) This function is generic over the function reducing runtime cost but cannot be called on trait objects.

fn write_next_mut_fn_dyn(&mut self, clone_fn: &mut dyn FnMut(&mut T, &mut T))

Moves the writer to the next block cloning using an FnMut dynamic reference. Arguments are (to, from) This function takes a dyn pointer so a v-table lookup is necessary. write_next_mut_fn is preferred if the function can be an fn pointer or write_next_mut_fn_impl is preferred if self is sized.

fn write_next_mut_fn_dyn_boxed(
    &mut self,
    clone_fn: Box<dyn FnOnce(&mut T, &mut T)>
)

Moves the writer to the next block cloning using a boxed FnOnce Arguments are (to, from) This function takes a boxed dyn pointer so a v-table lookup is necessary. write_next_mut_fn_dyn is preferred if the function can be coerced into an FnMut as no heap allocation will be necessary.

impl<T: Debug> Debug for RwLockCyclerWriter<T> where
    T: 'static, 

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

Formats the value using the given formatter.

impl<T> EnsureSend for RwLockCyclerWriter<T> where
    T: Send + Sync, 

impl<T> EnsureSync for RwLockCyclerWriter<T> where
    T: Send + Sync, 

impl<T> ReadAccess for RwLockCyclerWriter<T> where
    T: ReadAccess, 

type Read = T::Read

The type of read data that can be accessed. Will default to Self when https://github.com/rust-lang/rust/issues/29661 is resolved.

fn read_data(&self) -> &Self::Read

Gets a shared reference to the read data of the current block

impl<T> WriteAccess for RwLockCyclerWriter<T> where
    T: WriteAccess, 

type Write = T::Write

The type of write data that can be accessed. Will default to Self when https://github.com/rust-lang/rust/issues/29661 is resolved.

fn write_data(&self) -> &Self::Write

Gets a shared reference to the write data of the current block

fn write_data_mut(&mut self) -> &mut Self::Write

Gets an exclusive reference to the write data of the current block