Struct PhantomMutex 

pub struct PhantomMutex;

A zero-sized raw mutex implementation that does not perform physical locking.

PhantomMutex can be used as the raw lock type in a KMutex<Class, PhantomMutex> field to serve as a zero-sized “phantom” lock in structs where physical synchronization is managed by an external shared lock (such as a ref-counted PeerHolder for peered dispatchers).

Using KMutex<Class, PhantomMutex> allows structs to integrate with #[guarded] and #[guarded_by(...)] without allocating memory for a physical mutex in every instance.

Example

use ksync::{KCell, KMutex, PhantomMutex, guarded};

#[guarded]
struct RealObject {
    #[mutex]
    mu: KMutex,
}

#[guarded]
struct PeeredObject {
    #[mutex(RealObjectMuClass)]
    mu: KMutex<PhantomMutex>,
    #[guarded_by(mu)]
    value: KCell<i32>,
}

// When holding the shared physical mutex (`real_obj.mu`), call `lock_mu` to access fields
// protected by the zero-sized `PhantomMutex`:

    ksync::lock!(let guard = phantom_obj.lock_mu(&real_obj.mu));
    let value = guard.value();

// If already holding a lock token from another guard of the same class, call `guard_mu`
// to obtain an accessor object without re-locking:

    let other_value = other_phantom_obj.guard_mu(guard.token()).value();

Implementations

impl PhantomMutex

pub fn project<'__pin>( self: Pin<&'__pin mut Self>, ) -> PhantomMutexProjection<'__pin>

Pin-projects all fields of Self.

These fields are structurally pinned:

These fields are not structurally pinned:

Trait Implementations

impl Clone for PhantomMutex

fn clone(&self) -> PhantomMutex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PhantomMutex

impl Debug for PhantomMutex

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

Formats the value using the given formatter.

impl Default for PhantomMutex

fn default() -> PhantomMutex

Returns the “default value” for a type.

impl HasPinData for PhantomMutex

type PinData = __ThePinData

unsafe fn __pin_data() -> Self::PinData

impl RawLock for PhantomMutex

type LockEntry = ()

Opaque stack entry storage type used by the lock validation loop detector (e.g. LockDep).

type DefaultPolicy = PhantomMutexPolicy

Default policy that should be used when acquiring this lock.

unsafe fn init(_class_id: *const c_void) -> impl PinInit<Self, Infallible>

where Self: Sized,

Returns a PinInit block to initialize the raw mutex in-place.

fn as_mut_ptr(&self) -> *mut c_void

Convert the raw mutex reference to a standard c_void pointer for FFI.

const LOCK_FLAGS: LockFlags = lockdep::LOCK_FLAGS_NONE

Flags specifying validation rules for the lock class.