gRPC migration
Change-Id: Ib390f6dde0d5a8d6db12ccd7da41135570ad1354
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
index 71c755c..07da5db 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
@@ -15,6 +15,7 @@
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/flags"
+ "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/set"
"google.golang.org/protobuf/proto"
@@ -23,6 +24,7 @@
)
// Unmarshal reads the given []byte into the given proto.Message.
+// The provided message must be mutable (e.g., a non-nil pointer to a message).
func Unmarshal(b []byte, m proto.Message) error {
return UnmarshalOptions{}.Unmarshal(b, m)
}
@@ -47,11 +49,19 @@
}
}
-// Unmarshal reads the given []byte and populates the given proto.Message using
-// options in UnmarshalOptions object. It will clear the message first before
-// setting the fields. If it returns an error, the given message may be
-// partially set.
+// Unmarshal reads the given []byte and populates the given proto.Message
+// using options in the UnmarshalOptions object.
+// It will clear the message first before setting the fields.
+// If it returns an error, the given message may be partially set.
+// The provided message must be mutable (e.g., a non-nil pointer to a message).
func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
+ return o.unmarshal(b, m)
+}
+
+// unmarshal is a centralized function that all unmarshal operations go through.
+// For profiling purposes, avoid changing the name of this function or
+// introducing other code paths for unmarshal that do not go through this.
+func (o UnmarshalOptions) unmarshal(b []byte, m proto.Message) error {
proto.Reset(m)
if o.Resolver == nil {
@@ -104,8 +114,8 @@
// unmarshalMessage unmarshals a message into the given protoreflect.Message.
func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error {
- if isCustomType(m.Descriptor().FullName()) {
- return d.unmarshalCustomType(m)
+ if unmarshal := wellKnownTypeUnmarshaler(m.Descriptor().FullName()); unmarshal != nil {
+ return unmarshal(d, m)
}
tok, err := d.Read()
@@ -116,15 +126,6 @@
return d.unexpectedTokenError(tok)
}
- if err := d.unmarshalFields(m, skipTypeURL); err != nil {
- return err
- }
-
- return nil
-}
-
-// unmarshalFields unmarshals the fields into the given protoreflect.Message.
-func (d decoder) unmarshalFields(m pref.Message, skipTypeURL bool) error {
messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets")
@@ -162,7 +163,7 @@
if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
// Only extension names are in [name] format.
extName := pref.FullName(name[1 : len(name)-1])
- extType, err := d.findExtension(extName)
+ extType, err := d.opts.Resolver.FindExtensionByName(extName)
if err != nil && err != protoregistry.NotFound {
return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err)
}
@@ -176,17 +177,7 @@
// The name can either be the JSON name or the proto field name.
fd = fieldDescs.ByJSONName(name)
if fd == nil {
- fd = fieldDescs.ByName(pref.Name(name))
- if fd == nil {
- // The proto name of a group field is in all lowercase,
- // while the textual field name is the group message name.
- gd := fieldDescs.ByName(pref.Name(strings.ToLower(name)))
- if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == pref.Name(name) {
- fd = gd
- }
- } else if fd.Kind() == pref.GroupKind && fd.Message().Name() != pref.Name(name) {
- fd = nil // reset since field name is actually the message name
- }
+ fd = fieldDescs.ByTextName(name)
}
}
if flags.ProtoLegacy {
@@ -249,23 +240,14 @@
}
}
-// findExtension returns protoreflect.ExtensionType from the resolver if found.
-func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
- xt, err := d.opts.Resolver.FindExtensionByName(xtName)
- if err == nil {
- return xt, nil
- }
- return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
-}
-
func isKnownValue(fd pref.FieldDescriptor) bool {
md := fd.Message()
- return md != nil && md.FullName() == "google.protobuf.Value"
+ return md != nil && md.FullName() == genid.Value_message_fullname
}
func isNullValue(fd pref.FieldDescriptor) bool {
ed := fd.Enum()
- return ed != nil && ed.FullName() == "google.protobuf.NullValue"
+ return ed != nil && ed.FullName() == genid.NullValue_enum_fullname
}
// unmarshalSingular unmarshals to the non-repeated field specified
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
index e545feb..ba971f0 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
@@ -7,14 +7,17 @@
import (
"encoding/base64"
"fmt"
- "sort"
"google.golang.org/protobuf/internal/encoding/json"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
+ "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/flags"
+ "google.golang.org/protobuf/internal/genid"
+ "google.golang.org/protobuf/internal/order"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
@@ -104,6 +107,13 @@
// MarshalOptions. Do not depend on the output being stable. It may change over
// time across different versions of the program.
func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
+ return o.marshal(m)
+}
+
+// marshal is a centralized function that all marshal operations go through.
+// For profiling purposes, avoid changing the name of this function or
+// introducing other code paths for marshal that do not go through this.
+func (o MarshalOptions) marshal(m proto.Message) ([]byte, error) {
if o.Multiline && o.Indent == "" {
o.Indent = defaultIndent
}
@@ -123,7 +133,7 @@
}
enc := encoder{internalEnc, o}
- if err := enc.marshalMessage(m.ProtoReflect()); err != nil {
+ if err := enc.marshalMessage(m.ProtoReflect(), ""); err != nil {
return nil, err
}
if o.AllowPartial {
@@ -137,76 +147,94 @@
opts MarshalOptions
}
-// marshalMessage marshals the given protoreflect.Message.
-func (e encoder) marshalMessage(m pref.Message) error {
- if isCustomType(m.Descriptor().FullName()) {
- return e.marshalCustomType(m)
+// typeFieldDesc is a synthetic field descriptor used for the "@type" field.
+var typeFieldDesc = func() protoreflect.FieldDescriptor {
+ var fd filedesc.Field
+ fd.L0.FullName = "@type"
+ fd.L0.Index = -1
+ fd.L1.Cardinality = protoreflect.Optional
+ fd.L1.Kind = protoreflect.StringKind
+ return &fd
+}()
+
+// typeURLFieldRanger wraps a protoreflect.Message and modifies its Range method
+// to additionally iterate over a synthetic field for the type URL.
+type typeURLFieldRanger struct {
+ order.FieldRanger
+ typeURL string
+}
+
+func (m typeURLFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
+ if !f(typeFieldDesc, pref.ValueOfString(m.typeURL)) {
+ return
+ }
+ m.FieldRanger.Range(f)
+}
+
+// unpopulatedFieldRanger wraps a protoreflect.Message and modifies its Range
+// method to additionally iterate over unpopulated fields.
+type unpopulatedFieldRanger struct{ pref.Message }
+
+func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
+ fds := m.Descriptor().Fields()
+ for i := 0; i < fds.Len(); i++ {
+ fd := fds.Get(i)
+ if m.Has(fd) || fd.ContainingOneof() != nil {
+ continue // ignore populated fields and fields within a oneofs
+ }
+
+ v := m.Get(fd)
+ isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid()
+ isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil
+ if isProto2Scalar || isSingularMessage {
+ v = pref.Value{} // use invalid value to emit null
+ }
+ if !f(fd, v) {
+ return
+ }
+ }
+ m.Message.Range(f)
+}
+
+// marshalMessage marshals the fields in the given protoreflect.Message.
+// If the typeURL is non-empty, then a synthetic "@type" field is injected
+// containing the URL as the value.
+func (e encoder) marshalMessage(m pref.Message, typeURL string) error {
+ if !flags.ProtoLegacy && messageset.IsMessageSet(m.Descriptor()) {
+ return errors.New("no support for proto1 MessageSets")
+ }
+
+ if marshal := wellKnownTypeMarshaler(m.Descriptor().FullName()); marshal != nil {
+ return marshal(e, m)
}
e.StartObject()
defer e.EndObject()
- if err := e.marshalFields(m); err != nil {
- return err
+
+ var fields order.FieldRanger = m
+ if e.opts.EmitUnpopulated {
+ fields = unpopulatedFieldRanger{m}
+ }
+ if typeURL != "" {
+ fields = typeURLFieldRanger{fields, typeURL}
}
- return nil
-}
-
-// marshalFields marshals the fields in the given protoreflect.Message.
-func (e encoder) marshalFields(m pref.Message) error {
- messageDesc := m.Descriptor()
- if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
- return errors.New("no support for proto1 MessageSets")
- }
-
- // Marshal out known fields.
- fieldDescs := messageDesc.Fields()
- for i := 0; i < fieldDescs.Len(); {
- fd := fieldDescs.Get(i)
- if od := fd.ContainingOneof(); od != nil {
- fd = m.WhichOneof(od)
- i += od.Fields().Len()
- if fd == nil {
- continue // unpopulated oneofs are not affected by EmitUnpopulated
- }
- } else {
- i++
- }
-
- val := m.Get(fd)
- if !m.Has(fd) {
- if !e.opts.EmitUnpopulated {
- continue
- }
- isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid()
- isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil
- if isProto2Scalar || isSingularMessage {
- // Use invalid value to emit null.
- val = pref.Value{}
- }
- }
-
+ var err error
+ order.RangeFields(fields, order.IndexNameFieldOrder, func(fd pref.FieldDescriptor, v pref.Value) bool {
name := fd.JSONName()
if e.opts.UseProtoNames {
- name = string(fd.Name())
- // Use type name for group field name.
- if fd.Kind() == pref.GroupKind {
- name = string(fd.Message().Name())
- }
+ name = fd.TextName()
}
- if err := e.WriteName(name); err != nil {
- return err
- }
- if err := e.marshalValue(val, fd); err != nil {
- return err
- }
- }
- // Marshal out extensions.
- if err := e.marshalExtensions(m); err != nil {
- return err
- }
- return nil
+ if err = e.WriteName(name); err != nil {
+ return false
+ }
+ if err = e.marshalValue(v, fd); err != nil {
+ return false
+ }
+ return true
+ })
+ return err
}
// marshalValue marshals the given protoreflect.Value.
@@ -261,7 +289,7 @@
e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes()))
case pref.EnumKind:
- if fd.Enum().FullName() == "google.protobuf.NullValue" {
+ if fd.Enum().FullName() == genid.NullValue_enum_fullname {
e.WriteNull()
} else {
desc := fd.Enum().Values().ByNumber(val.Enum())
@@ -273,7 +301,7 @@
}
case pref.MessageKind, pref.GroupKind:
- if err := e.marshalMessage(val.Message()); err != nil {
+ if err := e.marshalMessage(val.Message(), ""); err != nil {
return err
}
@@ -297,98 +325,20 @@
return nil
}
-type mapEntry struct {
- key pref.MapKey
- value pref.Value
-}
-
// marshalMap marshals given protoreflect.Map.
func (e encoder) marshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
e.StartObject()
defer e.EndObject()
- // Get a sorted list based on keyType first.
- entries := make([]mapEntry, 0, mmap.Len())
- mmap.Range(func(key pref.MapKey, val pref.Value) bool {
- entries = append(entries, mapEntry{key: key, value: val})
+ var err error
+ order.RangeEntries(mmap, order.GenericKeyOrder, func(k pref.MapKey, v pref.Value) bool {
+ if err = e.WriteName(k.String()); err != nil {
+ return false
+ }
+ if err = e.marshalSingular(v, fd.MapValue()); err != nil {
+ return false
+ }
return true
})
- sortMap(fd.MapKey().Kind(), entries)
-
- // Write out sorted list.
- for _, entry := range entries {
- if err := e.WriteName(entry.key.String()); err != nil {
- return err
- }
- if err := e.marshalSingular(entry.value, fd.MapValue()); err != nil {
- return err
- }
- }
- return nil
-}
-
-// sortMap orders list based on value of key field for deterministic ordering.
-func sortMap(keyKind pref.Kind, values []mapEntry) {
- sort.Slice(values, func(i, j int) bool {
- switch keyKind {
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind,
- pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- return values[i].key.Int() < values[j].key.Int()
-
- case pref.Uint32Kind, pref.Fixed32Kind,
- pref.Uint64Kind, pref.Fixed64Kind:
- return values[i].key.Uint() < values[j].key.Uint()
- }
- return values[i].key.String() < values[j].key.String()
- })
-}
-
-// marshalExtensions marshals extension fields.
-func (e encoder) marshalExtensions(m pref.Message) error {
- type entry struct {
- key string
- value pref.Value
- desc pref.FieldDescriptor
- }
-
- // Get a sorted list based on field key first.
- var entries []entry
- m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
- if !fd.IsExtension() {
- return true
- }
-
- // For MessageSet extensions, the name used is the parent message.
- name := fd.FullName()
- if messageset.IsMessageSetExtension(fd) {
- name = name.Parent()
- }
-
- // Use [name] format for JSON field name.
- entries = append(entries, entry{
- key: string(name),
- value: v,
- desc: fd,
- })
- return true
- })
-
- // Sort extensions lexicographically.
- sort.Slice(entries, func(i, j int) bool {
- return entries[i].key < entries[j].key
- })
-
- // Write out sorted list.
- for _, entry := range entries {
- // JSON field name is the proto field name enclosed in [], similar to
- // textproto. This is consistent with Go v1 lib. C++ lib v3.7.0 does not
- // marshal out extension fields.
- if err := e.WriteName("[" + entry.key + "]"); err != nil {
- return err
- }
- if err := e.marshalValue(entry.value, entry.desc); err != nil {
- return err
- }
- }
- return nil
+ return err
}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
index 3c3ef14..72924a9 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
@@ -7,85 +7,93 @@
import (
"bytes"
"fmt"
+ "math"
"strconv"
"strings"
"time"
- "google.golang.org/protobuf/internal/detectknown"
"google.golang.org/protobuf/internal/encoding/json"
"google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/fieldnum"
+ "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect"
)
-// isCustomType returns true if type name has special JSON conversion rules.
-// The list of custom types here has to match the ones in marshalCustomType and
-// unmarshalCustomType.
-func isCustomType(name pref.FullName) bool {
- switch detectknown.Which(name) {
- case detectknown.AnyProto:
- case detectknown.TimestampProto:
- case detectknown.DurationProto:
- case detectknown.WrappersProto:
- case detectknown.StructProto:
- case detectknown.FieldMaskProto:
- case detectknown.EmptyProto:
- default:
- return false
+type marshalFunc func(encoder, pref.Message) error
+
+// wellKnownTypeMarshaler returns a marshal function if the message type
+// has specialized serialization behavior. It returns nil otherwise.
+func wellKnownTypeMarshaler(name pref.FullName) marshalFunc {
+ if name.Parent() == genid.GoogleProtobuf_package {
+ switch name.Name() {
+ case genid.Any_message_name:
+ return encoder.marshalAny
+ case genid.Timestamp_message_name:
+ return encoder.marshalTimestamp
+ case genid.Duration_message_name:
+ return encoder.marshalDuration
+ case genid.BoolValue_message_name,
+ genid.Int32Value_message_name,
+ genid.Int64Value_message_name,
+ genid.UInt32Value_message_name,
+ genid.UInt64Value_message_name,
+ genid.FloatValue_message_name,
+ genid.DoubleValue_message_name,
+ genid.StringValue_message_name,
+ genid.BytesValue_message_name:
+ return encoder.marshalWrapperType
+ case genid.Struct_message_name:
+ return encoder.marshalStruct
+ case genid.ListValue_message_name:
+ return encoder.marshalListValue
+ case genid.Value_message_name:
+ return encoder.marshalKnownValue
+ case genid.FieldMask_message_name:
+ return encoder.marshalFieldMask
+ case genid.Empty_message_name:
+ return encoder.marshalEmpty
+ }
}
- return true
+ return nil
}
-// marshalCustomType marshals given well-known type message that have special
-// JSON conversion rules. It needs to be a message type where isCustomType
-// returns true, else it will panic.
-func (e encoder) marshalCustomType(m pref.Message) error {
- name := m.Descriptor().FullName()
- switch detectknown.Which(name) {
- case detectknown.AnyProto:
- return e.marshalAny(m)
- case detectknown.TimestampProto:
- return e.marshalTimestamp(m)
- case detectknown.DurationProto:
- return e.marshalDuration(m)
- case detectknown.WrappersProto:
- return e.marshalWrapperType(m)
- case detectknown.StructProto:
- return e.marshalStructType(m)
- case detectknown.FieldMaskProto:
- return e.marshalFieldMask(m)
- case detectknown.EmptyProto:
- return e.marshalEmpty(m)
- default:
- panic(fmt.Sprintf("%s does not have a custom marshaler", name))
- }
-}
+type unmarshalFunc func(decoder, pref.Message) error
-// unmarshalCustomType unmarshals given well-known type message that have
-// special JSON conversion rules. It needs to be a message type where
-// isCustomType returns true, else it will panic.
-func (d decoder) unmarshalCustomType(m pref.Message) error {
- name := m.Descriptor().FullName()
- switch detectknown.Which(name) {
- case detectknown.AnyProto:
- return d.unmarshalAny(m)
- case detectknown.TimestampProto:
- return d.unmarshalTimestamp(m)
- case detectknown.DurationProto:
- return d.unmarshalDuration(m)
- case detectknown.WrappersProto:
- return d.unmarshalWrapperType(m)
- case detectknown.StructProto:
- return d.unmarshalStructType(m)
- case detectknown.FieldMaskProto:
- return d.unmarshalFieldMask(m)
- case detectknown.EmptyProto:
- return d.unmarshalEmpty(m)
- default:
- panic(fmt.Sprintf("%s does not have a custom unmarshaler", name))
+// wellKnownTypeUnmarshaler returns a unmarshal function if the message type
+// has specialized serialization behavior. It returns nil otherwise.
+func wellKnownTypeUnmarshaler(name pref.FullName) unmarshalFunc {
+ if name.Parent() == genid.GoogleProtobuf_package {
+ switch name.Name() {
+ case genid.Any_message_name:
+ return decoder.unmarshalAny
+ case genid.Timestamp_message_name:
+ return decoder.unmarshalTimestamp
+ case genid.Duration_message_name:
+ return decoder.unmarshalDuration
+ case genid.BoolValue_message_name,
+ genid.Int32Value_message_name,
+ genid.Int64Value_message_name,
+ genid.UInt32Value_message_name,
+ genid.UInt64Value_message_name,
+ genid.FloatValue_message_name,
+ genid.DoubleValue_message_name,
+ genid.StringValue_message_name,
+ genid.BytesValue_message_name:
+ return decoder.unmarshalWrapperType
+ case genid.Struct_message_name:
+ return decoder.unmarshalStruct
+ case genid.ListValue_message_name:
+ return decoder.unmarshalListValue
+ case genid.Value_message_name:
+ return decoder.unmarshalKnownValue
+ case genid.FieldMask_message_name:
+ return decoder.unmarshalFieldMask
+ case genid.Empty_message_name:
+ return decoder.unmarshalEmpty
+ }
}
+ return nil
}
// The JSON representation of an Any message uses the regular representation of
@@ -96,37 +104,29 @@
func (e encoder) marshalAny(m pref.Message) error {
fds := m.Descriptor().Fields()
- fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
- fdValue := fds.ByNumber(fieldnum.Any_Value)
-
- // Start writing the JSON object.
- e.StartObject()
- defer e.EndObject()
+ fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
+ fdValue := fds.ByNumber(genid.Any_Value_field_number)
if !m.Has(fdType) {
if !m.Has(fdValue) {
// If message is empty, marshal out empty JSON object.
+ e.StartObject()
+ e.EndObject()
return nil
} else {
// Return error if type_url field is not set, but value is set.
- return errors.New("%s: type_url is not set", m.Descriptor().FullName())
+ return errors.New("%s: %v is not set", genid.Any_message_fullname, genid.Any_TypeUrl_field_name)
}
}
typeVal := m.Get(fdType)
valueVal := m.Get(fdValue)
- // Marshal out @type field.
- typeURL := typeVal.String()
- e.WriteName("@type")
- if err := e.WriteString(typeURL); err != nil {
- return err
- }
-
// Resolve the type in order to unmarshal value field.
+ typeURL := typeVal.String()
emt, err := e.opts.Resolver.FindMessageByURL(typeURL)
if err != nil {
- return errors.New("%s: unable to resolve %q: %v", m.Descriptor().FullName(), typeURL, err)
+ return errors.New("%s: unable to resolve %q: %v", genid.Any_message_fullname, typeURL, err)
}
em := emt.New()
@@ -135,19 +135,28 @@
Resolver: e.opts.Resolver,
}.Unmarshal(valueVal.Bytes(), em.Interface())
if err != nil {
- return errors.New("%s: unable to unmarshal %q: %v", m.Descriptor().FullName(), typeURL, err)
+ return errors.New("%s: unable to unmarshal %q: %v", genid.Any_message_fullname, typeURL, err)
}
// If type of value has custom JSON encoding, marshal out a field "value"
// with corresponding custom JSON encoding of the embedded message as a
// field.
- if isCustomType(emt.Descriptor().FullName()) {
+ if marshal := wellKnownTypeMarshaler(emt.Descriptor().FullName()); marshal != nil {
+ e.StartObject()
+ defer e.EndObject()
+
+ // Marshal out @type field.
+ e.WriteName("@type")
+ if err := e.WriteString(typeURL); err != nil {
+ return err
+ }
+
e.WriteName("value")
- return e.marshalCustomType(em)
+ return marshal(e, em)
}
// Else, marshal out the embedded message's fields in this Any object.
- if err := e.marshalFields(em); err != nil {
+ if err := e.marshalMessage(em, typeURL); err != nil {
return err
}
@@ -198,10 +207,10 @@
// Create new message for the embedded message type and unmarshal into it.
em := emt.New()
- if isCustomType(emt.Descriptor().FullName()) {
+ if unmarshal := wellKnownTypeUnmarshaler(emt.Descriptor().FullName()); unmarshal != nil {
// If embedded message is a custom type,
// unmarshal the JSON "value" field into it.
- if err := d.unmarshalAnyValue(em); err != nil {
+ if err := d.unmarshalAnyValue(unmarshal, em); err != nil {
return err
}
} else {
@@ -221,8 +230,8 @@
}
fds := m.Descriptor().Fields()
- fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
- fdValue := fds.ByNumber(fieldnum.Any_Value)
+ fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
+ fdValue := fds.ByNumber(genid.Any_Value_field_number)
m.Set(fdType, pref.ValueOfString(typeURL))
m.Set(fdValue, pref.ValueOfBytes(b))
@@ -345,7 +354,7 @@
// unmarshalAnyValue unmarshals the given custom-type message from the JSON
// object's "value" field.
-func (d decoder) unmarshalAnyValue(m pref.Message) error {
+func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m pref.Message) error {
// Skip ObjectOpen, and start reading the fields.
d.Read()
@@ -373,7 +382,7 @@
return d.newError(tok.Pos(), `duplicate "value" field`)
}
// Unmarshal the field value into the given message.
- if err := d.unmarshalCustomType(m); err != nil {
+ if err := unmarshal(d, m); err != nil {
return err
}
found = true
@@ -393,17 +402,14 @@
// Wrapper types are encoded as JSON primitives like string, number or boolean.
-// The "value" field has the same field number for all wrapper types.
-const wrapperFieldNumber = fieldnum.BoolValue_Value
-
func (e encoder) marshalWrapperType(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(wrapperFieldNumber)
+ fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val := m.Get(fd)
return e.marshalSingular(val, fd)
}
func (d decoder) unmarshalWrapperType(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(wrapperFieldNumber)
+ fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val, err := d.unmarshalScalar(fd)
if err != nil {
return err
@@ -453,42 +459,16 @@
}
}
-func (e encoder) marshalStructType(m pref.Message) error {
- switch m.Descriptor().Name() {
- case "Struct":
- return e.marshalStruct(m)
- case "ListValue":
- return e.marshalListValue(m)
- case "Value":
- return e.marshalKnownValue(m)
- default:
- panic(fmt.Sprintf("invalid struct type: %v", m.Descriptor().FullName()))
- }
-}
-
-func (d decoder) unmarshalStructType(m pref.Message) error {
- switch m.Descriptor().Name() {
- case "Struct":
- return d.unmarshalStruct(m)
- case "ListValue":
- return d.unmarshalListValue(m)
- case "Value":
- return d.unmarshalKnownValue(m)
- default:
- panic(fmt.Sprintf("invalid struct type: %v", m.Descriptor().FullName()))
- }
-}
-
// The JSON representation for Struct is a JSON object that contains the encoded
// Struct.fields map and follows the serialization rules for a map.
func (e encoder) marshalStruct(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(fieldnum.Struct_Fields)
+ fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return e.marshalMap(m.Get(fd).Map(), fd)
}
func (d decoder) unmarshalStruct(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(fieldnum.Struct_Fields)
+ fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return d.unmarshalMap(m.Mutable(fd).Map(), fd)
}
@@ -497,12 +477,12 @@
// repeated field.
func (e encoder) marshalListValue(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(fieldnum.ListValue_Values)
+ fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return e.marshalList(m.Get(fd).List(), fd)
}
func (d decoder) unmarshalListValue(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(fieldnum.ListValue_Values)
+ fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return d.unmarshalList(m.Mutable(fd).List(), fd)
}
@@ -511,10 +491,15 @@
// Value message needs to be a oneof field set, else it is an error.
func (e encoder) marshalKnownValue(m pref.Message) error {
- od := m.Descriptor().Oneofs().ByName("kind")
+ od := m.Descriptor().Oneofs().ByName(genid.Value_Kind_oneof_name)
fd := m.WhichOneof(od)
if fd == nil {
- return errors.New("%s: none of the oneof fields is set", m.Descriptor().FullName())
+ return errors.New("%s: none of the oneof fields is set", genid.Value_message_fullname)
+ }
+ if fd.Number() == genid.Value_NumberValue_field_number {
+ if v := m.Get(fd).Float(); math.IsNaN(v) || math.IsInf(v, 0) {
+ return errors.New("%s: invalid %v value", genid.Value_NumberValue_field_fullname, v)
+ }
}
return e.marshalSingular(m.Get(fd), fd)
}
@@ -530,7 +515,7 @@
switch tok.Kind() {
case json.Null:
d.Read()
- fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_NullValue)
+ fd = m.Descriptor().Fields().ByNumber(genid.Value_NullValue_field_number)
val = pref.ValueOfEnum(0)
case json.Bool:
@@ -538,7 +523,7 @@
if err != nil {
return err
}
- fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_BoolValue)
+ fd = m.Descriptor().Fields().ByNumber(genid.Value_BoolValue_field_number)
val = pref.ValueOfBool(tok.Bool())
case json.Number:
@@ -546,11 +531,11 @@
if err != nil {
return err
}
- fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_NumberValue)
+ fd = m.Descriptor().Fields().ByNumber(genid.Value_NumberValue_field_number)
var ok bool
val, ok = unmarshalFloat(tok, 64)
if !ok {
- return d.newError(tok.Pos(), "invalid google.protobuf.Value: %v", tok.RawString())
+ return d.newError(tok.Pos(), "invalid %v: %v", genid.Value_message_fullname, tok.RawString())
}
case json.String:
@@ -564,25 +549,25 @@
if err != nil {
return err
}
- fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_StringValue)
+ fd = m.Descriptor().Fields().ByNumber(genid.Value_StringValue_field_number)
val = pref.ValueOfString(tok.ParsedString())
case json.ObjectOpen:
- fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_StructValue)
+ fd = m.Descriptor().Fields().ByNumber(genid.Value_StructValue_field_number)
val = m.NewField(fd)
if err := d.unmarshalStruct(val.Message()); err != nil {
return err
}
case json.ArrayOpen:
- fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_ListValue)
+ fd = m.Descriptor().Fields().ByNumber(genid.Value_ListValue_field_number)
val = m.NewField(fd)
if err := d.unmarshalListValue(val.Message()); err != nil {
return err
}
default:
- return d.newError(tok.Pos(), "invalid google.protobuf.Value: %v", tok.RawString())
+ return d.newError(tok.Pos(), "invalid %v: %v", genid.Value_message_fullname, tok.RawString())
}
m.Set(fd, val)
@@ -608,32 +593,29 @@
func (e encoder) marshalDuration(m pref.Message) error {
fds := m.Descriptor().Fields()
- fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
- fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
+ fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
+ fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
secsVal := m.Get(fdSeconds)
nanosVal := m.Get(fdNanos)
secs := secsVal.Int()
nanos := nanosVal.Int()
if secs < -maxSecondsInDuration || secs > maxSecondsInDuration {
- return errors.New("%s: seconds out of range %v", m.Descriptor().FullName(), secs)
+ return errors.New("%s: seconds out of range %v", genid.Duration_message_fullname, secs)
}
if nanos < -secondsInNanos || nanos > secondsInNanos {
- return errors.New("%s: nanos out of range %v", m.Descriptor().FullName(), nanos)
+ return errors.New("%s: nanos out of range %v", genid.Duration_message_fullname, nanos)
}
if (secs > 0 && nanos < 0) || (secs < 0 && nanos > 0) {
- return errors.New("%s: signs of seconds and nanos do not match", m.Descriptor().FullName())
+ return errors.New("%s: signs of seconds and nanos do not match", genid.Duration_message_fullname)
}
// Generated output always contains 0, 3, 6, or 9 fractional digits,
// depending on required precision, followed by the suffix "s".
- f := "%d.%09d"
- if nanos < 0 {
- nanos = -nanos
- if secs == 0 {
- f = "-%d.%09d"
- }
+ var sign string
+ if secs < 0 || nanos < 0 {
+ sign, secs, nanos = "-", -1*secs, -1*nanos
}
- x := fmt.Sprintf(f, secs, nanos)
+ x := fmt.Sprintf("%s%d.%09d", sign, secs, nanos)
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, ".000")
@@ -652,17 +634,17 @@
secs, nanos, ok := parseDuration(tok.ParsedString())
if !ok {
- return d.newError(tok.Pos(), "invalid google.protobuf.Duration value %v", tok.RawString())
+ return d.newError(tok.Pos(), "invalid %v value %v", genid.Duration_message_fullname, tok.RawString())
}
// Validate seconds. No need to validate nanos because parseDuration would
// have covered that already.
if secs < -maxSecondsInDuration || secs > maxSecondsInDuration {
- return d.newError(tok.Pos(), "google.protobuf.Duration value out of range: %v", tok.RawString())
+ return d.newError(tok.Pos(), "%v value out of range: %v", genid.Duration_message_fullname, tok.RawString())
}
fds := m.Descriptor().Fields()
- fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
- fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
+ fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
+ fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
m.Set(fdSeconds, pref.ValueOfInt64(secs))
m.Set(fdNanos, pref.ValueOfInt32(nanos))
@@ -799,18 +781,18 @@
func (e encoder) marshalTimestamp(m pref.Message) error {
fds := m.Descriptor().Fields()
- fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
- fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
+ fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
+ fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
secsVal := m.Get(fdSeconds)
nanosVal := m.Get(fdNanos)
secs := secsVal.Int()
nanos := nanosVal.Int()
if secs < minTimestampSeconds || secs > maxTimestampSeconds {
- return errors.New("%s: seconds out of range %v", m.Descriptor().FullName(), secs)
+ return errors.New("%s: seconds out of range %v", genid.Timestamp_message_fullname, secs)
}
if nanos < 0 || nanos > secondsInNanos {
- return errors.New("%s: nanos out of range %v", m.Descriptor().FullName(), nanos)
+ return errors.New("%s: nanos out of range %v", genid.Timestamp_message_fullname, nanos)
}
// Uses RFC 3339, where generated output will be Z-normalized and uses 0, 3,
// 6 or 9 fractional digits.
@@ -834,18 +816,18 @@
t, err := time.Parse(time.RFC3339Nano, tok.ParsedString())
if err != nil {
- return d.newError(tok.Pos(), "invalid google.protobuf.Timestamp value %v", tok.RawString())
+ return d.newError(tok.Pos(), "invalid %v value %v", genid.Timestamp_message_fullname, tok.RawString())
}
// Validate seconds. No need to validate nanos because time.Parse would have
// covered that already.
secs := t.Unix()
if secs < minTimestampSeconds || secs > maxTimestampSeconds {
- return d.newError(tok.Pos(), "google.protobuf.Timestamp value out of range: %v", tok.RawString())
+ return d.newError(tok.Pos(), "%v value out of range: %v", genid.Timestamp_message_fullname, tok.RawString())
}
fds := m.Descriptor().Fields()
- fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
- fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
+ fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
+ fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
m.Set(fdSeconds, pref.ValueOfInt64(secs))
m.Set(fdNanos, pref.ValueOfInt32(int32(t.Nanosecond())))
@@ -858,16 +840,19 @@
// end up differently after a round-trip.
func (e encoder) marshalFieldMask(m pref.Message) error {
- fd := m.Descriptor().Fields().ByNumber(fieldnum.FieldMask_Paths)
+ fd := m.Descriptor().Fields().ByNumber(genid.FieldMask_Paths_field_number)
list := m.Get(fd).List()
paths := make([]string, 0, list.Len())
for i := 0; i < list.Len(); i++ {
s := list.Get(i).String()
+ if !pref.FullName(s).IsValid() {
+ return errors.New("%s contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s)
+ }
// Return error if conversion to camelCase is not reversible.
cc := strs.JSONCamelCase(s)
if s != strs.JSONSnakeCase(cc) {
- return errors.New("%s.paths contains irreversible value %q", m.Descriptor().FullName(), s)
+ return errors.New("%s contains irreversible value %q", genid.FieldMask_Paths_field_fullname, s)
}
paths = append(paths, cc)
}
@@ -890,14 +875,15 @@
}
paths := strings.Split(str, ",")
- fd := m.Descriptor().Fields().ByNumber(fieldnum.FieldMask_Paths)
+ fd := m.Descriptor().Fields().ByNumber(genid.FieldMask_Paths_field_number)
list := m.Mutable(fd).List()
- for _, s := range paths {
- s = strings.TrimSpace(s)
- // Convert to snake_case. Unlike encoding, no validation is done because
- // it is not possible to know the original path names.
- list.Append(pref.ValueOfString(strs.JSONSnakeCase(s)))
+ for _, s0 := range paths {
+ s := strs.JSONSnakeCase(s0)
+ if strings.Contains(s0, "_") || !pref.FullName(s).IsValid() {
+ return d.newError(tok.Pos(), "%v contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s0)
+ }
+ list.Append(pref.ValueOfString(s))
}
return nil
}