Struct Unaware 

#[repr(transparent)]
pub struct Unaware<T>(pub T);

Allows transferring a value that doesn’t implement ThreadAware.

Since the ThreadAware trait is not commonly implemented, this wrapper can be used to allow transferring values that don’t implement ThreadAware.

Performance Considerations

Care must be taken when using this type - since the value will be moved as is, if it contains shared references to data other threads may use, it can introduce contention, resulting in performance impact.

You should never wrap types that are immediately ThreadAware, hence its name Unaware.

In addition, if the wrapped value contains an Arc with interior mutability somewhere inside, this wrapper should not be used, and an Arc with a PerThread or PerNuma with independent initialization per affinity is a better option.

Tuple Fields

0: T

Implementations

impl<T> Unaware<T>

pub fn into_inner(self) -> T

Consumes the wrapper and returns the inner value.

pub fn into_arc(self: Arc<Self>) -> Arc<T>

Converts an Arc<Unaware<T>> into an Arc<T>.

Trait Implementations

impl<T: Clone> Clone for Unaware<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Unaware<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Unaware<T>

fn default() -> Unaware<T>

Returns the “default value” for a type.

impl<T> Deref for Unaware<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Unaware<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> From<T> for Unaware<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Unaware<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Unaware<T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> ThreadAware for Unaware<T>

fn relocated( self, _source: MemoryAffinity, _destination: PinnedAffinity, ) -> Self

Consume a value and return a value in the destination affinity.

impl<T: Copy> Copy for Unaware<T>

impl<T: Eq> Eq for Unaware<T>

impl<T> StructuralPartialEq for Unaware<T>