Struct holochain::prelude::kitsune_p2p::dependencies::kitsune_p2p_types::dependencies::ghost_actor::dependencies::mockall::Fragile

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

A Fragile<T> wraps a non sendable T to be safely send to other threads.

Once the value has been wrapped it can be sent to other threads but access to the value on those threads will fail.

If the value needs destruction and the fragile wrapper is on another thread the destructor will panic. Alternatively you can use Sticky which is not going to panic but might temporarily leak the value.

Implementations

impl<T> Fragile<T>

pub fn new(value: T) -> Fragile<T>

Creates a new Fragile wrapping a value.

The value that is moved into the Fragile can be non Send and will be anchored to the thread that created the object. If the fragile wrapper type ends up being send from thread to thread only the original thread can interact with the value.

pub fn is_valid(&self) -> bool

Returns true if the access is valid.

This will be false if the value was sent to another thread.

pub fn into_inner(self) -> T

Consumes the Fragile, returning the wrapped value.

Panics

Panics if called from a different thread than the one where the original value was created.

pub fn try_into_inner(self) -> Result<T, Fragile<T>>

Consumes the Fragile, returning the wrapped value if successful.

The wrapped value is returned if this is called from the same thread as the one where the original value was created, otherwise the Fragile is returned as Err(self).

pub fn get(&self) -> &T

Immutably borrows the wrapped value.

Panics

Panics if the calling thread is not the one that wrapped the value. For a non-panicking variant, use try_get.

pub fn get_mut(&mut self) -> &mut T

Mutably borrows the wrapped value.

Panics

Panics if the calling thread is not the one that wrapped the value. For a non-panicking variant, use try_get_mut.

pub fn try_get(&self) -> Result<&T, InvalidThreadAccess>

Tries to immutably borrow the wrapped value.

Returns None if the calling thread is not the one that wrapped the value.

pub fn try_get_mut(&mut self) -> Result<&mut T, InvalidThreadAccess>

Tries to mutably borrow the wrapped value.

Returns None if the calling thread is not the one that wrapped the value.

Trait Implementations

impl<T> Clone for Fragile<T>

where T: Clone,

fn clone(&self) -> Fragile<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Fragile<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Fragile<T>

where T: Default,

fn default() -> Fragile<T>

Returns the “default value” for a type.

impl<T> Display for Fragile<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T> Drop for Fragile<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<T> for Fragile<T>

fn from(t: T) -> Fragile<T>

Converts to this type from the input type.

impl<T> Ord for Fragile<T>

where T: Ord,

fn cmp(&self, other: &Fragile<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T> PartialEq for Fragile<T>

where T: PartialEq,

fn eq(&self, other: &Fragile<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialOrd for Fragile<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Fragile<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Fragile<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Fragile<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Fragile<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Fragile<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Eq for Fragile<T>

where T: Eq,

impl<T> Send for Fragile<T>

impl<T> Sync for Fragile<T>