Arrays (T[])

Arrays are represented with the most common and efficient native data structures, such as std::vector<T> in C++ or Array<T> in Swift and Kotlin.

TypeScript

import { type HybridObject, Apple } from 'nitro-core'

@Apple(...)
export declare class Contacts extends HybridObject {
  getAllUsers(): User[]
}

Swift

class HybridContacts: HybridContactsSpec {
  func getAllUsers() throws -> [User]
}

Kotlin

class HybridContacts: HybridContactsSpec() {
  override fun getAllUsers(): Array<User>
}

C++

class HybridContacts: public HybridContactsSpec {
  std::vector<User> getAllUsers() override;
};

Kotlin PrimitiveArray

As a performance improvement, the JNI (C++ -> Kotlin interface) provides Primitive Array datatypes which can avoid boxing primitives into Objects, and provides bulk copy methods. This makes all array operations a lot faster, and Nitrogen is smart enough to ✨automagically✨ use Primitive Arrays whenever possible. This will replace the following arrays:

• Array<Double> -> DoubleArray
• Array<Boolean> -> BooleanArray
• Array<Long> -> LongArray
• Array<ULong> -> ULongArray

ULongArray shares its LongArray with JNI, so UInt64[] crosses without copying. Kotlin still marks ULongArray as experimental, and code that uses it gets an opt-in warning. Generated code opts in already. To opt in your own code, add @file:OptIn(ExperimentalUnsignedTypes::class) to the file, or opt in the whole module:

android {
  kotlinOptions {
    freeCompilerArgs += ["-opt-in=kotlin.ExperimentalUnsignedTypes"]
  }
}