🥮 mooncakes.io

    #core/binary

    Binary serialization utilities.

    #Types

    • BinaryWriter: Sequential binary writer with auto-growing buffer
    • BinaryReader: Sequential binary reader with position tracking

    #BinaryWriter Methods

    • write_u32(value): Write 32-bit unsigned (little-endian)
    • write_i32(value): Write 32-bit signed (little-endian)
    • write_u64(value): Write 64-bit unsigned (little-endian)
    • write_i64(value): Write 64-bit signed (little-endian)
    • write_f32(value): Write 32-bit float (IEEE 754)
    • write_f64(value): Write 64-bit float (IEEE 754)
    • write_bytes(bytes): Write raw bytes
    • to_bytes(): Get final buffer

    #BinaryReader Methods

    • read_u32(): Read 32-bit unsigned
    • read_i32(): Read 32-bit signed
    • read_u64(): Read 64-bit unsigned
    • read_i64(): Read 64-bit signed
    • read_f32(): Read 32-bit float
    • read_f64(): Read 64-bit float
    • read_bytes(n): Read n bytes
    • position(): Get current read position

    #Utilities

    • crc32(data): Compute CRC32 checksum
    • read_u32_le(data, offset): Read u32 at offset
    • write_u32_le(data, offset, value): Write u32 at offset

    BinaryReader

    source
    pub struct BinaryReader {
      data : Bytes
      offset : Int
    }

    Binary reader for deserialization

    BinaryReader::has_more

    source
    fn BinaryReader::has_more(self : BinaryReader) -> Bool

    Check if there are more bytes to read

    BinaryReader::new

    source
    fn BinaryReader::new(data : Bytes) -> BinaryReader

    Create a new binary reader

    BinaryReader::peek_byte

    source
    fn BinaryReader::peek_byte(self : BinaryReader) -> Byte

    Read the byte at the current position without advancing the cursor. Used by version-aware decoders that need to disambiguate two on-disk layouts that share a version tag but differ in their entry encoding.

    BinaryReader::position

    source
    fn BinaryReader::position(self : BinaryReader) -> Int

    Get current read position

    BinaryReader::read_byte

    source
    fn BinaryReader::read_byte(self : BinaryReader) -> Byte

    Read a single byte

    BinaryReader::read_bytes

    source
    fn BinaryReader::read_bytes(self : BinaryReader, len : Int) -> Bytes

    Read len bytes. Aborts if not enough data remaining.

    BinaryReader::read_f32

    source
    fn BinaryReader::read_f32(self : BinaryReader) -> Float

    Read a f32 value (little-endian)

    BinaryReader::read_f64

    source
    fn BinaryReader::read_f64(self : BinaryReader) -> Double

    Read a f64 value

    BinaryReader::read_i32

    source
    fn BinaryReader::read_i32(self : BinaryReader) -> Int

    Read an i32 value (little-endian)

    BinaryReader::read_i64

    source
    fn BinaryReader::read_i64(self : BinaryReader) -> Int64

    Read an i64 value (little-endian)

    BinaryReader::read_u32

    source
    fn BinaryReader::read_u32(self : BinaryReader) -> UInt

    Read a u32 value (little-endian)

    BinaryReader::read_u64

    source
    fn BinaryReader::read_u64(self : BinaryReader) -> UInt64

    Read a u64 value (little-endian)

    BinaryReader::remaining

    source
    fn BinaryReader::remaining(self : BinaryReader) -> Int

    Get remaining bytes count

    BinaryReader::skip

    source
    fn BinaryReader::skip(self : BinaryReader, n : Int) -> Unit

    Skip n bytes. Aborts if not enough data remaining.

    BinaryWriter

    source
    pub struct BinaryWriter {
      buf : FixedArray[Byte]
      len : Int
    }

    Binary writer for serialization - single buffer with grow-on-demand

    BinaryWriter::concat

    source
    fn BinaryWriter::concat(self : BinaryWriter) -> Bytes

    Get result as Bytes (zero-copy slice)

    BinaryWriter::new

    source
    fn BinaryWriter::new(capacity? : Int) -> BinaryWriter

    Create a new binary writer with initial capacity

    BinaryWriter::push_byte

    source
    fn BinaryWriter::push_byte(self : BinaryWriter, value : Byte) -> Unit

    Push a single byte

    BinaryWriter::push_bytes

    source
    fn BinaryWriter::push_bytes(self : BinaryWriter, data : Bytes) -> Unit

    Push raw bytes

    BinaryWriter::push_f32

    source
    fn BinaryWriter::push_f32(self : BinaryWriter, value : Float) -> Unit

    Push a f32 value (little-endian)

    BinaryWriter::push_f64

    source
    fn BinaryWriter::push_f64(self : BinaryWriter, value : Double) -> Unit

    Push a f64 value

    BinaryWriter::push_i32

    source
    fn BinaryWriter::push_i32(self : BinaryWriter, value : Int) -> Unit

    Push an i32 value (little-endian)

    BinaryWriter::push_i64

    source
    fn BinaryWriter::push_i64(self : BinaryWriter, value : Int64) -> Unit

    Push an i64 value (little-endian)

    BinaryWriter::push_u32

    source
    fn BinaryWriter::push_u32(self : BinaryWriter, value : UInt) -> Unit

    Push a u32 value (little-endian)

    BinaryWriter::push_u64

    source
    fn BinaryWriter::push_u64(self : BinaryWriter, value : UInt64) -> Unit

    Push a u64 value (little-endian)

    bytes_equal

    source
    fn bytes_equal(a : Bytes, b : Bytes) -> Bool

    Byte-level equality comparison.

    crc32

    source
    fn crc32(data : Bytes) -> UInt

    Compute CRC32 checksum of data

    crc32_fast

    source
    fn crc32_fast(data : Bytes) -> UInt

    Compute CRC32 using lookup table (faster for larger data)

    crc32_verify

    source
    fn crc32_verify(data : Bytes, expected : UInt) -> Bool

    Verify CRC32 checksum

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io