diff options
Diffstat (limited to 'vendor/github.com/jhump/protoreflect/codec')
4 files changed, 831 insertions, 0 deletions
diff --git a/vendor/github.com/jhump/protoreflect/codec/codec.go b/vendor/github.com/jhump/protoreflect/codec/codec.go new file mode 100644 index 0000000..7e5c568 --- /dev/null +++ b/vendor/github.com/jhump/protoreflect/codec/codec.go @@ -0,0 +1,218 @@ +package codec + +import ( + "io" + + "github.com/golang/protobuf/proto" + + "github.com/jhump/protoreflect/internal/codec" +) + +// ErrOverflow is returned when an integer is too large to be represented. +var ErrOverflow = codec.ErrOverflow + +// ErrBadWireType is returned when decoding a wire-type from a buffer that +// is not valid. +var ErrBadWireType = codec.ErrBadWireType + +// NB: much of the implementation is in an internal package, to avoid an import +// cycle between this codec package and the desc package. We export it from +// this package, but we can't use a type alias because we also need to add +// methods to it, to broaden the exposed API. + +// Buffer is a reader and a writer that wraps a slice of bytes and also +// provides API for decoding and encoding the protobuf binary format. +// +// Its operation is similar to that of a bytes.Buffer: writing pushes +// data to the end of the buffer while reading pops data from the head +// of the buffer. So the same buffer can be used to both read and write. +type Buffer codec.Buffer + +// NewBuffer creates a new buffer with the given slice of bytes as the +// buffer's initial contents. +func NewBuffer(buf []byte) *Buffer { + return (*Buffer)(codec.NewBuffer(buf)) +} + +// SetDeterministic sets this buffer to encode messages deterministically. This +// is useful for tests. But the overhead is non-zero, so it should not likely be +// used outside of tests. When true, map fields in a message must have their +// keys sorted before serialization to ensure deterministic output. Otherwise, +// values in a map field will be serialized in map iteration order. +func (cb *Buffer) SetDeterministic(deterministic bool) { + (*codec.Buffer)(cb).SetDeterministic(deterministic) +} + +// IsDeterministic returns whether or not this buffer is configured to encode +// messages deterministically. +func (cb *Buffer) IsDeterministic() bool { + return (*codec.Buffer)(cb).IsDeterministic() +} + +// Reset resets this buffer back to empty. Any subsequent writes/encodes +// to the buffer will allocate a new backing slice of bytes. +func (cb *Buffer) Reset() { + (*codec.Buffer)(cb).Reset() +} + +// Bytes returns the slice of bytes remaining in the buffer. Note that +// this does not perform a copy: if the contents of the returned slice +// are modified, the modifications will be visible to subsequent reads +// via the buffer. +func (cb *Buffer) Bytes() []byte { + return (*codec.Buffer)(cb).Bytes() +} + +// String returns the remaining bytes in the buffer as a string. +func (cb *Buffer) String() string { + return (*codec.Buffer)(cb).String() +} + +// EOF returns true if there are no more bytes remaining to read. +func (cb *Buffer) EOF() bool { + return (*codec.Buffer)(cb).EOF() +} + +// Skip attempts to skip the given number of bytes in the input. If +// the input has fewer bytes than the given count, io.ErrUnexpectedEOF +// is returned and the buffer is unchanged. Otherwise, the given number +// of bytes are skipped and nil is returned. +func (cb *Buffer) Skip(count int) error { + return (*codec.Buffer)(cb).Skip(count) + +} + +// Len returns the remaining number of bytes in the buffer. +func (cb *Buffer) Len() int { + return (*codec.Buffer)(cb).Len() +} + +// Read implements the io.Reader interface. If there are no bytes +// remaining in the buffer, it will return 0, io.EOF. Otherwise, +// it reads max(len(dest), cb.Len()) bytes from input and copies +// them into dest. It returns the number of bytes copied and a nil +// error in this case. +func (cb *Buffer) Read(dest []byte) (int, error) { + return (*codec.Buffer)(cb).Read(dest) +} + +var _ io.Reader = (*Buffer)(nil) + +// Write implements the io.Writer interface. It always returns +// len(data), nil. +func (cb *Buffer) Write(data []byte) (int, error) { + return (*codec.Buffer)(cb).Write(data) +} + +var _ io.Writer = (*Buffer)(nil) + +// DecodeVarint reads a varint-encoded integer from the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (cb *Buffer) DecodeVarint() (uint64, error) { + return (*codec.Buffer)(cb).DecodeVarint() +} + +// DecodeTagAndWireType decodes a field tag and wire type from input. +// This reads a varint and then extracts the two fields from the varint +// value read. +func (cb *Buffer) DecodeTagAndWireType() (tag int32, wireType int8, err error) { + return (*codec.Buffer)(cb).DecodeTagAndWireType() +} + +// DecodeFixed64 reads a 64-bit integer from the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (cb *Buffer) DecodeFixed64() (x uint64, err error) { + return (*codec.Buffer)(cb).DecodeFixed64() +} + +// DecodeFixed32 reads a 32-bit integer from the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (cb *Buffer) DecodeFixed32() (x uint64, err error) { + return (*codec.Buffer)(cb).DecodeFixed32() +} + +// DecodeRawBytes reads a count-delimited byte buffer from the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (cb *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { + return (*codec.Buffer)(cb).DecodeRawBytes(alloc) +} + +// ReadGroup reads the input until a "group end" tag is found +// and returns the data up to that point. Subsequent reads from +// the buffer will read data after the group end tag. If alloc +// is true, the data is copied to a new slice before being returned. +// Otherwise, the returned slice is a view into the buffer's +// underlying byte slice. +// +// This function correctly handles nested groups: if a "group start" +// tag is found, then that group's end tag will be included in the +// returned data. +func (cb *Buffer) ReadGroup(alloc bool) ([]byte, error) { + return (*codec.Buffer)(cb).ReadGroup(alloc) +} + +// SkipGroup is like ReadGroup, except that it discards the +// data and just advances the buffer to point to the input +// right *after* the "group end" tag. +func (cb *Buffer) SkipGroup() error { + return (*codec.Buffer)(cb).SkipGroup() +} + +// SkipField attempts to skip the value of a field with the given wire +// type. When consuming a protobuf-encoded stream, it can be called immediately +// after DecodeTagAndWireType to discard the subsequent data for the field. +func (cb *Buffer) SkipField(wireType int8) error { + return (*codec.Buffer)(cb).SkipField(wireType) +} + +// EncodeVarint writes a varint-encoded integer to the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (cb *Buffer) EncodeVarint(x uint64) error { + return (*codec.Buffer)(cb).EncodeVarint(x) +} + +// EncodeTagAndWireType encodes the given field tag and wire type to the +// buffer. This combines the two values and then writes them as a varint. +func (cb *Buffer) EncodeTagAndWireType(tag int32, wireType int8) error { + return (*codec.Buffer)(cb).EncodeTagAndWireType(tag, wireType) +} + +// EncodeFixed64 writes a 64-bit integer to the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (cb *Buffer) EncodeFixed64(x uint64) error { + return (*codec.Buffer)(cb).EncodeFixed64(x) + +} + +// EncodeFixed32 writes a 32-bit integer to the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (cb *Buffer) EncodeFixed32(x uint64) error { + return (*codec.Buffer)(cb).EncodeFixed32(x) +} + +// EncodeRawBytes writes a count-delimited byte buffer to the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (cb *Buffer) EncodeRawBytes(b []byte) error { + return (*codec.Buffer)(cb).EncodeRawBytes(b) +} + +// EncodeMessage writes the given message to the buffer. +func (cb *Buffer) EncodeMessage(pm proto.Message) error { + return (*codec.Buffer)(cb).EncodeMessage(pm) +} + +// EncodeDelimitedMessage writes the given message to the buffer with a +// varint-encoded length prefix (the delimiter). +func (cb *Buffer) EncodeDelimitedMessage(pm proto.Message) error { + return (*codec.Buffer)(cb).EncodeDelimitedMessage(pm) +} diff --git a/vendor/github.com/jhump/protoreflect/codec/decode_fields.go b/vendor/github.com/jhump/protoreflect/codec/decode_fields.go new file mode 100644 index 0000000..0edb817 --- /dev/null +++ b/vendor/github.com/jhump/protoreflect/codec/decode_fields.go @@ -0,0 +1,318 @@ +package codec + +import ( + "errors" + "fmt" + "io" + "math" + + "github.com/golang/protobuf/proto" + "google.golang.org/protobuf/types/descriptorpb" + + "github.com/jhump/protoreflect/desc" +) + +var varintTypes = map[descriptorpb.FieldDescriptorProto_Type]bool{} +var fixed32Types = map[descriptorpb.FieldDescriptorProto_Type]bool{} +var fixed64Types = map[descriptorpb.FieldDescriptorProto_Type]bool{} + +func init() { + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_BOOL] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_INT32] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_INT64] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_UINT32] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_UINT64] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_SINT32] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_SINT64] = true + varintTypes[descriptorpb.FieldDescriptorProto_TYPE_ENUM] = true + + fixed32Types[descriptorpb.FieldDescriptorProto_TYPE_FIXED32] = true + fixed32Types[descriptorpb.FieldDescriptorProto_TYPE_SFIXED32] = true + fixed32Types[descriptorpb.FieldDescriptorProto_TYPE_FLOAT] = true + + fixed64Types[descriptorpb.FieldDescriptorProto_TYPE_FIXED64] = true + fixed64Types[descriptorpb.FieldDescriptorProto_TYPE_SFIXED64] = true + fixed64Types[descriptorpb.FieldDescriptorProto_TYPE_DOUBLE] = true +} + +// ErrWireTypeEndGroup is returned from DecodeFieldValue if the tag and wire-type +// it reads indicates an end-group marker. +var ErrWireTypeEndGroup = errors.New("unexpected wire type: end group") + +// MessageFactory is used to instantiate messages when DecodeFieldValue needs to +// decode a message value. +// +// Also see MessageFactory in "github.com/jhump/protoreflect/dynamic", which +// implements this interface. +type MessageFactory interface { + NewMessage(md *desc.MessageDescriptor) proto.Message +} + +// UnknownField represents a field that was parsed from the binary wire +// format for a message, but was not a recognized field number. Enough +// information is preserved so that re-serializing the message won't lose +// any of the unrecognized data. +type UnknownField struct { + // The tag number for the unrecognized field. + Tag int32 + + // Encoding indicates how the unknown field was encoded on the wire. If it + // is proto.WireBytes or proto.WireGroupStart then Contents will be set to + // the raw bytes. If it is proto.WireTypeFixed32 then the data is in the least + // significant 32 bits of Value. Otherwise, the data is in all 64 bits of + // Value. + Encoding int8 + Contents []byte + Value uint64 +} + +// DecodeZigZag32 decodes a signed 32-bit integer from the given +// zig-zag encoded value. +func DecodeZigZag32(v uint64) int32 { + return int32((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)) +} + +// DecodeZigZag64 decodes a signed 64-bit integer from the given +// zig-zag encoded value. +func DecodeZigZag64(v uint64) int64 { + return int64((v >> 1) ^ uint64((int64(v&1)<<63)>>63)) +} + +// DecodeFieldValue will read a field value from the buffer and return its +// value and the corresponding field descriptor. The given function is used +// to lookup a field descriptor by tag number. The given factory is used to +// instantiate a message if the field value is (or contains) a message value. +// +// On error, the field descriptor and value are typically nil. However, if the +// error returned is ErrWireTypeEndGroup, the returned value will indicate any +// tag number encoded in the end-group marker. +// +// If the field descriptor returned is nil, that means that the given function +// returned nil. This is expected to happen for unrecognized tag numbers. In +// that case, no error is returned, and the value will be an UnknownField. +func (cb *Buffer) DecodeFieldValue(fieldFinder func(int32) *desc.FieldDescriptor, fact MessageFactory) (*desc.FieldDescriptor, interface{}, error) { + if cb.EOF() { + return nil, nil, io.EOF + } + tagNumber, wireType, err := cb.DecodeTagAndWireType() + if err != nil { + return nil, nil, err + } + if wireType == proto.WireEndGroup { + return nil, tagNumber, ErrWireTypeEndGroup + } + fd := fieldFinder(tagNumber) + if fd == nil { + val, err := cb.decodeUnknownField(tagNumber, wireType) + return nil, val, err + } + val, err := cb.decodeKnownField(fd, wireType, fact) + return fd, val, err +} + +// DecodeScalarField extracts a properly-typed value from v. The returned value's +// type depends on the given field descriptor type. It will be the same type as +// generated structs use for the field descriptor's type. Enum types will return +// an int32. If the given field type uses length-delimited encoding (nested +// messages, bytes, and strings), an error is returned. +func DecodeScalarField(fd *desc.FieldDescriptor, v uint64) (interface{}, error) { + switch fd.GetType() { + case descriptorpb.FieldDescriptorProto_TYPE_BOOL: + return v != 0, nil + case descriptorpb.FieldDescriptorProto_TYPE_UINT32, + descriptorpb.FieldDescriptorProto_TYPE_FIXED32: + if v > math.MaxUint32 { + return nil, ErrOverflow + } + return uint32(v), nil + + case descriptorpb.FieldDescriptorProto_TYPE_INT32, + descriptorpb.FieldDescriptorProto_TYPE_ENUM: + s := int64(v) + if s > math.MaxInt32 || s < math.MinInt32 { + return nil, ErrOverflow + } + return int32(s), nil + + case descriptorpb.FieldDescriptorProto_TYPE_SFIXED32: + if v > math.MaxUint32 { + return nil, ErrOverflow + } + return int32(v), nil + + case descriptorpb.FieldDescriptorProto_TYPE_SINT32: + if v > math.MaxUint32 { + return nil, ErrOverflow + } + return DecodeZigZag32(v), nil + + case descriptorpb.FieldDescriptorProto_TYPE_UINT64, + descriptorpb.FieldDescriptorProto_TYPE_FIXED64: + return v, nil + + case descriptorpb.FieldDescriptorProto_TYPE_INT64, + descriptorpb.FieldDescriptorProto_TYPE_SFIXED64: + return int64(v), nil + + case descriptorpb.FieldDescriptorProto_TYPE_SINT64: + return DecodeZigZag64(v), nil + + case descriptorpb.FieldDescriptorProto_TYPE_FLOAT: + if v > math.MaxUint32 { + return nil, ErrOverflow + } + return math.Float32frombits(uint32(v)), nil + + case descriptorpb.FieldDescriptorProto_TYPE_DOUBLE: + return math.Float64frombits(v), nil + + default: + // bytes, string, message, and group cannot be represented as a simple numeric value + return nil, fmt.Errorf("bad input; field %s requires length-delimited wire type", fd.GetFullyQualifiedName()) + } +} + +// DecodeLengthDelimitedField extracts a properly-typed value from bytes. The +// returned value's type will usually be []byte, string, or, for nested messages, +// the type returned from the given message factory. However, since repeated +// scalar fields can be length-delimited, when they used packed encoding, it can +// also return an []interface{}, where each element is a scalar value. Furthermore, +// it could return a scalar type, not in a slice, if the given field descriptor is +// not repeated. This is to support cases where a field is changed from optional +// to repeated. New code may emit a packed repeated representation, but old code +// still expects a single scalar value. In this case, if the actual data in bytes +// contains multiple values, only the last value is returned. +func DecodeLengthDelimitedField(fd *desc.FieldDescriptor, bytes []byte, mf MessageFactory) (interface{}, error) { + switch { + case fd.GetType() == descriptorpb.FieldDescriptorProto_TYPE_BYTES: + return bytes, nil + + case fd.GetType() == descriptorpb.FieldDescriptorProto_TYPE_STRING: + return string(bytes), nil + + case fd.GetType() == descriptorpb.FieldDescriptorProto_TYPE_MESSAGE || + fd.GetType() == descriptorpb.FieldDescriptorProto_TYPE_GROUP: + msg := mf.NewMessage(fd.GetMessageType()) + err := proto.Unmarshal(bytes, msg) + if err != nil { + return nil, err + } else { + return msg, nil + } + + default: + // even if the field is not repeated or not packed, we still parse it as such for + // backwards compatibility (e.g. message we are de-serializing could have been both + // repeated and packed at the time of serialization) + packedBuf := NewBuffer(bytes) + var slice []interface{} + var val interface{} + for !packedBuf.EOF() { + var v uint64 + var err error + if varintTypes[fd.GetType()] { + v, err = packedBuf.DecodeVarint() + } else if fixed32Types[fd.GetType()] { + v, err = packedBuf.DecodeFixed32() + } else if fixed64Types[fd.GetType()] { + v, err = packedBuf.DecodeFixed64() + } else { + return nil, fmt.Errorf("bad input; cannot parse length-delimited wire type for field %s", fd.GetFullyQualifiedName()) + } + if err != nil { + return nil, err + } + val, err = DecodeScalarField(fd, v) + if err != nil { + return nil, err + } + if fd.IsRepeated() { + slice = append(slice, val) + } + } + if fd.IsRepeated() { + return slice, nil + } else { + // if not a repeated field, last value wins + return val, nil + } + } +} + +func (b *Buffer) decodeKnownField(fd *desc.FieldDescriptor, encoding int8, fact MessageFactory) (interface{}, error) { + var val interface{} + var err error + switch encoding { + case proto.WireFixed32: + var num uint64 + num, err = b.DecodeFixed32() + if err == nil { + val, err = DecodeScalarField(fd, num) + } + case proto.WireFixed64: + var num uint64 + num, err = b.DecodeFixed64() + if err == nil { + val, err = DecodeScalarField(fd, num) + } + case proto.WireVarint: + var num uint64 + num, err = b.DecodeVarint() + if err == nil { + val, err = DecodeScalarField(fd, num) + } + + case proto.WireBytes: + alloc := fd.GetType() == descriptorpb.FieldDescriptorProto_TYPE_BYTES + var raw []byte + raw, err = b.DecodeRawBytes(alloc) + if err == nil { + val, err = DecodeLengthDelimitedField(fd, raw, fact) + } + + case proto.WireStartGroup: + if fd.GetMessageType() == nil { + return nil, fmt.Errorf("cannot parse field %s from group-encoded wire type", fd.GetFullyQualifiedName()) + } + msg := fact.NewMessage(fd.GetMessageType()) + var data []byte + data, err = b.ReadGroup(false) + if err == nil { + err = proto.Unmarshal(data, msg) + if err == nil { + val = msg + } + } + + default: + return nil, ErrBadWireType + } + if err != nil { + return nil, err + } + + return val, nil +} + +func (b *Buffer) decodeUnknownField(tagNumber int32, encoding int8) (interface{}, error) { + u := UnknownField{Tag: tagNumber, Encoding: encoding} + var err error + switch encoding { + case proto.WireFixed32: + u.Value, err = b.DecodeFixed32() + case proto.WireFixed64: + u.Value, err = b.DecodeFixed64() + case proto.WireVarint: + u.Value, err = b.DecodeVarint() + case proto.WireBytes: + u.Contents, err = b.DecodeRawBytes(true) + case proto.WireStartGroup: + u.Contents, err = b.ReadGroup(true) + default: + err = ErrBadWireType + } + if err != nil { + return nil, err + } + return u, nil +} diff --git a/vendor/github.com/jhump/protoreflect/codec/doc.go b/vendor/github.com/jhump/protoreflect/codec/doc.go new file mode 100644 index 0000000..f76499f --- /dev/null +++ b/vendor/github.com/jhump/protoreflect/codec/doc.go @@ -0,0 +1,7 @@ +// Package codec contains a reader/write type that assists with encoding +// and decoding protobuf's binary representation. +// +// The code in this package began as a fork of proto.Buffer but provides +// additional API to make it more useful to code that needs to dynamically +// process or produce the protobuf binary format. +package codec diff --git a/vendor/github.com/jhump/protoreflect/codec/encode_fields.go b/vendor/github.com/jhump/protoreflect/codec/encode_fields.go new file mode 100644 index 0000000..280f730 --- /dev/null +++ b/vendor/github.com/jhump/protoreflect/codec/encode_fields.go @@ -0,0 +1,288 @@ +package codec + +import ( + "fmt" + "math" + "reflect" + "sort" + + "github.com/golang/protobuf/proto" + "google.golang.org/protobuf/types/descriptorpb" + + "github.com/jhump/protoreflect/desc" +) + +// EncodeZigZag64 does zig-zag encoding to convert the given +// signed 64-bit integer into a form that can be expressed +// efficiently as a varint, even for negative values. +func EncodeZigZag64(v int64) uint64 { + return (uint64(v) << 1) ^ uint64(v>>63) +} + +// EncodeZigZag32 does zig-zag encoding to convert the given +// signed 32-bit integer into a form that can be expressed +// efficiently as a varint, even for negative values. +func EncodeZigZag32(v int32) uint64 { + return uint64((uint32(v) << 1) ^ uint32((v >> 31))) +} + +func (cb *Buffer) EncodeFieldValue(fd *desc.FieldDescriptor, val interface{}) error { + if fd.IsMap() { + mp := val.(map[interface{}]interface{}) + entryType := fd.GetMessageType() + keyType := entryType.FindFieldByNumber(1) + valType := entryType.FindFieldByNumber(2) + var entryBuffer Buffer + if cb.IsDeterministic() { + entryBuffer.SetDeterministic(true) + keys := make([]interface{}, 0, len(mp)) + for k := range mp { + keys = append(keys, k) + } + sort.Sort(sortable(keys)) + for _, k := range keys { + v := mp[k] + entryBuffer.Reset() + if err := entryBuffer.encodeFieldElement(keyType, k); err != nil { + return err + } + rv := reflect.ValueOf(v) + if rv.Kind() != reflect.Ptr || !rv.IsNil() { + if err := entryBuffer.encodeFieldElement(valType, v); err != nil { + return err + } + } + if err := cb.EncodeTagAndWireType(fd.GetNumber(), proto.WireBytes); err != nil { + return err + } + if err := cb.EncodeRawBytes(entryBuffer.Bytes()); err != nil { + return err + } + } + } else { + for k, v := range mp { + entryBuffer.Reset() + if err := entryBuffer.encodeFieldElement(keyType, k); err != nil { + return err + } + rv := reflect.ValueOf(v) + if rv.Kind() != reflect.Ptr || !rv.IsNil() { + if err := entryBuffer.encodeFieldElement(valType, v); err != nil { + return err + } + } + if err := cb.EncodeTagAndWireType(fd.GetNumber(), proto.WireBytes); err != nil { + return err + } + if err := cb.EncodeRawBytes(entryBuffer.Bytes()); err != nil { + return err + } + } + } + return nil + } else if fd.IsRepeated() { + sl := val.([]interface{}) + wt, err := getWireType(fd.GetType()) + if err != nil { + return err + } + if isPacked(fd) && len(sl) > 0 && + (wt == proto.WireVarint || wt == proto.WireFixed32 || wt == proto.WireFixed64) { + // packed repeated field + var packedBuffer Buffer + for _, v := range sl { + if err := packedBuffer.encodeFieldValue(fd, v); err != nil { + return err + } + } + if err := cb.EncodeTagAndWireType(fd.GetNumber(), proto.WireBytes); err != nil { + return err + } + return cb.EncodeRawBytes(packedBuffer.Bytes()) + } else { + // non-packed repeated field + for _, v := range sl { + if err := cb.encodeFieldElement(fd, v); err != nil { + return err + } + } + return nil + } + } else { + return cb.encodeFieldElement(fd, val) + } +} + +func isPacked(fd *desc.FieldDescriptor) bool { + opts := fd.AsFieldDescriptorProto().GetOptions() + // if set, use that value + if opts != nil && opts.Packed != nil { + return opts.GetPacked() + } + // if unset: proto2 defaults to false, proto3 to true + return fd.GetFile().IsProto3() +} + +// sortable is used to sort map keys. Values will be integers (int32, int64, uint32, and uint64), +// bools, or strings. +type sortable []interface{} + +func (s sortable) Len() int { + return len(s) +} + +func (s sortable) Less(i, j int) bool { + vi := s[i] + vj := s[j] + switch reflect.TypeOf(vi).Kind() { + case reflect.Int32: + return vi.(int32) < vj.(int32) + case reflect.Int64: + return vi.(int64) < vj.(int64) + case reflect.Uint32: + return vi.(uint32) < vj.(uint32) + case reflect.Uint64: + return vi.(uint64) < vj.(uint64) + case reflect.String: + return vi.(string) < vj.(string) + case reflect.Bool: + return !vi.(bool) && vj.(bool) + default: + panic(fmt.Sprintf("cannot compare keys of type %v", reflect.TypeOf(vi))) + } +} + +func (s sortable) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} + +func (b *Buffer) encodeFieldElement(fd *desc.FieldDescriptor, val interface{}) error { + wt, err := getWireType(fd.GetType()) + if err != nil { + return err + } + if err := b.EncodeTagAndWireType(fd.GetNumber(), wt); err != nil { + return err + } + if err := b.encodeFieldValue(fd, val); err != nil { + return err + } + if wt == proto.WireStartGroup { + return b.EncodeTagAndWireType(fd.GetNumber(), proto.WireEndGroup) + } + return nil +} + +func (b *Buffer) encodeFieldValue(fd *desc.FieldDescriptor, val interface{}) error { + switch fd.GetType() { + case descriptorpb.FieldDescriptorProto_TYPE_BOOL: + v := val.(bool) + if v { + return b.EncodeVarint(1) + } + return b.EncodeVarint(0) + + case descriptorpb.FieldDescriptorProto_TYPE_ENUM, + descriptorpb.FieldDescriptorProto_TYPE_INT32: + v := val.(int32) + return b.EncodeVarint(uint64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_SFIXED32: + v := val.(int32) + return b.EncodeFixed32(uint64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_SINT32: + v := val.(int32) + return b.EncodeVarint(EncodeZigZag32(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_UINT32: + v := val.(uint32) + return b.EncodeVarint(uint64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_FIXED32: + v := val.(uint32) + return b.EncodeFixed32(uint64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_INT64: + v := val.(int64) + return b.EncodeVarint(uint64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_SFIXED64: + v := val.(int64) + return b.EncodeFixed64(uint64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_SINT64: + v := val.(int64) + return b.EncodeVarint(EncodeZigZag64(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_UINT64: + v := val.(uint64) + return b.EncodeVarint(v) + + case descriptorpb.FieldDescriptorProto_TYPE_FIXED64: + v := val.(uint64) + return b.EncodeFixed64(v) + + case descriptorpb.FieldDescriptorProto_TYPE_DOUBLE: + v := val.(float64) + return b.EncodeFixed64(math.Float64bits(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_FLOAT: + v := val.(float32) + return b.EncodeFixed32(uint64(math.Float32bits(v))) + + case descriptorpb.FieldDescriptorProto_TYPE_BYTES: + v := val.([]byte) + return b.EncodeRawBytes(v) + + case descriptorpb.FieldDescriptorProto_TYPE_STRING: + v := val.(string) + return b.EncodeRawBytes(([]byte)(v)) + + case descriptorpb.FieldDescriptorProto_TYPE_MESSAGE: + return b.EncodeDelimitedMessage(val.(proto.Message)) + + case descriptorpb.FieldDescriptorProto_TYPE_GROUP: + // just append the nested message to this buffer + return b.EncodeMessage(val.(proto.Message)) + // whosoever writeth start-group tag (e.g. caller) is responsible for writing end-group tag + + default: + return fmt.Errorf("unrecognized field type: %v", fd.GetType()) + } +} + +func getWireType(t descriptorpb.FieldDescriptorProto_Type) (int8, error) { + switch t { + case descriptorpb.FieldDescriptorProto_TYPE_ENUM, + descriptorpb.FieldDescriptorProto_TYPE_BOOL, + descriptorpb.FieldDescriptorProto_TYPE_INT32, + descriptorpb.FieldDescriptorProto_TYPE_SINT32, + descriptorpb.FieldDescriptorProto_TYPE_UINT32, + descriptorpb.FieldDescriptorProto_TYPE_INT64, + descriptorpb.FieldDescriptorProto_TYPE_SINT64, + descriptorpb.FieldDescriptorProto_TYPE_UINT64: + return proto.WireVarint, nil + + case descriptorpb.FieldDescriptorProto_TYPE_FIXED32, + descriptorpb.FieldDescriptorProto_TYPE_SFIXED32, + descriptorpb.FieldDescriptorProto_TYPE_FLOAT: + return proto.WireFixed32, nil + + case descriptorpb.FieldDescriptorProto_TYPE_FIXED64, + descriptorpb.FieldDescriptorProto_TYPE_SFIXED64, + descriptorpb.FieldDescriptorProto_TYPE_DOUBLE: + return proto.WireFixed64, nil + + case descriptorpb.FieldDescriptorProto_TYPE_BYTES, + descriptorpb.FieldDescriptorProto_TYPE_STRING, + descriptorpb.FieldDescriptorProto_TYPE_MESSAGE: + return proto.WireBytes, nil + + case descriptorpb.FieldDescriptorProto_TYPE_GROUP: + return proto.WireStartGroup, nil + + default: + return 0, ErrBadWireType + } +} |