🥮 mooncakes.io
    Sign in

    flatbuffers

    Download zip
    Author
    Version
    0.1.4
    License
    Apache-2.0
    Repository
    Last updated
    17 days ago
    Downloads
    56K

    Dependencies

    #FlatBuffers for MoonBit

    A pure MoonBit implementation of Google FlatBuffers - an efficient cross-platform serialization library.

    #Features

    • Zero-copy deserialization - Read data directly from buffer without parsing
    • Memory efficient - No intermediate allocations during read
    • Type safe - Compile-time type checking
    • Schema support - Parse .fbs schemas and generate MoonBit code
    • Full FlatBuffers compatibility - Binary format compatible with other languages

    #Installation

    Add to your moon.mod.json:

    {
  "deps": {
    "mizchi/flatbuffers": "0.1.0"
  }
}

    #Quick Start

    #Basic Usage

    // Create a FlatBuffer
    let builder = @flatbuffers.Builder::new()

    // Create a string (must be created before the table)
    let name = builder.create_string("Alice")

    // Build a table with 2 fields
    builder.start_object(2)
    builder.add_offset(0, name)     // field 0: name (string)
    builder.add_int32(1, 30, 0)     // field 1: age (int32, default 0)
    let person = builder.end_object()

    // Finish the buffer
    builder.finish(person)

    // Get serialized bytes
    let bytes = builder.to_bytes()

    // Read it back
    let buf = @flatbuffers.ByteBuffer::from_bytes(bytes)
    let root = @flatbuffers.Table::get_root(buf)
    let name = root.get_string(0, "")   // "Alice"
    let age = root.get_int32(1, 0)      // 30

    #Using Object API (Schema-based)

    // Define schema
    let schema = @flatbuffers.TableSchema::new("Person", [
      @flatbuffers.FieldDef::new("name", 0, @flatbuffers.FieldType::string()),
      @flatbuffers.FieldDef::with_default_int("age", 1, @flatbuffers.FieldType::int32(), 0),
    ])

    // Build using ObjectBuilder
    let builder = @flatbuffers.Builder::new()
    let obj = @flatbuffers.ObjectBuilder::new(builder, schema)
      .set_string("name", "Bob")
    obj.start()
    ignore(obj.add_int32("age", 25))
    obj.finish_buffer()

    // Read using ObjectReader
    let buf = @flatbuffers.ByteBuffer::new(builder.to_fixed_array())
    let root = @flatbuffers.Table::get_root(buf)
    let reader = @flatbuffers.ObjectReader::new(root, schema)
    println(reader.get_string("name"))  // "Bob"
    println(reader.get_int32("age"))    // 25

    #Code Generation

    Generate MoonBit code from FlatBuffers schema:

    ///|
    let schema_text =
      #|table Monster {
      #|  name:string;
      #|  hp:short = 100;
      #|}

    ///|
    let schema = @flatbuffers.parse_schema(schema_text)

    ///|
    let code = @flatbuffers.generate_moonbit(schema)
    // Save `code` to a .mbt file

    Run the code generator CLI:

    moon run cmd/codegen

    #API Reference

    #Core Types

    TypeDescription
    ByteBufferRead-only buffer for deserialization
    BuilderMutable builder for serialization
    TableReader for table data

    #Builder Methods

    // Scalars
    builder.add_bool(slot, value, default)
    builder.add_int8(slot, value, default)
    builder.add_uint8(slot, value, default)
    builder.add_int16(slot, value, default)
    builder.add_uint16(slot, value, default)
    builder.add_int32(slot, value, default)
    builder.add_uint32(slot, value, default)
    builder.add_int64(slot, value, default)
    builder.add_uint64(slot, value, default)
    builder.add_float32(slot, value, default)
    builder.add_float64(slot, value, default)

    // Strings and Vectors
    builder.create_string(s)
    builder.create_shared_string(s)  // Deduplicates strings
    builder.create_byte_vector(data)
    builder.create_int32_vector(data)

    // Table construction
    builder.start_object(num_fields)
    builder.add_offset(slot, offset)
    builder.end_object() -> Int

    // Finishing
    builder.finish(root_offset)
    builder.finish_with_identifier(root_offset, "FILE")
    builder.finish_size_prefixed(root_offset)

    #Table Reader Methods

    // Scalars
    table.get_bool(slot, default) -> Bool
    table.get_int8(slot, default) -> Int
    table.get_int16(slot, default) -> Int
    table.get_int32(slot, default) -> Int
    table.get_int64(slot, default) -> Int64
    table.get_float32(slot, default) -> Float
    table.get_float64(slot, default) -> Double

    // Strings
    table.get_string(slot, default) -> String

    // Vectors
    table.get_vector_length(slot) -> Int
    table.get_vector_byte(slot, index) -> Byte
    table.get_vector_int32(slot, index) -> Int

    // Nested tables
    table.get_table(slot) -> Table?

    // Unions
    table.get_union_type(slot) -> Int
    table.get_union_table(slot) -> Table?

    #Advanced Features

    #Shared Strings

    Reduce buffer size by deduplicating identical strings:

    ///|
    let s1 = builder.create_shared_string("repeated")

    ///|
    let s2 = builder.create_shared_string("repeated") // Same offset as s1

    #Force Defaults

    Serialize fields even when they equal the default value:

    builder.set_force_defaults(true)
    builder.add_int32(0, 0, 0)  // Serialized even though value == default

    #JSON Conversion

    Convert FlatBuffers to JSON:

    ///|
    let json = @flatbuffers.JsonObjectBuilder::new()
      .add_string("name", table.get_string(0, ""))
      .add_int("hp", table.get_int32(1, 0))
      .to_json_string()
    // {"name": "Monster", "hp": 100}

    #Verifier

    Validate buffer integrity before reading:

    let buf = @flatbuffers.ByteBuffer::new(data)
    if buf.verify() {
      let root = @flatbuffers.Table::get_root(buf)
      // Safe to read
    }

    #Nested FlatBuffers

    Embed complete FlatBuffers inside other FlatBuffers:

    // Create nested buffer
    let inner_builder = @flatbuffers.Builder::new()
    // ... build inner ...

    // Embed in outer buffer
    let nested = outer_builder.create_nested_flatbuffer(inner_builder.to_fixed_array())
    outer_builder.add_offset(slot, nested)

    // Read nested
    let nested_root = table.get_nested_root(slot)

    #Supported Schema Features

    FeatureStatus
    TablesSupported
    StructsSupported
    EnumsSupported
    UnionsSupported
    VectorsSupported
    StringsSupported
    Nested FlatBuffersSupported
    Default valuesSupported
    File identifiersSupported
    Size-prefixed buffersSupported

    #Running Tests

    moon test

    #Running Benchmarks

    moon bench

    #License

    Apache-2.0

    #Acknowledgments

    Based on Google FlatBuffers.

    BaseType

    source
    pub enum BaseType {
      None
      UType
      Bool
      Byte
      UByte
      Short
      UShort
      Int
      UInt
      Long
      ULong
      Float
      Double
      String
      Vector
      Obj
      Union
      Array
      MaxBaseType
    } derive(Show)

    Base types for FlatBuffers fields

    BaseType::from_int

    source
    fn BaseType::from_int(value : Int) -> BaseType

    BaseType::to_int

    source
    fn BaseType::to_int(self : BaseType) -> Int

    Builder

    source
    pub struct Builder {
      buf : FixedArray[Byte]
      head : Int
      minalign : Int
      vtable : Array[Int]
      object_start : Int
      vtables : Array[Int]
      nested : Bool
      finished : Bool
      force_defaults : Bool
      string_cache : Map[String, Int]
    }

    Builder is used to construct FlatBuffers. Data is written backwards from the end of the buffer.

    Builder::add_bool

    source
    fn Builder::add_bool(self : Builder, slot_num : Int, val : Bool, default : Bool) -> Unit

    Add a boolean field

    Builder::add_float32

    source
    fn Builder::add_float32(self : Builder, slot_num : Int, val : Float, default : Float) -> Unit

    Add a Float32 field

    Builder::add_float64

    source
    fn Builder::add_float64(self : Builder, slot_num : Int, val : Double, default : Double) -> Unit

    Add a Float64 field

    Builder::add_int16

    source
    fn Builder::add_int16(self : Builder, slot_num : Int, val : Int, default : Int) -> Unit

    Add an Int16 field

    Builder::add_int32

    source
    fn Builder::add_int32(self : Builder, slot_num : Int, val : Int, default : Int) -> Unit

    Add an Int32 field

    Builder::add_int64

    source
    fn Builder::add_int64(self : Builder, slot_num : Int, val : Int64, default : Int64) -> Unit

    Add an Int64 field

    Builder::add_int8

    source
    fn Builder::add_int8(self : Builder, slot_num : Int, val : Int, default : Int) -> Unit

    Add an Int8 field

    Builder::add_offset

    source
    fn Builder::add_offset(self : Builder, slot_num : Int, val : Int) -> Unit

    Add an offset field (for strings, vectors, tables)

    Builder::add_struct

    source
    fn Builder::add_struct(self : Builder, slot_num : Int, val : Int) -> Unit

    Add a struct inline (structs are stored inline, not as offsets)

    Builder::add_uint16

    source
    fn Builder::add_uint16(self : Builder, slot_num : Int, val : Int, default : Int) -> Unit

    Add a UInt16 field

    Builder::add_uint32

    source
    fn Builder::add_uint32(self : Builder, slot_num : Int, val : UInt, default : UInt) -> Unit

    Add a UInt32 field

    Builder::add_uint64

    source
    fn Builder::add_uint64(self : Builder, slot_num : Int, val : UInt64, default : UInt64) -> Unit

    Add a UInt64 field

    Builder::add_uint8

    source
    fn Builder::add_uint8(self : Builder, slot_num : Int, val : Int, default : Int) -> Unit

    Add a UInt8 field

    Builder::add_union

    source
    fn Builder::add_union(self : Builder, type_slot : Int, type_value : Int, value_slot : Int, table_offset : Int) -> Unit

    Add a union to the object being built. type_slot: slot for the union type (ubyte) type_value: the union type value (0 = NONE, 1 = first type, etc.) value_slot: slot for the union value (offset) table_offset: offset to the table returned by end_object

    Builder::clear_string_cache

    source
    fn Builder::clear_string_cache(self : Builder) -> Unit

    Clear the shared string cache. Call this if you want to create duplicate strings intentionally.

    Builder::create_bool_vector

    source
    fn Builder::create_bool_vector(self : Builder, data : Array[Bool]) -> Int

    Create a vector of Bool values

    Builder::create_byte_vector

    source
    fn Builder::create_byte_vector(self : Builder, data : FixedArray[Byte]) -> Int

    Create a byte vector in the buffer

    Builder::create_float64_vector

    source
    fn Builder::create_float64_vector(self : Builder, data : Array[Double]) -> Int

    Create a vector of Float64 (Double) values

    Builder::create_int32_vector

    source
    fn Builder::create_int32_vector(self : Builder, data : Array[Int]) -> Int

    Create a vector of Int32 values

    Builder::create_int64_vector

    source
    fn Builder::create_int64_vector(self : Builder, data : Array[Int64]) -> Int

    Create a vector of Int64 values

    Builder::create_nested_flatbuffer

    source
    fn Builder::create_nested_flatbuffer(self : Builder, nested_bytes : FixedArray[Byte]) -> Int

    Create a nested FlatBuffer field from serialized bytes. The bytes should be a complete FlatBuffer (from Builder::to_bytes or similar). Returns an offset to use with add_offset.

    Builder::create_nested_flatbuffer_from_builder

    source
    fn Builder::create_nested_flatbuffer_from_builder(self : Builder, nested_builder : Builder) -> Int

    Create a nested FlatBuffer field from another builder's output. This is a convenience method that gets the bytes from the builder.

    Builder::create_offset_vector

    source
    fn Builder::create_offset_vector(self : Builder, offsets : Array[Int]) -> Int

    Create a vector of offsets (for tables/strings that were already created)

    Builder::create_shared_string

    source
    fn Builder::create_shared_string(self : Builder, s : String) -> Int

    Create a shared string in the buffer. If the same string was already created, returns the existing offset. This reduces buffer size when the same string appears multiple times.

    Builder::create_string

    source
    fn Builder::create_string(self : Builder, s : String) -> Int

    Create a string in the buffer

    Builder::create_string_vector

    source
    fn Builder::create_string_vector(self : Builder, strings : Array[String]) -> Int

    Create a vector of strings (convenience method)

    Builder::end_object

    source
    fn Builder::end_object(self : Builder) -> Int

    End building a table and return its offset

    Builder::end_vector

    source
    fn Builder::end_vector(self : Builder, num_elems : Int) -> Int

    End building a vector

    Builder::finish

    source
    fn Builder::finish(self : Builder, root_table : Int) -> Unit

    Finish building the buffer with root table

    Builder::finish_size_prefixed

    source
    fn Builder::finish_size_prefixed(self : Builder, root_table : Int) -> Unit

    Finish building the buffer with a size prefix

    Builder::finish_with_identifier

    source
    fn Builder::finish_with_identifier(self : Builder, root_table : Int, identifier : String) -> Unit

    Finish building the buffer with a file identifier

    Builder::get_force_defaults

    source
    fn Builder::get_force_defaults(self : Builder) -> Bool

    Get the current force_defaults setting

    Builder::new

    source
    fn Builder::new(initial_size? : Int) -> Builder

    Create a new Builder with initial capacity

    Builder::offset

    source
    fn Builder::offset(self : Builder) -> Int

    Get current offset from the end of the buffer

    Builder::place_bool

    source
    fn Builder::place_bool(self : Builder, val : Bool) -> Unit

    Place a bool at current position (for struct building)

    Builder::place_float32

    source
    fn Builder::place_float32(self : Builder, val : Float) -> Unit

    Place a Float32 at current position (for struct building)

    Builder::place_float64

    source
    fn Builder::place_float64(self : Builder, val : Double) -> Unit

    Place a Float64 at current position (for struct building)

    Builder::place_int16

    source
    fn Builder::place_int16(self : Builder, val : Int) -> Unit

    Place an Int16 at current position (for struct building)

    Builder::place_int32

    source
    fn Builder::place_int32(self : Builder, val : Int) -> Unit

    Place an Int32 at current position (for struct building)

    Builder::place_int64

    source
    fn Builder::place_int64(self : Builder, val : Int64) -> Unit

    Place an Int64 at current position (for struct building)

    Builder::place_int8

    source
    fn Builder::place_int8(self : Builder, val : Int) -> Unit

    Place an Int8 at current position (for struct building)

    Builder::place_uint16

    source
    fn Builder::place_uint16(self : Builder, val : Int) -> Unit

    Place a UInt16 at current position (for struct building)

    Builder::place_uint32

    source
    fn Builder::place_uint32(self : Builder, val : UInt) -> Unit

    Place a UInt32 at current position (for struct building)

    Builder::place_uint64

    source
    fn Builder::place_uint64(self : Builder, val : UInt64) -> Unit

    Place a UInt64 at current position (for struct building)

    Builder::place_uint8

    source
    fn Builder::place_uint8(self : Builder, val : Int) -> Unit

    Place a UInt8 at current position (for struct building)

    Builder::prep

    source
    fn Builder::prep(self : Builder, size : Int, additional : Int) -> Unit

    Prepare to write data with alignment

    Builder::prep_struct

    source
    fn Builder::prep_struct(self : Builder, size : Int, alignment : Int) -> Int

    Prepare to write a struct with the given size and alignment

    Builder::reset

    source
    fn Builder::reset(self : Builder) -> Unit

    Reset the builder to reuse it

    Builder::set_force_defaults

    source
    fn Builder::set_force_defaults(self : Builder, force : Bool) -> Unit

    Set whether to force serialization of default values. When true, fields are written even if they equal the default value. This is useful for debugging or when you need to see all fields.

    Builder::slot

    source
    fn Builder::slot(self : Builder, slot_num : Int) -> Unit

    Record a field slot

    Builder::start_object

    source
    fn Builder::start_object(self : Builder, num_fields : Int) -> Unit

    Start building a new table/object

    Builder::start_vector

    source
    fn Builder::start_vector(self : Builder, elem_size : Int, num_elems : Int, alignment : Int) -> Unit

    Start building a new vector

    Builder::struct_add_double

    source
    fn Builder::struct_add_double(self : Builder, val : Double) -> Unit

    Write a struct's double field

    Builder::struct_add_float

    source
    fn Builder::struct_add_float(self : Builder, val : Float) -> Unit

    Write a struct's float field (for inline struct building)

    Builder::struct_add_int16

    source
    fn Builder::struct_add_int16(self : Builder, val : Int) -> Unit

    Write a struct's int16 field

    Builder::struct_add_int32

    source
    fn Builder::struct_add_int32(self : Builder, val : Int) -> Unit

    Write a struct's int32 field

    Builder::struct_add_int64

    source
    fn Builder::struct_add_int64(self : Builder, val : Int64) -> Unit

    Write a struct's int64 field

    Builder::struct_add_int8

    source
    fn Builder::struct_add_int8(self : Builder, val : Int) -> Unit

    Write a struct's int8 field

    Builder::struct_pad

    source
    fn Builder::struct_pad(self : Builder, bytes : Int) -> Unit

    Pad struct to alignment

    Builder::to_bytes

    source
    fn Builder::to_bytes(self : Builder) -> Bytes

    Get the finished buffer as bytes

    Builder::to_fixed_array

    source
    fn Builder::to_fixed_array(self : Builder) -> FixedArray[Byte]

    Get the finished buffer as FixedArray

    Builder::write_byte

    source
    fn Builder::write_byte(self : Builder, val : Byte) -> Unit

    Write a byte at current position

    Builder::write_float32

    source
    fn Builder::write_float32(self : Builder, val : Float) -> Unit

    Write a Float32 (little-endian)

    Builder::write_float64

    source
    fn Builder::write_float64(self : Builder, val : Double) -> Unit

    Write a Float64/Double (little-endian)

    Builder::write_int16

    source
    fn Builder::write_int16(self : Builder, val : Int) -> Unit

    Write an Int16 (little-endian)

    Builder::write_int32

    source
    fn Builder::write_int32(self : Builder, val : Int) -> Unit

    Write an Int32 (little-endian)

    Builder::write_int64

    source
    fn Builder::write_int64(self : Builder, val : Int64) -> Unit

    Write an Int64 (little-endian)

    Builder::write_int8

    source
    fn Builder::write_int8(self : Builder, val : Int) -> Unit

    Write an Int8

    Builder::write_uint16

    source
    fn Builder::write_uint16(self : Builder, val : Int) -> Unit

    Write a UInt16 (little-endian)

    Builder::write_uint32

    source
    fn Builder::write_uint32(self : Builder, val : UInt) -> Unit

    Write a UInt32 (little-endian)

    Builder::write_uint64

    source
    fn Builder::write_uint64(self : Builder, val : UInt64) -> Unit

    Write a UInt64 (little-endian)

    Builder::write_uint8

    source
    fn Builder::write_uint8(self : Builder, val : Int) -> Unit

    Write a UInt8

    BuilderPool

    source
    pub struct BuilderPool {
      pool : Array[Builder]
      default_size : Int
    }

    Builder pool for reusing builders to reduce allocations. Use when building many FlatBuffers in a loop.

    BuilderPool::acquire

    source
    fn BuilderPool::acquire(self : BuilderPool) -> Builder

    Get a builder from the pool (or create a new one if empty)

    BuilderPool::new

    source
    fn BuilderPool::new(pool_size? : Int, default_buffer_size? : Int) -> BuilderPool

    Create a new BuilderPool

    BuilderPool::release

    source
    fn BuilderPool::release(self : BuilderPool, builder : Builder) -> Unit

    Return a builder to the pool

    ByteBuffer

    source
    pub struct ByteBuffer {
      data : FixedArray[Byte]
      pos : Int
    }

    ByteBuffer provides read access to a FlatBuffer binary. All multi-byte values are stored in little-endian format.

    ByteBuffer::from_bytes

    source
    fn ByteBuffer::from_bytes(bytes : Bytes) -> ByteBuffer

    Create a ByteBuffer from a Bytes object

    ByteBuffer::get_byte

    source
    fn ByteBuffer::get_byte(self : ByteBuffer, offset : Int) -> Byte

    Get a byte at the given offset

    ByteBuffer::get_identifier

    source
    fn ByteBuffer::get_identifier(self : ByteBuffer) -> String

    Get the file identifier from a buffer

    ByteBuffer::get_root_offset

    source
    fn ByteBuffer::get_root_offset(self : ByteBuffer) -> Int

    Get the root table offset from the buffer start

    ByteBuffer::has_identifier

    source
    fn ByteBuffer::has_identifier(self : ByteBuffer, identifier : String) -> Bool

    Check if buffer has a file identifier

    ByteBuffer::length

    source
    fn ByteBuffer::length(self : ByteBuffer) -> Int

    Get the underlying data length

    ByteBuffer::new

    source
    fn ByteBuffer::new(data : FixedArray[Byte]) -> ByteBuffer

    Create a new ByteBuffer from bytes

    ByteBuffer::read_float32

    source
    fn ByteBuffer::read_float32(self : ByteBuffer, offset : Int) -> Float

    Read a Float32 (little-endian) at offset

    ByteBuffer::read_float64

    source
    fn ByteBuffer::read_float64(self : ByteBuffer, offset : Int) -> Double

    Read a Float64/Double (little-endian) at offset

    ByteBuffer::read_int16

    source
    fn ByteBuffer::read_int16(self : ByteBuffer, offset : Int) -> Int

    Read an Int16 (little-endian) at offset

    ByteBuffer::read_int32

    source
    fn ByteBuffer::read_int32(self : ByteBuffer, offset : Int) -> Int

    Read an Int32 (little-endian) at offset

    ByteBuffer::read_int64

    source
    fn ByteBuffer::read_int64(self : ByteBuffer, offset : Int) -> Int64

    Read an Int64 (little-endian) at offset

    ByteBuffer::read_int8

    source
    fn ByteBuffer::read_int8(self : ByteBuffer, offset : Int) -> Int

    Read an Int8 (signed byte) at offset

    ByteBuffer::read_string

    source
    fn ByteBuffer::read_string(self : ByteBuffer, offset : Int) -> String

    Read a string at offset (FlatBuffer string format: length + UTF-8 data)

    ByteBuffer::read_uint16

    source
    fn ByteBuffer::read_uint16(self : ByteBuffer, offset : Int) -> Int

    Read a UInt16 (little-endian) at offset

    ByteBuffer::read_uint32

    source
    fn ByteBuffer::read_uint32(self : ByteBuffer, offset : Int) -> UInt

    Read a UInt32 (little-endian) at offset

    ByteBuffer::read_uint64

    source
    fn ByteBuffer::read_uint64(self : ByteBuffer, offset : Int) -> UInt64

    Read a UInt64 (little-endian) at offset

    ByteBuffer::read_uint8

    source
    fn ByteBuffer::read_uint8(self : ByteBuffer, offset : Int) -> Int

    Read a UInt8 (unsigned byte) at offset

    ByteBuffer::verify

    source
    fn ByteBuffer::verify(self : ByteBuffer) -> Bool

    Verify a buffer (convenience function)

    ByteBuffer::verify_size_prefixed

    source
    fn ByteBuffer::verify_size_prefixed(self : ByteBuffer) -> Bool

    Verify a size-prefixed buffer (convenience function)

    ByteBuffer::verify_with_identifier

    source
    fn ByteBuffer::verify_with_identifier(self : ByteBuffer, identifier : String) -> Bool

    Verify a buffer with identifier (convenience function)

    ByteBuffer::write_bool

    source
    fn ByteBuffer::write_bool(self : ByteBuffer, offset : Int, value : Bool) -> Unit

    Write a Bool at offset

    ByteBuffer::write_float32

    source
    fn ByteBuffer::write_float32(self : ByteBuffer, offset : Int, value : Float) -> Unit

    Write a Float32 (little-endian) at offset

    ByteBuffer::write_float64

    source
    fn ByteBuffer::write_float64(self : ByteBuffer, offset : Int, value : Double) -> Unit

    Write a Float64/Double (little-endian) at offset

    ByteBuffer::write_int16

    source
    fn ByteBuffer::write_int16(self : ByteBuffer, offset : Int, value : Int) -> Unit

    Write an Int16 (little-endian) at offset

    ByteBuffer::write_int32

    source
    fn ByteBuffer::write_int32(self : ByteBuffer, offset : Int, value : Int) -> Unit

    Write an Int32 (little-endian) at offset

    ByteBuffer::write_int64

    source
    fn ByteBuffer::write_int64(self : ByteBuffer, offset : Int, value : Int64) -> Unit

    Write an Int64 (little-endian) at offset

    ByteBuffer::write_int8

    source
    fn ByteBuffer::write_int8(self : ByteBuffer, offset : Int, value : Int) -> Unit

    Write an Int8 at offset

    ByteBuffer::write_uint16

    source
    fn ByteBuffer::write_uint16(self : ByteBuffer, offset : Int, value : Int) -> Unit

    Write a UInt16 (little-endian) at offset

    ByteBuffer::write_uint32

    source
    fn ByteBuffer::write_uint32(self : ByteBuffer, offset : Int, value : UInt) -> Unit

    Write a UInt32 (little-endian) at offset

    ByteBuffer::write_uint64

    source
    fn ByteBuffer::write_uint64(self : ByteBuffer, offset : Int, value : UInt64) -> Unit

    Write a UInt64 (little-endian) at offset

    ByteBuffer::write_uint8

    source
    fn ByteBuffer::write_uint8(self : ByteBuffer, offset : Int, value : Int) -> Unit

    Write a UInt8 at offset

    CachedTableReader

    source
    pub struct CachedTableReader {
      table : Table
      vtable_offset : Int
      vtable_size : Int
    }

    Pre-compute vtable offset once and use for multiple field reads

    CachedTableReader::get_bool

    source
    fn CachedTableReader::get_bool(self : CachedTableReader, field_slot : Int, default : Bool) -> Bool

    Fast bool read

    CachedTableReader::get_float64

    source
    fn CachedTableReader::get_float64(self : CachedTableReader, field_slot : Int, default : Double) -> Double

    Fast float64 read

    CachedTableReader::get_int32

    source
    fn CachedTableReader::get_int32(self : CachedTableReader, field_slot : Int, default : Int) -> Int

    Fast int32 read

    CachedTableReader::get_string

    source
    fn CachedTableReader::get_string(self : CachedTableReader, field_slot : Int, default : String) -> String

    Fast string read

    CachedTableReader::new

    source

    Create a cached table reader for faster repeated field access

    CallOptions

    source
    pub struct CallOptions {
      timeout_ms : Int?
      metadata : Metadata
      compression : Bool
    }

    Options for a gRPC call

    CallOptions::new

    source

    CallOptions::with_compression

    source
    fn CallOptions::with_compression(self : CallOptions, enabled : Bool) -> CallOptions

    CallOptions::with_metadata

    source
    fn CallOptions::with_metadata(self : CallOptions, metadata : Metadata) -> CallOptions

    CallOptions::with_timeout

    source
    fn CallOptions::with_timeout(self : CallOptions, ms : Int) -> CallOptions

    Channel

    source
    pub struct Channel {
      target : String
      state : ChannelState
      codec : FlatBuffersCodec
    }

    Abstract channel for gRPC communication

    Channel::connect

    source
    fn Channel::connect(self : Channel) -> Unit

    Channel::get_state

    source
    fn Channel::get_state(self : Channel) -> ChannelState

    Channel::get_target

    source
    fn Channel::get_target(self : Channel) -> String

    Channel::new

    source
    fn Channel::new(target : String) -> Channel

    Channel::shutdown

    source
    fn Channel::shutdown(self : Channel) -> Unit

    ChannelState

    source
    pub(all) enum ChannelState {
      Idle
      Connecting
      Ready
      TransientFailure
      Shutdown
    } derive(Eq, Show)

    Channel state

    ClientContext

    source
    pub struct ClientContext {
      metadata : Metadata
      response_headers : Metadata
      response_trailers : Metadata
      options : CallOptions
    }

    Context for client-side call handling

    ClientContext::add_metadata

    source
    fn ClientContext::add_metadata(self : ClientContext, key : String, value : String) -> ClientContext

    ClientContext::new

    source

    ClientContext::with_metadata

    source
    fn ClientContext::with_metadata(self : ClientContext, metadata : Metadata) -> ClientContext

    ClientContext::with_options

    source
    fn ClientContext::with_options(self : ClientContext, options : CallOptions) -> ClientContext

    ClientInterceptor

    source
    pub struct ClientInterceptor {
      on_request : (ClientContext, FixedArray[Byte]) -> FixedArray[Byte]
      on_response : (ClientContext, FixedArray[Byte]) -> FixedArray[Byte]
    }

    Client interceptor for modifying outgoing calls

    ClientInterceptor::new

    source
    fn ClientInterceptor::new(on_request : (ClientContext, FixedArray[Byte]) -> FixedArray[Byte], on_response : (ClientContext, FixedArray[Byte]) -> FixedArray[Byte]) -> ClientInterceptor

    ClientStream

    source
    pub struct ClientStream[T] {
      write_fn : (T) -> Bool
      close_fn : () -> Unit
      closed : Bool
    }

    Writable stream of messages

    ClientStream::close

    source
    fn[T] ClientStream::close(self : ClientStream[T]) -> Unit

    ClientStream::new

    source
    fn[T] ClientStream::new(write_fn : (T) -> Bool, close_fn : () -> Unit) -> ClientStream[T]

    ClientStream::write

    source
    fn[T] ClientStream::write(self : ClientStream[T], msg : T) -> Bool

    EnumAst

    source
    pub struct EnumAst {
      name : String
      base_type : ScalarType
      bit_flags : Bool
      values : Array[EnumValueAst]
    }

    Enum definition in schema

    EnumVal

    source
    pub struct EnumVal {
      buf : ByteBuffer
      pos : Int
    }

    An enumeration value

    EnumVal::name

    source
    fn EnumVal::name(self : EnumVal) -> String

    EnumVal::new

    source
    fn EnumVal::new(buf : ByteBuffer, pos : Int) -> EnumVal

    EnumVal::union_type

    source
    fn EnumVal::union_type(self : EnumVal) -> ReflectionType?

    Get union type (for union enum values)

    EnumVal::value

    source
    fn EnumVal::value(self : EnumVal) -> Int64

    EnumValueAst

    source
    pub struct EnumValueAst {
      name : String
      value : Int?
    }

    Enum value definition

    FieldAst

    source
    pub struct FieldAst {
      name : String
      field_type : FieldTypeAst
      default_value : String?
      deprecated : Bool
      id : Int?
    }

    Field definition in schema

    FieldDef

    source
    pub struct FieldDef {
      name : String
      slot : Int
      field_type : FieldType
      default_int : Int
      default_bool : Bool
    }

    Field definition for schema

    FieldDef::new

    source
    fn FieldDef::new(name : String, slot : Int, field_type : FieldType) -> FieldDef

    Create a new field definition

    FieldDef::with_default_bool

    source
    fn FieldDef::with_default_bool(name : String, slot : Int, default : Bool) -> FieldDef

    Create a field definition with bool default

    FieldDef::with_default_int

    source
    fn FieldDef::with_default_int(name : String, slot : Int, field_type : FieldType, default : Int) -> FieldDef

    Create a field definition with int default

    FieldType

    source
    pub enum FieldType {
      Bool
      Int8
      UInt8
      Int16
      UInt16
      Int32
      UInt32
      Int64
      UInt64
      Float32
      Float64
      String
      Vector(FieldType)
      Table
    }

    Field types supported by the Object API

    FieldType::bool

    source
    fn FieldType::bool() -> FieldType

    FieldType::float32

    source
    fn FieldType::float32() -> FieldType

    FieldType::float64

    source
    fn FieldType::float64() -> FieldType

    FieldType::int16

    source
    fn FieldType::int16() -> FieldType

    FieldType::int32

    source
    fn FieldType::int32() -> FieldType

    FieldType::int64

    source
    fn FieldType::int64() -> FieldType

    FieldType::int8

    source
    fn FieldType::int8() -> FieldType

    FieldType::string

    source
    fn FieldType::string() -> FieldType

    FieldType::table

    source
    fn FieldType::table() -> FieldType

    FieldType::uint16

    source
    fn FieldType::uint16() -> FieldType

    FieldType::uint32

    source
    fn FieldType::uint32() -> FieldType

    FieldType::uint64

    source
    fn FieldType::uint64() -> FieldType

    FieldType::uint8

    source
    fn FieldType::uint8() -> FieldType

    FieldType::vector

    source
    fn FieldType::vector(elem_type : FieldType) -> FieldType

    FieldTypeAst

    source
    pub enum FieldTypeAst {
      Scalar(ScalarType)
      String
      Vector(FieldTypeAst)
      Reference(String)
    }

    Field type in schema

    FlatBuffersCodec

    source
    pub struct FlatBuffersCodec {
      content_type : String
    }

    Codec for encoding/decoding FlatBuffers messages

    FlatBuffersCodec::decode

    source
    fn FlatBuffersCodec::decode(self : FlatBuffersCodec, data : FixedArray[Byte]) -> ByteBuffer

    Decode bytes to a ByteBuffer for reading

    FlatBuffersCodec::encode

    source
    fn FlatBuffersCodec::encode(self : FlatBuffersCodec, builder : Builder) -> FixedArray[Byte]

    Encode a FlatBuffers message to bytes

    FlatBuffersCodec::get_content_type

    source
    fn FlatBuffersCodec::get_content_type(self : FlatBuffersCodec) -> String

    Get the content type

    FlatBuffersCodec::new

    source

    FlexBuilder

    source
    pub struct FlexBuilder {
      buf : Array[Byte]
      stack : Array[FlexValue]
      string_pool : Map[String, Int]
      key_pool : Map[String, Int]
      finished : Bool
    }

    FlexBuffer builder

    FlexBuilder::add_blob

    source
    fn FlexBuilder::add_blob(self : FlexBuilder, data : FixedArray[Byte]) -> FlexBuilder

    Add a blob (binary data)

    FlexBuilder::add_bool

    source
    fn FlexBuilder::add_bool(self : FlexBuilder, val : Bool) -> FlexBuilder

    Add bool value

    FlexBuilder::add_float

    source
    fn FlexBuilder::add_float(self : FlexBuilder, val : Double) -> FlexBuilder

    Add float value

    FlexBuilder::add_int

    source
    fn FlexBuilder::add_int(self : FlexBuilder, val : Int64) -> FlexBuilder

    Add int value

    FlexBuilder::add_key

    source
    fn FlexBuilder::add_key(self : FlexBuilder, key : String) -> FlexBuilder

    Add a key (for maps) - keys are null-terminated strings without length prefix

    FlexBuilder::add_null

    source
    fn FlexBuilder::add_null(self : FlexBuilder) -> FlexBuilder

    Add null value

    FlexBuilder::add_string

    source
    fn FlexBuilder::add_string(self : FlexBuilder, s : String) -> FlexBuilder

    Add string value

    FlexBuilder::add_uint

    source
    fn FlexBuilder::add_uint(self : FlexBuilder, val : UInt64) -> FlexBuilder

    Add uint value

    FlexBuilder::end_float_vector

    source
    fn FlexBuilder::end_float_vector(self : FlexBuilder, count : Int) -> FlexBuilder

    End a typed vector of floats

    FlexBuilder::end_int_vector

    source
    fn FlexBuilder::end_int_vector(self : FlexBuilder, count : Int) -> FlexBuilder

    End a typed vector of ints

    FlexBuilder::end_map

    source
    fn FlexBuilder::end_map(self : FlexBuilder, count : Int) -> FlexBuilder

    End a map and push it onto the stack Map format: keys vector followed by values vector with type info Stack should contain: key1, val1, key2, val2, ... (pairs)

    FlexBuilder::end_vector

    source
    fn FlexBuilder::end_vector(self : FlexBuilder, count : Int) -> FlexBuilder

    End a vector and push it onto the stack

    FlexBuilder::finish

    source
    fn FlexBuilder::finish(self : FlexBuilder) -> FixedArray[Byte]

    Finish building and get the buffer

    FlexBuilder::new

    source

    Create a new FlexBuilder

    FlexRef

    source
    pub struct FlexRef {
      data : FixedArray[Byte]
      offset : Int
      parent_width : Int
      byte_width : Int
      flex_type : FlexType
    }

    A reference to a value in a FlexBuffer

    FlexRef::as_blob

    source
    fn FlexRef::as_blob(self : FlexRef) -> FixedArray[Byte]

    Get blob data

    FlexRef::as_bool

    source
    fn FlexRef::as_bool(self : FlexRef) -> Bool

    Get value as Bool

    FlexRef::as_double

    source
    fn FlexRef::as_double(self : FlexRef) -> Double

    Get value as Double

    FlexRef::as_int

    source
    fn FlexRef::as_int(self : FlexRef) -> Int

    Get value as Int

    FlexRef::as_int64

    source
    fn FlexRef::as_int64(self : FlexRef) -> Int64

    Get value as Int64

    FlexRef::as_string

    source
    fn FlexRef::as_string(self : FlexRef) -> String

    Get value as String

    FlexRef::as_uint64

    source
    fn FlexRef::as_uint64(self : FlexRef) -> UInt64

    Get value as UInt64

    FlexRef::from_bytes

    source
    fn FlexRef::from_bytes(data : FixedArray[Byte]) -> FlexRef

    Create a FlexRef from raw bytes

    FlexRef::get

    source
    fn FlexRef::get(self : FlexRef, index : Int) -> FlexRef

    Get element from vector by index

    FlexRef::get_by_key

    source
    fn FlexRef::get_by_key(self : FlexRef, key : String) -> FlexRef

    Get value from map by key

    FlexRef::get_type

    source
    fn FlexRef::get_type(self : FlexRef) -> FlexType

    Get the type of a FlexRef

    FlexRef::is_map

    source
    fn FlexRef::is_map(self : FlexRef) -> Bool

    Check if this is a Map

    FlexRef::is_null

    source
    fn FlexRef::is_null(self : FlexRef) -> Bool

    Check if value is null

    FlexRef::is_vector

    source
    fn FlexRef::is_vector(self : FlexRef) -> Bool

    Check if this is a Vector

    FlexRef::keys

    source
    fn FlexRef::keys(self : FlexRef) -> Array[String]

    Get all keys from a map

    FlexRef::length

    source
    fn FlexRef::length(self : FlexRef) -> Int

    Get vector length (for Vector, Map, typed vectors)

    FlexType

    source
    pub enum FlexType {
      Null
      Int
      UInt
      Float
      Key
      String
      IndirectInt
      IndirectUInt
      IndirectFloat
      Map
      Vector
      VectorInt
      VectorUInt
      VectorFloat
      VectorKey
      VectorString
      VectorInt2
      VectorUInt2
      VectorFloat2
      VectorInt3
      VectorUInt3
      VectorFloat3
      VectorInt4
      VectorUInt4
      VectorFloat4
      Blob
      Bool
      VectorBool
    } derive(Show)

    FlexBuffer value types

    FlexType::from_int

    source
    fn FlexType::from_int(value : Int) -> FlexType

    FlexType::is_fixed_typed_vector

    source
    fn FlexType::is_fixed_typed_vector(self : FlexType) -> Bool

    Check if type is a fixed typed vector

    FlexType::is_inline

    source
    fn FlexType::is_inline(self : FlexType) -> Bool

    Check if type is inline (stored directly in the data)

    FlexType::is_typed_vector

    source
    fn FlexType::is_typed_vector(self : FlexType) -> Bool

    Check if type is a typed vector

    FlexType::to_int

    source
    fn FlexType::to_int(self : FlexType) -> Int

    FlexValue

    source
    pub struct FlexValue {
      flex_type : FlexType
      min_bit_width : Int
      value_int : Int64
      value_uint : UInt64
      value_float : Double
      offset : Int
    }

    A value to be written to a FlexBuffer

    FlexValue::blob_ref

    source
    fn FlexValue::blob_ref(offset : Int) -> FlexValue

    FlexValue::bool_val

    source
    fn FlexValue::bool_val(val : Bool) -> FlexValue

    FlexValue::float

    source
    fn FlexValue::float(val : Double) -> FlexValue

    FlexValue::int

    source
    fn FlexValue::int(val : Int64) -> FlexValue

    FlexValue::key_ref

    source
    fn FlexValue::key_ref(offset : Int, min_bit_width : Int) -> FlexValue

    FlexValue::null

    source
    fn FlexValue::null() -> FlexValue

    FlexValue::string_ref

    source
    fn FlexValue::string_ref(offset : Int, min_bit_width : Int) -> FlexValue

    FlexValue::uint

    source
    fn FlexValue::uint(val : UInt64) -> FlexValue

    FlexValue::vector_ref

    source
    fn FlexValue::vector_ref(offset : Int, flex_type : FlexType, min_bit_width : Int) -> FlexValue

    GrpcError

    source
    pub struct GrpcError {
      status : GrpcStatus
      message : String
      metadata : Metadata
    }

    gRPC error with status and message
    impl Show for GrpcError

    GrpcError::new

    source
    fn GrpcError::new(status : GrpcStatus, message : String) -> GrpcError

    GrpcError::with_metadata

    source
    fn GrpcError::with_metadata(status : GrpcStatus, message : String, metadata : Metadata) -> GrpcError

    GrpcStatus

    source
    pub(all) enum GrpcStatus {
      Ok
      Cancelled
      Unknown
      InvalidArgument
      DeadlineExceeded
      NotFound
      AlreadyExists
      PermissionDenied
      ResourceExhausted
      FailedPrecondition
      Aborted
      OutOfRange
      Unimplemented
      Internal
      Unavailable
      DataLoss
      Unauthenticated
    } derive(Eq, Show)

    gRPC status codes

    GrpcStatus::code

    source
    fn GrpcStatus::code(self : GrpcStatus) -> Int

    GrpcStatus::from_code

    source
    fn GrpcStatus::from_code(code : Int) -> GrpcStatus

    HealthService

    source
    pub struct HealthService {
      status_map : Array[(String, ServingStatus)]
    }

    Health check service

    HealthService::check

    source
    fn HealthService::check(self : HealthService, service : String) -> ServingStatus

    HealthService::clear_status

    source
    fn HealthService::clear_status(self : HealthService, service : String) -> Unit

    HealthService::new

    source

    HealthService::set_status

    source
    fn HealthService::set_status(self : HealthService, service : String, status : ServingStatus) -> Unit

    JsonObjectBuilder

    source
    pub struct JsonObjectBuilder {
      fields : Array[(String, JsonValue)]
    }

    JSON object builder for convenient construction

    JsonObjectBuilder::add_array

    source
    fn JsonObjectBuilder::add_array(self : JsonObjectBuilder, name : String, value : Array[JsonValue]) -> JsonObjectBuilder

    Add an array field

    JsonObjectBuilder::add_bool

    source
    fn JsonObjectBuilder::add_bool(self : JsonObjectBuilder, name : String, value : Bool) -> JsonObjectBuilder

    Add a boolean field

    JsonObjectBuilder::add_float

    source
    fn JsonObjectBuilder::add_float(self : JsonObjectBuilder, name : String, value : Double) -> JsonObjectBuilder

    Add a float field

    JsonObjectBuilder::add_int

    source
    fn JsonObjectBuilder::add_int(self : JsonObjectBuilder, name : String, value : Int) -> JsonObjectBuilder

    Add an integer field

    JsonObjectBuilder::add_int64

    source
    fn JsonObjectBuilder::add_int64(self : JsonObjectBuilder, name : String, value : Int64) -> JsonObjectBuilder

    Add an Int64 field

    JsonObjectBuilder::add_null

    source
    fn JsonObjectBuilder::add_null(self : JsonObjectBuilder, name : String) -> JsonObjectBuilder

    Add a null field

    JsonObjectBuilder::add_object

    source
    fn JsonObjectBuilder::add_object(self : JsonObjectBuilder, name : String, value : JsonObjectBuilder) -> JsonObjectBuilder

    Add a nested object field

    JsonObjectBuilder::add_string

    source
    fn JsonObjectBuilder::add_string(self : JsonObjectBuilder, name : String, value : String) -> JsonObjectBuilder

    Add a string field

    JsonObjectBuilder::add_uint

    source
    fn JsonObjectBuilder::add_uint(self : JsonObjectBuilder, name : String, value : UInt) -> JsonObjectBuilder

    Add a UInt field

    JsonObjectBuilder::add_uint64

    source
    fn JsonObjectBuilder::add_uint64(self : JsonObjectBuilder, name : String, value : UInt64) -> JsonObjectBuilder

    Add a UInt64 field

    JsonObjectBuilder::add_value

    source
    fn JsonObjectBuilder::add_value(self : JsonObjectBuilder, name : String, value : JsonValue) -> JsonObjectBuilder

    Add a JsonValue field

    JsonObjectBuilder::build

    source

    Build the JSON value

    JsonObjectBuilder::new

    source

    Create a new JSON object builder

    JsonObjectBuilder::to_json_string

    source
    fn JsonObjectBuilder::to_json_string(self : JsonObjectBuilder) -> String

    Convert to JSON string

    JsonValue

    source
    pub enum JsonValue {
      Null
      Bool(Bool)
      Int(Int)
      Int64(Int64)
      UInt(UInt)
      UInt64(UInt64)
      Float(Double)
      String(String)
      Array(Array[JsonValue])
      Object(Array[(String, JsonValue)])
    }

    JSON value types

    JsonValue::array

    source
    fn JsonValue::array(arr : Array[JsonValue]) -> JsonValue

    Create an array JSON value

    JsonValue::bool

    source
    fn JsonValue::bool(b : Bool) -> JsonValue

    Create a boolean JSON value

    JsonValue::float

    source
    fn JsonValue::float(f : Double) -> JsonValue

    Create a float JSON value

    JsonValue::int

    source
    fn JsonValue::int(n : Int) -> JsonValue

    Create an integer JSON value

    JsonValue::int64

    source
    fn JsonValue::int64(n : Int64) -> JsonValue

    Create an Int64 JSON value

    JsonValue::null

    source
    fn JsonValue::null() -> JsonValue

    Create a null JSON value

    JsonValue::object

    source
    fn JsonValue::object(fields : Array[(String, JsonValue)]) -> JsonValue

    Create an object JSON value

    JsonValue::string

    source
    fn JsonValue::string(s : String) -> JsonValue

    Create a string JSON value

    JsonValue::to_string

    source
    fn JsonValue::to_string(self : JsonValue) -> String

    Convert a JsonValue to a JSON string

    JsonValue::uint

    source
    fn JsonValue::uint(n : UInt) -> JsonValue

    Create a UInt JSON value

    JsonValue::uint64

    source
    fn JsonValue::uint64(n : UInt64) -> JsonValue

    Create a UInt64 JSON value

    KeyValue

    source
    pub struct KeyValue {
      buf : ByteBuffer
      pos : Int
    }

    Key-value pair for attributes

    KeyValue::key

    source
    fn KeyValue::key(self : KeyValue) -> String

    KeyValue::new

    source
    fn KeyValue::new(buf : ByteBuffer, pos : Int) -> KeyValue

    KeyValue::value

    source
    fn KeyValue::value(self : KeyValue) -> String

    MessageFrame

    source
    pub struct MessageFrame {
      compressed : Bool
      length : Int
      data : FixedArray[Byte]
    }

    gRPC message frame (Length-Prefixed Message)

    MessageFrame::decode

    source
    fn MessageFrame::decode(data : FixedArray[Byte]) -> MessageFrame?

    Decode frame from wire format

    MessageFrame::encode

    source
    fn MessageFrame::encode(self : MessageFrame) -> FixedArray[Byte]

    Encode frame to wire format

    MessageFrame::new

    source
    fn MessageFrame::new(data : FixedArray[Byte], compressed : Bool) -> MessageFrame

    Metadata

    source
    pub struct Metadata {
      entries : Array[(String, String)]
    }

    Key-value metadata for gRPC calls

    Metadata::add

    source
    fn Metadata::add(self : Metadata, key : String, value : String) -> Metadata

    Metadata::get

    source
    fn Metadata::get(self : Metadata, key : String) -> String?

    Metadata::get_all

    source
    fn Metadata::get_all(self : Metadata, key : String) -> Array[String]

    Metadata::is_empty

    source
    fn Metadata::is_empty(self : Metadata) -> Bool

    Metadata::len

    source
    fn Metadata::len(self : Metadata) -> Int

    Metadata::new

    source
    fn Metadata::new() -> Metadata

    Metadata::remove

    source
    fn Metadata::remove(self : Metadata, key : String) -> Metadata

    MethodDescriptor

    source
    pub struct MethodDescriptor {
      service_name : String
      method_name : String
      method_type : MethodType
      full_path : String
    } derive(Show)

    Method descriptor

    MethodDescriptor::new

    source
    fn MethodDescriptor::new(service_name : String, method_name : String, method_type : MethodType) -> MethodDescriptor

    MethodType

    source
    pub(all) enum MethodType {
      Unary
      ServerStreaming
      ClientStreaming
      BidirectionalStreaming
    } derive(Eq, Show)

    Method type for gRPC

    ObjectBuilder

    source
    pub struct ObjectBuilder {
      builder : Builder
      schema : TableSchema
      string_offsets : Map[String, Int]
      vector_offsets : Map[String, Int]
      table_offsets : Map[String, Int]
    }

    Object builder wraps a Builder with schema information

    ObjectBuilder::add_bool

    source
    fn ObjectBuilder::add_bool(self : ObjectBuilder, name : String, value : Bool) -> ObjectBuilder

    Add a boolean field

    ObjectBuilder::add_int16

    source
    fn ObjectBuilder::add_int16(self : ObjectBuilder, name : String, value : Int) -> ObjectBuilder

    Add an int16 field

    ObjectBuilder::add_int32

    source
    fn ObjectBuilder::add_int32(self : ObjectBuilder, name : String, value : Int) -> ObjectBuilder

    Add an int32 field

    ObjectBuilder::add_uint8

    source
    fn ObjectBuilder::add_uint8(self : ObjectBuilder, name : String, value : Int) -> ObjectBuilder

    Add a uint8 field

    ObjectBuilder::end

    source
    fn ObjectBuilder::end(self : ObjectBuilder) -> Int

    End the object and return its offset

    ObjectBuilder::finish_buffer

    source
    fn ObjectBuilder::finish_buffer(self : ObjectBuilder) -> Unit

    Convenience method to finish the buffer with this object as root

    ObjectBuilder::finish_fields

    source
    fn ObjectBuilder::finish_fields(self : ObjectBuilder) -> Unit

    Finish adding scalar fields and add pre-created offsets

    ObjectBuilder::get_builder

    source
    fn ObjectBuilder::get_builder(self : ObjectBuilder) -> Builder

    Get the underlying builder

    ObjectBuilder::new

    source
    fn ObjectBuilder::new(builder : Builder, schema : TableSchema) -> ObjectBuilder

    Create an object builder

    ObjectBuilder::set_int32_vector

    source
    fn ObjectBuilder::set_int32_vector(self : ObjectBuilder, name : String, values : Array[Int]) -> ObjectBuilder

    Set an int32 vector field (must be called before start_object)

    ObjectBuilder::set_shared_string

    source
    fn ObjectBuilder::set_shared_string(self : ObjectBuilder, name : String, value : String) -> ObjectBuilder

    Set a shared string field (must be called before start_object)

    ObjectBuilder::set_string

    source
    fn ObjectBuilder::set_string(self : ObjectBuilder, name : String, value : String) -> ObjectBuilder

    Set a string field (must be called before start_object)

    ObjectBuilder::set_table_offset

    source
    fn ObjectBuilder::set_table_offset(self : ObjectBuilder, name : String, offset : Int) -> ObjectBuilder

    Set a nested table offset (from another ObjectBuilder)

    ObjectBuilder::start

    source
    fn ObjectBuilder::start(self : ObjectBuilder) -> Unit

    Start building the object

    ObjectReader

    source
    pub struct ObjectReader {
      table : Table
      schema : TableSchema
    }

    Object reader wraps a Table with schema information

    ObjectReader::get_bool

    source
    fn ObjectReader::get_bool(self : ObjectReader, name : String) -> Bool

    Get a boolean field by name

    ObjectReader::get_int16

    source
    fn ObjectReader::get_int16(self : ObjectReader, name : String) -> Int

    Get an int16 field by name

    ObjectReader::get_int32

    source
    fn ObjectReader::get_int32(self : ObjectReader, name : String) -> Int

    Get an int32 field by name

    ObjectReader::get_string

    source
    fn ObjectReader::get_string(self : ObjectReader, name : String) -> String

    Get a string field by name

    ObjectReader::get_table

    source
    fn ObjectReader::get_table(self : ObjectReader) -> Table

    Get the underlying table

    ObjectReader::get_table_field

    source
    fn ObjectReader::get_table_field(self : ObjectReader, name : String) -> Table?

    Get a nested table by name

    ObjectReader::get_uint8

    source
    fn ObjectReader::get_uint8(self : ObjectReader, name : String) -> Int

    Get a uint8 field by name

    ObjectReader::get_vector_length

    source
    fn ObjectReader::get_vector_length(self : ObjectReader, name : String) -> Int

    Get vector length by field name

    ObjectReader::new

    source
    fn ObjectReader::new(table : Table, schema : TableSchema) -> ObjectReader

    Create an object reader

    ObjectReader::to_json

    source
    fn ObjectReader::to_json(self : ObjectReader) -> JsonValue

    Convert to JSON using schema

    ReflectionEnum

    source
    pub struct ReflectionEnum {
      buf : ByteBuffer
      pos : Int
    }

    An enumeration type definition

    ReflectionEnum::is_union

    source
    fn ReflectionEnum::is_union(self : ReflectionEnum) -> Bool

    ReflectionEnum::name

    source
    fn ReflectionEnum::name(self : ReflectionEnum) -> String

    ReflectionEnum::new

    source
    fn ReflectionEnum::new(buf : ByteBuffer, pos : Int) -> ReflectionEnum

    ReflectionEnum::underlying_type

    source
    fn ReflectionEnum::underlying_type(self : ReflectionEnum) -> ReflectionType?

    ReflectionEnum::values

    source
    fn ReflectionEnum::values(self : ReflectionEnum, index : Int) -> EnumVal?

    ReflectionEnum::values_length

    source
    fn ReflectionEnum::values_length(self : ReflectionEnum) -> Int

    ReflectionField

    source
    pub struct ReflectionField {
      buf : ByteBuffer
      pos : Int
    }

    A field definition in a table or struct

    ReflectionField::default_integer

    source
    fn ReflectionField::default_integer(self : ReflectionField) -> Int64

    ReflectionField::default_real

    source
    fn ReflectionField::default_real(self : ReflectionField) -> Double

    ReflectionField::deprecated

    source
    fn ReflectionField::deprecated(self : ReflectionField) -> Bool

    ReflectionField::field_type

    source

    ReflectionField::id

    source
    fn ReflectionField::id(self : ReflectionField) -> Int

    ReflectionField::key

    source
    fn ReflectionField::key(self : ReflectionField) -> Bool

    ReflectionField::name

    source
    fn ReflectionField::name(self : ReflectionField) -> String

    ReflectionField::new

    source
    fn ReflectionField::new(buf : ByteBuffer, pos : Int) -> ReflectionField

    ReflectionField::offset

    source
    fn ReflectionField::offset(self : ReflectionField) -> Int

    ReflectionField::optional

    source
    fn ReflectionField::optional(self : ReflectionField) -> Bool

    ReflectionField::required

    source
    fn ReflectionField::required(self : ReflectionField) -> Bool

    ReflectionObject

    source
    pub struct ReflectionObject {
      buf : ByteBuffer
      pos : Int
    }

    A table or struct definition

    ReflectionObject::bytesize

    source
    fn ReflectionObject::bytesize(self : ReflectionObject) -> Int

    ReflectionObject::field_by_name

    source
    fn ReflectionObject::field_by_name(self : ReflectionObject, name : String) -> ReflectionField?

    Find a field by name

    ReflectionObject::fields

    source
    fn ReflectionObject::fields(self : ReflectionObject, index : Int) -> ReflectionField?

    ReflectionObject::fields_length

    source
    fn ReflectionObject::fields_length(self : ReflectionObject) -> Int

    ReflectionObject::is_struct

    source
    fn ReflectionObject::is_struct(self : ReflectionObject) -> Bool

    ReflectionObject::minalign

    source
    fn ReflectionObject::minalign(self : ReflectionObject) -> Int

    ReflectionObject::name

    source
    fn ReflectionObject::name(self : ReflectionObject) -> String

    ReflectionObject::new

    source
    fn ReflectionObject::new(buf : ByteBuffer, pos : Int) -> ReflectionObject

    ReflectionSchema

    source
    pub struct ReflectionSchema {
      buf : ByteBuffer
    }

    The root schema definition

    ReflectionSchema::enum_by_name

    source
    fn ReflectionSchema::enum_by_name(self : ReflectionSchema, name : String) -> ReflectionEnum?

    Find an enum by name

    ReflectionSchema::enums

    source
    fn ReflectionSchema::enums(self : ReflectionSchema, index : Int) -> ReflectionEnum?

    Get an enum by index

    ReflectionSchema::enums_length

    source
    fn ReflectionSchema::enums_length(self : ReflectionSchema) -> Int

    Get the number of enums

    ReflectionSchema::file_ext

    source
    fn ReflectionSchema::file_ext(self : ReflectionSchema) -> String

    Get the file extension

    ReflectionSchema::file_ident

    source
    fn ReflectionSchema::file_ident(self : ReflectionSchema) -> String

    Get the file identifier

    ReflectionSchema::from_bytes

    source
    fn ReflectionSchema::from_bytes(data : FixedArray[Byte]) -> ReflectionSchema

    Parse a binary schema (.bfbs) file

    ReflectionSchema::is_valid

    source
    fn ReflectionSchema::is_valid(self : ReflectionSchema) -> Bool

    Check if this is a valid binary schema

    ReflectionSchema::object_by_name

    source
    fn ReflectionSchema::object_by_name(self : ReflectionSchema, name : String) -> ReflectionObject?

    Find an object by name

    ReflectionSchema::objects

    source
    fn ReflectionSchema::objects(self : ReflectionSchema, index : Int) -> ReflectionObject?

    Get an object by index

    ReflectionSchema::objects_length

    source
    fn ReflectionSchema::objects_length(self : ReflectionSchema) -> Int

    Get the number of objects (tables/structs)

    ReflectionSchema::root_table

    source

    Get the root table type

    ReflectionService

    source
    pub struct ReflectionService {
      services : Array[ServiceDescriptor]
    }

    Service for gRPC reflection

    ReflectionService::get_service

    source
    fn ReflectionService::get_service(self : ReflectionService, name : String) -> ServiceDescriptor?

    ReflectionService::list_services

    source
    fn ReflectionService::list_services(self : ReflectionService) -> Array[String]

    ReflectionService::new

    source

    ReflectionService::register

    source
    fn ReflectionService::register(self : ReflectionService, service : ServiceDescriptor) -> Unit

    ReflectionType

    source
    pub struct ReflectionType {
      buf : ByteBuffer
      pos : Int
    }

    Type information for a field

    ReflectionType::base_size

    source
    fn ReflectionType::base_size(self : ReflectionType) -> Int

    Get base size (in bytes)

    ReflectionType::base_type

    source
    fn ReflectionType::base_type(self : ReflectionType) -> BaseType

    Get the base type

    ReflectionType::element

    source
    fn ReflectionType::element(self : ReflectionType) -> BaseType

    Get the element type (for vectors and arrays)

    ReflectionType::element_size

    source
    fn ReflectionType::element_size(self : ReflectionType) -> Int

    Get element size (for vectors)

    ReflectionType::fixed_length

    source
    fn ReflectionType::fixed_length(self : ReflectionType) -> Int

    Get fixed length (for Array type)

    ReflectionType::index

    source
    fn ReflectionType::index(self : ReflectionType) -> Int

    Get the index to the object (for Obj type)

    ReflectionType::new

    source
    fn ReflectionType::new(buf : ByteBuffer, pos : Int) -> ReflectionType

    ScalarType

    source
    pub enum ScalarType {
      Bool
      Byte
      UByte
      Short
      UShort
      Int
      UInt
      Long
      ULong
      Float
      Double
    }

    Scalar types in FlatBuffers

    ScalarType::default_value

    source
    fn ScalarType::default_value(self : ScalarType) -> String

    ScalarType::from_string

    source
    fn ScalarType::from_string(s : String) -> ScalarType?

    ScalarType::to_builder_method

    source
    fn ScalarType::to_builder_method(self : ScalarType) -> String

    ScalarType::to_getter_method

    source
    fn ScalarType::to_getter_method(self : ScalarType) -> String

    ScalarType::to_moonbit_type

    source
    fn ScalarType::to_moonbit_type(self : ScalarType) -> String

    SchemaAst

    source
    pub struct SchemaAst {
      ns : String
      enums : Array[EnumAst]
      structs : Array[StructAst]
      tables : Array[TableAst]
      unions : Array[UnionAst]
      root_type : String?
    }

    Schema definition

    SchemaAst::new

    source
    fn SchemaAst::new() -> SchemaAst

    ServerContext

    source
    pub struct ServerContext {
      metadata : Metadata
      response_headers : Metadata
      response_trailers : Metadata
      deadline : Int64?
      peer : String
      cancelled : Bool
    }

    Context for server-side call handling

    ServerContext::is_cancelled

    source
    fn ServerContext::is_cancelled(self : ServerContext) -> Bool

    ServerContext::new

    source

    ServerContext::set_header

    source
    fn ServerContext::set_header(self : ServerContext, key : String, value : String) -> Unit

    ServerContext::set_trailer

    source
    fn ServerContext::set_trailer(self : ServerContext, key : String, value : String) -> Unit

    ServerContext::with_deadline

    source
    fn ServerContext::with_deadline(self : ServerContext, deadline : Int64) -> ServerContext

    ServerContext::with_metadata

    source
    fn ServerContext::with_metadata(self : ServerContext, metadata : Metadata) -> ServerContext

    ServerContext::with_peer

    source
    fn ServerContext::with_peer(self : ServerContext, peer : String) -> ServerContext

    ServerInterceptor

    source
    pub struct ServerInterceptor {
      on_request : (ServerContext, FixedArray[Byte]) -> FixedArray[Byte]
      on_response : (ServerContext, FixedArray[Byte]) -> FixedArray[Byte]
    }

    Server interceptor for handling incoming calls

    ServerInterceptor::new

    source
    fn ServerInterceptor::new(on_request : (ServerContext, FixedArray[Byte]) -> FixedArray[Byte], on_response : (ServerContext, FixedArray[Byte]) -> FixedArray[Byte]) -> ServerInterceptor

    ServerStream

    source
    pub struct ServerStream[T] {
      read_fn : () -> T?
      done : Bool
    }

    Readable stream of messages

    ServerStream::new

    source
    fn[T] ServerStream::new(read_fn : () -> T?) -> ServerStream[T]

    ServerStream::read

    source
    fn[T] ServerStream::read(self : ServerStream[T]) -> T?

    ServiceDescriptor

    source
    pub struct ServiceDescriptor {
      name : String
      methods : Array[MethodDescriptor]
    } derive(Show)

    Descriptor for a gRPC service

    ServiceDescriptor::add_method

    source

    ServiceDescriptor::get_method

    source
    fn ServiceDescriptor::get_method(self : ServiceDescriptor, name : String) -> MethodDescriptor?

    ServiceDescriptor::new

    source
    fn ServiceDescriptor::new(name : String) -> ServiceDescriptor

    ServingStatus

    source
    pub(all) enum ServingStatus {
      Unknown
      Serving
      NotServing
      ServiceUnknown
    } derive(Eq, Show)

    Health check status

    ServingStatus::to_int

    source
    fn ServingStatus::to_int(self : ServingStatus) -> Int

    StructAst

    source
    pub struct StructAst {
      name : String
      fields : Array[FieldAst]
    }

    Struct definition in schema (fixed-size)

    Table

    source
    pub struct Table {
      buf : ByteBuffer
      pos : Int
    }

    Table provides read access to a FlatBuffer table. It handles vtable lookups and field access.

    Table::get_bool

    source
    fn Table::get_bool(self : Table, field_slot : Int, default : Bool) -> Bool

    Get a boolean field

    Table::get_bool_optional

    source
    fn Table::get_bool_optional(self : Table, field_slot : Int) -> Bool?

    Get an optional boolean field (returns None if not present)

    Table::get_float32

    source
    fn Table::get_float32(self : Table, field_slot : Int, default : Float) -> Float

    Get a Float32 field

    Table::get_float32_optional

    source
    fn Table::get_float32_optional(self : Table, field_slot : Int) -> Float?

    Get an optional Float32 field

    Table::get_float64

    source
    fn Table::get_float64(self : Table, field_slot : Int, default : Double) -> Double

    Get a Float64 field

    Table::get_float64_optional

    source
    fn Table::get_float64_optional(self : Table, field_slot : Int) -> Double?

    Get an optional Float64 field

    Table::get_int16

    source
    fn Table::get_int16(self : Table, field_slot : Int, default : Int) -> Int

    Get an Int16 field

    Table::get_int16_optional

    source
    fn Table::get_int16_optional(self : Table, field_slot : Int) -> Int?

    Get an optional Int16 field

    Table::get_int32

    source
    fn Table::get_int32(self : Table, field_slot : Int, default : Int) -> Int

    Get an Int32 field

    Table::get_int32_optional

    source
    fn Table::get_int32_optional(self : Table, field_slot : Int) -> Int?

    Get an optional Int32 field

    Table::get_int64

    source
    fn Table::get_int64(self : Table, field_slot : Int, default : Int64) -> Int64

    Get an Int64 field

    Table::get_int64_optional

    source
    fn Table::get_int64_optional(self : Table, field_slot : Int) -> Int64?

    Get an optional Int64 field

    Table::get_int8

    source
    fn Table::get_int8(self : Table, field_slot : Int, default : Int) -> Int

    Get an Int8 field

    Table::get_int8_optional

    source
    fn Table::get_int8_optional(self : Table, field_slot : Int) -> Int?

    Get an optional Int8 field

    Table::get_nested_flatbuffer

    source
    fn Table::get_nested_flatbuffer(self : Table, field_slot : Int) -> ByteBuffer?

    Get a nested FlatBuffer from a table field. Returns a ByteBuffer that can be used to read the nested data. Returns None if the field is not present.

    Table::get_nested_root

    source
    fn Table::get_nested_root(self : Table, field_slot : Int) -> Table?

    Get a nested FlatBuffer's root table directly. Returns None if the field is not present.

    Table::get_root

    source
    fn Table::get_root(buf : ByteBuffer) -> Table

    Get the root table from a buffer

    Table::get_root_size_prefixed

    source
    fn Table::get_root_size_prefixed(buf : ByteBuffer) -> Table

    Get root table from a size-prefixed buffer

    Table::get_string

    source
    fn Table::get_string(self : Table, field_slot : Int, default : String) -> String

    Get a string field

    Table::get_string_optional

    source
    fn Table::get_string_optional(self : Table, field_slot : Int) -> String?

    Get an optional string field

    Table::get_struct

    source
    fn Table::get_struct(self : Table, field_slot : Int) -> Int?

    Get a struct field (returns the position in buffer where struct data starts)

    Table::get_table

    source
    fn Table::get_table(self : Table, field_slot : Int) -> Table?

    Get a nested table field

    Table::get_table_offset

    source
    fn Table::get_table_offset(self : Table, field_slot : Int) -> Int?

    Get the offset to a nested table field

    Table::get_uint16

    source
    fn Table::get_uint16(self : Table, field_slot : Int, default : Int) -> Int

    Get a UInt16 field

    Table::get_uint16_optional

    source
    fn Table::get_uint16_optional(self : Table, field_slot : Int) -> Int?

    Get an optional UInt16 field

    Table::get_uint32

    source
    fn Table::get_uint32(self : Table, field_slot : Int, default : UInt) -> UInt

    Get a UInt32 field

    Table::get_uint32_optional

    source
    fn Table::get_uint32_optional(self : Table, field_slot : Int) -> UInt?

    Get an optional UInt32 field

    Table::get_uint64

    source
    fn Table::get_uint64(self : Table, field_slot : Int, default : UInt64) -> UInt64

    Get a UInt64 field

    Table::get_uint64_optional

    source
    fn Table::get_uint64_optional(self : Table, field_slot : Int) -> UInt64?

    Get an optional UInt64 field

    Table::get_uint8

    source
    fn Table::get_uint8(self : Table, field_slot : Int, default : Int) -> Int

    Get a UInt8 field

    Table::get_uint8_optional

    source
    fn Table::get_uint8_optional(self : Table, field_slot : Int) -> Int?

    Get an optional UInt8 field

    Table::get_union_table

    source
    fn Table::get_union_table(self : Table, value_slot : Int) -> Table?

    Get a union table from the value slot Returns None if the union type is NONE (0) or offset is invalid

    Table::get_union_type

    source
    fn Table::get_union_type(self : Table, type_slot : Int) -> Int

    Get the union type from a table

    Table::get_vector_byte

    source
    fn Table::get_vector_byte(self : Table, field_slot : Int, index : Int) -> Byte

    Get a byte element from a vector

    Table::get_vector_bytes_slice

    source
    fn Table::get_vector_bytes_slice(self : Table, field_slot : Int) -> FixedArray[Byte]

    Get entire byte vector as FixedArray (optimized with blit)

    Table::get_vector_float64

    source
    fn Table::get_vector_float64(self : Table, field_slot : Int, index : Int) -> Double

    Get a float64 element from a vector

    Table::get_vector_float64_batch

    source
    fn Table::get_vector_float64_batch(self : Table, field_slot : Int, start_index : Int, count : Int) -> Array[Double]

    Batch read multiple float64 values from a vector efficiently

    Table::get_vector_int32

    source
    fn Table::get_vector_int32(self : Table, field_slot : Int, index : Int) -> Int

    Get an Int32 element from a vector

    Table::get_vector_int32_batch

    source
    fn Table::get_vector_int32_batch(self : Table, field_slot : Int, start_index : Int, count : Int) -> Array[Int]

    Batch read multiple int32 values from a vector efficiently

    Table::get_vector_length

    source
    fn Table::get_vector_length(self : Table, field_slot : Int) -> Int

    Get the vector length for a vector field

    Table::get_vector_start

    source
    fn Table::get_vector_start(self : Table, field_slot : Int) -> Int

    Get the start of vector data

    Table::get_vector_string

    source
    fn Table::get_vector_string(self : Table, field_slot : Int, index : Int) -> String

    Get a string element from a vector of strings

    Table::get_vector_table

    source
    fn Table::get_vector_table(self : Table, field_slot : Int, index : Int) -> Table?

    Get a table element from a vector of tables

    Table::has_field

    source
    fn Table::has_field(self : Table, field_slot : Int) -> Bool

    Check if a field is present

    Table::mutate_bool

    source
    fn Table::mutate_bool(self : Table, field_slot : Int, value : Bool) -> Bool

    Mutate a boolean field in-place Returns true if the field exists and was mutated

    Table::mutate_float32

    source
    fn Table::mutate_float32(self : Table, field_slot : Int, value : Float) -> Bool

    Mutate a Float32 field in-place

    Table::mutate_float64

    source
    fn Table::mutate_float64(self : Table, field_slot : Int, value : Double) -> Bool

    Mutate a Float64 field in-place

    Table::mutate_int16

    source
    fn Table::mutate_int16(self : Table, field_slot : Int, value : Int) -> Bool

    Mutate an Int16 field in-place

    Table::mutate_int32

    source
    fn Table::mutate_int32(self : Table, field_slot : Int, value : Int) -> Bool

    Mutate an Int32 field in-place

    Table::mutate_int64

    source
    fn Table::mutate_int64(self : Table, field_slot : Int, value : Int64) -> Bool

    Mutate an Int64 field in-place

    Table::mutate_int8

    source
    fn Table::mutate_int8(self : Table, field_slot : Int, value : Int) -> Bool

    Mutate an Int8 field in-place

    Table::mutate_uint16

    source
    fn Table::mutate_uint16(self : Table, field_slot : Int, value : Int) -> Bool

    Mutate a UInt16 field in-place

    Table::mutate_uint32

    source
    fn Table::mutate_uint32(self : Table, field_slot : Int, value : UInt) -> Bool

    Mutate a UInt32 field in-place

    Table::mutate_uint64

    source
    fn Table::mutate_uint64(self : Table, field_slot : Int, value : UInt64) -> Bool

    Mutate a UInt64 field in-place

    Table::mutate_uint8

    source
    fn Table::mutate_uint8(self : Table, field_slot : Int, value : Int) -> Bool

    Mutate a UInt8 field in-place

    Table::mutate_vector_byte

    source
    fn Table::mutate_vector_byte(self : Table, field_slot : Int, index : Int, value : Byte) -> Bool

    Mutate an element in a byte vector

    Table::mutate_vector_float64

    source
    fn Table::mutate_vector_float64(self : Table, field_slot : Int, index : Int, value : Double) -> Bool

    Mutate an element in a Float64 vector

    Table::mutate_vector_int32

    source
    fn Table::mutate_vector_int32(self : Table, field_slot : Int, index : Int, value : Int) -> Bool

    Mutate an element in an Int32 vector

    Table::new

    source
    fn Table::new(buf : ByteBuffer, pos : Int) -> Table

    Create a Table from a ByteBuffer at the given position

    Table::vector_byte_to_json

    source
    fn Table::vector_byte_to_json(self : Table, slot : Int) -> JsonValue

    Convert a byte vector to JSON array

    Table::vector_int32_to_json

    source
    fn Table::vector_int32_to_json(self : Table, slot : Int) -> JsonValue

    Convert an int vector to JSON array

    Table::verify_nested_flatbuffer

    source
    fn Table::verify_nested_flatbuffer(self : Table, field_slot : Int, verifier : Verifier) -> Bool

    Verify a nested FlatBuffer field. Returns true if the field is absent or contains a valid FlatBuffer.

    Table::vtable_offset

    source
    fn Table::vtable_offset(self : Table, field : Int) -> Int

    Get the vtable offset for a field

    TableAst

    source
    pub struct TableAst {
      name : String
      fields : Array[FieldAst]
    }

    Table definition in schema (variable-size)

    TableSchema

    source
    pub struct TableSchema {
      name : String
      fields : Array[FieldDef]
      field_map : Map[String, Int]
    }

    Table schema definition

    TableSchema::field_count

    source
    fn TableSchema::field_count(self : TableSchema) -> Int

    Get number of fields

    TableSchema::get_field

    source
    fn TableSchema::get_field(self : TableSchema, name : String) -> FieldDef?

    Get field definition by name

    TableSchema::new

    source
    fn TableSchema::new(name : String, fields : Array[FieldDef]) -> TableSchema

    Create a new table schema

    UnionAst

    source
    pub struct UnionAst {
      name : String
      types : Array[String]
    }

    Union definition in schema

    Verifier

    source
    pub struct Verifier {
      buf : ByteBuffer
      opts : VerifierOptions
      depth : Int
      num_tables : Int
    }

    Verifier for FlatBuffer validation

    Verifier::from_buffer

    source
    fn Verifier::from_buffer(buf : ByteBuffer) -> Verifier

    Create a verifier with default options

    Verifier::new

    source
    fn Verifier::new(buf : ByteBuffer, opts : VerifierOptions) -> Verifier

    Create a new verifier

    Verifier::pop_depth

    source
    fn Verifier::pop_depth(self : Verifier) -> Unit

    Pop depth after nested verification

    Verifier::push_depth

    source
    fn Verifier::push_depth(self : Verifier) -> Bool

    Push depth for nested verification

    Verifier::verify_alignment

    source
    fn Verifier::verify_alignment(self : Verifier, pos : Int, align : Int) -> Bool

    Check alignment

    Verifier::verify_buffer

    source
    fn Verifier::verify_buffer(self : Verifier) -> Bool

    Verify a buffer has a valid root table

    Verifier::verify_buffer_with_identifier

    source
    fn Verifier::verify_buffer_with_identifier(self : Verifier, identifier : String) -> Bool

    Verify a buffer with file identifier

    Verifier::verify_range

    source
    fn Verifier::verify_range(self : Verifier, start : Int, len : Int) -> Bool

    Check if a range is within buffer bounds

    Verifier::verify_scalar

    source
    fn Verifier::verify_scalar(self : Verifier, pos : Int, size : Int) -> Bool

    Verify a scalar at position

    Verifier::verify_size_prefixed_buffer

    source
    fn Verifier::verify_size_prefixed_buffer(self : Verifier) -> Bool

    Verify a size-prefixed buffer

    Verifier::verify_string

    source
    fn Verifier::verify_string(self : Verifier, pos : Int) -> Bool

    Verify a string at offset position

    Verifier::verify_table_start

    source
    fn Verifier::verify_table_start(self : Verifier, pos : Int) -> Bool

    Verify a table at position (basic verification)

    Verifier::verify_vector

    source
    fn Verifier::verify_vector(self : Verifier, pos : Int, elem_size : Int) -> Bool

    Verify a vector at offset position

    VerifierOptions

    source
    pub struct VerifierOptions {
      max_depth : Int
      max_tables : Int
      check_alignment : Bool
    }

    Verifier options

    VerifierOptions::default

    source

    Create default verifier options

    VerifierOptions::new

    source
    fn VerifierOptions::new(max_depth : Int, max_tables : Int, check_alignment : Bool) -> VerifierOptions

    Create custom verifier options

    flex_parse

    source
    fn flex_parse(data : FixedArray[Byte]) -> FlexRef

    Parse FlexBuffer from bytes

    generate_moonbit

    source
    fn generate_moonbit(schema : SchemaAst) -> String

    Generate MoonBit code from schema

    parse_schema

    source
    fn parse_schema(input : String) -> SchemaAst

    Parse a FlatBuffers schema

    read_field_dynamic

    source
    fn read_field_dynamic(table : Table, field : ReflectionField) -> JsonValue

    Read a field value dynamically using reflection

    table_to_json_dynamic

    source
    fn table_to_json_dynamic(table : Table, obj : ReflectionObject) -> JsonValue

    Convert a table to JSON using schema reflection

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io