Struct tokenlock::SingletonTokenRef

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

Zero-sized logical equivalent of &'a 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 token = SingletonToken::<MyTag>::new().unwrap();
let lock = TokenLock::new(token.id(), 1);

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

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

SingletonTokenRef does not allow mutable borrow:

let token_ref: SingletonTokenRef<MyTag> = token.borrow();

// compile error: `SingletonTokenRef` does not implement `DerefMut`
*lock.write(&mut *token_ref) = 4;

SingletonTokenRef is Send-able because SingletonToken is Sync:

let token: &'static SingletonTokenGuard<MyTag> =
    Box::leak(Box::new(SingletonToken::<MyTag>::new().unwrap()));
let token_ref: SingletonTokenRef<MyTag> = token.borrow();
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_sync(&self) -> SingletonTokenRef<'_, Tag>

Borrow self: UnsyncSingletonToken as SingletonTokenRef.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<Tag: ?Sized, Variant: SingletonTokenVariant> Deref for SingletonTokenRef<'_, 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> Eq for SingletonTokenRef<'_, Tag, Variant>

impl<Tag: ?Sized, Variant: SingletonTokenVariant> Hash for SingletonTokenRef<'_, 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<SingletonTokenRef<'_, Tag, Variant>> for SingletonTokenRef<'_, 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 !=.