Struct tracing_mutex::lockapi::TracingWrapper

pub struct TracingWrapper<T> { /* private fields */ }

Tracing wrapper for all lock_api traits.

This wrapper implements any of the locking traits available, given that the wrapped type implements them. As such, this wrapper can be used both for normal mutexes and rwlocks.

Trait Implementations

impl<T: Debug> Debug for TracingWrapper<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for TracingWrapper<T>

fn default() -> TracingWrapper<T>

Returns the “default value” for a type.

impl<T> RawMutex for TracingWrapper<T>

where T: RawMutex,

type GuardMarker = GuardNoSend

Always equal to GuardNoSend, as an implementation detail in the tracking system requires this behaviour. May change in the future to reflect the actual guard type from the wrapped primitive.

const INIT: Self = _

Initial value for an unlocked mutex.

fn lock(&self)

Acquires this mutex, blocking the current thread until it is able to do so.

fn try_lock(&self) -> bool

Attempts to acquire this mutex without blocking. Returns true if the lock was successfully acquired and false otherwise.

unsafe fn unlock(&self)

Unlocks this mutex.

fn is_locked(&self) -> bool

Checks whether the mutex is currently locked.

impl<T> RawMutexFair for TracingWrapper<T>

where T: RawMutexFair,

unsafe fn unlock_fair(&self)

Unlocks this mutex using a fair unlock protocol.

unsafe fn bump(&self)

Temporarily yields the mutex to a waiting thread if there is one.

impl<T> RawMutexTimed for TracingWrapper<T>

where T: RawMutexTimed,

type Duration = <T as RawMutexTimed>::Duration

Duration type used for try_lock_for.

type Instant = <T as RawMutexTimed>::Instant

Instant type used for try_lock_until.

fn try_lock_for(&self, timeout: Self::Duration) -> bool

Attempts to acquire this lock until a timeout is reached.

fn try_lock_until(&self, timeout: Self::Instant) -> bool

Attempts to acquire this lock until a timeout is reached.

impl<T> RawRwLock for TracingWrapper<T>

where T: RawRwLock,

type GuardMarker = GuardNoSend

Always equal to GuardNoSend, as an implementation detail in the tracking system requires this behaviour. May change in the future to reflect the actual guard type from the wrapped primitive.

const INIT: Self = _

Initial value for an unlocked RwLock.

fn lock_shared(&self)

Acquires a shared lock, blocking the current thread until it is able to do so.

fn try_lock_shared(&self) -> bool

Attempts to acquire a shared lock without blocking.

unsafe fn unlock_shared(&self)

Releases a shared lock.

fn lock_exclusive(&self)

Acquires an exclusive lock, blocking the current thread until it is able to do so.

fn try_lock_exclusive(&self) -> bool

Attempts to acquire an exclusive lock without blocking.

unsafe fn unlock_exclusive(&self)

Releases an exclusive lock.

fn is_locked(&self) -> bool

Checks if this RwLock is currently locked in any way.

fn is_locked_exclusive(&self) -> bool

Check if this RwLock is currently exclusively locked.

impl<T> RawRwLockDowngrade for TracingWrapper<T>

where T: RawRwLockDowngrade,

unsafe fn downgrade(&self)

Atomically downgrades an exclusive lock into a shared lock without allowing any thread to take an exclusive lock in the meantime.

impl<T> RawRwLockFair for TracingWrapper<T>

where T: RawRwLockFair,

unsafe fn unlock_shared_fair(&self)

Releases a shared lock using a fair unlock protocol.

unsafe fn unlock_exclusive_fair(&self)

Releases an exclusive lock using a fair unlock protocol.

unsafe fn bump_shared(&self)

Temporarily yields a shared lock to a waiting thread if there is one.

unsafe fn bump_exclusive(&self)

Temporarily yields an exclusive lock to a waiting thread if there is one.

impl<T> RawRwLockRecursive for TracingWrapper<T>

where T: RawRwLockRecursive,

fn lock_shared_recursive(&self)

Acquires a shared lock without deadlocking in case of a recursive lock.

fn try_lock_shared_recursive(&self) -> bool

Attempts to acquire a shared lock without deadlocking in case of a recursive lock.

impl<T> RawRwLockRecursiveTimed for TracingWrapper<T>

where T: RawRwLockRecursiveTimed,

fn try_lock_shared_recursive_for(&self, timeout: Self::Duration) -> bool

Attempts to acquire a shared lock until a timeout is reached, without deadlocking in case of a recursive lock.

fn try_lock_shared_recursive_until(&self, timeout: Self::Instant) -> bool

Attempts to acquire a shared lock until a timeout is reached, without deadlocking in case of a recursive lock.

impl<T> RawRwLockTimed for TracingWrapper<T>

where T: RawRwLockTimed,

type Duration = <T as RawRwLockTimed>::Duration

Duration type used for try_lock_for.

type Instant = <T as RawRwLockTimed>::Instant

Instant type used for try_lock_until.

fn try_lock_shared_for(&self, timeout: Self::Duration) -> bool

Attempts to acquire a shared lock until a timeout is reached.

fn try_lock_shared_until(&self, timeout: Self::Instant) -> bool

Attempts to acquire a shared lock until a timeout is reached.

fn try_lock_exclusive_for(&self, timeout: Self::Duration) -> bool

Attempts to acquire an exclusive lock until a timeout is reached.

fn try_lock_exclusive_until(&self, timeout: Self::Instant) -> bool

Attempts to acquire an exclusive lock until a timeout is reached.

impl<T> RawRwLockUpgrade for TracingWrapper<T>

where T: RawRwLockUpgrade,

fn lock_upgradable(&self)

Acquires an upgradable lock, blocking the current thread until it is able to do so.

fn try_lock_upgradable(&self) -> bool

Attempts to acquire an upgradable lock without blocking.

unsafe fn unlock_upgradable(&self)

Releases an upgradable lock.

unsafe fn upgrade(&self)

Upgrades an upgradable lock to an exclusive lock.

unsafe fn try_upgrade(&self) -> bool

Attempts to upgrade an upgradable lock to an exclusive lock without blocking.

impl<T> RawRwLockUpgradeDowngrade for TracingWrapper<T>

where T: RawRwLockUpgradeDowngrade,

unsafe fn downgrade_upgradable(&self)

Downgrades an upgradable lock to a shared lock.

unsafe fn downgrade_to_upgradable(&self)

Downgrades an exclusive lock to an upgradable lock.

impl<T> RawRwLockUpgradeFair for TracingWrapper<T>

where T: RawRwLockUpgradeFair,

unsafe fn unlock_upgradable_fair(&self)

Releases an upgradable lock using a fair unlock protocol.

unsafe fn bump_upgradable(&self)

Temporarily yields an upgradable lock to a waiting thread if there is one.

impl<T> RawRwLockUpgradeTimed for TracingWrapper<T>

where T: RawRwLockUpgradeTimed,

fn try_lock_upgradable_for(&self, timeout: Self::Duration) -> bool

Attempts to acquire an upgradable lock until a timeout is reached.

fn try_lock_upgradable_until(&self, timeout: Self::Instant) -> bool

Attempts to acquire an upgradable lock until a timeout is reached.

unsafe fn try_upgrade_for(&self, timeout: Self::Duration) -> bool

Attempts to upgrade an upgradable lock to an exclusive lock until a timeout is reached.

unsafe fn try_upgrade_until(&self, timeout: Self::Instant) -> bool

Attempts to upgrade an upgradable lock to an exclusive lock until a timeout is reached.