Struct tokenlock::SingletonTokenRefMut

pub struct SingletonTokenRefMut<'a, Tag: ?Sized, Variant = SyncVariant>(_);

Zero-sized logical equivalent of &'a mut SingletonToken<Tag>.

The second type parameter (Variant) is internal use only and exempt from the API stability guarantee.

Examples

struct MyTag;
impl_singleton_token_factory!(MyTag);
let mut token = SingletonToken::<MyTag>::new().unwrap();
let lock = TokenLock::new(token.id(), 1);

// `SingletonTokenRefMut` is zero-sized (unlike `&SingletonToken`), so there is
// no runtime overhead involved with passing `SingletonTokenRefMut`.
access_lock(token.borrow_mut(), &lock);

fn access_lock(
    mut token: SingletonTokenRefMut<'_, MyTag>,
    lock: &TokenLock<u32, SingletonTokenId<MyTag>>,
) {
    assert_eq!(*lock.read(&*token), 1);
    lock.replace(&mut *token, 2);
}

SingletonTokenRefMut is Send-able because SingletonToken is Send:

let token: &'static mut SingletonTokenGuard<MyTag> =
    Box::leak(Box::new(SingletonToken::<MyTag>::new().unwrap()));
let token_ref: SingletonTokenRefMut<MyTag> = token.borrow_mut();
std::thread::spawn(move || {
    let _token_ref = token_ref;
});

Methods from Deref<Target = SingletonToken<Tag, Variant>>

pub fn id(&self) -> SingletonTokenId<Tag>

Construct an SingletonTokenId that equates to self.

pub fn borrow(&self) -> SingletonTokenRef<'_, Tag, Variant>

Borrow self as SingletonTokenRef or UnsyncSingletonTokenRef of the same Sync-ness as Self.

SingletonTokenRef is truly zero-sized, so it's more efficient to store and pass than &SingletonToken.

pub fn borrow_mut(&mut self) -> SingletonTokenRefMut<'_, Tag, Variant>

Borrow self mutably as SingletonTokenRefMut or UnsyncSingletonTokenRefMut of the same Sync-ness as Self.

SingletonTokenRefMut is truly zero-sized, so it's more efficient to store and pass than &mut SingletonToken.

pub fn borrow_sync(&self) -> SingletonTokenRef<'_, Tag>

Borrow self: UnsyncSingletonToken as SingletonTokenRef.

pub fn borrow_sync_mut(&mut self) -> SingletonTokenRefMut<'_, Tag>

Borrow self: UnsyncSingletonToken mutably as SingletonTokenRefMut.

pub fn borrow_unsync_mut(&mut self) -> UnsyncSingletonTokenRefMut<'_, Tag>

Borrow self: SingletonToken mutably as UnsyncSingletonTokenRefMut.

There is no borrow_unsync because that would allow UnsyncSingletonToken to be logically borrowed by multiple threads.

Trait Implementations

impl<Tag: ?Sized, Variant: SingletonTokenVariant> Debug for SingletonTokenRefMut<'_, Tag, Variant>

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

Formats the value using the given formatter.

impl<Tag: ?Sized, Variant: SingletonTokenVariant> Deref for SingletonTokenRefMut<'_, Tag, Variant>

type Target = SingletonToken<Tag, Variant>

The resulting type after dereferencing.

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

Dereferences the value.

impl<Tag: ?Sized, Variant: SingletonTokenVariant> DerefMut for SingletonTokenRefMut<'_, Tag, Variant>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Tag: ?Sized, Variant: SingletonTokenVariant> Eq for SingletonTokenRefMut<'_, Tag, Variant>

impl<Tag: ?Sized, Variant: SingletonTokenVariant> Hash for SingletonTokenRefMut<'_, Tag, Variant>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<Tag: ?Sized, Variant: SingletonTokenVariant> PartialEq<SingletonTokenRefMut<'_, Tag, Variant>> for SingletonTokenRefMut<'_, Tag, Variant>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.