Source: buffer.go in package github.com/golang/protobuf/proto


package proto

import (
	"errors"
	"fmt"

	"google.golang.org/protobuf/encoding/prototext"
	"google.golang.org/protobuf/encoding/protowire"
	"google.golang.org/protobuf/runtime/protoimpl"
)

const (
	WireVarint     = 0
	WireFixed32    = 5
	WireFixed64    = 1
	WireBytes      = 2
	WireStartGroup = 3
	WireEndGroup   = 4
)

EncodeVarint returns the varint encoded bytes of v.

func EncodeVarint(v uint64) []byte {
	return protowire.AppendVarint(nil, v)
}

SizeVarint returns the length of the varint encoded bytes of v. This is equal to len(EncodeVarint(v)).

func SizeVarint(v uint64) int {
	return protowire.SizeVarint(v)
}

DecodeVarint parses a varint encoded integer from b, returning the integer value and the length of the varint. It returns (0, 0) if there is a parse error.

func DecodeVarint(b []byte) (uint64, int) {
	v, n := protowire.ConsumeVarint(b)
	if n < 0 {
		return 0, 0
	}
	return v, n
}

Buffer is a buffer for encoding and decoding the protobuf wire format. It may be reused between invocations to reduce memory usage.

type Buffer struct {
	buf           []byte
	idx           int
	deterministic bool
}

NewBuffer allocates a new Buffer initialized with buf, where the contents of buf are considered the unread portion of the buffer.

func NewBuffer(buf []byte) *Buffer {
	return &Buffer{buf: buf}
}

SetDeterministic specifies whether to use deterministic serialization. Deterministic serialization guarantees that for a given binary, equal messages will always be serialized to the same bytes. This implies: - Repeated serialization of a message will return the same bytes. - Different processes of the same binary (which may be executing on different machines) will serialize equal messages to the same bytes. Note that the deterministic serialization is NOT canonical across languages. It is not guaranteed to remain stable over time. It is unstable across different builds with schema changes due to unknown fields. Users who need canonical serialization (e.g., persistent storage in a canonical form, fingerprinting, etc.) should define their own canonicalization specification and implement their own serializer rather than relying on this API. If deterministic serialization is requested, map entries will be sorted by keys in lexographical order. This is an implementation detail and subject to change.

func (b *Buffer) SetDeterministic(deterministic bool) {
	b.deterministic = deterministic
}

SetBuf sets buf as the internal buffer, where the contents of buf are considered the unread portion of the buffer.

func (b *Buffer) SetBuf(buf []byte) {
	b.buf = buf
	b.idx = 0
}

Reset clears the internal buffer of all written and unread data.

func (b *Buffer) Reset() {
	b.buf = b.buf[:0]
	b.idx = 0
}

Bytes returns the internal buffer.

func (b *Buffer) Bytes() []byte {
	return b.buf
}

Unread returns the unread portion of the buffer.

func (b *Buffer) Unread() []byte {
	return b.buf[b.idx:]
}

Marshal appends the wire-format encoding of m to the buffer.

func (b *Buffer) Marshal(m Message) error {
	var err error
	b.buf, err = marshalAppend(b.buf, m, b.deterministic)
	return err
}

Unmarshal parses the wire-format message in the buffer and places the decoded results in m. It does not reset m before unmarshaling.

func (b *Buffer) Unmarshal(m Message) error {
	err := UnmarshalMerge(b.Unread(), m)
	b.idx = len(b.buf)
	return err
}

type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields }

func (m *unknownFields) String() string { panic("not implemented") }
func (m *unknownFields) Reset()         { panic("not implemented") }
func (m *unknownFields) ProtoMessage()  { panic("not implemented") }

DebugPrint dumps the encoded bytes of b with a header and footer including s to stdout. This is only intended for debugging.

func (*Buffer) DebugPrint(s string, b []byte) {
	m := MessageReflect(new(unknownFields))
	m.SetUnknown(b)
	b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface())
	fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s)
}

EncodeVarint appends an unsigned varint encoding to the buffer.

func (b *Buffer) EncodeVarint(v uint64) error {
	b.buf = protowire.AppendVarint(b.buf, v)
	return nil
}

EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.

func (b *Buffer) EncodeZigzag32(v uint64) error {
	return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
}

EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.

func (b *Buffer) EncodeZigzag64(v uint64) error {
	return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63))))
}

EncodeFixed32 appends a 32-bit little-endian integer to the buffer.

func (b *Buffer) EncodeFixed32(v uint64) error {
	b.buf = protowire.AppendFixed32(b.buf, uint32(v))
	return nil
}

EncodeFixed64 appends a 64-bit little-endian integer to the buffer.

func (b *Buffer) EncodeFixed64(v uint64) error {
	b.buf = protowire.AppendFixed64(b.buf, uint64(v))
	return nil
}

EncodeRawBytes appends a length-prefixed raw bytes to the buffer.

func (b *Buffer) EncodeRawBytes(v []byte) error {
	b.buf = protowire.AppendBytes(b.buf, v)
	return nil
}

EncodeStringBytes appends a length-prefixed raw bytes to the buffer. It does not validate whether v contains valid UTF-8.

func (b *Buffer) EncodeStringBytes(v string) error {
	b.buf = protowire.AppendString(b.buf, v)
	return nil
}

EncodeMessage appends a length-prefixed encoded message to the buffer.

func (b *Buffer) EncodeMessage(m Message) error {
	var err error
	b.buf = protowire.AppendVarint(b.buf, uint64(Size(m)))
	b.buf, err = marshalAppend(b.buf, m, b.deterministic)
	return err
}

DecodeVarint consumes an encoded unsigned varint from the buffer.

func (b *Buffer) DecodeVarint() (uint64, error) {
	v, n := protowire.ConsumeVarint(b.buf[b.idx:])
	if n < 0 {
		return 0, protowire.ParseError(n)
	}
	b.idx += n
	return uint64(v), nil
}

DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.

func (b *Buffer) DecodeZigzag32() (uint64, error) {
	v, err := b.DecodeVarint()
	if err != nil {
		return 0, err
	}
	return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil
}

DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.

func (b *Buffer) DecodeZigzag64() (uint64, error) {
	v, err := b.DecodeVarint()
	if err != nil {
		return 0, err
	}
	return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil
}

DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.

func (b *Buffer) DecodeFixed32() (uint64, error) {
	v, n := protowire.ConsumeFixed32(b.buf[b.idx:])
	if n < 0 {
		return 0, protowire.ParseError(n)
	}
	b.idx += n
	return uint64(v), nil
}

DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.

func (b *Buffer) DecodeFixed64() (uint64, error) {
	v, n := protowire.ConsumeFixed64(b.buf[b.idx:])
	if n < 0 {
		return 0, protowire.ParseError(n)
	}
	b.idx += n
	return uint64(v), nil
}

DecodeRawBytes consumes a length-prefixed raw bytes from the buffer. If alloc is specified, it returns a copy the raw bytes rather than a sub-slice of the buffer.

func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) {
	v, n := protowire.ConsumeBytes(b.buf[b.idx:])
	if n < 0 {
		return nil, protowire.ParseError(n)
	}
	b.idx += n
	if alloc {
		v = append([]byte(nil), v...)
	}
	return v, nil
}

DecodeStringBytes consumes a length-prefixed raw bytes from the buffer. It does not validate whether the raw bytes contain valid UTF-8.

func (b *Buffer) DecodeStringBytes() (string, error) {
	v, n := protowire.ConsumeString(b.buf[b.idx:])
	if n < 0 {
		return "", protowire.ParseError(n)
	}
	b.idx += n
	return v, nil
}

DecodeMessage consumes a length-prefixed message from the buffer. It does not reset m before unmarshaling.

func (b *Buffer) DecodeMessage(m Message) error {
	v, err := b.DecodeRawBytes(false)
	if err != nil {
		return err
	}
	return UnmarshalMerge(v, m)
}

DecodeGroup consumes a message group from the buffer. It assumes that the start group marker has already been consumed and consumes all bytes until (and including the end group marker). It does not reset m before unmarshaling.

func (b *Buffer) DecodeGroup(m Message) error {
	v, n, err := consumeGroup(b.buf[b.idx:])
	if err != nil {
		return err
	}
	b.idx += n
	return UnmarshalMerge(v, m)
}

consumeGroup parses b until it finds an end group marker, returning the raw bytes of the message (excluding the end group marker) and the the total length of the message (including the end group marker).

func consumeGroup(b []byte) ([]byte, int, error) {
	b0 := b
	depth := 1 // assume this follows a start group marker
	for {
		_, wtyp, tagLen := protowire.ConsumeTag(b)
		if tagLen < 0 {
			return nil, 0, protowire.ParseError(tagLen)
		}
		b = b[tagLen:]

		var valLen int
		switch wtyp {
		case protowire.VarintType:
			_, valLen = protowire.ConsumeVarint(b)
		case protowire.Fixed32Type:
			_, valLen = protowire.ConsumeFixed32(b)
		case protowire.Fixed64Type:
			_, valLen = protowire.ConsumeFixed64(b)
		case protowire.BytesType:
			_, valLen = protowire.ConsumeBytes(b)
		case protowire.StartGroupType:
			depth++
		case protowire.EndGroupType:
			depth--
		default:
			return nil, 0, errors.New("proto: cannot parse reserved wire type")
		}
		if valLen < 0 {
			return nil, 0, protowire.ParseError(valLen)
		}
		b = b[valLen:]

		if depth == 0 {
			return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil
		}
	}