Struct gdnative::core_types::VariantArray

pub struct VariantArray<Own = Shared>where
    Own: Ownership,{ /* private fields */ }

A reference-counted Variant vector. Godot’s generic array data type. Negative indices can be used to count from the right.

Generic methods on this type performs Variant conversion every time. This could be significant for complex structures. Users may convert arguments to Variants before calling to avoid this behavior if necessary.

Safety

This is a reference-counted collection with “interior mutability” in Rust parlance. To enforce that the official thread-safety guidelines are followed this type uses the typestate pattern. The typestate Access tracks whether there is thread-local or unique access (where pretty much all operations are safe) or whether the value might be “shared”, in which case not all operations are safe.

Implementations

impl<Own> VariantArray<Own>where
    Own: Ownership,

Operations allowed on all arrays at any point in time.

pub fn set<T>(&self, idx: i32, val: T)where
    T: OwnedToVariant,

Sets the value of the element at the given offset.

pub fn get(&self, idx: i32) -> Variant

Returns a copy of the element at the given offset.

pub unsafe fn get_ref(&self, idx: i32) -> &Variant

Returns a reference to the element at the given offset.

Safety

The returned reference is invalidated if the same container is mutated through another reference.

Variant is reference-counted and thus cheaply cloned. Consider using get instead.

pub unsafe fn get_mut_ref(&self, idx: i32) -> &mut Variant

Returns a mutable reference to the element at the given offset.

Safety

The returned reference is invalidated if the same container is mutated through another reference. It is possible to create two mutable references to the same memory location if the same idx is provided, causing undefined behavior.

pub fn count<T>(&self, val: T) -> i32where
    T: ToVariant,

pub fn is_empty(&self) -> bool

Returns true if the VariantArray contains no elements.

pub fn len(&self) -> i32

Returns the number of elements in the array.

pub fn find<T>(&self, what: T, from: i32) -> i32where
    T: ToVariant,

Searches the array for a value and returns its index. Pass an initial search index as the second argument. Returns -1 if value is not found.

pub fn contains<T>(&self, what: T) -> boolwhere
    T: ToVariant,

Returns true if the VariantArray contains the specified value.

pub fn rfind<T>(&self, what: T, from: i32) -> i32where
    T: ToVariant,

Searches the array in reverse order. Pass an initial search index as the second argument. If negative, the start index is considered relative to the end of the array.

pub fn find_last<T>(&self, what: T) -> i32where
    T: ToVariant,

Searches the array in reverse order for a value. Returns its index or -1 if not found.

pub fn invert(&self)

Inverts the order of the elements in the array.

pub fn hash(&self) -> i32

Return a hashed i32 value representing the array contents.

pub fn sort(&self)

pub fn duplicate(&self) -> VariantArray<Unique>

Create a copy of the array.

This creates a new array and is not a cheap reference count increment.

pub fn duplicate_deep(&self) -> VariantArray<Unique>

Create a deep copy of the array.

This creates a new array and is not a cheap reference count increment.

pub fn iter(&self) -> Iter<'_, Own>

Returns an iterator through all values in the VariantArray.

VariantArray is reference-counted and have interior mutability in Rust parlance. Modifying the same underlying collection while observing the safety assumptions will not violate memory safely, but may lead to surprising behavior in the iterator.

impl<Own> VariantArray<Own>where
    Own: LocalThreadOwnership,

Operations allowed on Dictionaries that can only be referenced to from the current thread.

pub fn clear(&self)

Clears the array, resizing to 0.

pub fn remove(&self, idx: i32)

Removes the element at idx.

pub fn erase<T>(&self, val: T)where
    T: ToVariant,

Removed the first occurrence of val.

pub fn resize(&self, size: i32)

Resizes the array, filling with Nil if necessary.

pub fn push<T>(&self, val: T)where
    T: OwnedToVariant,

Appends an element at the end of the array.

pub fn pop(&self) -> Variant

Removes an element at the end of the array.

pub fn push_front<T>(&self, val: T)where
    T: OwnedToVariant,

Appends an element to the front of the array.

pub fn pop_front(&self) -> Variant

Removes an element at the front of the array.

pub fn insert<T>(&self, at: i32, val: T)where
    T: OwnedToVariant,

Insert a new int at a given position in the array.

impl<Own> VariantArray<Own>where
    Own: NonUniqueOwnership,

Operations allowed on non-unique arrays.

pub unsafe fn assume_unique(self) -> VariantArray<Unique>

Assume that this is the only reference to this array, on which operations that change the container size can be safely performed.

Safety

It isn’t thread-safe to perform operations that change the container size from multiple threads at the same time. Creating multiple Unique references to the same collections, or violating the thread-safety guidelines in non-Rust code will cause undefined behavior.

impl VariantArray<Unique>

Operations allowed on unique arrays.

pub fn new() -> VariantArray<Unique>

Creates an empty VariantArray.

pub fn into_shared(self) -> VariantArray<Shared>

Put this array under the “shared” access type.

pub fn into_thread_local(self) -> VariantArray<ThreadLocal>

Put this array under the “thread-local” access type.

impl VariantArray<Shared>

Operations allowed on arrays that might be shared between different threads.

pub fn new_shared() -> VariantArray<Shared>

Create a new shared array.

impl VariantArray<ThreadLocal>

Operations allowed on Dictionaries that may only be shared on the current thread.

pub fn new_thread_local() -> VariantArray<ThreadLocal>

Create a new thread-local array.

Trait Implementations

impl CoerceFromVariant for VariantArray<Shared>

fn coerce_from_variant(v: &Variant) -> VariantArray<Shared>

impl<Own> Debug for VariantArray<Own>where
    Own: Ownership,

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

Formats the value using the given formatter.

impl Default for VariantArray<Shared>

fn default() -> VariantArray<Shared>

Returns the “default value” for a type.

impl Default for VariantArray<ThreadLocal>

fn default() -> VariantArray<ThreadLocal>

Returns the “default value” for a type.

impl Default for VariantArray<Unique>

fn default() -> VariantArray<Unique>

Returns the “default value” for a type.

impl<Own> Drop for VariantArray<Own>where
    Own: Ownership,

fn drop(&mut self)

Executes the destructor for this type.

impl Export for VariantArray<Shared>

type Hint = ArrayHint

A type-specific hint type that is valid for the type being exported.

fn export_info(
    hint: Option<<VariantArray<Shared> as Export>::Hint>
) -> ExportInfo

Returns ExportInfo given an optional typed hint.

impl<T, Own> Extend<T> for VariantArray<Own>where
    T: ToVariant,
    Own: LocalThreadOwnership,

fn extend<I>(&mut self, iter: I)where
    I: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> FromIterator<T> for VariantArray<Unique>where
    T: ToVariant,

fn from_iter<I>(iter: I) -> VariantArray<Unique>where
    I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl FromVariant for VariantArray<Shared>

fn from_variant(
    variant: &Variant
) -> Result<VariantArray<Shared>, FromVariantError>

impl<'a, Own> IntoIterator for &'a VariantArray<Own>where
    Own: Ownership,

type Item = Variant

The type of the elements being iterated over.

type IntoIter = Iter<'a, Own>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a VariantArray<Own> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for VariantArray<Unique>

type Item = Variant

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <VariantArray<Unique> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Own> NewRef for VariantArray<Own>where
    Own: NonUniqueOwnership,

fn new_ref(&self) -> VariantArray<Own>

Creates a new reference to the underlying object.

impl OwnedToVariant for VariantArray<Unique>

fn owned_to_variant(self) -> Variant

impl ToVariant for VariantArray<Shared>

fn to_variant(&self) -> Variant