Struct MainThreadCell 

pub struct MainThreadCell<T: 'static> { /* private fields */ }

A thread-safe cell that ensures all access to its contents happens on the main thread.

MainThreadCell<T> allows you to share T across threads while guaranteeing that all access to the inner value occurs on the main thread. This is particularly useful for platform-specific resources that have main-thread-only requirements.

Thread Safety

• The cell itself can be cloned and sent across threads
• All access methods verify they’re called from the main thread
• The with and with_async methods automatically dispatch to the main thread
• Drop operations are automatically handled on the main thread

Implementations

impl<T> MainThreadCell<T>

pub fn new(t: T) -> Self

Creates a new MainThreadCell containing the given value.

This must be called on the main thread. Constructing the cell elsewhere would allow a non-Send value (and any aliases it contains) to cross threads.

Panics

Panics if called from a non-main thread.

pub fn lock(&self) -> MainThreadGuard<'_, T>

Locks the cell and returns a guard providing mutable access to the inner value.

This method can only be called from the main thread.

Panics

Panics if called from a non-main thread.

pub fn assume<C, R>(&self, c: C) -> R

where C: FnOnce(&T) -> R,

Runs a closure with immutable access to the inner value.

This method can only be called from the main thread.

Panics

Panics if called from a non-main thread.

pub async fn with<C, R>(&self, c: C) -> R

where C: FnOnce(&T) -> R + Send + 'static, R: Send + 'static, T: 'static,

Runs a closure with the inner value, ensuring execution on the main thread.

If called from the main thread, the closure executes immediately. If called from another thread, it’s dispatched to the main thread.

Panics

For the duration of this function, the cell may not be otherwise used.

pub async fn with_async<C, R, F>(&self, c: C) -> R

where C: FnOnce(&T) -> F + Send + 'static, F: Future<Output = R> + Send + 'static, R: Send + 'static, T: 'static,

Runs an async closure with the inner value, ensuring execution on the main thread.

If called from the main thread, the closure executes immediately. If called from another thread, it’s dispatched to the main thread.

This method is more restrictive than with_async - it requires that access to the inner value doesn’t cross async boundaries within the closure.

Panics

For the duration of this function, the cell may not be otherwise used.

pub async fn new_on_main_thread<C, F>(c: C) -> MainThreadCell<T>

where C: FnOnce() -> F + Send + 'static, F: Future<Output = T> + Send + 'static,

Creates a new MainThreadCell by running a constructor closure on the main thread.

This function ensures the value is created on the main thread, which is useful for resources that must be constructed there.

Trait Implementations

impl<T> Clone for MainThreadCell<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MainThreadCell<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for MainThreadCell<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<T> for MainThreadCell<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T> PartialEq for MainThreadCell<T>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T> Send for MainThreadCell<T>