PhysicsJoints

startIndex

get startIndex(): number

let startIndex: Int

The position of the first element in a nonempty collection. If the collection is empty, `startIndex` is equal to `endIndex`.

replaceSubrange

replaceSubrange(subrange: SDKHandle, newElements: Array<SDKHandle>): void

mutating func replaceSubrange<C>(_ subrange: Range<Int>, with newElements: C) where C : Collection, C.Element == any PhysicsJoint

Replaces the specified subrange of elements with the given collection. This method has the effect of removing the specified range of elements from the collection and inserting the new elements at the same location. The number of new elements need not match the number of elements being removed. In this example, three elements in the middle of an array of integers are replaced by the five elements of a `Repeated<Int>` instance. var nums = [10, 20, 30, 40, 50] nums.replaceSubrange(1...3, with: repeatElement(1, count: 5)) print(nums) // Prints "[10, 1, 1, 1, 1, 1, 50]" If you pass a zero-length range as the `subrange` parameter, this method inserts the elements of `newElements` at `subrange.startIndex`. Calling the `insert(contentsOf:at:)` method instead is preferred. Likewise, if you pass a zero-length collection as the `newElements` parameter, this method removes the elements in the given subrange without replacement. Calling the `removeSubrange(_:)` method instead is preferred. Calling this method may invalidate any existing indices for use with this collection. - Parameters: - subrange: The subrange of the collection to replace. The bounds of the range must be valid indices of the collection. - newElements: The new elements to add to the collection. - Complexity: O(*n* + *m*), where *n* is length of this collection and *m* is the length of `newElements`. If the call to this method simply appends the contents of `newElements` to the collection, this method is equivalent to `append(contentsOf:)`.

count

get count(): number

var count: Int { get }

The number of elements in the collection. To check whether a collection is empty, use its `isEmpty` property instead of comparing `count` to zero. Unless the collection guarantees random-access performance, calculating `count` can be an O(*n*) operation. - Complexity: O(1) if the collection conforms to `RandomAccessCollection`; otherwise, O(*n*), where *n* is the length of the collection.

index

indexAfter(i: number): number

func index(after i: Int) -> Int

Returns the position immediately after the given index. The successor of an index must be well defined. For an index `i` into a collection `c`, calling `c.index(after: i)` returns the same index every time. - Parameter i: A valid index of the collection. `i` must be less than `endIndex`. - Returns: The index value immediately after `i`.

index

indexBefore(i: number): number

func index(before i: Int) -> Int

Returns the position immediately before the given index. - Parameter i: A valid index of the collection. `i` must be greater than `startIndex`. - Returns: The index value immediately before `i`.

endIndex

get endIndex(): number

var endIndex: Int { get }

The collection's "past the end" position---that is, the position one greater than the last valid subscript argument. When you need a range that includes the last element of a collection, use the half-open range operator (`..<`) with `endIndex`. The `..<` operator creates a range that doesn't include the upper bound, so it's always safe to use with `endIndex`. For example: let numbers = [10, 20, 30, 40, 50] if let index = numbers.firstIndex(of: 30) { print(numbers[index ..< numbers.endIndex]) } // Prints "[30, 40, 50]" If the collection is empty, `endIndex` is equal to `startIndex`.

init

static init(): PhysicsJoints

init()

Creates a new, empty collection.

subscript

subscript(index: number): SDKHandle

subscript(index: Int) -> any PhysicsJoint { get set }

Accesses the element at the specified position. For example, you can replace an element of an array by using its subscript. var streets = ["Adams", "Bryant", "Channing", "Douglas", "Evarts"] streets[1] = "Butler" print(streets[1]) // Prints "Butler" You can subscript a collection with any valid index other than the collection's end index. The end index refers to the position one past the last element of a collection, so it doesn't correspond with an element. - Parameter position: The position of the element to access. `position` must be a valid index of the collection that is not equal to the `endIndex` property. - Complexity: O(1)

init

static init93291(sequence: SDKHandle): PhysicsJoints

init(_ sequence: any Sequence<any PhysicsJoint>)