protopack

func (Message) Format ¶

func (m Message) Format(s fmt.State, r rune)

Format implements a custom formatter to visualize the syntax tree. Using "%#v" formats the Message in Go source code.

func (Message) Marshal ¶

func (m Message) Marshal() []byte

Marshal encodes a syntax tree into the protobuf wire format.

Example message definition:

message MyMessage {
	string field1 = 1;
	int64 field2 = 2;
	repeated float32 field3 = 3;
}

Example encoded message:

b := Message{
	Tag{1, BytesType}, String("Hello, world!"),
	Tag{2, VarintType}, Varint(-10),
	Tag{3, BytesType}, LengthPrefix{
		Float32(1.1), Float32(2.2), Float32(3.3),
	},
}.Marshal()

Resulting wire data:

0x0000  0a 0d 48 65 6c 6c 6f 2c  20 77 6f 72 6c 64 21 10  |..Hello, world!.|
0x0010  f6 ff ff ff ff ff ff ff  ff 01 1a 0c cd cc 8c 3f  |...............?|
0x0020  cd cc 0c 40 33 33 53 40                           |...@33S@|

func (Message) Size ¶

func (m Message) Size() int

Size reports the size in bytes of the marshaled message.

func (*Message) Unmarshal ¶

func (m *Message) Unmarshal(in []byte)

Unmarshal parses the input protobuf wire data as a syntax tree. Any parsing error results in the remainder of the input being concatenated to the message as a Raw type.

Each tag (a tuple of the field number and wire type) encountered is inserted into the syntax tree as a Tag.

The contents of each wire type is mapped to the following Go types:

• VarintType ⇒ Uvarint
• Fixed32Type ⇒ Uint32
• Fixed64Type ⇒ Uint64
• BytesType ⇒ Bytes
• StartGroupType and StartGroupType ⇒ Message

Since the wire format is not self-describing, this function cannot parse sub-messages and will leave them as the Bytes type. Further manual parsing can be performed as such:

var m, m1, m2 Message
m.Unmarshal(b)
m1.Unmarshal(m[3].(Bytes))
m[3] = LengthPrefix(m1)
m2.Unmarshal(m[3].(LengthPrefix)[1].(Bytes))
m[3].(LengthPrefix)[1] = LengthPrefix(m2)

Unmarshal is useful for debugging the protobuf wire format.

func (*Message) UnmarshalAbductive ¶ added in v1.27.0

func (m *Message) UnmarshalAbductive(in []byte, desc protoreflect.MessageDescriptor)

UnmarshalAbductive is like Message.UnmarshalDescriptor, but infers abductively whether any unknown bytes values is a message based on whether it is a syntactically well-formed message.

Note that the protobuf wire format is not fully self-describing, so abductive inference may attempt to expand a bytes value as a message that is not actually a message. It is a best-effort guess.

func (*Message) UnmarshalDescriptor ¶

func (m *Message) UnmarshalDescriptor(in []byte, desc protoreflect.MessageDescriptor)

UnmarshalDescriptor parses the input protobuf wire data as a syntax tree using the provided message descriptor for more accurate parsing of fields. It operates like Message.Unmarshal, but may use a wider range of Go types to represent the wire data.

The contents of each wire type is mapped to one of the following Go types:

• VarintType ⇒ Bool, Varint, Svarint, Uvarint
• Fixed32Type ⇒ Int32, Uint32, Float32
• Fixed64Type ⇒ Uint32, Uint64, Float64
• BytesType ⇒ String, Bytes, LengthPrefix
• StartGroupType and StartGroupType ⇒ Message

If the field is unknown, it uses the same mapping as Message.Unmarshal. Known sub-messages are parsed as a Message and packed repeated fields are parsed as a LengthPrefix.