Struct dubble::DoubleBuffered

pub struct DoubleBuffered<T: Clone> { /* fields omitted */ }

Represents something that is double-buffered. The type being buffered must be Clone, so that the read buffer can be updated with the contents of the write buffer during the update.

See the module-level documentation for more information.

Methods

impl<T: Clone> DoubleBuffered<T>

pub fn new(value: T) -> Self

Initialises the double-buffer with the value. Both buffers are initialised with the same value.

pub fn construct_with<F: Fn() -> T>(constructor: F) -> Self

Uses constructor to construct each buffer. It's handy to pass things like Vec::new into here. DoubleBuffered also implements default if the wrapped type does, so you could also do DoubleBuffered<Vec<T>>::default()

pub fn read(&self) -> &T

Returns an immutable reference to the read buffer.

pub fn write(&mut self) -> &mut T

Returns a mutable reference to the write buffer. Note that changes made through this reference will not be reflected until after update is called.

This might seem a little weird; "why not just go my_buf.write(stuff)"?. The reason is so that you can update the elements of a collection without having to build a clone of the collection. For example:

let mut my_buf: DoubleBuffered<Vec<i32>> = DoubleBuffered::default();
let mut wb = my_buf.write();
wb.push(4);

Compared to the other potential form:

let mut wb = my_buf.read().clone();
wb.push(5);
// my_buf.write(wb);

Notice that you have to create a copy and modify it.

pub fn update(&mut self)

Copies the write buffer into the read buffer.

pub fn upsert(&mut self, value: T)

Writes the value to the write buffer, and then immediately updates the read buffer.

pub fn unbuffer_read(self) -> T

Returns the read buffer. This does not update the read buffer with the contents of the write buffer beforehand. You could think of this like "quit without saving" in a word processor.

pub fn unbuffer_write(self) -> T

Returns the write buffer.

Trait Implementations

impl<T: Clone> Deref for DoubleBuffered<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Clone> DerefMut for DoubleBuffered<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: Default + Clone> Default for DoubleBuffered<T>

fn default() -> Self

Use the default constructor for the type.

impl<I, T: Index<I> + Clone> Index<I> for DoubleBuffered<T>

type Output = <T as Index<I>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I, T: IndexMut<I> + Clone> IndexMut<I> for DoubleBuffered<T>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.