🥮 mooncakes.io
README

#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 issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io