Represents a reference to (possibly empty) sequence of C values. It can be either a stable pointer CPointer or a sequence of immutable values CValues.

CVariable

abstract class CVariable(rawPtr: NativePtr) : CPointed

The C data variable located in memory.

DeferScope

open class DeferScope

DoubleVar

typealias DoubleVar = DoubleVarOf<Double>

DoubleVarOf

class DoubleVarOf<T : Double>(rawPtr: NativePtr) : CPrimitiveVar

ExportObjCClass

@Target(allowedTargets = [AnnotationTarget.CLASS])

annotation class ExportObjCClass(name: String)

Makes Kotlin subclass of Objective-C class visible for runtime lookup after Kotlin main function gets invoked.

ExternalObjCClass

@Target(allowedTargets = [AnnotationTarget.CLASS])

annotation class ExternalObjCClass(protocolGetter: String, binaryName: String)

FloatVar

typealias FloatVar = FloatVarOf<Float>

FloatVarOf

class FloatVarOf<T : Float>(rawPtr: NativePtr) : CPrimitiveVar

ForeignException

class ForeignException : Exception

InteropStubs

@Target(allowedTargets = [AnnotationTarget.FILE])

annotation class InteropStubs

IntVar

typealias IntVar = IntVarOf<Int>

IntVarOf

class IntVarOf<T : Int>(rawPtr: NativePtr) : CPrimitiveVar

LongVar

typealias LongVar = LongVarOf<Long>

LongVarOf

class LongVarOf<T : Long>(rawPtr: NativePtr) : CPrimitiveVar

MemScope

class MemScope : ArenaBase

NativeFreeablePlacement

interface NativeFreeablePlacement : NativePlacement

nativeHeap

object nativeHeap : NativeFreeablePlacement

NativePlacement

interface NativePlacement

NativePointed

open class NativePointed

The entity which has an associated native pointer. Subtypes are supposed to represent interpretations of the pointed data or code.

NativePtr

typealias NativePtr = kotlin.native.internal.NativePtr

ObjCAction

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

annotation class ObjCAction

Makes Kotlin method in Objective-C class accessible through Objective-C dispatch to be used as action sent by control in UIKit or AppKit.

ObjCBlockVar

typealias ObjCBlockVar<T> = ObjCNotImplementedVar<T>

ObjCClass

interface ObjCClass : ObjCObject

ObjCClassOf

interface ObjCClassOf<T : ObjCObject> : ObjCClass

ObjCConstructor

@Target(allowedTargets = [AnnotationTarget.CONSTRUCTOR])

annotation class ObjCConstructor(initSelector: String, designated: Boolean)

ObjCFactory

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

annotation class ObjCFactory(selector: String, encoding: String, isStret: Boolean)

ObjCMethod

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER])

annotation class ObjCMethod(selector: String, encoding: String, isStret: Boolean)

ObjCNotImplementedVar

class ObjCNotImplementedVar<T>(rawPtr: NativePtr) : CVariable

ObjCObject

interface ObjCObject

ObjCObjectBase

abstract class ObjCObjectBase : ObjCObject

ObjCObjectBaseMeta

abstract class ObjCObjectBaseMeta : ObjCObjectBase, ObjCClass

ObjCObjectMeta

typealias ObjCObjectMeta = ObjCClass

ObjCObjectVar

class ObjCObjectVar<T>(rawPtr: NativePtr) : CVariable

ObjCOutlet

@Target(allowedTargets = [AnnotationTarget.PROPERTY])

annotation class ObjCOutlet

Makes Kotlin property in Objective-C class settable through Objective-C dispatch to be used as IB outlet.

ObjCProtocol

interface ObjCProtocol : ObjCObject

ObjCStringVarOf

typealias ObjCStringVarOf<T> = ObjCNotImplementedVar<T>

Pinned

data class Pinned<out T : Any>

ShortVar

typealias ShortVar = ShortVarOf<Short>

ShortVarOf

class ShortVarOf<T : Short>(rawPtr: NativePtr) : CPrimitiveVar

StableObjPtr

~~typealias~~ StableObjPtr = StableRef<*>

StableRef

@JvmInline

value class StableRef<out T : Any>

This class provides a way to create a stable handle to any Kotlin object. After converting to CPointer it can be safely passed to native code e.g. to be received in a Kotlin callback.

UByteVar

typealias UByteVar = UByteVarOf<UByte>

UByteVarOf

class UByteVarOf<T : UByte>(rawPtr: NativePtr) : CPrimitiveVar

UIntVar

typealias UIntVar = UIntVarOf<UInt>

UIntVarOf

class UIntVarOf<T : UInt>(rawPtr: NativePtr) : CPrimitiveVar

ULongVar

typealias ULongVar = ULongVarOf<ULong>

ULongVarOf

class ULongVarOf<T : ULong>(rawPtr: NativePtr) : CPrimitiveVar

UShortVar

typealias UShortVar = UShortVarOf<UShort>

UShortVarOf

class UShortVarOf<T : UShort>(rawPtr: NativePtr) : CPrimitiveVar

Vector128Var

typealias Vector128Var = Vector128VarOf<Vector128>

Vector128VarOf

class Vector128VarOf<T : Vector128>(rawPtr: NativePtr) : CVariable

Functions

addressOf

fun Pinned<ByteArray>.addressOf(index: Int): CPointer<ByteVar>

fun Pinned<CharArray>.addressOf(index: Int): CPointer<COpaque>

fun Pinned<DoubleArray>.addressOf(index: Int): CPointer<DoubleVar>

fun Pinned<FloatArray>.addressOf(index: Int): CPointer<FloatVar>

fun Pinned<IntArray>.addressOf(index: Int): CPointer<IntVar>

fun Pinned<LongArray>.addressOf(index: Int): CPointer<LongVar>

fun Pinned<ShortArray>.addressOf(index: Int): CPointer<ShortVar>

fun Pinned<String>.addressOf(index: Int): CPointer<COpaque>

fun Pinned<UByteArray>.addressOf(index: Int): CPointer<UByteVar>

fun Pinned<UIntArray>.addressOf(index: Int): CPointer<UIntVar>

fun Pinned<ULongArray>.addressOf(index: Int): CPointer<ULongVar>

fun Pinned<UShortArray>.addressOf(index: Int): CPointer<UShortVar>

alignOf

inline fun <T : CVariable> alignOf(): Int

alloc

inline fun <T : CVariable> NativePlacement.alloc(): T

Allocates variable of given type.

inline fun <T : CVariable> NativePlacement.alloc(initialize: T.() -> Unit): T

Allocates variable of given type and initializes it applying given block.

allocArray

inline fun <T : CVariable> NativePlacement.allocArray(length: Int): CArrayPointer<T>

inline fun <T : CVariable> NativePlacement.allocArray(length: Long): CArrayPointer<T>

Allocates C array of given elements type and length.

inline fun <T : CVariable> NativePlacement.allocArray(length: Int, initializer: T.(index: Int) -> Unit): CArrayPointer<T>

inline fun <T : CVariable> NativePlacement.allocArray(length: Long, initializer: T.(index: Long) -> Unit): CArrayPointer<T>

Allocates C array of given elements type and length, and initializes its elements applying given block.

allocArrayOf

inline fun <T : CPointer<*>> NativePlacement.allocArrayOf(vararg elements: T?): CArrayPointer<CPointerVarOf<T>>

inline fun <T : CPointer<*>> NativePlacement.allocArrayOf(elements: List<T?>): CArrayPointer<CPointerVarOf<T>>

Allocates C array of given values.

fun NativePlacement.allocArrayOf(elements: ByteArray): CArrayPointer<ByteVar>

fun NativePlacement.allocArrayOf(vararg elements: Float): CArrayPointer<FloatVar>

allocArrayOfPointersTo

fun <T : CPointed> NativePlacement.allocArrayOfPointersTo(vararg elements: T?): CPointer<CPointerVarOf<CPointer<T>>>

fun <T : CPointed> NativePlacement.allocArrayOfPointersTo(elements: List<T?>): CArrayPointer<CPointerVar<T>>

Allocates C array of pointers to given elements.

allocPointerTo

fun <T : CPointed> NativePlacement.allocPointerTo(): CPointerVarOf<CPointer<T>>

arrayMemberAt

inline fun <T : CVariable> CStructVar.arrayMemberAt(offset: Long): CArrayPointer<T>

asStableRef

inline fun <T : Any> CPointer<*>.asStableRef(): StableRef<T>

Converts to StableRef this opaque pointer produced by StableRef.asCPointer.

autoreleasepool

inline fun <R> autoreleasepool(block: () -> R): R

bitsToDouble

external fun bitsToDouble(bits: Long): Double

bitsToFloat

external fun bitsToFloat(bits: Int): Float

convert

inline external fun <R : Any> Byte.convert(): R

inline external fun <R : Any> Int.convert(): R

inline external fun <R : Any> Long.convert(): R

inline external fun <R : Any> Short.convert(): R

inline external fun <R : Any> UByte.convert(): R

inline external fun <R : Any> UInt.convert(): R

inline external fun <R : Any> ULong.convert(): R

inline external fun <R : Any> UShort.convert(): R

copy

inline fun <T : CStructVar> CValue<T>.copy(modify: T.() -> Unit): CValue<T>

createKotlinObjectHolder

external fun createKotlinObjectHolder(any: Any?): NativePtr

CreateKStringFromNSString

~~external~~ ~~fun~~ ~~CreateKStringFromNSString~~(~~ptr~~: NativePtr): String?

CreateNSStringFromKString

~~external~~ ~~fun~~ ~~CreateNSStringFromKString~~(~~str~~: String?): NativePtr

createValues

inline fun <T : CVariable> createValues(count: Int, initializer: T.(index: Int) -> Unit): CValues<T>

cValue

inline fun <T : CVariable> cValue(): CValue<T>

inline fun <T : CStructVar> cValue(initialize: T.() -> Unit): CValue<T>

cValuesOf

fun <T : CPointed> cValuesOf(vararg elements: CPointer<T>?): CValues<CPointerVar<T>>

fun cValuesOf(vararg elements: Double): CValues<DoubleVar>

fun cValuesOf(vararg elements: Float): CValues<FloatVar>

fun cValuesOf(vararg elements: Int): CValues<IntVar>

fun cValuesOf(vararg elements: Long): CValues<LongVar>

fun cValuesOf(vararg elements: Short): CValues<ShortVar>

fun cValuesOf(vararg elements: UByte): CValues<UByteVar>

fun cValuesOf(vararg elements: UInt): CValues<UIntVar>

fun cValuesOf(vararg elements: ULong): CValues<ULongVar>

fun cValuesOf(vararg elements: UShort): CValues<UShortVar>

fun cValuesOf(vararg elements: Byte): CValues<ByteVar>

Returns sequence of immutable values CValues to pass them to C code.

free

fun NativeFreeablePlacement.free(pointer: CPointer<*>)

fun NativeFreeablePlacement.free(pointed: NativePointed)

get

inline operator fun <T : CVariable> CPointer<T>.get(index: Int): T

inline operator fun <T : CVariable> CPointer<T>.get(index: Long): T

inline operator fun <T : Byte> CPointer<ByteVarOf<T>>.get(index: Int): T

inline operator fun <T : Byte> CPointer<ByteVarOf<T>>.get(index: Long): T

inline operator fun <T : CPointer<*>> CPointer<CPointerVarOf<T>>.get(index: Int): T?

inline operator fun <T : CPointer<*>> CPointer<CPointerVarOf<T>>.get(index: Long): T?

inline operator fun <T : Double> CPointer<DoubleVarOf<T>>.get(index: Int): T

inline operator fun <T : Double> CPointer<DoubleVarOf<T>>.get(index: Long): T

inline operator fun <T : Float> CPointer<FloatVarOf<T>>.get(index: Int): T

inline operator fun <T : Float> CPointer<FloatVarOf<T>>.get(index: Long): T

inline operator fun <T : Int> CPointer<IntVarOf<T>>.get(index: Int): T

inline operator fun <T : Int> CPointer<IntVarOf<T>>.get(index: Long): T

inline operator fun <T : Long> CPointer<LongVarOf<T>>.get(index: Int): T

inline operator fun <T : Long> CPointer<LongVarOf<T>>.get(index: Long): T

inline operator fun <T : Short> CPointer<ShortVarOf<T>>.get(index: Int): T

inline operator fun <T : Short> CPointer<ShortVarOf<T>>.get(index: Long): T

inline operator fun <T : UByte> CPointer<UByteVarOf<T>>.get(index: Int): T

inline operator fun <T : UByte> CPointer<UByteVarOf<T>>.get(index: Long): T

inline operator fun <T : UInt> CPointer<UIntVarOf<T>>.get(index: Int): T

inline operator fun <T : UInt> CPointer<UIntVarOf<T>>.get(index: Long): T

inline operator fun <T : ULong> CPointer<ULongVarOf<T>>.get(index: Int): T

inline operator fun <T : ULong> CPointer<ULongVarOf<T>>.get(index: Long): T

inline operator fun <T : UShort> CPointer<UShortVarOf<T>>.get(index: Int): T

inline operator fun <T : UShort> CPointer<UShortVarOf<T>>.get(index: Long): T

getBytes

fun <T : CVariable> CValues<T>.getBytes(): ByteArray

getOriginalKotlinClass

fun getOriginalKotlinClass(objCClass: ObjCClass): KClass<*>?

If objCClass is a class generated to Objective-C header for Kotlin class, returns KClass for that original Kotlin class.

fun getOriginalKotlinClass(objCProtocol: ObjCProtocol): KClass<*>?

If objCProtocol is a protocol generated to Objective-C header for Kotlin class, returns KClass for that original Kotlin class.

getRawPointer

external fun NativePointed.getRawPointer(): NativePtr

getRawValue

external fun CPointer<*>.getRawValue(): NativePtr

initBy

~~external~~ ~~fun~~ <T : ObjCObjectBase> T.~~initBy~~(~~constructorCall~~: T): T

interpretCPointer

external fun <T : CPointed> interpretCPointer(rawValue: NativePtr): CPointer<T>?

Performs type cast of the CPointer from the given raw pointer.

interpretNullableOpaquePointed

fun interpretNullableOpaquePointed(ptr: NativePtr): NativePointed?

interpretNullablePointed

external fun <T : NativePointed> interpretNullablePointed(ptr: NativePtr): T?

Performs type cast of the native pointer to given interop type, including null values.

interpretObjCPointer

inline fun <T : Any> interpretObjCPointer(objcPtr: NativePtr): T

interpretObjCPointerOrNull

external fun <T> interpretObjCPointerOrNull(objcPtr: NativePtr): T?

interpretOpaquePointed

fun interpretOpaquePointed(ptr: NativePtr): NativePointed

interpretPointed

inline fun <T : NativePointed> interpretPointed(ptr: NativePtr): T

Returns interpretation of entity with given pointer.

invoke

operator external fun <R> CPointer<CFunction<() -> R>>.invoke(): R

operator external fun <P1, R> CPointer<CFunction<(P1) -> R>>.invoke(p1: P1): R

operator external fun <P1, P2, R> CPointer<CFunction<(P1, P2) -> R>>.invoke(p1: P1, p2: P2): R

operator external fun <P1, P2, P3, R> CPointer<CFunction<(P1, P2, P3) -> R>>.invoke(p1: P1, p2: P2, p3: P3): R

operator external fun <P1, P2, P3, P4, R> CPointer<CFunction<(P1, P2, P3, P4) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4): R

operator external fun <P1, P2, P3, P4, P5, R> CPointer<CFunction<(P1, P2, P3, P4, P5) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5): R

operator external fun <P1, P2, P3, P4, P5, P6, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21): R

operator external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R> CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22) -> R>>.invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21, p22: P22): R

memberAt

inline fun <T : CPointed> CStructVar.memberAt(offset: Long): T

Returns the member of this CStructVar which is located by given offset in bytes.

memScoped

inline fun <R> memScoped(block: MemScope.() -> R): R

Runs given block providing allocation of memory which will be automatically disposed at the end of this scope.

narrow

inline external fun <R : Number> Number.narrow(): R

objc_autoreleasePoolPop

external fun objc_autoreleasePoolPop(ptr: NativePtr)

objc_autoreleasePoolPush

external fun objc_autoreleasePoolPush(): NativePtr

objc_lookUpClass

external fun objc_lookUpClass(name: NativePtr): NativePtr

objc_release

external fun objc_release(ptr: NativePtr)

objc_retain

external fun objc_retain(ptr: NativePtr): NativePtr

objc_retainAutoreleaseReturnValue

external fun objc_retainAutoreleaseReturnValue(ptr: NativePtr): NativePtr

objcPtr

external fun Any?.objcPtr(): NativePtr

optional

fun optional(): Nothing

fun <T : Any> T.pin(): Pinned<T>

placeTo

fun <T : CVariable> CValues<T>.placeTo(scope: AutofreeScope): CPointer<T>

plus

inline operator fun <T : ByteVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : ByteVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : CPointerVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : CPointerVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : DoubleVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : DoubleVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : FloatVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : FloatVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : IntVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : IntVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : LongVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : LongVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : ShortVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : ShortVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : UByteVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : UByteVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : UIntVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : UIntVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : ULongVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : ULongVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

inline operator fun <T : UShortVarOf<*>> CPointer<T>?.plus(index: Int): CPointer<T>?

inline operator fun <T : UShortVarOf<*>> CPointer<T>?.plus(index: Long): CPointer<T>?

readBits

external fun readBits(ptr: NativePtr, offset: Long, size: Int, signed: Boolean): Long

readBytes

fun COpaquePointer.readBytes(count: Int): ByteArray

readValue

inline fun <T : CStructVar> T.readValue(): CValue<T>

fun <T : CVariable> CPointed.readValue(size: Long, align: Int): CValue<T>

readValues

inline fun <T : CVariable> T.readValues(count: Int): CValues<T>

fun <T : CVariable> CPointed.readValues(size: Int, align: Int): CValues<T>

refTo

fun ByteArray.refTo(index: Int): CValuesRef<ByteVar>

fun CharArray.refTo(index: Int): CValuesRef<COpaque>

fun DoubleArray.refTo(index: Int): CValuesRef<DoubleVar>

fun FloatArray.refTo(index: Int): CValuesRef<FloatVar>

fun IntArray.refTo(index: Int): CValuesRef<IntVar>

fun LongArray.refTo(index: Int): CValuesRef<LongVar>

fun ShortArray.refTo(index: Int): CValuesRef<ShortVar>

fun String.refTo(index: Int): CValuesRef<COpaque>

fun UByteArray.refTo(index: Int): CValuesRef<UByteVar>

fun UIntArray.refTo(index: Int): CValuesRef<UIntVar>

fun ULongArray.refTo(index: Int): CValuesRef<ULongVar>

fun UShortArray.refTo(index: Int): CValuesRef<UShortVar>

reinterpret

fun <T : CPointed> CPointer<*>.reinterpret(): CPointer<T>

~~fun~~ <T : ObjCObject> ObjCObject.~~reinterpret~~(): T

inline fun <T : NativePointed> NativePointed.reinterpret(): T

Changes the interpretation of the pointed data or code.

set

inline operator fun <T : Byte> CPointer<ByteVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : Byte> CPointer<ByteVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : CPointer<*>> CPointer<CPointerVarOf<T>>.set(index: Int, value: T?)

inline operator fun <T : CPointer<*>> CPointer<CPointerVarOf<T>>.set(index: Long, value: T?)

inline operator fun <T : Double> CPointer<DoubleVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : Double> CPointer<DoubleVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : Float> CPointer<FloatVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : Float> CPointer<FloatVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : Int> CPointer<IntVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : Int> CPointer<IntVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : Long> CPointer<LongVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : Long> CPointer<LongVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : Short> CPointer<ShortVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : Short> CPointer<ShortVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : UByte> CPointer<UByteVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : UByte> CPointer<UByteVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : UInt> CPointer<UIntVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : UInt> CPointer<UIntVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : ULong> CPointer<ULongVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : ULong> CPointer<ULongVarOf<T>>.set(index: Long, value: T)

inline operator fun <T : UShort> CPointer<UShortVarOf<T>>.set(index: Int, value: T)

inline operator fun <T : UShort> CPointer<UShortVarOf<T>>.set(index: Long, value: T)

signExtend

inline external fun <R : Number> Number.signExtend(): R

sizeOf

inline fun <T : CVariable> sizeOf(): Long

staticCFunction

external fun <R> staticCFunction(function: () -> R): CPointer<CFunction<() -> R>>

Returns a pointer to C function which calls given Kotlin static function.

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R>>

external fun <P1, R> staticCFunction(function: (P1) -> R): CPointer<CFunction<(P1) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22) -> R>>

external fun <P1, P2, R> staticCFunction(function: (P1, P2) -> R): CPointer<CFunction<(P1, P2) -> R>>

external fun <P1, P2, P3, R> staticCFunction(function: (P1, P2, P3) -> R): CPointer<CFunction<(P1, P2, P3) -> R>>

external fun <P1, P2, P3, P4, R> staticCFunction(function: (P1, P2, P3, P4) -> R): CPointer<CFunction<(P1, P2, P3, P4) -> R>>

external fun <P1, P2, P3, P4, P5, R> staticCFunction(function: (P1, P2, P3, P4, P5) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5) -> R>>

external fun <P1, P2, P3, P4, P5, P6, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8) -> R>>

external fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, R> staticCFunction(function: (P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R): CPointer<CFunction<(P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R>>

toBoolean

inline fun Byte.toBoolean(): Boolean

toByte

inline fun Boolean.toByte(): Byte

toCPointer

fun <T : CPointed> Long.toCPointer(): CPointer<T>?

toCStringArray

fun Array<String>.toCStringArray(autofreeScope: AutofreeScope): CPointer<CPointerVar<ByteVar>>

Convert this array of Kotlin strings to C array of C strings, allocating memory for the array and C strings with given AutofreeScope.

fun List<String>.toCStringArray(autofreeScope: AutofreeScope): CPointer<CPointerVar<ByteVar>>

Convert this list of Kotlin strings to C array of C strings, allocating memory for the array and C strings with given AutofreeScope.

toCValues

fun <T : CPointed> Array<CPointer<T>?>.toCValues(): CValues<CPointerVar<T>>

fun ByteArray.toCValues(): CValues<ByteVar>

fun DoubleArray.toCValues(): CValues<DoubleVar>

fun FloatArray.toCValues(): CValues<FloatVar>

fun IntArray.toCValues(): CValues<IntVar>

fun LongArray.toCValues(): CValues<LongVar>

fun ShortArray.toCValues(): CValues<ShortVar>

fun UByteArray.toCValues(): CValues<UByteVar>

fun UIntArray.toCValues(): CValues<UIntVar>

fun ULongArray.toCValues(): CValues<ULongVar>

fun UShortArray.toCValues(): CValues<UShortVar>

fun <T : CPointed> List<CPointer<T>?>.toCValues(): CValues<CPointerVar<T>>

toKString

fun ByteArray.toKString(): String

Decodes a string from the bytes in UTF-8 encoding in this array. Bytes following the first occurrence of 0 byte, if it occurs, are not decoded.

Since Kotlin

1.3

fun CPointer<ByteVar>.toKString(): String

fun CPointer<ShortVar>.toKString(): String

fun CPointer<UShortVar>.toKString(): String

fun ByteArray.toKString(startIndex: Int = 0, endIndex: Int = this.size, throwOnInvalidSequence: Boolean = false): String

Decodes a string from the bytes in UTF-8 encoding in this array or its subrange. Bytes following the first occurrence of 0 byte, if it occurs, are not decoded.