from __future__ import annotations import ctypes import typing T = typing.TypeVar("T") c_lib = None def init_lib(path): """Initializes the native library. Must be called at least once before anything else.""" global c_lib c_lib = ctypes.cdll.LoadLibrary(path) c_lib.primitive_void.argtypes = [] c_lib.primitive_void2.argtypes = [] c_lib.primitive_bool.argtypes = [ctypes.c_bool] c_lib.primitive_u8.argtypes = [ctypes.c_uint8] c_lib.primitive_u16.argtypes = [ctypes.c_uint16] c_lib.primitive_u32.argtypes = [ctypes.c_uint32] c_lib.primitive_u64.argtypes = [ctypes.c_uint64] c_lib.primitive_i8.argtypes = [ctypes.c_int8] c_lib.primitive_i16.argtypes = [ctypes.c_int16] c_lib.primitive_i32.argtypes = [ctypes.c_int32] c_lib.primitive_i64.argtypes = [ctypes.c_int64] c_lib.boolean_alignment.argtypes = [BooleanAlignment] c_lib.boolean_alignment2.argtypes = [ctypes.c_bool] c_lib.aligned_to_packed1.argtypes = [Aligned1] c_lib.aligned_to_packed2.argtypes = [Aligned2] c_lib.many_args_5.argtypes = [ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64] c_lib.many_args_10.argtypes = [ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64] c_lib.ptr.argtypes = [ctypes.POINTER(ctypes.c_int64)] c_lib.ptr_mut.argtypes = [ctypes.POINTER(ctypes.c_int64)] c_lib.ptr_ptr.argtypes = [ctypes.POINTER(ctypes.POINTER(ctypes.c_int64))] c_lib.ref_simple.argtypes = [ctypes.POINTER(ctypes.c_int64)] c_lib.ref_mut_simple.argtypes = [ctypes.POINTER(ctypes.c_int64)] c_lib.ref_option.argtypes = [ctypes.POINTER(ctypes.c_int64)] c_lib.ref_mut_option.argtypes = [ctypes.POINTER(ctypes.c_int64)] c_lib.tupled.argtypes = [Tupled] c_lib.complex_args_1.argtypes = [Vec3f32, ctypes.POINTER(Tupled)] c_lib.complex_args_2.argtypes = [SomeForeignType] c_lib.callback.argtypes = [ctypes.CFUNCTYPE(ctypes.c_uint8, ctypes.c_uint8), ctypes.c_uint8] c_lib.generic_1a.argtypes = [Genericu32, Phantomu8] c_lib.generic_1b.argtypes = [Genericu8, Phantomu8] c_lib.generic_1c.argtypes = [ctypes.POINTER(Genericu8), ctypes.POINTER(Genericu8)] c_lib.generic_2.argtypes = [ctypes.c_void_p] c_lib.generic_3.argtypes = [ctypes.c_void_p] c_lib.generic_4.argtypes = [ctypes.c_void_p] c_lib.array_1.argtypes = [Array] c_lib.documented.argtypes = [StructDocumented] c_lib.ambiguous_1.argtypes = [Vec1] c_lib.ambiguous_2.argtypes = [Vec2] c_lib.ambiguous_3.argtypes = [Vec1, Vec2] c_lib.namespaced_type.argtypes = [Vec] c_lib.namespaced_inner_option.argtypes = [OptionVec] c_lib.namespaced_inner_slice.argtypes = [SliceVec] c_lib.namespaced_inner_slice_mut.argtypes = [SliceMutVec] c_lib.panics.argtypes = [] c_lib.renamed.argtypes = [StructRenamed] c_lib.sleep.argtypes = [ctypes.c_uint64] c_lib.weird_1.argtypes = [Weird1u32, Weird2u8] c_lib.visibility.argtypes = [Visibility1, Visibility2] c_lib.repr_transparent.argtypes = [Tupled, ctypes.POINTER(Tupled)] c_lib.pattern_ascii_pointer_1.argtypes = [ctypes.POINTER(ctypes.c_char)] c_lib.pattern_ascii_pointer_2.argtypes = [] c_lib.pattern_ascii_pointer_len.argtypes = [ctypes.POINTER(ctypes.c_char), UseAsciiStringPattern] c_lib.pattern_ascii_pointer_return_slice.argtypes = [] c_lib.pattern_ffi_slice_1.argtypes = [Sliceu32] c_lib.pattern_ffi_slice_1b.argtypes = [SliceMutu32] c_lib.pattern_ffi_slice_2.argtypes = [SliceVec3f32, ctypes.c_int32] c_lib.pattern_ffi_slice_3.argtypes = [SliceMutu8, ctypes.CFUNCTYPE(None, SliceMutu8)] c_lib.pattern_ffi_slice_4.argtypes = [Sliceu8, SliceMutu8] c_lib.pattern_ffi_slice_5.argtypes = [ctypes.POINTER(Sliceu8), ctypes.POINTER(SliceMutu8)] c_lib.pattern_ffi_slice_6.argtypes = [ctypes.POINTER(SliceMutu8), ctypes.CFUNCTYPE(ctypes.c_uint8, ctypes.c_uint8)] c_lib.pattern_ffi_slice_delegate.argtypes = [ctypes.CFUNCTYPE(ctypes.c_uint8, Sliceu8)] c_lib.pattern_ffi_slice_delegate_huge.argtypes = [ctypes.CFUNCTYPE(Vec3f32, SliceVec3f32)] c_lib.pattern_ffi_option_1.argtypes = [OptionInner] c_lib.pattern_ffi_option_2.argtypes = [OptionInner] c_lib.pattern_ffi_bool.argtypes = [ctypes.c_uint8] c_lib.pattern_ffi_cchar.argtypes = [ctypes.c_char] c_lib.pattern_ffi_cchar_const_pointer.argtypes = [ctypes.POINTER(ctypes.c_char)] c_lib.pattern_ffi_cchar_mut_pointer.argtypes = [ctypes.POINTER(ctypes.c_char)] c_lib.pattern_api_guard.argtypes = [] c_lib.pattern_callback_1.argtypes = [ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint32), ctypes.c_uint32] c_lib.pattern_callback_2.argtypes = [ctypes.CFUNCTYPE(None, ctypes.c_void_p)] c_lib.pattern_callback_3.argtypes = [DelegateCallbackMyCallbackContextual, ctypes.c_uint32] c_lib.pattern_callback_4.argtypes = [ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint32), ctypes.c_uint32] c_lib.simple_service_destroy.argtypes = [ctypes.POINTER(ctypes.c_void_p)] c_lib.simple_service_new_with.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.c_uint32] c_lib.simple_service_new_without.argtypes = [ctypes.POINTER(ctypes.c_void_p)] c_lib.simple_service_new_with_string.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_char)] c_lib.simple_service_new_failing.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.c_uint8] c_lib.simple_service_method_result.argtypes = [ctypes.c_void_p, ctypes.c_uint32] c_lib.simple_service_method_value.argtypes = [ctypes.c_void_p, ctypes.c_uint32] c_lib.simple_service_method_void.argtypes = [ctypes.c_void_p] c_lib.simple_service_method_mut_self.argtypes = [ctypes.c_void_p, Sliceu8] c_lib.simple_service_method_mut_self_void.argtypes = [ctypes.c_void_p, SliceBool] c_lib.simple_service_method_mut_self_ref.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint8), ctypes.POINTER(ctypes.c_uint8)] c_lib.simple_service_method_mut_self_ref_slice.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint8), ctypes.POINTER(ctypes.c_uint8), Sliceu8] c_lib.simple_service_method_mut_self_ref_slice_limited.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint8), ctypes.POINTER(ctypes.c_uint8), Sliceu8, Sliceu8] c_lib.simple_service_method_mut_self_ffi_error.argtypes = [ctypes.c_void_p, SliceMutu8] c_lib.simple_service_method_mut_self_no_error.argtypes = [ctypes.c_void_p, SliceMutu8] c_lib.simple_service_return_slice.argtypes = [ctypes.c_void_p] c_lib.simple_service_return_slice_mut.argtypes = [ctypes.c_void_p] c_lib.simple_service_return_string.argtypes = [ctypes.c_void_p] c_lib.simple_service_method_void_ffi_error.argtypes = [ctypes.c_void_p] c_lib.simple_service_method_callback.argtypes = [ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint32)] c_lib.simple_service_lt_destroy.argtypes = [ctypes.POINTER(ctypes.c_void_p)] c_lib.simple_service_lt_new_with.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_uint32)] c_lib.simple_service_lt_method_lt.argtypes = [ctypes.c_void_p, SliceBool] c_lib.simple_service_lt_method_lt2.argtypes = [ctypes.c_void_p, SliceBool] c_lib.simple_service_lt_return_string_accept_slice.argtypes = [ctypes.c_void_p, Sliceu8] c_lib.simple_service_lt_method_void_ffi_error.argtypes = [ctypes.c_void_p] c_lib.primitive_bool.restype = ctypes.c_bool c_lib.primitive_u8.restype = ctypes.c_uint8 c_lib.primitive_u16.restype = ctypes.c_uint16 c_lib.primitive_u32.restype = ctypes.c_uint32 c_lib.primitive_u64.restype = ctypes.c_uint64 c_lib.primitive_i8.restype = ctypes.c_int8 c_lib.primitive_i16.restype = ctypes.c_int16 c_lib.primitive_i32.restype = ctypes.c_int32 c_lib.primitive_i64.restype = ctypes.c_int64 c_lib.boolean_alignment.restype = BooleanAlignment c_lib.boolean_alignment2.restype = BooleanAlignment c_lib.aligned_to_packed1.restype = Packed1 c_lib.aligned_to_packed2.restype = Packed2 c_lib.many_args_5.restype = ctypes.c_int64 c_lib.many_args_10.restype = ctypes.c_int64 c_lib.ptr.restype = ctypes.POINTER(ctypes.c_int64) c_lib.ptr_mut.restype = ctypes.POINTER(ctypes.c_int64) c_lib.ptr_ptr.restype = ctypes.POINTER(ctypes.POINTER(ctypes.c_int64)) c_lib.ref_simple.restype = ctypes.POINTER(ctypes.c_int64) c_lib.ref_mut_simple.restype = ctypes.POINTER(ctypes.c_int64) c_lib.ref_option.restype = ctypes.c_bool c_lib.ref_mut_option.restype = ctypes.c_bool c_lib.tupled.restype = Tupled c_lib.complex_args_1.restype = ctypes.c_int c_lib.complex_args_2.restype = ctypes.c_void_p c_lib.callback.restype = ctypes.c_uint8 c_lib.generic_1a.restype = ctypes.c_uint32 c_lib.generic_1b.restype = ctypes.c_uint8 c_lib.generic_1c.restype = ctypes.c_uint8 c_lib.generic_2.restype = ctypes.c_uint8 c_lib.generic_3.restype = ctypes.c_uint8 c_lib.generic_4.restype = ctypes.c_uint8 c_lib.array_1.restype = ctypes.c_uint8 c_lib.documented.restype = ctypes.c_int c_lib.ambiguous_1.restype = Vec1 c_lib.ambiguous_2.restype = Vec2 c_lib.ambiguous_3.restype = ctypes.c_bool c_lib.namespaced_type.restype = Vec c_lib.namespaced_inner_option.restype = OptionVec c_lib.namespaced_inner_slice.restype = SliceVec c_lib.namespaced_inner_slice_mut.restype = SliceMutVec c_lib.panics.restype = ctypes.c_int c_lib.renamed.restype = ctypes.c_int c_lib.weird_1.restype = ctypes.c_bool c_lib.repr_transparent.restype = Tupled c_lib.pattern_ascii_pointer_1.restype = ctypes.c_uint32 c_lib.pattern_ascii_pointer_2.restype = ctypes.POINTER(ctypes.c_char) c_lib.pattern_ascii_pointer_len.restype = ctypes.c_uint32 c_lib.pattern_ascii_pointer_return_slice.restype = SliceUseAsciiStringPattern c_lib.pattern_ffi_slice_1.restype = ctypes.c_uint32 c_lib.pattern_ffi_slice_1b.restype = ctypes.c_uint32 c_lib.pattern_ffi_slice_2.restype = Vec3f32 c_lib.pattern_ffi_slice_delegate.restype = ctypes.c_uint8 c_lib.pattern_ffi_slice_delegate_huge.restype = Vec3f32 c_lib.pattern_ffi_option_1.restype = OptionInner c_lib.pattern_ffi_option_2.restype = Inner c_lib.pattern_ffi_bool.restype = ctypes.c_uint8 c_lib.pattern_ffi_cchar.restype = ctypes.c_char c_lib.pattern_ffi_cchar_const_pointer.restype = ctypes.POINTER(ctypes.c_char) c_lib.pattern_ffi_cchar_mut_pointer.restype = ctypes.POINTER(ctypes.c_char) c_lib.pattern_api_guard.restype = ctypes.c_uint64 c_lib.pattern_callback_1.restype = ctypes.c_uint32 c_lib.pattern_callback_2.restype = ctypes.CFUNCTYPE(None, ctypes.c_void_p) c_lib.pattern_callback_4.restype = ctypes.c_uint32 c_lib.simple_service_destroy.restype = ctypes.c_int c_lib.simple_service_new_with.restype = ctypes.c_int c_lib.simple_service_new_without.restype = ctypes.c_int c_lib.simple_service_new_with_string.restype = ctypes.c_int c_lib.simple_service_new_failing.restype = ctypes.c_int c_lib.simple_service_method_result.restype = ctypes.c_int c_lib.simple_service_method_value.restype = ctypes.c_uint32 c_lib.simple_service_method_mut_self.restype = ctypes.c_uint8 c_lib.simple_service_method_mut_self_ref.restype = ctypes.c_uint8 c_lib.simple_service_method_mut_self_ref_slice.restype = ctypes.c_uint8 c_lib.simple_service_method_mut_self_ref_slice_limited.restype = ctypes.c_uint8 c_lib.simple_service_method_mut_self_ffi_error.restype = ctypes.c_int c_lib.simple_service_method_mut_self_no_error.restype = ctypes.c_int c_lib.simple_service_return_slice.restype = Sliceu32 c_lib.simple_service_return_slice_mut.restype = SliceMutu32 c_lib.simple_service_return_string.restype = ctypes.POINTER(ctypes.c_char) c_lib.simple_service_method_void_ffi_error.restype = ctypes.c_int c_lib.simple_service_method_callback.restype = ctypes.c_int c_lib.simple_service_lt_destroy.restype = ctypes.c_int c_lib.simple_service_lt_new_with.restype = ctypes.c_int c_lib.simple_service_lt_return_string_accept_slice.restype = ctypes.POINTER(ctypes.c_char) c_lib.simple_service_lt_method_void_ffi_error.restype = ctypes.c_int c_lib.complex_args_1.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.panics.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_destroy.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_new_with.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_new_without.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_new_with_string.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_new_failing.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_method_result.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_method_mut_self_ffi_error.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_method_mut_self_no_error.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_method_void_ffi_error.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_method_callback.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_lt_destroy.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_lt_new_with.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) c_lib.simple_service_lt_method_void_ffi_error.errcheck = lambda rval, _fptr, _args: _errcheck(rval, 0) def primitive_void(): return c_lib.primitive_void() def primitive_void2(): return c_lib.primitive_void2() def primitive_bool(x: bool) -> bool: return c_lib.primitive_bool(x) def primitive_u8(x: int) -> int: return c_lib.primitive_u8(x) def primitive_u16(x: int) -> int: return c_lib.primitive_u16(x) def primitive_u32(x: int) -> int: return c_lib.primitive_u32(x) def primitive_u64(x: int) -> int: return c_lib.primitive_u64(x) def primitive_i8(x: int) -> int: return c_lib.primitive_i8(x) def primitive_i16(x: int) -> int: return c_lib.primitive_i16(x) def primitive_i32(x: int) -> int: return c_lib.primitive_i32(x) def primitive_i64(x: int) -> int: return c_lib.primitive_i64(x) def boolean_alignment(x: BooleanAlignment) -> BooleanAlignment: return c_lib.boolean_alignment(x) def boolean_alignment2(rval: bool) -> BooleanAlignment: return c_lib.boolean_alignment2(rval) def aligned_to_packed1(a: Aligned1) -> Packed1: return c_lib.aligned_to_packed1(a) def aligned_to_packed2(a: Aligned2) -> Packed2: return c_lib.aligned_to_packed2(a) def many_args_5(x0: int, x1: int, x2: int, x3: int, x4: int) -> int: return c_lib.many_args_5(x0, x1, x2, x3, x4) def many_args_10(x0: int, x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int, x8: int, x9: int) -> int: return c_lib.many_args_10(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) def ptr(x: ctypes.POINTER(ctypes.c_int64)) -> ctypes.POINTER(ctypes.c_int64): return c_lib.ptr(x) def ptr_mut(x: ctypes.POINTER(ctypes.c_int64)) -> ctypes.POINTER(ctypes.c_int64): """ # Safety Parameter x must point to valid data.""" return c_lib.ptr_mut(x) def ptr_ptr(x: ctypes.POINTER(ctypes.POINTER(ctypes.c_int64))) -> ctypes.POINTER(ctypes.POINTER(ctypes.c_int64)): return c_lib.ptr_ptr(x) def ref_simple(x: ctypes.POINTER(ctypes.c_int64)) -> ctypes.POINTER(ctypes.c_int64): return c_lib.ref_simple(x) def ref_mut_simple(x: ctypes.POINTER(ctypes.c_int64)) -> ctypes.POINTER(ctypes.c_int64): return c_lib.ref_mut_simple(x) def ref_option(x: ctypes.POINTER(ctypes.c_int64)) -> bool: return c_lib.ref_option(x) def ref_mut_option(x: ctypes.POINTER(ctypes.c_int64)) -> bool: return c_lib.ref_mut_option(x) def tupled(x: Tupled) -> Tupled: return c_lib.tupled(x) def complex_args_1(a: Vec3f32, b: ctypes.POINTER(Tupled)): return c_lib.complex_args_1(a, b) def complex_args_2(cmplx: SomeForeignType) -> ctypes.c_void_p: return c_lib.complex_args_2(cmplx) def callback(callback, value: int) -> int: if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_u8_rval_u8(callback) return c_lib.callback(callback, value) def generic_1a(x: Genericu32, y: Phantomu8) -> int: return c_lib.generic_1a(x, y) def generic_1b(x: Genericu8, y: Phantomu8) -> int: return c_lib.generic_1b(x, y) def generic_1c(x: ctypes.POINTER(Genericu8), y: ctypes.POINTER(Genericu8)) -> int: return c_lib.generic_1c(x, y) def generic_2(x: ctypes.c_void_p) -> int: return c_lib.generic_2(x) def generic_3(x: ctypes.c_void_p) -> int: return c_lib.generic_3(x) def generic_4(x: ctypes.c_void_p) -> int: return c_lib.generic_4(x) def array_1(x: Array) -> int: return c_lib.array_1(x) def documented(x: StructDocumented) -> ctypes.c_int: """ This function has documentation.""" return c_lib.documented(x) def ambiguous_1(x: Vec1) -> Vec1: return c_lib.ambiguous_1(x) def ambiguous_2(x: Vec2) -> Vec2: return c_lib.ambiguous_2(x) def ambiguous_3(x: Vec1, y: Vec2) -> bool: return c_lib.ambiguous_3(x, y) def namespaced_type(x: Vec) -> Vec: return c_lib.namespaced_type(x) def namespaced_inner_option(x: OptionVec) -> OptionVec: return c_lib.namespaced_inner_option(x) def namespaced_inner_slice(x: SliceVec | ctypes.Array[Vec]) -> SliceVec: if hasattr(x, "_length_") and getattr(x, "_type_", "") == Vec: x = SliceVec(data=ctypes.cast(x, ctypes.POINTER(Vec)), len=len(x)) return c_lib.namespaced_inner_slice(x) def namespaced_inner_slice_mut(x: SliceMutVec | ctypes.Array[Vec]) -> SliceMutVec: if hasattr(x, "_length_") and getattr(x, "_type_", "") == Vec: x = SliceMutVec(data=ctypes.cast(x, ctypes.POINTER(Vec)), len=len(x)) return c_lib.namespaced_inner_slice_mut(x) def panics(): return c_lib.panics() def renamed(x: StructRenamed) -> ctypes.c_int: return c_lib.renamed(x) def sleep(millis: int): return c_lib.sleep(millis) def weird_1(x: Weird1u32, y: Weird2u8) -> bool: return c_lib.weird_1(x, y) def visibility(x: Visibility1, y: Visibility2): return c_lib.visibility(x, y) def repr_transparent(x: Tupled, r: ctypes.POINTER(Tupled)) -> Tupled: return c_lib.repr_transparent(x, r) def pattern_ascii_pointer_1(x: bytes) -> int: if not hasattr(x, "__ctypes_from_outparam__"): x = ctypes.cast(x, ctypes.POINTER(ctypes.c_char)) return c_lib.pattern_ascii_pointer_1(x) def pattern_ascii_pointer_2() -> bytes: rval = c_lib.pattern_ascii_pointer_2() return ctypes.string_at(rval) def pattern_ascii_pointer_len(x: bytes, y: UseAsciiStringPattern) -> int: if not hasattr(x, "__ctypes_from_outparam__"): x = ctypes.cast(x, ctypes.POINTER(ctypes.c_char)) return c_lib.pattern_ascii_pointer_len(x, y) def pattern_ascii_pointer_return_slice() -> SliceUseAsciiStringPattern: return c_lib.pattern_ascii_pointer_return_slice() def pattern_ffi_slice_1(ffi_slice: Sliceu32 | ctypes.Array[ctypes.c_uint32]) -> int: if hasattr(ffi_slice, "_length_") and getattr(ffi_slice, "_type_", "") == ctypes.c_uint32: ffi_slice = Sliceu32(data=ctypes.cast(ffi_slice, ctypes.POINTER(ctypes.c_uint32)), len=len(ffi_slice)) return c_lib.pattern_ffi_slice_1(ffi_slice) def pattern_ffi_slice_1b(ffi_slice: SliceMutu32 | ctypes.Array[ctypes.c_uint32]) -> int: if hasattr(ffi_slice, "_length_") and getattr(ffi_slice, "_type_", "") == ctypes.c_uint32: ffi_slice = SliceMutu32(data=ctypes.cast(ffi_slice, ctypes.POINTER(ctypes.c_uint32)), len=len(ffi_slice)) return c_lib.pattern_ffi_slice_1b(ffi_slice) def pattern_ffi_slice_2(ffi_slice: SliceVec3f32 | ctypes.Array[Vec3f32], i: int) -> Vec3f32: if hasattr(ffi_slice, "_length_") and getattr(ffi_slice, "_type_", "") == Vec3f32: ffi_slice = SliceVec3f32(data=ctypes.cast(ffi_slice, ctypes.POINTER(Vec3f32)), len=len(ffi_slice)) return c_lib.pattern_ffi_slice_2(ffi_slice, i) def pattern_ffi_slice_3(slice: SliceMutu8 | ctypes.Array[ctypes.c_uint8], callback): if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = SliceMutu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_SliceMutu8(callback) return c_lib.pattern_ffi_slice_3(slice, callback) def pattern_ffi_slice_4(slice: Sliceu8 | ctypes.Array[ctypes.c_uint8], slice2: SliceMutu8 | ctypes.Array[ctypes.c_uint8]): if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = Sliceu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) if hasattr(slice2, "_length_") and getattr(slice2, "_type_", "") == ctypes.c_uint8: slice2 = SliceMutu8(data=ctypes.cast(slice2, ctypes.POINTER(ctypes.c_uint8)), len=len(slice2)) return c_lib.pattern_ffi_slice_4(slice, slice2) def pattern_ffi_slice_5(slice: ctypes.POINTER(Sliceu8), slice2: ctypes.POINTER(SliceMutu8)): return c_lib.pattern_ffi_slice_5(slice, slice2) def pattern_ffi_slice_6(slice: ctypes.POINTER(SliceMutu8), callback): if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_u8_rval_u8(callback) return c_lib.pattern_ffi_slice_6(slice, callback) def pattern_ffi_slice_delegate(callback) -> int: if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_Sliceu8_rval_u8(callback) return c_lib.pattern_ffi_slice_delegate(callback) def pattern_ffi_slice_delegate_huge(callback) -> Vec3f32: if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_SliceVec3f32_rval_Vec3f32(callback) return c_lib.pattern_ffi_slice_delegate_huge(callback) def pattern_ffi_option_1(ffi_slice: OptionInner) -> OptionInner: return c_lib.pattern_ffi_option_1(ffi_slice) def pattern_ffi_option_2(ffi_slice: OptionInner) -> Inner: return c_lib.pattern_ffi_option_2(ffi_slice) def pattern_ffi_bool(ffi_bool): return c_lib.pattern_ffi_bool(ffi_bool) def pattern_ffi_cchar(ffi_cchar: ctypes.c_char) -> ctypes.c_char: return c_lib.pattern_ffi_cchar(ffi_cchar) def pattern_ffi_cchar_const_pointer(ffi_cchar: ctypes.POINTER(ctypes.c_char)) -> ctypes.POINTER(ctypes.c_char): return c_lib.pattern_ffi_cchar_const_pointer(ffi_cchar) def pattern_ffi_cchar_mut_pointer(ffi_cchar: ctypes.POINTER(ctypes.c_char)) -> ctypes.POINTER(ctypes.c_char): return c_lib.pattern_ffi_cchar_mut_pointer(ffi_cchar) def pattern_api_guard(): return c_lib.pattern_api_guard() def pattern_callback_1(callback, x: int) -> int: if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_u32_rval_u32(callback) return c_lib.pattern_callback_1(callback, x) def pattern_callback_2(callback): if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_pconst(callback) return c_lib.pattern_callback_2(callback) def pattern_callback_3(callback: DelegateCallbackMyCallbackContextual, x: int): return c_lib.pattern_callback_3(callback, x) def pattern_callback_4(callback, x: int) -> int: if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_u32_rval_u32(callback) return c_lib.pattern_callback_4(callback, x) U8 = 255 F32_MIN_POSITIVE = 0.000000000000000000000000000000000000011754944 COMPUTED_I32 = -2147483647 TRUE = ctypes.c_uint8(1) FALSE = ctypes.c_uint8(0) def _errcheck(returned, success): """Checks for FFIErrors and converts them to an exception.""" if returned == success: return else: raise Exception(f"Function returned error: {returned}") class CallbackVars(object): """Helper to be used `lambda x: setattr(cv, "x", x)` when getting values from callbacks.""" def __str__(self): rval = "" for var in filter(lambda x: "__" not in x, dir(self)): rval += f"{var}: {getattr(self, var)}" return rval class _Iter(object): """Helper for slice iterators.""" def __init__(self, target): self.i = 0 self.target = target def __iter__(self): self.i = 0 return self def __next__(self): if self.i >= self.target.len: raise StopIteration() rval = self.target[self.i] self.i += 1 return rval class EnumDocumented: """ Documented enum.""" # Variant A. A = 0 # Variant B. B = 1 # Variant B. C = 2 class EnumRenamed: X = 0 class FFIError: Ok = 0 Null = 100 Panic = 200 Fail = 300 class Aligned1(ctypes.Structure): _pack_ = 2 # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint8), ("y", ctypes.c_uint16), ] def __init__(self, x: int = None, y: int = None): if x is not None: self.x = x if y is not None: self.y = y @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) @property def y(self) -> int: return ctypes.Structure.__get__(self, "y") @y.setter def y(self, value: int): return ctypes.Structure.__set__(self, "y", value) class Aligned2(ctypes.Structure): _pack_ = 64 # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint8), ("y", ctypes.c_uint16), ] def __init__(self, x: int = None, y: int = None): if x is not None: self.x = x if y is not None: self.y = y @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) @property def y(self) -> int: return ctypes.Structure.__get__(self, "y") @y.setter def y(self, value: int): return ctypes.Structure.__set__(self, "y", value) class BooleanAlignment(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("a", ctypes.c_int32), ("b", ctypes.c_int16), ("c", ctypes.c_int16), ("d", ctypes.c_uint8), ("e", ctypes.c_uint8), ("f", ctypes.c_uint8), ("g", ctypes.c_uint8), ("h", ctypes.c_uint8), ("i", ctypes.c_uint8), ("j", ctypes.c_uint8), ("k", ctypes.c_uint8), ("id", ctypes.c_uint64), ("is_valid", ctypes.c_bool), ("datum", ctypes.c_uint64), ] def __init__(self, a: int = None, b: int = None, c: int = None, d: int = None, e: int = None, f: int = None, g: int = None, h: int = None, i: int = None, j: int = None, k: int = None, id: int = None, is_valid: bool = None, datum: int = None): if a is not None: self.a = a if b is not None: self.b = b if c is not None: self.c = c if d is not None: self.d = d if e is not None: self.e = e if f is not None: self.f = f if g is not None: self.g = g if h is not None: self.h = h if i is not None: self.i = i if j is not None: self.j = j if k is not None: self.k = k if id is not None: self.id = id if is_valid is not None: self.is_valid = is_valid if datum is not None: self.datum = datum @property def a(self) -> int: return ctypes.Structure.__get__(self, "a") @a.setter def a(self, value: int): return ctypes.Structure.__set__(self, "a", value) @property def b(self) -> int: return ctypes.Structure.__get__(self, "b") @b.setter def b(self, value: int): return ctypes.Structure.__set__(self, "b", value) @property def c(self) -> int: return ctypes.Structure.__get__(self, "c") @c.setter def c(self, value: int): return ctypes.Structure.__set__(self, "c", value) @property def d(self) -> int: return ctypes.Structure.__get__(self, "d") @d.setter def d(self, value: int): return ctypes.Structure.__set__(self, "d", value) @property def e(self) -> int: return ctypes.Structure.__get__(self, "e") @e.setter def e(self, value: int): return ctypes.Structure.__set__(self, "e", value) @property def f(self) -> int: return ctypes.Structure.__get__(self, "f") @f.setter def f(self, value: int): return ctypes.Structure.__set__(self, "f", value) @property def g(self) -> int: return ctypes.Structure.__get__(self, "g") @g.setter def g(self, value: int): return ctypes.Structure.__set__(self, "g", value) @property def h(self) -> int: return ctypes.Structure.__get__(self, "h") @h.setter def h(self, value: int): return ctypes.Structure.__set__(self, "h", value) @property def i(self) -> int: return ctypes.Structure.__get__(self, "i") @i.setter def i(self, value: int): return ctypes.Structure.__set__(self, "i", value) @property def j(self) -> int: return ctypes.Structure.__get__(self, "j") @j.setter def j(self, value: int): return ctypes.Structure.__set__(self, "j", value) @property def k(self) -> int: return ctypes.Structure.__get__(self, "k") @k.setter def k(self, value: int): return ctypes.Structure.__set__(self, "k", value) @property def id(self) -> int: return ctypes.Structure.__get__(self, "id") @id.setter def id(self, value: int): return ctypes.Structure.__set__(self, "id", value) @property def is_valid(self) -> bool: return ctypes.Structure.__get__(self, "is_valid") @is_valid.setter def is_valid(self, value: bool): return ctypes.Structure.__set__(self, "is_valid", value) @property def datum(self) -> int: return ctypes.Structure.__get__(self, "datum") @datum.setter def datum(self, value: int): return ctypes.Structure.__set__(self, "datum", value) class ExtraTypef32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_float), ] def __init__(self, x: float = None): if x is not None: self.x = x @property def x(self) -> float: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): return ctypes.Structure.__set__(self, "x", value) class Inner(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_float), ] def __init__(self, x: float = None): if x is not None: self.x = x @property def x(self) -> float: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): return ctypes.Structure.__set__(self, "x", value) class Packed1(ctypes.Structure): _pack_ = 1 # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint8), ("y", ctypes.c_uint16), ] def __init__(self, x: int = None, y: int = None): if x is not None: self.x = x if y is not None: self.y = y @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) @property def y(self) -> int: return ctypes.Structure.__get__(self, "y") @y.setter def y(self, value: int): return ctypes.Structure.__set__(self, "y", value) class Packed2(ctypes.Structure): _pack_ = 1 # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint8), ("y", ctypes.c_uint16), ] def __init__(self, x: int = None, y: int = None): if x is not None: self.x = x if y is not None: self.y = y @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) @property def y(self) -> int: return ctypes.Structure.__get__(self, "y") @y.setter def y(self, value: int): return ctypes.Structure.__set__(self, "y", value) class Phantomu8(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint32), ] def __init__(self, x: int = None): if x is not None: self.x = x @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) class SomeForeignType(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint32), ] def __init__(self, x: int = None): if x is not None: self.x = x @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) class StructDocumented(ctypes.Structure): """ Documented struct.""" # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_float), ] def __init__(self, x: float = None): if x is not None: self.x = x @property def x(self) -> float: """ Documented field.""" return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): """ Documented field.""" return ctypes.Structure.__set__(self, "x", value) class StructRenamed(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("e", ctypes.c_int), ] def __init__(self, e: ctypes.c_int = None): if e is not None: self.e = e @property def e(self) -> ctypes.c_int: return ctypes.Structure.__get__(self, "e") @e.setter def e(self, value: ctypes.c_int): return ctypes.Structure.__set__(self, "e", value) class Tupled(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x0", ctypes.c_uint8), ] def __init__(self, x0: int = None): if x0 is not None: self.x0 = x0 @property def x0(self) -> int: return ctypes.Structure.__get__(self, "x0") @x0.setter def x0(self, value: int): return ctypes.Structure.__set__(self, "x0", value) class UseAsciiStringPattern(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("ascii_string", ctypes.POINTER(ctypes.c_char)), ] def __init__(self, ascii_string: bytes = None): if ascii_string is not None: self.ascii_string = ascii_string @property def ascii_string(self) -> bytes: return ctypes.Structure.__get__(self, "ascii_string") @ascii_string.setter def ascii_string(self, value: bytes): return ctypes.Structure.__set__(self, "ascii_string", value) class Vec(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_double), ("z", ctypes.c_double), ] def __init__(self, x: float = None, z: float = None): if x is not None: self.x = x if z is not None: self.z = z @property def x(self) -> float: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): return ctypes.Structure.__set__(self, "x", value) @property def z(self) -> float: return ctypes.Structure.__get__(self, "z") @z.setter def z(self, value: float): return ctypes.Structure.__set__(self, "z", value) class Vec1(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_float), ("y", ctypes.c_float), ] def __init__(self, x: float = None, y: float = None): if x is not None: self.x = x if y is not None: self.y = y @property def x(self) -> float: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): return ctypes.Structure.__set__(self, "x", value) @property def y(self) -> float: return ctypes.Structure.__get__(self, "y") @y.setter def y(self, value: float): return ctypes.Structure.__set__(self, "y", value) class Vec2(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_double), ("z", ctypes.c_double), ] def __init__(self, x: float = None, z: float = None): if x is not None: self.x = x if z is not None: self.z = z @property def x(self) -> float: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): return ctypes.Structure.__set__(self, "x", value) @property def z(self) -> float: return ctypes.Structure.__get__(self, "z") @z.setter def z(self, value: float): return ctypes.Structure.__set__(self, "z", value) class Vec3f32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_float), ("y", ctypes.c_float), ("z", ctypes.c_float), ] def __init__(self, x: float = None, y: float = None, z: float = None): if x is not None: self.x = x if y is not None: self.y = y if z is not None: self.z = z @property def x(self) -> float: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: float): return ctypes.Structure.__set__(self, "x", value) @property def y(self) -> float: return ctypes.Structure.__get__(self, "y") @y.setter def y(self, value: float): return ctypes.Structure.__set__(self, "y", value) @property def z(self) -> float: return ctypes.Structure.__get__(self, "z") @z.setter def z(self, value: float): return ctypes.Structure.__set__(self, "z", value) class Visibility1(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("pblc", ctypes.c_uint8), ("prvt", ctypes.c_uint8), ] def __init__(self, pblc: int = None, prvt: int = None): if pblc is not None: self.pblc = pblc if prvt is not None: self.prvt = prvt @property def pblc(self) -> int: return ctypes.Structure.__get__(self, "pblc") @pblc.setter def pblc(self, value: int): return ctypes.Structure.__set__(self, "pblc", value) @property def prvt(self) -> int: return ctypes.Structure.__get__(self, "prvt") @prvt.setter def prvt(self, value: int): return ctypes.Structure.__set__(self, "prvt", value) class Visibility2(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("pblc1", ctypes.c_uint8), ("pblc2", ctypes.c_uint8), ] def __init__(self, pblc1: int = None, pblc2: int = None): if pblc1 is not None: self.pblc1 = pblc1 if pblc2 is not None: self.pblc2 = pblc2 @property def pblc1(self) -> int: return ctypes.Structure.__get__(self, "pblc1") @pblc1.setter def pblc1(self, value: int): return ctypes.Structure.__set__(self, "pblc1", value) @property def pblc2(self) -> int: return ctypes.Structure.__get__(self, "pblc2") @pblc2.setter def pblc2(self, value: int): return ctypes.Structure.__set__(self, "pblc2", value) class Weird1u32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.c_uint32), ] def __init__(self, x: int = None): if x is not None: self.x = x @property def x(self) -> int: return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: int): return ctypes.Structure.__set__(self, "x", value) class Array(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.c_uint8 * 16), ] def __init__(self, data = None): if data is not None: self.data = data @property def data(self): return ctypes.Structure.__get__(self, "data") @data.setter def data(self, value): return ctypes.Structure.__set__(self, "data", value) class Genericu32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.POINTER(ctypes.c_uint32)), ] def __init__(self, x: ctypes.POINTER(ctypes.c_uint32) = None): if x is not None: self.x = x @property def x(self) -> ctypes.POINTER(ctypes.c_uint32): return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: ctypes.POINTER(ctypes.c_uint32)): return ctypes.Structure.__set__(self, "x", value) class Genericu8(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("x", ctypes.POINTER(ctypes.c_uint8)), ] def __init__(self, x: ctypes.POINTER(ctypes.c_uint8) = None): if x is not None: self.x = x @property def x(self) -> ctypes.POINTER(ctypes.c_uint8): return ctypes.Structure.__get__(self, "x") @x.setter def x(self, value: ctypes.POINTER(ctypes.c_uint8)): return ctypes.Structure.__set__(self, "x", value) class Weird2u8(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("t", ctypes.c_uint8), ("a", ctypes.c_uint8 * 5), ("r", ctypes.POINTER(ctypes.c_uint8)), ] def __init__(self, t: int = None, a = None, r: ctypes.POINTER(ctypes.c_uint8) = None): if t is not None: self.t = t if a is not None: self.a = a if r is not None: self.r = r @property def t(self) -> int: return ctypes.Structure.__get__(self, "t") @t.setter def t(self, value: int): return ctypes.Structure.__set__(self, "t", value) @property def a(self): return ctypes.Structure.__get__(self, "a") @a.setter def a(self, value): return ctypes.Structure.__set__(self, "a", value) @property def r(self) -> ctypes.POINTER(ctypes.c_uint8): return ctypes.Structure.__get__(self, "r") @r.setter def r(self, value: ctypes.POINTER(ctypes.c_uint8)): return ctypes.Structure.__set__(self, "r", value) class SliceBool(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(ctypes.c_uint8)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i): if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def copied(self) -> SliceBool: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (ctypes.c_uint8 * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(ctypes.c_uint8)) rval = SliceBool(data=ctypes.cast(array, ctypes.POINTER(ctypes.c_uint8)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[ctypes.c_uint8]: return _Iter(self) def iter(self) -> typing.Iterable[ctypes.c_uint8]: """Convenience method returning a value iterator.""" return iter(self) def first(self): """Returns the first element of this slice.""" return self[0] def last(self): """Returns the last element of this slice.""" return self[len(self)-1] class Sliceu32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(ctypes.c_uint32)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> int: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def copied(self) -> Sliceu32: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (ctypes.c_uint32 * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(ctypes.c_uint32)) rval = Sliceu32(data=ctypes.cast(array, ctypes.POINTER(ctypes.c_uint32)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[ctypes.c_uint32]: return _Iter(self) def iter(self) -> typing.Iterable[ctypes.c_uint32]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> int: """Returns the first element of this slice.""" return self[0] def last(self) -> int: """Returns the last element of this slice.""" return self[len(self)-1] class Sliceu8(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(ctypes.c_uint8)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> int: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def copied(self) -> Sliceu8: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (ctypes.c_uint8 * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(ctypes.c_uint8)) rval = Sliceu8(data=ctypes.cast(array, ctypes.POINTER(ctypes.c_uint8)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[ctypes.c_uint8]: return _Iter(self) def iter(self) -> typing.Iterable[ctypes.c_uint8]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> int: """Returns the first element of this slice.""" return self[0] def last(self) -> int: """Returns the last element of this slice.""" return self[len(self)-1] def bytearray(self): """Returns a bytearray with the content of this slice.""" rval = bytearray(len(self)) for i in range(len(self)): rval[i] = self[i] return rval class SliceMutu32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(ctypes.c_uint32)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> int: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def __setitem__(self, i, v: int): if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") self.data[index] = v def copied(self) -> SliceMutu32: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (ctypes.c_uint32 * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(ctypes.c_uint32)) rval = SliceMutu32(data=ctypes.cast(array, ctypes.POINTER(ctypes.c_uint32)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[ctypes.c_uint32]: return _Iter(self) def iter(self) -> typing.Iterable[ctypes.c_uint32]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> int: """Returns the first element of this slice.""" return self[0] def last(self) -> int: """Returns the last element of this slice.""" return self[len(self)-1] class SliceMutu8(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(ctypes.c_uint8)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> int: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def __setitem__(self, i, v: int): if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") self.data[index] = v def copied(self) -> SliceMutu8: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (ctypes.c_uint8 * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(ctypes.c_uint8)) rval = SliceMutu8(data=ctypes.cast(array, ctypes.POINTER(ctypes.c_uint8)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[ctypes.c_uint8]: return _Iter(self) def iter(self) -> typing.Iterable[ctypes.c_uint8]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> int: """Returns the first element of this slice.""" return self[0] def last(self) -> int: """Returns the last element of this slice.""" return self[len(self)-1] def bytearray(self): """Returns a bytearray with the content of this slice.""" rval = bytearray(len(self)) for i in range(len(self)): rval[i] = self[i] return rval class OptionInner(ctypes.Structure): """May optionally hold a value.""" _fields_ = [ ("_t", Inner), ("_is_some", ctypes.c_uint8), ] @property def value(self) -> Inner: """Returns the value if it exists, or None.""" if self._is_some == 1: return self._t else: return None def is_some(self) -> bool: """Returns true if the value exists.""" return self._is_some == 1 def is_none(self) -> bool: """Returns true if the value does not exist.""" return self._is_some != 0 class OptionVec(ctypes.Structure): """May optionally hold a value.""" _fields_ = [ ("_t", Vec), ("_is_some", ctypes.c_uint8), ] @property def value(self) -> Vec: """Returns the value if it exists, or None.""" if self._is_some == 1: return self._t else: return None def is_some(self) -> bool: """Returns true if the value exists.""" return self._is_some == 1 def is_none(self) -> bool: """Returns true if the value does not exist.""" return self._is_some != 0 class DelegateCallbackMyCallbackContextual(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("callback", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint32)), ("context", ctypes.c_void_p), ] def __init__(self, callback = None, context: ctypes.c_void_p = None): if callback is not None: self.callback = callback if context is not None: self.context = context @property def callback(self): return ctypes.Structure.__get__(self, "callback") @callback.setter def callback(self, value): return ctypes.Structure.__set__(self, "callback", value) @property def context(self) -> ctypes.c_void_p: return ctypes.Structure.__get__(self, "context") @context.setter def context(self, value: ctypes.c_void_p): return ctypes.Structure.__set__(self, "context", value) class SliceUseAsciiStringPattern(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(UseAsciiStringPattern)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> UseAsciiStringPattern: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def copied(self) -> SliceUseAsciiStringPattern: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (UseAsciiStringPattern * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(UseAsciiStringPattern)) rval = SliceUseAsciiStringPattern(data=ctypes.cast(array, ctypes.POINTER(UseAsciiStringPattern)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[UseAsciiStringPattern]: return _Iter(self) def iter(self) -> typing.Iterable[UseAsciiStringPattern]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> UseAsciiStringPattern: """Returns the first element of this slice.""" return self[0] def last(self) -> UseAsciiStringPattern: """Returns the last element of this slice.""" return self[len(self)-1] class SliceVec(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(Vec)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> Vec: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def copied(self) -> SliceVec: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (Vec * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(Vec)) rval = SliceVec(data=ctypes.cast(array, ctypes.POINTER(Vec)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[Vec]: return _Iter(self) def iter(self) -> typing.Iterable[Vec]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> Vec: """Returns the first element of this slice.""" return self[0] def last(self) -> Vec: """Returns the last element of this slice.""" return self[len(self)-1] class SliceVec3f32(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(Vec3f32)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> Vec3f32: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def copied(self) -> SliceVec3f32: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (Vec3f32 * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(Vec3f32)) rval = SliceVec3f32(data=ctypes.cast(array, ctypes.POINTER(Vec3f32)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[Vec3f32]: return _Iter(self) def iter(self) -> typing.Iterable[Vec3f32]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> Vec3f32: """Returns the first element of this slice.""" return self[0] def last(self) -> Vec3f32: """Returns the last element of this slice.""" return self[len(self)-1] class SliceMutVec(ctypes.Structure): # These fields represent the underlying C data layout _fields_ = [ ("data", ctypes.POINTER(Vec)), ("len", ctypes.c_uint64), ] def __len__(self): return self.len def __getitem__(self, i) -> Vec: if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") return self.data[index] def __setitem__(self, i, v: Vec): if i < 0: index = self.len+i else: index = i if index >= self.len: raise IndexError("Index out of range") self.data[index] = v def copied(self) -> SliceMutVec: """Returns a shallow, owned copy of the underlying slice. The returned object owns the immediate data, but not the targets of any contained pointers. In other words, if your struct contains any pointers the returned object may only be used as long as these pointers are valid. If the struct did not contain any pointers the returned object is valid indefinitely.""" array = (Vec * len(self))() ctypes.memmove(array, self.data, len(self) * ctypes.sizeof(Vec)) rval = SliceMutVec(data=ctypes.cast(array, ctypes.POINTER(Vec)), len=len(self)) rval.owned = array # Store array in returned slice to prevent memory deallocation return rval def __iter__(self) -> typing.Iterable[Vec]: return _Iter(self) def iter(self) -> typing.Iterable[Vec]: """Convenience method returning a value iterator.""" return iter(self) def first(self) -> Vec: """Returns the first element of this slice.""" return self[0] def last(self) -> Vec: """Returns the last element of this slice.""" return self[len(self)-1] class callbacks: """Helpers to define callbacks.""" fn_u8_rval_u8 = ctypes.CFUNCTYPE(ctypes.c_uint8, ctypes.c_uint8) fn_Sliceu8_rval_u8 = ctypes.CFUNCTYPE(ctypes.c_uint8, Sliceu8) fn_SliceVec3f32_rval_Vec3f32 = ctypes.CFUNCTYPE(Vec3f32, SliceVec3f32) fn_SliceMutu8 = ctypes.CFUNCTYPE(None, SliceMutu8) fn_u8_rval_u8 = ctypes.CFUNCTYPE(ctypes.c_uint8, ctypes.c_uint8) fn_u32_rval_u32 = ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint32) fn_pconst__u32 = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint32) fn_u32_rval_u32 = ctypes.CFUNCTYPE(ctypes.c_uint32, ctypes.c_uint32) fn_pconst = ctypes.CFUNCTYPE(None, ctypes.c_void_p) class SimpleService: """ Some struct we want to expose as a class.""" __api_lock = object() def __init__(self, api_lock, ctx): assert(api_lock == SimpleService.__api_lock), "You must create this with a static constructor." self._ctx = ctx @property def _as_parameter_(self): return self._ctx @staticmethod def new_with(some_value: int) -> SimpleService: """ The constructor must return a `Result`.""" ctx = ctypes.c_void_p() c_lib.simple_service_new_with(ctx, some_value) self = SimpleService(SimpleService.__api_lock, ctx) return self @staticmethod def new_without() -> SimpleService: """""" ctx = ctypes.c_void_p() c_lib.simple_service_new_without(ctx, ) self = SimpleService(SimpleService.__api_lock, ctx) return self @staticmethod def new_with_string(ascii: bytes) -> SimpleService: """""" ctx = ctypes.c_void_p() if not hasattr(ascii, "__ctypes_from_outparam__"): ascii = ctypes.cast(ascii, ctypes.POINTER(ctypes.c_char)) c_lib.simple_service_new_with_string(ctx, ascii) self = SimpleService(SimpleService.__api_lock, ctx) return self @staticmethod def new_failing(some_value: int) -> SimpleService: """""" ctx = ctypes.c_void_p() c_lib.simple_service_new_failing(ctx, some_value) self = SimpleService(SimpleService.__api_lock, ctx) return self def __del__(self): c_lib.simple_service_destroy(self._ctx, ) def method_result(self, anon1: int): """ Methods returning a Result<(), _> are the default and do not need annotations.""" return c_lib.simple_service_method_result(self._ctx, anon1) def method_value(self, x: int) -> int: """""" return c_lib.simple_service_method_value(self._ctx, x) def method_void(self, ): """ This method should be documented. Multiple lines.""" return c_lib.simple_service_method_void(self._ctx, ) def method_mut_self(self, slice: Sliceu8 | ctypes.Array[ctypes.c_uint8]) -> int: """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = Sliceu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_method_mut_self(self._ctx, slice) def method_mut_self_void(self, slice: SliceBool | ctypes.Array[ctypes.c_uint8]): """ Single line.""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = SliceBool(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_method_mut_self_void(self._ctx, slice) def method_mut_self_ref(self, x: ctypes.POINTER(ctypes.c_uint8), y: ctypes.POINTER(ctypes.c_uint8)) -> int: """""" return c_lib.simple_service_method_mut_self_ref(self._ctx, x, y) def method_mut_self_ref_slice(self, x: ctypes.POINTER(ctypes.c_uint8), y: ctypes.POINTER(ctypes.c_uint8), slice: Sliceu8 | ctypes.Array[ctypes.c_uint8]) -> int: """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = Sliceu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_method_mut_self_ref_slice(self._ctx, x, y, slice) def method_mut_self_ref_slice_limited(self, x: ctypes.POINTER(ctypes.c_uint8), y: ctypes.POINTER(ctypes.c_uint8), slice: Sliceu8 | ctypes.Array[ctypes.c_uint8], slice2: Sliceu8 | ctypes.Array[ctypes.c_uint8]) -> int: """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = Sliceu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) if hasattr(slice2, "_length_") and getattr(slice2, "_type_", "") == ctypes.c_uint8: slice2 = Sliceu8(data=ctypes.cast(slice2, ctypes.POINTER(ctypes.c_uint8)), len=len(slice2)) return c_lib.simple_service_method_mut_self_ref_slice_limited(self._ctx, x, y, slice, slice2) def method_mut_self_ffi_error(self, slice: SliceMutu8 | ctypes.Array[ctypes.c_uint8]): """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = SliceMutu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_method_mut_self_ffi_error(self._ctx, slice) def method_mut_self_no_error(self, slice: SliceMutu8 | ctypes.Array[ctypes.c_uint8]): """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = SliceMutu8(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_method_mut_self_no_error(self._ctx, slice) def return_slice(self, ) -> Sliceu32: """ Warning, you _must_ discard the returned slice object before calling into this service again, as otherwise undefined behavior might happen.""" return c_lib.simple_service_return_slice(self._ctx, ) def return_slice_mut(self, ) -> SliceMutu32: """ Warning, you _must_ discard the returned slice object before calling into this service again, as otherwise undefined behavior might happen.""" return c_lib.simple_service_return_slice_mut(self._ctx, ) def return_string(self, ) -> bytes: """ This function has no panic safeguards. If it panics your host app will be in an undefined state.""" rval = c_lib.simple_service_return_string(self._ctx, ) return ctypes.string_at(rval) def method_void_ffi_error(self, ): """""" return c_lib.simple_service_method_void_ffi_error(self._ctx, ) def method_callback(self, callback): """""" if not hasattr(callback, "__ctypes_from_outparam__"): callback = callbacks.fn_u32_rval_u32(callback) return c_lib.simple_service_method_callback(self._ctx, callback) class SimpleServiceLifetime: __api_lock = object() def __init__(self, api_lock, ctx): assert(api_lock == SimpleServiceLifetime.__api_lock), "You must create this with a static constructor." self._ctx = ctx @property def _as_parameter_(self): return self._ctx @staticmethod def new_with(some_value: ctypes.POINTER(ctypes.c_uint32)) -> SimpleServiceLifetime: """""" ctx = ctypes.c_void_p() c_lib.simple_service_lt_new_with(ctx, some_value) self = SimpleServiceLifetime(SimpleServiceLifetime.__api_lock, ctx) return self def __del__(self): c_lib.simple_service_lt_destroy(self._ctx, ) def method_lt(self, slice: SliceBool | ctypes.Array[ctypes.c_uint8]): """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = SliceBool(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_lt_method_lt(self._ctx, slice) def method_lt2(self, slice: SliceBool | ctypes.Array[ctypes.c_uint8]): """""" if hasattr(slice, "_length_") and getattr(slice, "_type_", "") == ctypes.c_uint8: slice = SliceBool(data=ctypes.cast(slice, ctypes.POINTER(ctypes.c_uint8)), len=len(slice)) return c_lib.simple_service_lt_method_lt2(self._ctx, slice) def return_string_accept_slice(self, anon1: Sliceu8 | ctypes.Array[ctypes.c_uint8]) -> bytes: """""" if hasattr(anon1, "_length_") and getattr(anon1, "_type_", "") == ctypes.c_uint8: anon1 = Sliceu8(data=ctypes.cast(anon1, ctypes.POINTER(ctypes.c_uint8)), len=len(anon1)) rval = c_lib.simple_service_lt_return_string_accept_slice(self._ctx, anon1) return ctypes.string_at(rval) def method_void_ffi_error(self, ): """""" return c_lib.simple_service_lt_method_void_ffi_error(self._ctx, )