Struct Current

pub struct Current<T>(/* private fields */);

Available on crate features std and unsafe_layout only.

A marker object representing the current instance of a type T.

This struct does not hold any actual value but instead allows access to a globally tracked instance of T, typically managed through CurrentGuard.

The primary purpose of Current<T> is to:

• Provide safe, structured access to a global instance of T.
• Prevent direct global mutable access in safe code.

Not a smart pointer; instead, it acts as a reference handle for thread-local state.

Vendored

This is adapted work from current.

Implementations

impl<T: Any> Current<T>

pub unsafe fn new() -> Current<T>

Creates a new Current<T> marker object.

Safety

• This function does not initialize an actual value.
• Dereferencing without an active CurrentGuard leads to undefined behavior.
• Ensure that CurrentGuard is properly managed before using this.

Example

let current = unsafe { Current::<MyType>::new() };

pub unsafe fn current(&mut self) -> Option<&mut T>

Retrieves an exclusive reference to the current instance of T, if set.

Safety

• May return a dangling reference if the associated CurrentGuard<T> has been dropped.
• The caller must ensure the reference is only used while the CurrentGuard<T> is alive.
• If the same T is set multiple times, the reference may be stale.

Example

let mut my_value = MyType::new();
let guard = CurrentGuard::new(&mut my_value);
let current = unsafe { Current::<MyType>::new().current() };
assert!(current.is_some());

pub unsafe fn current_unwrap(&mut self) -> &mut T

Retrieves an exclusive reference to the current instance of T, or panics.

Safety

Same as current: the caller must ensure the reference remains valid.

Panics

Panics if no instance of T is currently set.

Example

let mut my_value = MyType::new();
let guard = CurrentGuard::new(&mut my_value);
let current = unsafe { Current::<MyType>::new().current_unwrap() };

Trait Implementations

impl<T: Any> Deref for Current<T>

type Target = T

The resulting type after dereferencing.

fn deref<'a>(&'a self) -> &'a T

Dereferences the value.

impl<T: Any> DerefMut for Current<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.