Skip to main content

Unique

Struct Unique

pub struct Unique<T>where
    T: UniqueType,
{ /* private fields */ }

Expand description

Makes sure the inner value is unique and can be safely shared across threads.

No other part of the engine will have access to the inner value and only Send + Sync or other Unique<T> values can be passed to functions on T. Unique also blocks access to Gd::clone or to their InstanceId.

Unique supports these generally not thread safe types:

Implementations§

impl<T> Unique<Gd<T>>
where T: GodotClass + NewAlloc,

pub fn new_alloc() -> Unique<Gd<T>>

impl<T> Unique<Gd<T>>
where T: GodotClass + NewGd,

pub fn new_gd() -> Unique<Gd<T>>

impl<K, V> Unique<Dictionary<K, V>>
where K: Element, V: Element,

pub fn new() -> Unique<Dictionary<K, V>>

impl<V> Unique<Array<V>>
where V: Element,

pub fn new() -> Unique<Array<V>>

impl<T> Unique<Gd<T>>
where T: GodotClass<Memory = MemRefCounted> + Bounds,

pub fn try_from_ref_counted(value: Gd<T>) -> Option<Unique<Gd<T>>>
where T: GodotClass<Declarer = DeclEngine, Memory = MemRefCounted> + Inherits<RefCounted> + Inherits<Object>,

Attempts to verify that the provided ref-counted object is in fact unique.

This might fail if the object is referenced by anything else or any of its internal references are shared with other objects. Specific reasons for this conversion to fail:

Reference counter is > 1.
Reference count of any property value is > 1.
Any property value directly inherits from Object (manually managed).
Any property value is of type Dictionary or any of the Array types.
Any property is a custom callable.
Any property fails these checks recursively.

Since all checks are applied recursively to all objects which are referenced by the given value this conversion can potentially be quite expensive.

impl<T> Unique<Gd<T>>
where T: GodotClass<Declarer = DeclEngine>,

pub fn apply_gd<F>(&mut self, f: F)
where F: FnOnce(&mut T) + Send + Sync,

Apply modifications to unique instance of the inner type.

All captured outer variables must be thread-safe.

impl<T> Unique<Gd<T>>
where T: GodotClass<Declarer = DeclUser>,

pub fn apply<F>(&mut self, f: F)
where F: FnOnce(&mut T) + Send + Sync,

Apply modifications to unique instance of the inner type.

All captured outer variables must be thread-safe.

impl<K, V> Unique<Dictionary<K, V>>
where K: Element, V: Element,

pub fn apply<F>(&mut self, f: F)
where F: FnOnce(&mut Dictionary<K, V>) + Send + Sync,

Apply modifications to unique instance of the inner type.

All captured outer variables must be thread-safe.

impl<V> Unique<Array<V>>
where V: Element,

pub fn apply<F>(&mut self, f: F)
where F: FnOnce(&mut Array<V>) + Send + Sync,

Apply modifications to unique instance of the inner type.

All captured outer variables must be thread-safe.

impl<T> Unique<T>
where T: UniqueType,

Unwraps the inner value and gives up all uniqueness guarantees.

Trait Implementations§

impl<T> ThreadSafeArgContext for Unique<T>
where T: UniqueType,

fn guarantee_thread_safe()

Panics if the value is being used in a non thread-safe context.

impl<V> AsArg<AnyArray> for Unique<Array<V>>
where V: Element,

impl<K, V> AsArg<AnyDictionary> for Unique<Dictionary<K, V>>
where K: Element, V: Element,

impl<V> AsArg<Array<V>> for Unique<Array<V>>
where V: Element,

impl<K, V> AsArg<Dictionary<K, V>> for Unique<Dictionary<K, V>>
where K: Element, V: Element,

impl<T> AsArg<Gd<T>> for Unique<Gd<T>>
where T: GodotClass,

impl<T> AsArg<Option<Gd<T>>> for Unique<Gd<T>>
where T: GodotClass,

impl<V> AsArg<Variant> for Unique<Array<V>>
where V: Element,

impl<K, V> AsArg<Variant> for Unique<Dictionary<K, V>>
where K: Element, V: Element,

impl<T> AsArg<Variant> for Unique<Gd<T>>
where T: GodotClass,

impl<T> Send for Unique<T>
where T: UniqueType,

impl<T> Sync for Unique<T>
where T: UniqueType,

Auto Trait Implementations§

impl<T> Freeze for Unique<T>
where T: Freeze,

impl<T> RefUnwindSafe for Unique<T>
where T: RefUnwindSafe,

impl<T> Unpin for Unique<T>
where T: Unpin,

impl<T> UnsafeUnpin for Unique<T>
where T: UnsafeUnpin,

impl<T> UnwindSafe for Unique<T>
where T: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.