Struct ReadRef

pub struct ReadRef<'a, T: 'a, const N: usize> { /* private fields */ }

A barely smart pointer referencing data owned by VLock. The access to the data is RAII-style, and is released when dropped.

This type is created by VLock::read.

This type can’t be cloned. Holding on to a version for too long is no good. Instead, call read to acquire more copies if necessary. The next read may return a newer version, however.

Trait Implementations

impl<T, const N: usize> AsRef<T> for ReadRef<'_, T, N>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, const N: usize> Borrow<T> for ReadRef<'_, T, N>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: Debug, const N: usize> Debug for ReadRef<'_, T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Deref for ReadRef<'_, T, N>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Display, const N: usize> Display for ReadRef<'_, T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Drop for ReadRef<'_, T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> Hash for ReadRef<'_, T, N>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds the address of a pointer to calculate a hash, which is unique per version.

Dereference to hash the value behind the pointer.

Examples

use std::collections::HashSet;

use vlock::VLock;

let lock: VLock<_, 2> = 10.into();
let mut ptr_set = HashSet::new();
let mut val_set = HashSet::new();
assert!(ptr_set.insert(lock.read()));
assert!(val_set.insert(*lock.read()));
assert!(!ptr_set.insert(lock.read()));
assert!(!val_set.insert(*lock.read()));

lock.update(|curr, value| *value = *curr, || 0);
assert!(ptr_set.insert(lock.read()));
assert!(!val_set.insert(*lock.read()));

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const N: usize> PartialEq for ReadRef<'_, T, N>

fn eq(&self, other: &Self) -> bool

Equality by comparing the addresses of two pointers, which if equal guarantee that two versions are in fact the same exact version.

Dereference to compare the inner values.

Examples

use vlock::VLock;

let lock: VLock<_, 2> = 10.into();
let read1 = lock.read();
let read2 = lock.read();
assert_eq!(read1, read2);

lock.update(|curr, value| *value = *curr, || 0);
let read3 = lock.read();
assert_ne!(read2, read3);
assert_eq!(*read2, *read3);

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const N: usize> Pointer for ReadRef<'_, T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Eq for ReadRef<'_, T, N>

impl<T: Sync, const N: usize> Send for ReadRef<'_, T, N>

impl<T: Sync, const N: usize> Sync for ReadRef<'_, T, N>