Struct Unique 

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

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:

• Gd
• Dictionary
• Array

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,

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,

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>),

impl<V> Unique<Array<V>>

where V: Element,

pub fn apply<F>(&mut self, f: F)

where F: FnOnce(&mut Array<V>),

impl<T> Unique<T>

where T: UniqueType,

pub fn share(self) -> T

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<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<T> Send for Unique<T>

where T: UniqueType,

impl<T> Sync for Unique<T>

where T: UniqueType,