UCharIterator

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct UCharIterator
{
    public IntPtr context;
    public int length;
    public int start;
    public int index;
    public int limit;
    public int reservedField;
    public IntPtr getIndex;
    public IntPtr move;
    public IntPtr hasNext;
    public IntPtr hasPrevious;
    public IntPtr current;
    public IntPtr next;
    public IntPtr previous;
    public IntPtr reservedFn;
    public IntPtr getState;
    public IntPtr setState;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure UCharIterator
    Public context As IntPtr
    Public length As Integer
    Public start As Integer
    Public index As Integer
    Public limit As Integer
    Public reservedField As Integer
    Public getIndex As IntPtr
    Public move As IntPtr
    Public hasNext As IntPtr
    Public hasPrevious As IntPtr
    Public current As IntPtr
    Public next As IntPtr
    Public previous As IntPtr
    Public reservedFn As IntPtr
    Public getState As IntPtr
    Public setState As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class UCharIterator(ctypes.Structure):
    _fields_ = [
        ("context", ctypes.c_void_p),
        ("length", ctypes.c_int),
        ("start", ctypes.c_int),
        ("index", ctypes.c_int),
        ("limit", ctypes.c_int),
        ("reservedField", ctypes.c_int),
        ("getIndex", ctypes.c_void_p),
        ("move", ctypes.c_void_p),
        ("hasNext", ctypes.c_void_p),
        ("hasPrevious", ctypes.c_void_p),
        ("current", ctypes.c_void_p),
        ("next", ctypes.c_void_p),
        ("previous", ctypes.c_void_p),
        ("reservedFn", ctypes.c_void_p),
        ("getState", ctypes.c_void_p),
        ("setState", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct UCharIterator {
    pub context: *mut core::ffi::c_void,
    pub length: i32,
    pub start: i32,
    pub index: i32,
    pub limit: i32,
    pub reservedField: i32,
    pub getIndex: *mut core::ffi::c_void,
    pub move: *mut core::ffi::c_void,
    pub hasNext: *mut core::ffi::c_void,
    pub hasPrevious: *mut core::ffi::c_void,
    pub current: *mut core::ffi::c_void,
    pub next: *mut core::ffi::c_void,
    pub previous: *mut core::ffi::c_void,
    pub reservedFn: *mut core::ffi::c_void,
    pub getState: *mut core::ffi::c_void,
    pub setState: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type UCharIterator struct {
	context uintptr
	length int32
	start int32
	index int32
	limit int32
	reservedField int32
	getIndex uintptr
	move uintptr
	hasNext uintptr
	hasPrevious uintptr
	current uintptr
	next uintptr
	previous uintptr
	reservedFn uintptr
	getState uintptr
	setState uintptr
}

type
  UCharIterator = record
    context: Pointer;
    length: Integer;
    start: Integer;
    index: Integer;
    limit: Integer;
    reservedField: Integer;
    getIndex: Pointer;
    move: Pointer;
    hasNext: Pointer;
    hasPrevious: Pointer;
    current: Pointer;
    next: Pointer;
    previous: Pointer;
    reservedFn: Pointer;
    getState: Pointer;
    setState: Pointer;
  end;

const UCharIterator = extern struct {
    context: ?*anyopaque,
    length: i32,
    start: i32,
    index: i32,
    limit: i32,
    reservedField: i32,
    getIndex: ?*anyopaque,
    move: ?*anyopaque,
    hasNext: ?*anyopaque,
    hasPrevious: ?*anyopaque,
    current: ?*anyopaque,
    next: ?*anyopaque,
    previous: ?*anyopaque,
    reservedFn: ?*anyopaque,
    getState: ?*anyopaque,
    setState: ?*anyopaque,
};

type
  UCharIterator {.bycopy.} = object
    context: pointer
    length: int32
    start: int32
    index: int32
    limit: int32
    reservedField: int32
    getIndex: pointer
    move: pointer
    hasNext: pointer
    hasPrevious: pointer
    current: pointer
    next: pointer
    previous: pointer
    reservedFn: pointer
    getState: pointer
    setState: pointer

struct UCharIterator
{
    void* context;
    int length;
    int start;
    int index;
    int limit;
    int reservedField;
    void* getIndex;
    void* move;
    void* hasNext;
    void* hasPrevious;
    void* current;
    void* next;
    void* previous;
    void* reservedFn;
    void* getState;
    void* setState;
}