GArray

Conformances

• protocol BidirectionalCollection<Element>

  A collection that supports backward as well as forward traversal.

• protocol Collection<Element>

  A sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.

• protocol ContentVariantRepresentable

  Some of Godot’s builtin classes use ContentType for storage. This needs to be public because it affects their initialization, but SwiftGodot users should never need to conform their types toContentVariantRepresentable.

• protocol Copyable

  A type whose values can be implicitly or explicitly copied.

• protocol Equatable

  A type that can be compared for value equality.

• protocol Escapable
• protocol RandomAccessCollection<Element>

  A collection that supports efficient random-access index traversal.

• protocol Sequence<Element>

  A type that provides sequential, iterated access to its elements.

• protocol VariantRepresentable

  Types that conform to VariantRepresentable can be stored directly in Variant with no conversion. These include all of the Variant types from Godot (for example GString, Rect, Plane), Godot objects (those that subclass SwiftGodot.Object) as well as the built-in Swift types UInt8, Int64 and Double.

• protocol VariantStorable

  Types that conform to VariantStorable can be stored in a Variant and can be extracted back out of a Variant.

Typealiases

• typealias ContentType

Type members

• init()

  Constructs an empty GArray.

• init<T>(T.Type)

  Initializes an empty, but typed GArray. For example: GArray(Node.self)

• init(alreadyOwnedContent: ContentType)
• init(base: GArray, type: Int32, className: StringName, script: Variant)

  Creates a typed array from the base array. All arguments are required.

• init(content: ContentType)
• init(from: GArray)

  Returns the same array as from. If you need a copy of the array, use duplicate(deep:).

• init(from: PackedByteArray)

  Constructs an array from a PackedByteArray.

• init(from: PackedColorArray)

  Constructs an array from a PackedColorArray.

• init(from: PackedInt32Array)

  Constructs an array from a PackedInt32Array.

• init(from: PackedInt64Array)

  Constructs an array from a PackedInt64Array.

• init(from: PackedStringArray)

  Constructs an array from a PackedStringArray.

• init(from: PackedFloat32Array)

  Constructs an array from a PackedFloat32Array.

• init(from: PackedFloat64Array)

  Constructs an array from a PackedFloat64Array.

• init(from: PackedVector2Array)

  Constructs an array from a PackedVector2Array.

• init(from: PackedVector3Array)

  Constructs an array from a PackedVector3Array.

• init(from: PackedVector4Array)

  Constructs an array from a PackedVector4Array.

• static var godotType: Variant.GType
• static let zero: ContentType
• static func != (lhs: GArray, rhs: GArray) -> Bool

  Compares the left operand GArray against the right GArray. Returns true if the sizes or contents of the arrays are not equal, false otherwise.

• static func + (lhs: GArray, rhs: GArray) -> GArray

  Concatenates two GArrays together, with the right GArray being added to the end of the GArray specified in the left operand. For example, [1, 2] + [3, 4] results in [1, 2, 3, 4].

• static func < (lhs: GArray, rhs: GArray) -> Bool

  Performs a comparison for each index between the left operand GArray and the right GArray, considering the highest common index of both arrays for this comparison: Returns true on the first occurrence of an element that is less, or false if the element is greater. Note that depending on the type of data stored, this function may be recursive. If all elements are equal, it compares the length of both arrays and returns false if the left operand GArray has fewer elements, otherwise it returns true.

• static func <= (lhs: GArray, rhs: GArray) -> Bool

  Performs a comparison for each index between the left operand GArray and the right GArray, considering the highest common index of both arrays for this comparison: Returns true on the first occurrence of an element that is less, or false if the element is greater. Note that depending on the type of data stored, this function may be recursive. If all elements are equal, it compares the length of both arrays and returns true if the left operand GArray has the same number of elements or fewer, otherwise it returns false.

• static func == (lhs: GArray, rhs: GArray) -> Bool

  Compares the left operand GArray against the right GArray. Returns true if the sizes and contents of the arrays are equal, false otherwise.

• static func > (lhs: GArray, rhs: GArray) -> Bool

  Performs a comparison for each index between the left operand GArray and the right GArray, considering the highest common index of both arrays for this comparison: Returns true on the first occurrence of an element that is greater, or false if the element is less. Note that depending on the type of data stored, this function may be recursive. If all elements are equal, it compares the length of both arrays and returns true if the right GArray has more elements, otherwise it returns false.

• static func >= (lhs: GArray, rhs: GArray) -> Bool

  Performs a comparison for each index between the left operand GArray and the right GArray, considering the highest common index of both arrays for this comparison: Returns true on the first occurrence of an element that is greater, or false if the element is less. Note that depending on the type of data stored, this function may be recursive. If all elements are equal, it compares the length of both arrays and returns true if the right GArray has more or the same number of elements, otherwise it returns false.

Instance members

• var content: ContentType
• var endIndex: Int
• var startIndex: Int
• subscript(Int) -> Variant
• func all(method: Callable) -> Bool

  Calls the provided Callable on each element in the array and returns true if the Callable returns true for all elements in the array. If the Callable returns false for one array element or more, this method returns false.

• func any(method: Callable) -> Bool

  Calls the provided Callable on each element in the array and returns true if the Callable returns true for one or more elements in the array. If the Callable returns false for all elements in the array, this method returns false.

• func append(Variant)

  Appends an element at the end of the array (alias of pushBack(value:)).

• func appendArray(GArray)

  Appends another array at the end of this array.

• func assign(array: GArray)

  Assigns elements of another array into the array. Resizes the array to match array. Performs type conversions if the array is typed.

• func back() -> Variant

  Returns the last element of the array. Prints an error and returns null if the array is empty.

• func bsearch(value: Variant, before: Bool) -> Int64

  Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a before specifier can be passed. If false, the returned index comes after all existing entries of the value in the array.

• func bsearchCustom(value: Variant, func: Callable, before: Bool) -> Int64

  Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search and a custom comparison method. Optionally, a before specifier can be passed. If false, the returned index comes after all existing entries of the value in the array. The custom method receives two arguments (an element from the array and the value searched for) and must return true if the first argument is less than the second, and return false otherwise.

• func clear()

  Clears the array. This is equivalent to using resize(size:) with a size of 0.

• func count(value: Variant) -> Int64

  Returns the number of times an element is in the array.

• func duplicate(deep: Bool) -> GArray

  Returns a copy of the array.

• func erase(value: Variant)

  Removes the first occurrence of a value from the array. If the value does not exist in the array, nothing happens. To remove an element by index, use removeAt(position:) instead.

• func fill(value: Variant)

  Assigns the given value to all elements in the array. This can typically be used together with resize(size:) to create an array with a given size and initialized elements:

• func filter(method: Callable) -> GArray

  Calls the provided Callable on each element in the array and returns a new array with the elements for which the method returned true.

• func find(what: Variant, from: Int64) -> Int64

  Searches the array for a value and returns its index or -1 if not found. Optionally, the initial search index can be passed.

• func front() -> Variant

  Returns the first element of the array. Prints an error and returns null if the array is empty.

• func getTypedBuiltin() -> Int64

  Returns the built-in type of the typed array as a Variant.GType constant. If the array is not typed, returns ``Variant.GType/`nil```.

• func getTypedClassName() -> StringName

  Returns the native class name of the typed array if the built-in type is object. Otherwise, this method returns an empty string.

• func getTypedScript() -> Variant

  Returns the script associated with the typed array. This method returns a Script instance or null.

• func has(value: Variant) -> Bool

  Returns true if the array contains the given value.

• func hash() -> Int64

  Returns a hashed 32-bit integer value representing the array and its contents.

• func index(after: Int) -> Int
• func index(before: Int) -> Int
• func insert(position: Int64, value: Variant) -> Int64

  Inserts a new element at a given position in the array. The position must be valid, or at the end of the array (pos == size()). Returns ok on success, or one of the other GodotError values if the operation failed.

• func isEmpty() -> Bool

  Returns true if the array is empty.

• func isReadOnly() -> Bool

  Returns true if the array is read-only. See makeReadOnly. Arrays are automatically read-only if declared with const keyword.

• func isSameTyped(array: GArray) -> Bool

  Returns true if the array is typed the same as array.

• func isTyped() -> Bool

  Returns true if the array is typed. Typed arrays can only store elements of their associated type and provide type safety for the [] operator. Methods of typed array still return Variant.

• func makeReadOnly()

  Makes the array read-only, i.e. disabled modifying of the array’s elements. Does not apply to nested content, e.g. content of nested arrays.

• func map(method: Callable) -> GArray

  Calls the provided Callable for each element in the array and returns a new array filled with values returned by the method.

• func max() -> Variant

  Returns the maximum value contained in the array if all elements are of comparable types. If the elements can’t be compared, null is returned.

• func min() -> Variant

  Returns the minimum value contained in the array if all elements are of comparable types. If the elements can’t be compared, null is returned.

• func pickRandom() -> Variant

  Returns a random value from the target array. Prints an error and returns null if the array is empty.

• func popAt(position: Int64) -> Variant

  Removes and returns the element of the array at index position. If negative, position is considered relative to the end of the array. Leaves the array unchanged and returns null if the array is empty or if it’s accessed out of bounds. An error message is printed when the array is accessed out of bounds, but not when the array is empty.

• func popBack() -> Variant

  Removes and returns the last element of the array. Returns null if the array is empty, without printing an error message. See also popFront.

• func popFront() -> Variant

  Removes and returns the first element of the array. Returns null if the array is empty, without printing an error message. See also popBack.

• func pushBack(value: Variant)

  Appends an element at the end of the array. See also pushFront(value:).

• func pushFront(value: Variant)

  Adds an element at the beginning of the array. See also pushBack(value:).

• func reduce(method: Callable, accum: Variant) -> Variant

  Calls the provided Callable for each element in array and accumulates the result in accum.

• func removeAt(position: Int64)

  Removes an element from the array by index. If the index does not exist in the array, nothing happens. To remove an element by searching for its value, use erase(value:) instead.

• func resize(size: Int64) -> Int64

  Resizes the array to contain a different number of elements. If the array size is smaller, elements are cleared, if bigger, new elements are null. Returns ok on success, or one of the other GodotError values if the operation failed.

• func reverse()

  Reverses the order of the elements in the array.

• func rfind(what: Variant, from: Int64) -> Int64

  Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.

• func shuffle()

  Shuffles the array such that the items will have a random order. This method uses the global random number generator common to methods such as @GlobalScope.randi. Call @GlobalScope.randomize to ensure that a new seed will be used each time if you want non-reproducible shuffling.

• func size() -> Int64

  Returns the number of elements in the array.

• func slice(begin: Int64, end: Int64, step: Int64, deep: Bool) -> GArray

  Returns the slice of the GArray, from begin (inclusive) to end (exclusive), as a new GArray.

• func sort()

  Sorts the array.

• func sortCustom(func: Callable)

  Sorts the array using a custom method. The custom method receives two arguments (a pair of elements from the array) and must return either true or false. For two elements a and b, if the given method returns true, element b will be after element a in the array.

Type features

• init?(Variant)
• static func makeOrUnwrap(Variant) -> Self?

  Unwraps an object from a variant.

• static func makeOrUnwrap(Variant) -> Self?

  Unwraps an object from a variant. This is useful when you want one method to call that will return the unwrapped Variant, regardless of whether it is a SwiftGodot.Object or not.

• static func != (lhs: Self, rhs: Self) -> Bool

  Returns a Boolean value indicating whether two values are not equal.

Instance features

• var count: Int

  The number of elements in the collection.

• var first: Self.Element?

  The first element of the collection.

• var isEmpty: Bool

  A Boolean value indicating whether the collection is empty.

• var last: Self.Element?

  The last element of the collection.

• var lazy: LazySequence<Self>

  A sequence containing the same elements as this sequence, but on which some operations, such as map and filter, are implemented lazily.

• var underestimatedCount: Int

  A value less than or equal to the number of elements in the collection.

• func allSatisfy((Self.Element) throws -> Bool) rethrows -> Bool

  Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.

• func compactMap<ElementOfResult>((Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

  Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.

• func compare<Comparator>(Comparator.Compared, Comparator.Compared) -> ComparisonResult

  If lhs is ordered before rhs in the ordering described by the given sequence of SortComparators

• func contains(Self.Element) -> Bool

  Returns a Boolean value indicating whether the sequence contains the given element.

• func contains(where: (Self.Element) throws -> Bool) rethrows -> Bool

  Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.

• func count<E>(where: (Self.Element)throws

  Returns the number of elements in the sequence that satisfy the given predicate.

• func difference<C>(from: C) -> CollectionDifference<Self.Element>

  Returns the difference needed to produce this collection’s ordered elements from the given collection.

• func difference<C>(from: C, by: (C.Element, Self.Element) -> Bool) -> CollectionDifference<Self.Element>

  Returns the difference needed to produce this collection’s ordered elements from the given collection, using the given predicate as an equivalence test.

• func drop(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence

  Returns a subsequence by skipping elements while predicate returns true and returning the remaining elements.

• func dropFirst(Int) -> Self.SubSequence

  Returns a subsequence containing all but the given number of initial elements.

• func dropLast(Int) -> Self.SubSequence

  Returns a subsequence containing all but the specified number of final elements.

• func elementsEqual<OtherSequence>(OtherSequence) -> Bool

  Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.

• func elementsEqual<OtherSequence>(OtherSequence, by: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool

  Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.

• func enumerated() -> EnumeratedSequence<Self>

  Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero and x represents an element of the sequence.

• func filter((Self.Element) throws -> Bool) rethrows -> [Self.Element]

  Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.

• func filter(Predicate<Self.Element>) throws -> [Self.Element]
• func first(where: (Self.Element) throws -> Bool) rethrows -> Self.Element?

  Returns the first element of the sequence that satisfies the given predicate.

• func firstIndex(of: Self.Element) -> Self.Index?

  Returns the first index where the specified value appears in the collection.

• func firstIndex(where: (Self.Element) throws -> Bool) rethrows -> Self.Index?

  Returns the first index in which an element of the collection satisfies the given predicate.

• func firstRange<C>(of: C) -> Range<Self.Index>?

  Finds and returns the range of the first occurrence of a given collection within this collection.

• func flatMap<SegmentOfResult>((Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element]

  Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.

• func forEach((Self.Element) throws -> Void) rethrows

  Calls the given closure on each element in the sequence in the same order as a for-in loop.

• func formIndex(inout Self.Index, offsetBy: Int)

  Offsets the given index by the specified distance.

• func formIndex(inout Self.Index, offsetBy: Int, limitedBy: Self.Index) -> Bool

  Offsets the given index by the specified distance, or so that it equals the given limiting index.

• func formIndex(after: inout Self.Index)

  Replaces the given index with its successor.

• func formIndex(before: inout Self.Index)
• func formatted<S>(S) -> S.FormatOutput
• func index(Self.Index, offsetBy: Int, limitedBy: Self.Index) -> Self.Index?

  Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.

• func indices(of: Self.Element) -> RangeSet<Self.Index>

  Returns the indices of all the elements that are equal to the given element.

• func indices(where: (Self.Element) throws -> Bool) rethrows -> RangeSet<Self.Index>

  Returns the indices of all the elements that match the given predicate.

• func last(where: (Self.Element) throws -> Bool) rethrows -> Self.Element?

  Returns the last element of the sequence that satisfies the given predicate.

• func lastIndex(of: Self.Element) -> Self.Index?

  Returns the last index where the specified value appears in the collection.

• func lastIndex(where: (Self.Element) throws -> Bool) rethrows -> Self.Index?

  Returns the index of the last element in the collection that matches the given predicate.

• func lexicographicallyPrecedes<OtherSequence>(OtherSequence, by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool

  Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.

• func makeIterator() -> IndexingIterator<Self>

  Returns an iterator over the elements of the collection.

• func map<T, E>((Self.Element)throws

  Returns an array containing the results of mapping the given closure over the sequence’s elements.

• func map<T, E>((Self.Element)throws

  Returns an array containing the results of mapping the given closure over the sequence’s elements.

• func max(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element?

  Returns the maximum element in the sequence, using the given predicate as the comparison between elements.

• func min(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element?

  Returns the minimum element in the sequence, using the given predicate as the comparison between elements.

• func prefix(Int) -> Self.SubSequence

  Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.

• func prefix(through: Self.Index) -> Self.SubSequence

  Returns a subsequence from the start of the collection through the specified position.

• func prefix(upTo: Self.Index) -> Self.SubSequence

  Returns a subsequence from the start of the collection up to, but not including, the specified position.

• func prefix(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence

  Returns a subsequence containing the initial elements until predicate returns false and skipping the remaining elements.

• func randomElement() -> Self.Element?

  Returns a random element of the collection.

• func randomElement<T>(using: inout T) -> Self.Element?

  Returns a random element of the collection, using the given generator as a source for randomness.

• func ranges<C>(of: C) -> [Range<Self.Index>]

  Finds and returns the ranges of the all occurrences of a given sequence within the collection.

• func reduce<Result>(Result, (Result, Self.Element) throws -> Result) rethrows -> Result

  Returns the result of combining the elements of the sequence using the given closure.

• func reduce<Result>(into: Result, (inout Result, Self.Element) throws -> ()) rethrows -> Result

  Returns the result of combining the elements of the sequence using the given closure.

• func removingSubranges(RangeSet<Self.Index>) -> DiscontiguousSlice<Self>

  Returns a collection of the elements in this collection that are not represented by the given range set.

• func reversed() -> ReversedCollection<Self>

  Returns a view presenting the elements of the collection in reverse order.

• func shuffled() -> [Self.Element]

  Returns the elements of the sequence, shuffled.

• func shuffled<T>(using: inout T) -> [Self.Element]

  Returns the elements of the sequence, shuffled using the given generator as a source for randomness.

• func sorted(by: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element]

  Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.

• func sorted<Comparator>(using: Comparator) -> [Self.Element]

  Returns the elements of the sequence, sorted using the given comparator to compare elements.

• func sorted<S, Comparator>(using: S) -> [Self.Element]

  Returns the elements of the sequence, sorted using the given array of SortComparators to compare elements.

• func split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence]

  Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.

• func split(separator: Self.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence]

  Returns the longest possible subsequences of the collection, in order, around elements equal to the given element.

• func starts<PossiblePrefix>(with: PossiblePrefix) -> Bool

  Returns a Boolean value indicating whether the initial elements of the sequence are the same as the elements in another sequence.

• func starts<PossiblePrefix>(with: PossiblePrefix, by: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool

  Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.

• func suffix(Int) -> Self.SubSequence

  Returns a subsequence, up to the given maximum length, containing the final elements of the collection.

• func suffix(from: Self.Index) -> Self.SubSequence

  Returns a subsequence from the specified position to the end of the collection.

• func toVariantRepresentable() -> Self
• func trimmingPrefix<Prefix>(Prefix) -> Self.SubSequence

  Returns a new collection of the same type by removing prefix from the start of the collection.

• func trimmingPrefix(while: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence
• func withContiguousStorageIfAvailable<R>((UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R?