Struct tokenlock::UnsyncTokenLock

pub struct UnsyncTokenLock<T: ?Sized, Keyhole> { /* private fields */ }

Like TokenLock, but the usable Tokens are constrained by Unsync. This subtle difference allows it to be Sync even if T is not.

See the module-level documentation for more details.

Implementations

impl<T, Keyhole> UnsyncTokenLock<T, Keyhole>

Construction and Destruction

pub const fn new(keyhole: Keyhole, data: T) -> Self

Construct a Self.

pub fn wrap(data: T) -> Self where
    Keyhole: Default, 

Construct a Self with a default-constructed Keyhole.

pub fn into_inner(self) -> T

Consume self, returning the contained data.

impl<T: ?Sized, Keyhole> UnsyncTokenLock<T, Keyhole>

Miscellaneous

pub const fn keyhole(&self) -> &Keyhole

Get a reference to the contained Keyhole (keyhole).

pub const fn as_ptr(&self) -> *mut T

Get a raw pointer to the contained data.

impl<T: ?Sized, Keyhole> UnsyncTokenLock<T, Keyhole>

Borrowing

pub fn read<'a, K: Token<Keyhole> + Unsync>(&'a self, token: &'a K) -> &'a T

Get a reference to the contained data. Panic if token doesn’t fit in the keyhole.

pub fn write<'a, K: Token<Keyhole>>(&'a self, token: &'a mut K) -> &'a mut T

Get a mutable reference to the contained data. Panic if token doesn’t fit in the keyhole.

pub fn try_read<'a, K: Token<Keyhole> + Unsync>(
    &'a self,
    token: &'a K
) -> Result<&'a T, BadTokenError>

Get a reference to the contained data. Return BadTokenError if token doesn’t fit in the keyhole.

pub fn try_write<'a, K: Token<Keyhole>>(
    &'a self,
    token: &'a mut K
) -> Result<&'a mut T, BadTokenError>

Get a mutable reference to the contained data. Return BadTokenError if token doesn’t fit in the keyhole.

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

Get a mutable reference to the contained data.

impl<T, Keyhole> UnsyncTokenLock<T, Keyhole>

Utilities

pub fn get<K: Token<Keyhole> + Unsync>(&self, token: &K) -> T where
    T: Clone, 

Get the contained data by cloning. Panic if token doesn’t fit in the keyhole.

pub fn try_get<K: Token<Keyhole> + Unsync>(
    &self,
    token: &K
) -> Result<T, BadTokenError> where
    T: Clone, 

Get the contained data by cloning. Return BadTokenError if token doesn’t fit in the keyhole.

pub fn set<K: Token<Keyhole>>(&self, token: &mut K, value: T)

Assign a new value. Panic if token doesn’t fit in thekeyhole.

pub fn try_set<K: Token<Keyhole>>(
    &self,
    token: &mut K,
    value: T
) -> Result<(), BadTokenError>

Assign a new value. Return BadTokenError if token doesn’t fit in the keyhole.

pub fn take<K: Token<Keyhole>>(&self, token: &mut K) -> T where
    T: Default, 

Take the contained data, leaving Default::default() in its place. Panic if token doesn’t fit in the keyhole.

pub fn try_take<K: Token<Keyhole>>(
    &self,
    token: &mut K
) -> Result<T, BadTokenError> where
    T: Default, 

Take the contained data, leaving Default::default() in its place. Return BadTokenError if token doesn’t fit in the keyhole.

pub fn replace<K: Token<Keyhole>>(&self, token: &mut K, t: T) -> T

Replace the contained data with a new one. Panic if token doesn’t fit in the keyhole.

This function corresponds to std::mem::replace.

pub fn replace_with<K: Token<Keyhole>>(
    &self,
    token: &mut K,
    f: impl FnOnce(&mut T) -> T
) -> T

Replace the contained data with a new one computed by the given closure. Panic if token doesn’t fit in the keyhole.

This function corresponds to std::mem::replace.

pub fn try_replace_with<K: Token<Keyhole>>(
    &self,
    token: &mut K,
    f: impl FnOnce(&mut T) -> T
) -> Result<T, BadTokenError>

Replace the contained data with a new one computed by f. Panic if token doesn’t fit in the keyhole.

This function corresponds to std::mem::replace.

pub fn swap<IOther, K: Token<Keyhole> + Token<IOther>>(
    &self,
    token: &mut K,
    other: &UnsyncTokenLock<T, IOther>
)

Swap the contained data with the contained data of other. Panic if token doesn’t fit in the keyhole of both TokenLocks.

This function corresponds to std::mem::swap.

pub fn try_swap<IOther, K: Token<Keyhole> + Token<IOther>>(
    &self,
    token: &mut K,
    other: &UnsyncTokenLock<T, IOther>
) -> Result<(), BadTokenError>

Swap the contained data with the contained data of other. Return BadTokenError if token doesn’t fit in the keyhole of both TokenLocks.

impl<T: Clone, Keyhole: Clone> UnsyncTokenLock<T, Keyhole>

Cloning

pub fn clone<K: Token<Keyhole> + Unsync>(&self, token: &K) -> Self

Clone self. Panic if token doesn’t fit in the keyhole.

pub fn try_clone<K: Token<Keyhole> + Unsync>(
    &self,
    token: &K
) -> Result<Self, BadTokenError>

Clone self. Return BadTokenError if token doesn’t fit in the keyhole.

Trait Implementations

impl<T: ConstDefault, Keyhole: ConstDefault> ConstDefault for UnsyncTokenLock<T, Keyhole>

const DEFAULT: Self = Self{keyhole: const_default_1::ConstDefault::DEFAULT, data: const_default_1::ConstDefault::DEFAULT,}

The constant default value.

impl<T: ?Sized, Keyhole: Debug> Debug for UnsyncTokenLock<T, Keyhole>

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

Formats the value using the given formatter.

impl<T: Default + ?Sized, Keyhole: Default> Default for UnsyncTokenLock<T, Keyhole>

fn default() -> UnsyncTokenLock<T, Keyhole>

Returns the “default value” for a type.

impl<T: ?Sized + Send, Keyhole: Send> Send for UnsyncTokenLock<T, Keyhole>

impl<T: ?Sized + Send, Keyhole: Sync> Sync for UnsyncTokenLock<T, Keyhole>