🥮 mooncakes.io

moonproto

A pure-runtime Protocol Buffers wire format encoder/decoder and proto3 subset parser in MoonBit

protobuf
serialization
encoding
wire-format
proto-parser
moon add Duan-lang-dev/moonproto@0.2.0
Download zip
Version
0.2.0
License
MIT
Repository
Last updated
14 days ago
Downloads
14
README

#Duan525/moonproto

#
Message

source
pub trait Message {
  fn encode(Self, Encoder) -> Unit
}

Types implementing Message can encode themselves as protobuf messages.

#
AddressBook

source
pub(all) struct AddressBook {
  people : Array[Person]
} derive(Eq, 
Debug)

A collection of people, encoded as a repeated length-delimited field.

#
AddressBook::decode

source
fn AddressBook::decode(dec : Decoder) -> AddressBook

Decode an AddressBook from a Decoder.

#
AddressBook::encode

source
fn AddressBook::encode(self : AddressBook, enc : Encoder) -> Unit

Encode an AddressBook (field 1 is a repeated Person message).

#
AddressBook::from_bytes

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

Deserialize an AddressBook from bytes.

#
AddressBook::new

source
fn AddressBook::new(people : Array[Person]) -> AddressBook

Create an AddressBook from a list of people.

#
AddressBook::to_bytes

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

Serialize an AddressBook to bytes.

#
Decoder

source
type Decoder

#
Decoder::new

source
fn Decoder::new(bytes : Bytes) -> Decoder

Create a new Decoder from bytes.

#
Decoder::read_bool

source
fn Decoder::read_bool(self : Decoder) -> Bool?

Read a bool value (wire type 0).

#
Decoder::read_bytes

source
fn Decoder::read_bytes(self : Decoder) -> Bytes?

Read a bytes value (wire type 2).

#
Decoder::read_double

source
fn Decoder::read_double(self : Decoder) -> Double?

Read a double value (wire type 1).

#
Decoder::read_fixed32

source
fn Decoder::read_fixed32(self : Decoder) -> UInt?

Read a fixed32 value (wire type 5).

#
Decoder::read_fixed64

source
fn Decoder::read_fixed64(self : Decoder) -> UInt64?

Read a fixed64 value (wire type 1).

#
Decoder::read_float

source
fn Decoder::read_float(self : Decoder) -> Float?

Read a float value (wire type 5).

#
Decoder::read_int32

source
fn Decoder::read_int32(self : Decoder) -> Int?

Read an int32 value (wire type 0).

#
Decoder::read_int64

source
fn Decoder::read_int64(self : Decoder) -> Int64?

Read an int64 value (wire type 0).

#
Decoder::read_message

source
fn Decoder::read_message(self : Decoder) -> Decoder?

Read a nested message (wire type 2). Returns a new Decoder for the nested bytes.

#
Decoder::read_sfixed32

source
fn Decoder::read_sfixed32(self : Decoder) -> Int?

Read an sfixed32 value (wire type 5).

#
Decoder::read_sfixed64

source
fn Decoder::read_sfixed64(self : Decoder) -> Int64?

Read an sfixed64 value (wire type 1).

#
Decoder::read_sint32

source
fn Decoder::read_sint32(self : Decoder) -> Int?

Read a sint32 value (wire type 0, zigzag).

#
Decoder::read_sint64

source
fn Decoder::read_sint64(self : Decoder) -> Int64?

Read a sint64 value (wire type 0, zigzag).

#
Decoder::read_string

source
fn Decoder::read_string(self : Decoder) -> String?

Read a string value (wire type 2).

#
Decoder::read_tag

source
fn Decoder::read_tag(self : Decoder) -> (UInt, UInt)?

Read the next tag. Returns (field_number, wire_type) or None at end.

#
Decoder::read_uint32

source
fn Decoder::read_uint32(self : Decoder) -> UInt?

Read a uint32 value (wire type 0).

#
Decoder::read_uint64

source
fn Decoder::read_uint64(self : Decoder) -> UInt64?

Read a uint64 value (wire type 0).

#
Decoder::skip_field

source
fn Decoder::skip_field(self : Decoder, wire_type : UInt) -> Int?

Skip a field of the given wire type. Returns bytes consumed or None on error.

#
Encoder

source
type Encoder

#
Encoder::encode_bool

source
fn Encoder::encode_bool(self : Encoder, field_number : UInt, value : Bool) -> Encoder

Encode a bool field (wire type 0, varint).

#
Encoder::encode_bytes

source
fn Encoder::encode_bytes(self : Encoder, field_number : UInt, value : Bytes) -> Encoder

Encode a bytes field (wire type 2, length-delimited).

#
Encoder::encode_double

source
fn Encoder::encode_double(self : Encoder, field_number : UInt, value : Double) -> Encoder

Encode a double field (wire type 1).

#
Encoder::encode_fixed32

source
fn Encoder::encode_fixed32(self : Encoder, field_number : UInt, value : UInt) -> Encoder

Encode a fixed32 field (wire type 5).

#
Encoder::encode_fixed64

source
fn Encoder::encode_fixed64(self : Encoder, field_number : UInt, value : UInt64) -> Encoder

Encode a fixed64 field (wire type 1).

#
Encoder::encode_float

source
fn Encoder::encode_float(self : Encoder, field_number : UInt, value : Float) -> Encoder

Encode a float field (wire type 5).

#
Encoder::encode_int32

source
fn Encoder::encode_int32(self : Encoder, field_number : UInt, value : Int) -> Encoder

Encode an int32 field (wire type 0, varint).

#
Encoder::encode_int64

source
fn Encoder::encode_int64(self : Encoder, field_number : UInt, value : Int64) -> Encoder

Encode an int64 field (wire type 0, varint).

#
Encoder::encode_message

source
fn Encoder::encode_message(self : Encoder, field_number : UInt, inner : Encoder) -> Encoder

Encode a nested message field (wire type 2, length-delimited).

#
Encoder::encode_sfixed32

source
fn Encoder::encode_sfixed32(self : Encoder, field_number : UInt, value : Int) -> Encoder

Encode a sfixed32 field (wire type 5).

#
Encoder::encode_sfixed64

source
fn Encoder::encode_sfixed64(self : Encoder, field_number : UInt, value : Int64) -> Encoder

Encode a sfixed64 field (wire type 1).

#
Encoder::encode_sint32

source
fn Encoder::encode_sint32(self : Encoder, field_number : UInt, value : Int) -> Encoder

Encode a sint32 field (wire type 0, zigzag + varint).

#
Encoder::encode_sint64

source
fn Encoder::encode_sint64(self : Encoder, field_number : UInt, value : Int64) -> Encoder

Encode a sint64 field (wire type 0, zigzag + varint).

#
Encoder::encode_string

source
fn Encoder::encode_string(self : Encoder, field_number : UInt, value : String) -> Encoder

Encode a string field (wire type 2, length-delimited). Strings are encoded as UTF-8 bytes.

#
Encoder::encode_uint32

source
fn Encoder::encode_uint32(self : Encoder, field_number : UInt, value : UInt) -> Encoder

Encode a uint32 field (wire type 0, varint).

#
Encoder::encode_uint64

source
fn Encoder::encode_uint64(self : Encoder, field_number : UInt, value : UInt64) -> Encoder

Encode a uint64 field (wire type 0, varint).

#
Encoder::new

source
fn Encoder::new() -> Encoder

Create a new Encoder.

#
Encoder::to_bytes

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

Get the encoded bytes from the encoder.

#
FieldLabel

source
pub enum FieldLabel {
  Optional
  Required
  Repeated
} derive(Eq, 
Debug)

Represents a field label.

#
FieldType

source
pub enum FieldType {
  Int32
  Int64
  Uint32
  Uint64
  Sint32
  Sint64
  Fixed32
  Fixed64
  Sfixed32
  Sfixed64
  Float
  Double
  Bool
  String
  Bytes
  Map(FieldType, FieldType)
  Message(String)
  Enum(String)
} derive(Eq, 
Debug)

Represents a protobuf field type.

#
Person

source
pub(all) struct Person {
  name : String
  age : Int
  active : Bool
  tags : Array[String]
} derive(Eq, 
Debug)

A typed protobuf message with explicit field numbers.

#
Person::decode

source
fn Person::decode(dec : Decoder) -> Person

Decode a Person from a Decoder. Unknown fields are skipped.

#
Person::encode

source
fn Person::encode(self : Person, enc : Encoder) -> Unit

Encode a Person into an Encoder.

#
Person::from_bytes

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

Deserialize a Person from bytes.

#
Person::new

source
fn Person::new(name : String, age : Int, active : Bool, tags : Array[String]) -> Person

Create a Person from its fields.

#
Person::to_bytes

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

Serialize a Person to bytes.

#
ProtoEnum

source
pub struct ProtoEnum {
  name : String
  values : Array[ProtoEnumValue]
} derive(Eq, 
Debug)

Represents an enum definition.

#
ProtoEnumValue

source
pub struct ProtoEnumValue {
  name : String
  number : Int
} derive(Eq, 
Debug)

Represents an enum value.

#
ProtoError

source
pub struct ProtoError {
  line : Int
  message : String
} derive(Eq, 
Debug)

A parse error with a line position and message.

#
ProtoField

source
pub struct ProtoField {
  name : String
  number : UInt
  field_type : FieldType
  label : FieldLabel
} derive(Eq, 
Debug)

Represents a single field in a message.

#
ProtoFile

source
pub struct ProtoFile {
  messages : Array[ProtoMessage]
  enums : Array[ProtoEnum]
  services : Array[ProtoService]
} derive(Eq, 
Debug)

A parsed .proto file containing all definitions.

#
ProtoMessage

source
pub struct ProtoMessage {
  name : String
  fields : Array[ProtoField]
  oneofs : Array[ProtoOneof]
  nested_messages : Array[ProtoMessage]
  nested_enums : Array[ProtoEnum]
} derive(Eq, 
Debug)

Represents a message definition.

#
ProtoOneof

source
pub struct ProtoOneof {
  name : String
  fields : Array[ProtoField]
} derive(Eq, 
Debug)

Represents a oneof group inside a message.

#
ProtoRpc

source
pub struct ProtoRpc {
  name : String
  input_type : String
  output_type : String
  client_streaming : Bool
  server_streaming : Bool
} derive(Eq, 
Debug)

Represents an RPC method inside a service.

#
ProtoService

source
pub struct ProtoService {
  name : String
  rpcs : Array[ProtoRpc]
} derive(Eq, 
Debug)

Represents a service definition.

#
WIRE_FIXED32

source
let WIRE_FIXED32 : UInt

#
WIRE_FIXED64

source
let WIRE_FIXED64 : UInt

#
WIRE_LENGTH_DELIMITED

source
let WIRE_LENGTH_DELIMITED : UInt

#
WIRE_VARINT

source
let WIRE_VARINT : UInt

Wire type constants for protobuf encoding.

#
decode_packed_fixed32

source
fn decode_packed_fixed32(data : Bytes) -> Array[UInt]

Decode all fixed32 values from packed bytes into an array.

#
decode_packed_fixed64

source
fn decode_packed_fixed64(data : Bytes) -> Array[UInt64]

Decode all fixed64 values from packed bytes into an array.

#
decode_packed_varint

source
fn decode_packed_varint(data : Bytes) -> Array[UInt64]

Decode all varints from packed bytes into an array.

#
decode_sint32

source
fn decode_sint32(bytes : Bytes, pos : Int) -> (Int, Int)?

Decode a zigzag-encoded signed 32-bit varint from bytes at a given position. Returns (value, bytes_consumed) or None if the varint is truncated.

#
decode_sint64

source
fn decode_sint64(bytes : Bytes, pos : Int) -> (Int64, Int)?

Decode a zigzag-encoded signed 64-bit varint from bytes at a given position. Returns (value, bytes_consumed) or None if the varint is truncated.

#
decode_varint

source
fn decode_varint(bytes : Bytes, pos : Int) -> (UInt64, Int)?

Decode a protobuf varint from bytes at a given position. Returns (value, bytes_consumed) or None if the varint is truncated.

#
decode_zigzag32

source
fn decode_zigzag32(value : UInt) -> Int

Zigzag decode an unsigned 32-bit integer to signed.

#
decode_zigzag64

source
fn decode_zigzag64(value : UInt64) -> Int64

Zigzag decode an unsigned 64-bit integer to signed.

#
encode_packed_double

source
fn encode_packed_double(buf : 
Buffer, field_number : UInt, values : Array[Double]) -> Unit

Encode a packed repeated double field.

#
encode_packed_fixed32

source
fn encode_packed_fixed32(buf : 
Buffer, field_number : UInt, values : Array[UInt]) -> Unit

Encode a packed repeated fixed32 field.

#
encode_packed_fixed64

source
fn encode_packed_fixed64(buf : 
Buffer, field_number : UInt, values : Array[UInt64]) -> Unit

Encode a packed repeated fixed64 field.

#
encode_packed_float

source
fn encode_packed_float(buf : 
Buffer, field_number : UInt, values : Array[Float]) -> Unit

Encode a packed repeated float field.

#
encode_packed_varint

source
fn encode_packed_varint(buf : 
Buffer, field_number : UInt, values : Array[UInt64]) -> Unit

Encode a packed repeated varint field (int32, uint32, sint32, bool, enum, int64, etc.)

#
encode_sint32

source
fn encode_sint32(buf : 
Buffer, value : Int) -> Unit

Encode a signed 32-bit integer as a zigzag-encoded varint.

#
encode_sint64

source
fn encode_sint64(buf : 
Buffer, value : Int64) -> Unit

Encode a signed 64-bit integer as a zigzag-encoded varint.

#
encode_varint

source
fn encode_varint(buf : 
Buffer, value : UInt64) -> Unit

Encode an unsigned 64-bit integer as a protobuf varint into the buffer.

#
encode_zigzag32

source
fn encode_zigzag32(value : Int) -> UInt

Zigzag encode a signed 32-bit integer to unsigned.

#
encode_zigzag64

source
fn encode_zigzag64(value : Int64) -> UInt64

Zigzag encode a signed 64-bit integer to unsigned.

#
format_proto_error

source
fn format_proto_error(err : ProtoError) -> String

Format a parse error as a readable string.

#
make_tag

source
fn make_tag(field_number : UInt, wire_type : UInt) -> UInt

Make a protobuf tag from field number and wire type. tag = (field_number << 3) | wire_type

#
parse_proto

source
fn parse_proto(content : String) -> Result[ProtoFile, ProtoError]

Parse a .proto file content string into a ProtoFile.

#
read_fixed32

source
fn read_fixed32(bytes : Bytes, pos : Int) -> (UInt, Int)?

Read a fixed32 value from bytes at the given position. Returns (value, new_position) or None if out of bounds.

#
read_fixed64

source
fn read_fixed64(bytes : Bytes, pos : Int) -> (UInt64, Int)?

Read a fixed64 value from bytes at the given position. Returns (value, new_position) or None if out of bounds.

#
split_tag

source
fn split_tag(tag : UInt) -> (UInt, UInt)

Split a protobuf tag into (field_number, wire_type).

#
write_double

source
fn write_double(buf : 
Buffer, value : Double) -> Unit

Write a double as fixed64.

#
write_fixed32

source
fn write_fixed32(buf : 
Buffer, value : UInt) -> Unit

Write a fixed32 value in little-endian format.

#
write_fixed64

source
fn write_fixed64(buf : 
Buffer, value : UInt64) -> Unit

Write a fixed64 value in little-endian format.

#
write_float

source
fn write_float(buf : 
Buffer, value : Float) -> Unit

Write a float as fixed32.

#
write_length_delimited_prefix

source
fn write_length_delimited_prefix(buf : 
Buffer, field_number : UInt, byte_length : UInt) -> Unit

Write a Length-delimited field prefix: tag + length as varint.

#
write_tag

source
fn write_tag(buf : 
Buffer, field_number : UInt, wire_type : UInt) -> Unit

Write a protobuf tag to the buffer.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io