gtsocial-umbx

buffer.go (9791B)

---

 // Copyright 2019 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 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
 		}
 	}
 }