// 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 protojson
import (
"encoding/base64"
"fmt"
"math"
"strconv"
"strings"
"google.golang.org/protobuf/encoding/protowire"
"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/flags"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/set"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
// 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)
}
// UnmarshalOptions is a configurable JSON format parser.
type UnmarshalOptions struct {
pragma.NoUnkeyedLiterals
// If AllowPartial is set, input for messages that will result in missing
// required fields will not return an error.
AllowPartial bool
// If DiscardUnknown is set, unknown fields and enum name values are ignored.
DiscardUnknown bool
// Resolver is used for looking up types when unmarshaling
// google.protobuf.Any messages or extension fields.
// If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
protoregistry.MessageTypeResolver
protoregistry.ExtensionTypeResolver
}
// RecursionLimit limits how deeply messages may be nested.
// If zero, a default limit is applied.
RecursionLimit int
}
// 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 {
o.Resolver = protoregistry.GlobalTypes
}
if o.RecursionLimit == 0 {
o.RecursionLimit = protowire.DefaultRecursionLimit
}
dec := decoder{json.NewDecoder(b), o}
if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
return err
}
// Check for EOF.
tok, err := dec.Read()
if err != nil {
return err
}
if tok.Kind() != json.EOF {
return dec.unexpectedTokenError(tok)
}
if o.AllowPartial {
return nil
}
return proto.CheckInitialized(m)
}
type decoder struct {
*json.Decoder
opts UnmarshalOptions
}
// newError returns an error object with position info.
func (d decoder) newError(pos int, f string, x ...any) error {
line, column := d.Position(pos)
head := fmt.Sprintf("(line %d:%d): ", line, column)
return errors.New(head+f, x...)
}
// unexpectedTokenError returns a syntax error for the given unexpected token.
func (d decoder) unexpectedTokenError(tok json.Token) error {
return d.syntaxError(tok.Pos(), "unexpected token %s", tok.RawString())
}
// syntaxError returns a syntax error for given position.
func (d decoder) syntaxError(pos int, f string, x ...any) error {
line, column := d.Position(pos)
head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
return errors.New(head+f, x...)
}
// unmarshalMessage unmarshals a message into the given protoreflect.Message.
func (d decoder) unmarshalMessage(m protoreflect.Message, skipTypeURL bool) error {
d.opts.RecursionLimit--
if d.opts.RecursionLimit < 0 {
return errors.New("exceeded max recursion depth")
}
if unmarshal := wellKnownTypeUnmarshaler(m.Descriptor().FullName()); unmarshal != nil {
return unmarshal(d, m)
}
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.ObjectOpen {
return d.unexpectedTokenError(tok)
}
messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets")
}
var seenNums set.Ints
var seenOneofs set.Ints
fieldDescs := messageDesc.Fields()
for {
// Read field name.
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
default:
return d.unexpectedTokenError(tok)
case json.ObjectClose:
return nil
case json.Name:
// Continue below.
}
name := tok.Name()
// Unmarshaling a non-custom embedded message in Any will contain the
// JSON field "@type" which should be skipped because it is not a field
// of the embedded message, but simply an artifact of the Any format.
if skipTypeURL && name == "@type" {
d.Read()
continue
}
// Get the FieldDescriptor.
var fd protoreflect.FieldDescriptor
if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
// Only extension names are in [name] format.
extName := protoreflect.FullName(name[1 : len(name)-1])
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)
}
if extType != nil {
fd = extType.TypeDescriptor()
if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
}
}
} else {
// The name can either be the JSON name or the proto field name.
fd = fieldDescs.ByJSONName(name)
if fd == nil {
fd = fieldDescs.ByTextName(name)
}
}
if fd == nil {
// Field is unknown.
if d.opts.DiscardUnknown {
if err := d.skipJSONValue(); err != nil {
return err
}
continue
}
return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
}
// Do not allow duplicate fields.
num := uint64(fd.Number())
if seenNums.Has(num) {
return d.newError(tok.Pos(), "duplicate field %v", tok.RawString())
}
seenNums.Set(num)
// No need to set values for JSON null unless the field type is
// google.protobuf.Value or google.protobuf.NullValue.
if tok, _ := d.Peek(); tok.Kind() == json.Null && !isKnownValue(fd) && !isNullValue(fd) {
d.Read()
continue
}
switch {
case fd.IsList():
list := m.Mutable(fd).List()
if err := d.unmarshalList(list, fd); err != nil {
return err
}
case fd.IsMap():
mmap := m.Mutable(fd).Map()
if err := d.unmarshalMap(mmap, fd); err != nil {
return err
}
default:
// If field is a oneof, check if it has already been set.
if od := fd.ContainingOneof(); od != nil {
idx := uint64(od.Index())
if seenOneofs.Has(idx) {
return d.newError(tok.Pos(), "error parsing %s, oneof %v is already set", tok.RawString(), od.FullName())
}
seenOneofs.Set(idx)
}
// Required or optional fields.
if err := d.unmarshalSingular(m, fd); err != nil {
return err
}
}
}
}
func isKnownValue(fd protoreflect.FieldDescriptor) bool {
md := fd.Message()
return md != nil && md.FullName() == genid.Value_message_fullname
}
func isNullValue(fd protoreflect.FieldDescriptor) bool {
ed := fd.Enum()
return ed != nil && ed.FullName() == genid.NullValue_enum_fullname
}
// unmarshalSingular unmarshals to the non-repeated field specified
// by the given FieldDescriptor.
func (d decoder) unmarshalSingular(m protoreflect.Message, fd protoreflect.FieldDescriptor) error {
var val protoreflect.Value
var err error
switch fd.Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
val = m.NewField(fd)
err = d.unmarshalMessage(val.Message(), false)
default:
val, err = d.unmarshalScalar(fd)
}
if err != nil {
return err
}
if val.IsValid() {
m.Set(fd, val)
}
return nil
}
// unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by
// the given FieldDescriptor.
func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
const b32 int = 32
const b64 int = 64
tok, err := d.Read()
if err != nil {
return protoreflect.Value{}, err
}
kind := fd.Kind()
switch kind {
case protoreflect.BoolKind:
if tok.Kind() == json.Bool {
return protoreflect.ValueOfBool(tok.Bool()), nil
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if v, ok := unmarshalInt(tok, b32); ok {
return v, nil
}
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if v, ok := unmarshalInt(tok, b64); ok {
return v, nil
}
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if v, ok := unmarshalUint(tok, b32); ok {
return v, nil
}
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if v, ok := unmarshalUint(tok, b64); ok {
return v, nil
}
case protoreflect.FloatKind:
if v, ok := unmarshalFloat(tok, b32); ok {
return v, nil
}
case protoreflect.DoubleKind:
if v, ok := unmarshalFloat(tok, b64); ok {
return v, nil
}
case protoreflect.StringKind:
if tok.Kind() == json.String {
return protoreflect.ValueOfString(tok.ParsedString()), nil
}
case protoreflect.BytesKind:
if v, ok := unmarshalBytes(tok); ok {
return v, nil
}
case protoreflect.EnumKind:
if v, ok := unmarshalEnum(tok, fd, d.opts.DiscardUnknown); ok {
return v, nil
}
default:
panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
}
return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v field %v: %v", kind, fd.JSONName(), tok.RawString())
}
func unmarshalInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.Number:
return getInt(tok, bitSize)
case json.String:
// Decode number from string.
s := strings.TrimSpace(tok.ParsedString())
if len(s) != len(tok.ParsedString()) {
return protoreflect.Value{}, false
}
dec := json.NewDecoder([]byte(s))
tok, err := dec.Read()
if err != nil {
return protoreflect.Value{}, false
}
return getInt(tok, bitSize)
}
return protoreflect.Value{}, false
}
func getInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Int(bitSize)
if !ok {
return protoreflect.Value{}, false
}
if bitSize == 32 {
return protoreflect.ValueOfInt32(int32(n)), true
}
return protoreflect.ValueOfInt64(n), true
}
func unmarshalUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.Number:
return getUint(tok, bitSize)
case json.String:
// Decode number from string.
s := strings.TrimSpace(tok.ParsedString())
if len(s) != len(tok.ParsedString()) {
return protoreflect.Value{}, false
}
dec := json.NewDecoder([]byte(s))
tok, err := dec.Read()
if err != nil {
return protoreflect.Value{}, false
}
return getUint(tok, bitSize)
}
return protoreflect.Value{}, false
}
func getUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Uint(bitSize)
if !ok {
return protoreflect.Value{}, false
}
if bitSize == 32 {
return protoreflect.ValueOfUint32(uint32(n)), true
}
return protoreflect.ValueOfUint64(n), true
}
func unmarshalFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.Number:
return getFloat(tok, bitSize)
case json.String:
s := tok.ParsedString()
switch s {
case "NaN":
if bitSize == 32 {
return protoreflect.ValueOfFloat32(float32(math.NaN())), true
}
return protoreflect.ValueOfFloat64(math.NaN()), true
case "Infinity":
if bitSize == 32 {
return protoreflect.ValueOfFloat32(float32(math.Inf(+1))), true
}
return protoreflect.ValueOfFloat64(math.Inf(+1)), true
case "-Infinity":
if bitSize == 32 {
return protoreflect.ValueOfFloat32(float32(math.Inf(-1))), true
}
return protoreflect.ValueOfFloat64(math.Inf(-1)), true
}
// Decode number from string.
if len(s) != len(strings.TrimSpace(s)) {
return protoreflect.Value{}, false
}
dec := json.NewDecoder([]byte(s))
tok, err := dec.Read()
if err != nil {
return protoreflect.Value{}, false
}
return getFloat(tok, bitSize)
}
return protoreflect.Value{}, false
}
func getFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Float(bitSize)
if !ok {
return protoreflect.Value{}, false
}
if bitSize == 32 {
return protoreflect.ValueOfFloat32(float32(n)), true
}
return protoreflect.ValueOfFloat64(n), true
}
func unmarshalBytes(tok json.Token) (protoreflect.Value, bool) {
if tok.Kind() != json.String {
return protoreflect.Value{}, false
}
s := tok.ParsedString()
enc := base64.StdEncoding
if strings.ContainsAny(s, "-_") {
enc = base64.URLEncoding
}
if len(s)%4 != 0 {
enc = enc.WithPadding(base64.NoPadding)
}
b, err := enc.DecodeString(s)
if err != nil {
return protoreflect.Value{}, false
}
return protoreflect.ValueOfBytes(b), true
}
func unmarshalEnum(tok json.Token, fd protoreflect.FieldDescriptor, discardUnknown bool) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.String:
// Lookup EnumNumber based on name.
s := tok.ParsedString()
if enumVal := fd.Enum().Values().ByName(protoreflect.Name(s)); enumVal != nil {
return protoreflect.ValueOfEnum(enumVal.Number()), true
}
if discardUnknown {
return protoreflect.Value{}, true
}
case json.Number:
if n, ok := tok.Int(32); ok {
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(n)), true
}
case json.Null:
// This is only valid for google.protobuf.NullValue.
if isNullValue(fd) {
return protoreflect.ValueOfEnum(0), true
}
}
return protoreflect.Value{}, false
}
func (d decoder) unmarshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.ArrayOpen {
return d.unexpectedTokenError(tok)
}
switch fd.Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
for {
tok, err := d.Peek()
if err != nil {
return err
}
if tok.Kind() == json.ArrayClose {
d.Read()
return nil
}
val := list.NewElement()
if err := d.unmarshalMessage(val.Message(), false); err != nil {
return err
}
list.Append(val)
}
default:
for {
tok, err := d.Peek()
if err != nil {
return err
}
if tok.Kind() == json.ArrayClose {
d.Read()
return nil
}
val, err := d.unmarshalScalar(fd)
if err != nil {
return err
}
if val.IsValid() {
list.Append(val)
}
}
}
return nil
}
func (d decoder) unmarshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.ObjectOpen {
return d.unexpectedTokenError(tok)
}
// Determine ahead whether map entry is a scalar type or a message type in
// order to call the appropriate unmarshalMapValue func inside the for loop
// below.
var unmarshalMapValue func() (protoreflect.Value, error)
switch fd.MapValue().Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
unmarshalMapValue = func() (protoreflect.Value, error) {
val := mmap.NewValue()
if err := d.unmarshalMessage(val.Message(), false); err != nil {
return protoreflect.Value{}, err
}
return val, nil
}
default:
unmarshalMapValue = func() (protoreflect.Value, error) {
return d.unmarshalScalar(fd.MapValue())
}
}
Loop:
for {
// Read field name.
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
default:
return d.unexpectedTokenError(tok)
case json.ObjectClose:
break Loop
case json.Name:
// Continue.
}
// Unmarshal field name.
pkey, err := d.unmarshalMapKey(tok, fd.MapKey())
if err != nil {
return err
}
// Check for duplicate field name.
if mmap.Has(pkey) {
return d.newError(tok.Pos(), "duplicate map key %v", tok.RawString())
}
// Read and unmarshal field value.
pval, err := unmarshalMapValue()
if err != nil {
return err
}
if pval.IsValid() {
mmap.Set(pkey, pval)
}
}
return nil
}
// unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey.
// A map key type is any integral or string type.
func (d decoder) unmarshalMapKey(tok json.Token, fd protoreflect.FieldDescriptor) (protoreflect.MapKey, error) {
const b32 = 32
const b64 = 64
const base10 = 10
name := tok.Name()
kind := fd.Kind()
switch kind {
case protoreflect.StringKind:
return protoreflect.ValueOfString(name).MapKey(), nil
case protoreflect.BoolKind:
switch name {
case "true":
return protoreflect.ValueOfBool(true).MapKey(), nil
case "false":
return protoreflect.ValueOfBool(false).MapKey(), nil
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if n, err := strconv.ParseInt(name, base10, b32); err == nil {
return protoreflect.ValueOfInt32(int32(n)).MapKey(), nil
}
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if n, err := strconv.ParseInt(name, base10, b64); err == nil {
return protoreflect.ValueOfInt64(int64(n)).MapKey(), nil
}
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if n, err := strconv.ParseUint(name, base10, b32); err == nil {
return protoreflect.ValueOfUint32(uint32(n)).MapKey(), nil
}
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if n, err := strconv.ParseUint(name, base10, b64); err == nil {
return protoreflect.ValueOfUint64(uint64(n)).MapKey(), nil
}
default:
panic(fmt.Sprintf("invalid kind for map key: %v", kind))
}
return protoreflect.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
}
// 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 protojson
import (
"encoding/base64"
"fmt"
"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"
"google.golang.org/protobuf/reflect/protoregistry"
)
const defaultIndent = " "
// Format formats the message as a multiline string.
// This function is only intended for human consumption and ignores errors.
// Do not depend on the output being stable. Its output will change across
// different builds of your program, even when using the same version of the
// protobuf module.
func Format(m proto.Message) string {
return MarshalOptions{Multiline: true}.Format(m)
}
// Marshal writes the given [proto.Message] in JSON format using default options.
// Do not depend on the output being stable. Its output will change across
// different builds of your program, even when using the same version of the
// protobuf module.
func Marshal(m proto.Message) ([]byte, error) {
return MarshalOptions{}.Marshal(m)
}
// MarshalOptions is a configurable JSON format marshaler.
type MarshalOptions struct {
pragma.NoUnkeyedLiterals
// Multiline specifies whether the marshaler should format the output in
// indented-form with every textual element on a new line.
// If Indent is an empty string, then an arbitrary indent is chosen.
Multiline bool
// Indent specifies the set of indentation characters to use in a multiline
// formatted output such that every entry is preceded by Indent and
// terminated by a newline. If non-empty, then Multiline is treated as true.
// Indent can only be composed of space or tab characters.
Indent string
// AllowPartial allows messages that have missing required fields to marshal
// without returning an error. If AllowPartial is false (the default),
// Marshal will return error if there are any missing required fields.
AllowPartial bool
// UseProtoNames uses proto field name instead of lowerCamelCase name in JSON
// field names.
UseProtoNames bool
// UseEnumNumbers emits enum values as numbers.
UseEnumNumbers bool
// EmitUnpopulated specifies whether to emit unpopulated fields. It does not
// emit unpopulated oneof fields or unpopulated extension fields.
// The JSON value emitted for unpopulated fields are as follows:
// ╔═══════╤════════════════════════════╗
// ║ JSON │ Protobuf field ║
// ╠═══════╪════════════════════════════╣
// ║ false │ proto3 boolean fields ║
// ║ 0 │ proto3 numeric fields ║
// ║ "" │ proto3 string/bytes fields ║
// ║ null │ proto2 scalar fields ║
// ║ null │ message fields ║
// ║ [] │ list fields ║
// ║ {} │ map fields ║
// ╚═══════╧════════════════════════════╝
EmitUnpopulated bool
// EmitDefaultValues specifies whether to emit default-valued primitive fields,
// empty lists, and empty maps. The fields affected are as follows:
// ╔═══════╤════════════════════════════════════════╗
// ║ JSON │ Protobuf field ║
// ╠═══════╪════════════════════════════════════════╣
// ║ false │ non-optional scalar boolean fields ║
// ║ 0 │ non-optional scalar numeric fields ║
// ║ "" │ non-optional scalar string/byte fields ║
// ║ [] │ empty repeated fields ║
// ║ {} │ empty map fields ║
// ╚═══════╧════════════════════════════════════════╝
//
// Behaves similarly to EmitUnpopulated, but does not emit "null"-value fields,
// i.e. presence-sensing fields that are omitted will remain omitted to preserve
// presence-sensing.
// EmitUnpopulated takes precedence over EmitDefaultValues since the former generates
// a strict superset of the latter.
EmitDefaultValues bool
// Resolver is used for looking up types when expanding google.protobuf.Any
// messages. If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
protoregistry.ExtensionTypeResolver
protoregistry.MessageTypeResolver
}
}
// Format formats the message as a string.
// This method is only intended for human consumption and ignores errors.
// Do not depend on the output being stable. Its output will change across
// different builds of your program, even when using the same version of the
// protobuf module.
func (o MarshalOptions) Format(m proto.Message) string {
if m == nil || !m.ProtoReflect().IsValid() {
return "<nil>" // invalid syntax, but okay since this is for debugging
}
o.AllowPartial = true
b, _ := o.Marshal(m)
return string(b)
}
// Marshal marshals the given [proto.Message] in the JSON format using options in
// Do not depend on the output being stable. Its output will change across
// different builds of your program, even when using the same version of the
// protobuf module.
func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
return o.marshal(nil, m)
}
// MarshalAppend appends the JSON format encoding of m to b,
// returning the result.
func (o MarshalOptions) MarshalAppend(b []byte, m proto.Message) ([]byte, error) {
return o.marshal(b, 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(b []byte, m proto.Message) ([]byte, error) {
if o.Multiline && o.Indent == "" {
o.Indent = defaultIndent
}
if o.Resolver == nil {
o.Resolver = protoregistry.GlobalTypes
}
internalEnc, err := json.NewEncoder(b, o.Indent)
if err != nil {
return nil, err
}
// Treat nil message interface as an empty message,
// in which case the output in an empty JSON object.
if m == nil {
return append(b, '{', '}'), nil
}
enc := encoder{internalEnc, o}
if err := enc.marshalMessage(m.ProtoReflect(), ""); err != nil {
return nil, err
}
if o.AllowPartial {
return enc.Bytes(), nil
}
return enc.Bytes(), proto.CheckInitialized(m)
}
type encoder struct {
*json.Encoder
opts MarshalOptions
}
// 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(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
if !f(typeFieldDesc, protoreflect.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 {
protoreflect.Message
skipNull bool
}
func (m unpopulatedFieldRanger) Range(f func(protoreflect.FieldDescriptor, protoreflect.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)
if fd.HasPresence() {
if m.skipNull {
continue
}
v = protoreflect.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 protoreflect.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()
var fields order.FieldRanger = m
switch {
case e.opts.EmitUnpopulated:
fields = unpopulatedFieldRanger{Message: m, skipNull: false}
case e.opts.EmitDefaultValues:
fields = unpopulatedFieldRanger{Message: m, skipNull: true}
}
if typeURL != "" {
fields = typeURLFieldRanger{fields, typeURL}
}
var err error
order.RangeFields(fields, order.IndexNameFieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
name := fd.JSONName()
if e.opts.UseProtoNames {
name = fd.TextName()
}
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.
func (e encoder) marshalValue(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch {
case fd.IsList():
return e.marshalList(val.List(), fd)
case fd.IsMap():
return e.marshalMap(val.Map(), fd)
default:
return e.marshalSingular(val, fd)
}
}
// marshalSingular marshals the given non-repeated field value. This includes
// all scalar types, enums, messages, and groups.
func (e encoder) marshalSingular(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
if !val.IsValid() {
e.WriteNull()
return nil
}
switch kind := fd.Kind(); kind {
case protoreflect.BoolKind:
e.WriteBool(val.Bool())
case protoreflect.StringKind:
if e.WriteString(val.String()) != nil {
return errors.InvalidUTF8(string(fd.FullName()))
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
e.WriteInt(val.Int())
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
e.WriteUint(val.Uint())
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Uint64Kind,
protoreflect.Sfixed64Kind, protoreflect.Fixed64Kind:
// 64-bit integers are written out as JSON string.
e.WriteString(val.String())
case protoreflect.FloatKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 32)
case protoreflect.DoubleKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 64)
case protoreflect.BytesKind:
e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes()))
case protoreflect.EnumKind:
if fd.Enum().FullName() == genid.NullValue_enum_fullname {
e.WriteNull()
} else {
desc := fd.Enum().Values().ByNumber(val.Enum())
if e.opts.UseEnumNumbers || desc == nil {
e.WriteInt(int64(val.Enum()))
} else {
e.WriteString(string(desc.Name()))
}
}
case protoreflect.MessageKind, protoreflect.GroupKind:
if err := e.marshalMessage(val.Message(), ""); err != nil {
return err
}
default:
panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
}
return nil
}
// marshalList marshals the given protoreflect.List.
func (e encoder) marshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
e.StartArray()
defer e.EndArray()
for i := 0; i < list.Len(); i++ {
item := list.Get(i)
if err := e.marshalSingular(item, fd); err != nil {
return err
}
}
return nil
}
// marshalMap marshals given protoreflect.Map.
func (e encoder) marshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
e.StartObject()
defer e.EndObject()
var err error
order.RangeEntries(mmap, order.GenericKeyOrder, func(k protoreflect.MapKey, v protoreflect.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
})
return err
}
// 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 protojson
import (
"bytes"
"fmt"
"math"
"strconv"
"strings"
"time"
"google.golang.org/protobuf/internal/encoding/json"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
)
type marshalFunc func(encoder, protoreflect.Message) error
// wellKnownTypeMarshaler returns a marshal function if the message type
// has specialized serialization behavior. It returns nil otherwise.
func wellKnownTypeMarshaler(name protoreflect.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 nil
}
type unmarshalFunc func(decoder, protoreflect.Message) error
// wellKnownTypeUnmarshaler returns a unmarshal function if the message type
// has specialized serialization behavior. It returns nil otherwise.
func wellKnownTypeUnmarshaler(name protoreflect.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
// the deserialized, embedded message, with an additional field `@type` which
// contains the type URL. If the embedded message type is well-known and has a
// custom JSON representation, that representation will be embedded adding a
// field `value` which holds the custom JSON in addition to the `@type` field.
func (e encoder) marshalAny(m protoreflect.Message) error {
fds := m.Descriptor().Fields()
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: %v is not set", genid.Any_message_fullname, genid.Any_TypeUrl_field_name)
}
}
typeVal := m.Get(fdType)
valueVal := m.Get(fdValue)
// 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", genid.Any_message_fullname, typeURL, err)
}
em := emt.New()
err = proto.UnmarshalOptions{
AllowPartial: true, // never check required fields inside an Any
Resolver: e.opts.Resolver,
}.Unmarshal(valueVal.Bytes(), em.Interface())
if err != nil {
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 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 marshal(e, em)
}
// Else, marshal out the embedded message's fields in this Any object.
if err := e.marshalMessage(em, typeURL); err != nil {
return err
}
return nil
}
func (d decoder) unmarshalAny(m protoreflect.Message) error {
// Peek to check for json.ObjectOpen to avoid advancing a read.
start, err := d.Peek()
if err != nil {
return err
}
if start.Kind() != json.ObjectOpen {
return d.unexpectedTokenError(start)
}
// Use another decoder to parse the unread bytes for @type field. This
// avoids advancing a read from current decoder because the current JSON
// object may contain the fields of the embedded type.
dec := decoder{d.Clone(), UnmarshalOptions{RecursionLimit: d.opts.RecursionLimit}}
tok, err := findTypeURL(dec)
switch err {
case errEmptyObject:
// An empty JSON object translates to an empty Any message.
d.Read() // Read json.ObjectOpen.
d.Read() // Read json.ObjectClose.
return nil
case errMissingType:
if d.opts.DiscardUnknown {
// Treat all fields as unknowns, similar to an empty object.
return d.skipJSONValue()
}
// Use start.Pos() for line position.
return d.newError(start.Pos(), err.Error())
default:
if err != nil {
return err
}
}
typeURL := tok.ParsedString()
emt, err := d.opts.Resolver.FindMessageByURL(typeURL)
if err != nil {
return d.newError(tok.Pos(), "unable to resolve %v: %q", tok.RawString(), err)
}
// Create new message for the embedded message type and unmarshal into it.
em := emt.New()
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(unmarshal, em); err != nil {
return err
}
} else {
// Else unmarshal the current JSON object into it.
if err := d.unmarshalMessage(em, true); err != nil {
return err
}
}
// Serialize the embedded message and assign the resulting bytes to the
// proto value field.
b, err := proto.MarshalOptions{
AllowPartial: true, // No need to check required fields inside an Any.
Deterministic: true,
}.Marshal(em.Interface())
if err != nil {
return d.newError(start.Pos(), "error in marshaling Any.value field: %v", err)
}
fds := m.Descriptor().Fields()
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
fdValue := fds.ByNumber(genid.Any_Value_field_number)
m.Set(fdType, protoreflect.ValueOfString(typeURL))
m.Set(fdValue, protoreflect.ValueOfBytes(b))
return nil
}
var errEmptyObject = fmt.Errorf(`empty object`)
var errMissingType = fmt.Errorf(`missing "@type" field`)
// findTypeURL returns the token for the "@type" field value from the given
// JSON bytes. It is expected that the given bytes start with json.ObjectOpen.
// It returns errEmptyObject if the JSON object is empty or errMissingType if
// @type field does not exist. It returns other error if the @type field is not
// valid or other decoding issues.
func findTypeURL(d decoder) (json.Token, error) {
var typeURL string
var typeTok json.Token
numFields := 0
// Skip start object.
d.Read()
Loop:
for {
tok, err := d.Read()
if err != nil {
return json.Token{}, err
}
switch tok.Kind() {
case json.ObjectClose:
if typeURL == "" {
// Did not find @type field.
if numFields > 0 {
return json.Token{}, errMissingType
}
return json.Token{}, errEmptyObject
}
break Loop
case json.Name:
numFields++
if tok.Name() != "@type" {
// Skip value.
if err := d.skipJSONValue(); err != nil {
return json.Token{}, err
}
continue
}
// Return error if this was previously set already.
if typeURL != "" {
return json.Token{}, d.newError(tok.Pos(), `duplicate "@type" field`)
}
// Read field value.
tok, err := d.Read()
if err != nil {
return json.Token{}, err
}
if tok.Kind() != json.String {
return json.Token{}, d.newError(tok.Pos(), `@type field value is not a string: %v`, tok.RawString())
}
typeURL = tok.ParsedString()
if typeURL == "" {
return json.Token{}, d.newError(tok.Pos(), `@type field contains empty value`)
}
typeTok = tok
}
}
return typeTok, nil
}
// skipJSONValue parses a JSON value (null, boolean, string, number, object and
// array) in order to advance the read to the next JSON value. It relies on
// the decoder returning an error if the types are not in valid sequence.
func (d decoder) skipJSONValue() error {
var open int
for {
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case json.ObjectClose, json.ArrayClose:
open--
case json.ObjectOpen, json.ArrayOpen:
open++
if open > d.opts.RecursionLimit {
return errors.New("exceeded max recursion depth")
}
case json.EOF:
// This can only happen if there's a bug in Decoder.Read.
// Avoid an infinite loop if this does happen.
return errors.New("unexpected EOF")
}
if open == 0 {
return nil
}
}
}
// unmarshalAnyValue unmarshals the given custom-type message from the JSON
// object's "value" field.
func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m protoreflect.Message) error {
// Skip ObjectOpen, and start reading the fields.
d.Read()
var found bool // Used for detecting duplicate "value".
for {
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case json.ObjectClose:
if !found {
// We tolerate an omitted `value` field with the google.protobuf.Empty Well-Known-Type,
// for compatibility with other proto runtimes that have interpreted the spec differently.
if m.Descriptor().FullName() != genid.Empty_message_fullname {
return d.newError(tok.Pos(), `missing "value" field`)
}
}
return nil
case json.Name:
switch tok.Name() {
case "@type":
// Skip the value as this was previously parsed already.
d.Read()
case "value":
if found {
return d.newError(tok.Pos(), `duplicate "value" field`)
}
// Unmarshal the field value into the given message.
if err := unmarshal(d, m); err != nil {
return err
}
found = true
default:
if d.opts.DiscardUnknown {
if err := d.skipJSONValue(); err != nil {
return err
}
continue
}
return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
}
}
}
}
// Wrapper types are encoded as JSON primitives like string, number or boolean.
func (e encoder) marshalWrapperType(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val := m.Get(fd)
return e.marshalSingular(val, fd)
}
func (d decoder) unmarshalWrapperType(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val, err := d.unmarshalScalar(fd)
if err != nil {
return err
}
m.Set(fd, val)
return nil
}
// The JSON representation for Empty is an empty JSON object.
func (e encoder) marshalEmpty(protoreflect.Message) error {
e.StartObject()
e.EndObject()
return nil
}
func (d decoder) unmarshalEmpty(protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.ObjectOpen {
return d.unexpectedTokenError(tok)
}
for {
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case json.ObjectClose:
return nil
case json.Name:
if d.opts.DiscardUnknown {
if err := d.skipJSONValue(); err != nil {
return err
}
continue
}
return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
default:
return d.unexpectedTokenError(tok)
}
}
}
// 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 protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return e.marshalMap(m.Get(fd).Map(), fd)
}
func (d decoder) unmarshalStruct(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return d.unmarshalMap(m.Mutable(fd).Map(), fd)
}
// The JSON representation for ListValue is JSON array that contains the encoded
// ListValue.values repeated field and follows the serialization rules for a
// repeated field.
func (e encoder) marshalListValue(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return e.marshalList(m.Get(fd).List(), fd)
}
func (d decoder) unmarshalListValue(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return d.unmarshalList(m.Mutable(fd).List(), fd)
}
// The JSON representation for a Value is dependent on the oneof field that is
// set. Each of the field in the oneof has its own custom serialization rule. A
// Value message needs to be a oneof field set, else it is an error.
func (e encoder) marshalKnownValue(m protoreflect.Message) error {
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", 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)
}
func (d decoder) unmarshalKnownValue(m protoreflect.Message) error {
tok, err := d.Peek()
if err != nil {
return err
}
var fd protoreflect.FieldDescriptor
var val protoreflect.Value
switch tok.Kind() {
case json.Null:
d.Read()
fd = m.Descriptor().Fields().ByNumber(genid.Value_NullValue_field_number)
val = protoreflect.ValueOfEnum(0)
case json.Bool:
tok, err := d.Read()
if err != nil {
return err
}
fd = m.Descriptor().Fields().ByNumber(genid.Value_BoolValue_field_number)
val = protoreflect.ValueOfBool(tok.Bool())
case json.Number:
tok, err := d.Read()
if err != nil {
return err
}
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 %v: %v", genid.Value_message_fullname, tok.RawString())
}
case json.String:
// A JSON string may have been encoded from the number_value field,
// e.g. "NaN", "Infinity", etc. Parsing a proto double type also allows
// for it to be in JSON string form. Given this custom encoding spec,
// however, there is no way to identify that and hence a JSON string is
// always assigned to the string_value field, which means that certain
// encoding cannot be parsed back to the same field.
tok, err := d.Read()
if err != nil {
return err
}
fd = m.Descriptor().Fields().ByNumber(genid.Value_StringValue_field_number)
val = protoreflect.ValueOfString(tok.ParsedString())
case json.ObjectOpen:
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(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 %v: %v", genid.Value_message_fullname, tok.RawString())
}
m.Set(fd, val)
return nil
}
// The JSON representation for a Duration is a JSON string that ends in the
// suffix "s" (indicating seconds) and is preceded by the number of seconds,
// with nanoseconds expressed as fractional seconds.
//
// Durations less than one second are represented with a 0 seconds field and a
// positive or negative nanos field. For durations of one second or more, a
// non-zero value for the nanos field must be of the same sign as the seconds
// field.
//
// Duration.seconds must be from -315,576,000,000 to +315,576,000,000 inclusive.
// Duration.nanos must be from -999,999,999 to +999,999,999 inclusive.
const (
secondsInNanos = 999999999
maxSecondsInDuration = 315576000000
)
func (e encoder) marshalDuration(m protoreflect.Message) error {
fds := m.Descriptor().Fields()
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", genid.Duration_message_fullname, secs)
}
if nanos < -secondsInNanos || nanos > secondsInNanos {
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", genid.Duration_message_fullname)
}
// Generated output always contains 0, 3, 6, or 9 fractional digits,
// depending on required precision, followed by the suffix "s".
var sign string
if secs < 0 || nanos < 0 {
sign, secs, nanos = "-", -1*secs, -1*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")
e.WriteString(x + "s")
return nil
}
func (d decoder) unmarshalDuration(m protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.String {
return d.unexpectedTokenError(tok)
}
secs, nanos, ok := parseDuration(tok.ParsedString())
if !ok {
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(), "%v value out of range: %v", genid.Duration_message_fullname, tok.RawString())
}
fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
m.Set(fdSeconds, protoreflect.ValueOfInt64(secs))
m.Set(fdNanos, protoreflect.ValueOfInt32(nanos))
return nil
}
// parseDuration parses the given input string for seconds and nanoseconds value
// for the Duration JSON format. The format is a decimal number with a suffix
// 's'. It can have optional plus/minus sign. There needs to be at least an
// integer or fractional part. Fractional part is limited to 9 digits only for
// nanoseconds precision, regardless of whether there are trailing zero digits.
// Example values are 1s, 0.1s, 1.s, .1s, +1s, -1s, -.1s.
func parseDuration(input string) (int64, int32, bool) {
b := []byte(input)
size := len(b)
if size < 2 {
return 0, 0, false
}
if b[size-1] != 's' {
return 0, 0, false
}
b = b[:size-1]
// Read optional plus/minus symbol.
var neg bool
switch b[0] {
case '-':
neg = true
b = b[1:]
case '+':
b = b[1:]
}
if len(b) == 0 {
return 0, 0, false
}
// Read the integer part.
var intp []byte
switch {
case b[0] == '0':
b = b[1:]
case '1' <= b[0] && b[0] <= '9':
intp = b[0:]
b = b[1:]
n := 1
for len(b) > 0 && '0' <= b[0] && b[0] <= '9' {
n++
b = b[1:]
}
intp = intp[:n]
case b[0] == '.':
// Continue below.
default:
return 0, 0, false
}
hasFrac := false
var frac [9]byte
if len(b) > 0 {
if b[0] != '.' {
return 0, 0, false
}
// Read the fractional part.
b = b[1:]
n := 0
for len(b) > 0 && n < 9 && '0' <= b[0] && b[0] <= '9' {
frac[n] = b[0]
n++
b = b[1:]
}
// It is not valid if there are more bytes left.
if len(b) > 0 {
return 0, 0, false
}
// Pad fractional part with 0s.
for i := n; i < 9; i++ {
frac[i] = '0'
}
hasFrac = true
}
var secs int64
if len(intp) > 0 {
var err error
secs, err = strconv.ParseInt(string(intp), 10, 64)
if err != nil {
return 0, 0, false
}
}
var nanos int64
if hasFrac {
nanob := bytes.TrimLeft(frac[:], "0")
if len(nanob) > 0 {
var err error
nanos, err = strconv.ParseInt(string(nanob), 10, 32)
if err != nil {
return 0, 0, false
}
}
}
if neg {
if secs > 0 {
secs = -secs
}
if nanos > 0 {
nanos = -nanos
}
}
return secs, int32(nanos), true
}
// The JSON representation for a Timestamp is a JSON string in the RFC 3339
// format, i.e. "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where
// {year} is always expressed using four digits while {month}, {day}, {hour},
// {min}, and {sec} are zero-padded to two digits each. The fractional seconds,
// which can go up to 9 digits, up to 1 nanosecond resolution, is optional. The
// "Z" suffix indicates the timezone ("UTC"); the timezone is required. Encoding
// should always use UTC (as indicated by "Z") and a decoder should be able to
// accept both UTC and other timezones (as indicated by an offset).
//
// Timestamp.seconds must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z
// inclusive.
// Timestamp.nanos must be from 0 to 999,999,999 inclusive.
const (
maxTimestampSeconds = 253402300799
minTimestampSeconds = -62135596800
)
func (e encoder) marshalTimestamp(m protoreflect.Message) error {
fds := m.Descriptor().Fields()
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", genid.Timestamp_message_fullname, secs)
}
if nanos < 0 || nanos > secondsInNanos {
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.
t := time.Unix(secs, nanos).UTC()
x := t.Format("2006-01-02T15:04:05.000000000")
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, "000")
x = strings.TrimSuffix(x, ".000")
e.WriteString(x + "Z")
return nil
}
func (d decoder) unmarshalTimestamp(m protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.String {
return d.unexpectedTokenError(tok)
}
s := tok.ParsedString()
t, err := time.Parse(time.RFC3339Nano, s)
if err != nil {
return d.newError(tok.Pos(), "invalid %v value %v", genid.Timestamp_message_fullname, tok.RawString())
}
// Validate seconds.
secs := t.Unix()
if secs < minTimestampSeconds || secs > maxTimestampSeconds {
return d.newError(tok.Pos(), "%v value out of range: %v", genid.Timestamp_message_fullname, tok.RawString())
}
// Validate subseconds.
i := strings.LastIndexByte(s, '.') // start of subsecond field
j := strings.LastIndexAny(s, "Z-+") // start of timezone field
if i >= 0 && j >= i && j-i > len(".999999999") {
return d.newError(tok.Pos(), "invalid %v value %v", genid.Timestamp_message_fullname, tok.RawString())
}
fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
m.Set(fdSeconds, protoreflect.ValueOfInt64(secs))
m.Set(fdNanos, protoreflect.ValueOfInt32(int32(t.Nanosecond())))
return nil
}
// The JSON representation for a FieldMask is a JSON string where paths are
// separated by a comma. Fields name in each path are converted to/from
// lower-camel naming conventions. Encoding should fail if the path name would
// end up differently after a round-trip.
func (e encoder) marshalFieldMask(m protoreflect.Message) error {
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 !protoreflect.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 contains irreversible value %q", genid.FieldMask_Paths_field_fullname, s)
}
paths = append(paths, cc)
}
e.WriteString(strings.Join(paths, ","))
return nil
}
func (d decoder) unmarshalFieldMask(m protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != json.String {
return d.unexpectedTokenError(tok)
}
str := strings.TrimSpace(tok.ParsedString())
if str == "" {
return nil
}
paths := strings.Split(str, ",")
fd := m.Descriptor().Fields().ByNumber(genid.FieldMask_Paths_field_number)
list := m.Mutable(fd).List()
for _, s0 := range paths {
s := strs.JSONSnakeCase(s0)
if strings.Contains(s0, "_") || !protoreflect.FullName(s).IsValid() {
return d.newError(tok.Pos(), "%v contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s0)
}
list.Append(protoreflect.ValueOfString(s))
}
return nil
}
// Copyright 2018 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 prototext
import (
"fmt"
"unicode/utf8"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/encoding/text"
"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/internal/strs"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
// 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)
}
// UnmarshalOptions is a configurable textproto format unmarshaler.
type UnmarshalOptions struct {
pragma.NoUnkeyedLiterals
// AllowPartial accepts input for messages that will result in missing
// required fields. If AllowPartial is false (the default), Unmarshal will
// return error if there are any missing required fields.
AllowPartial bool
// DiscardUnknown specifies whether to ignore unknown fields when parsing.
// An unknown field is any field whose field name or field number does not
// resolve to any known or extension field in the message.
// By default, unmarshal rejects unknown fields as an error.
DiscardUnknown bool
// Resolver is used for looking up types when unmarshaling
// google.protobuf.Any messages or extension fields.
// If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
protoregistry.MessageTypeResolver
protoregistry.ExtensionTypeResolver
}
}
// Unmarshal reads the given []byte and populates the given [proto.Message]
// using options in the UnmarshalOptions object.
// 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 {
o.Resolver = protoregistry.GlobalTypes
}
dec := decoder{text.NewDecoder(b), o}
if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
return err
}
if o.AllowPartial {
return nil
}
return proto.CheckInitialized(m)
}
type decoder struct {
*text.Decoder
opts UnmarshalOptions
}
// newError returns an error object with position info.
func (d decoder) newError(pos int, f string, x ...any) error {
line, column := d.Position(pos)
head := fmt.Sprintf("(line %d:%d): ", line, column)
return errors.New(head+f, x...)
}
// unexpectedTokenError returns a syntax error for the given unexpected token.
func (d decoder) unexpectedTokenError(tok text.Token) error {
return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())
}
// syntaxError returns a syntax error for given position.
func (d decoder) syntaxError(pos int, f string, x ...any) error {
line, column := d.Position(pos)
head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
return errors.New(head+f, x...)
}
// unmarshalMessage unmarshals into the given protoreflect.Message.
func (d decoder) unmarshalMessage(m protoreflect.Message, checkDelims bool) error {
messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets")
}
if messageDesc.FullName() == genid.Any_message_fullname {
return d.unmarshalAny(m, checkDelims)
}
if checkDelims {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != text.MessageOpen {
return d.unexpectedTokenError(tok)
}
}
var seenNums set.Ints
var seenOneofs set.Ints
fieldDescs := messageDesc.Fields()
for {
// Read field name.
tok, err := d.Read()
if err != nil {
return err
}
switch typ := tok.Kind(); typ {
case text.Name:
// Continue below.
case text.EOF:
if checkDelims {
return text.ErrUnexpectedEOF
}
return nil
default:
if checkDelims && typ == text.MessageClose {
return nil
}
return d.unexpectedTokenError(tok)
}
// Resolve the field descriptor.
var name protoreflect.Name
var fd protoreflect.FieldDescriptor
var xt protoreflect.ExtensionType
var xtErr error
var isFieldNumberName bool
switch tok.NameKind() {
case text.IdentName:
name = protoreflect.Name(tok.IdentName())
fd = fieldDescs.ByTextName(string(name))
case text.TypeName:
// Handle extensions only. This code path is not for Any.
xt, xtErr = d.opts.Resolver.FindExtensionByName(protoreflect.FullName(tok.TypeName()))
case text.FieldNumber:
isFieldNumberName = true
num := protoreflect.FieldNumber(tok.FieldNumber())
if !num.IsValid() {
return d.newError(tok.Pos(), "invalid field number: %d", num)
}
fd = fieldDescs.ByNumber(num)
if fd == nil {
xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)
}
}
if xt != nil {
fd = xt.TypeDescriptor()
if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
}
} else if xtErr != nil && xtErr != protoregistry.NotFound {
return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)
}
// Handle unknown fields.
if fd == nil {
if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {
d.skipValue()
continue
}
return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())
}
// Handle fields identified by field number.
if isFieldNumberName {
// TODO: Add an option to permit parsing field numbers.
//
// This requires careful thought as the MarshalOptions.EmitUnknown
// option allows formatting unknown fields as the field number and the
// best-effort textual representation of the field value. In that case,
// it may not be possible to unmarshal the value from a parser that does
// have information about the unknown field.
return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())
}
switch {
case fd.IsList():
kind := fd.Kind()
if kind != protoreflect.MessageKind && kind != protoreflect.GroupKind && !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :")
}
list := m.Mutable(fd).List()
if err := d.unmarshalList(fd, list); err != nil {
return err
}
case fd.IsMap():
mmap := m.Mutable(fd).Map()
if err := d.unmarshalMap(fd, mmap); err != nil {
return err
}
default:
kind := fd.Kind()
if kind != protoreflect.MessageKind && kind != protoreflect.GroupKind && !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :")
}
// If field is a oneof, check if it has already been set.
if od := fd.ContainingOneof(); od != nil {
idx := uint64(od.Index())
if seenOneofs.Has(idx) {
return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())
}
seenOneofs.Set(idx)
}
num := uint64(fd.Number())
if seenNums.Has(num) {
return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())
}
if err := d.unmarshalSingular(fd, m); err != nil {
return err
}
seenNums.Set(num)
}
}
return nil
}
// unmarshalSingular unmarshals a non-repeated field value specified by the
// given FieldDescriptor.
func (d decoder) unmarshalSingular(fd protoreflect.FieldDescriptor, m protoreflect.Message) error {
var val protoreflect.Value
var err error
switch fd.Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
val = m.NewField(fd)
err = d.unmarshalMessage(val.Message(), true)
default:
val, err = d.unmarshalScalar(fd)
}
if err == nil {
m.Set(fd, val)
}
return err
}
// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
// given FieldDescriptor.
func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
tok, err := d.Read()
if err != nil {
return protoreflect.Value{}, err
}
if tok.Kind() != text.Scalar {
return protoreflect.Value{}, d.unexpectedTokenError(tok)
}
kind := fd.Kind()
switch kind {
case protoreflect.BoolKind:
if b, ok := tok.Bool(); ok {
return protoreflect.ValueOfBool(b), nil
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if n, ok := tok.Int32(); ok {
return protoreflect.ValueOfInt32(n), nil
}
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if n, ok := tok.Int64(); ok {
return protoreflect.ValueOfInt64(n), nil
}
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if n, ok := tok.Uint32(); ok {
return protoreflect.ValueOfUint32(n), nil
}
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if n, ok := tok.Uint64(); ok {
return protoreflect.ValueOfUint64(n), nil
}
case protoreflect.FloatKind:
if n, ok := tok.Float32(); ok {
return protoreflect.ValueOfFloat32(n), nil
}
case protoreflect.DoubleKind:
if n, ok := tok.Float64(); ok {
return protoreflect.ValueOfFloat64(n), nil
}
case protoreflect.StringKind:
if s, ok := tok.String(); ok {
if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
return protoreflect.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
}
return protoreflect.ValueOfString(s), nil
}
case protoreflect.BytesKind:
if b, ok := tok.String(); ok {
return protoreflect.ValueOfBytes([]byte(b)), nil
}
case protoreflect.EnumKind:
if lit, ok := tok.Enum(); ok {
// Lookup EnumNumber based on name.
if enumVal := fd.Enum().Values().ByName(protoreflect.Name(lit)); enumVal != nil {
return protoreflect.ValueOfEnum(enumVal.Number()), nil
}
}
if num, ok := tok.Int32(); ok {
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(num)), nil
}
default:
panic(fmt.Sprintf("invalid scalar kind %v", kind))
}
return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
}
// unmarshalList unmarshals into given protoreflect.List. A list value can
// either be in [] syntax or simply just a single scalar/message value.
func (d decoder) unmarshalList(fd protoreflect.FieldDescriptor, list protoreflect.List) error {
tok, err := d.Peek()
if err != nil {
return err
}
switch fd.Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
switch tok.Kind() {
case text.ListOpen:
d.Read()
for {
tok, err := d.Peek()
if err != nil {
return err
}
switch tok.Kind() {
case text.ListClose:
d.Read()
return nil
case text.MessageOpen:
pval := list.NewElement()
if err := d.unmarshalMessage(pval.Message(), true); err != nil {
return err
}
list.Append(pval)
default:
return d.unexpectedTokenError(tok)
}
}
case text.MessageOpen:
pval := list.NewElement()
if err := d.unmarshalMessage(pval.Message(), true); err != nil {
return err
}
list.Append(pval)
return nil
}
default:
switch tok.Kind() {
case text.ListOpen:
d.Read()
for {
tok, err := d.Peek()
if err != nil {
return err
}
switch tok.Kind() {
case text.ListClose:
d.Read()
return nil
case text.Scalar:
pval, err := d.unmarshalScalar(fd)
if err != nil {
return err
}
list.Append(pval)
default:
return d.unexpectedTokenError(tok)
}
}
case text.Scalar:
pval, err := d.unmarshalScalar(fd)
if err != nil {
return err
}
list.Append(pval)
return nil
}
}
return d.unexpectedTokenError(tok)
}
// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
// textproto message containing {key: <kvalue>, value: <mvalue>}.
func (d decoder) unmarshalMap(fd protoreflect.FieldDescriptor, mmap protoreflect.Map) error {
// Determine ahead whether map entry is a scalar type or a message type in
// order to call the appropriate unmarshalMapValue func inside
// unmarshalMapEntry.
var unmarshalMapValue func() (protoreflect.Value, error)
switch fd.MapValue().Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
unmarshalMapValue = func() (protoreflect.Value, error) {
pval := mmap.NewValue()
if err := d.unmarshalMessage(pval.Message(), true); err != nil {
return protoreflect.Value{}, err
}
return pval, nil
}
default:
unmarshalMapValue = func() (protoreflect.Value, error) {
return d.unmarshalScalar(fd.MapValue())
}
}
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case text.MessageOpen:
return d.unmarshalMapEntry(fd, mmap, unmarshalMapValue)
case text.ListOpen:
for {
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case text.ListClose:
return nil
case text.MessageOpen:
if err := d.unmarshalMapEntry(fd, mmap, unmarshalMapValue); err != nil {
return err
}
default:
return d.unexpectedTokenError(tok)
}
}
default:
return d.unexpectedTokenError(tok)
}
}
// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
// textproto message containing {key: <kvalue>, value: <mvalue>}.
func (d decoder) unmarshalMapEntry(fd protoreflect.FieldDescriptor, mmap protoreflect.Map, unmarshalMapValue func() (protoreflect.Value, error)) error {
var key protoreflect.MapKey
var pval protoreflect.Value
Loop:
for {
// Read field name.
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case text.Name:
if tok.NameKind() != text.IdentName {
if !d.opts.DiscardUnknown {
return d.newError(tok.Pos(), "unknown map entry field %q", tok.RawString())
}
d.skipValue()
continue Loop
}
// Continue below.
case text.MessageClose:
break Loop
default:
return d.unexpectedTokenError(tok)
}
switch name := protoreflect.Name(tok.IdentName()); name {
case genid.MapEntry_Key_field_name:
if !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :")
}
if key.IsValid() {
return d.newError(tok.Pos(), "map entry %q cannot be repeated", name)
}
val, err := d.unmarshalScalar(fd.MapKey())
if err != nil {
return err
}
key = val.MapKey()
case genid.MapEntry_Value_field_name:
if kind := fd.MapValue().Kind(); (kind != protoreflect.MessageKind) && (kind != protoreflect.GroupKind) {
if !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :")
}
}
if pval.IsValid() {
return d.newError(tok.Pos(), "map entry %q cannot be repeated", name)
}
pval, err = unmarshalMapValue()
if err != nil {
return err
}
default:
if !d.opts.DiscardUnknown {
return d.newError(tok.Pos(), "unknown map entry field %q", name)
}
d.skipValue()
}
}
if !key.IsValid() {
key = fd.MapKey().Default().MapKey()
}
if !pval.IsValid() {
switch fd.MapValue().Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind:
// If value field is not set for message/group types, construct an
// empty one as default.
pval = mmap.NewValue()
default:
pval = fd.MapValue().Default()
}
}
mmap.Set(key, pval)
return nil
}
// unmarshalAny unmarshals an Any textproto. It can either be in expanded form
// or non-expanded form.
func (d decoder) unmarshalAny(m protoreflect.Message, checkDelims bool) error {
var typeURL string
var bValue []byte
var seenTypeUrl bool
var seenValue bool
var isExpanded bool
if checkDelims {
tok, err := d.Read()
if err != nil {
return err
}
if tok.Kind() != text.MessageOpen {
return d.unexpectedTokenError(tok)
}
}
Loop:
for {
// Read field name. Can only have 3 possible field names, i.e. type_url,
// value and type URL name inside [].
tok, err := d.Read()
if err != nil {
return err
}
if typ := tok.Kind(); typ != text.Name {
if checkDelims {
if typ == text.MessageClose {
break Loop
}
} else if typ == text.EOF {
break Loop
}
return d.unexpectedTokenError(tok)
}
switch tok.NameKind() {
case text.IdentName:
// Both type_url and value fields require field separator :.
if !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :")
}
switch name := protoreflect.Name(tok.IdentName()); name {
case genid.Any_TypeUrl_field_name:
if seenTypeUrl {
return d.newError(tok.Pos(), "duplicate %v field", genid.Any_TypeUrl_field_fullname)
}
if isExpanded {
return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
}
tok, err := d.Read()
if err != nil {
return err
}
var ok bool
typeURL, ok = tok.String()
if !ok {
return d.newError(tok.Pos(), "invalid %v field value: %v", genid.Any_TypeUrl_field_fullname, tok.RawString())
}
seenTypeUrl = true
case genid.Any_Value_field_name:
if seenValue {
return d.newError(tok.Pos(), "duplicate %v field", genid.Any_Value_field_fullname)
}
if isExpanded {
return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
}
tok, err := d.Read()
if err != nil {
return err
}
s, ok := tok.String()
if !ok {
return d.newError(tok.Pos(), "invalid %v field value: %v", genid.Any_Value_field_fullname, tok.RawString())
}
bValue = []byte(s)
seenValue = true
default:
if !d.opts.DiscardUnknown {
return d.newError(tok.Pos(), "invalid field name %q in %v message", tok.RawString(), genid.Any_message_fullname)
}
}
case text.TypeName:
if isExpanded {
return d.newError(tok.Pos(), "cannot have more than one type")
}
if seenTypeUrl {
return d.newError(tok.Pos(), "conflict with type_url field")
}
typeURL = tok.TypeName()
var err error
bValue, err = d.unmarshalExpandedAny(typeURL, tok.Pos())
if err != nil {
return err
}
isExpanded = true
default:
if !d.opts.DiscardUnknown {
return d.newError(tok.Pos(), "invalid field name %q in %v message", tok.RawString(), genid.Any_message_fullname)
}
}
}
fds := m.Descriptor().Fields()
if len(typeURL) > 0 {
m.Set(fds.ByNumber(genid.Any_TypeUrl_field_number), protoreflect.ValueOfString(typeURL))
}
if len(bValue) > 0 {
m.Set(fds.ByNumber(genid.Any_Value_field_number), protoreflect.ValueOfBytes(bValue))
}
return nil
}
func (d decoder) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error) {
mt, err := d.opts.Resolver.FindMessageByURL(typeURL)
if err != nil {
return nil, d.newError(pos, "unable to resolve message [%v]: %v", typeURL, err)
}
// Create new message for the embedded message type and unmarshal the value
// field into it.
m := mt.New()
if err := d.unmarshalMessage(m, true); err != nil {
return nil, err
}
// Serialize the embedded message and return the resulting bytes.
b, err := proto.MarshalOptions{
AllowPartial: true, // Never check required fields inside an Any.
Deterministic: true,
}.Marshal(m.Interface())
if err != nil {
return nil, d.newError(pos, "error in marshaling message into Any.value: %v", err)
}
return b, nil
}
// skipValue makes the decoder parse a field value in order to advance the read
// to the next field. It relies on Read returning an error if the types are not
// in valid sequence.
func (d decoder) skipValue() error {
tok, err := d.Read()
if err != nil {
return err
}
// Only need to continue reading for messages and lists.
switch tok.Kind() {
case text.MessageOpen:
return d.skipMessageValue()
case text.ListOpen:
for {
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case text.ListClose:
return nil
case text.MessageOpen:
if err := d.skipMessageValue(); err != nil {
return err
}
default:
// Skip items. This will not validate whether skipped values are
// of the same type or not, same behavior as C++
// TextFormat::Parser::AllowUnknownField(true) version 3.8.0.
}
}
}
return nil
}
// skipMessageValue makes the decoder parse and skip over all fields in a
// message. It assumes that the previous read type is MessageOpen.
func (d decoder) skipMessageValue() error {
for {
tok, err := d.Read()
if err != nil {
return err
}
switch tok.Kind() {
case text.MessageClose:
return nil
case text.Name:
if err := d.skipValue(); err != nil {
return err
}
}
}
}
// Copyright 2018 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 prototext
import (
"fmt"
"strconv"
"unicode/utf8"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/encoding/text"
"google.golang.org/protobuf/internal/errors"
"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/internal/strs"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
const defaultIndent = " "
// Format formats the message as a multiline string.
// This function is only intended for human consumption and ignores errors.
// Do not depend on the output being stable. Its output will change across
// different builds of your program, even when using the same version of the
// protobuf module.
func Format(m proto.Message) string {
return MarshalOptions{Multiline: true}.Format(m)
}
// Marshal writes the given [proto.Message] in textproto format using default
// options. Do not depend on the output being stable. Its output will change
// across different builds of your program, even when using the same version of
// the protobuf module.
func Marshal(m proto.Message) ([]byte, error) {
return MarshalOptions{}.Marshal(m)
}
// MarshalOptions is a configurable text format marshaler.
type MarshalOptions struct {
pragma.NoUnkeyedLiterals
// Multiline specifies whether the marshaler should format the output in
// indented-form with every textual element on a new line.
// If Indent is an empty string, then an arbitrary indent is chosen.
Multiline bool
// Indent specifies the set of indentation characters to use in a multiline
// formatted output such that every entry is preceded by Indent and
// terminated by a newline. If non-empty, then Multiline is treated as true.
// Indent can only be composed of space or tab characters.
Indent string
// EmitASCII specifies whether to format strings and bytes as ASCII only
// as opposed to using UTF-8 encoding when possible.
EmitASCII bool
// allowInvalidUTF8 specifies whether to permit the encoding of strings
// with invalid UTF-8. This is unexported as it is intended to only
// be specified by the Format method.
allowInvalidUTF8 bool
// AllowPartial allows messages that have missing required fields to marshal
// without returning an error. If AllowPartial is false (the default),
// Marshal will return error if there are any missing required fields.
AllowPartial bool
// EmitUnknown specifies whether to emit unknown fields in the output.
// If specified, the unmarshaler may be unable to parse the output.
// The default is to exclude unknown fields.
EmitUnknown bool
// Resolver is used for looking up types when expanding google.protobuf.Any
// messages. If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
protoregistry.ExtensionTypeResolver
protoregistry.MessageTypeResolver
}
}
// Format formats the message as a string.
// This method is only intended for human consumption and ignores errors.
// Do not depend on the output being stable. Its output will change across
// different builds of your program, even when using the same version of the
// protobuf module.
func (o MarshalOptions) Format(m proto.Message) string {
if m == nil || !m.ProtoReflect().IsValid() {
return "<nil>" // invalid syntax, but okay since this is for debugging
}
o.allowInvalidUTF8 = true
o.AllowPartial = true
o.EmitUnknown = true
b, _ := o.Marshal(m)
return string(b)
}
// Marshal writes the given [proto.Message] in textproto format using options in
// MarshalOptions object. Do not depend on the output being stable. Its output
// will change across different builds of your program, even when using the
// same version of the protobuf module.
func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
return o.marshal(nil, m)
}
// MarshalAppend appends the textproto format encoding of m to b,
// returning the result.
func (o MarshalOptions) MarshalAppend(b []byte, m proto.Message) ([]byte, error) {
return o.marshal(b, 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(b []byte, m proto.Message) ([]byte, error) {
var delims = [2]byte{'{', '}'}
if o.Multiline && o.Indent == "" {
o.Indent = defaultIndent
}
if o.Resolver == nil {
o.Resolver = protoregistry.GlobalTypes
}
internalEnc, err := text.NewEncoder(b, o.Indent, delims, o.EmitASCII)
if err != nil {
return nil, err
}
// Treat nil message interface as an empty message,
// in which case there is nothing to output.
if m == nil {
return b, nil
}
enc := encoder{internalEnc, o}
err = enc.marshalMessage(m.ProtoReflect(), false)
if err != nil {
return nil, err
}
out := enc.Bytes()
if len(o.Indent) > 0 && len(out) > 0 {
out = append(out, '\n')
}
if o.AllowPartial {
return out, nil
}
return out, proto.CheckInitialized(m)
}
type encoder struct {
*text.Encoder
opts MarshalOptions
}
// marshalMessage marshals the given protoreflect.Message.
func (e encoder) marshalMessage(m protoreflect.Message, inclDelims bool) error {
messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets")
}
if inclDelims {
e.StartMessage()
defer e.EndMessage()
}
// Handle Any expansion.
if messageDesc.FullName() == genid.Any_message_fullname {
if e.marshalAny(m) {
return nil
}
// If unable to expand, continue on to marshal Any as a regular message.
}
// Marshal fields.
var err error
order.RangeFields(m, order.IndexNameFieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
if err = e.marshalField(fd.TextName(), v, fd); err != nil {
return false
}
return true
})
if err != nil {
return err
}
// Marshal unknown fields.
if e.opts.EmitUnknown {
e.marshalUnknown(m.GetUnknown())
}
return nil
}
// marshalField marshals the given field with protoreflect.Value.
func (e encoder) marshalField(name string, val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch {
case fd.IsList():
return e.marshalList(name, val.List(), fd)
case fd.IsMap():
return e.marshalMap(name, val.Map(), fd)
default:
e.WriteName(name)
return e.marshalSingular(val, fd)
}
}
// marshalSingular marshals the given non-repeated field value. This includes
// all scalar types, enums, messages, and groups.
func (e encoder) marshalSingular(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
kind := fd.Kind()
switch kind {
case protoreflect.BoolKind:
e.WriteBool(val.Bool())
case protoreflect.StringKind:
s := val.String()
if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
return errors.InvalidUTF8(string(fd.FullName()))
}
e.WriteString(s)
case protoreflect.Int32Kind, protoreflect.Int64Kind,
protoreflect.Sint32Kind, protoreflect.Sint64Kind,
protoreflect.Sfixed32Kind, protoreflect.Sfixed64Kind:
e.WriteInt(val.Int())
case protoreflect.Uint32Kind, protoreflect.Uint64Kind,
protoreflect.Fixed32Kind, protoreflect.Fixed64Kind:
e.WriteUint(val.Uint())
case protoreflect.FloatKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 32)
case protoreflect.DoubleKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 64)
case protoreflect.BytesKind:
e.WriteString(string(val.Bytes()))
case protoreflect.EnumKind:
num := val.Enum()
if desc := fd.Enum().Values().ByNumber(num); desc != nil {
e.WriteLiteral(string(desc.Name()))
} else {
// Use numeric value if there is no enum description.
e.WriteInt(int64(num))
}
case protoreflect.MessageKind, protoreflect.GroupKind:
return e.marshalMessage(val.Message(), true)
default:
panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
}
return nil
}
// marshalList marshals the given protoreflect.List as multiple name-value fields.
func (e encoder) marshalList(name string, list protoreflect.List, fd protoreflect.FieldDescriptor) error {
size := list.Len()
for i := 0; i < size; i++ {
e.WriteName(name)
if err := e.marshalSingular(list.Get(i), fd); err != nil {
return err
}
}
return nil
}
// marshalMap marshals the given protoreflect.Map as multiple name-value fields.
func (e encoder) marshalMap(name string, mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
var err error
order.RangeEntries(mmap, order.GenericKeyOrder, func(key protoreflect.MapKey, val protoreflect.Value) bool {
e.WriteName(name)
e.StartMessage()
defer e.EndMessage()
e.WriteName(string(genid.MapEntry_Key_field_name))
err = e.marshalSingular(key.Value(), fd.MapKey())
if err != nil {
return false
}
e.WriteName(string(genid.MapEntry_Value_field_name))
err = e.marshalSingular(val, fd.MapValue())
if err != nil {
return false
}
return true
})
return err
}
// marshalUnknown parses the given []byte and marshals fields out.
// This function assumes proper encoding in the given []byte.
func (e encoder) marshalUnknown(b []byte) {
const dec = 10
const hex = 16
for len(b) > 0 {
num, wtype, n := protowire.ConsumeTag(b)
b = b[n:]
e.WriteName(strconv.FormatInt(int64(num), dec))
switch wtype {
case protowire.VarintType:
var v uint64
v, n = protowire.ConsumeVarint(b)
e.WriteUint(v)
case protowire.Fixed32Type:
var v uint32
v, n = protowire.ConsumeFixed32(b)
e.WriteLiteral("0x" + strconv.FormatUint(uint64(v), hex))
case protowire.Fixed64Type:
var v uint64
v, n = protowire.ConsumeFixed64(b)
e.WriteLiteral("0x" + strconv.FormatUint(v, hex))
case protowire.BytesType:
var v []byte
v, n = protowire.ConsumeBytes(b)
e.WriteString(string(v))
case protowire.StartGroupType:
e.StartMessage()
var v []byte
v, n = protowire.ConsumeGroup(num, b)
e.marshalUnknown(v)
e.EndMessage()
default:
panic(fmt.Sprintf("prototext: error parsing unknown field wire type: %v", wtype))
}
b = b[n:]
}
}
// marshalAny marshals the given google.protobuf.Any message in expanded form.
// It returns true if it was able to marshal, else false.
func (e encoder) marshalAny(any protoreflect.Message) bool {
// Construct the embedded message.
fds := any.Descriptor().Fields()
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
typeURL := any.Get(fdType).String()
mt, err := e.opts.Resolver.FindMessageByURL(typeURL)
if err != nil {
return false
}
m := mt.New().Interface()
// Unmarshal bytes into embedded message.
fdValue := fds.ByNumber(genid.Any_Value_field_number)
value := any.Get(fdValue)
err = proto.UnmarshalOptions{
AllowPartial: true,
Resolver: e.opts.Resolver,
}.Unmarshal(value.Bytes(), m)
if err != nil {
return false
}
// Get current encoder position. If marshaling fails, reset encoder output
// back to this position.
pos := e.Snapshot()
// Field name is the proto field name enclosed in [].
e.WriteName("[" + typeURL + "]")
err = e.marshalMessage(m.ProtoReflect(), true)
if err != nil {
e.Reset(pos)
return false
}
return true
}
// Copyright 2018 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 protowire parses and formats the raw wire encoding.
// See https://protobuf.dev/programming-guides/encoding.
//
// For marshaling and unmarshaling entire protobuf messages,
// use the [google.golang.org/protobuf/proto] package instead.
package protowire
import (
"io"
"math"
"math/bits"
"google.golang.org/protobuf/internal/errors"
)
// Number represents the field number.
type Number int32
const (
MinValidNumber Number = 1
FirstReservedNumber Number = 19000
LastReservedNumber Number = 19999
MaxValidNumber Number = 1<<29 - 1
DefaultRecursionLimit = 10000
)
// IsValid reports whether the field number is semantically valid.
func (n Number) IsValid() bool {
return MinValidNumber <= n && n <= MaxValidNumber
}
// Type represents the wire type.
type Type int8
const (
VarintType Type = 0
Fixed32Type Type = 5
Fixed64Type Type = 1
BytesType Type = 2
StartGroupType Type = 3
EndGroupType Type = 4
)
const (
_ = -iota
errCodeTruncated
errCodeFieldNumber
errCodeOverflow
errCodeReserved
errCodeEndGroup
errCodeRecursionDepth
)
var (
errFieldNumber = errors.New("invalid field number")
errOverflow = errors.New("variable length integer overflow")
errReserved = errors.New("cannot parse reserved wire type")
errEndGroup = errors.New("mismatching end group marker")
errParse = errors.New("parse error")
)
// ParseError converts an error code into an error value.
// This returns nil if n is a non-negative number.
func ParseError(n int) error {
if n >= 0 {
return nil
}
switch n {
case errCodeTruncated:
return io.ErrUnexpectedEOF
case errCodeFieldNumber:
return errFieldNumber
case errCodeOverflow:
return errOverflow
case errCodeReserved:
return errReserved
case errCodeEndGroup:
return errEndGroup
default:
return errParse
}
}
// ConsumeField parses an entire field record (both tag and value) and returns
// the field number, the wire type, and the total length.
// This returns a negative length upon an error (see [ParseError]).
//
// The total length includes the tag header and the end group marker (if the
// field is a group).
func ConsumeField(b []byte) (Number, Type, int) {
num, typ, n := ConsumeTag(b)
if n < 0 {
return 0, 0, n // forward error code
}
m := ConsumeFieldValue(num, typ, b[n:])
if m < 0 {
return 0, 0, m // forward error code
}
return num, typ, n + m
}
// ConsumeFieldValue parses a field value and returns its length.
// This assumes that the field [Number] and wire [Type] have already been parsed.
// This returns a negative length upon an error (see [ParseError]).
//
// When parsing a group, the length includes the end group marker and
// the end group is verified to match the starting field number.
func ConsumeFieldValue(num Number, typ Type, b []byte) (n int) {
return consumeFieldValueD(num, typ, b, DefaultRecursionLimit)
}
func consumeFieldValueD(num Number, typ Type, b []byte, depth int) (n int) {
switch typ {
case VarintType:
_, n = ConsumeVarint(b)
return n
case Fixed32Type:
_, n = ConsumeFixed32(b)
return n
case Fixed64Type:
_, n = ConsumeFixed64(b)
return n
case BytesType:
_, n = ConsumeBytes(b)
return n
case StartGroupType:
if depth < 0 {
return errCodeRecursionDepth
}
n0 := len(b)
for {
num2, typ2, n := ConsumeTag(b)
if n < 0 {
return n // forward error code
}
b = b[n:]
if typ2 == EndGroupType {
if num != num2 {
return errCodeEndGroup
}
return n0 - len(b)
}
n = consumeFieldValueD(num2, typ2, b, depth-1)
if n < 0 {
return n // forward error code
}
b = b[n:]
}
case EndGroupType:
return errCodeEndGroup
default:
return errCodeReserved
}
}
// AppendTag encodes num and typ as a varint-encoded tag and appends it to b.
func AppendTag(b []byte, num Number, typ Type) []byte {
return AppendVarint(b, EncodeTag(num, typ))
}
// ConsumeTag parses b as a varint-encoded tag, reporting its length.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeTag(b []byte) (Number, Type, int) {
v, n := ConsumeVarint(b)
if n < 0 {
return 0, 0, n // forward error code
}
num, typ := DecodeTag(v)
if num < MinValidNumber {
return 0, 0, errCodeFieldNumber
}
return num, typ, n
}
func SizeTag(num Number) int {
return SizeVarint(EncodeTag(num, 0)) // wire type has no effect on size
}
// AppendVarint appends v to b as a varint-encoded uint64.
func AppendVarint(b []byte, v uint64) []byte {
switch {
case v < 1<<7:
b = append(b, byte(v))
case v < 1<<14:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte(v>>7))
case v < 1<<21:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte(v>>14))
case v < 1<<28:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte(v>>21))
case v < 1<<35:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte((v>>21)&0x7f|0x80),
byte(v>>28))
case v < 1<<42:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte((v>>21)&0x7f|0x80),
byte((v>>28)&0x7f|0x80),
byte(v>>35))
case v < 1<<49:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte((v>>21)&0x7f|0x80),
byte((v>>28)&0x7f|0x80),
byte((v>>35)&0x7f|0x80),
byte(v>>42))
case v < 1<<56:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte((v>>21)&0x7f|0x80),
byte((v>>28)&0x7f|0x80),
byte((v>>35)&0x7f|0x80),
byte((v>>42)&0x7f|0x80),
byte(v>>49))
case v < 1<<63:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte((v>>21)&0x7f|0x80),
byte((v>>28)&0x7f|0x80),
byte((v>>35)&0x7f|0x80),
byte((v>>42)&0x7f|0x80),
byte((v>>49)&0x7f|0x80),
byte(v>>56))
default:
b = append(b,
byte((v>>0)&0x7f|0x80),
byte((v>>7)&0x7f|0x80),
byte((v>>14)&0x7f|0x80),
byte((v>>21)&0x7f|0x80),
byte((v>>28)&0x7f|0x80),
byte((v>>35)&0x7f|0x80),
byte((v>>42)&0x7f|0x80),
byte((v>>49)&0x7f|0x80),
byte((v>>56)&0x7f|0x80),
1)
}
return b
}
// ConsumeVarint parses b as a varint-encoded uint64, reporting its length.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeVarint(b []byte) (v uint64, n int) {
var y uint64
if len(b) <= 0 {
return 0, errCodeTruncated
}
v = uint64(b[0])
if v < 0x80 {
return v, 1
}
v -= 0x80
if len(b) <= 1 {
return 0, errCodeTruncated
}
y = uint64(b[1])
v += y << 7
if y < 0x80 {
return v, 2
}
v -= 0x80 << 7
if len(b) <= 2 {
return 0, errCodeTruncated
}
y = uint64(b[2])
v += y << 14
if y < 0x80 {
return v, 3
}
v -= 0x80 << 14
if len(b) <= 3 {
return 0, errCodeTruncated
}
y = uint64(b[3])
v += y << 21
if y < 0x80 {
return v, 4
}
v -= 0x80 << 21
if len(b) <= 4 {
return 0, errCodeTruncated
}
y = uint64(b[4])
v += y << 28
if y < 0x80 {
return v, 5
}
v -= 0x80 << 28
if len(b) <= 5 {
return 0, errCodeTruncated
}
y = uint64(b[5])
v += y << 35
if y < 0x80 {
return v, 6
}
v -= 0x80 << 35
if len(b) <= 6 {
return 0, errCodeTruncated
}
y = uint64(b[6])
v += y << 42
if y < 0x80 {
return v, 7
}
v -= 0x80 << 42
if len(b) <= 7 {
return 0, errCodeTruncated
}
y = uint64(b[7])
v += y << 49
if y < 0x80 {
return v, 8
}
v -= 0x80 << 49
if len(b) <= 8 {
return 0, errCodeTruncated
}
y = uint64(b[8])
v += y << 56
if y < 0x80 {
return v, 9
}
v -= 0x80 << 56
if len(b) <= 9 {
return 0, errCodeTruncated
}
y = uint64(b[9])
v += y << 63
if y < 2 {
return v, 10
}
return 0, errCodeOverflow
}
// SizeVarint returns the encoded size of a varint.
// The size is guaranteed to be within 1 and 10, inclusive.
func SizeVarint(v uint64) int {
// This computes 1 + (bits.Len64(v)-1)/7.
// 9/64 is a good enough approximation of 1/7
//
// The Go compiler can translate the bits.LeadingZeros64 call into the LZCNT
// instruction, which is very fast on CPUs from the last few years. The
// specific way of expressing the calculation matches C++ Protobuf, see
// https://godbolt.org/z/4P3h53oM4 for the C++ code and how gcc/clang
// optimize that function for GOAMD64=v1 and GOAMD64=v3 (-march=haswell).
// By OR'ing v with 1, we guarantee that v is never 0, without changing the
// result of SizeVarint. LZCNT is not defined for 0, meaning the compiler
// needs to add extra instructions to handle that case.
//
// The Go compiler currently (go1.24.4) does not make use of this knowledge.
// This opportunity (removing the XOR instruction, which handles the 0 case)
// results in a small (1%) performance win across CPU architectures.
//
// Independently of avoiding the 0 case, we need the v |= 1 line because
// it allows the Go compiler to eliminate an extra XCHGL barrier.
v |= 1
// It would be clearer to write log2value := 63 - uint32(...), but
// writing uint32(...) ^ 63 is much more efficient (-14% ARM, -20% Intel).
// Proof of identity for our value range [0..63]:
// https://go.dev/play/p/Pdn9hEWYakX
log2value := uint32(bits.LeadingZeros64(v)) ^ 63
return int((log2value*9 + (64 + 9)) / 64)
}
// AppendFixed32 appends v to b as a little-endian uint32.
func AppendFixed32(b []byte, v uint32) []byte {
return append(b,
byte(v>>0),
byte(v>>8),
byte(v>>16),
byte(v>>24))
}
// ConsumeFixed32 parses b as a little-endian uint32, reporting its length.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeFixed32(b []byte) (v uint32, n int) {
if len(b) < 4 {
return 0, errCodeTruncated
}
v = uint32(b[0])<<0 | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
return v, 4
}
// SizeFixed32 returns the encoded size of a fixed32; which is always 4.
func SizeFixed32() int {
return 4
}
// AppendFixed64 appends v to b as a little-endian uint64.
func AppendFixed64(b []byte, v uint64) []byte {
return append(b,
byte(v>>0),
byte(v>>8),
byte(v>>16),
byte(v>>24),
byte(v>>32),
byte(v>>40),
byte(v>>48),
byte(v>>56))
}
// ConsumeFixed64 parses b as a little-endian uint64, reporting its length.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeFixed64(b []byte) (v uint64, n int) {
if len(b) < 8 {
return 0, errCodeTruncated
}
v = uint64(b[0])<<0 | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
return v, 8
}
// SizeFixed64 returns the encoded size of a fixed64; which is always 8.
func SizeFixed64() int {
return 8
}
// AppendBytes appends v to b as a length-prefixed bytes value.
func AppendBytes(b []byte, v []byte) []byte {
return append(AppendVarint(b, uint64(len(v))), v...)
}
// ConsumeBytes parses b as a length-prefixed bytes value, reporting its length.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeBytes(b []byte) (v []byte, n int) {
m, n := ConsumeVarint(b)
if n < 0 {
return nil, n // forward error code
}
if m > uint64(len(b[n:])) {
return nil, errCodeTruncated
}
return b[n:][:m], n + int(m)
}
// SizeBytes returns the encoded size of a length-prefixed bytes value,
// given only the length.
func SizeBytes(n int) int {
return SizeVarint(uint64(n)) + n
}
// AppendString appends v to b as a length-prefixed bytes value.
func AppendString(b []byte, v string) []byte {
return append(AppendVarint(b, uint64(len(v))), v...)
}
// ConsumeString parses b as a length-prefixed bytes value, reporting its length.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeString(b []byte) (v string, n int) {
bb, n := ConsumeBytes(b)
return string(bb), n
}
// AppendGroup appends v to b as group value, with a trailing end group marker.
// The value v must not contain the end marker.
func AppendGroup(b []byte, num Number, v []byte) []byte {
return AppendVarint(append(b, v...), EncodeTag(num, EndGroupType))
}
// ConsumeGroup parses b as a group value until the trailing end group marker,
// and verifies that the end marker matches the provided num. The value v
// does not contain the end marker, while the length does contain the end marker.
// This returns a negative length upon an error (see [ParseError]).
func ConsumeGroup(num Number, b []byte) (v []byte, n int) {
n = ConsumeFieldValue(num, StartGroupType, b)
if n < 0 {
return nil, n // forward error code
}
b = b[:n]
// Truncate off end group marker, but need to handle denormalized varints.
// Assuming end marker is never 0 (which is always the case since
// EndGroupType is non-zero), we can truncate all trailing bytes where the
// lower 7 bits are all zero (implying that the varint is denormalized).
for len(b) > 0 && b[len(b)-1]&0x7f == 0 {
b = b[:len(b)-1]
}
b = b[:len(b)-SizeTag(num)]
return b, n
}
// SizeGroup returns the encoded size of a group, given only the length.
func SizeGroup(num Number, n int) int {
return n + SizeTag(num)
}
// DecodeTag decodes the field [Number] and wire [Type] from its unified form.
// The [Number] is -1 if the decoded field number overflows int32.
// Other than overflow, this does not check for field number validity.
func DecodeTag(x uint64) (Number, Type) {
// NOTE: MessageSet allows for larger field numbers than normal.
if x>>3 > uint64(math.MaxInt32) {
return -1, 0
}
return Number(x >> 3), Type(x & 7)
}
// EncodeTag encodes the field [Number] and wire [Type] into its unified form.
func EncodeTag(num Number, typ Type) uint64 {
return uint64(num)<<3 | uint64(typ&7)
}
// DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.
//
// Input: {…, 5, 3, 1, 0, 2, 4, 6, …}
// Output: {…, -3, -2, -1, 0, +1, +2, +3, …}
func DecodeZigZag(x uint64) int64 {
return int64(x>>1) ^ int64(x)<<63>>63
}
// EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.
//
// Input: {…, -3, -2, -1, 0, +1, +2, +3, …}
// Output: {…, 5, 3, 1, 0, 2, 4, 6, …}
func EncodeZigZag(x int64) uint64 {
return uint64(x<<1) ^ uint64(x>>63)
}
// DecodeBool decodes a uint64 as a bool.
//
// Input: { 0, 1, 2, …}
// Output: {false, true, true, …}
func DecodeBool(x uint64) bool {
return x != 0
}
// EncodeBool encodes a bool as a uint64.
//
// Input: {false, true}
// Output: { 0, 1}
func EncodeBool(x bool) uint64 {
if x {
return 1
}
return 0
}
// Copyright 2018 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 descfmt provides functionality to format descriptors.
package descfmt
import (
"fmt"
"io"
"reflect"
"strconv"
"strings"
"google.golang.org/protobuf/internal/detrand"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
)
type list interface {
Len() int
pragma.DoNotImplement
}
func FormatList(s fmt.State, r rune, vs list) {
io.WriteString(s, formatListOpt(vs, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
}
func formatListOpt(vs list, isRoot, allowMulti bool) string {
start, end := "[", "]"
if isRoot {
var name string
switch vs.(type) {
case protoreflect.Names:
name = "Names"
case protoreflect.FieldNumbers:
name = "FieldNumbers"
case protoreflect.FieldRanges:
name = "FieldRanges"
case protoreflect.EnumRanges:
name = "EnumRanges"
case protoreflect.FileImports:
name = "FileImports"
case protoreflect.Descriptor:
name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
default:
name = reflect.ValueOf(vs).Elem().Type().Name()
}
start, end = name+"{", "}"
}
var ss []string
switch vs := vs.(type) {
case protoreflect.Names:
for i := 0; i < vs.Len(); i++ {
ss = append(ss, fmt.Sprint(vs.Get(i)))
}
return start + joinStrings(ss, false) + end
case protoreflect.FieldNumbers:
for i := 0; i < vs.Len(); i++ {
ss = append(ss, fmt.Sprint(vs.Get(i)))
}
return start + joinStrings(ss, false) + end
case protoreflect.FieldRanges:
for i := 0; i < vs.Len(); i++ {
r := vs.Get(i)
if r[0]+1 == r[1] {
ss = append(ss, fmt.Sprintf("%d", r[0]))
} else {
ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive
}
}
return start + joinStrings(ss, false) + end
case protoreflect.EnumRanges:
for i := 0; i < vs.Len(); i++ {
r := vs.Get(i)
if r[0] == r[1] {
ss = append(ss, fmt.Sprintf("%d", r[0]))
} else {
ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive
}
}
return start + joinStrings(ss, false) + end
case protoreflect.FileImports:
for i := 0; i < vs.Len(); i++ {
var rs records
rv := reflect.ValueOf(vs.Get(i))
rs.Append(rv, []methodAndName{
{rv.MethodByName("Path"), "Path"},
{rv.MethodByName("Package"), "Package"},
{rv.MethodByName("IsPublic"), "IsPublic"},
{rv.MethodByName("IsWeak"), "IsWeak"},
}...)
ss = append(ss, "{"+rs.Join()+"}")
}
return start + joinStrings(ss, allowMulti) + end
default:
_, isEnumValue := vs.(protoreflect.EnumValueDescriptors)
for i := 0; i < vs.Len(); i++ {
m := reflect.ValueOf(vs).MethodByName("Get")
v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
ss = append(ss, formatDescOpt(v.(protoreflect.Descriptor), false, allowMulti && !isEnumValue, nil))
}
return start + joinStrings(ss, allowMulti && isEnumValue) + end
}
}
type methodAndName struct {
method reflect.Value
name string
}
func FormatDesc(s fmt.State, r rune, t protoreflect.Descriptor) {
io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#')), nil))
}
func InternalFormatDescOptForTesting(t protoreflect.Descriptor, isRoot, allowMulti bool, record func(string)) string {
return formatDescOpt(t, isRoot, allowMulti, record)
}
func formatDescOpt(t protoreflect.Descriptor, isRoot, allowMulti bool, record func(string)) string {
rv := reflect.ValueOf(t)
rt := rv.MethodByName("ProtoType").Type().In(0)
start, end := "{", "}"
if isRoot {
start = rt.Name() + "{"
}
_, isFile := t.(protoreflect.FileDescriptor)
rs := records{
allowMulti: allowMulti,
record: record,
}
if t.IsPlaceholder() {
if isFile {
rs.Append(rv, []methodAndName{
{rv.MethodByName("Path"), "Path"},
{rv.MethodByName("Package"), "Package"},
{rv.MethodByName("IsPlaceholder"), "IsPlaceholder"},
}...)
} else {
rs.Append(rv, []methodAndName{
{rv.MethodByName("FullName"), "FullName"},
{rv.MethodByName("IsPlaceholder"), "IsPlaceholder"},
}...)
}
} else {
switch {
case isFile:
rs.Append(rv, methodAndName{rv.MethodByName("Syntax"), "Syntax"})
case isRoot:
rs.Append(rv, []methodAndName{
{rv.MethodByName("Syntax"), "Syntax"},
{rv.MethodByName("FullName"), "FullName"},
}...)
default:
rs.Append(rv, methodAndName{rv.MethodByName("Name"), "Name"})
}
switch t := t.(type) {
case protoreflect.FieldDescriptor:
accessors := []methodAndName{
{rv.MethodByName("Number"), "Number"},
{rv.MethodByName("Cardinality"), "Cardinality"},
{rv.MethodByName("Kind"), "Kind"},
{rv.MethodByName("HasJSONName"), "HasJSONName"},
{rv.MethodByName("JSONName"), "JSONName"},
{rv.MethodByName("HasPresence"), "HasPresence"},
{rv.MethodByName("IsExtension"), "IsExtension"},
{rv.MethodByName("IsPacked"), "IsPacked"},
{rv.MethodByName("IsWeak"), "IsWeak"},
{rv.MethodByName("IsList"), "IsList"},
{rv.MethodByName("IsMap"), "IsMap"},
{rv.MethodByName("MapKey"), "MapKey"},
{rv.MethodByName("MapValue"), "MapValue"},
{rv.MethodByName("HasDefault"), "HasDefault"},
{rv.MethodByName("Default"), "Default"},
{rv.MethodByName("ContainingOneof"), "ContainingOneof"},
{rv.MethodByName("ContainingMessage"), "ContainingMessage"},
{rv.MethodByName("Message"), "Message"},
{rv.MethodByName("Enum"), "Enum"},
}
for _, s := range accessors {
switch s.name {
case "MapKey":
if k := t.MapKey(); k != nil {
rs.recs = append(rs.recs, [2]string{"MapKey", k.Kind().String()})
}
case "MapValue":
if v := t.MapValue(); v != nil {
switch v.Kind() {
case protoreflect.EnumKind:
rs.AppendRecs("MapValue", [2]string{"MapValue", string(v.Enum().FullName())})
case protoreflect.MessageKind, protoreflect.GroupKind:
rs.AppendRecs("MapValue", [2]string{"MapValue", string(v.Message().FullName())})
default:
rs.AppendRecs("MapValue", [2]string{"MapValue", v.Kind().String()})
}
}
case "ContainingOneof":
if od := t.ContainingOneof(); od != nil {
rs.AppendRecs("ContainingOneof", [2]string{"Oneof", string(od.Name())})
}
case "ContainingMessage":
if t.IsExtension() {
rs.AppendRecs("ContainingMessage", [2]string{"Extendee", string(t.ContainingMessage().FullName())})
}
case "Message":
if !t.IsMap() {
rs.Append(rv, s)
}
default:
rs.Append(rv, s)
}
}
case protoreflect.OneofDescriptor:
var ss []string
fs := t.Fields()
for i := 0; i < fs.Len(); i++ {
ss = append(ss, string(fs.Get(i).Name()))
}
if len(ss) > 0 {
rs.AppendRecs("Fields", [2]string{"Fields", "[" + joinStrings(ss, false) + "]"})
}
case protoreflect.FileDescriptor:
rs.Append(rv, []methodAndName{
{rv.MethodByName("Path"), "Path"},
{rv.MethodByName("Package"), "Package"},
{rv.MethodByName("Imports"), "Imports"},
{rv.MethodByName("Messages"), "Messages"},
{rv.MethodByName("Enums"), "Enums"},
{rv.MethodByName("Extensions"), "Extensions"},
{rv.MethodByName("Services"), "Services"},
}...)
case protoreflect.MessageDescriptor:
rs.Append(rv, []methodAndName{
{rv.MethodByName("IsMapEntry"), "IsMapEntry"},
{rv.MethodByName("Fields"), "Fields"},
{rv.MethodByName("Oneofs"), "Oneofs"},
{rv.MethodByName("ReservedNames"), "ReservedNames"},
{rv.MethodByName("ReservedRanges"), "ReservedRanges"},
{rv.MethodByName("RequiredNumbers"), "RequiredNumbers"},
{rv.MethodByName("ExtensionRanges"), "ExtensionRanges"},
{rv.MethodByName("Messages"), "Messages"},
{rv.MethodByName("Enums"), "Enums"},
{rv.MethodByName("Extensions"), "Extensions"},
}...)
case protoreflect.EnumDescriptor:
rs.Append(rv, []methodAndName{
{rv.MethodByName("Values"), "Values"},
{rv.MethodByName("ReservedNames"), "ReservedNames"},
{rv.MethodByName("ReservedRanges"), "ReservedRanges"},
{rv.MethodByName("IsClosed"), "IsClosed"},
}...)
case protoreflect.EnumValueDescriptor:
rs.Append(rv, []methodAndName{
{rv.MethodByName("Number"), "Number"},
}...)
case protoreflect.ServiceDescriptor:
rs.Append(rv, []methodAndName{
{rv.MethodByName("Methods"), "Methods"},
}...)
case protoreflect.MethodDescriptor:
rs.Append(rv, []methodAndName{
{rv.MethodByName("Input"), "Input"},
{rv.MethodByName("Output"), "Output"},
{rv.MethodByName("IsStreamingClient"), "IsStreamingClient"},
{rv.MethodByName("IsStreamingServer"), "IsStreamingServer"},
}...)
}
if m := rv.MethodByName("GoType"); m.IsValid() {
rs.Append(rv, methodAndName{m, "GoType"})
}
}
return start + rs.Join() + end
}
type records struct {
recs [][2]string
allowMulti bool
// record is a function that will be called for every Append() or
// AppendRecs() call, to be used for testing with the
// InternalFormatDescOptForTesting function.
record func(string)
}
func (rs *records) AppendRecs(fieldName string, newRecs [2]string) {
if rs.record != nil {
rs.record(fieldName)
}
rs.recs = append(rs.recs, newRecs)
}
func (rs *records) Append(v reflect.Value, accessors ...methodAndName) {
for _, a := range accessors {
if rs.record != nil {
rs.record(a.name)
}
var rv reflect.Value
if a.method.IsValid() {
rv = a.method.Call(nil)[0]
}
if v.Kind() == reflect.Struct && !rv.IsValid() {
rv = v.FieldByName(a.name)
}
if !rv.IsValid() {
panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a.name))
}
if _, ok := rv.Interface().(protoreflect.Value); ok {
rv = rv.MethodByName("Interface").Call(nil)[0]
if !rv.IsNil() {
rv = rv.Elem()
}
}
// Ignore zero values.
var isZero bool
switch rv.Kind() {
case reflect.Interface, reflect.Slice:
isZero = rv.IsNil()
case reflect.Bool:
isZero = rv.Bool() == false
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
isZero = rv.Int() == 0
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
isZero = rv.Uint() == 0
case reflect.String:
isZero = rv.String() == ""
}
if n, ok := rv.Interface().(list); ok {
isZero = n.Len() == 0
}
if isZero {
continue
}
// Format the value.
var s string
v := rv.Interface()
switch v := v.(type) {
case list:
s = formatListOpt(v, false, rs.allowMulti)
case protoreflect.FieldDescriptor, protoreflect.OneofDescriptor, protoreflect.EnumValueDescriptor, protoreflect.MethodDescriptor:
s = string(v.(protoreflect.Descriptor).Name())
case protoreflect.Descriptor:
s = string(v.FullName())
case string:
s = strconv.Quote(v)
case []byte:
s = fmt.Sprintf("%q", v)
default:
s = fmt.Sprint(v)
}
rs.recs = append(rs.recs, [2]string{a.name, s})
}
}
func (rs *records) Join() string {
var ss []string
// In single line mode, simply join all records with commas.
if !rs.allowMulti {
for _, r := range rs.recs {
ss = append(ss, r[0]+formatColon(0)+r[1])
}
return joinStrings(ss, false)
}
// In allowMulti line mode, align single line records for more readable output.
var maxLen int
flush := func(i int) {
for _, r := range rs.recs[len(ss):i] {
ss = append(ss, r[0]+formatColon(maxLen-len(r[0]))+r[1])
}
maxLen = 0
}
for i, r := range rs.recs {
if isMulti := strings.Contains(r[1], "\n"); isMulti {
flush(i)
ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t"))
} else if maxLen < len(r[0]) {
maxLen = len(r[0])
}
}
flush(len(rs.recs))
return joinStrings(ss, true)
}
func formatColon(padding int) string {
// Deliberately introduce instability into the debug output to
// discourage users from performing string comparisons.
// This provides us flexibility to change the output in the future.
if detrand.Bool() {
return ":" + strings.Repeat(" ", 1+padding) // use non-breaking spaces (U+00a0)
} else {
return ":" + strings.Repeat(" ", 1+padding) // use regular spaces (U+0020)
}
}
func joinStrings(ss []string, isMulti bool) string {
if len(ss) == 0 {
return ""
}
if isMulti {
return "\n\t" + strings.Join(ss, "\n\t") + "\n"
}
return strings.Join(ss, ", ")
}
// Copyright 2018 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 detrand provides deterministically random functionality.
//
// The pseudo-randomness of these functions is seeded by the program binary
// itself and guarantees that the output does not change within a program,
// while ensuring that the output is unstable across different builds.
package detrand
import (
"encoding/binary"
"hash/fnv"
"os"
)
// Disable disables detrand such that all functions returns the zero value.
// This function is not concurrent-safe and must be called during program init.
func Disable() {
randSeed = 0
}
// Bool returns a deterministically random boolean.
func Bool() bool {
return randSeed%2 == 1
}
// Intn returns a deterministically random integer between 0 and n-1, inclusive.
func Intn(n int) int {
if n <= 0 {
panic("must be positive")
}
return int(randSeed % uint64(n))
}
// randSeed is a best-effort at an approximate hash of the Go binary.
var randSeed = binaryHash()
func binaryHash() uint64 {
// Open the Go binary.
s, err := os.Executable()
if err != nil {
return 0
}
f, err := os.Open(s)
if err != nil {
return 0
}
defer f.Close()
// Hash the size and several samples of the Go binary.
const numSamples = 8
var buf [64]byte
h := fnv.New64()
fi, err := f.Stat()
if err != nil {
return 0
}
binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
h.Write(buf[:8])
for i := int64(0); i < numSamples; i++ {
if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
return 0
}
h.Write(buf[:])
}
return h.Sum64()
}
// Copyright 2018 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 defval marshals and unmarshals textual forms of default values.
//
// This package handles both the form historically used in Go struct field tags
// and also the form used by google.protobuf.FieldDescriptorProto.default_value
// since they differ in superficial ways.
package defval
import (
"fmt"
"math"
"strconv"
ptext "google.golang.org/protobuf/internal/encoding/text"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
)
// Format is the serialization format used to represent the default value.
type Format int
const (
_ Format = iota
// Descriptor uses the serialization format that protoc uses with the
// google.protobuf.FieldDescriptorProto.default_value field.
Descriptor
// GoTag uses the historical serialization format in Go struct field tags.
GoTag
)
// Unmarshal deserializes the default string s according to the given kind k.
// When k is an enum, a list of enum value descriptors must be provided.
func Unmarshal(s string, k protoreflect.Kind, evs protoreflect.EnumValueDescriptors, f Format) (protoreflect.Value, protoreflect.EnumValueDescriptor, error) {
switch k {
case protoreflect.BoolKind:
if f == GoTag {
switch s {
case "1":
return protoreflect.ValueOfBool(true), nil, nil
case "0":
return protoreflect.ValueOfBool(false), nil, nil
}
} else {
switch s {
case "true":
return protoreflect.ValueOfBool(true), nil, nil
case "false":
return protoreflect.ValueOfBool(false), nil, nil
}
}
case protoreflect.EnumKind:
if f == GoTag {
// Go tags use the numeric form of the enum value.
if n, err := strconv.ParseInt(s, 10, 32); err == nil {
if ev := evs.ByNumber(protoreflect.EnumNumber(n)); ev != nil {
return protoreflect.ValueOfEnum(ev.Number()), ev, nil
}
}
} else {
// Descriptor default_value use the enum identifier.
ev := evs.ByName(protoreflect.Name(s))
if ev != nil {
return protoreflect.ValueOfEnum(ev.Number()), ev, nil
}
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if v, err := strconv.ParseInt(s, 10, 32); err == nil {
return protoreflect.ValueOfInt32(int32(v)), nil, nil
}
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if v, err := strconv.ParseInt(s, 10, 64); err == nil {
return protoreflect.ValueOfInt64(int64(v)), nil, nil
}
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if v, err := strconv.ParseUint(s, 10, 32); err == nil {
return protoreflect.ValueOfUint32(uint32(v)), nil, nil
}
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if v, err := strconv.ParseUint(s, 10, 64); err == nil {
return protoreflect.ValueOfUint64(uint64(v)), nil, nil
}
case protoreflect.FloatKind, protoreflect.DoubleKind:
var v float64
var err error
switch s {
case "-inf":
v = math.Inf(-1)
case "inf":
v = math.Inf(+1)
case "nan":
v = math.NaN()
default:
v, err = strconv.ParseFloat(s, 64)
}
if err == nil {
if k == protoreflect.FloatKind {
return protoreflect.ValueOfFloat32(float32(v)), nil, nil
} else {
return protoreflect.ValueOfFloat64(float64(v)), nil, nil
}
}
case protoreflect.StringKind:
// String values are already unescaped and can be used as is.
return protoreflect.ValueOfString(s), nil, nil
case protoreflect.BytesKind:
if b, ok := unmarshalBytes(s); ok {
return protoreflect.ValueOfBytes(b), nil, nil
}
}
return protoreflect.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
}
// Marshal serializes v as the default string according to the given kind k.
// When specifying the Descriptor format for an enum kind, the associated
// enum value descriptor must be provided.
func Marshal(v protoreflect.Value, ev protoreflect.EnumValueDescriptor, k protoreflect.Kind, f Format) (string, error) {
switch k {
case protoreflect.BoolKind:
if f == GoTag {
if v.Bool() {
return "1", nil
} else {
return "0", nil
}
} else {
if v.Bool() {
return "true", nil
} else {
return "false", nil
}
}
case protoreflect.EnumKind:
if f == GoTag {
return strconv.FormatInt(int64(v.Enum()), 10), nil
} else {
return string(ev.Name()), nil
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return strconv.FormatInt(v.Int(), 10), nil
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return strconv.FormatUint(v.Uint(), 10), nil
case protoreflect.FloatKind, protoreflect.DoubleKind:
f := v.Float()
switch {
case math.IsInf(f, -1):
return "-inf", nil
case math.IsInf(f, +1):
return "inf", nil
case math.IsNaN(f):
return "nan", nil
default:
if k == protoreflect.FloatKind {
return strconv.FormatFloat(f, 'g', -1, 32), nil
} else {
return strconv.FormatFloat(f, 'g', -1, 64), nil
}
}
case protoreflect.StringKind:
// String values are serialized as is without any escaping.
return v.String(), nil
case protoreflect.BytesKind:
if s, ok := marshalBytes(v.Bytes()); ok {
return s, nil
}
}
return "", errors.New("could not format value for %v: %v", k, v)
}
// unmarshalBytes deserializes bytes by applying C unescaping.
func unmarshalBytes(s string) ([]byte, bool) {
// Bytes values use the same escaping as the text format,
// however they lack the surrounding double quotes.
v, err := ptext.UnmarshalString(`"` + s + `"`)
if err != nil {
return nil, false
}
return []byte(v), true
}
// marshalBytes serializes bytes by using C escaping.
// To match the exact output of protoc, this is identical to the
// CEscape function in strutil.cc of the protoc source code.
func marshalBytes(b []byte) (string, bool) {
var s []byte
for _, c := range b {
switch c {
case '\n':
s = append(s, `\n`...)
case '\r':
s = append(s, `\r`...)
case '\t':
s = append(s, `\t`...)
case '"':
s = append(s, `\"`...)
case '\'':
s = append(s, `\'`...)
case '\\':
s = append(s, `\\`...)
default:
if printableASCII := c >= 0x20 && c <= 0x7e; printableASCII {
s = append(s, c)
} else {
s = append(s, fmt.Sprintf(`\%03o`, c)...)
}
}
}
return string(s), true
}
// Copyright 2018 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 json
import (
"bytes"
"fmt"
"io"
"regexp"
"unicode/utf8"
"google.golang.org/protobuf/internal/errors"
)
// call specifies which Decoder method was invoked.
type call uint8
const (
readCall call = iota
peekCall
)
const unexpectedFmt = "unexpected token %s"
// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
// Decoder is a token-based JSON decoder.
type Decoder struct {
// lastCall is last method called, either readCall or peekCall.
// Initial value is readCall.
lastCall call
// lastToken contains the last read token.
lastToken Token
// lastErr contains the last read error.
lastErr error
// openStack is a stack containing ObjectOpen and ArrayOpen values. The
// top of stack represents the object or the array the current value is
// directly located in.
openStack []Kind
// orig is used in reporting line and column.
orig []byte
// in contains the unconsumed input.
in []byte
}
// NewDecoder returns a Decoder to read the given []byte.
func NewDecoder(b []byte) *Decoder {
return &Decoder{orig: b, in: b}
}
// Peek looks ahead and returns the next token kind without advancing a read.
func (d *Decoder) Peek() (Token, error) {
defer func() { d.lastCall = peekCall }()
if d.lastCall == readCall {
d.lastToken, d.lastErr = d.Read()
}
return d.lastToken, d.lastErr
}
// Read returns the next JSON token.
// It will return an error if there is no valid token.
func (d *Decoder) Read() (Token, error) {
const scalar = Null | Bool | Number | String
defer func() { d.lastCall = readCall }()
if d.lastCall == peekCall {
return d.lastToken, d.lastErr
}
tok, err := d.parseNext()
if err != nil {
return Token{}, err
}
switch tok.kind {
case EOF:
if len(d.openStack) != 0 ||
d.lastToken.kind&scalar|ObjectClose|ArrayClose == 0 {
return Token{}, ErrUnexpectedEOF
}
case Null:
if !d.isValueNext() {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
case Bool, Number:
if !d.isValueNext() {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
case String:
if d.isValueNext() {
break
}
// This string token should only be for a field name.
if d.lastToken.kind&(ObjectOpen|comma) == 0 {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
if len(d.in) == 0 {
return Token{}, ErrUnexpectedEOF
}
if c := d.in[0]; c != ':' {
return Token{}, d.newSyntaxError(d.currPos(), `unexpected character %s, missing ":" after field name`, string(c))
}
tok.kind = Name
d.consume(1)
case ObjectOpen, ArrayOpen:
if !d.isValueNext() {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
d.openStack = append(d.openStack, tok.kind)
case ObjectClose:
if len(d.openStack) == 0 ||
d.lastToken.kind&(Name|comma) != 0 ||
d.openStack[len(d.openStack)-1] != ObjectOpen {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
d.openStack = d.openStack[:len(d.openStack)-1]
case ArrayClose:
if len(d.openStack) == 0 ||
d.lastToken.kind == comma ||
d.openStack[len(d.openStack)-1] != ArrayOpen {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
d.openStack = d.openStack[:len(d.openStack)-1]
case comma:
if len(d.openStack) == 0 ||
d.lastToken.kind&(scalar|ObjectClose|ArrayClose) == 0 {
return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
}
}
// Update d.lastToken only after validating token to be in the right sequence.
d.lastToken = tok
if d.lastToken.kind == comma {
return d.Read()
}
return tok, nil
}
// Any sequence that looks like a non-delimiter (for error reporting).
var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9]{1,32}|.)`)
// parseNext parses for the next JSON token. It returns a Token object for
// different types, except for Name. It does not handle whether the next token
// is in a valid sequence or not.
func (d *Decoder) parseNext() (Token, error) {
// Trim leading spaces.
d.consume(0)
in := d.in
if len(in) == 0 {
return d.consumeToken(EOF, 0), nil
}
switch in[0] {
case 'n':
if n := matchWithDelim("null", in); n != 0 {
return d.consumeToken(Null, n), nil
}
case 't':
if n := matchWithDelim("true", in); n != 0 {
return d.consumeBoolToken(true, n), nil
}
case 'f':
if n := matchWithDelim("false", in); n != 0 {
return d.consumeBoolToken(false, n), nil
}
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
if n, ok := parseNumber(in); ok {
return d.consumeToken(Number, n), nil
}
case '"':
s, n, err := d.parseString(in)
if err != nil {
return Token{}, err
}
return d.consumeStringToken(s, n), nil
case '{':
return d.consumeToken(ObjectOpen, 1), nil
case '}':
return d.consumeToken(ObjectClose, 1), nil
case '[':
return d.consumeToken(ArrayOpen, 1), nil
case ']':
return d.consumeToken(ArrayClose, 1), nil
case ',':
return d.consumeToken(comma, 1), nil
}
return Token{}, d.newSyntaxError(d.currPos(), "invalid value %s", errRegexp.Find(in))
}
// newSyntaxError returns an error with line and column information useful for
// syntax errors.
func (d *Decoder) newSyntaxError(pos int, f string, x ...any) error {
e := errors.New(f, x...)
line, column := d.Position(pos)
return errors.New("syntax error (line %d:%d): %v", line, column, e)
}
// Position returns line and column number of given index of the original input.
// It will panic if index is out of range.
func (d *Decoder) Position(idx int) (line int, column int) {
b := d.orig[:idx]
line = bytes.Count(b, []byte("\n")) + 1
if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
b = b[i+1:]
}
column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
return line, column
}
// currPos returns the current index position of d.in from d.orig.
func (d *Decoder) currPos() int {
return len(d.orig) - len(d.in)
}
// matchWithDelim matches s with the input b and verifies that the match
// terminates with a delimiter of some form (e.g., r"[^-+_.a-zA-Z0-9]").
// As a special case, EOF is considered a delimiter. It returns the length of s
// if there is a match, else 0.
func matchWithDelim(s string, b []byte) int {
if !bytes.HasPrefix(b, []byte(s)) {
return 0
}
n := len(s)
if n < len(b) && isNotDelim(b[n]) {
return 0
}
return n
}
// isNotDelim returns true if given byte is a not delimiter character.
func isNotDelim(c byte) bool {
return (c == '-' || c == '+' || c == '.' || c == '_' ||
('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
('0' <= c && c <= '9'))
}
// consume consumes n bytes of input and any subsequent whitespace.
func (d *Decoder) consume(n int) {
d.in = d.in[n:]
for len(d.in) > 0 {
switch d.in[0] {
case ' ', '\n', '\r', '\t':
d.in = d.in[1:]
default:
return
}
}
}
// isValueNext returns true if next type should be a JSON value: Null,
// Number, String or Bool.
func (d *Decoder) isValueNext() bool {
if len(d.openStack) == 0 {
return d.lastToken.kind == 0
}
start := d.openStack[len(d.openStack)-1]
switch start {
case ObjectOpen:
return d.lastToken.kind&Name != 0
case ArrayOpen:
return d.lastToken.kind&(ArrayOpen|comma) != 0
}
panic(fmt.Sprintf(
"unreachable logic in Decoder.isValueNext, lastToken.kind: %v, openStack: %v",
d.lastToken.kind, start))
}
// consumeToken constructs a Token for given Kind with raw value derived from
// current d.in and given size, and consumes the given size-length of it.
func (d *Decoder) consumeToken(kind Kind, size int) Token {
tok := Token{
kind: kind,
raw: d.in[:size],
pos: len(d.orig) - len(d.in),
}
d.consume(size)
return tok
}
// consumeBoolToken constructs a Token for a Bool kind with raw value derived from
// current d.in and given size.
func (d *Decoder) consumeBoolToken(b bool, size int) Token {
tok := Token{
kind: Bool,
raw: d.in[:size],
pos: len(d.orig) - len(d.in),
boo: b,
}
d.consume(size)
return tok
}
// consumeStringToken constructs a Token for a String kind with raw value derived
// from current d.in and given size.
func (d *Decoder) consumeStringToken(s string, size int) Token {
tok := Token{
kind: String,
raw: d.in[:size],
pos: len(d.orig) - len(d.in),
str: s,
}
d.consume(size)
return tok
}
// Clone returns a copy of the Decoder for use in reading ahead the next JSON
// object, array or other values without affecting current Decoder.
func (d *Decoder) Clone() *Decoder {
ret := *d
ret.openStack = append([]Kind(nil), ret.openStack...)
return &ret
}
// Copyright 2018 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 json
import (
"bytes"
"strconv"
)
// parseNumber reads the given []byte for a valid JSON number. If it is valid,
// it returns the number of bytes. Parsing logic follows the definition in
// https://tools.ietf.org/html/rfc7159#section-6, and is based off
// encoding/json.isValidNumber function.
func parseNumber(input []byte) (int, bool) {
var n int
s := input
if len(s) == 0 {
return 0, false
}
// Optional -
if s[0] == '-' {
s = s[1:]
n++
if len(s) == 0 {
return 0, false
}
}
// Digits
switch {
case s[0] == '0':
s = s[1:]
n++
case '1' <= s[0] && s[0] <= '9':
s = s[1:]
n++
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
default:
return 0, false
}
// . followed by 1 or more digits.
if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
s = s[2:]
n += 2
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
}
// e or E followed by an optional - or + and
// 1 or more digits.
if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
s = s[1:]
n++
if s[0] == '+' || s[0] == '-' {
s = s[1:]
n++
if len(s) == 0 {
return 0, false
}
}
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
}
// Check that next byte is a delimiter or it is at the end.
if n < len(input) && isNotDelim(input[n]) {
return 0, false
}
return n, true
}
// numberParts is the result of parsing out a valid JSON number. It contains
// the parts of a number. The parts are used for integer conversion.
type numberParts struct {
neg bool
intp []byte
frac []byte
exp []byte
}
// parseNumber constructs numberParts from given []byte. The logic here is
// similar to consumeNumber above with the difference of having to construct
// numberParts. The slice fields in numberParts are subslices of the input.
func parseNumberParts(input []byte) (numberParts, bool) {
var neg bool
var intp []byte
var frac []byte
var exp []byte
s := input
if len(s) == 0 {
return numberParts{}, false
}
// Optional -
if s[0] == '-' {
neg = true
s = s[1:]
if len(s) == 0 {
return numberParts{}, false
}
}
// Digits
switch {
case s[0] == '0':
// Skip first 0 and no need to store.
s = s[1:]
case '1' <= s[0] && s[0] <= '9':
intp = s
n := 1
s = s[1:]
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
intp = intp[:n]
default:
return numberParts{}, false
}
// . followed by 1 or more digits.
if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
frac = s[1:]
n := 1
s = s[2:]
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
frac = frac[:n]
}
// e or E followed by an optional - or + and
// 1 or more digits.
if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
s = s[1:]
exp = s
n := 0
if s[0] == '+' || s[0] == '-' {
s = s[1:]
n++
if len(s) == 0 {
return numberParts{}, false
}
}
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
exp = exp[:n]
}
return numberParts{
neg: neg,
intp: intp,
frac: bytes.TrimRight(frac, "0"), // Remove unnecessary 0s to the right.
exp: exp,
}, true
}
// normalizeToIntString returns an integer string in normal form without the
// E-notation for given numberParts. It will return false if it is not an
// integer or if the exponent exceeds than max/min int value.
func normalizeToIntString(n numberParts) (string, bool) {
intpSize := len(n.intp)
fracSize := len(n.frac)
if intpSize == 0 && fracSize == 0 {
return "0", true
}
var exp int
if len(n.exp) > 0 {
i, err := strconv.ParseInt(string(n.exp), 10, 32)
if err != nil {
return "", false
}
exp = int(i)
}
var num []byte
if exp >= 0 {
// For positive E, shift fraction digits into integer part and also pad
// with zeroes as needed.
// If there are more digits in fraction than the E value, then the
// number is not an integer.
if fracSize > exp {
return "", false
}
// Make sure resulting digits are within max value limit to avoid
// unnecessarily constructing a large byte slice that may simply fail
// later on.
const maxDigits = 20 // Max uint64 value has 20 decimal digits.
if intpSize+exp > maxDigits {
return "", false
}
// Set cap to make a copy of integer part when appended.
num = n.intp[:len(n.intp):len(n.intp)]
num = append(num, n.frac...)
for i := 0; i < exp-fracSize; i++ {
num = append(num, '0')
}
} else {
// For negative E, shift digits in integer part out.
// If there are fractions, then the number is not an integer.
if fracSize > 0 {
return "", false
}
// index is where the decimal point will be after adjusting for negative
// exponent.
index := intpSize + exp
if index < 0 {
return "", false
}
num = n.intp
// If any of the digits being shifted to the right of the decimal point
// is non-zero, then the number is not an integer.
for i := index; i < intpSize; i++ {
if num[i] != '0' {
return "", false
}
}
num = num[:index]
}
if n.neg {
return "-" + string(num), true
}
return string(num), true
}
// Copyright 2018 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 json
import (
"strconv"
"unicode"
"unicode/utf16"
"unicode/utf8"
"google.golang.org/protobuf/internal/strs"
)
func (d *Decoder) parseString(in []byte) (string, int, error) {
in0 := in
if len(in) == 0 {
return "", 0, ErrUnexpectedEOF
}
if in[0] != '"' {
return "", 0, d.newSyntaxError(d.currPos(), "invalid character %q at start of string", in[0])
}
in = in[1:]
i := indexNeedEscapeInBytes(in)
in, out := in[i:], in[:i:i] // set cap to prevent mutations
for len(in) > 0 {
switch r, n := utf8.DecodeRune(in); {
case r == utf8.RuneError && n == 1:
return "", 0, d.newSyntaxError(d.currPos(), "invalid UTF-8 in string")
case r < ' ':
return "", 0, d.newSyntaxError(d.currPos(), "invalid character %q in string", r)
case r == '"':
in = in[1:]
n := len(in0) - len(in)
return string(out), n, nil
case r == '\\':
if len(in) < 2 {
return "", 0, ErrUnexpectedEOF
}
switch r := in[1]; r {
case '"', '\\', '/':
in, out = in[2:], append(out, r)
case 'b':
in, out = in[2:], append(out, '\b')
case 'f':
in, out = in[2:], append(out, '\f')
case 'n':
in, out = in[2:], append(out, '\n')
case 'r':
in, out = in[2:], append(out, '\r')
case 't':
in, out = in[2:], append(out, '\t')
case 'u':
if len(in) < 6 {
return "", 0, ErrUnexpectedEOF
}
v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
if err != nil {
return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:6])
}
in = in[6:]
r := rune(v)
if utf16.IsSurrogate(r) {
if len(in) < 6 {
return "", 0, ErrUnexpectedEOF
}
v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
r = utf16.DecodeRune(r, rune(v))
if in[0] != '\\' || in[1] != 'u' ||
r == unicode.ReplacementChar || err != nil {
return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:6])
}
in = in[6:]
}
out = append(out, string(r)...)
default:
return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:2])
}
default:
i := indexNeedEscapeInBytes(in[n:])
in, out = in[n+i:], append(out, in[:n+i]...)
}
}
return "", 0, ErrUnexpectedEOF
}
// indexNeedEscapeInBytes returns the index of the character that needs
// escaping. If no characters need escaping, this returns the input length.
func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
// 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 json
import (
"bytes"
"fmt"
"strconv"
)
// Kind represents a token kind expressible in the JSON format.
type Kind uint16
const (
Invalid Kind = (1 << iota) / 2
EOF
Null
Bool
Number
String
Name
ObjectOpen
ObjectClose
ArrayOpen
ArrayClose
// comma is only for parsing in between tokens and
// does not need to be exported.
comma
)
func (k Kind) String() string {
switch k {
case EOF:
return "eof"
case Null:
return "null"
case Bool:
return "bool"
case Number:
return "number"
case String:
return "string"
case ObjectOpen:
return "{"
case ObjectClose:
return "}"
case Name:
return "name"
case ArrayOpen:
return "["
case ArrayClose:
return "]"
case comma:
return ","
}
return "<invalid>"
}
// Token provides a parsed token kind and value.
//
// Values are provided by the difference accessor methods. The accessor methods
// Name, Bool, and ParsedString will panic if called on the wrong kind. There
// are different accessor methods for the Number kind for converting to the
// appropriate Go numeric type and those methods have the ok return value.
type Token struct {
// Token kind.
kind Kind
// pos provides the position of the token in the original input.
pos int
// raw bytes of the serialized token.
// This is a subslice into the original input.
raw []byte
// boo is parsed boolean value.
boo bool
// str is parsed string value.
str string
}
// Kind returns the token kind.
func (t Token) Kind() Kind {
return t.kind
}
// RawString returns the read value in string.
func (t Token) RawString() string {
return string(t.raw)
}
// Pos returns the token position from the input.
func (t Token) Pos() int {
return t.pos
}
// Name returns the object name if token is Name, else it panics.
func (t Token) Name() string {
if t.kind == Name {
return t.str
}
panic(fmt.Sprintf("Token is not a Name: %v", t.RawString()))
}
// Bool returns the bool value if token kind is Bool, else it panics.
func (t Token) Bool() bool {
if t.kind == Bool {
return t.boo
}
panic(fmt.Sprintf("Token is not a Bool: %v", t.RawString()))
}
// ParsedString returns the string value for a JSON string token or the read
// value in string if token is not a string.
func (t Token) ParsedString() string {
if t.kind == String {
return t.str
}
panic(fmt.Sprintf("Token is not a String: %v", t.RawString()))
}
// Float returns the floating-point number if token kind is Number.
//
// The floating-point precision is specified by the bitSize parameter: 32 for
// float32 or 64 for float64. If bitSize=32, the result still has type float64,
// but it will be convertible to float32 without changing its value. It will
// return false if the number exceeds the floating point limits for given
// bitSize.
func (t Token) Float(bitSize int) (float64, bool) {
if t.kind != Number {
return 0, false
}
f, err := strconv.ParseFloat(t.RawString(), bitSize)
if err != nil {
return 0, false
}
return f, true
}
// Int returns the signed integer number if token is Number.
//
// The given bitSize specifies the integer type that the result must fit into.
// It returns false if the number is not an integer value or if the result
// exceeds the limits for given bitSize.
func (t Token) Int(bitSize int) (int64, bool) {
s, ok := t.getIntStr()
if !ok {
return 0, false
}
n, err := strconv.ParseInt(s, 10, bitSize)
if err != nil {
return 0, false
}
return n, true
}
// Uint returns the signed integer number if token is Number.
//
// The given bitSize specifies the unsigned integer type that the result must
// fit into. It returns false if the number is not an unsigned integer value
// or if the result exceeds the limits for given bitSize.
func (t Token) Uint(bitSize int) (uint64, bool) {
s, ok := t.getIntStr()
if !ok {
return 0, false
}
n, err := strconv.ParseUint(s, 10, bitSize)
if err != nil {
return 0, false
}
return n, true
}
func (t Token) getIntStr() (string, bool) {
if t.kind != Number {
return "", false
}
parts, ok := parseNumberParts(t.raw)
if !ok {
return "", false
}
return normalizeToIntString(parts)
}
// TokenEquals returns true if given Tokens are equal, else false.
func TokenEquals(x, y Token) bool {
return x.kind == y.kind &&
x.pos == y.pos &&
bytes.Equal(x.raw, y.raw) &&
x.boo == y.boo &&
x.str == y.str
}
// Copyright 2018 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 json
import (
"math"
"math/bits"
"strconv"
"strings"
"unicode/utf8"
"google.golang.org/protobuf/internal/detrand"
"google.golang.org/protobuf/internal/errors"
)
// kind represents an encoding type.
type kind uint8
const (
_ kind = (1 << iota) / 2
name
scalar
objectOpen
objectClose
arrayOpen
arrayClose
)
// Encoder provides methods to write out JSON constructs and values. The user is
// responsible for producing valid sequences of JSON constructs and values.
type Encoder struct {
indent string
lastKind kind
indents []byte
out []byte
}
// NewEncoder returns an Encoder.
//
// If indent is a non-empty string, it causes every entry for an Array or Object
// to be preceded by the indent and trailed by a newline.
func NewEncoder(buf []byte, indent string) (*Encoder, error) {
e := &Encoder{
out: buf,
}
if len(indent) > 0 {
if strings.Trim(indent, " \t") != "" {
return nil, errors.New("indent may only be composed of space or tab characters")
}
e.indent = indent
}
return e, nil
}
// Bytes returns the content of the written bytes.
func (e *Encoder) Bytes() []byte {
return e.out
}
// WriteNull writes out the null value.
func (e *Encoder) WriteNull() {
e.prepareNext(scalar)
e.out = append(e.out, "null"...)
}
// WriteBool writes out the given boolean value.
func (e *Encoder) WriteBool(b bool) {
e.prepareNext(scalar)
if b {
e.out = append(e.out, "true"...)
} else {
e.out = append(e.out, "false"...)
}
}
// WriteString writes out the given string in JSON string value. Returns error
// if input string contains invalid UTF-8.
func (e *Encoder) WriteString(s string) error {
e.prepareNext(scalar)
var err error
if e.out, err = appendString(e.out, s); err != nil {
return err
}
return nil
}
// Sentinel error used for indicating invalid UTF-8.
var errInvalidUTF8 = errors.New("invalid UTF-8")
func appendString(out []byte, in string) ([]byte, error) {
out = append(out, '"')
i := indexNeedEscapeInString(in)
in, out = in[i:], append(out, in[:i]...)
for len(in) > 0 {
switch r, n := utf8.DecodeRuneInString(in); {
case r == utf8.RuneError && n == 1:
return out, errInvalidUTF8
case r < ' ' || r == '"' || r == '\\':
out = append(out, '\\')
switch r {
case '"', '\\':
out = append(out, byte(r))
case '\b':
out = append(out, 'b')
case '\f':
out = append(out, 'f')
case '\n':
out = append(out, 'n')
case '\r':
out = append(out, 'r')
case '\t':
out = append(out, 't')
default:
out = append(out, 'u')
out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
out = strconv.AppendUint(out, uint64(r), 16)
}
in = in[n:]
default:
i := indexNeedEscapeInString(in[n:])
in, out = in[n+i:], append(out, in[:n+i]...)
}
}
out = append(out, '"')
return out, nil
}
// indexNeedEscapeInString returns the index of the character that needs
// escaping. If no characters need escaping, this returns the input length.
func indexNeedEscapeInString(s string) int {
for i, r := range s {
if r < ' ' || r == '\\' || r == '"' || r == utf8.RuneError {
return i
}
}
return len(s)
}
// WriteFloat writes out the given float and bitSize in JSON number value.
func (e *Encoder) WriteFloat(n float64, bitSize int) {
e.prepareNext(scalar)
e.out = appendFloat(e.out, n, bitSize)
}
// appendFloat formats given float in bitSize, and appends to the given []byte.
func appendFloat(out []byte, n float64, bitSize int) []byte {
switch {
case math.IsNaN(n):
return append(out, `"NaN"`...)
case math.IsInf(n, +1):
return append(out, `"Infinity"`...)
case math.IsInf(n, -1):
return append(out, `"-Infinity"`...)
}
// JSON number formatting logic based on encoding/json.
// See floatEncoder.encode for reference.
fmt := byte('f')
if abs := math.Abs(n); abs != 0 {
if bitSize == 64 && (abs < 1e-6 || abs >= 1e21) ||
bitSize == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) {
fmt = 'e'
}
}
out = strconv.AppendFloat(out, n, fmt, -1, bitSize)
if fmt == 'e' {
n := len(out)
if n >= 4 && out[n-4] == 'e' && out[n-3] == '-' && out[n-2] == '0' {
out[n-2] = out[n-1]
out = out[:n-1]
}
}
return out
}
// WriteInt writes out the given signed integer in JSON number value.
func (e *Encoder) WriteInt(n int64) {
e.prepareNext(scalar)
e.out = strconv.AppendInt(e.out, n, 10)
}
// WriteUint writes out the given unsigned integer in JSON number value.
func (e *Encoder) WriteUint(n uint64) {
e.prepareNext(scalar)
e.out = strconv.AppendUint(e.out, n, 10)
}
// StartObject writes out the '{' symbol.
func (e *Encoder) StartObject() {
e.prepareNext(objectOpen)
e.out = append(e.out, '{')
}
// EndObject writes out the '}' symbol.
func (e *Encoder) EndObject() {
e.prepareNext(objectClose)
e.out = append(e.out, '}')
}
// WriteName writes out the given string in JSON string value and the name
// separator ':'. Returns error if input string contains invalid UTF-8, which
// should not be likely as protobuf field names should be valid.
func (e *Encoder) WriteName(s string) error {
e.prepareNext(name)
var err error
// Append to output regardless of error.
e.out, err = appendString(e.out, s)
e.out = append(e.out, ':')
return err
}
// StartArray writes out the '[' symbol.
func (e *Encoder) StartArray() {
e.prepareNext(arrayOpen)
e.out = append(e.out, '[')
}
// EndArray writes out the ']' symbol.
func (e *Encoder) EndArray() {
e.prepareNext(arrayClose)
e.out = append(e.out, ']')
}
// prepareNext adds possible comma and indentation for the next value based
// on last type and indent option. It also updates lastKind to next.
func (e *Encoder) prepareNext(next kind) {
defer func() {
// Set lastKind to next.
e.lastKind = next
}()
if len(e.indent) == 0 {
// Need to add comma on the following condition.
if e.lastKind&(scalar|objectClose|arrayClose) != 0 &&
next&(name|scalar|objectOpen|arrayOpen) != 0 {
e.out = append(e.out, ',')
// For single-line output, add a random extra space after each
// comma to make output unstable.
if detrand.Bool() {
e.out = append(e.out, ' ')
}
}
return
}
switch {
case e.lastKind&(objectOpen|arrayOpen) != 0:
// If next type is NOT closing, add indent and newline.
if next&(objectClose|arrayClose) == 0 {
e.indents = append(e.indents, e.indent...)
e.out = append(e.out, '\n')
e.out = append(e.out, e.indents...)
}
case e.lastKind&(scalar|objectClose|arrayClose) != 0:
switch {
// If next type is either a value or name, add comma and newline.
case next&(name|scalar|objectOpen|arrayOpen) != 0:
e.out = append(e.out, ',', '\n')
// If next type is a closing object or array, adjust indentation.
case next&(objectClose|arrayClose) != 0:
e.indents = e.indents[:len(e.indents)-len(e.indent)]
e.out = append(e.out, '\n')
}
e.out = append(e.out, e.indents...)
case e.lastKind&name != 0:
e.out = append(e.out, ' ')
// For multi-line output, add a random extra space after key: to make
// output unstable.
if detrand.Bool() {
e.out = append(e.out, ' ')
}
}
}
// 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 messageset encodes and decodes the obsolete MessageSet wire format.
package messageset
import (
"math"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
)
// The MessageSet wire format is equivalent to a message defined as follows,
// where each Item defines an extension field with a field number of 'type_id'
// and content of 'message'. MessageSet extensions must be non-repeated message
// fields.
//
// message MessageSet {
// repeated group Item = 1 {
// required int32 type_id = 2;
// required string message = 3;
// }
// }
const (
FieldItem = protowire.Number(1)
FieldTypeID = protowire.Number(2)
FieldMessage = protowire.Number(3)
)
// ExtensionName is the field name for extensions of MessageSet.
//
// A valid MessageSet extension must be of the form:
//
// message MyMessage {
// extend proto2.bridge.MessageSet {
// optional MyMessage message_set_extension = 1234;
// }
// ...
// }
const ExtensionName = "message_set_extension"
// IsMessageSet returns whether the message uses the MessageSet wire format.
func IsMessageSet(md protoreflect.MessageDescriptor) bool {
xmd, ok := md.(interface{ IsMessageSet() bool })
return ok && xmd.IsMessageSet()
}
// IsMessageSetExtension reports this field properly extends a MessageSet.
func IsMessageSetExtension(fd protoreflect.FieldDescriptor) bool {
switch {
case fd.Name() != ExtensionName:
return false
case !IsMessageSet(fd.ContainingMessage()):
return false
case fd.FullName().Parent() != fd.Message().FullName():
return false
}
return true
}
// SizeField returns the size of a MessageSet item field containing an extension
// with the given field number, not counting the contents of the message subfield.
func SizeField(num protowire.Number) int {
return 2*protowire.SizeTag(FieldItem) + protowire.SizeTag(FieldTypeID) + protowire.SizeVarint(uint64(num))
}
// Unmarshal parses a MessageSet.
//
// It calls fn with the type ID and value of each item in the MessageSet.
// Unknown fields are discarded.
//
// If wantLen is true, the item values include the varint length prefix.
// This is ugly, but simplifies the fast-path decoder in internal/impl.
func Unmarshal(b []byte, wantLen bool, fn func(typeID protowire.Number, value []byte) error) error {
for len(b) > 0 {
num, wtyp, n := protowire.ConsumeTag(b)
if n < 0 {
return protowire.ParseError(n)
}
b = b[n:]
if num != FieldItem || wtyp != protowire.StartGroupType {
n := protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return protowire.ParseError(n)
}
b = b[n:]
continue
}
typeID, value, n, err := ConsumeFieldValue(b, wantLen)
if err != nil {
return err
}
b = b[n:]
if typeID == 0 {
continue
}
if err := fn(typeID, value); err != nil {
return err
}
}
return nil
}
// ConsumeFieldValue parses b as a MessageSet item field value until and including
// the trailing end group marker. It assumes the start group tag has already been parsed.
// It returns the contents of the type_id and message subfields and the total
// item length.
//
// If wantLen is true, the returned message value includes the length prefix.
func ConsumeFieldValue(b []byte, wantLen bool) (typeid protowire.Number, message []byte, n int, err error) {
ilen := len(b)
for {
num, wtyp, n := protowire.ConsumeTag(b)
if n < 0 {
return 0, nil, 0, protowire.ParseError(n)
}
b = b[n:]
switch {
case num == FieldItem && wtyp == protowire.EndGroupType:
if wantLen && len(message) == 0 {
// The message field was missing, which should never happen.
// Be prepared for this case anyway.
message = protowire.AppendVarint(message, 0)
}
return typeid, message, ilen - len(b), nil
case num == FieldTypeID && wtyp == protowire.VarintType:
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, nil, 0, protowire.ParseError(n)
}
b = b[n:]
if v < 1 || v > math.MaxInt32 {
return 0, nil, 0, errors.New("invalid type_id in message set")
}
typeid = protowire.Number(v)
case num == FieldMessage && wtyp == protowire.BytesType:
m, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, nil, 0, protowire.ParseError(n)
}
if message == nil {
if wantLen {
message = b[:n:n]
} else {
message = m[:len(m):len(m)]
}
} else {
// This case should never happen in practice, but handle it for
// correctness: The MessageSet item contains multiple message
// fields, which need to be merged.
//
// In the case where we're returning the length, this becomes
// quite inefficient since we need to strip the length off
// the existing data and reconstruct it with the combined length.
if wantLen {
_, nn := protowire.ConsumeVarint(message)
m0 := message[nn:]
message = nil
message = protowire.AppendVarint(message, uint64(len(m0)+len(m)))
message = append(message, m0...)
message = append(message, m...)
} else {
message = append(message, m...)
}
}
b = b[n:]
default:
// We have no place to put it, so we just ignore unknown fields.
n := protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return 0, nil, 0, protowire.ParseError(n)
}
b = b[n:]
}
}
}
// AppendFieldStart appends the start of a MessageSet item field containing
// an extension with the given number. The caller must add the message
// subfield (including the tag).
func AppendFieldStart(b []byte, num protowire.Number) []byte {
b = protowire.AppendTag(b, FieldItem, protowire.StartGroupType)
b = protowire.AppendTag(b, FieldTypeID, protowire.VarintType)
b = protowire.AppendVarint(b, uint64(num))
return b
}
// AppendFieldEnd appends the trailing end group marker for a MessageSet item field.
func AppendFieldEnd(b []byte) []byte {
return protowire.AppendTag(b, FieldItem, protowire.EndGroupType)
}
// SizeUnknown returns the size of an unknown fields section in MessageSet format.
//
// See AppendUnknown.
func SizeUnknown(unknown []byte) (size int) {
for len(unknown) > 0 {
num, typ, n := protowire.ConsumeTag(unknown)
if n < 0 || typ != protowire.BytesType {
return 0
}
unknown = unknown[n:]
_, n = protowire.ConsumeBytes(unknown)
if n < 0 {
return 0
}
unknown = unknown[n:]
size += SizeField(num) + protowire.SizeTag(FieldMessage) + n
}
return size
}
// AppendUnknown appends unknown fields to b in MessageSet format.
//
// For historic reasons, unresolved items in a MessageSet are stored in a
// message's unknown fields section in non-MessageSet format. That is, an
// unknown item with typeID T and value V appears in the unknown fields as
// a field with number T and value V.
//
// This function converts the unknown fields back into MessageSet form.
func AppendUnknown(b, unknown []byte) ([]byte, error) {
for len(unknown) > 0 {
num, typ, n := protowire.ConsumeTag(unknown)
if n < 0 || typ != protowire.BytesType {
return nil, errors.New("invalid data in message set unknown fields")
}
unknown = unknown[n:]
_, n = protowire.ConsumeBytes(unknown)
if n < 0 {
return nil, errors.New("invalid data in message set unknown fields")
}
b = AppendFieldStart(b, num)
b = protowire.AppendTag(b, FieldMessage, protowire.BytesType)
b = append(b, unknown[:n]...)
b = AppendFieldEnd(b)
unknown = unknown[n:]
}
return b, nil
}
// Copyright 2018 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 tag marshals and unmarshals the legacy struct tags as generated
// by historical versions of protoc-gen-go.
package tag
import (
"reflect"
"strconv"
"strings"
"google.golang.org/protobuf/internal/encoding/defval"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
var byteType = reflect.TypeOf(byte(0))
// Unmarshal decodes the tag into a prototype.Field.
//
// The goType is needed to determine the original protoreflect.Kind since the
// tag does not record sufficient information to determine that.
// The type is the underlying field type (e.g., a repeated field may be
// represented by []T, but the Go type passed in is just T).
// A list of enum value descriptors must be provided for enum fields.
// This does not populate the Enum or Message.
//
// This function is a best effort attempt; parsing errors are ignored.
func Unmarshal(tag string, goType reflect.Type, evs protoreflect.EnumValueDescriptors) protoreflect.FieldDescriptor {
f := new(filedesc.Field)
f.L0.ParentFile = filedesc.SurrogateProto2
f.L1.EditionFeatures = f.L0.ParentFile.L1.EditionFeatures
for len(tag) > 0 {
i := strings.IndexByte(tag, ',')
if i < 0 {
i = len(tag)
}
switch s := tag[:i]; {
case strings.HasPrefix(s, "name="):
f.L0.FullName = protoreflect.FullName(s[len("name="):])
case strings.Trim(s, "0123456789") == "":
n, _ := strconv.ParseUint(s, 10, 32)
f.L1.Number = protoreflect.FieldNumber(n)
case s == "opt":
f.L1.Cardinality = protoreflect.Optional
case s == "req":
f.L1.Cardinality = protoreflect.Required
case s == "rep":
f.L1.Cardinality = protoreflect.Repeated
case s == "varint":
switch goType.Kind() {
case reflect.Bool:
f.L1.Kind = protoreflect.BoolKind
case reflect.Int32:
f.L1.Kind = protoreflect.Int32Kind
case reflect.Int64:
f.L1.Kind = protoreflect.Int64Kind
case reflect.Uint32:
f.L1.Kind = protoreflect.Uint32Kind
case reflect.Uint64:
f.L1.Kind = protoreflect.Uint64Kind
}
case s == "zigzag32":
if goType.Kind() == reflect.Int32 {
f.L1.Kind = protoreflect.Sint32Kind
}
case s == "zigzag64":
if goType.Kind() == reflect.Int64 {
f.L1.Kind = protoreflect.Sint64Kind
}
case s == "fixed32":
switch goType.Kind() {
case reflect.Int32:
f.L1.Kind = protoreflect.Sfixed32Kind
case reflect.Uint32:
f.L1.Kind = protoreflect.Fixed32Kind
case reflect.Float32:
f.L1.Kind = protoreflect.FloatKind
}
case s == "fixed64":
switch goType.Kind() {
case reflect.Int64:
f.L1.Kind = protoreflect.Sfixed64Kind
case reflect.Uint64:
f.L1.Kind = protoreflect.Fixed64Kind
case reflect.Float64:
f.L1.Kind = protoreflect.DoubleKind
}
case s == "bytes":
switch {
case goType.Kind() == reflect.String:
f.L1.Kind = protoreflect.StringKind
case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
f.L1.Kind = protoreflect.BytesKind
default:
f.L1.Kind = protoreflect.MessageKind
}
case s == "group":
f.L1.Kind = protoreflect.GroupKind
case strings.HasPrefix(s, "enum="):
f.L1.Kind = protoreflect.EnumKind
case strings.HasPrefix(s, "json="):
jsonName := s[len("json="):]
if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) {
f.L1.StringName.InitJSON(jsonName)
}
case s == "packed":
f.L1.EditionFeatures.IsPacked = true
case strings.HasPrefix(s, "def="):
// The default tag is special in that everything afterwards is the
// default regardless of the presence of commas.
s, i = tag[len("def="):], len(tag)
v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag)
f.L1.Default = filedesc.DefaultValue(v, ev)
case s == "proto3":
f.L0.ParentFile = filedesc.SurrogateProto3
}
tag = strings.TrimPrefix(tag[i:], ",")
}
// The generator uses the group message name instead of the field name.
// We obtain the real field name by lowercasing the group name.
if f.L1.Kind == protoreflect.GroupKind {
f.L0.FullName = protoreflect.FullName(strings.ToLower(string(f.L0.FullName)))
}
return f
}
// Marshal encodes the protoreflect.FieldDescriptor as a tag.
//
// The enumName must be provided if the kind is an enum.
// Historically, the formulation of the enum "name" was the proto package
// dot-concatenated with the generated Go identifier for the enum type.
// Depending on the context on how Marshal is called, there are different ways
// through which that information is determined. As such it is the caller's
// responsibility to provide a function to obtain that information.
func Marshal(fd protoreflect.FieldDescriptor, enumName string) string {
var tag []string
switch fd.Kind() {
case protoreflect.BoolKind, protoreflect.EnumKind, protoreflect.Int32Kind, protoreflect.Uint32Kind, protoreflect.Int64Kind, protoreflect.Uint64Kind:
tag = append(tag, "varint")
case protoreflect.Sint32Kind:
tag = append(tag, "zigzag32")
case protoreflect.Sint64Kind:
tag = append(tag, "zigzag64")
case protoreflect.Sfixed32Kind, protoreflect.Fixed32Kind, protoreflect.FloatKind:
tag = append(tag, "fixed32")
case protoreflect.Sfixed64Kind, protoreflect.Fixed64Kind, protoreflect.DoubleKind:
tag = append(tag, "fixed64")
case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind:
tag = append(tag, "bytes")
case protoreflect.GroupKind:
tag = append(tag, "group")
}
tag = append(tag, strconv.Itoa(int(fd.Number())))
switch fd.Cardinality() {
case protoreflect.Optional:
tag = append(tag, "opt")
case protoreflect.Required:
tag = append(tag, "req")
case protoreflect.Repeated:
tag = append(tag, "rep")
}
if fd.IsPacked() {
tag = append(tag, "packed")
}
name := string(fd.Name())
if fd.Kind() == protoreflect.GroupKind {
// The name of the FieldDescriptor for a group field is
// lowercased. To find the original capitalization, we
// look in the field's MessageType.
name = string(fd.Message().Name())
}
tag = append(tag, "name="+name)
if jsonName := fd.JSONName(); jsonName != "" && jsonName != name && !fd.IsExtension() {
// NOTE: The jsonName != name condition is suspect, but it preserve
// the exact same semantics from the previous generator.
tag = append(tag, "json="+jsonName)
}
// The previous implementation does not tag extension fields as proto3,
// even when the field is defined in a proto3 file. Match that behavior
// for consistency.
if fd.Syntax() == protoreflect.Proto3 && !fd.IsExtension() {
tag = append(tag, "proto3")
}
if fd.Kind() == protoreflect.EnumKind && enumName != "" {
tag = append(tag, "enum="+enumName)
}
if fd.ContainingOneof() != nil {
tag = append(tag, "oneof")
}
// This must appear last in the tag, since commas in strings aren't escaped.
if fd.HasDefault() {
def, _ := defval.Marshal(fd.Default(), fd.DefaultEnumValue(), fd.Kind(), defval.GoTag)
tag = append(tag, "def="+def)
}
return strings.Join(tag, ",")
}
// Copyright 2018 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 text
import (
"bytes"
"fmt"
"io"
"strconv"
"unicode/utf8"
"google.golang.org/protobuf/internal/errors"
)
// Decoder is a token-based textproto decoder.
type Decoder struct {
// lastCall is last method called, either readCall or peekCall.
// Initial value is readCall.
lastCall call
// lastToken contains the last read token.
lastToken Token
// lastErr contains the last read error.
lastErr error
// openStack is a stack containing the byte characters for MessageOpen and
// ListOpen kinds. The top of stack represents the message or the list that
// the current token is nested in. An empty stack means the current token is
// at the top level message. The characters '{' and '<' both represent the
// MessageOpen kind.
openStack []byte
// orig is used in reporting line and column.
orig []byte
// in contains the unconsumed input.
in []byte
}
// NewDecoder returns a Decoder to read the given []byte.
func NewDecoder(b []byte) *Decoder {
return &Decoder{orig: b, in: b}
}
// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
// call specifies which Decoder method was invoked.
type call uint8
const (
readCall call = iota
peekCall
)
// Peek looks ahead and returns the next token and error without advancing a read.
func (d *Decoder) Peek() (Token, error) {
defer func() { d.lastCall = peekCall }()
if d.lastCall == readCall {
d.lastToken, d.lastErr = d.Read()
}
return d.lastToken, d.lastErr
}
// Read returns the next token.
// It will return an error if there is no valid token.
func (d *Decoder) Read() (Token, error) {
defer func() { d.lastCall = readCall }()
if d.lastCall == peekCall {
return d.lastToken, d.lastErr
}
tok, err := d.parseNext(d.lastToken.kind)
if err != nil {
return Token{}, err
}
switch tok.kind {
case comma, semicolon:
tok, err = d.parseNext(tok.kind)
if err != nil {
return Token{}, err
}
}
d.lastToken = tok
return tok, nil
}
const (
mismatchedFmt = "mismatched close character %q"
unexpectedFmt = "unexpected character %q"
)
// parseNext parses the next Token based on given last kind.
func (d *Decoder) parseNext(lastKind Kind) (Token, error) {
// Trim leading spaces.
d.consume(0)
isEOF := false
if len(d.in) == 0 {
isEOF = true
}
switch lastKind {
case EOF:
return d.consumeToken(EOF, 0, 0), nil
case bof:
// Start of top level message. Next token can be EOF or Name.
if isEOF {
return d.consumeToken(EOF, 0, 0), nil
}
return d.parseFieldName()
case Name:
// Next token can be MessageOpen, ListOpen or Scalar.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case '{', '<':
d.pushOpenStack(ch)
return d.consumeToken(MessageOpen, 1, 0), nil
case '[':
d.pushOpenStack(ch)
return d.consumeToken(ListOpen, 1, 0), nil
default:
return d.parseScalar()
}
case Scalar:
openKind, closeCh := d.currentOpenKind()
switch openKind {
case bof:
// Top level message.
// Next token can be EOF, comma, semicolon or Name.
if isEOF {
return d.consumeToken(EOF, 0, 0), nil
}
switch d.in[0] {
case ',':
return d.consumeToken(comma, 1, 0), nil
case ';':
return d.consumeToken(semicolon, 1, 0), nil
default:
return d.parseFieldName()
}
case MessageOpen:
// Next token can be MessageClose, comma, semicolon or Name.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case closeCh:
d.popOpenStack()
return d.consumeToken(MessageClose, 1, 0), nil
case otherCloseChar[closeCh]:
return Token{}, d.newSyntaxError(mismatchedFmt, ch)
case ',':
return d.consumeToken(comma, 1, 0), nil
case ';':
return d.consumeToken(semicolon, 1, 0), nil
default:
return d.parseFieldName()
}
case ListOpen:
// Next token can be ListClose or comma.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case ']':
d.popOpenStack()
return d.consumeToken(ListClose, 1, 0), nil
case ',':
return d.consumeToken(comma, 1, 0), nil
default:
return Token{}, d.newSyntaxError(unexpectedFmt, ch)
}
}
case MessageOpen:
// Next token can be MessageClose or Name.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
_, closeCh := d.currentOpenKind()
switch ch := d.in[0]; ch {
case closeCh:
d.popOpenStack()
return d.consumeToken(MessageClose, 1, 0), nil
case otherCloseChar[closeCh]:
return Token{}, d.newSyntaxError(mismatchedFmt, ch)
default:
return d.parseFieldName()
}
case MessageClose:
openKind, closeCh := d.currentOpenKind()
switch openKind {
case bof:
// Top level message.
// Next token can be EOF, comma, semicolon or Name.
if isEOF {
return d.consumeToken(EOF, 0, 0), nil
}
switch ch := d.in[0]; ch {
case ',':
return d.consumeToken(comma, 1, 0), nil
case ';':
return d.consumeToken(semicolon, 1, 0), nil
default:
return d.parseFieldName()
}
case MessageOpen:
// Next token can be MessageClose, comma, semicolon or Name.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case closeCh:
d.popOpenStack()
return d.consumeToken(MessageClose, 1, 0), nil
case otherCloseChar[closeCh]:
return Token{}, d.newSyntaxError(mismatchedFmt, ch)
case ',':
return d.consumeToken(comma, 1, 0), nil
case ';':
return d.consumeToken(semicolon, 1, 0), nil
default:
return d.parseFieldName()
}
case ListOpen:
// Next token can be ListClose or comma
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case closeCh:
d.popOpenStack()
return d.consumeToken(ListClose, 1, 0), nil
case ',':
return d.consumeToken(comma, 1, 0), nil
default:
return Token{}, d.newSyntaxError(unexpectedFmt, ch)
}
}
case ListOpen:
// Next token can be ListClose, MessageStart or Scalar.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case ']':
d.popOpenStack()
return d.consumeToken(ListClose, 1, 0), nil
case '{', '<':
d.pushOpenStack(ch)
return d.consumeToken(MessageOpen, 1, 0), nil
default:
return d.parseScalar()
}
case ListClose:
openKind, closeCh := d.currentOpenKind()
switch openKind {
case bof:
// Top level message.
// Next token can be EOF, comma, semicolon or Name.
if isEOF {
return d.consumeToken(EOF, 0, 0), nil
}
switch ch := d.in[0]; ch {
case ',':
return d.consumeToken(comma, 1, 0), nil
case ';':
return d.consumeToken(semicolon, 1, 0), nil
default:
return d.parseFieldName()
}
case MessageOpen:
// Next token can be MessageClose, comma, semicolon or Name.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case closeCh:
d.popOpenStack()
return d.consumeToken(MessageClose, 1, 0), nil
case otherCloseChar[closeCh]:
return Token{}, d.newSyntaxError(mismatchedFmt, ch)
case ',':
return d.consumeToken(comma, 1, 0), nil
case ';':
return d.consumeToken(semicolon, 1, 0), nil
default:
return d.parseFieldName()
}
default:
// It is not possible to have this case. Let it panic below.
}
case comma, semicolon:
openKind, closeCh := d.currentOpenKind()
switch openKind {
case bof:
// Top level message. Next token can be EOF or Name.
if isEOF {
return d.consumeToken(EOF, 0, 0), nil
}
return d.parseFieldName()
case MessageOpen:
// Next token can be MessageClose or Name.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case closeCh:
d.popOpenStack()
return d.consumeToken(MessageClose, 1, 0), nil
case otherCloseChar[closeCh]:
return Token{}, d.newSyntaxError(mismatchedFmt, ch)
default:
return d.parseFieldName()
}
case ListOpen:
if lastKind == semicolon {
// It is not be possible to have this case as logic here
// should not have produced a semicolon Token when inside a
// list. Let it panic below.
break
}
// Next token can be MessageOpen or Scalar.
if isEOF {
return Token{}, ErrUnexpectedEOF
}
switch ch := d.in[0]; ch {
case '{', '<':
d.pushOpenStack(ch)
return d.consumeToken(MessageOpen, 1, 0), nil
default:
return d.parseScalar()
}
}
}
line, column := d.Position(len(d.orig) - len(d.in))
panic(fmt.Sprintf("Decoder.parseNext: bug at handling line %d:%d with lastKind=%v", line, column, lastKind))
}
var otherCloseChar = map[byte]byte{
'}': '>',
'>': '}',
}
// currentOpenKind indicates whether current position is inside a message, list
// or top-level message by returning MessageOpen, ListOpen or bof respectively.
// If the returned kind is either a MessageOpen or ListOpen, it also returns the
// corresponding closing character.
func (d *Decoder) currentOpenKind() (Kind, byte) {
if len(d.openStack) == 0 {
return bof, 0
}
openCh := d.openStack[len(d.openStack)-1]
switch openCh {
case '{':
return MessageOpen, '}'
case '<':
return MessageOpen, '>'
case '[':
return ListOpen, ']'
}
panic(fmt.Sprintf("Decoder: openStack contains invalid byte %c", openCh))
}
func (d *Decoder) pushOpenStack(ch byte) {
d.openStack = append(d.openStack, ch)
}
func (d *Decoder) popOpenStack() {
d.openStack = d.openStack[:len(d.openStack)-1]
}
// parseFieldName parses field name and separator.
func (d *Decoder) parseFieldName() (tok Token, err error) {
defer func() {
if err == nil && d.tryConsumeChar(':') {
tok.attrs |= hasSeparator
}
}()
// Extension or Any type URL.
if d.in[0] == '[' {
return d.parseTypeName()
}
// Identifier.
if size := parseIdent(d.in, false); size > 0 {
return d.consumeToken(Name, size, uint8(IdentName)), nil
}
// Field number. Identify if input is a valid number that is not negative
// and is decimal integer within 32-bit range.
if num := parseNumber(d.in); num.size > 0 {
str := num.string(d.in)
if !num.neg && num.kind == numDec {
if _, err := strconv.ParseInt(str, 10, 32); err == nil {
return d.consumeToken(Name, num.size, uint8(FieldNumber)), nil
}
}
return Token{}, d.newSyntaxError("invalid field number: %s", str)
}
return Token{}, d.newSyntaxError("invalid field name: %s", errId(d.in))
}
// parseTypeName parses Any type URL or extension field name. The name is
// enclosed in [ and ] characters. The C++ parser does not handle many legal URL
// strings. This implementation is more liberal and allows for the pattern
// ^[-_a-zA-Z0-9]+([./][-_a-zA-Z0-9]+)*`). Whitespaces and comments are allowed
// in between [ ], '.', '/' and the sub names.
func (d *Decoder) parseTypeName() (Token, error) {
startPos := len(d.orig) - len(d.in)
// Use alias s to advance first in order to use d.in for error handling.
// Caller already checks for [ as first character.
s := consume(d.in[1:], 0)
if len(s) == 0 {
return Token{}, ErrUnexpectedEOF
}
var name []byte
for len(s) > 0 && isTypeNameChar(s[0]) {
name = append(name, s[0])
s = s[1:]
}
s = consume(s, 0)
var closed bool
for len(s) > 0 && !closed {
switch {
case s[0] == ']':
s = s[1:]
closed = true
case s[0] == '/', s[0] == '.':
if len(name) > 0 && (name[len(name)-1] == '/' || name[len(name)-1] == '.') {
return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
d.orig[startPos:len(d.orig)-len(s)+1])
}
name = append(name, s[0])
s = s[1:]
s = consume(s, 0)
for len(s) > 0 && isTypeNameChar(s[0]) {
name = append(name, s[0])
s = s[1:]
}
s = consume(s, 0)
default:
return Token{}, d.newSyntaxError(
"invalid type URL/extension field name: %s", d.orig[startPos:len(d.orig)-len(s)+1])
}
}
if !closed {
return Token{}, ErrUnexpectedEOF
}
// First character cannot be '.'. Last character cannot be '.' or '/'.
size := len(name)
if size == 0 || name[0] == '.' || name[size-1] == '.' || name[size-1] == '/' {
return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
d.orig[startPos:len(d.orig)-len(s)])
}
d.in = s
endPos := len(d.orig) - len(d.in)
d.consume(0)
return Token{
kind: Name,
attrs: uint8(TypeName),
pos: startPos,
raw: d.orig[startPos:endPos],
str: string(name),
}, nil
}
func isTypeNameChar(b byte) bool {
return (b == '-' || b == '_' ||
('0' <= b && b <= '9') ||
('a' <= b && b <= 'z') ||
('A' <= b && b <= 'Z'))
}
func isWhiteSpace(b byte) bool {
switch b {
case ' ', '\n', '\r', '\t':
return true
default:
return false
}
}
// parseIdent parses an unquoted proto identifier and returns size.
// If allowNeg is true, it allows '-' to be the first character in the
// identifier. This is used when parsing literal values like -infinity, etc.
// Regular expression matches an identifier: `^[_a-zA-Z][_a-zA-Z0-9]*`
func parseIdent(input []byte, allowNeg bool) int {
var size int
s := input
if len(s) == 0 {
return 0
}
if allowNeg && s[0] == '-' {
s = s[1:]
size++
if len(s) == 0 {
return 0
}
}
switch {
case s[0] == '_',
'a' <= s[0] && s[0] <= 'z',
'A' <= s[0] && s[0] <= 'Z':
s = s[1:]
size++
default:
return 0
}
for len(s) > 0 && (s[0] == '_' ||
'a' <= s[0] && s[0] <= 'z' ||
'A' <= s[0] && s[0] <= 'Z' ||
'0' <= s[0] && s[0] <= '9') {
s = s[1:]
size++
}
if len(s) > 0 && !isDelim(s[0]) {
return 0
}
return size
}
// parseScalar parses for a string, literal or number value.
func (d *Decoder) parseScalar() (Token, error) {
if d.in[0] == '"' || d.in[0] == '\'' {
return d.parseStringValue()
}
if tok, ok := d.parseLiteralValue(); ok {
return tok, nil
}
if tok, ok := d.parseNumberValue(); ok {
return tok, nil
}
return Token{}, d.newSyntaxError("invalid scalar value: %s", errId(d.in))
}
// parseLiteralValue parses a literal value. A literal value is used for
// bools, special floats and enums. This function simply identifies that the
// field value is a literal.
func (d *Decoder) parseLiteralValue() (Token, bool) {
size := parseIdent(d.in, true)
if size == 0 {
return Token{}, false
}
return d.consumeToken(Scalar, size, literalValue), true
}
// consumeToken constructs a Token for given Kind from d.in and consumes given
// size-length from it.
func (d *Decoder) consumeToken(kind Kind, size int, attrs uint8) Token {
// Important to compute raw and pos before consuming.
tok := Token{
kind: kind,
attrs: attrs,
pos: len(d.orig) - len(d.in),
raw: d.in[:size],
}
d.consume(size)
return tok
}
// newSyntaxError returns a syntax error with line and column information for
// current position.
func (d *Decoder) newSyntaxError(f string, x ...any) error {
e := errors.New(f, x...)
line, column := d.Position(len(d.orig) - len(d.in))
return errors.New("syntax error (line %d:%d): %v", line, column, e)
}
// Position returns line and column number of given index of the original input.
// It will panic if index is out of range.
func (d *Decoder) Position(idx int) (line int, column int) {
b := d.orig[:idx]
line = bytes.Count(b, []byte("\n")) + 1
if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
b = b[i+1:]
}
column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
return line, column
}
func (d *Decoder) tryConsumeChar(c byte) bool {
if len(d.in) > 0 && d.in[0] == c {
d.consume(1)
return true
}
return false
}
// consume consumes n bytes of input and any subsequent whitespace or comments.
func (d *Decoder) consume(n int) {
d.in = consume(d.in, n)
return
}
// consume consumes n bytes of input and any subsequent whitespace or comments.
func consume(b []byte, n int) []byte {
b = b[n:]
for len(b) > 0 {
switch b[0] {
case ' ', '\n', '\r', '\t':
b = b[1:]
case '#':
if i := bytes.IndexByte(b, '\n'); i >= 0 {
b = b[i+len("\n"):]
} else {
b = nil
}
default:
return b
}
}
return b
}
// errId extracts a byte sequence that looks like an invalid ID
// (for the purposes of error reporting).
func errId(seq []byte) []byte {
const maxLen = 32
for i := 0; i < len(seq); {
if i > maxLen {
return append(seq[:i:i], "…"...)
}
r, size := utf8.DecodeRune(seq[i:])
if r > utf8.RuneSelf || (r != '/' && isDelim(byte(r))) {
if i == 0 {
// Either the first byte is invalid UTF-8 or a
// delimiter, or the first rune is non-ASCII.
// Return it as-is.
i = size
}
return seq[:i:i]
}
i += size
}
// No delimiter found.
return seq
}
// isDelim returns true if given byte is a delimiter character.
func isDelim(c byte) bool {
return !(c == '-' || c == '+' || c == '.' || c == '_' ||
('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
('0' <= c && c <= '9'))
}
// Copyright 2018 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 text
// parseNumberValue parses a number from the input and returns a Token object.
func (d *Decoder) parseNumberValue() (Token, bool) {
in := d.in
num := parseNumber(in)
if num.size == 0 {
return Token{}, false
}
numAttrs := num.kind
if num.neg {
numAttrs |= isNegative
}
tok := Token{
kind: Scalar,
attrs: numberValue,
pos: len(d.orig) - len(d.in),
raw: d.in[:num.size],
str: num.string(d.in),
numAttrs: numAttrs,
}
d.consume(num.size)
return tok, true
}
const (
numDec uint8 = (1 << iota) / 2
numHex
numOct
numFloat
)
// number is the result of parsing out a valid number from parseNumber. It
// contains data for doing float or integer conversion via the strconv package
// in conjunction with the input bytes.
type number struct {
kind uint8
neg bool
size int
// if neg, this is the length of whitespace and comments between
// the minus sign and the rest fo the number literal
sep int
}
func (num number) string(data []byte) string {
strSize := num.size
last := num.size - 1
if num.kind == numFloat && (data[last] == 'f' || data[last] == 'F') {
strSize = last
}
if num.neg && num.sep > 0 {
// strip whitespace/comments between negative sign and the rest
strLen := strSize - num.sep
str := make([]byte, strLen)
str[0] = data[0]
copy(str[1:], data[num.sep+1:strSize])
return string(str)
}
return string(data[:strSize])
}
// parseNumber constructs a number object from given input. It allows for the
// following patterns:
//
// integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*)
// float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?)
//
// It also returns the number of parsed bytes for the given number, 0 if it is
// not a number.
func parseNumber(input []byte) number {
kind := numDec
var size int
var neg bool
s := input
if len(s) == 0 {
return number{}
}
// Optional -
var sep int
if s[0] == '-' {
neg = true
s = s[1:]
size++
// Consume any whitespace or comments between the
// negative sign and the rest of the number
lenBefore := len(s)
s = consume(s, 0)
sep = lenBefore - len(s)
size += sep
if len(s) == 0 {
return number{}
}
}
switch {
case s[0] == '0':
if len(s) > 1 {
switch {
case s[1] == 'x' || s[1] == 'X':
// Parse as hex number.
kind = numHex
n := 2
s = s[2:]
for len(s) > 0 && (('0' <= s[0] && s[0] <= '9') ||
('a' <= s[0] && s[0] <= 'f') ||
('A' <= s[0] && s[0] <= 'F')) {
s = s[1:]
n++
}
if n == 2 {
return number{}
}
size += n
case '0' <= s[1] && s[1] <= '7':
// Parse as octal number.
kind = numOct
n := 2
s = s[2:]
for len(s) > 0 && '0' <= s[0] && s[0] <= '7' {
s = s[1:]
n++
}
size += n
}
if kind&(numHex|numOct) > 0 {
if len(s) > 0 && !isDelim(s[0]) {
return number{}
}
return number{kind: kind, neg: neg, size: size, sep: sep}
}
}
s = s[1:]
size++
case '1' <= s[0] && s[0] <= '9':
n := 1
s = s[1:]
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
size += n
case s[0] == '.':
// Set kind to numFloat to signify the intent to parse as float. And
// that it needs to have other digits after '.'.
kind = numFloat
default:
return number{}
}
// . followed by 0 or more digits.
if len(s) > 0 && s[0] == '.' {
n := 1
s = s[1:]
// If decimal point was before any digits, it should be followed by
// other digits.
if len(s) == 0 && kind == numFloat {
return number{}
}
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
size += n
kind = numFloat
}
// e or E followed by an optional - or + and 1 or more digits.
if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
kind = numFloat
s = s[1:]
n := 1
if s[0] == '+' || s[0] == '-' {
s = s[1:]
n++
if len(s) == 0 {
return number{}
}
}
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
s = s[1:]
n++
}
size += n
}
// Optional suffix f or F for floats.
if len(s) > 0 && (s[0] == 'f' || s[0] == 'F') {
kind = numFloat
s = s[1:]
size++
}
// Check that next byte is a delimiter or it is at the end.
if len(s) > 0 && !isDelim(s[0]) {
return number{}
}
return number{kind: kind, neg: neg, size: size, sep: sep}
}
// Copyright 2018 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 text
import (
"bytes"
"strconv"
"strings"
"unicode"
"unicode/utf16"
"unicode/utf8"
"google.golang.org/protobuf/internal/strs"
)
// parseStringValue parses string field token.
// This differs from parseString since the text format allows
// multiple back-to-back string literals where they are semantically treated
// as a single large string with all values concatenated.
//
// E.g., `"foo" "bar" "baz"` => "foobarbaz"
func (d *Decoder) parseStringValue() (Token, error) {
// Note that the ending quote is sufficient to unambiguously mark the end
// of a string. Thus, the text grammar does not require intervening
// whitespace or control characters in-between strings.
// Thus, the following is valid:
// `"foo"'bar'"baz"` => "foobarbaz"
in0 := d.in
var ss []string
for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
s, err := d.parseString()
if err != nil {
return Token{}, err
}
ss = append(ss, s)
}
// d.in already points to the end of the value at this point.
return Token{
kind: Scalar,
attrs: stringValue,
pos: len(d.orig) - len(in0),
raw: in0[:len(in0)-len(d.in)],
str: strings.Join(ss, ""),
}, nil
}
// parseString parses a string value enclosed in " or '.
func (d *Decoder) parseString() (string, error) {
in := d.in
if len(in) == 0 {
return "", ErrUnexpectedEOF
}
quote := in[0]
in = in[1:]
i := indexNeedEscapeInBytes(in)
in, out := in[i:], in[:i:i] // set cap to prevent mutations
for len(in) > 0 {
switch r, n := utf8.DecodeRune(in); {
case r == utf8.RuneError && n == 1:
return "", d.newSyntaxError("invalid UTF-8 detected")
case r == 0 || r == '\n':
return "", d.newSyntaxError("invalid character %q in string", r)
case r == rune(quote):
in = in[1:]
d.consume(len(d.in) - len(in))
return string(out), nil
case r == '\\':
if len(in) < 2 {
return "", ErrUnexpectedEOF
}
switch r := in[1]; r {
case '"', '\'', '\\', '?':
in, out = in[2:], append(out, r)
case 'a':
in, out = in[2:], append(out, '\a')
case 'b':
in, out = in[2:], append(out, '\b')
case 'n':
in, out = in[2:], append(out, '\n')
case 'r':
in, out = in[2:], append(out, '\r')
case 't':
in, out = in[2:], append(out, '\t')
case 'v':
in, out = in[2:], append(out, '\v')
case 'f':
in, out = in[2:], append(out, '\f')
case '0', '1', '2', '3', '4', '5', '6', '7':
// One, two, or three octal characters.
n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
if n > 3 {
n = 3
}
v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
if err != nil {
return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
}
in, out = in[1+n:], append(out, byte(v))
case 'x':
// One or two hexadecimal characters.
n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
if n > 2 {
n = 2
}
v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
if err != nil {
return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
}
in, out = in[2+n:], append(out, byte(v))
case 'u', 'U':
// Four or eight hexadecimal characters
n := 6
if r == 'U' {
n = 10
}
if len(in) < n {
return "", ErrUnexpectedEOF
}
v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
if utf8.MaxRune < v || err != nil {
return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
}
in = in[n:]
r := rune(v)
if utf16.IsSurrogate(r) {
if len(in) < 6 {
return "", ErrUnexpectedEOF
}
v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
r = utf16.DecodeRune(r, rune(v))
if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
}
in = in[6:]
}
out = append(out, string(r)...)
default:
return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
}
default:
i := indexNeedEscapeInBytes(in[n:])
in, out = in[n+i:], append(out, in[:n+i]...)
}
}
return "", ErrUnexpectedEOF
}
// indexNeedEscapeInString returns the index of the character that needs
// escaping. If no characters need escaping, this returns the input length.
func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
// UnmarshalString returns an unescaped string given a textproto string value.
// String value needs to contain single or double quotes. This is only used by
// internal/encoding/defval package for unmarshaling bytes.
func UnmarshalString(s string) (string, error) {
d := NewDecoder([]byte(s))
return d.parseString()
}
// Copyright 2018 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 text
import (
"bytes"
"fmt"
"math"
"strconv"
"strings"
"google.golang.org/protobuf/internal/flags"
)
// Kind represents a token kind expressible in the textproto format.
type Kind uint8
// Kind values.
const (
Invalid Kind = iota
EOF
Name // Name indicates the field name.
Scalar // Scalar are scalar values, e.g. "string", 47, ENUM_LITERAL, true.
MessageOpen
MessageClose
ListOpen
ListClose
// comma and semi-colon are only for parsing in between values and should not be exposed.
comma
semicolon
// bof indicates beginning of file, which is the default token
// kind at the beginning of parsing.
bof = Invalid
)
func (t Kind) String() string {
switch t {
case Invalid:
return "<invalid>"
case EOF:
return "eof"
case Scalar:
return "scalar"
case Name:
return "name"
case MessageOpen:
return "{"
case MessageClose:
return "}"
case ListOpen:
return "["
case ListClose:
return "]"
case comma:
return ","
case semicolon:
return ";"
default:
return fmt.Sprintf("<invalid:%v>", uint8(t))
}
}
// NameKind represents different types of field names.
type NameKind uint8
// NameKind values.
const (
IdentName NameKind = iota + 1
TypeName
FieldNumber
)
func (t NameKind) String() string {
switch t {
case IdentName:
return "IdentName"
case TypeName:
return "TypeName"
case FieldNumber:
return "FieldNumber"
default:
return fmt.Sprintf("<invalid:%v>", uint8(t))
}
}
// Bit mask in Token.attrs to indicate if a Name token is followed by the
// separator char ':'. The field name separator char is optional for message
// field or repeated message field, but required for all other types. Decoder
// simply indicates whether a Name token is followed by separator or not. It is
// up to the prototext package to validate.
const hasSeparator = 1 << 7
// Scalar value types.
const (
numberValue = iota + 1
stringValue
literalValue
)
// Bit mask in Token.numAttrs to indicate that the number is a negative.
const isNegative = 1 << 7
// Token provides a parsed token kind and value. Values are provided by the
// different accessor methods.
type Token struct {
// Kind of the Token object.
kind Kind
// attrs contains metadata for the following Kinds:
// Name: hasSeparator bit and one of NameKind.
// Scalar: one of numberValue, stringValue, literalValue.
attrs uint8
// numAttrs contains metadata for numberValue:
// - highest bit is whether negative or positive.
// - lower bits indicate one of numDec, numHex, numOct, numFloat.
numAttrs uint8
// pos provides the position of the token in the original input.
pos int
// raw bytes of the serialized token.
// This is a subslice into the original input.
raw []byte
// str contains parsed string for the following:
// - stringValue of Scalar kind
// - numberValue of Scalar kind
// - TypeName of Name kind
str string
}
// Kind returns the token kind.
func (t Token) Kind() Kind {
return t.kind
}
// RawString returns the read value in string.
func (t Token) RawString() string {
return string(t.raw)
}
// Pos returns the token position from the input.
func (t Token) Pos() int {
return t.pos
}
// NameKind returns IdentName, TypeName or FieldNumber.
// It panics if type is not Name.
func (t Token) NameKind() NameKind {
if t.kind == Name {
return NameKind(t.attrs &^ hasSeparator)
}
panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
}
// HasSeparator returns true if the field name is followed by the separator char
// ':', else false. It panics if type is not Name.
func (t Token) HasSeparator() bool {
if t.kind == Name {
return t.attrs&hasSeparator != 0
}
panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
}
// IdentName returns the value for IdentName type.
func (t Token) IdentName() string {
if t.kind == Name && t.attrs&uint8(IdentName) != 0 {
return string(t.raw)
}
panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
}
// TypeName returns the value for TypeName type.
func (t Token) TypeName() string {
if t.kind == Name && t.attrs&uint8(TypeName) != 0 {
return t.str
}
panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
}
// FieldNumber returns the value for FieldNumber type. It returns a
// non-negative int32 value. Caller will still need to validate for the correct
// field number range.
func (t Token) FieldNumber() int32 {
if t.kind != Name || t.attrs&uint8(FieldNumber) == 0 {
panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
}
// Following should not return an error as it had already been called right
// before this Token was constructed.
num, _ := strconv.ParseInt(string(t.raw), 10, 32)
return int32(num)
}
// String returns the string value for a Scalar type.
func (t Token) String() (string, bool) {
if t.kind != Scalar || t.attrs != stringValue {
return "", false
}
return t.str, true
}
// Enum returns the literal value for a Scalar type for use as enum literals.
func (t Token) Enum() (string, bool) {
if t.kind != Scalar || t.attrs != literalValue || (len(t.raw) > 0 && t.raw[0] == '-') {
return "", false
}
return string(t.raw), true
}
// Bool returns the bool value for a Scalar type.
func (t Token) Bool() (bool, bool) {
if t.kind != Scalar {
return false, false
}
switch t.attrs {
case literalValue:
if b, ok := boolLits[string(t.raw)]; ok {
return b, true
}
case numberValue:
// Unsigned integer representation of 0 or 1 is permitted: 00, 0x0, 01,
// 0x1, etc.
n, err := strconv.ParseUint(t.str, 0, 64)
if err == nil {
switch n {
case 0:
return false, true
case 1:
return true, true
}
}
}
return false, false
}
// These exact boolean literals are the ones supported in C++.
var boolLits = map[string]bool{
"t": true,
"true": true,
"True": true,
"f": false,
"false": false,
"False": false,
}
// Uint64 returns the uint64 value for a Scalar type.
func (t Token) Uint64() (uint64, bool) {
if t.kind != Scalar || t.attrs != numberValue ||
t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
return 0, false
}
n, err := strconv.ParseUint(t.str, 0, 64)
if err != nil {
return 0, false
}
return n, true
}
// Uint32 returns the uint32 value for a Scalar type.
func (t Token) Uint32() (uint32, bool) {
if t.kind != Scalar || t.attrs != numberValue ||
t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
return 0, false
}
n, err := strconv.ParseUint(t.str, 0, 32)
if err != nil {
return 0, false
}
return uint32(n), true
}
// Int64 returns the int64 value for a Scalar type.
func (t Token) Int64() (int64, bool) {
if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
return 0, false
}
if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {
return n, true
}
// C++ accepts large positive hex numbers as negative values.
// This feature is here for proto1 backwards compatibility purposes.
if flags.ProtoLegacy && (t.numAttrs == numHex) {
if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {
return int64(n), true
}
}
return 0, false
}
// Int32 returns the int32 value for a Scalar type.
func (t Token) Int32() (int32, bool) {
if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
return 0, false
}
if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {
return int32(n), true
}
// C++ accepts large positive hex numbers as negative values.
// This feature is here for proto1 backwards compatibility purposes.
if flags.ProtoLegacy && (t.numAttrs == numHex) {
if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {
return int32(n), true
}
}
return 0, false
}
// Float64 returns the float64 value for a Scalar type.
func (t Token) Float64() (float64, bool) {
if t.kind != Scalar {
return 0, false
}
switch t.attrs {
case literalValue:
if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
return f, true
}
case numberValue:
n, err := strconv.ParseFloat(t.str, 64)
if err == nil {
return n, true
}
nerr := err.(*strconv.NumError)
if nerr.Err == strconv.ErrRange {
return n, true
}
}
return 0, false
}
// Float32 returns the float32 value for a Scalar type.
func (t Token) Float32() (float32, bool) {
if t.kind != Scalar {
return 0, false
}
switch t.attrs {
case literalValue:
if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
return float32(f), true
}
case numberValue:
n, err := strconv.ParseFloat(t.str, 64)
if err == nil {
// Overflows are treated as (-)infinity.
return float32(n), true
}
nerr := err.(*strconv.NumError)
if nerr.Err == strconv.ErrRange {
return float32(n), true
}
}
return 0, false
}
// These are the supported float literals which C++ permits case-insensitive
// variants of these.
var floatLits = map[string]float64{
"nan": math.NaN(),
"inf": math.Inf(1),
"infinity": math.Inf(1),
"-inf": math.Inf(-1),
"-infinity": math.Inf(-1),
}
// TokenEquals returns true if given Tokens are equal, else false.
func TokenEquals(x, y Token) bool {
return x.kind == y.kind &&
x.attrs == y.attrs &&
x.numAttrs == y.numAttrs &&
x.pos == y.pos &&
bytes.Equal(x.raw, y.raw) &&
x.str == y.str
}
// Copyright 2018 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 text
import (
"math"
"math/bits"
"strconv"
"strings"
"unicode/utf8"
"google.golang.org/protobuf/internal/detrand"
"google.golang.org/protobuf/internal/errors"
)
// encType represents an encoding type.
type encType uint8
const (
_ encType = (1 << iota) / 2
name
scalar
messageOpen
messageClose
)
// Encoder provides methods to write out textproto constructs and values. The user is
// responsible for producing valid sequences of constructs and values.
type Encoder struct {
encoderState
indent string
delims [2]byte
outputASCII bool
}
type encoderState struct {
lastType encType
indents []byte
out []byte
}
// NewEncoder returns an Encoder.
//
// If indent is a non-empty string, it causes every entry in a List or Message
// to be preceded by the indent and trailed by a newline.
//
// If delims is not the zero value, it controls the delimiter characters used
// for messages (e.g., "{}" vs "<>").
//
// If outputASCII is true, strings will be serialized in such a way that
// multi-byte UTF-8 sequences are escaped. This property ensures that the
// overall output is ASCII (as opposed to UTF-8).
func NewEncoder(buf []byte, indent string, delims [2]byte, outputASCII bool) (*Encoder, error) {
e := &Encoder{
encoderState: encoderState{out: buf},
}
if len(indent) > 0 {
if strings.Trim(indent, " \t") != "" {
return nil, errors.New("indent may only be composed of space and tab characters")
}
e.indent = indent
}
switch delims {
case [2]byte{0, 0}:
e.delims = [2]byte{'{', '}'}
case [2]byte{'{', '}'}, [2]byte{'<', '>'}:
e.delims = delims
default:
return nil, errors.New("delimiters may only be \"{}\" or \"<>\"")
}
e.outputASCII = outputASCII
return e, nil
}
// Bytes returns the content of the written bytes.
func (e *Encoder) Bytes() []byte {
return e.out
}
// StartMessage writes out the '{' or '<' symbol.
func (e *Encoder) StartMessage() {
e.prepareNext(messageOpen)
e.out = append(e.out, e.delims[0])
}
// EndMessage writes out the '}' or '>' symbol.
func (e *Encoder) EndMessage() {
e.prepareNext(messageClose)
e.out = append(e.out, e.delims[1])
}
// WriteName writes out the field name and the separator ':'.
func (e *Encoder) WriteName(s string) {
e.prepareNext(name)
e.out = append(e.out, s...)
e.out = append(e.out, ':')
}
// WriteBool writes out the given boolean value.
func (e *Encoder) WriteBool(b bool) {
if b {
e.WriteLiteral("true")
} else {
e.WriteLiteral("false")
}
}
// WriteString writes out the given string value.
func (e *Encoder) WriteString(s string) {
e.prepareNext(scalar)
e.out = appendString(e.out, s, e.outputASCII)
}
func appendString(out []byte, in string, outputASCII bool) []byte {
out = append(out, '"')
i := indexNeedEscapeInString(in)
in, out = in[i:], append(out, in[:i]...)
for len(in) > 0 {
switch r, n := utf8.DecodeRuneInString(in); {
case r == utf8.RuneError && n == 1:
// We do not report invalid UTF-8 because strings in the text format
// are used to represent both the proto string and bytes type.
r = rune(in[0])
fallthrough
case r < ' ' || r == '"' || r == '\\' || r == 0x7f:
out = append(out, '\\')
switch r {
case '"', '\\':
out = append(out, byte(r))
case '\n':
out = append(out, 'n')
case '\r':
out = append(out, 'r')
case '\t':
out = append(out, 't')
default:
out = append(out, 'x')
out = append(out, "00"[1+(bits.Len32(uint32(r))-1)/4:]...)
out = strconv.AppendUint(out, uint64(r), 16)
}
in = in[n:]
case r >= utf8.RuneSelf && (outputASCII || r <= 0x009f):
out = append(out, '\\')
if r <= math.MaxUint16 {
out = append(out, 'u')
out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
out = strconv.AppendUint(out, uint64(r), 16)
} else {
out = append(out, 'U')
out = append(out, "00000000"[1+(bits.Len32(uint32(r))-1)/4:]...)
out = strconv.AppendUint(out, uint64(r), 16)
}
in = in[n:]
default:
i := indexNeedEscapeInString(in[n:])
in, out = in[n+i:], append(out, in[:n+i]...)
}
}
out = append(out, '"')
return out
}
// indexNeedEscapeInString returns the index of the character that needs
// escaping. If no characters need escaping, this returns the input length.
func indexNeedEscapeInString(s string) int {
for i := 0; i < len(s); i++ {
if c := s[i]; c < ' ' || c == '"' || c == '\'' || c == '\\' || c >= 0x7f {
return i
}
}
return len(s)
}
// WriteFloat writes out the given float value for given bitSize.
func (e *Encoder) WriteFloat(n float64, bitSize int) {
e.prepareNext(scalar)
e.out = appendFloat(e.out, n, bitSize)
}
func appendFloat(out []byte, n float64, bitSize int) []byte {
switch {
case math.IsNaN(n):
return append(out, "nan"...)
case math.IsInf(n, +1):
return append(out, "inf"...)
case math.IsInf(n, -1):
return append(out, "-inf"...)
default:
return strconv.AppendFloat(out, n, 'g', -1, bitSize)
}
}
// WriteInt writes out the given signed integer value.
func (e *Encoder) WriteInt(n int64) {
e.prepareNext(scalar)
e.out = strconv.AppendInt(e.out, n, 10)
}
// WriteUint writes out the given unsigned integer value.
func (e *Encoder) WriteUint(n uint64) {
e.prepareNext(scalar)
e.out = strconv.AppendUint(e.out, n, 10)
}
// WriteLiteral writes out the given string as a literal value without quotes.
// This is used for writing enum literal strings.
func (e *Encoder) WriteLiteral(s string) {
e.prepareNext(scalar)
e.out = append(e.out, s...)
}
// prepareNext adds possible space and indentation for the next value based
// on last encType and indent option. It also updates e.lastType to next.
func (e *Encoder) prepareNext(next encType) {
defer func() {
e.lastType = next
}()
// Single line.
if len(e.indent) == 0 {
// Add space after each field before the next one.
if e.lastType&(scalar|messageClose) != 0 && next == name {
e.out = append(e.out, ' ')
// Add a random extra space to make output unstable.
if detrand.Bool() {
e.out = append(e.out, ' ')
}
}
return
}
// Multi-line.
switch {
case e.lastType == name:
e.out = append(e.out, ' ')
// Add a random extra space after name: to make output unstable.
if detrand.Bool() {
e.out = append(e.out, ' ')
}
case e.lastType == messageOpen && next != messageClose:
e.indents = append(e.indents, e.indent...)
e.out = append(e.out, '\n')
e.out = append(e.out, e.indents...)
case e.lastType&(scalar|messageClose) != 0:
if next == messageClose {
e.indents = e.indents[:len(e.indents)-len(e.indent)]
}
e.out = append(e.out, '\n')
e.out = append(e.out, e.indents...)
}
}
// Snapshot returns the current snapshot for use in Reset.
func (e *Encoder) Snapshot() encoderState {
return e.encoderState
}
// Reset resets the Encoder to the given encoderState from a Snapshot.
func (e *Encoder) Reset(es encoderState) {
e.encoderState = es
}
// AppendString appends the escaped form of the input string to b.
func AppendString(b []byte, s string) []byte {
return appendString(b, s, false)
}
// Copyright 2018 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 errors implements functions to manipulate errors.
package errors
import (
"errors"
"fmt"
"google.golang.org/protobuf/internal/detrand"
)
// Error is a sentinel matching all errors produced by this package.
var Error = errors.New("protobuf error")
// New formats a string according to the format specifier and arguments and
// returns an error that has a "proto" prefix.
func New(f string, x ...any) error {
return &prefixError{s: format(f, x...)}
}
type prefixError struct{ s string }
var prefix = func() string {
// Deliberately introduce instability into the error message string to
// discourage users from performing error string comparisons.
if detrand.Bool() {
return "proto: " // use non-breaking spaces (U+00a0)
} else {
return "proto: " // use regular spaces (U+0020)
}
}()
func (e *prefixError) Error() string {
return prefix + e.s
}
func (e *prefixError) Unwrap() error {
return Error
}
// Wrap returns an error that has a "proto" prefix, the formatted string described
// by the format specifier and arguments, and a suffix of err. The error wraps err.
func Wrap(err error, f string, x ...any) error {
return &wrapError{
s: format(f, x...),
err: err,
}
}
type wrapError struct {
s string
err error
}
func (e *wrapError) Error() string {
return format("%v%v: %v", prefix, e.s, e.err)
}
func (e *wrapError) Unwrap() error {
return e.err
}
func (e *wrapError) Is(target error) bool {
return target == Error
}
func format(f string, x ...any) string {
// avoid "proto: " prefix when chaining
for i := 0; i < len(x); i++ {
switch e := x[i].(type) {
case *prefixError:
x[i] = e.s
case *wrapError:
x[i] = format("%v: %v", e.s, e.err)
}
}
return fmt.Sprintf(f, x...)
}
func InvalidUTF8(name string) error {
return New("field %v contains invalid UTF-8", name)
}
func RequiredNotSet(name string) error {
return New("required field %v not set", name)
}
type SizeMismatchError struct {
Calculated, Measured int
}
func (e *SizeMismatchError) Error() string {
return fmt.Sprintf("size mismatch (see https://github.com/golang/protobuf/issues/1609): calculated=%d, measured=%d", e.Calculated, e.Measured)
}
func MismatchedSizeCalculation(calculated, measured int) error {
return &SizeMismatchError{
Calculated: calculated,
Measured: measured,
}
}
// 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 filedesc provides functionality for constructing descriptors.
//
// The types in this package implement interfaces in the protoreflect package
// related to protobuf descripriptors.
package filedesc
import (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
// Builder construct a protoreflect.FileDescriptor from the raw descriptor.
type Builder struct {
// GoPackagePath is the Go package path that is invoking this builder.
GoPackagePath string
// RawDescriptor is the wire-encoded bytes of FileDescriptorProto
// and must be populated.
RawDescriptor []byte
// NumEnums is the total number of enums declared in the file.
NumEnums int32
// NumMessages is the total number of messages declared in the file.
// It includes the implicit message declarations for map entries.
NumMessages int32
// NumExtensions is the total number of extensions declared in the file.
NumExtensions int32
// NumServices is the total number of services declared in the file.
NumServices int32
// TypeResolver resolves extension field types for descriptor options.
// If nil, it uses protoregistry.GlobalTypes.
TypeResolver interface {
protoregistry.ExtensionTypeResolver
}
// FileRegistry is use to lookup file, enum, and message dependencies.
// Once constructed, the file descriptor is registered here.
// If nil, it uses protoregistry.GlobalFiles.
FileRegistry interface {
FindFileByPath(string) (protoreflect.FileDescriptor, error)
FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error)
RegisterFile(protoreflect.FileDescriptor) error
}
}
// resolverByIndex is an interface Builder.FileRegistry may implement.
// If so, it permits looking up an enum or message dependency based on the
// sub-list and element index into filetype.Builder.DependencyIndexes.
type resolverByIndex interface {
FindEnumByIndex(int32, int32, []Enum, []Message) protoreflect.EnumDescriptor
FindMessageByIndex(int32, int32, []Enum, []Message) protoreflect.MessageDescriptor
}
// Indexes of each sub-list in filetype.Builder.DependencyIndexes.
const (
listFieldDeps int32 = iota
listExtTargets
listExtDeps
listMethInDeps
listMethOutDeps
)
// Out is the output of the Builder.
type Out struct {
File protoreflect.FileDescriptor
// Enums is all enum descriptors in "flattened ordering".
Enums []Enum
// Messages is all message descriptors in "flattened ordering".
// It includes the implicit message declarations for map entries.
Messages []Message
// Extensions is all extension descriptors in "flattened ordering".
Extensions []Extension
// Service is all service descriptors in "flattened ordering".
Services []Service
}
// Build constructs a FileDescriptor given the parameters set in Builder.
// It assumes that the inputs are well-formed and panics if any inconsistencies
// are encountered.
//
// If NumEnums+NumMessages+NumExtensions+NumServices is zero,
// then Build automatically derives them from the raw descriptor.
func (db Builder) Build() (out Out) {
// Populate the counts if uninitialized.
if db.NumEnums+db.NumMessages+db.NumExtensions+db.NumServices == 0 {
db.unmarshalCounts(db.RawDescriptor, true)
}
// Initialize resolvers and registries if unpopulated.
if db.TypeResolver == nil {
db.TypeResolver = protoregistry.GlobalTypes
}
if db.FileRegistry == nil {
db.FileRegistry = protoregistry.GlobalFiles
}
fd := newRawFile(db)
out.File = fd
out.Enums = fd.allEnums
out.Messages = fd.allMessages
out.Extensions = fd.allExtensions
out.Services = fd.allServices
if err := db.FileRegistry.RegisterFile(fd); err != nil {
panic(err)
}
return out
}
// unmarshalCounts counts the number of enum, message, extension, and service
// declarations in the raw message, which is either a FileDescriptorProto
// or a MessageDescriptorProto depending on whether isFile is set.
func (db *Builder) unmarshalCounts(b []byte, isFile bool) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
if isFile {
switch num {
case genid.FileDescriptorProto_EnumType_field_number:
db.NumEnums++
case genid.FileDescriptorProto_MessageType_field_number:
db.unmarshalCounts(v, false)
db.NumMessages++
case genid.FileDescriptorProto_Extension_field_number:
db.NumExtensions++
case genid.FileDescriptorProto_Service_field_number:
db.NumServices++
}
} else {
switch num {
case genid.DescriptorProto_EnumType_field_number:
db.NumEnums++
case genid.DescriptorProto_NestedType_field_number:
db.unmarshalCounts(v, false)
db.NumMessages++
case genid.DescriptorProto_Extension_field_number:
db.NumExtensions++
}
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
// 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 filedesc
import (
"bytes"
"fmt"
"strings"
"sync"
"sync/atomic"
"google.golang.org/protobuf/internal/descfmt"
"google.golang.org/protobuf/internal/descopts"
"google.golang.org/protobuf/internal/encoding/defval"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
// Edition is an Enum for proto2.Edition
type Edition int32
// These values align with the value of Enum in descriptor.proto which allows
// direct conversion between the proto enum and this enum.
const (
EditionUnknown Edition = 0
EditionProto2 Edition = 998
EditionProto3 Edition = 999
Edition2023 Edition = 1000
Edition2024 Edition = 1001
EditionUnsupported Edition = 100000
)
// The types in this file may have a suffix:
// • L0: Contains fields common to all descriptors (except File) and
// must be initialized up front.
// • L1: Contains fields specific to a descriptor and
// must be initialized up front. If the associated proto uses Editions, the
// Editions features must always be resolved. If not explicitly set, the
// appropriate default must be resolved and set.
// • L2: Contains fields that are lazily initialized when constructing
// from the raw file descriptor. When constructing as a literal, the L2
// fields must be initialized up front.
//
// The types are exported so that packages like reflect/protodesc can
// directly construct descriptors.
type (
File struct {
fileRaw
L1 FileL1
once uint32 // atomically set if L2 is valid
mu sync.Mutex // protects L2
L2 *FileL2
}
FileL1 struct {
Syntax protoreflect.Syntax
Edition Edition // Only used if Syntax == Editions
Path string
Package protoreflect.FullName
Enums Enums
Messages Messages
Extensions Extensions
Services Services
EditionFeatures EditionFeatures
}
FileL2 struct {
Options func() protoreflect.ProtoMessage
Imports FileImports
Locations SourceLocations
}
// EditionFeatures is a frequently-instantiated struct, so please take care
// to minimize padding when adding new fields to this struct (add them in
// the right place/order).
EditionFeatures struct {
// StripEnumPrefix determines if the plugin generates enum value
// constants as-is, with their prefix stripped, or both variants.
StripEnumPrefix int
// IsFieldPresence is true if field_presence is EXPLICIT
// https://protobuf.dev/editions/features/#field_presence
IsFieldPresence bool
// IsFieldPresence is true if field_presence is LEGACY_REQUIRED
// https://protobuf.dev/editions/features/#field_presence
IsLegacyRequired bool
// IsOpenEnum is true if enum_type is OPEN
// https://protobuf.dev/editions/features/#enum_type
IsOpenEnum bool
// IsPacked is true if repeated_field_encoding is PACKED
// https://protobuf.dev/editions/features/#repeated_field_encoding
IsPacked bool
// IsUTF8Validated is true if utf_validation is VERIFY
// https://protobuf.dev/editions/features/#utf8_validation
IsUTF8Validated bool
// IsDelimitedEncoded is true if message_encoding is DELIMITED
// https://protobuf.dev/editions/features/#message_encoding
IsDelimitedEncoded bool
// IsJSONCompliant is true if json_format is ALLOW
// https://protobuf.dev/editions/features/#json_format
IsJSONCompliant bool
// GenerateLegacyUnmarshalJSON determines if the plugin generates the
// UnmarshalJSON([]byte) error method for enums.
GenerateLegacyUnmarshalJSON bool
// APILevel controls which API (Open, Hybrid or Opaque) should be used
// for generated code (.pb.go files).
APILevel int
}
)
func (fd *File) ParentFile() protoreflect.FileDescriptor { return fd }
func (fd *File) Parent() protoreflect.Descriptor { return nil }
func (fd *File) Index() int { return 0 }
func (fd *File) Syntax() protoreflect.Syntax { return fd.L1.Syntax }
// Not exported and just used to reconstruct the original FileDescriptor proto
func (fd *File) Edition() int32 { return int32(fd.L1.Edition) }
func (fd *File) Name() protoreflect.Name { return fd.L1.Package.Name() }
func (fd *File) FullName() protoreflect.FullName { return fd.L1.Package }
func (fd *File) IsPlaceholder() bool { return false }
func (fd *File) Options() protoreflect.ProtoMessage {
if f := fd.lazyInit().Options; f != nil {
return f()
}
return descopts.File
}
func (fd *File) Path() string { return fd.L1.Path }
func (fd *File) Package() protoreflect.FullName { return fd.L1.Package }
func (fd *File) Imports() protoreflect.FileImports { return &fd.lazyInit().Imports }
func (fd *File) Enums() protoreflect.EnumDescriptors { return &fd.L1.Enums }
func (fd *File) Messages() protoreflect.MessageDescriptors { return &fd.L1.Messages }
func (fd *File) Extensions() protoreflect.ExtensionDescriptors { return &fd.L1.Extensions }
func (fd *File) Services() protoreflect.ServiceDescriptors { return &fd.L1.Services }
func (fd *File) SourceLocations() protoreflect.SourceLocations { return &fd.lazyInit().Locations }
func (fd *File) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) }
func (fd *File) ProtoType(protoreflect.FileDescriptor) {}
func (fd *File) ProtoInternal(pragma.DoNotImplement) {}
func (fd *File) lazyInit() *FileL2 {
if atomic.LoadUint32(&fd.once) == 0 {
fd.lazyInitOnce()
}
return fd.L2
}
func (fd *File) lazyInitOnce() {
fd.mu.Lock()
if fd.L2 == nil {
fd.lazyRawInit() // recursively initializes all L2 structures
}
atomic.StoreUint32(&fd.once, 1)
fd.mu.Unlock()
}
// GoPackagePath is a pseudo-internal API for determining the Go package path
// that this file descriptor is declared in.
//
// WARNING: This method is exempt from the compatibility promise and may be
// removed in the future without warning.
func (fd *File) GoPackagePath() string {
return fd.builder.GoPackagePath
}
type (
Enum struct {
Base
L1 EnumL1
L2 *EnumL2 // protected by fileDesc.once
}
EnumL1 struct {
eagerValues bool // controls whether EnumL2.Values is already populated
EditionFeatures EditionFeatures
}
EnumL2 struct {
Options func() protoreflect.ProtoMessage
Values EnumValues
ReservedNames Names
ReservedRanges EnumRanges
}
EnumValue struct {
Base
L1 EnumValueL1
}
EnumValueL1 struct {
Options func() protoreflect.ProtoMessage
Number protoreflect.EnumNumber
}
)
func (ed *Enum) Options() protoreflect.ProtoMessage {
if f := ed.lazyInit().Options; f != nil {
return f()
}
return descopts.Enum
}
func (ed *Enum) Values() protoreflect.EnumValueDescriptors {
if ed.L1.eagerValues {
return &ed.L2.Values
}
return &ed.lazyInit().Values
}
func (ed *Enum) ReservedNames() protoreflect.Names { return &ed.lazyInit().ReservedNames }
func (ed *Enum) ReservedRanges() protoreflect.EnumRanges { return &ed.lazyInit().ReservedRanges }
func (ed *Enum) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) }
func (ed *Enum) ProtoType(protoreflect.EnumDescriptor) {}
func (ed *Enum) lazyInit() *EnumL2 {
ed.L0.ParentFile.lazyInit() // implicitly initializes L2
return ed.L2
}
func (ed *Enum) IsClosed() bool {
return !ed.L1.EditionFeatures.IsOpenEnum
}
func (ed *EnumValue) Options() protoreflect.ProtoMessage {
if f := ed.L1.Options; f != nil {
return f()
}
return descopts.EnumValue
}
func (ed *EnumValue) Number() protoreflect.EnumNumber { return ed.L1.Number }
func (ed *EnumValue) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) }
func (ed *EnumValue) ProtoType(protoreflect.EnumValueDescriptor) {}
type (
Message struct {
Base
L1 MessageL1
L2 *MessageL2 // protected by fileDesc.once
}
MessageL1 struct {
Enums Enums
Messages Messages
Extensions Extensions
IsMapEntry bool // promoted from google.protobuf.MessageOptions
IsMessageSet bool // promoted from google.protobuf.MessageOptions
EditionFeatures EditionFeatures
}
MessageL2 struct {
Options func() protoreflect.ProtoMessage
Fields Fields
Oneofs Oneofs
ReservedNames Names
ReservedRanges FieldRanges
RequiredNumbers FieldNumbers // must be consistent with Fields.Cardinality
ExtensionRanges FieldRanges
ExtensionRangeOptions []func() protoreflect.ProtoMessage // must be same length as ExtensionRanges
}
Field struct {
Base
L1 FieldL1
}
FieldL1 struct {
Options func() protoreflect.ProtoMessage
Number protoreflect.FieldNumber
Cardinality protoreflect.Cardinality // must be consistent with Message.RequiredNumbers
Kind protoreflect.Kind
StringName stringName
IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
IsLazy bool // promoted from google.protobuf.FieldOptions
Default defaultValue
ContainingOneof protoreflect.OneofDescriptor // must be consistent with Message.Oneofs.Fields
Enum protoreflect.EnumDescriptor
Message protoreflect.MessageDescriptor
EditionFeatures EditionFeatures
}
Oneof struct {
Base
L1 OneofL1
}
OneofL1 struct {
Options func() protoreflect.ProtoMessage
Fields OneofFields // must be consistent with Message.Fields.ContainingOneof
EditionFeatures EditionFeatures
}
)
func (md *Message) Options() protoreflect.ProtoMessage {
if f := md.lazyInit().Options; f != nil {
return f()
}
return descopts.Message
}
func (md *Message) IsMapEntry() bool { return md.L1.IsMapEntry }
func (md *Message) Fields() protoreflect.FieldDescriptors { return &md.lazyInit().Fields }
func (md *Message) Oneofs() protoreflect.OneofDescriptors { return &md.lazyInit().Oneofs }
func (md *Message) ReservedNames() protoreflect.Names { return &md.lazyInit().ReservedNames }
func (md *Message) ReservedRanges() protoreflect.FieldRanges { return &md.lazyInit().ReservedRanges }
func (md *Message) RequiredNumbers() protoreflect.FieldNumbers { return &md.lazyInit().RequiredNumbers }
func (md *Message) ExtensionRanges() protoreflect.FieldRanges { return &md.lazyInit().ExtensionRanges }
func (md *Message) ExtensionRangeOptions(i int) protoreflect.ProtoMessage {
if f := md.lazyInit().ExtensionRangeOptions[i]; f != nil {
return f()
}
return descopts.ExtensionRange
}
func (md *Message) Enums() protoreflect.EnumDescriptors { return &md.L1.Enums }
func (md *Message) Messages() protoreflect.MessageDescriptors { return &md.L1.Messages }
func (md *Message) Extensions() protoreflect.ExtensionDescriptors { return &md.L1.Extensions }
func (md *Message) ProtoType(protoreflect.MessageDescriptor) {}
func (md *Message) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) }
func (md *Message) lazyInit() *MessageL2 {
md.L0.ParentFile.lazyInit() // implicitly initializes L2
return md.L2
}
// IsMessageSet is a pseudo-internal API for checking whether a message
// should serialize in the proto1 message format.
//
// WARNING: This method is exempt from the compatibility promise and may be
// removed in the future without warning.
func (md *Message) IsMessageSet() bool {
return md.L1.IsMessageSet
}
func (fd *Field) Options() protoreflect.ProtoMessage {
if f := fd.L1.Options; f != nil {
return f()
}
return descopts.Field
}
func (fd *Field) Number() protoreflect.FieldNumber { return fd.L1.Number }
func (fd *Field) Cardinality() protoreflect.Cardinality { return fd.L1.Cardinality }
func (fd *Field) Kind() protoreflect.Kind {
return fd.L1.Kind
}
func (fd *Field) HasJSONName() bool { return fd.L1.StringName.hasJSON }
func (fd *Field) JSONName() string { return fd.L1.StringName.getJSON(fd) }
func (fd *Field) TextName() string { return fd.L1.StringName.getText(fd) }
func (fd *Field) HasPresence() bool {
if fd.L1.Cardinality == protoreflect.Repeated {
return false
}
return fd.IsExtension() || fd.L1.EditionFeatures.IsFieldPresence || fd.L1.Message != nil || fd.L1.ContainingOneof != nil
}
func (fd *Field) HasOptionalKeyword() bool {
return (fd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 && fd.L1.Cardinality == protoreflect.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional
}
func (fd *Field) IsPacked() bool {
if fd.L1.Cardinality != protoreflect.Repeated {
return false
}
switch fd.L1.Kind {
case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind:
return false
}
return fd.L1.EditionFeatures.IsPacked
}
func (fd *Field) IsExtension() bool { return false }
func (fd *Field) IsWeak() bool { return false }
func (fd *Field) IsLazy() bool { return fd.L1.IsLazy }
func (fd *Field) IsList() bool { return fd.Cardinality() == protoreflect.Repeated && !fd.IsMap() }
func (fd *Field) IsMap() bool { return fd.Message() != nil && fd.Message().IsMapEntry() }
func (fd *Field) MapKey() protoreflect.FieldDescriptor {
if !fd.IsMap() {
return nil
}
return fd.Message().Fields().ByNumber(genid.MapEntry_Key_field_number)
}
func (fd *Field) MapValue() protoreflect.FieldDescriptor {
if !fd.IsMap() {
return nil
}
return fd.Message().Fields().ByNumber(genid.MapEntry_Value_field_number)
}
func (fd *Field) HasDefault() bool { return fd.L1.Default.has }
func (fd *Field) Default() protoreflect.Value { return fd.L1.Default.get(fd) }
func (fd *Field) DefaultEnumValue() protoreflect.EnumValueDescriptor { return fd.L1.Default.enum }
func (fd *Field) ContainingOneof() protoreflect.OneofDescriptor { return fd.L1.ContainingOneof }
func (fd *Field) ContainingMessage() protoreflect.MessageDescriptor {
return fd.L0.Parent.(protoreflect.MessageDescriptor)
}
func (fd *Field) Enum() protoreflect.EnumDescriptor {
return fd.L1.Enum
}
func (fd *Field) Message() protoreflect.MessageDescriptor {
return fd.L1.Message
}
func (fd *Field) IsMapEntry() bool {
parent, ok := fd.L0.Parent.(protoreflect.MessageDescriptor)
return ok && parent.IsMapEntry()
}
func (fd *Field) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) }
func (fd *Field) ProtoType(protoreflect.FieldDescriptor) {}
// EnforceUTF8 is a pseudo-internal API to determine whether to enforce UTF-8
// validation for the string field. This exists for Google-internal use only
// since proto3 did not enforce UTF-8 validity prior to the open-source release.
// If this method does not exist, the default is to enforce valid UTF-8.
//
// WARNING: This method is exempt from the compatibility promise and may be
// removed in the future without warning.
func (fd *Field) EnforceUTF8() bool {
return fd.L1.EditionFeatures.IsUTF8Validated
}
func (od *Oneof) IsSynthetic() bool {
return od.L0.ParentFile.L1.Syntax == protoreflect.Proto3 && len(od.L1.Fields.List) == 1 && od.L1.Fields.List[0].HasOptionalKeyword()
}
func (od *Oneof) Options() protoreflect.ProtoMessage {
if f := od.L1.Options; f != nil {
return f()
}
return descopts.Oneof
}
func (od *Oneof) Fields() protoreflect.FieldDescriptors { return &od.L1.Fields }
func (od *Oneof) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, od) }
func (od *Oneof) ProtoType(protoreflect.OneofDescriptor) {}
type (
Extension struct {
Base
L1 ExtensionL1
L2 *ExtensionL2 // protected by fileDesc.once
}
ExtensionL1 struct {
Number protoreflect.FieldNumber
Extendee protoreflect.MessageDescriptor
Cardinality protoreflect.Cardinality
Kind protoreflect.Kind
IsLazy bool
EditionFeatures EditionFeatures
}
ExtensionL2 struct {
Options func() protoreflect.ProtoMessage
StringName stringName
IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
Default defaultValue
Enum protoreflect.EnumDescriptor
Message protoreflect.MessageDescriptor
}
)
func (xd *Extension) Options() protoreflect.ProtoMessage {
if f := xd.lazyInit().Options; f != nil {
return f()
}
return descopts.Field
}
func (xd *Extension) Number() protoreflect.FieldNumber { return xd.L1.Number }
func (xd *Extension) Cardinality() protoreflect.Cardinality { return xd.L1.Cardinality }
func (xd *Extension) Kind() protoreflect.Kind { return xd.L1.Kind }
func (xd *Extension) HasJSONName() bool { return xd.lazyInit().StringName.hasJSON }
func (xd *Extension) JSONName() string { return xd.lazyInit().StringName.getJSON(xd) }
func (xd *Extension) TextName() string { return xd.lazyInit().StringName.getText(xd) }
func (xd *Extension) HasPresence() bool { return xd.L1.Cardinality != protoreflect.Repeated }
func (xd *Extension) HasOptionalKeyword() bool {
return (xd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 && xd.L1.Cardinality == protoreflect.Optional) || xd.lazyInit().IsProto3Optional
}
func (xd *Extension) IsPacked() bool {
if xd.L1.Cardinality != protoreflect.Repeated {
return false
}
switch xd.L1.Kind {
case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind:
return false
}
return xd.L1.EditionFeatures.IsPacked
}
func (xd *Extension) IsExtension() bool { return true }
func (xd *Extension) IsWeak() bool { return false }
func (xd *Extension) IsLazy() bool { return xd.L1.IsLazy }
func (xd *Extension) IsList() bool { return xd.Cardinality() == protoreflect.Repeated }
func (xd *Extension) IsMap() bool { return false }
func (xd *Extension) MapKey() protoreflect.FieldDescriptor { return nil }
func (xd *Extension) MapValue() protoreflect.FieldDescriptor { return nil }
func (xd *Extension) HasDefault() bool { return xd.lazyInit().Default.has }
func (xd *Extension) Default() protoreflect.Value { return xd.lazyInit().Default.get(xd) }
func (xd *Extension) DefaultEnumValue() protoreflect.EnumValueDescriptor {
return xd.lazyInit().Default.enum
}
func (xd *Extension) ContainingOneof() protoreflect.OneofDescriptor { return nil }
func (xd *Extension) ContainingMessage() protoreflect.MessageDescriptor { return xd.L1.Extendee }
func (xd *Extension) Enum() protoreflect.EnumDescriptor { return xd.lazyInit().Enum }
func (xd *Extension) Message() protoreflect.MessageDescriptor { return xd.lazyInit().Message }
func (xd *Extension) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, xd) }
func (xd *Extension) ProtoType(protoreflect.FieldDescriptor) {}
func (xd *Extension) ProtoInternal(pragma.DoNotImplement) {}
func (xd *Extension) lazyInit() *ExtensionL2 {
xd.L0.ParentFile.lazyInit() // implicitly initializes L2
return xd.L2
}
type (
Service struct {
Base
L1 ServiceL1
L2 *ServiceL2 // protected by fileDesc.once
}
ServiceL1 struct{}
ServiceL2 struct {
Options func() protoreflect.ProtoMessage
Methods Methods
}
Method struct {
Base
L1 MethodL1
}
MethodL1 struct {
Options func() protoreflect.ProtoMessage
Input protoreflect.MessageDescriptor
Output protoreflect.MessageDescriptor
IsStreamingClient bool
IsStreamingServer bool
}
)
func (sd *Service) Options() protoreflect.ProtoMessage {
if f := sd.lazyInit().Options; f != nil {
return f()
}
return descopts.Service
}
func (sd *Service) Methods() protoreflect.MethodDescriptors { return &sd.lazyInit().Methods }
func (sd *Service) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, sd) }
func (sd *Service) ProtoType(protoreflect.ServiceDescriptor) {}
func (sd *Service) ProtoInternal(pragma.DoNotImplement) {}
func (sd *Service) lazyInit() *ServiceL2 {
sd.L0.ParentFile.lazyInit() // implicitly initializes L2
return sd.L2
}
func (md *Method) Options() protoreflect.ProtoMessage {
if f := md.L1.Options; f != nil {
return f()
}
return descopts.Method
}
func (md *Method) Input() protoreflect.MessageDescriptor { return md.L1.Input }
func (md *Method) Output() protoreflect.MessageDescriptor { return md.L1.Output }
func (md *Method) IsStreamingClient() bool { return md.L1.IsStreamingClient }
func (md *Method) IsStreamingServer() bool { return md.L1.IsStreamingServer }
func (md *Method) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) }
func (md *Method) ProtoType(protoreflect.MethodDescriptor) {}
func (md *Method) ProtoInternal(pragma.DoNotImplement) {}
// Surrogate files are can be used to create standalone descriptors
// where the syntax is only information derived from the parent file.
var (
SurrogateProto2 = &File{L1: FileL1{Syntax: protoreflect.Proto2}, L2: &FileL2{}}
SurrogateProto3 = &File{L1: FileL1{Syntax: protoreflect.Proto3}, L2: &FileL2{}}
SurrogateEdition2023 = &File{L1: FileL1{Syntax: protoreflect.Editions, Edition: Edition2023}, L2: &FileL2{}}
)
type (
Base struct {
L0 BaseL0
}
BaseL0 struct {
FullName protoreflect.FullName // must be populated
ParentFile *File // must be populated
Parent protoreflect.Descriptor
Index int
}
)
func (d *Base) Name() protoreflect.Name { return d.L0.FullName.Name() }
func (d *Base) FullName() protoreflect.FullName { return d.L0.FullName }
func (d *Base) ParentFile() protoreflect.FileDescriptor {
if d.L0.ParentFile == SurrogateProto2 || d.L0.ParentFile == SurrogateProto3 {
return nil // surrogate files are not real parents
}
return d.L0.ParentFile
}
func (d *Base) Parent() protoreflect.Descriptor { return d.L0.Parent }
func (d *Base) Index() int { return d.L0.Index }
func (d *Base) Syntax() protoreflect.Syntax { return d.L0.ParentFile.Syntax() }
func (d *Base) IsPlaceholder() bool { return false }
func (d *Base) ProtoInternal(pragma.DoNotImplement) {}
type stringName struct {
hasJSON bool
once sync.Once
nameJSON string
nameText string
}
// InitJSON initializes the name. It is exported for use by other internal packages.
func (s *stringName) InitJSON(name string) {
s.hasJSON = true
s.nameJSON = name
}
// Returns true if this field is structured like the synthetic field of a proto2
// group. This allows us to expand our treatment of delimited fields without
// breaking proto2 files that have been upgraded to editions.
func isGroupLike(fd protoreflect.FieldDescriptor) bool {
// Groups are always group types.
if fd.Kind() != protoreflect.GroupKind {
return false
}
// Group fields are always the lowercase type name.
if strings.ToLower(string(fd.Message().Name())) != string(fd.Name()) {
return false
}
// Groups could only be defined in the same file they're used.
if fd.Message().ParentFile() != fd.ParentFile() {
return false
}
// Group messages are always defined in the same scope as the field. File
// level extensions will compare NULL == NULL here, which is why the file
// comparison above is necessary to ensure both come from the same file.
if fd.IsExtension() {
return fd.Parent() == fd.Message().Parent()
}
return fd.ContainingMessage() == fd.Message().Parent()
}
func (s *stringName) lazyInit(fd protoreflect.FieldDescriptor) *stringName {
s.once.Do(func() {
if fd.IsExtension() {
// For extensions, JSON and text are formatted the same way.
var name string
if messageset.IsMessageSetExtension(fd) {
name = string("[" + fd.FullName().Parent() + "]")
} else {
name = string("[" + fd.FullName() + "]")
}
s.nameJSON = name
s.nameText = name
} else {
// Format the JSON name.
if !s.hasJSON {
s.nameJSON = strs.JSONCamelCase(string(fd.Name()))
}
// Format the text name.
s.nameText = string(fd.Name())
if isGroupLike(fd) {
s.nameText = string(fd.Message().Name())
}
}
})
return s
}
func (s *stringName) getJSON(fd protoreflect.FieldDescriptor) string { return s.lazyInit(fd).nameJSON }
func (s *stringName) getText(fd protoreflect.FieldDescriptor) string { return s.lazyInit(fd).nameText }
func DefaultValue(v protoreflect.Value, ev protoreflect.EnumValueDescriptor) defaultValue {
dv := defaultValue{has: v.IsValid(), val: v, enum: ev}
if b, ok := v.Interface().([]byte); ok {
// Store a copy of the default bytes, so that we can detect
// accidental mutations of the original value.
dv.bytes = append([]byte(nil), b...)
}
return dv
}
func unmarshalDefault(b []byte, k protoreflect.Kind, pf *File, ed protoreflect.EnumDescriptor) defaultValue {
var evs protoreflect.EnumValueDescriptors
if k == protoreflect.EnumKind {
// If the enum is declared within the same file, be careful not to
// blindly call the Values method, lest we bind ourselves in a deadlock.
if e, ok := ed.(*Enum); ok && e.L0.ParentFile == pf {
evs = &e.L2.Values
} else {
evs = ed.Values()
}
// If we are unable to resolve the enum dependency, use a placeholder
// enum value since we will not be able to parse the default value.
if ed.IsPlaceholder() && protoreflect.Name(b).IsValid() {
v := protoreflect.ValueOfEnum(0)
ev := PlaceholderEnumValue(ed.FullName().Parent().Append(protoreflect.Name(b)))
return DefaultValue(v, ev)
}
}
v, ev, err := defval.Unmarshal(string(b), k, evs, defval.Descriptor)
if err != nil {
panic(err)
}
return DefaultValue(v, ev)
}
type defaultValue struct {
has bool
val protoreflect.Value
enum protoreflect.EnumValueDescriptor
bytes []byte
}
func (dv *defaultValue) get(fd protoreflect.FieldDescriptor) protoreflect.Value {
// Return the zero value as the default if unpopulated.
if !dv.has {
if fd.Cardinality() == protoreflect.Repeated {
return protoreflect.Value{}
}
switch fd.Kind() {
case protoreflect.BoolKind:
return protoreflect.ValueOfBool(false)
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
return protoreflect.ValueOfInt32(0)
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return protoreflect.ValueOfInt64(0)
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
return protoreflect.ValueOfUint32(0)
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return protoreflect.ValueOfUint64(0)
case protoreflect.FloatKind:
return protoreflect.ValueOfFloat32(0)
case protoreflect.DoubleKind:
return protoreflect.ValueOfFloat64(0)
case protoreflect.StringKind:
return protoreflect.ValueOfString("")
case protoreflect.BytesKind:
return protoreflect.ValueOfBytes(nil)
case protoreflect.EnumKind:
if evs := fd.Enum().Values(); evs.Len() > 0 {
return protoreflect.ValueOfEnum(evs.Get(0).Number())
}
return protoreflect.ValueOfEnum(0)
}
}
if len(dv.bytes) > 0 && !bytes.Equal(dv.bytes, dv.val.Bytes()) {
// TODO: Avoid panic if we're running with the race detector
// and instead spawn a goroutine that periodically resets
// this value back to the original to induce a race.
panic(fmt.Sprintf("detected mutation on the default bytes for %v", fd.FullName()))
}
return dv.val
}
// 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 filedesc
import (
"fmt"
"sync"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
// fileRaw is a data struct used when initializing a file descriptor from
// a raw FileDescriptorProto.
type fileRaw struct {
builder Builder
allEnums []Enum
allMessages []Message
allExtensions []Extension
allServices []Service
}
func newRawFile(db Builder) *File {
fd := &File{fileRaw: fileRaw{builder: db}}
fd.initDecls(db.NumEnums, db.NumMessages, db.NumExtensions, db.NumServices)
fd.unmarshalSeed(db.RawDescriptor)
// Extended message targets are eagerly resolved since registration
// needs this information at program init time.
for i := range fd.allExtensions {
xd := &fd.allExtensions[i]
xd.L1.Extendee = fd.resolveMessageDependency(xd.L1.Extendee, listExtTargets, int32(i))
}
fd.checkDecls()
return fd
}
// initDecls pre-allocates slices for the exact number of enums, messages
// (including map entries), extensions, and services declared in the proto file.
// This is done to avoid regrowing the slice, which would change the address
// for any previously seen declaration.
//
// The alloc methods "allocates" slices by pulling from the capacity.
func (fd *File) initDecls(numEnums, numMessages, numExtensions, numServices int32) {
fd.allEnums = make([]Enum, 0, numEnums)
fd.allMessages = make([]Message, 0, numMessages)
fd.allExtensions = make([]Extension, 0, numExtensions)
fd.allServices = make([]Service, 0, numServices)
}
func (fd *File) allocEnums(n int) []Enum {
total := len(fd.allEnums)
es := fd.allEnums[total : total+n]
fd.allEnums = fd.allEnums[:total+n]
return es
}
func (fd *File) allocMessages(n int) []Message {
total := len(fd.allMessages)
ms := fd.allMessages[total : total+n]
fd.allMessages = fd.allMessages[:total+n]
return ms
}
func (fd *File) allocExtensions(n int) []Extension {
total := len(fd.allExtensions)
xs := fd.allExtensions[total : total+n]
fd.allExtensions = fd.allExtensions[:total+n]
return xs
}
func (fd *File) allocServices(n int) []Service {
total := len(fd.allServices)
xs := fd.allServices[total : total+n]
fd.allServices = fd.allServices[:total+n]
return xs
}
// checkDecls performs a sanity check that the expected number of expected
// declarations matches the number that were found in the descriptor proto.
func (fd *File) checkDecls() {
switch {
case len(fd.allEnums) != cap(fd.allEnums):
case len(fd.allMessages) != cap(fd.allMessages):
case len(fd.allExtensions) != cap(fd.allExtensions):
case len(fd.allServices) != cap(fd.allServices):
default:
return
}
panic("mismatching cardinality")
}
func (fd *File) unmarshalSeed(b []byte) {
sb := getBuilder()
defer putBuilder(sb)
var prevField protoreflect.FieldNumber
var numEnums, numMessages, numExtensions, numServices int
var posEnums, posMessages, posExtensions, posServices int
var options []byte
b0 := b
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FileDescriptorProto_Syntax_field_number:
switch string(v) {
case "proto2":
fd.L1.Syntax = protoreflect.Proto2
fd.L1.Edition = EditionProto2
case "proto3":
fd.L1.Syntax = protoreflect.Proto3
fd.L1.Edition = EditionProto3
case "editions":
fd.L1.Syntax = protoreflect.Editions
default:
panic("invalid syntax")
}
case genid.FileDescriptorProto_Name_field_number:
fd.L1.Path = sb.MakeString(v)
case genid.FileDescriptorProto_Package_field_number:
fd.L1.Package = protoreflect.FullName(sb.MakeString(v))
case genid.FileDescriptorProto_Options_field_number:
options = v
case genid.FileDescriptorProto_EnumType_field_number:
if prevField != genid.FileDescriptorProto_EnumType_field_number {
if numEnums > 0 {
panic("non-contiguous repeated field")
}
posEnums = len(b0) - len(b) - n - m
}
numEnums++
case genid.FileDescriptorProto_MessageType_field_number:
if prevField != genid.FileDescriptorProto_MessageType_field_number {
if numMessages > 0 {
panic("non-contiguous repeated field")
}
posMessages = len(b0) - len(b) - n - m
}
numMessages++
case genid.FileDescriptorProto_Extension_field_number:
if prevField != genid.FileDescriptorProto_Extension_field_number {
if numExtensions > 0 {
panic("non-contiguous repeated field")
}
posExtensions = len(b0) - len(b) - n - m
}
numExtensions++
case genid.FileDescriptorProto_Service_field_number:
if prevField != genid.FileDescriptorProto_Service_field_number {
if numServices > 0 {
panic("non-contiguous repeated field")
}
posServices = len(b0) - len(b) - n - m
}
numServices++
}
prevField = num
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FileDescriptorProto_Edition_field_number:
fd.L1.Edition = Edition(v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
prevField = -1 // ignore known field numbers of unknown wire type
}
}
// If syntax is missing, it is assumed to be proto2.
if fd.L1.Syntax == 0 {
fd.L1.Syntax = protoreflect.Proto2
fd.L1.Edition = EditionProto2
}
fd.L1.EditionFeatures = getFeaturesFor(fd.L1.Edition)
// Parse editions features from options if any
if options != nil {
fd.unmarshalSeedOptions(options)
}
// Must allocate all declarations before parsing each descriptor type
// to ensure we handled all descriptors in "flattened ordering".
if numEnums > 0 {
fd.L1.Enums.List = fd.allocEnums(numEnums)
}
if numMessages > 0 {
fd.L1.Messages.List = fd.allocMessages(numMessages)
}
if numExtensions > 0 {
fd.L1.Extensions.List = fd.allocExtensions(numExtensions)
}
if numServices > 0 {
fd.L1.Services.List = fd.allocServices(numServices)
}
if numEnums > 0 {
b := b0[posEnums:]
for i := range fd.L1.Enums.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
fd.L1.Enums.List[i].unmarshalSeed(v, sb, fd, fd, i)
b = b[n+m:]
}
}
if numMessages > 0 {
b := b0[posMessages:]
for i := range fd.L1.Messages.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
fd.L1.Messages.List[i].unmarshalSeed(v, sb, fd, fd, i)
b = b[n+m:]
}
}
if numExtensions > 0 {
b := b0[posExtensions:]
for i := range fd.L1.Extensions.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
fd.L1.Extensions.List[i].unmarshalSeed(v, sb, fd, fd, i)
b = b[n+m:]
}
}
if numServices > 0 {
b := b0[posServices:]
for i := range fd.L1.Services.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
fd.L1.Services.List[i].unmarshalSeed(v, sb, fd, fd, i)
b = b[n+m:]
}
}
}
func (fd *File) unmarshalSeedOptions(b []byte) {
for b := b; len(b) > 0; {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FileOptions_Features_field_number:
if fd.Syntax() != protoreflect.Editions {
panic(fmt.Sprintf("invalid descriptor: using edition features in a proto with syntax %s", fd.Syntax()))
}
fd.L1.EditionFeatures = unmarshalFeatureSet(v, fd.L1.EditionFeatures)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
ed.L0.ParentFile = pf
ed.L0.Parent = pd
ed.L0.Index = i
ed.L1.EditionFeatures = featuresFromParentDesc(ed.Parent())
var numValues int
for b := b; len(b) > 0; {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.EnumDescriptorProto_Name_field_number:
ed.L0.FullName = appendFullName(sb, pd.FullName(), v)
case genid.EnumDescriptorProto_Value_field_number:
numValues++
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
// Only construct enum value descriptors for top-level enums since
// they are needed for registration.
if pd != pf {
return
}
ed.L1.eagerValues = true
ed.L2 = new(EnumL2)
ed.L2.Values.List = make([]EnumValue, numValues)
for i := 0; len(b) > 0; {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.EnumDescriptorProto_Value_field_number:
ed.L2.Values.List[i].unmarshalFull(v, sb, pf, ed, i)
i++
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (md *Message) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
md.L0.ParentFile = pf
md.L0.Parent = pd
md.L0.Index = i
md.L1.EditionFeatures = featuresFromParentDesc(md.Parent())
var prevField protoreflect.FieldNumber
var numEnums, numMessages, numExtensions int
var posEnums, posMessages, posExtensions int
b0 := b
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.DescriptorProto_Name_field_number:
md.L0.FullName = appendFullName(sb, pd.FullName(), v)
case genid.DescriptorProto_EnumType_field_number:
if prevField != genid.DescriptorProto_EnumType_field_number {
if numEnums > 0 {
panic("non-contiguous repeated field")
}
posEnums = len(b0) - len(b) - n - m
}
numEnums++
case genid.DescriptorProto_NestedType_field_number:
if prevField != genid.DescriptorProto_NestedType_field_number {
if numMessages > 0 {
panic("non-contiguous repeated field")
}
posMessages = len(b0) - len(b) - n - m
}
numMessages++
case genid.DescriptorProto_Extension_field_number:
if prevField != genid.DescriptorProto_Extension_field_number {
if numExtensions > 0 {
panic("non-contiguous repeated field")
}
posExtensions = len(b0) - len(b) - n - m
}
numExtensions++
case genid.DescriptorProto_Options_field_number:
md.unmarshalSeedOptions(v)
}
prevField = num
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
prevField = -1 // ignore known field numbers of unknown wire type
}
}
// Must allocate all declarations before parsing each descriptor type
// to ensure we handled all descriptors in "flattened ordering".
if numEnums > 0 {
md.L1.Enums.List = pf.allocEnums(numEnums)
}
if numMessages > 0 {
md.L1.Messages.List = pf.allocMessages(numMessages)
}
if numExtensions > 0 {
md.L1.Extensions.List = pf.allocExtensions(numExtensions)
}
if numEnums > 0 {
b := b0[posEnums:]
for i := range md.L1.Enums.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
md.L1.Enums.List[i].unmarshalSeed(v, sb, pf, md, i)
b = b[n+m:]
}
}
if numMessages > 0 {
b := b0[posMessages:]
for i := range md.L1.Messages.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
md.L1.Messages.List[i].unmarshalSeed(v, sb, pf, md, i)
b = b[n+m:]
}
}
if numExtensions > 0 {
b := b0[posExtensions:]
for i := range md.L1.Extensions.List {
_, n := protowire.ConsumeVarint(b)
v, m := protowire.ConsumeBytes(b[n:])
md.L1.Extensions.List[i].unmarshalSeed(v, sb, pf, md, i)
b = b[n+m:]
}
}
}
func (md *Message) unmarshalSeedOptions(b []byte) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.MessageOptions_MapEntry_field_number:
md.L1.IsMapEntry = protowire.DecodeBool(v)
case genid.MessageOptions_MessageSetWireFormat_field_number:
md.L1.IsMessageSet = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.MessageOptions_Features_field_number:
md.L1.EditionFeatures = unmarshalFeatureSet(v, md.L1.EditionFeatures)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
xd.L0.ParentFile = pf
xd.L0.Parent = pd
xd.L0.Index = i
xd.L1.EditionFeatures = featuresFromParentDesc(pd)
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FieldDescriptorProto_Number_field_number:
xd.L1.Number = protoreflect.FieldNumber(v)
case genid.FieldDescriptorProto_Label_field_number:
xd.L1.Cardinality = protoreflect.Cardinality(v)
case genid.FieldDescriptorProto_Type_field_number:
xd.L1.Kind = protoreflect.Kind(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FieldDescriptorProto_Name_field_number:
xd.L0.FullName = appendFullName(sb, pd.FullName(), v)
case genid.FieldDescriptorProto_Extendee_field_number:
xd.L1.Extendee = PlaceholderMessage(makeFullName(sb, v))
case genid.FieldDescriptorProto_Options_field_number:
xd.unmarshalOptions(v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if xd.L1.Kind == protoreflect.MessageKind && xd.L1.EditionFeatures.IsDelimitedEncoded {
xd.L1.Kind = protoreflect.GroupKind
}
}
func (xd *Extension) unmarshalOptions(b []byte) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FieldOptions_Packed_field_number:
xd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v)
case genid.FieldOptions_Lazy_field_number:
xd.L1.IsLazy = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FieldOptions_Features_field_number:
xd.L1.EditionFeatures = unmarshalFeatureSet(v, xd.L1.EditionFeatures)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
sd.L0.ParentFile = pf
sd.L0.Parent = pd
sd.L0.Index = i
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.ServiceDescriptorProto_Name_field_number:
sd.L0.FullName = appendFullName(sb, pd.FullName(), v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
var nameBuilderPool = sync.Pool{
New: func() any { return new(strs.Builder) },
}
func getBuilder() *strs.Builder {
return nameBuilderPool.Get().(*strs.Builder)
}
func putBuilder(b *strs.Builder) {
nameBuilderPool.Put(b)
}
// makeFullName converts b to a protoreflect.FullName,
// where b must start with a leading dot.
func makeFullName(sb *strs.Builder, b []byte) protoreflect.FullName {
if len(b) == 0 || b[0] != '.' {
panic("name reference must be fully qualified")
}
return protoreflect.FullName(sb.MakeString(b[1:]))
}
func appendFullName(sb *strs.Builder, prefix protoreflect.FullName, suffix []byte) protoreflect.FullName {
return sb.AppendFullName(prefix, protoreflect.Name(strs.UnsafeString(suffix)))
}
// 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 filedesc
import (
"reflect"
"sync"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/descopts"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
)
func (fd *File) lazyRawInit() {
fd.unmarshalFull(fd.builder.RawDescriptor)
fd.resolveMessages()
fd.resolveExtensions()
fd.resolveServices()
}
func (file *File) resolveMessages() {
var depIdx int32
for i := range file.allMessages {
md := &file.allMessages[i]
// Resolve message field dependencies.
for j := range md.L2.Fields.List {
fd := &md.L2.Fields.List[j]
// Resolve message field dependency.
switch fd.L1.Kind {
case protoreflect.EnumKind:
fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
depIdx++
case protoreflect.MessageKind, protoreflect.GroupKind:
fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
depIdx++
if fd.L1.Kind == protoreflect.GroupKind && (fd.IsMap() || fd.IsMapEntry()) {
// A map field might inherit delimited encoding from a file-wide default feature.
// But maps never actually use delimited encoding. (At least for now...)
fd.L1.Kind = protoreflect.MessageKind
}
}
// Default is resolved here since it depends on Enum being resolved.
if v := fd.L1.Default.val; v.IsValid() {
fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)
}
}
}
}
func (file *File) resolveExtensions() {
var depIdx int32
for i := range file.allExtensions {
xd := &file.allExtensions[i]
// Resolve extension field dependency.
switch xd.L1.Kind {
case protoreflect.EnumKind:
xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
depIdx++
case protoreflect.MessageKind, protoreflect.GroupKind:
xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
depIdx++
}
// Default is resolved here since it depends on Enum being resolved.
if v := xd.L2.Default.val; v.IsValid() {
xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)
}
}
}
func (file *File) resolveServices() {
var depIdx int32
for i := range file.allServices {
sd := &file.allServices[i]
// Resolve method dependencies.
for j := range sd.L2.Methods.List {
md := &sd.L2.Methods.List[j]
md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)
md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)
depIdx++
}
}
}
func (file *File) resolveEnumDependency(ed protoreflect.EnumDescriptor, i, j int32) protoreflect.EnumDescriptor {
r := file.builder.FileRegistry
if r, ok := r.(resolverByIndex); ok {
if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
return ed2
}
}
for i := range file.allEnums {
if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {
return ed2
}
}
if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
return d.(protoreflect.EnumDescriptor)
}
return ed
}
func (file *File) resolveMessageDependency(md protoreflect.MessageDescriptor, i, j int32) protoreflect.MessageDescriptor {
r := file.builder.FileRegistry
if r, ok := r.(resolverByIndex); ok {
if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
return md2
}
}
for i := range file.allMessages {
if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {
return md2
}
}
if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
return d.(protoreflect.MessageDescriptor)
}
return md
}
func (fd *File) unmarshalFull(b []byte) {
sb := getBuilder()
defer putBuilder(sb)
var enumIdx, messageIdx, extensionIdx, serviceIdx int
var rawOptions []byte
fd.L2 = new(FileL2)
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FileDescriptorProto_PublicDependency_field_number:
fd.L2.Imports[v].IsPublic = true
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FileDescriptorProto_Dependency_field_number:
path := sb.MakeString(v)
imp, _ := fd.builder.FileRegistry.FindFileByPath(path)
if imp == nil {
imp = PlaceholderFile(path)
}
fd.L2.Imports = append(fd.L2.Imports, protoreflect.FileImport{FileDescriptor: imp})
case genid.FileDescriptorProto_EnumType_field_number:
fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
enumIdx++
case genid.FileDescriptorProto_MessageType_field_number:
fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
messageIdx++
case genid.FileDescriptorProto_Extension_field_number:
fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
extensionIdx++
case genid.FileDescriptorProto_Service_field_number:
fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)
serviceIdx++
case genid.FileDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)
}
func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
var rawValues [][]byte
var rawOptions []byte
if !ed.L1.eagerValues {
ed.L2 = new(EnumL2)
}
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.EnumDescriptorProto_Value_field_number:
rawValues = append(rawValues, v)
case genid.EnumDescriptorProto_ReservedName_field_number:
ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
case genid.EnumDescriptorProto_ReservedRange_field_number:
ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
case genid.EnumDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if !ed.L1.eagerValues && len(rawValues) > 0 {
ed.L2.Values.List = make([]EnumValue, len(rawValues))
for i, b := range rawValues {
ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)
}
}
ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
}
func unmarshalEnumReservedRange(b []byte) (r [2]protoreflect.EnumNumber) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number:
r[0] = protoreflect.EnumNumber(v)
case genid.EnumDescriptorProto_EnumReservedRange_End_field_number:
r[1] = protoreflect.EnumNumber(v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
return r
}
func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
vd.L0.ParentFile = pf
vd.L0.Parent = pd
vd.L0.Index = i
var rawOptions []byte
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.EnumValueDescriptorProto_Number_field_number:
vd.L1.Number = protoreflect.EnumNumber(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.EnumValueDescriptorProto_Name_field_number:
// NOTE: Enum values are in the same scope as the enum parent.
vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)
case genid.EnumValueDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)
}
func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
var rawFields, rawOneofs [][]byte
var enumIdx, messageIdx, extensionIdx int
var rawOptions []byte
md.L2 = new(MessageL2)
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.DescriptorProto_Field_field_number:
rawFields = append(rawFields, v)
case genid.DescriptorProto_OneofDecl_field_number:
rawOneofs = append(rawOneofs, v)
case genid.DescriptorProto_ReservedName_field_number:
md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
case genid.DescriptorProto_ReservedRange_field_number:
md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
case genid.DescriptorProto_ExtensionRange_field_number:
r, rawOptions := unmarshalMessageExtensionRange(v)
opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)
md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)
md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)
case genid.DescriptorProto_EnumType_field_number:
md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
enumIdx++
case genid.DescriptorProto_NestedType_field_number:
md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
messageIdx++
case genid.DescriptorProto_Extension_field_number:
md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
extensionIdx++
case genid.DescriptorProto_Options_field_number:
md.unmarshalOptions(v)
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if len(rawFields) > 0 || len(rawOneofs) > 0 {
md.L2.Fields.List = make([]Field, len(rawFields))
md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))
for i, b := range rawFields {
fd := &md.L2.Fields.List[i]
fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
if fd.L1.Cardinality == protoreflect.Required {
md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
}
}
for i, b := range rawOneofs {
od := &md.L2.Oneofs.List[i]
od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
}
}
md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)
}
func (md *Message) unmarshalOptions(b []byte) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.MessageOptions_MapEntry_field_number:
md.L1.IsMapEntry = protowire.DecodeBool(v)
case genid.MessageOptions_MessageSetWireFormat_field_number:
md.L1.IsMessageSet = protowire.DecodeBool(v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func unmarshalMessageReservedRange(b []byte) (r [2]protoreflect.FieldNumber) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.DescriptorProto_ReservedRange_Start_field_number:
r[0] = protoreflect.FieldNumber(v)
case genid.DescriptorProto_ReservedRange_End_field_number:
r[1] = protoreflect.FieldNumber(v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
return r
}
func unmarshalMessageExtensionRange(b []byte) (r [2]protoreflect.FieldNumber, rawOptions []byte) {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.DescriptorProto_ExtensionRange_Start_field_number:
r[0] = protoreflect.FieldNumber(v)
case genid.DescriptorProto_ExtensionRange_End_field_number:
r[1] = protoreflect.FieldNumber(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.DescriptorProto_ExtensionRange_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
return r, rawOptions
}
func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
fd.L0.ParentFile = pf
fd.L0.Parent = pd
fd.L0.Index = i
fd.L1.EditionFeatures = featuresFromParentDesc(fd.Parent())
var rawTypeName []byte
var rawOptions []byte
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FieldDescriptorProto_Number_field_number:
fd.L1.Number = protoreflect.FieldNumber(v)
case genid.FieldDescriptorProto_Label_field_number:
fd.L1.Cardinality = protoreflect.Cardinality(v)
case genid.FieldDescriptorProto_Type_field_number:
fd.L1.Kind = protoreflect.Kind(v)
case genid.FieldDescriptorProto_OneofIndex_field_number:
// In Message.unmarshalFull, we allocate slices for both
// the field and oneof descriptors before unmarshaling either
// of them. This ensures pointers to slice elements are stable.
od := &pd.(*Message).L2.Oneofs.List[v]
od.L1.Fields.List = append(od.L1.Fields.List, fd)
if fd.L1.ContainingOneof != nil {
panic("oneof type already set")
}
fd.L1.ContainingOneof = od
case genid.FieldDescriptorProto_Proto3Optional_field_number:
fd.L1.IsProto3Optional = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FieldDescriptorProto_Name_field_number:
fd.L0.FullName = appendFullName(sb, pd.FullName(), v)
case genid.FieldDescriptorProto_JsonName_field_number:
fd.L1.StringName.InitJSON(sb.MakeString(v))
case genid.FieldDescriptorProto_DefaultValue_field_number:
fd.L1.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
case genid.FieldDescriptorProto_TypeName_field_number:
rawTypeName = v
case genid.FieldDescriptorProto_Options_field_number:
fd.unmarshalOptions(v)
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if fd.L1.Kind == protoreflect.MessageKind && fd.L1.EditionFeatures.IsDelimitedEncoded {
fd.L1.Kind = protoreflect.GroupKind
}
if fd.L1.EditionFeatures.IsLegacyRequired {
fd.L1.Cardinality = protoreflect.Required
}
if rawTypeName != nil {
name := makeFullName(sb, rawTypeName)
switch fd.L1.Kind {
case protoreflect.EnumKind:
fd.L1.Enum = PlaceholderEnum(name)
case protoreflect.MessageKind, protoreflect.GroupKind:
fd.L1.Message = PlaceholderMessage(name)
}
}
fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
}
func (fd *Field) unmarshalOptions(b []byte) {
const FieldOptions_EnforceUTF8 = 13
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FieldOptions_Packed_field_number:
fd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v)
case genid.FieldOptions_Lazy_field_number:
fd.L1.IsLazy = protowire.DecodeBool(v)
case FieldOptions_EnforceUTF8:
fd.L1.EditionFeatures.IsUTF8Validated = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FieldOptions_Features_field_number:
fd.L1.EditionFeatures = unmarshalFeatureSet(v, fd.L1.EditionFeatures)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
od.L0.ParentFile = pf
od.L0.Parent = pd
od.L0.Index = i
var rawOptions []byte
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.OneofDescriptorProto_Name_field_number:
od.L0.FullName = appendFullName(sb, pd.FullName(), v)
case genid.OneofDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
od.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Oneof, rawOptions)
}
func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
var rawTypeName []byte
var rawOptions []byte
xd.L2 = new(ExtensionL2)
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FieldDescriptorProto_Proto3Optional_field_number:
xd.L2.IsProto3Optional = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FieldDescriptorProto_JsonName_field_number:
xd.L2.StringName.InitJSON(sb.MakeString(v))
case genid.FieldDescriptorProto_DefaultValue_field_number:
xd.L2.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
case genid.FieldDescriptorProto_TypeName_field_number:
rawTypeName = v
case genid.FieldDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if rawTypeName != nil {
name := makeFullName(sb, rawTypeName)
switch xd.L1.Kind {
case protoreflect.EnumKind:
xd.L2.Enum = PlaceholderEnum(name)
case protoreflect.MessageKind, protoreflect.GroupKind:
xd.L2.Message = PlaceholderMessage(name)
}
}
xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
}
func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
var rawMethods [][]byte
var rawOptions []byte
sd.L2 = new(ServiceL2)
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.ServiceDescriptorProto_Method_field_number:
rawMethods = append(rawMethods, v)
case genid.ServiceDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if len(rawMethods) > 0 {
sd.L2.Methods.List = make([]Method, len(rawMethods))
for i, b := range rawMethods {
sd.L2.Methods.List[i].unmarshalFull(b, sb, sd.L0.ParentFile, sd, i)
}
}
sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
}
func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
md.L0.ParentFile = pf
md.L0.Parent = pd
md.L0.Index = i
var rawOptions []byte
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.MethodDescriptorProto_ClientStreaming_field_number:
md.L1.IsStreamingClient = protowire.DecodeBool(v)
case genid.MethodDescriptorProto_ServerStreaming_field_number:
md.L1.IsStreamingServer = protowire.DecodeBool(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.MethodDescriptorProto_Name_field_number:
md.L0.FullName = appendFullName(sb, pd.FullName(), v)
case genid.MethodDescriptorProto_InputType_field_number:
md.L1.Input = PlaceholderMessage(makeFullName(sb, v))
case genid.MethodDescriptorProto_OutputType_field_number:
md.L1.Output = PlaceholderMessage(makeFullName(sb, v))
case genid.MethodDescriptorProto_Options_field_number:
rawOptions = appendOptions(rawOptions, v)
}
default:
m := protowire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
md.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Method, rawOptions)
}
// appendOptions appends src to dst, where the returned slice is never nil.
// This is necessary to distinguish between empty and unpopulated options.
func appendOptions(dst, src []byte) []byte {
if dst == nil {
dst = []byte{}
}
return append(dst, src...)
}
// optionsUnmarshaler constructs a lazy unmarshal function for an options message.
//
// The type of message to unmarshal to is passed as a pointer since the
// vars in descopts may not yet be populated at the time this function is called.
func (db *Builder) optionsUnmarshaler(p *protoreflect.ProtoMessage, b []byte) func() protoreflect.ProtoMessage {
if b == nil {
return nil
}
var opts protoreflect.ProtoMessage
var once sync.Once
return func() protoreflect.ProtoMessage {
once.Do(func() {
if *p == nil {
panic("Descriptor.Options called without importing the descriptor package")
}
opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(protoreflect.ProtoMessage)
if err := (proto.UnmarshalOptions{
AllowPartial: true,
Resolver: db.TypeResolver,
}).Unmarshal(b, opts); err != nil {
panic(err)
}
})
return opts
}
}
// 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 filedesc
import (
"fmt"
"math"
"sort"
"sync"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/descfmt"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
)
type FileImports []protoreflect.FileImport
func (p *FileImports) Len() int { return len(*p) }
func (p *FileImports) Get(i int) protoreflect.FileImport { return (*p)[i] }
func (p *FileImports) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}
type Names struct {
List []protoreflect.Name
once sync.Once
has map[protoreflect.Name]int // protected by once
}
func (p *Names) Len() int { return len(p.List) }
func (p *Names) Get(i int) protoreflect.Name { return p.List[i] }
func (p *Names) Has(s protoreflect.Name) bool { return p.lazyInit().has[s] > 0 }
func (p *Names) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *Names) ProtoInternal(pragma.DoNotImplement) {}
func (p *Names) lazyInit() *Names {
p.once.Do(func() {
if len(p.List) > 0 {
p.has = make(map[protoreflect.Name]int, len(p.List))
for _, s := range p.List {
p.has[s] = p.has[s] + 1
}
}
})
return p
}
// CheckValid reports any errors with the set of names with an error message
// that completes the sentence: "ranges is invalid because it has ..."
func (p *Names) CheckValid() error {
for s, n := range p.lazyInit().has {
switch {
case n > 1:
return errors.New("duplicate name: %q", s)
case false && !s.IsValid():
// NOTE: The C++ implementation does not validate the identifier.
// See https://github.com/protocolbuffers/protobuf/issues/6335.
return errors.New("invalid name: %q", s)
}
}
return nil
}
type EnumRanges struct {
List [][2]protoreflect.EnumNumber // start inclusive; end inclusive
once sync.Once
sorted [][2]protoreflect.EnumNumber // protected by once
}
func (p *EnumRanges) Len() int { return len(p.List) }
func (p *EnumRanges) Get(i int) [2]protoreflect.EnumNumber { return p.List[i] }
func (p *EnumRanges) Has(n protoreflect.EnumNumber) bool {
for ls := p.lazyInit().sorted; len(ls) > 0; {
i := len(ls) / 2
switch r := enumRange(ls[i]); {
case n < r.Start():
ls = ls[:i] // search lower
case n > r.End():
ls = ls[i+1:] // search upper
default:
return true
}
}
return false
}
func (p *EnumRanges) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *EnumRanges) ProtoInternal(pragma.DoNotImplement) {}
func (p *EnumRanges) lazyInit() *EnumRanges {
p.once.Do(func() {
p.sorted = append(p.sorted, p.List...)
sort.Slice(p.sorted, func(i, j int) bool {
return p.sorted[i][0] < p.sorted[j][0]
})
})
return p
}
// CheckValid reports any errors with the set of names with an error message
// that completes the sentence: "ranges is invalid because it has ..."
func (p *EnumRanges) CheckValid() error {
var rp enumRange
for i, r := range p.lazyInit().sorted {
r := enumRange(r)
switch {
case !(r.Start() <= r.End()):
return errors.New("invalid range: %v", r)
case !(rp.End() < r.Start()) && i > 0:
return errors.New("overlapping ranges: %v with %v", rp, r)
}
rp = r
}
return nil
}
type enumRange [2]protoreflect.EnumNumber
func (r enumRange) Start() protoreflect.EnumNumber { return r[0] } // inclusive
func (r enumRange) End() protoreflect.EnumNumber { return r[1] } // inclusive
func (r enumRange) String() string {
if r.Start() == r.End() {
return fmt.Sprintf("%d", r.Start())
}
return fmt.Sprintf("%d to %d", r.Start(), r.End())
}
type FieldRanges struct {
List [][2]protoreflect.FieldNumber // start inclusive; end exclusive
once sync.Once
sorted [][2]protoreflect.FieldNumber // protected by once
}
func (p *FieldRanges) Len() int { return len(p.List) }
func (p *FieldRanges) Get(i int) [2]protoreflect.FieldNumber { return p.List[i] }
func (p *FieldRanges) Has(n protoreflect.FieldNumber) bool {
for ls := p.lazyInit().sorted; len(ls) > 0; {
i := len(ls) / 2
switch r := fieldRange(ls[i]); {
case n < r.Start():
ls = ls[:i] // search lower
case n > r.End():
ls = ls[i+1:] // search upper
default:
return true
}
}
return false
}
func (p *FieldRanges) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *FieldRanges) ProtoInternal(pragma.DoNotImplement) {}
func (p *FieldRanges) lazyInit() *FieldRanges {
p.once.Do(func() {
p.sorted = append(p.sorted, p.List...)
sort.Slice(p.sorted, func(i, j int) bool {
return p.sorted[i][0] < p.sorted[j][0]
})
})
return p
}
// CheckValid reports any errors with the set of ranges with an error message
// that completes the sentence: "ranges is invalid because it has ..."
func (p *FieldRanges) CheckValid(isMessageSet bool) error {
var rp fieldRange
for i, r := range p.lazyInit().sorted {
r := fieldRange(r)
switch {
case !isValidFieldNumber(r.Start(), isMessageSet):
return errors.New("invalid field number: %d", r.Start())
case !isValidFieldNumber(r.End(), isMessageSet):
return errors.New("invalid field number: %d", r.End())
case !(r.Start() <= r.End()):
return errors.New("invalid range: %v", r)
case !(rp.End() < r.Start()) && i > 0:
return errors.New("overlapping ranges: %v with %v", rp, r)
}
rp = r
}
return nil
}
// isValidFieldNumber reports whether the field number is valid.
// Unlike the FieldNumber.IsValid method, it allows ranges that cover the
// reserved number range.
func isValidFieldNumber(n protoreflect.FieldNumber, isMessageSet bool) bool {
return protowire.MinValidNumber <= n && (n <= protowire.MaxValidNumber || isMessageSet)
}
// CheckOverlap reports an error if p and q overlap.
func (p *FieldRanges) CheckOverlap(q *FieldRanges) error {
rps := p.lazyInit().sorted
rqs := q.lazyInit().sorted
for pi, qi := 0, 0; pi < len(rps) && qi < len(rqs); {
rp := fieldRange(rps[pi])
rq := fieldRange(rqs[qi])
if !(rp.End() < rq.Start() || rq.End() < rp.Start()) {
return errors.New("overlapping ranges: %v with %v", rp, rq)
}
if rp.Start() < rq.Start() {
pi++
} else {
qi++
}
}
return nil
}
type fieldRange [2]protoreflect.FieldNumber
func (r fieldRange) Start() protoreflect.FieldNumber { return r[0] } // inclusive
func (r fieldRange) End() protoreflect.FieldNumber { return r[1] - 1 } // inclusive
func (r fieldRange) String() string {
if r.Start() == r.End() {
return fmt.Sprintf("%d", r.Start())
}
return fmt.Sprintf("%d to %d", r.Start(), r.End())
}
type FieldNumbers struct {
List []protoreflect.FieldNumber
once sync.Once
has map[protoreflect.FieldNumber]struct{} // protected by once
}
func (p *FieldNumbers) Len() int { return len(p.List) }
func (p *FieldNumbers) Get(i int) protoreflect.FieldNumber { return p.List[i] }
func (p *FieldNumbers) Has(n protoreflect.FieldNumber) bool {
p.once.Do(func() {
if len(p.List) > 0 {
p.has = make(map[protoreflect.FieldNumber]struct{}, len(p.List))
for _, n := range p.List {
p.has[n] = struct{}{}
}
}
})
_, ok := p.has[n]
return ok
}
func (p *FieldNumbers) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}
type OneofFields struct {
List []protoreflect.FieldDescriptor
once sync.Once
byName map[protoreflect.Name]protoreflect.FieldDescriptor // protected by once
byJSON map[string]protoreflect.FieldDescriptor // protected by once
byText map[string]protoreflect.FieldDescriptor // protected by once
byNum map[protoreflect.FieldNumber]protoreflect.FieldDescriptor // protected by once
}
func (p *OneofFields) Len() int { return len(p.List) }
func (p *OneofFields) Get(i int) protoreflect.FieldDescriptor { return p.List[i] }
func (p *OneofFields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
return p.lazyInit().byName[s]
}
func (p *OneofFields) ByJSONName(s string) protoreflect.FieldDescriptor {
return p.lazyInit().byJSON[s]
}
func (p *OneofFields) ByTextName(s string) protoreflect.FieldDescriptor {
return p.lazyInit().byText[s]
}
func (p *OneofFields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
return p.lazyInit().byNum[n]
}
func (p *OneofFields) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *OneofFields) ProtoInternal(pragma.DoNotImplement) {}
func (p *OneofFields) lazyInit() *OneofFields {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]protoreflect.FieldDescriptor, len(p.List))
p.byJSON = make(map[string]protoreflect.FieldDescriptor, len(p.List))
p.byText = make(map[string]protoreflect.FieldDescriptor, len(p.List))
p.byNum = make(map[protoreflect.FieldNumber]protoreflect.FieldDescriptor, len(p.List))
for _, f := range p.List {
// Field names and numbers are guaranteed to be unique.
p.byName[f.Name()] = f
p.byJSON[f.JSONName()] = f
p.byText[f.TextName()] = f
p.byNum[f.Number()] = f
}
}
})
return p
}
type SourceLocations struct {
// List is a list of SourceLocations.
// The SourceLocation.Next field does not need to be populated
// as it will be lazily populated upon first need.
List []protoreflect.SourceLocation
// File is the parent file descriptor that these locations are relative to.
// If non-nil, ByDescriptor verifies that the provided descriptor
// is a child of this file descriptor.
File protoreflect.FileDescriptor
once sync.Once
byPath map[pathKey]int
}
func (p *SourceLocations) Len() int { return len(p.List) }
func (p *SourceLocations) Get(i int) protoreflect.SourceLocation { return p.lazyInit().List[i] }
func (p *SourceLocations) byKey(k pathKey) protoreflect.SourceLocation {
if i, ok := p.lazyInit().byPath[k]; ok {
return p.List[i]
}
return protoreflect.SourceLocation{}
}
func (p *SourceLocations) ByPath(path protoreflect.SourcePath) protoreflect.SourceLocation {
return p.byKey(newPathKey(path))
}
func (p *SourceLocations) ByDescriptor(desc protoreflect.Descriptor) protoreflect.SourceLocation {
if p.File != nil && desc != nil && p.File != desc.ParentFile() {
return protoreflect.SourceLocation{} // mismatching parent files
}
var pathArr [16]int32
path := pathArr[:0]
for {
switch desc.(type) {
case protoreflect.FileDescriptor:
// Reverse the path since it was constructed in reverse.
for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {
path[i], path[j] = path[j], path[i]
}
return p.byKey(newPathKey(path))
case protoreflect.MessageDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_MessageType_field_number))
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_NestedType_field_number))
default:
return protoreflect.SourceLocation{}
}
case protoreflect.FieldDescriptor:
isExtension := desc.(protoreflect.FieldDescriptor).IsExtension()
path = append(path, int32(desc.Index()))
desc = desc.Parent()
if isExtension {
switch desc.(type) {
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_Extension_field_number))
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_Extension_field_number))
default:
return protoreflect.SourceLocation{}
}
} else {
switch desc.(type) {
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_Field_field_number))
default:
return protoreflect.SourceLocation{}
}
}
case protoreflect.OneofDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_OneofDecl_field_number))
default:
return protoreflect.SourceLocation{}
}
case protoreflect.EnumDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_EnumType_field_number))
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_EnumType_field_number))
default:
return protoreflect.SourceLocation{}
}
case protoreflect.EnumValueDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case protoreflect.EnumDescriptor:
path = append(path, int32(genid.EnumDescriptorProto_Value_field_number))
default:
return protoreflect.SourceLocation{}
}
case protoreflect.ServiceDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_Service_field_number))
default:
return protoreflect.SourceLocation{}
}
case protoreflect.MethodDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case protoreflect.ServiceDescriptor:
path = append(path, int32(genid.ServiceDescriptorProto_Method_field_number))
default:
return protoreflect.SourceLocation{}
}
default:
return protoreflect.SourceLocation{}
}
}
}
func (p *SourceLocations) lazyInit() *SourceLocations {
p.once.Do(func() {
if len(p.List) > 0 {
// Collect all the indexes for a given path.
pathIdxs := make(map[pathKey][]int, len(p.List))
for i, l := range p.List {
k := newPathKey(l.Path)
pathIdxs[k] = append(pathIdxs[k], i)
}
// Update the next index for all locations.
p.byPath = make(map[pathKey]int, len(p.List))
for k, idxs := range pathIdxs {
for i := 0; i < len(idxs)-1; i++ {
p.List[idxs[i]].Next = idxs[i+1]
}
p.List[idxs[len(idxs)-1]].Next = 0
p.byPath[k] = idxs[0] // record the first location for this path
}
}
})
return p
}
func (p *SourceLocations) ProtoInternal(pragma.DoNotImplement) {}
// pathKey is a comparable representation of protoreflect.SourcePath.
type pathKey struct {
arr [16]uint8 // first n-1 path segments; last element is the length
str string // used if the path does not fit in arr
}
func newPathKey(p protoreflect.SourcePath) (k pathKey) {
if len(p) < len(k.arr) {
for i, ps := range p {
if ps < 0 || math.MaxUint8 <= ps {
return pathKey{str: p.String()}
}
k.arr[i] = uint8(ps)
}
k.arr[len(k.arr)-1] = uint8(len(p))
return k
}
return pathKey{str: p.String()}
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package filedesc
import (
"fmt"
"strings"
"sync"
"google.golang.org/protobuf/internal/descfmt"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
)
type Enums struct {
List []Enum
once sync.Once
byName map[protoreflect.Name]*Enum // protected by once
}
func (p *Enums) Len() int {
return len(p.List)
}
func (p *Enums) Get(i int) protoreflect.EnumDescriptor {
return &p.List[i]
}
func (p *Enums) ByName(s protoreflect.Name) protoreflect.EnumDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Enums) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Enums) ProtoInternal(pragma.DoNotImplement) {}
func (p *Enums) lazyInit() *Enums {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Enum, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
}
}
})
return p
}
type EnumValues struct {
List []EnumValue
once sync.Once
byName map[protoreflect.Name]*EnumValue // protected by once
byNum map[protoreflect.EnumNumber]*EnumValue // protected by once
}
func (p *EnumValues) Len() int {
return len(p.List)
}
func (p *EnumValues) Get(i int) protoreflect.EnumValueDescriptor {
return &p.List[i]
}
func (p *EnumValues) ByName(s protoreflect.Name) protoreflect.EnumValueDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *EnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
if d := p.lazyInit().byNum[n]; d != nil {
return d
}
return nil
}
func (p *EnumValues) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *EnumValues) ProtoInternal(pragma.DoNotImplement) {}
func (p *EnumValues) lazyInit() *EnumValues {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*EnumValue, len(p.List))
p.byNum = make(map[protoreflect.EnumNumber]*EnumValue, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
if _, ok := p.byNum[d.Number()]; !ok {
p.byNum[d.Number()] = d
}
}
}
})
return p
}
type Messages struct {
List []Message
once sync.Once
byName map[protoreflect.Name]*Message // protected by once
}
func (p *Messages) Len() int {
return len(p.List)
}
func (p *Messages) Get(i int) protoreflect.MessageDescriptor {
return &p.List[i]
}
func (p *Messages) ByName(s protoreflect.Name) protoreflect.MessageDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Messages) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Messages) ProtoInternal(pragma.DoNotImplement) {}
func (p *Messages) lazyInit() *Messages {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Message, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
}
}
})
return p
}
type Fields struct {
List []Field
once sync.Once
byName map[protoreflect.Name]*Field // protected by once
byJSON map[string]*Field // protected by once
byText map[string]*Field // protected by once
byNum map[protoreflect.FieldNumber]*Field // protected by once
}
func (p *Fields) Len() int {
return len(p.List)
}
func (p *Fields) Get(i int) protoreflect.FieldDescriptor {
return &p.List[i]
}
func (p *Fields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Fields) ByJSONName(s string) protoreflect.FieldDescriptor {
if d := p.lazyInit().byJSON[s]; d != nil {
return d
}
return nil
}
func (p *Fields) ByTextName(s string) protoreflect.FieldDescriptor {
if d := p.lazyInit().byText[s]; d != nil {
return d
}
return nil
}
func (p *Fields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
if d := p.lazyInit().byNum[n]; d != nil {
return d
}
return nil
}
func (p *Fields) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Fields) ProtoInternal(pragma.DoNotImplement) {}
func (p *Fields) lazyInit() *Fields {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Field, len(p.List))
p.byJSON = make(map[string]*Field, len(p.List))
p.byText = make(map[string]*Field, len(p.List))
p.byNum = make(map[protoreflect.FieldNumber]*Field, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
if _, ok := p.byJSON[d.JSONName()]; !ok {
p.byJSON[d.JSONName()] = d
}
if _, ok := p.byText[d.TextName()]; !ok {
p.byText[d.TextName()] = d
}
if isGroupLike(d) {
lowerJSONName := strings.ToLower(d.JSONName())
if _, ok := p.byJSON[lowerJSONName]; !ok {
p.byJSON[lowerJSONName] = d
}
lowerTextName := strings.ToLower(d.TextName())
if _, ok := p.byText[lowerTextName]; !ok {
p.byText[lowerTextName] = d
}
}
if _, ok := p.byNum[d.Number()]; !ok {
p.byNum[d.Number()] = d
}
}
}
})
return p
}
type Oneofs struct {
List []Oneof
once sync.Once
byName map[protoreflect.Name]*Oneof // protected by once
}
func (p *Oneofs) Len() int {
return len(p.List)
}
func (p *Oneofs) Get(i int) protoreflect.OneofDescriptor {
return &p.List[i]
}
func (p *Oneofs) ByName(s protoreflect.Name) protoreflect.OneofDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Oneofs) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Oneofs) ProtoInternal(pragma.DoNotImplement) {}
func (p *Oneofs) lazyInit() *Oneofs {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Oneof, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
}
}
})
return p
}
type Extensions struct {
List []Extension
once sync.Once
byName map[protoreflect.Name]*Extension // protected by once
}
func (p *Extensions) Len() int {
return len(p.List)
}
func (p *Extensions) Get(i int) protoreflect.ExtensionDescriptor {
return &p.List[i]
}
func (p *Extensions) ByName(s protoreflect.Name) protoreflect.ExtensionDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Extensions) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Extensions) ProtoInternal(pragma.DoNotImplement) {}
func (p *Extensions) lazyInit() *Extensions {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Extension, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
}
}
})
return p
}
type Services struct {
List []Service
once sync.Once
byName map[protoreflect.Name]*Service // protected by once
}
func (p *Services) Len() int {
return len(p.List)
}
func (p *Services) Get(i int) protoreflect.ServiceDescriptor {
return &p.List[i]
}
func (p *Services) ByName(s protoreflect.Name) protoreflect.ServiceDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Services) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Services) ProtoInternal(pragma.DoNotImplement) {}
func (p *Services) lazyInit() *Services {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Service, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
}
}
})
return p
}
type Methods struct {
List []Method
once sync.Once
byName map[protoreflect.Name]*Method // protected by once
}
func (p *Methods) Len() int {
return len(p.List)
}
func (p *Methods) Get(i int) protoreflect.MethodDescriptor {
return &p.List[i]
}
func (p *Methods) ByName(s protoreflect.Name) protoreflect.MethodDescriptor {
if d := p.lazyInit().byName[s]; d != nil {
return d
}
return nil
}
func (p *Methods) Format(s fmt.State, r rune) {
descfmt.FormatList(s, r, p)
}
func (p *Methods) ProtoInternal(pragma.DoNotImplement) {}
func (p *Methods) lazyInit() *Methods {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[protoreflect.Name]*Method, len(p.List))
for i := range p.List {
d := &p.List[i]
if _, ok := p.byName[d.Name()]; !ok {
p.byName[d.Name()] = d
}
}
}
})
return p
}
// Copyright 2024 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 filedesc
import (
"fmt"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/editiondefaults"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect"
)
var defaultsCache = make(map[Edition]EditionFeatures)
var defaultsKeys = []Edition{}
func init() {
unmarshalEditionDefaults(editiondefaults.Defaults)
SurrogateProto2.L1.EditionFeatures = getFeaturesFor(EditionProto2)
SurrogateProto3.L1.EditionFeatures = getFeaturesFor(EditionProto3)
SurrogateEdition2023.L1.EditionFeatures = getFeaturesFor(Edition2023)
}
func unmarshalGoFeature(b []byte, parent EditionFeatures) EditionFeatures {
for len(b) > 0 {
num, _, n := protowire.ConsumeTag(b)
b = b[n:]
switch num {
case genid.GoFeatures_LegacyUnmarshalJsonEnum_field_number:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
parent.GenerateLegacyUnmarshalJSON = protowire.DecodeBool(v)
case genid.GoFeatures_ApiLevel_field_number:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
parent.APILevel = int(v)
case genid.GoFeatures_StripEnumPrefix_field_number:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
parent.StripEnumPrefix = int(v)
default:
panic(fmt.Sprintf("unkown field number %d while unmarshalling GoFeatures", num))
}
}
return parent
}
func unmarshalFeatureSet(b []byte, parent EditionFeatures) EditionFeatures {
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FeatureSet_FieldPresence_field_number:
parent.IsFieldPresence = v == genid.FeatureSet_EXPLICIT_enum_value || v == genid.FeatureSet_LEGACY_REQUIRED_enum_value
parent.IsLegacyRequired = v == genid.FeatureSet_LEGACY_REQUIRED_enum_value
case genid.FeatureSet_EnumType_field_number:
parent.IsOpenEnum = v == genid.FeatureSet_OPEN_enum_value
case genid.FeatureSet_RepeatedFieldEncoding_field_number:
parent.IsPacked = v == genid.FeatureSet_PACKED_enum_value
case genid.FeatureSet_Utf8Validation_field_number:
parent.IsUTF8Validated = v == genid.FeatureSet_VERIFY_enum_value
case genid.FeatureSet_MessageEncoding_field_number:
parent.IsDelimitedEncoded = v == genid.FeatureSet_DELIMITED_enum_value
case genid.FeatureSet_JsonFormat_field_number:
parent.IsJSONCompliant = v == genid.FeatureSet_ALLOW_enum_value
case genid.FeatureSet_EnforceNamingStyle_field_number:
// EnforceNamingStyle is enforced in protoc, languages other than C++
// are not supposed to do anything with this feature.
case genid.FeatureSet_DefaultSymbolVisibility_field_number:
// DefaultSymbolVisibility is enforced in protoc, runtimes should not
// inspect this value.
default:
panic(fmt.Sprintf("unkown field number %d while unmarshalling FeatureSet", num))
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FeatureSet_Go_ext_number:
parent = unmarshalGoFeature(v, parent)
}
}
}
return parent
}
func featuresFromParentDesc(parentDesc protoreflect.Descriptor) EditionFeatures {
var parentFS EditionFeatures
switch p := parentDesc.(type) {
case *File:
parentFS = p.L1.EditionFeatures
case *Message:
parentFS = p.L1.EditionFeatures
default:
panic(fmt.Sprintf("unknown parent type %T", parentDesc))
}
return parentFS
}
func unmarshalEditionDefault(b []byte) {
var ed Edition
var fs EditionFeatures
for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b)
b = b[n:]
switch typ {
case protowire.VarintType:
v, m := protowire.ConsumeVarint(b)
b = b[m:]
switch num {
case genid.FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_number:
ed = Edition(v)
}
case protowire.BytesType:
v, m := protowire.ConsumeBytes(b)
b = b[m:]
switch num {
case genid.FeatureSetDefaults_FeatureSetEditionDefault_FixedFeatures_field_number:
fs = unmarshalFeatureSet(v, fs)
case genid.FeatureSetDefaults_FeatureSetEditionDefault_OverridableFeatures_field_number:
fs = unmarshalFeatureSet(v, fs)
}
}
}
defaultsCache[ed] = fs
defaultsKeys = append(defaultsKeys, ed)
}
func unmarshalEditionDefaults(b []byte) {
for len(b) > 0 {
num, _, n := protowire.ConsumeTag(b)
b = b[n:]
switch num {
case genid.FeatureSetDefaults_Defaults_field_number:
def, m := protowire.ConsumeBytes(b)
b = b[m:]
unmarshalEditionDefault(def)
case genid.FeatureSetDefaults_MinimumEdition_field_number,
genid.FeatureSetDefaults_MaximumEdition_field_number:
// We don't care about the minimum and maximum editions. If the
// edition we are looking for later on is not in the cache we know
// it is outside of the range between minimum and maximum edition.
_, m := protowire.ConsumeVarint(b)
b = b[m:]
default:
panic(fmt.Sprintf("unkown field number %d while unmarshalling EditionDefault", num))
}
}
}
func getFeaturesFor(ed Edition) EditionFeatures {
match := EditionUnknown
for _, key := range defaultsKeys {
if key > ed {
break
}
match = key
}
if match == EditionUnknown {
panic(fmt.Sprintf("unsupported edition: %v", ed))
}
return defaultsCache[match]
}
// 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 filedesc
import (
"google.golang.org/protobuf/internal/descopts"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
)
var (
emptyNames = new(Names)
emptyEnumRanges = new(EnumRanges)
emptyFieldRanges = new(FieldRanges)
emptyFieldNumbers = new(FieldNumbers)
emptySourceLocations = new(SourceLocations)
emptyFiles = new(FileImports)
emptyMessages = new(Messages)
emptyFields = new(Fields)
emptyOneofs = new(Oneofs)
emptyEnums = new(Enums)
emptyEnumValues = new(EnumValues)
emptyExtensions = new(Extensions)
emptyServices = new(Services)
)
// PlaceholderFile is a placeholder, representing only the file path.
type PlaceholderFile string
func (f PlaceholderFile) ParentFile() protoreflect.FileDescriptor { return f }
func (f PlaceholderFile) Parent() protoreflect.Descriptor { return nil }
func (f PlaceholderFile) Index() int { return 0 }
func (f PlaceholderFile) Syntax() protoreflect.Syntax { return 0 }
func (f PlaceholderFile) Name() protoreflect.Name { return "" }
func (f PlaceholderFile) FullName() protoreflect.FullName { return "" }
func (f PlaceholderFile) IsPlaceholder() bool { return true }
func (f PlaceholderFile) Options() protoreflect.ProtoMessage { return descopts.File }
func (f PlaceholderFile) Path() string { return string(f) }
func (f PlaceholderFile) Package() protoreflect.FullName { return "" }
func (f PlaceholderFile) Imports() protoreflect.FileImports { return emptyFiles }
func (f PlaceholderFile) Messages() protoreflect.MessageDescriptors { return emptyMessages }
func (f PlaceholderFile) Enums() protoreflect.EnumDescriptors { return emptyEnums }
func (f PlaceholderFile) Extensions() protoreflect.ExtensionDescriptors { return emptyExtensions }
func (f PlaceholderFile) Services() protoreflect.ServiceDescriptors { return emptyServices }
func (f PlaceholderFile) SourceLocations() protoreflect.SourceLocations { return emptySourceLocations }
func (f PlaceholderFile) ProtoType(protoreflect.FileDescriptor) { return }
func (f PlaceholderFile) ProtoInternal(pragma.DoNotImplement) { return }
// PlaceholderEnum is a placeholder, representing only the full name.
type PlaceholderEnum protoreflect.FullName
func (e PlaceholderEnum) ParentFile() protoreflect.FileDescriptor { return nil }
func (e PlaceholderEnum) Parent() protoreflect.Descriptor { return nil }
func (e PlaceholderEnum) Index() int { return 0 }
func (e PlaceholderEnum) Syntax() protoreflect.Syntax { return 0 }
func (e PlaceholderEnum) Name() protoreflect.Name { return protoreflect.FullName(e).Name() }
func (e PlaceholderEnum) FullName() protoreflect.FullName { return protoreflect.FullName(e) }
func (e PlaceholderEnum) IsPlaceholder() bool { return true }
func (e PlaceholderEnum) Options() protoreflect.ProtoMessage { return descopts.Enum }
func (e PlaceholderEnum) Values() protoreflect.EnumValueDescriptors { return emptyEnumValues }
func (e PlaceholderEnum) ReservedNames() protoreflect.Names { return emptyNames }
func (e PlaceholderEnum) ReservedRanges() protoreflect.EnumRanges { return emptyEnumRanges }
func (e PlaceholderEnum) IsClosed() bool { return false }
func (e PlaceholderEnum) ProtoType(protoreflect.EnumDescriptor) { return }
func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return }
// PlaceholderEnumValue is a placeholder, representing only the full name.
type PlaceholderEnumValue protoreflect.FullName
func (e PlaceholderEnumValue) ParentFile() protoreflect.FileDescriptor { return nil }
func (e PlaceholderEnumValue) Parent() protoreflect.Descriptor { return nil }
func (e PlaceholderEnumValue) Index() int { return 0 }
func (e PlaceholderEnumValue) Syntax() protoreflect.Syntax { return 0 }
func (e PlaceholderEnumValue) Name() protoreflect.Name { return protoreflect.FullName(e).Name() }
func (e PlaceholderEnumValue) FullName() protoreflect.FullName { return protoreflect.FullName(e) }
func (e PlaceholderEnumValue) IsPlaceholder() bool { return true }
func (e PlaceholderEnumValue) Options() protoreflect.ProtoMessage { return descopts.EnumValue }
func (e PlaceholderEnumValue) Number() protoreflect.EnumNumber { return 0 }
func (e PlaceholderEnumValue) ProtoType(protoreflect.EnumValueDescriptor) { return }
func (e PlaceholderEnumValue) ProtoInternal(pragma.DoNotImplement) { return }
// PlaceholderMessage is a placeholder, representing only the full name.
type PlaceholderMessage protoreflect.FullName
func (m PlaceholderMessage) ParentFile() protoreflect.FileDescriptor { return nil }
func (m PlaceholderMessage) Parent() protoreflect.Descriptor { return nil }
func (m PlaceholderMessage) Index() int { return 0 }
func (m PlaceholderMessage) Syntax() protoreflect.Syntax { return 0 }
func (m PlaceholderMessage) Name() protoreflect.Name { return protoreflect.FullName(m).Name() }
func (m PlaceholderMessage) FullName() protoreflect.FullName { return protoreflect.FullName(m) }
func (m PlaceholderMessage) IsPlaceholder() bool { return true }
func (m PlaceholderMessage) Options() protoreflect.ProtoMessage { return descopts.Message }
func (m PlaceholderMessage) IsMapEntry() bool { return false }
func (m PlaceholderMessage) Fields() protoreflect.FieldDescriptors { return emptyFields }
func (m PlaceholderMessage) Oneofs() protoreflect.OneofDescriptors { return emptyOneofs }
func (m PlaceholderMessage) ReservedNames() protoreflect.Names { return emptyNames }
func (m PlaceholderMessage) ReservedRanges() protoreflect.FieldRanges { return emptyFieldRanges }
func (m PlaceholderMessage) RequiredNumbers() protoreflect.FieldNumbers { return emptyFieldNumbers }
func (m PlaceholderMessage) ExtensionRanges() protoreflect.FieldRanges { return emptyFieldRanges }
func (m PlaceholderMessage) ExtensionRangeOptions(int) protoreflect.ProtoMessage {
panic("index out of range")
}
func (m PlaceholderMessage) Messages() protoreflect.MessageDescriptors { return emptyMessages }
func (m PlaceholderMessage) Enums() protoreflect.EnumDescriptors { return emptyEnums }
func (m PlaceholderMessage) Extensions() protoreflect.ExtensionDescriptors { return emptyExtensions }
func (m PlaceholderMessage) ProtoType(protoreflect.MessageDescriptor) { return }
func (m PlaceholderMessage) ProtoInternal(pragma.DoNotImplement) { return }
// Copyright 2025 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 filedesc
import "google.golang.org/protobuf/reflect/protoreflect"
// UsePresenceForField reports whether the presence bitmap should be used for
// the specified field.
func UsePresenceForField(fd protoreflect.FieldDescriptor) (usePresence, canBeLazy bool) {
switch {
case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
// Oneof fields never use the presence bitmap.
//
// Synthetic oneofs are an exception: Those are used to implement proto3
// optional fields and hence should follow non-oneof field semantics.
return false, false
case fd.IsMap():
// Map-typed fields never use the presence bitmap.
return false, false
case fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind:
// Lazy fields always use the presence bitmap (only messages can be lazy).
isLazy := fd.(interface{ IsLazy() bool }).IsLazy()
return isLazy, isLazy
default:
// If the field has presence, use the presence bitmap.
return fd.HasPresence(), false
}
}
// 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 filetype provides functionality for wrapping descriptors
// with Go type information.
package filetype
import (
"reflect"
"google.golang.org/protobuf/internal/descopts"
"google.golang.org/protobuf/internal/filedesc"
pimpl "google.golang.org/protobuf/internal/impl"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
// Builder constructs type descriptors from a raw file descriptor
// and associated Go types for each enum and message declaration.
//
// # Flattened Ordering
//
// The protobuf type system represents declarations as a tree. Certain nodes in
// the tree require us to either associate it with a concrete Go type or to
// resolve a dependency, which is information that must be provided separately
// since it cannot be derived from the file descriptor alone.
//
// However, representing a tree as Go literals is difficult to simply do in a
// space and time efficient way. Thus, we store them as a flattened list of
// objects where the serialization order from the tree-based form is important.
//
// The "flattened ordering" is defined as a tree traversal of all enum, message,
// extension, and service declarations using the following algorithm:
//
// def VisitFileDecls(fd):
// for e in fd.Enums: yield e
// for m in fd.Messages: yield m
// for x in fd.Extensions: yield x
// for s in fd.Services: yield s
// for m in fd.Messages: yield from VisitMessageDecls(m)
//
// def VisitMessageDecls(md):
// for e in md.Enums: yield e
// for m in md.Messages: yield m
// for x in md.Extensions: yield x
// for m in md.Messages: yield from VisitMessageDecls(m)
//
// The traversal starts at the root file descriptor and yields each direct
// declaration within each node before traversing into sub-declarations
// that children themselves may have.
type Builder struct {
// File is the underlying file descriptor builder.
File filedesc.Builder
// GoTypes is a unique set of the Go types for all declarations and
// dependencies. Each type is represented as a zero value of the Go type.
//
// Declarations are Go types generated for enums and messages directly
// declared (not publicly imported) in the proto source file.
// Messages for map entries are accounted for, but represented by nil.
// Enum declarations in "flattened ordering" come first, followed by
// message declarations in "flattened ordering".
//
// Dependencies are Go types for enums or messages referenced by
// message fields, for parent extended messages of
// extension fields, for enums or messages referenced by extension fields,
// and for input and output messages referenced by service methods.
// Dependencies must come after declarations, but the ordering of
// dependencies themselves is unspecified.
GoTypes []any
// DependencyIndexes is an ordered list of indexes into GoTypes for the
// dependencies of messages, extensions, or services.
//
// There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
// 0. Message field dependencies: list of the enum or message type
// referred to by every message field.
// 1. Extension field targets: list of the extended parent message of
// every extension.
// 2. Extension field dependencies: list of the enum or message type
// referred to by every extension field.
// 3. Service method inputs: list of the input message type
// referred to by every service method.
// 4. Service method outputs: list of the output message type
// referred to by every service method.
//
// The offset into DependencyIndexes for the start of each sub-list
// is appended to the end in reverse order.
DependencyIndexes []int32
// EnumInfos is a list of enum infos in "flattened ordering".
EnumInfos []pimpl.EnumInfo
// MessageInfos is a list of message infos in "flattened ordering".
// If provided, the GoType and PBType for each element is populated.
//
// Requirement: len(MessageInfos) == len(Build.Messages)
MessageInfos []pimpl.MessageInfo
// ExtensionInfos is a list of extension infos in "flattened ordering".
// Each element is initialized and registered with the protoregistry package.
//
// Requirement: len(LegacyExtensions) == len(Build.Extensions)
ExtensionInfos []pimpl.ExtensionInfo
// TypeRegistry is the registry to register each type descriptor.
// If nil, it uses protoregistry.GlobalTypes.
TypeRegistry interface {
RegisterMessage(protoreflect.MessageType) error
RegisterEnum(protoreflect.EnumType) error
RegisterExtension(protoreflect.ExtensionType) error
}
}
// Out is the output of the builder.
type Out struct {
File protoreflect.FileDescriptor
}
func (tb Builder) Build() (out Out) {
// Replace the resolver with one that resolves dependencies by index,
// which is faster and more reliable than relying on the global registry.
if tb.File.FileRegistry == nil {
tb.File.FileRegistry = protoregistry.GlobalFiles
}
tb.File.FileRegistry = &resolverByIndex{
goTypes: tb.GoTypes,
depIdxs: tb.DependencyIndexes,
fileRegistry: tb.File.FileRegistry,
}
// Initialize registry if unpopulated.
if tb.TypeRegistry == nil {
tb.TypeRegistry = protoregistry.GlobalTypes
}
fbOut := tb.File.Build()
out.File = fbOut.File
// Process enums.
enumGoTypes := tb.GoTypes[:len(fbOut.Enums)]
if len(tb.EnumInfos) != len(fbOut.Enums) {
panic("mismatching enum lengths")
}
if len(fbOut.Enums) > 0 {
for i := range fbOut.Enums {
tb.EnumInfos[i] = pimpl.EnumInfo{
GoReflectType: reflect.TypeOf(enumGoTypes[i]),
Desc: &fbOut.Enums[i],
}
// Register enum types.
if err := tb.TypeRegistry.RegisterEnum(&tb.EnumInfos[i]); err != nil {
panic(err)
}
}
}
// Process messages.
messageGoTypes := tb.GoTypes[len(fbOut.Enums):][:len(fbOut.Messages)]
if len(tb.MessageInfos) != len(fbOut.Messages) {
panic("mismatching message lengths")
}
if len(fbOut.Messages) > 0 {
for i := range fbOut.Messages {
if messageGoTypes[i] == nil {
continue // skip map entry
}
tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
tb.MessageInfos[i].Desc = &fbOut.Messages[i]
// Register message types.
if err := tb.TypeRegistry.RegisterMessage(&tb.MessageInfos[i]); err != nil {
panic(err)
}
}
// As a special-case for descriptor.proto,
// locally register concrete message type for the options.
if out.File.Path() == "google/protobuf/descriptor.proto" && out.File.Package() == "google.protobuf" {
for i := range fbOut.Messages {
switch fbOut.Messages[i].Name() {
case "FileOptions":
descopts.File = messageGoTypes[i].(protoreflect.ProtoMessage)
case "EnumOptions":
descopts.Enum = messageGoTypes[i].(protoreflect.ProtoMessage)
case "EnumValueOptions":
descopts.EnumValue = messageGoTypes[i].(protoreflect.ProtoMessage)
case "MessageOptions":
descopts.Message = messageGoTypes[i].(protoreflect.ProtoMessage)
case "FieldOptions":
descopts.Field = messageGoTypes[i].(protoreflect.ProtoMessage)
case "OneofOptions":
descopts.Oneof = messageGoTypes[i].(protoreflect.ProtoMessage)
case "ExtensionRangeOptions":
descopts.ExtensionRange = messageGoTypes[i].(protoreflect.ProtoMessage)
case "ServiceOptions":
descopts.Service = messageGoTypes[i].(protoreflect.ProtoMessage)
case "MethodOptions":
descopts.Method = messageGoTypes[i].(protoreflect.ProtoMessage)
}
}
}
}
// Process extensions.
if len(tb.ExtensionInfos) != len(fbOut.Extensions) {
panic("mismatching extension lengths")
}
var depIdx int32
for i := range fbOut.Extensions {
// For enum and message kinds, determine the referent Go type so
// that we can construct their constructors.
const listExtDeps = 2
var goType reflect.Type
switch fbOut.Extensions[i].L1.Kind {
case protoreflect.EnumKind:
j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
goType = reflect.TypeOf(tb.GoTypes[j])
depIdx++
case protoreflect.MessageKind, protoreflect.GroupKind:
j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
goType = reflect.TypeOf(tb.GoTypes[j])
depIdx++
default:
goType = goTypeForPBKind[fbOut.Extensions[i].L1.Kind]
}
if fbOut.Extensions[i].IsList() {
goType = reflect.SliceOf(goType)
}
pimpl.InitExtensionInfo(&tb.ExtensionInfos[i], &fbOut.Extensions[i], goType)
// Register extension types.
if err := tb.TypeRegistry.RegisterExtension(&tb.ExtensionInfos[i]); err != nil {
panic(err)
}
}
return out
}
var goTypeForPBKind = map[protoreflect.Kind]reflect.Type{
protoreflect.BoolKind: reflect.TypeOf(bool(false)),
protoreflect.Int32Kind: reflect.TypeOf(int32(0)),
protoreflect.Sint32Kind: reflect.TypeOf(int32(0)),
protoreflect.Sfixed32Kind: reflect.TypeOf(int32(0)),
protoreflect.Int64Kind: reflect.TypeOf(int64(0)),
protoreflect.Sint64Kind: reflect.TypeOf(int64(0)),
protoreflect.Sfixed64Kind: reflect.TypeOf(int64(0)),
protoreflect.Uint32Kind: reflect.TypeOf(uint32(0)),
protoreflect.Fixed32Kind: reflect.TypeOf(uint32(0)),
protoreflect.Uint64Kind: reflect.TypeOf(uint64(0)),
protoreflect.Fixed64Kind: reflect.TypeOf(uint64(0)),
protoreflect.FloatKind: reflect.TypeOf(float32(0)),
protoreflect.DoubleKind: reflect.TypeOf(float64(0)),
protoreflect.StringKind: reflect.TypeOf(string("")),
protoreflect.BytesKind: reflect.TypeOf([]byte(nil)),
}
type depIdxs []int32
// Get retrieves the jth element of the ith sub-list.
func (x depIdxs) Get(i, j int32) int32 {
return x[x[int32(len(x))-i-1]+j]
}
type (
resolverByIndex struct {
goTypes []any
depIdxs depIdxs
fileRegistry
}
fileRegistry interface {
FindFileByPath(string) (protoreflect.FileDescriptor, error)
FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error)
RegisterFile(protoreflect.FileDescriptor) error
}
)
func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []filedesc.Enum, ms []filedesc.Message) protoreflect.EnumDescriptor {
if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
return &es[depIdx]
} else {
return pimpl.Export{}.EnumDescriptorOf(r.goTypes[depIdx])
}
}
func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []filedesc.Enum, ms []filedesc.Message) protoreflect.MessageDescriptor {
if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
return &ms[depIdx-len(es)]
} else {
return pimpl.Export{}.MessageDescriptorOf(r.goTypes[depIdx])
}
}
// 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 jsonfuzz includes fuzzers for protojson.Marshal and protojson.Unmarshal.
package jsonfuzz
import (
"google.golang.org/protobuf/encoding/protojson"
"google.golang.org/protobuf/proto"
fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
)
// Fuzz is a fuzzer for proto.Marshal and proto.Unmarshal.
func Fuzz(data []byte) (score int) {
m1 := &fuzzpb.Fuzz{}
if err := (protojson.UnmarshalOptions{
AllowPartial: true,
}).Unmarshal(data, m1); err != nil {
return 0
}
data1, err := protojson.MarshalOptions{
AllowPartial: true,
}.Marshal(m1)
if err != nil {
panic(err)
}
m2 := &fuzzpb.Fuzz{}
if err := (protojson.UnmarshalOptions{
AllowPartial: true,
}).Unmarshal(data1, m2); err != nil {
return 0
}
if !proto.Equal(m1, m2) {
panic("not equal")
}
return 1
}
// 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 textfuzz includes fuzzers for prototext.Marshal and prototext.Unmarshal.
package textfuzz
import (
"google.golang.org/protobuf/encoding/prototext"
"google.golang.org/protobuf/proto"
fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
)
// Fuzz is a fuzzer for proto.Marshal and proto.Unmarshal.
func Fuzz(data []byte) (score int) {
m1 := &fuzzpb.Fuzz{}
if err := (prototext.UnmarshalOptions{
AllowPartial: true,
}).Unmarshal(data, m1); err != nil {
return 0
}
data1, err := prototext.MarshalOptions{
AllowPartial: true,
}.Marshal(m1)
if err != nil {
panic(err)
}
m2 := &fuzzpb.Fuzz{}
if err := (prototext.UnmarshalOptions{
AllowPartial: true,
}).Unmarshal(data1, m2); err != nil {
return 0
}
if !proto.Equal(m1, m2) {
panic("not equal")
}
return 1
}
// 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 wirefuzz includes a fuzzer for the wire marshaler and unmarshaler.
package wirefuzz
import (
"fmt"
"google.golang.org/protobuf/internal/impl"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoregistry"
piface "google.golang.org/protobuf/runtime/protoiface"
fuzzpb "google.golang.org/protobuf/internal/testprotos/fuzz"
)
// Fuzz is a fuzzer for proto.Marshal and proto.Unmarshal.
func Fuzz(data []byte) (score int) {
// Unmarshal and Validate should agree about the validity of the message.
m1 := &fuzzpb.Fuzz{}
mt := m1.ProtoReflect().Type()
_, valid := impl.Validate(mt, piface.UnmarshalInput{Buf: data})
if err := (proto.UnmarshalOptions{AllowPartial: true}).Unmarshal(data, m1); err != nil {
switch valid {
case impl.ValidationUnknown:
case impl.ValidationInvalid:
default:
panic("unmarshal error with validation status: " + valid.String())
}
return 0
}
switch valid {
case impl.ValidationUnknown:
case impl.ValidationValid:
default:
panic("unmarshal ok with validation status: " + valid.String())
}
// Unmarshal, Validate, and CheckInitialized should agree about initialization.
checkInit := proto.CheckInitialized(m1) == nil
methods := m1.ProtoReflect().ProtoMethods()
in := piface.UnmarshalInput{Message: mt.New(), Resolver: protoregistry.GlobalTypes, Depth: 10000}
if checkInit {
// If the message initialized, the both Unmarshal and Validate should
// report it as such. False negatives are tolerated, but have a
// significant impact on performance. In general, they should always
// properly determine initialization for any normalized message,
// we produce by re-marshaling the message.
in.Buf, _ = proto.Marshal(m1)
if out, _ := methods.Unmarshal(in); out.Flags&piface.UnmarshalInitialized == 0 {
panic("unmarshal reports initialized message as partial")
}
if out, _ := impl.Validate(mt, in); out.Flags&piface.UnmarshalInitialized == 0 {
panic("validate reports initialized message as partial")
}
} else {
// If the message is partial, then neither Unmarshal nor Validate
// should ever report it as such. False positives are unacceptable.
in.Buf = data
if out, _ := methods.Unmarshal(in); out.Flags&piface.UnmarshalInitialized != 0 {
panic("unmarshal reports partial message as initialized")
}
if out, _ := impl.Validate(mt, in); out.Flags&piface.UnmarshalInitialized != 0 {
panic("validate reports partial message as initialized")
}
}
// Round-trip Marshal and Unmarshal should produce the same messages.
data1, err := proto.MarshalOptions{AllowPartial: !checkInit}.Marshal(m1)
if err != nil {
panic(err)
}
if proto.Size(m1) != len(data1) {
panic(fmt.Errorf("size does not match output: %d != %d", proto.Size(m1), len(data1)))
}
m2 := &fuzzpb.Fuzz{}
if err := (proto.UnmarshalOptions{AllowPartial: !checkInit}).Unmarshal(data1, m2); err != nil {
panic(err)
}
if !proto.Equal(m1, m2) {
panic("not equal")
}
return 1
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"strconv"
"google.golang.org/protobuf/encoding/prototext"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// Export is a zero-length named type that exists only to export a set of
// functions that we do not want to appear in godoc.
type Export struct{}
// NewError formats a string according to the format specifier and arguments and
// returns an error that has a "proto" prefix.
func (Export) NewError(f string, x ...any) error {
return errors.New(f, x...)
}
// enum is any enum type generated by protoc-gen-go
// and must be a named int32 type.
type enum = any
// EnumOf returns the protoreflect.Enum interface over e.
// It returns nil if e is nil.
func (Export) EnumOf(e enum) protoreflect.Enum {
switch e := e.(type) {
case nil:
return nil
case protoreflect.Enum:
return e
default:
return legacyWrapEnum(reflect.ValueOf(e))
}
}
// EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
// It returns nil if e is nil.
func (Export) EnumDescriptorOf(e enum) protoreflect.EnumDescriptor {
switch e := e.(type) {
case nil:
return nil
case protoreflect.Enum:
return e.Descriptor()
default:
return LegacyLoadEnumDesc(reflect.TypeOf(e))
}
}
// EnumTypeOf returns the protoreflect.EnumType for e.
// It returns nil if e is nil.
func (Export) EnumTypeOf(e enum) protoreflect.EnumType {
switch e := e.(type) {
case nil:
return nil
case protoreflect.Enum:
return e.Type()
default:
return legacyLoadEnumType(reflect.TypeOf(e))
}
}
// EnumStringOf returns the enum value as a string, either as the name if
// the number is resolvable, or the number formatted as a string.
func (Export) EnumStringOf(ed protoreflect.EnumDescriptor, n protoreflect.EnumNumber) string {
ev := ed.Values().ByNumber(n)
if ev != nil {
return string(ev.Name())
}
return strconv.Itoa(int(n))
}
// message is any message type generated by protoc-gen-go
// and must be a pointer to a named struct type.
type message = any
// legacyMessageWrapper wraps a v2 message as a v1 message.
type legacyMessageWrapper struct{ m protoreflect.ProtoMessage }
func (m legacyMessageWrapper) Reset() { proto.Reset(m.m) }
func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) }
func (m legacyMessageWrapper) ProtoMessage() {}
// ProtoMessageV1Of converts either a v1 or v2 message to a v1 message.
// It returns nil if m is nil.
func (Export) ProtoMessageV1Of(m message) protoiface.MessageV1 {
switch mv := m.(type) {
case nil:
return nil
case protoiface.MessageV1:
return mv
case unwrapper:
return Export{}.ProtoMessageV1Of(mv.protoUnwrap())
case protoreflect.ProtoMessage:
return legacyMessageWrapper{mv}
default:
panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
}
}
func (Export) protoMessageV2Of(m message) protoreflect.ProtoMessage {
switch mv := m.(type) {
case nil:
return nil
case protoreflect.ProtoMessage:
return mv
case legacyMessageWrapper:
return mv.m
case protoiface.MessageV1:
return nil
default:
panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
}
}
// ProtoMessageV2Of converts either a v1 or v2 message to a v2 message.
// It returns nil if m is nil.
func (Export) ProtoMessageV2Of(m message) protoreflect.ProtoMessage {
if m == nil {
return nil
}
if mv := (Export{}).protoMessageV2Of(m); mv != nil {
return mv
}
return legacyWrapMessage(reflect.ValueOf(m)).Interface()
}
// MessageOf returns the protoreflect.Message interface over m.
// It returns nil if m is nil.
func (Export) MessageOf(m message) protoreflect.Message {
if m == nil {
return nil
}
if mv := (Export{}).protoMessageV2Of(m); mv != nil {
return mv.ProtoReflect()
}
return legacyWrapMessage(reflect.ValueOf(m))
}
// MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
// It returns nil if m is nil.
func (Export) MessageDescriptorOf(m message) protoreflect.MessageDescriptor {
if m == nil {
return nil
}
if mv := (Export{}).protoMessageV2Of(m); mv != nil {
return mv.ProtoReflect().Descriptor()
}
return LegacyLoadMessageDesc(reflect.TypeOf(m))
}
// MessageTypeOf returns the protoreflect.MessageType for m.
// It returns nil if m is nil.
func (Export) MessageTypeOf(m message) protoreflect.MessageType {
if m == nil {
return nil
}
if mv := (Export{}).protoMessageV2Of(m); mv != nil {
return mv.ProtoReflect().Type()
}
return legacyLoadMessageType(reflect.TypeOf(m), "")
}
// MessageStringOf returns the message value as a string,
// which is the message serialized in the protobuf text format.
func (Export) MessageStringOf(m protoreflect.ProtoMessage) string {
return prototext.MarshalOptions{Multiline: false}.Format(m)
}
// Copyright 2024 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 impl
import (
"strconv"
"sync/atomic"
"unsafe"
"google.golang.org/protobuf/reflect/protoreflect"
)
func (Export) UnmarshalField(msg any, fieldNum int32) {
UnmarshalField(msg.(protoreflect.ProtoMessage).ProtoReflect(), protoreflect.FieldNumber(fieldNum))
}
// Present checks the presence set for a certain field number (zero
// based, ordered by appearance in original proto file). part is
// a pointer to the correct element in the bitmask array, num is the
// field number unaltered. Example (field number 70 -> part =
// &m.XXX_presence[1], num = 70)
func (Export) Present(part *uint32, num uint32) bool {
// This hook will read an unprotected shadow presence set if
// we're unning under the race detector
raceDetectHookPresent(part, num)
return atomic.LoadUint32(part)&(1<<(num%32)) > 0
}
// SetPresent adds a field to the presence set. part is a pointer to
// the relevant element in the array and num is the field number
// unaltered. size is the number of fields in the protocol
// buffer.
func (Export) SetPresent(part *uint32, num uint32, size uint32) {
// This hook will mutate an unprotected shadow presence set if
// we're running under the race detector
raceDetectHookSetPresent(part, num, presenceSize(size))
for {
old := atomic.LoadUint32(part)
if atomic.CompareAndSwapUint32(part, old, old|(1<<(num%32))) {
return
}
}
}
// SetPresentNonAtomic is like SetPresent, but operates non-atomically.
// It is meant for use by builder methods, where the message is known not
// to be accessible yet by other goroutines.
func (Export) SetPresentNonAtomic(part *uint32, num uint32, size uint32) {
// This hook will mutate an unprotected shadow presence set if
// we're running under the race detector
raceDetectHookSetPresent(part, num, presenceSize(size))
*part |= 1 << (num % 32)
}
// ClearPresence removes a field from the presence set. part is a
// pointer to the relevant element in the presence array and num is
// the field number unaltered.
func (Export) ClearPresent(part *uint32, num uint32) {
// This hook will mutate an unprotected shadow presence set if
// we're running under the race detector
raceDetectHookClearPresent(part, num)
for {
old := atomic.LoadUint32(part)
if atomic.CompareAndSwapUint32(part, old, old&^(1<<(num%32))) {
return
}
}
}
// interfaceToPointer takes a pointer to an empty interface whose value is a
// pointer type, and converts it into a "pointer" that points to the same
// target
func interfaceToPointer(i *any) pointer {
return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
}
func (p pointer) atomicGetPointer() pointer {
return pointer{p: atomic.LoadPointer((*unsafe.Pointer)(p.p))}
}
func (p pointer) atomicSetPointer(q pointer) {
atomic.StorePointer((*unsafe.Pointer)(p.p), q.p)
}
// AtomicCheckPointerIsNil takes an interface (which is a pointer to a
// pointer) and returns true if the pointed-to pointer is nil (using an
// atomic load). This function is inlineable and, on x86, just becomes a
// simple load and compare.
func (Export) AtomicCheckPointerIsNil(ptr any) bool {
return interfaceToPointer(&ptr).atomicGetPointer().IsNil()
}
// AtomicSetPointer takes two interfaces (first is a pointer to a pointer,
// second is a pointer) and atomically sets the second pointer into location
// referenced by first pointer. Unfortunately, atomicSetPointer() does not inline
// (even on x86), so this does not become a simple store on x86.
func (Export) AtomicSetPointer(dstPtr, valPtr any) {
interfaceToPointer(&dstPtr).atomicSetPointer(interfaceToPointer(&valPtr))
}
// AtomicLoadPointer loads the pointer at the location pointed at by src,
// and stores that pointer value into the location pointed at by dst.
func (Export) AtomicLoadPointer(ptr Pointer, dst Pointer) {
*(*unsafe.Pointer)(unsafe.Pointer(dst)) = atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(ptr)))
}
// AtomicInitializePointer makes ptr and dst point to the same value.
//
// If *ptr is a nil pointer, it sets *ptr = *dst.
//
// If *ptr is a non-nil pointer, it sets *dst = *ptr.
func (Export) AtomicInitializePointer(ptr Pointer, dst Pointer) {
if !atomic.CompareAndSwapPointer((*unsafe.Pointer)(ptr), unsafe.Pointer(nil), *(*unsafe.Pointer)(dst)) {
*(*unsafe.Pointer)(unsafe.Pointer(dst)) = atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(ptr)))
}
}
// MessageFieldStringOf returns the field formatted as a string,
// either as the field name if resolvable otherwise as a decimal string.
func (Export) MessageFieldStringOf(md protoreflect.MessageDescriptor, n protoreflect.FieldNumber) string {
fd := md.Fields().ByNumber(n)
if fd != nil {
return string(fd.Name())
}
return strconv.Itoa(int(n))
}
// Copyright 2024 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.
//go:build !race
package impl
// There is no additional data as we're not running under race detector.
type RaceDetectHookData struct{}
// Empty stubs for when not using the race detector. Calls to these from index.go should be optimized away.
func (presence) raceDetectHookPresent(num uint32) {}
func (presence) raceDetectHookSetPresent(num uint32, size presenceSize) {}
func (presence) raceDetectHookClearPresent(num uint32) {}
func (presence) raceDetectHookAllocAndCopy(src presence) {}
// raceDetectHookPresent is called by the generated file interface
// (*proto.internalFuncs) Present to optionally read an unprotected
// shadow bitmap when race detection is enabled. In regular code it is
// a noop.
func raceDetectHookPresent(field *uint32, num uint32) {}
// raceDetectHookSetPresent is called by the generated file interface
// (*proto.internalFuncs) SetPresent to optionally write an unprotected
// shadow bitmap when race detection is enabled. In regular code it is
// a noop.
func raceDetectHookSetPresent(field *uint32, num uint32, size presenceSize) {}
// raceDetectHookClearPresent is called by the generated file interface
// (*proto.internalFuncs) ClearPresent to optionally write an unprotected
// shadow bitmap when race detection is enabled. In regular code it is
// a noop.
func raceDetectHookClearPresent(field *uint32, num uint32) {}
// 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 impl
import (
"sync"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
func (mi *MessageInfo) checkInitialized(in protoiface.CheckInitializedInput) (protoiface.CheckInitializedOutput, error) {
var p pointer
if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer()
} else {
p = in.Message.(*messageReflectWrapper).pointer()
}
return protoiface.CheckInitializedOutput{}, mi.checkInitializedPointer(p)
}
func (mi *MessageInfo) checkInitializedPointer(p pointer) error {
mi.init()
if !mi.needsInitCheck {
return nil
}
if p.IsNil() {
for _, f := range mi.orderedCoderFields {
if f.isRequired {
return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
}
}
return nil
}
var presence presence
if mi.presenceOffset.IsValid() {
presence = p.Apply(mi.presenceOffset).PresenceInfo()
}
if mi.extensionOffset.IsValid() {
e := p.Apply(mi.extensionOffset).Extensions()
if err := mi.isInitExtensions(e); err != nil {
return err
}
}
for _, f := range mi.orderedCoderFields {
if !f.isRequired && f.funcs.isInit == nil {
continue
}
if f.presenceIndex != noPresence {
if !presence.Present(f.presenceIndex) {
if f.isRequired {
return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
}
continue
}
if f.funcs.isInit != nil {
f.mi.init()
if f.mi.needsInitCheck {
if f.isLazy && p.Apply(f.offset).AtomicGetPointer().IsNil() {
lazy := *p.Apply(mi.lazyOffset).LazyInfoPtr()
if !lazy.AllowedPartial() {
// Nothing to see here, it was checked on unmarshal
continue
}
mi.lazyUnmarshal(p, f.num)
}
if err := f.funcs.isInit(p.Apply(f.offset), f); err != nil {
return err
}
}
}
continue
}
fptr := p.Apply(f.offset)
if f.isPointer && fptr.Elem().IsNil() {
if f.isRequired {
return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
}
continue
}
if f.funcs.isInit == nil {
continue
}
if err := f.funcs.isInit(fptr, f); err != nil {
return err
}
}
return nil
}
func (mi *MessageInfo) isInitExtensions(ext *map[int32]ExtensionField) error {
if ext == nil {
return nil
}
for _, x := range *ext {
ei := getExtensionFieldInfo(x.Type())
if ei.funcs.isInit == nil || x.isUnexpandedLazy() {
continue
}
v := x.Value()
if !v.IsValid() {
continue
}
if err := ei.funcs.isInit(v); err != nil {
return err
}
}
return nil
}
var (
needsInitCheckMu sync.Mutex
needsInitCheckMap sync.Map
)
// needsInitCheck reports whether a message needs to be checked for partial initialization.
//
// It returns true if the message transitively includes any required or extension fields.
func needsInitCheck(md protoreflect.MessageDescriptor) bool {
if v, ok := needsInitCheckMap.Load(md); ok {
if has, ok := v.(bool); ok {
return has
}
}
needsInitCheckMu.Lock()
defer needsInitCheckMu.Unlock()
return needsInitCheckLocked(md)
}
func needsInitCheckLocked(md protoreflect.MessageDescriptor) (has bool) {
if v, ok := needsInitCheckMap.Load(md); ok {
// If has is true, we've previously determined that this message
// needs init checks.
//
// If has is false, we've previously determined that it can never
// be uninitialized.
//
// If has is not a bool, we've just encountered a cycle in the
// message graph. In this case, it is safe to return false: If
// the message does have required fields, we'll detect them later
// in the graph traversal.
has, ok := v.(bool)
return ok && has
}
needsInitCheckMap.Store(md, struct{}{}) // avoid cycles while descending into this message
defer func() {
needsInitCheckMap.Store(md, has)
}()
if md.RequiredNumbers().Len() > 0 {
return true
}
if md.ExtensionRanges().Len() > 0 {
return true
}
for i := 0; i < md.Fields().Len(); i++ {
fd := md.Fields().Get(i)
// Map keys are never messages, so just consider the map value.
if fd.IsMap() {
fd = fd.MapValue()
}
fmd := fd.Message()
if fmd != nil && needsInitCheckLocked(fmd) {
return true
}
}
return false
}
// 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 impl
import (
"sync"
"sync/atomic"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
)
type extensionFieldInfo struct {
wiretag uint64
tagsize int
unmarshalNeedsValue bool
funcs valueCoderFuncs
validation validationInfo
}
func getExtensionFieldInfo(xt protoreflect.ExtensionType) *extensionFieldInfo {
if xi, ok := xt.(*ExtensionInfo); ok {
xi.lazyInit()
return xi.info
}
// Ideally we'd cache the resulting *extensionFieldInfo so we don't have to
// recompute this metadata repeatedly. But without support for something like
// weak references, such a cache would pin temporary values (like dynamic
// extension types, constructed for the duration of a user request) to the
// heap forever, causing memory usage of the cache to grow unbounded.
// See discussion in https://github.com/golang/protobuf/issues/1521.
return makeExtensionFieldInfo(xt.TypeDescriptor())
}
func makeExtensionFieldInfo(xd protoreflect.ExtensionDescriptor) *extensionFieldInfo {
var wiretag uint64
if !xd.IsPacked() {
wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
} else {
wiretag = protowire.EncodeTag(xd.Number(), protowire.BytesType)
}
e := &extensionFieldInfo{
wiretag: wiretag,
tagsize: protowire.SizeVarint(wiretag),
funcs: encoderFuncsForValue(xd),
}
// Does the unmarshal function need a value passed to it?
// This is true for composite types, where we pass in a message, list, or map to fill in,
// and for enums, where we pass in a prototype value to specify the concrete enum type.
switch xd.Kind() {
case protoreflect.MessageKind, protoreflect.GroupKind, protoreflect.EnumKind:
e.unmarshalNeedsValue = true
default:
if xd.Cardinality() == protoreflect.Repeated {
e.unmarshalNeedsValue = true
}
}
return e
}
type lazyExtensionValue struct {
atomicOnce uint32 // atomically set if value is valid
mu sync.Mutex
xi *extensionFieldInfo
value protoreflect.Value
b []byte
}
type ExtensionField struct {
typ protoreflect.ExtensionType
// value is either the value of GetValue,
// or a *lazyExtensionValue that then returns the value of GetValue.
value protoreflect.Value
lazy *lazyExtensionValue
}
func (f *ExtensionField) appendLazyBytes(xt protoreflect.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
if f.lazy == nil {
f.lazy = &lazyExtensionValue{xi: xi}
}
f.typ = xt
f.lazy.xi = xi
f.lazy.b = protowire.AppendTag(f.lazy.b, num, wtyp)
f.lazy.b = append(f.lazy.b, b...)
}
func (f *ExtensionField) canLazy(xt protoreflect.ExtensionType) bool {
if f.typ == nil {
return true
}
if f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
return true
}
return false
}
// isUnexpandedLazy returns true if the ExensionField is lazy and not
// yet expanded, which means it's present and already checked for
// initialized required fields.
func (f *ExtensionField) isUnexpandedLazy() bool {
return f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0
}
// lazyBuffer retrieves the buffer for a lazy extension if it's not yet expanded.
//
// The returned buffer has to be kept over whatever operation we're planning,
// as re-retrieving it will fail after the message is lazily decoded.
func (f *ExtensionField) lazyBuffer() []byte {
// This function might be in the critical path, so check the atomic without
// taking a look first, then only take the lock if needed.
if !f.isUnexpandedLazy() {
return nil
}
f.lazy.mu.Lock()
defer f.lazy.mu.Unlock()
return f.lazy.b
}
func (f *ExtensionField) lazyInit() {
f.lazy.mu.Lock()
defer f.lazy.mu.Unlock()
if atomic.LoadUint32(&f.lazy.atomicOnce) == 1 {
return
}
if f.lazy.xi != nil {
b := f.lazy.b
val := f.typ.New()
for len(b) > 0 {
var tag uint64
if b[0] < 0x80 {
tag = uint64(b[0])
b = b[1:]
} else if len(b) >= 2 && b[1] < 128 {
tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
b = b[2:]
} else {
var n int
tag, n = protowire.ConsumeVarint(b)
if n < 0 {
panic(errors.New("bad tag in lazy extension decoding"))
}
b = b[n:]
}
num := protowire.Number(tag >> 3)
wtyp := protowire.Type(tag & 7)
var out unmarshalOutput
var err error
val, out, err = f.lazy.xi.funcs.unmarshal(b, val, num, wtyp, lazyUnmarshalOptions)
if err != nil {
panic(errors.New("decode failure in lazy extension decoding: %v", err))
}
b = b[out.n:]
}
f.lazy.value = val
} else {
panic("No support for lazy fns for ExtensionField")
}
f.lazy.xi = nil
f.lazy.b = nil
atomic.StoreUint32(&f.lazy.atomicOnce, 1)
}
// Set sets the type and value of the extension field.
// This must not be called concurrently.
func (f *ExtensionField) Set(t protoreflect.ExtensionType, v protoreflect.Value) {
f.typ = t
f.value = v
f.lazy = nil
}
// Value returns the value of the extension field.
// This may be called concurrently.
func (f *ExtensionField) Value() protoreflect.Value {
if f.lazy != nil {
if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
f.lazyInit()
}
return f.lazy.value
}
return f.value
}
// Type returns the type of the extension field.
// This may be called concurrently.
func (f ExtensionField) Type() protoreflect.ExtensionType {
return f.typ
}
// IsSet returns whether the extension field is set.
// This may be called concurrently.
func (f ExtensionField) IsSet() bool {
return f.typ != nil
}
// IsLazy reports whether a field is lazily encoded.
// It is exported for testing.
func IsLazy(m protoreflect.Message, fd protoreflect.FieldDescriptor) bool {
var mi *MessageInfo
var p pointer
switch m := m.(type) {
case *messageState:
mi = m.messageInfo()
p = m.pointer()
case *messageReflectWrapper:
mi = m.messageInfo()
p = m.pointer()
default:
return false
}
xd, ok := fd.(protoreflect.ExtensionTypeDescriptor)
if !ok {
return false
}
xt := xd.Type()
ext := mi.extensionMap(p)
if ext == nil {
return false
}
f, ok := (*ext)[int32(fd.Number())]
if !ok {
return false
}
return f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0
}
// 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 impl
import (
"reflect"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
type errInvalidUTF8 struct{}
func (errInvalidUTF8) Error() string { return "string field contains invalid UTF-8" }
func (errInvalidUTF8) InvalidUTF8() bool { return true }
func (errInvalidUTF8) Unwrap() error { return errors.Error }
// initOneofFieldCoders initializes the fast-path functions for the fields in a oneof.
//
// For size, marshal, and isInit operations, functions are set only on the first field
// in the oneof. The functions are called when the oneof is non-nil, and will dispatch
// to the appropriate field-specific function as necessary.
//
// The unmarshal function is set on each field individually as usual.
func (mi *MessageInfo) initOneofFieldCoders(od protoreflect.OneofDescriptor, si structInfo) {
fs := si.oneofsByName[od.Name()]
ft := fs.Type
oneofFields := make(map[reflect.Type]*coderFieldInfo)
needIsInit := false
fields := od.Fields()
for i, lim := 0, fields.Len(); i < lim; i++ {
fd := od.Fields().Get(i)
num := fd.Number()
// Make a copy of the original coderFieldInfo for use in unmarshaling.
//
// oneofFields[oneofType].funcs.marshal is the field-specific marshal function.
//
// mi.coderFields[num].marshal is set on only the first field in the oneof,
// and dispatches to the field-specific marshaler in oneofFields.
cf := *mi.coderFields[num]
ot := si.oneofWrappersByNumber[num]
cf.ft = ot.Field(0).Type
cf.mi, cf.funcs = fieldCoder(fd, cf.ft)
oneofFields[ot] = &cf
if cf.funcs.isInit != nil {
needIsInit = true
}
mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
var vw reflect.Value // pointer to wrapper type
vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind
if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
vw = vi.Elem()
} else {
vw = reflect.New(ot)
}
out, err := cf.funcs.unmarshal(b, pointerOfValue(vw).Apply(zeroOffset), wtyp, &cf, opts)
if err != nil {
return out, err
}
if cf.funcs.isInit == nil {
out.initialized = true
}
vi.Set(vw)
return out, nil
}
}
getInfo := func(p pointer) (pointer, *coderFieldInfo) {
v := p.AsValueOf(ft).Elem()
if v.IsNil() {
return pointer{}, nil
}
v = v.Elem() // interface -> *struct
if v.IsNil() {
return pointer{}, nil
}
return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
}
first := mi.coderFields[od.Fields().Get(0).Number()]
first.funcs.size = func(p pointer, _ *coderFieldInfo, opts marshalOptions) int {
p, info := getInfo(p)
if info == nil || info.funcs.size == nil {
return 0
}
return info.funcs.size(p, info, opts)
}
first.funcs.marshal = func(b []byte, p pointer, _ *coderFieldInfo, opts marshalOptions) ([]byte, error) {
p, info := getInfo(p)
if info == nil || info.funcs.marshal == nil {
return b, nil
}
return info.funcs.marshal(b, p, info, opts)
}
first.funcs.merge = func(dst, src pointer, _ *coderFieldInfo, opts mergeOptions) {
srcp, srcinfo := getInfo(src)
if srcinfo == nil || srcinfo.funcs.merge == nil {
return
}
dstp, dstinfo := getInfo(dst)
if dstinfo != srcinfo {
dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))
dstp = pointerOfValue(dst.AsValueOf(ft).Elem().Elem()).Apply(zeroOffset)
}
srcinfo.funcs.merge(dstp, srcp, srcinfo, opts)
}
if needIsInit {
first.funcs.isInit = func(p pointer, _ *coderFieldInfo) error {
p, info := getInfo(p)
if info == nil || info.funcs.isInit == nil {
return nil
}
return info.funcs.isInit(p, info)
}
}
}
func makeMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{
size: sizeMessageInfo,
marshal: appendMessageInfo,
unmarshal: consumeMessageInfo,
merge: mergeMessage,
}
if needsInitCheck(mi.Desc) {
funcs.isInit = isInitMessageInfo
}
return funcs
} else {
return pointerCoderFuncs{
size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
m := asMessage(p.AsValueOf(ft).Elem())
return sizeMessage(m, f.tagsize, opts)
},
marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
m := asMessage(p.AsValueOf(ft).Elem())
return appendMessage(b, m, f.wiretag, opts)
},
unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
mp := p.AsValueOf(ft).Elem()
if mp.IsNil() {
mp.Set(reflect.New(ft.Elem()))
}
return consumeMessage(b, asMessage(mp), wtyp, opts)
},
isInit: func(p pointer, f *coderFieldInfo) error {
m := asMessage(p.AsValueOf(ft).Elem())
return proto.CheckInitialized(m)
},
merge: mergeMessage,
}
}
}
func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
return protowire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize
}
func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
calculatedSize := f.mi.sizePointer(p.Elem(), opts)
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(calculatedSize))
before := len(b)
b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts)
if measuredSize := len(b) - before; calculatedSize != measuredSize && err == nil {
return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize)
}
return b, err
}
func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if p.Elem().IsNil() {
p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
}
o, err := f.mi.unmarshalPointer(v, p.Elem(), 0, opts)
if err != nil {
return out, err
}
out.n = n
out.initialized = o.initialized
return out, nil
}
func isInitMessageInfo(p pointer, f *coderFieldInfo) error {
return f.mi.checkInitializedPointer(p.Elem())
}
func sizeMessage(m proto.Message, tagsize int, opts marshalOptions) int {
return protowire.SizeBytes(opts.Options().Size(m)) + tagsize
}
func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
mopts := opts.Options()
calculatedSize := mopts.Size(m)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(calculatedSize))
before := len(b)
b, err := mopts.MarshalAppend(b, m)
if measuredSize := len(b) - before; calculatedSize != measuredSize && err == nil {
return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize)
}
return b, err
}
func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: v,
Message: m.ProtoReflect(),
})
if err != nil {
return out, err
}
out.n = n
out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil
}
func sizeMessageValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
m := v.Message().Interface()
return sizeMessage(m, tagsize, opts)
}
func appendMessageValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
m := v.Message().Interface()
return appendMessage(b, m, wiretag, opts)
}
func consumeMessageValue(b []byte, v protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error) {
m := v.Message().Interface()
out, err := consumeMessage(b, m, wtyp, opts)
return v, out, err
}
func isInitMessageValue(v protoreflect.Value) error {
m := v.Message().Interface()
return proto.CheckInitialized(m)
}
var coderMessageValue = valueCoderFuncs{
size: sizeMessageValue,
marshal: appendMessageValue,
unmarshal: consumeMessageValue,
isInit: isInitMessageValue,
merge: mergeMessageValue,
}
func sizeGroupValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
m := v.Message().Interface()
return sizeGroup(m, tagsize, opts)
}
func appendGroupValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
m := v.Message().Interface()
return appendGroup(b, m, wiretag, opts)
}
func consumeGroupValue(b []byte, v protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error) {
m := v.Message().Interface()
out, err := consumeGroup(b, m, num, wtyp, opts)
return v, out, err
}
var coderGroupValue = valueCoderFuncs{
size: sizeGroupValue,
marshal: appendGroupValue,
unmarshal: consumeGroupValue,
isInit: isInitMessageValue,
merge: mergeMessageValue,
}
func makeGroupFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
num := fd.Number()
if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{
size: sizeGroupType,
marshal: appendGroupType,
unmarshal: consumeGroupType,
merge: mergeMessage,
}
if needsInitCheck(mi.Desc) {
funcs.isInit = isInitMessageInfo
}
return funcs
} else {
return pointerCoderFuncs{
size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
m := asMessage(p.AsValueOf(ft).Elem())
return sizeGroup(m, f.tagsize, opts)
},
marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
m := asMessage(p.AsValueOf(ft).Elem())
return appendGroup(b, m, f.wiretag, opts)
},
unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
mp := p.AsValueOf(ft).Elem()
if mp.IsNil() {
mp.Set(reflect.New(ft.Elem()))
}
return consumeGroup(b, asMessage(mp), num, wtyp, opts)
},
isInit: func(p pointer, f *coderFieldInfo) error {
m := asMessage(p.AsValueOf(ft).Elem())
return proto.CheckInitialized(m)
},
merge: mergeMessage,
}
}
}
func sizeGroupType(p pointer, f *coderFieldInfo, opts marshalOptions) int {
return 2*f.tagsize + f.mi.sizePointer(p.Elem(), opts)
}
func appendGroupType(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, f.wiretag) // start group
b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts)
b = protowire.AppendVarint(b, f.wiretag+1) // end group
return b, err
}
func consumeGroupType(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.StartGroupType {
return out, errUnknown
}
if p.Elem().IsNil() {
p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
}
return f.mi.unmarshalPointer(b, p.Elem(), f.num, opts)
}
func sizeGroup(m proto.Message, tagsize int, opts marshalOptions) int {
return 2*tagsize + opts.Options().Size(m)
}
func appendGroup(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag) // start group
b, err := opts.Options().MarshalAppend(b, m)
b = protowire.AppendVarint(b, wiretag+1) // end group
return b, err
}
func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.StartGroupType {
return out, errUnknown
}
b, n := protowire.ConsumeGroup(num, b)
if n < 0 {
return out, errDecode
}
o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: b,
Message: m.ProtoReflect(),
})
if err != nil {
return out, err
}
out.n = n
out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil
}
func makeMessageSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{
size: sizeMessageSliceInfo,
marshal: appendMessageSliceInfo,
unmarshal: consumeMessageSliceInfo,
merge: mergeMessageSlice,
}
if needsInitCheck(mi.Desc) {
funcs.isInit = isInitMessageSliceInfo
}
return funcs
}
return pointerCoderFuncs{
size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
return sizeMessageSlice(p, ft, f.tagsize, opts)
},
marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
return appendMessageSlice(b, p, f.wiretag, ft, opts)
},
unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
return consumeMessageSlice(b, p, ft, wtyp, opts)
},
isInit: func(p pointer, f *coderFieldInfo) error {
return isInitMessageSlice(p, ft)
},
merge: mergeMessageSlice,
}
}
func sizeMessageSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
s := p.PointerSlice()
n := 0
for _, v := range s {
n += protowire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
}
return n
}
func appendMessageSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := p.PointerSlice()
var err error
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
siz := f.mi.sizePointer(v, opts)
b = protowire.AppendVarint(b, uint64(siz))
before := len(b)
b, err = f.mi.marshalAppendPointer(b, v, opts)
if err != nil {
return b, err
}
if measuredSize := len(b) - before; siz != measuredSize {
return nil, errors.MismatchedSizeCalculation(siz, measuredSize)
}
}
return b, nil
}
func consumeMessageSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
mp := pointerOfIface(m)
o, err := f.mi.unmarshalPointer(v, mp, 0, opts)
if err != nil {
return out, err
}
p.AppendPointerSlice(mp)
out.n = n
out.initialized = o.initialized
return out, nil
}
func isInitMessageSliceInfo(p pointer, f *coderFieldInfo) error {
s := p.PointerSlice()
for _, v := range s {
if err := f.mi.checkInitializedPointer(v); err != nil {
return err
}
}
return nil
}
func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, opts marshalOptions) int {
mopts := opts.Options()
s := p.PointerSlice()
n := 0
for _, v := range s {
m := asMessage(v.AsValueOf(goType.Elem()))
n += protowire.SizeBytes(mopts.Size(m)) + tagsize
}
return n
}
func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
mopts := opts.Options()
s := p.PointerSlice()
var err error
for _, v := range s {
m := asMessage(v.AsValueOf(goType.Elem()))
b = protowire.AppendVarint(b, wiretag)
siz := mopts.Size(m)
b = protowire.AppendVarint(b, uint64(siz))
before := len(b)
b, err = mopts.MarshalAppend(b, m)
if err != nil {
return b, err
}
if measuredSize := len(b) - before; siz != measuredSize {
return nil, errors.MismatchedSizeCalculation(siz, measuredSize)
}
}
return b, nil
}
func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
mp := reflect.New(goType.Elem())
o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: v,
Message: asMessage(mp).ProtoReflect(),
})
if err != nil {
return out, err
}
p.AppendPointerSlice(pointerOfValue(mp))
out.n = n
out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil
}
func isInitMessageSlice(p pointer, goType reflect.Type) error {
s := p.PointerSlice()
for _, v := range s {
m := asMessage(v.AsValueOf(goType.Elem()))
if err := proto.CheckInitialized(m); err != nil {
return err
}
}
return nil
}
// Slices of messages
func sizeMessageSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) int {
mopts := opts.Options()
list := listv.List()
n := 0
for i, llen := 0, list.Len(); i < llen; i++ {
m := list.Get(i).Message().Interface()
n += protowire.SizeBytes(mopts.Size(m)) + tagsize
}
return n
}
func appendMessageSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
mopts := opts.Options()
for i, llen := 0, list.Len(); i < llen; i++ {
m := list.Get(i).Message().Interface()
b = protowire.AppendVarint(b, wiretag)
siz := mopts.Size(m)
b = protowire.AppendVarint(b, uint64(siz))
before := len(b)
var err error
b, err = mopts.MarshalAppend(b, m)
if err != nil {
return b, err
}
if measuredSize := len(b) - before; siz != measuredSize {
return nil, errors.MismatchedSizeCalculation(siz, measuredSize)
}
}
return b, nil
}
func consumeMessageSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp != protowire.BytesType {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
m := list.NewElement()
o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: v,
Message: m.Message(),
})
if err != nil {
return protoreflect.Value{}, out, err
}
list.Append(m)
out.n = n
out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return listv, out, nil
}
func isInitMessageSliceValue(listv protoreflect.Value) error {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
m := list.Get(i).Message().Interface()
if err := proto.CheckInitialized(m); err != nil {
return err
}
}
return nil
}
var coderMessageSliceValue = valueCoderFuncs{
size: sizeMessageSliceValue,
marshal: appendMessageSliceValue,
unmarshal: consumeMessageSliceValue,
isInit: isInitMessageSliceValue,
merge: mergeMessageListValue,
}
func sizeGroupSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) int {
mopts := opts.Options()
list := listv.List()
n := 0
for i, llen := 0, list.Len(); i < llen; i++ {
m := list.Get(i).Message().Interface()
n += 2*tagsize + mopts.Size(m)
}
return n
}
func appendGroupSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
mopts := opts.Options()
for i, llen := 0, list.Len(); i < llen; i++ {
m := list.Get(i).Message().Interface()
b = protowire.AppendVarint(b, wiretag) // start group
var err error
b, err = mopts.MarshalAppend(b, m)
if err != nil {
return b, err
}
b = protowire.AppendVarint(b, wiretag+1) // end group
}
return b, nil
}
func consumeGroupSliceValue(b []byte, listv protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp != protowire.StartGroupType {
return protoreflect.Value{}, out, errUnknown
}
b, n := protowire.ConsumeGroup(num, b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
m := list.NewElement()
o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: b,
Message: m.Message(),
})
if err != nil {
return protoreflect.Value{}, out, err
}
list.Append(m)
out.n = n
out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return listv, out, nil
}
var coderGroupSliceValue = valueCoderFuncs{
size: sizeGroupSliceValue,
marshal: appendGroupSliceValue,
unmarshal: consumeGroupSliceValue,
isInit: isInitMessageSliceValue,
merge: mergeMessageListValue,
}
func makeGroupSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
num := fd.Number()
if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{
size: sizeGroupSliceInfo,
marshal: appendGroupSliceInfo,
unmarshal: consumeGroupSliceInfo,
merge: mergeMessageSlice,
}
if needsInitCheck(mi.Desc) {
funcs.isInit = isInitMessageSliceInfo
}
return funcs
}
return pointerCoderFuncs{
size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
return sizeGroupSlice(p, ft, f.tagsize, opts)
},
marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
return appendGroupSlice(b, p, f.wiretag, ft, opts)
},
unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
return consumeGroupSlice(b, p, num, wtyp, ft, opts)
},
isInit: func(p pointer, f *coderFieldInfo) error {
return isInitMessageSlice(p, ft)
},
merge: mergeMessageSlice,
}
}
func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, opts marshalOptions) int {
mopts := opts.Options()
s := p.PointerSlice()
n := 0
for _, v := range s {
m := asMessage(v.AsValueOf(messageType.Elem()))
n += 2*tagsize + mopts.Size(m)
}
return n
}
func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
s := p.PointerSlice()
var err error
for _, v := range s {
m := asMessage(v.AsValueOf(messageType.Elem()))
b = protowire.AppendVarint(b, wiretag) // start group
b, err = opts.Options().MarshalAppend(b, m)
if err != nil {
return b, err
}
b = protowire.AppendVarint(b, wiretag+1) // end group
}
return b, nil
}
func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.StartGroupType {
return out, errUnknown
}
b, n := protowire.ConsumeGroup(num, b)
if n < 0 {
return out, errDecode
}
mp := reflect.New(goType.Elem())
o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: b,
Message: asMessage(mp).ProtoReflect(),
})
if err != nil {
return out, err
}
p.AppendPointerSlice(pointerOfValue(mp))
out.n = n
out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil
}
func sizeGroupSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
s := p.PointerSlice()
n := 0
for _, v := range s {
n += 2*f.tagsize + f.mi.sizePointer(v, opts)
}
return n
}
func appendGroupSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := p.PointerSlice()
var err error
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag) // start group
b, err = f.mi.marshalAppendPointer(b, v, opts)
if err != nil {
return b, err
}
b = protowire.AppendVarint(b, f.wiretag+1) // end group
}
return b, nil
}
func consumeGroupSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
if wtyp != protowire.StartGroupType {
return unmarshalOutput{}, errUnknown
}
m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
mp := pointerOfIface(m)
out, err := f.mi.unmarshalPointer(b, mp, f.num, opts)
if err != nil {
return out, err
}
p.AppendPointerSlice(mp)
return out, nil
}
func asMessage(v reflect.Value) protoreflect.ProtoMessage {
if m, ok := v.Interface().(protoreflect.ProtoMessage); ok {
return m
}
return legacyWrapMessage(v).Interface()
}
// Copyright 2024 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
)
func makeOpaqueMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
mi := getMessageInfo(ft)
if mi == nil {
panic(fmt.Sprintf("invalid field: %v: unsupported message type %v", fd.FullName(), ft))
}
switch fd.Kind() {
case protoreflect.MessageKind:
return mi, pointerCoderFuncs{
size: sizeOpaqueMessage,
marshal: appendOpaqueMessage,
unmarshal: consumeOpaqueMessage,
isInit: isInitOpaqueMessage,
merge: mergeOpaqueMessage,
}
case protoreflect.GroupKind:
return mi, pointerCoderFuncs{
size: sizeOpaqueGroup,
marshal: appendOpaqueGroup,
unmarshal: consumeOpaqueGroup,
isInit: isInitOpaqueMessage,
merge: mergeOpaqueMessage,
}
}
panic("unexpected field kind")
}
func sizeOpaqueMessage(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return protowire.SizeBytes(f.mi.sizePointer(p.AtomicGetPointer(), opts)) + f.tagsize
}
func appendOpaqueMessage(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
mp := p.AtomicGetPointer()
calculatedSize := f.mi.sizePointer(mp, opts)
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(calculatedSize))
before := len(b)
b, err := f.mi.marshalAppendPointer(b, mp, opts)
if measuredSize := len(b) - before; calculatedSize != measuredSize && err == nil {
return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize)
}
return b, err
}
func consumeOpaqueMessage(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
mp := p.AtomicGetPointer()
if mp.IsNil() {
mp = p.AtomicSetPointerIfNil(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
}
o, err := f.mi.unmarshalPointer(v, mp, 0, opts)
if err != nil {
return out, err
}
out.n = n
out.initialized = o.initialized
return out, nil
}
func isInitOpaqueMessage(p pointer, f *coderFieldInfo) error {
mp := p.AtomicGetPointer()
if mp.IsNil() {
return nil
}
return f.mi.checkInitializedPointer(mp)
}
func mergeOpaqueMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
dstmp := dst.AtomicGetPointer()
if dstmp.IsNil() {
dstmp = dst.AtomicSetPointerIfNil(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
}
f.mi.mergePointer(dstmp, src.AtomicGetPointer(), opts)
}
func sizeOpaqueGroup(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return 2*f.tagsize + f.mi.sizePointer(p.AtomicGetPointer(), opts)
}
func appendOpaqueGroup(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, f.wiretag) // start group
b, err := f.mi.marshalAppendPointer(b, p.AtomicGetPointer(), opts)
b = protowire.AppendVarint(b, f.wiretag+1) // end group
return b, err
}
func consumeOpaqueGroup(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.StartGroupType {
return out, errUnknown
}
mp := p.AtomicGetPointer()
if mp.IsNil() {
mp = p.AtomicSetPointerIfNil(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
}
o, e := f.mi.unmarshalPointer(b, mp, f.num, opts)
return o, e
}
func makeOpaqueRepeatedMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
if ft.Kind() != reflect.Ptr || ft.Elem().Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid field: %v: unsupported type for opaque repeated message: %v", fd.FullName(), ft))
}
mt := ft.Elem().Elem() // *[]*T -> *T
mi := getMessageInfo(mt)
if mi == nil {
panic(fmt.Sprintf("invalid field: %v: unsupported message type %v", fd.FullName(), mt))
}
switch fd.Kind() {
case protoreflect.MessageKind:
return mi, pointerCoderFuncs{
size: sizeOpaqueMessageSlice,
marshal: appendOpaqueMessageSlice,
unmarshal: consumeOpaqueMessageSlice,
isInit: isInitOpaqueMessageSlice,
merge: mergeOpaqueMessageSlice,
}
case protoreflect.GroupKind:
return mi, pointerCoderFuncs{
size: sizeOpaqueGroupSlice,
marshal: appendOpaqueGroupSlice,
unmarshal: consumeOpaqueGroupSlice,
isInit: isInitOpaqueMessageSlice,
merge: mergeOpaqueMessageSlice,
}
}
panic("unexpected field kind")
}
func sizeOpaqueMessageSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := p.AtomicGetPointer().PointerSlice()
n := 0
for _, v := range s {
n += protowire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
}
return n
}
func appendOpaqueMessageSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := p.AtomicGetPointer().PointerSlice()
var err error
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
siz := f.mi.sizePointer(v, opts)
b = protowire.AppendVarint(b, uint64(siz))
before := len(b)
b, err = f.mi.marshalAppendPointer(b, v, opts)
if err != nil {
return b, err
}
if measuredSize := len(b) - before; siz != measuredSize {
return nil, errors.MismatchedSizeCalculation(siz, measuredSize)
}
}
return b, nil
}
func consumeOpaqueMessageSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
mp := pointerOfValue(reflect.New(f.mi.GoReflectType.Elem()))
o, err := f.mi.unmarshalPointer(v, mp, 0, opts)
if err != nil {
return out, err
}
sp := p.AtomicGetPointer()
if sp.IsNil() {
sp = p.AtomicSetPointerIfNil(pointerOfValue(reflect.New(f.ft.Elem())))
}
sp.AppendPointerSlice(mp)
out.n = n
out.initialized = o.initialized
return out, nil
}
func isInitOpaqueMessageSlice(p pointer, f *coderFieldInfo) error {
sp := p.AtomicGetPointer()
if sp.IsNil() {
return nil
}
s := sp.PointerSlice()
for _, v := range s {
if err := f.mi.checkInitializedPointer(v); err != nil {
return err
}
}
return nil
}
func mergeOpaqueMessageSlice(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
ds := dst.AtomicGetPointer()
if ds.IsNil() {
ds = dst.AtomicSetPointerIfNil(pointerOfValue(reflect.New(f.ft.Elem())))
}
for _, sp := range src.AtomicGetPointer().PointerSlice() {
dm := pointerOfValue(reflect.New(f.mi.GoReflectType.Elem()))
f.mi.mergePointer(dm, sp, opts)
ds.AppendPointerSlice(dm)
}
}
func sizeOpaqueGroupSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := p.AtomicGetPointer().PointerSlice()
n := 0
for _, v := range s {
n += 2*f.tagsize + f.mi.sizePointer(v, opts)
}
return n
}
func appendOpaqueGroupSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := p.AtomicGetPointer().PointerSlice()
var err error
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag) // start group
b, err = f.mi.marshalAppendPointer(b, v, opts)
if err != nil {
return b, err
}
b = protowire.AppendVarint(b, f.wiretag+1) // end group
}
return b, nil
}
func consumeOpaqueGroupSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.StartGroupType {
return out, errUnknown
}
mp := pointerOfValue(reflect.New(f.mi.GoReflectType.Elem()))
out, err = f.mi.unmarshalPointer(b, mp, f.num, opts)
if err != nil {
return out, err
}
sp := p.AtomicGetPointer()
if sp.IsNil() {
sp = p.AtomicSetPointerIfNil(pointerOfValue(reflect.New(f.ft.Elem())))
}
sp.AppendPointerSlice(mp)
return out, err
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package impl
import (
"math"
"unicode/utf8"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/reflect/protoreflect"
)
// sizeBool returns the size of wire encoding a bool pointer as a Bool.
func sizeBool(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Bool()
return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
}
// appendBool wire encodes a bool pointer as a Bool.
func appendBool(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Bool()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeBool(v))
return b, nil
}
// consumeBool wire decodes a bool pointer as a Bool.
func consumeBool(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Bool() = protowire.DecodeBool(v)
out.n = n
return out, nil
}
var coderBool = pointerCoderFuncs{
size: sizeBool,
marshal: appendBool,
unmarshal: consumeBool,
merge: mergeBool,
}
// sizeBoolNoZero returns the size of wire encoding a bool pointer as a Bool.
// The zero value is not encoded.
func sizeBoolNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Bool()
if v == false {
return 0
}
return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
}
// appendBoolNoZero wire encodes a bool pointer as a Bool.
// The zero value is not encoded.
func appendBoolNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Bool()
if v == false {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeBool(v))
return b, nil
}
var coderBoolNoZero = pointerCoderFuncs{
size: sizeBoolNoZero,
marshal: appendBoolNoZero,
unmarshal: consumeBool,
merge: mergeBoolNoZero,
}
// sizeBoolPtr returns the size of wire encoding a *bool pointer as a Bool.
// It panics if the pointer is nil.
func sizeBoolPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.BoolPtr()
return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
}
// appendBoolPtr wire encodes a *bool pointer as a Bool.
// It panics if the pointer is nil.
func appendBoolPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.BoolPtr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeBool(v))
return b, nil
}
// consumeBoolPtr wire decodes a *bool pointer as a Bool.
func consumeBoolPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.BoolPtr()
if *vp == nil {
*vp = new(bool)
}
**vp = protowire.DecodeBool(v)
out.n = n
return out, nil
}
var coderBoolPtr = pointerCoderFuncs{
size: sizeBoolPtr,
marshal: appendBoolPtr,
unmarshal: consumeBoolPtr,
merge: mergeBoolPtr,
}
// sizeBoolSlice returns the size of wire encoding a []bool pointer as a repeated Bool.
func sizeBoolSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.BoolSlice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
}
return size
}
// appendBoolSlice encodes a []bool pointer as a repeated Bool.
func appendBoolSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.BoolSlice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeBool(v))
}
return b, nil
}
// consumeBoolSlice wire decodes a []bool pointer as a repeated Bool.
func consumeBoolSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.BoolSlice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growBoolSlice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, protowire.DecodeBool(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, protowire.DecodeBool(v))
out.n = n
return out, nil
}
var coderBoolSlice = pointerCoderFuncs{
size: sizeBoolSlice,
marshal: appendBoolSlice,
unmarshal: consumeBoolSlice,
merge: mergeBoolSlice,
}
// sizeBoolPackedSlice returns the size of wire encoding a []bool pointer as a packed repeated Bool.
func sizeBoolPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.BoolSlice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(protowire.EncodeBool(v))
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool.
func appendBoolPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.BoolSlice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(protowire.EncodeBool(v))
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, protowire.EncodeBool(v))
}
return b, nil
}
var coderBoolPackedSlice = pointerCoderFuncs{
size: sizeBoolPackedSlice,
marshal: appendBoolPackedSlice,
unmarshal: consumeBoolSlice,
merge: mergeBoolSlice,
}
// sizeBoolValue returns the size of wire encoding a bool value as a Bool.
func sizeBoolValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
}
// appendBoolValue encodes a bool value as a Bool.
func appendBoolValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
return b, nil
}
// consumeBoolValue decodes a bool value as a Bool.
func consumeBoolValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfBool(protowire.DecodeBool(v)), out, nil
}
var coderBoolValue = valueCoderFuncs{
size: sizeBoolValue,
marshal: appendBoolValue,
unmarshal: consumeBoolValue,
merge: mergeScalarValue,
}
// sizeBoolSliceValue returns the size of wire encoding a []bool value as a repeated Bool.
func sizeBoolSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
}
return size
}
// appendBoolSliceValue encodes a []bool value as a repeated Bool.
func appendBoolSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
}
return b, nil
}
// consumeBoolSliceValue wire decodes a []bool value as a repeated Bool.
func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
out.n = n
return listv, out, nil
}
var coderBoolSliceValue = valueCoderFuncs{
size: sizeBoolSliceValue,
marshal: appendBoolSliceValue,
unmarshal: consumeBoolSliceValue,
merge: mergeListValue,
}
// sizeBoolPackedSliceValue returns the size of wire encoding a []bool value as a packed repeated Bool.
func sizeBoolPackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
}
return tagsize + protowire.SizeBytes(n)
}
// appendBoolPackedSliceValue encodes a []bool value as a packed repeated Bool.
func appendBoolPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
}
return b, nil
}
var coderBoolPackedSliceValue = valueCoderFuncs{
size: sizeBoolPackedSliceValue,
marshal: appendBoolPackedSliceValue,
unmarshal: consumeBoolSliceValue,
merge: mergeListValue,
}
// sizeEnumValue returns the size of wire encoding a value as a Enum.
func sizeEnumValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(uint64(v.Enum()))
}
// appendEnumValue encodes a value as a Enum.
func appendEnumValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(v.Enum()))
return b, nil
}
// consumeEnumValue decodes a value as a Enum.
func consumeEnumValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), out, nil
}
var coderEnumValue = valueCoderFuncs{
size: sizeEnumValue,
marshal: appendEnumValue,
unmarshal: consumeEnumValue,
merge: mergeScalarValue,
}
// sizeEnumSliceValue returns the size of wire encoding a [] value as a repeated Enum.
func sizeEnumSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(uint64(v.Enum()))
}
return size
}
// appendEnumSliceValue encodes a [] value as a repeated Enum.
func appendEnumSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(v.Enum()))
}
return b, nil
}
// consumeEnumSliceValue wire decodes a [] value as a repeated Enum.
func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
out.n = n
return listv, out, nil
}
var coderEnumSliceValue = valueCoderFuncs{
size: sizeEnumSliceValue,
marshal: appendEnumSliceValue,
unmarshal: consumeEnumSliceValue,
merge: mergeListValue,
}
// sizeEnumPackedSliceValue returns the size of wire encoding a [] value as a packed repeated Enum.
func sizeEnumPackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(v.Enum()))
}
return tagsize + protowire.SizeBytes(n)
}
// appendEnumPackedSliceValue encodes a [] value as a packed repeated Enum.
func appendEnumPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(v.Enum()))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, uint64(v.Enum()))
}
return b, nil
}
var coderEnumPackedSliceValue = valueCoderFuncs{
size: sizeEnumPackedSliceValue,
marshal: appendEnumPackedSliceValue,
unmarshal: consumeEnumSliceValue,
merge: mergeListValue,
}
// sizeInt32 returns the size of wire encoding a int32 pointer as a Int32.
func sizeInt32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int32()
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendInt32 wire encodes a int32 pointer as a Int32.
func appendInt32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int32()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
// consumeInt32 wire decodes a int32 pointer as a Int32.
func consumeInt32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Int32() = int32(v)
out.n = n
return out, nil
}
var coderInt32 = pointerCoderFuncs{
size: sizeInt32,
marshal: appendInt32,
unmarshal: consumeInt32,
merge: mergeInt32,
}
// sizeInt32NoZero returns the size of wire encoding a int32 pointer as a Int32.
// The zero value is not encoded.
func sizeInt32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int32()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendInt32NoZero wire encodes a int32 pointer as a Int32.
// The zero value is not encoded.
func appendInt32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int32()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
var coderInt32NoZero = pointerCoderFuncs{
size: sizeInt32NoZero,
marshal: appendInt32NoZero,
unmarshal: consumeInt32,
merge: mergeInt32NoZero,
}
// sizeInt32Ptr returns the size of wire encoding a *int32 pointer as a Int32.
// It panics if the pointer is nil.
func sizeInt32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.Int32Ptr()
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendInt32Ptr wire encodes a *int32 pointer as a Int32.
// It panics if the pointer is nil.
func appendInt32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Int32Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
// consumeInt32Ptr wire decodes a *int32 pointer as a Int32.
func consumeInt32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.Int32Ptr()
if *vp == nil {
*vp = new(int32)
}
**vp = int32(v)
out.n = n
return out, nil
}
var coderInt32Ptr = pointerCoderFuncs{
size: sizeInt32Ptr,
marshal: appendInt32Ptr,
unmarshal: consumeInt32Ptr,
merge: mergeInt32Ptr,
}
// sizeInt32Slice returns the size of wire encoding a []int32 pointer as a repeated Int32.
func sizeInt32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int32Slice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(uint64(v))
}
return size
}
// appendInt32Slice encodes a []int32 pointer as a repeated Int32.
func appendInt32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int32Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
}
return b, nil
}
// consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32.
func consumeInt32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Int32Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growInt32Slice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, int32(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, int32(v))
out.n = n
return out, nil
}
var coderInt32Slice = pointerCoderFuncs{
size: sizeInt32Slice,
marshal: appendInt32Slice,
unmarshal: consumeInt32Slice,
merge: mergeInt32Slice,
}
// sizeInt32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Int32.
func sizeInt32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int32Slice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(uint64(v))
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32.
func appendInt32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int32Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(uint64(v))
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, uint64(v))
}
return b, nil
}
var coderInt32PackedSlice = pointerCoderFuncs{
size: sizeInt32PackedSlice,
marshal: appendInt32PackedSlice,
unmarshal: consumeInt32Slice,
merge: mergeInt32Slice,
}
// sizeInt32Value returns the size of wire encoding a int32 value as a Int32.
func sizeInt32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
}
// appendInt32Value encodes a int32 value as a Int32.
func appendInt32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(int32(v.Int())))
return b, nil
}
// consumeInt32Value decodes a int32 value as a Int32.
func consumeInt32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfInt32(int32(v)), out, nil
}
var coderInt32Value = valueCoderFuncs{
size: sizeInt32Value,
marshal: appendInt32Value,
unmarshal: consumeInt32Value,
merge: mergeScalarValue,
}
// sizeInt32SliceValue returns the size of wire encoding a []int32 value as a repeated Int32.
func sizeInt32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
}
return size
}
// appendInt32SliceValue encodes a []int32 value as a repeated Int32.
func appendInt32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(int32(v.Int())))
}
return b, nil
}
// consumeInt32SliceValue wire decodes a []int32 value as a repeated Int32.
func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(v)))
out.n = n
return listv, out, nil
}
var coderInt32SliceValue = valueCoderFuncs{
size: sizeInt32SliceValue,
marshal: appendInt32SliceValue,
unmarshal: consumeInt32SliceValue,
merge: mergeListValue,
}
// sizeInt32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Int32.
func sizeInt32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(int32(v.Int())))
}
return tagsize + protowire.SizeBytes(n)
}
// appendInt32PackedSliceValue encodes a []int32 value as a packed repeated Int32.
func appendInt32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(int32(v.Int())))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, uint64(int32(v.Int())))
}
return b, nil
}
var coderInt32PackedSliceValue = valueCoderFuncs{
size: sizeInt32PackedSliceValue,
marshal: appendInt32PackedSliceValue,
unmarshal: consumeInt32SliceValue,
merge: mergeListValue,
}
// sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32.
func sizeSint32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int32()
return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
}
// appendSint32 wire encodes a int32 pointer as a Sint32.
func appendSint32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int32()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
return b, nil
}
// consumeSint32 wire decodes a int32 pointer as a Sint32.
func consumeSint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Int32() = int32(protowire.DecodeZigZag(v & math.MaxUint32))
out.n = n
return out, nil
}
var coderSint32 = pointerCoderFuncs{
size: sizeSint32,
marshal: appendSint32,
unmarshal: consumeSint32,
merge: mergeInt32,
}
// sizeSint32NoZero returns the size of wire encoding a int32 pointer as a Sint32.
// The zero value is not encoded.
func sizeSint32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int32()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
}
// appendSint32NoZero wire encodes a int32 pointer as a Sint32.
// The zero value is not encoded.
func appendSint32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int32()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
return b, nil
}
var coderSint32NoZero = pointerCoderFuncs{
size: sizeSint32NoZero,
marshal: appendSint32NoZero,
unmarshal: consumeSint32,
merge: mergeInt32NoZero,
}
// sizeSint32Ptr returns the size of wire encoding a *int32 pointer as a Sint32.
// It panics if the pointer is nil.
func sizeSint32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.Int32Ptr()
return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
}
// appendSint32Ptr wire encodes a *int32 pointer as a Sint32.
// It panics if the pointer is nil.
func appendSint32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Int32Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
return b, nil
}
// consumeSint32Ptr wire decodes a *int32 pointer as a Sint32.
func consumeSint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.Int32Ptr()
if *vp == nil {
*vp = new(int32)
}
**vp = int32(protowire.DecodeZigZag(v & math.MaxUint32))
out.n = n
return out, nil
}
var coderSint32Ptr = pointerCoderFuncs{
size: sizeSint32Ptr,
marshal: appendSint32Ptr,
unmarshal: consumeSint32Ptr,
merge: mergeInt32Ptr,
}
// sizeSint32Slice returns the size of wire encoding a []int32 pointer as a repeated Sint32.
func sizeSint32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int32Slice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
}
return size
}
// appendSint32Slice encodes a []int32 pointer as a repeated Sint32.
func appendSint32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int32Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
}
return b, nil
}
// consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32.
func consumeSint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Int32Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growInt32Slice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
out.n = n
return out, nil
}
var coderSint32Slice = pointerCoderFuncs{
size: sizeSint32Slice,
marshal: appendSint32Slice,
unmarshal: consumeSint32Slice,
merge: mergeInt32Slice,
}
// sizeSint32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sint32.
func sizeSint32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int32Slice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32.
func appendSint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int32Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
}
return b, nil
}
var coderSint32PackedSlice = pointerCoderFuncs{
size: sizeSint32PackedSlice,
marshal: appendSint32PackedSlice,
unmarshal: consumeSint32Slice,
merge: mergeInt32Slice,
}
// sizeSint32Value returns the size of wire encoding a int32 value as a Sint32.
func sizeSint32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
}
// appendSint32Value encodes a int32 value as a Sint32.
func appendSint32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
return b, nil
}
// consumeSint32Value decodes a int32 value as a Sint32.
func consumeSint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), out, nil
}
var coderSint32Value = valueCoderFuncs{
size: sizeSint32Value,
marshal: appendSint32Value,
unmarshal: consumeSint32Value,
merge: mergeScalarValue,
}
// sizeSint32SliceValue returns the size of wire encoding a []int32 value as a repeated Sint32.
func sizeSint32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
}
return size
}
// appendSint32SliceValue encodes a []int32 value as a repeated Sint32.
func appendSint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
}
return b, nil
}
// consumeSint32SliceValue wire decodes a []int32 value as a repeated Sint32.
func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
out.n = n
return listv, out, nil
}
var coderSint32SliceValue = valueCoderFuncs{
size: sizeSint32SliceValue,
marshal: appendSint32SliceValue,
unmarshal: consumeSint32SliceValue,
merge: mergeListValue,
}
// sizeSint32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sint32.
func sizeSint32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
}
return tagsize + protowire.SizeBytes(n)
}
// appendSint32PackedSliceValue encodes a []int32 value as a packed repeated Sint32.
func appendSint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
}
return b, nil
}
var coderSint32PackedSliceValue = valueCoderFuncs{
size: sizeSint32PackedSliceValue,
marshal: appendSint32PackedSliceValue,
unmarshal: consumeSint32SliceValue,
merge: mergeListValue,
}
// sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32.
func sizeUint32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Uint32()
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendUint32 wire encodes a uint32 pointer as a Uint32.
func appendUint32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint32()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
// consumeUint32 wire decodes a uint32 pointer as a Uint32.
func consumeUint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Uint32() = uint32(v)
out.n = n
return out, nil
}
var coderUint32 = pointerCoderFuncs{
size: sizeUint32,
marshal: appendUint32,
unmarshal: consumeUint32,
merge: mergeUint32,
}
// sizeUint32NoZero returns the size of wire encoding a uint32 pointer as a Uint32.
// The zero value is not encoded.
func sizeUint32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Uint32()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendUint32NoZero wire encodes a uint32 pointer as a Uint32.
// The zero value is not encoded.
func appendUint32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint32()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
var coderUint32NoZero = pointerCoderFuncs{
size: sizeUint32NoZero,
marshal: appendUint32NoZero,
unmarshal: consumeUint32,
merge: mergeUint32NoZero,
}
// sizeUint32Ptr returns the size of wire encoding a *uint32 pointer as a Uint32.
// It panics if the pointer is nil.
func sizeUint32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.Uint32Ptr()
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendUint32Ptr wire encodes a *uint32 pointer as a Uint32.
// It panics if the pointer is nil.
func appendUint32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Uint32Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
// consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32.
func consumeUint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.Uint32Ptr()
if *vp == nil {
*vp = new(uint32)
}
**vp = uint32(v)
out.n = n
return out, nil
}
var coderUint32Ptr = pointerCoderFuncs{
size: sizeUint32Ptr,
marshal: appendUint32Ptr,
unmarshal: consumeUint32Ptr,
merge: mergeUint32Ptr,
}
// sizeUint32Slice returns the size of wire encoding a []uint32 pointer as a repeated Uint32.
func sizeUint32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint32Slice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(uint64(v))
}
return size
}
// appendUint32Slice encodes a []uint32 pointer as a repeated Uint32.
func appendUint32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint32Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
}
return b, nil
}
// consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32.
func consumeUint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Uint32Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growUint32Slice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, uint32(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, uint32(v))
out.n = n
return out, nil
}
var coderUint32Slice = pointerCoderFuncs{
size: sizeUint32Slice,
marshal: appendUint32Slice,
unmarshal: consumeUint32Slice,
merge: mergeUint32Slice,
}
// sizeUint32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Uint32.
func sizeUint32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint32Slice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(uint64(v))
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32.
func appendUint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint32Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(uint64(v))
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, uint64(v))
}
return b, nil
}
var coderUint32PackedSlice = pointerCoderFuncs{
size: sizeUint32PackedSlice,
marshal: appendUint32PackedSlice,
unmarshal: consumeUint32Slice,
merge: mergeUint32Slice,
}
// sizeUint32Value returns the size of wire encoding a uint32 value as a Uint32.
func sizeUint32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
}
// appendUint32Value encodes a uint32 value as a Uint32.
func appendUint32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
return b, nil
}
// consumeUint32Value decodes a uint32 value as a Uint32.
func consumeUint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfUint32(uint32(v)), out, nil
}
var coderUint32Value = valueCoderFuncs{
size: sizeUint32Value,
marshal: appendUint32Value,
unmarshal: consumeUint32Value,
merge: mergeScalarValue,
}
// sizeUint32SliceValue returns the size of wire encoding a []uint32 value as a repeated Uint32.
func sizeUint32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
}
return size
}
// appendUint32SliceValue encodes a []uint32 value as a repeated Uint32.
func appendUint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
}
return b, nil
}
// consumeUint32SliceValue wire decodes a []uint32 value as a repeated Uint32.
func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint32(uint32(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint32(uint32(v)))
out.n = n
return listv, out, nil
}
var coderUint32SliceValue = valueCoderFuncs{
size: sizeUint32SliceValue,
marshal: appendUint32SliceValue,
unmarshal: consumeUint32SliceValue,
merge: mergeListValue,
}
// sizeUint32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Uint32.
func sizeUint32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(uint32(v.Uint())))
}
return tagsize + protowire.SizeBytes(n)
}
// appendUint32PackedSliceValue encodes a []uint32 value as a packed repeated Uint32.
func appendUint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(uint32(v.Uint())))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
}
return b, nil
}
var coderUint32PackedSliceValue = valueCoderFuncs{
size: sizeUint32PackedSliceValue,
marshal: appendUint32PackedSliceValue,
unmarshal: consumeUint32SliceValue,
merge: mergeListValue,
}
// sizeInt64 returns the size of wire encoding a int64 pointer as a Int64.
func sizeInt64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int64()
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendInt64 wire encodes a int64 pointer as a Int64.
func appendInt64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int64()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
// consumeInt64 wire decodes a int64 pointer as a Int64.
func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Int64() = int64(v)
out.n = n
return out, nil
}
var coderInt64 = pointerCoderFuncs{
size: sizeInt64,
marshal: appendInt64,
unmarshal: consumeInt64,
merge: mergeInt64,
}
// sizeInt64NoZero returns the size of wire encoding a int64 pointer as a Int64.
// The zero value is not encoded.
func sizeInt64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int64()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendInt64NoZero wire encodes a int64 pointer as a Int64.
// The zero value is not encoded.
func appendInt64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int64()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
var coderInt64NoZero = pointerCoderFuncs{
size: sizeInt64NoZero,
marshal: appendInt64NoZero,
unmarshal: consumeInt64,
merge: mergeInt64NoZero,
}
// sizeInt64Ptr returns the size of wire encoding a *int64 pointer as a Int64.
// It panics if the pointer is nil.
func sizeInt64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.Int64Ptr()
return f.tagsize + protowire.SizeVarint(uint64(v))
}
// appendInt64Ptr wire encodes a *int64 pointer as a Int64.
// It panics if the pointer is nil.
func appendInt64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Int64Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
return b, nil
}
// consumeInt64Ptr wire decodes a *int64 pointer as a Int64.
func consumeInt64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.Int64Ptr()
if *vp == nil {
*vp = new(int64)
}
**vp = int64(v)
out.n = n
return out, nil
}
var coderInt64Ptr = pointerCoderFuncs{
size: sizeInt64Ptr,
marshal: appendInt64Ptr,
unmarshal: consumeInt64Ptr,
merge: mergeInt64Ptr,
}
// sizeInt64Slice returns the size of wire encoding a []int64 pointer as a repeated Int64.
func sizeInt64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int64Slice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(uint64(v))
}
return size
}
// appendInt64Slice encodes a []int64 pointer as a repeated Int64.
func appendInt64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int64Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, uint64(v))
}
return b, nil
}
// consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64.
func consumeInt64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Int64Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growInt64Slice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, int64(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, int64(v))
out.n = n
return out, nil
}
var coderInt64Slice = pointerCoderFuncs{
size: sizeInt64Slice,
marshal: appendInt64Slice,
unmarshal: consumeInt64Slice,
merge: mergeInt64Slice,
}
// sizeInt64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Int64.
func sizeInt64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int64Slice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(uint64(v))
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64.
func appendInt64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int64Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(uint64(v))
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, uint64(v))
}
return b, nil
}
var coderInt64PackedSlice = pointerCoderFuncs{
size: sizeInt64PackedSlice,
marshal: appendInt64PackedSlice,
unmarshal: consumeInt64Slice,
merge: mergeInt64Slice,
}
// sizeInt64Value returns the size of wire encoding a int64 value as a Int64.
func sizeInt64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(uint64(v.Int()))
}
// appendInt64Value encodes a int64 value as a Int64.
func appendInt64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(v.Int()))
return b, nil
}
// consumeInt64Value decodes a int64 value as a Int64.
func consumeInt64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfInt64(int64(v)), out, nil
}
var coderInt64Value = valueCoderFuncs{
size: sizeInt64Value,
marshal: appendInt64Value,
unmarshal: consumeInt64Value,
merge: mergeScalarValue,
}
// sizeInt64SliceValue returns the size of wire encoding a []int64 value as a repeated Int64.
func sizeInt64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(uint64(v.Int()))
}
return size
}
// appendInt64SliceValue encodes a []int64 value as a repeated Int64.
func appendInt64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, uint64(v.Int()))
}
return b, nil
}
// consumeInt64SliceValue wire decodes a []int64 value as a repeated Int64.
func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt64(int64(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt64(int64(v)))
out.n = n
return listv, out, nil
}
var coderInt64SliceValue = valueCoderFuncs{
size: sizeInt64SliceValue,
marshal: appendInt64SliceValue,
unmarshal: consumeInt64SliceValue,
merge: mergeListValue,
}
// sizeInt64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Int64.
func sizeInt64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(v.Int()))
}
return tagsize + protowire.SizeBytes(n)
}
// appendInt64PackedSliceValue encodes a []int64 value as a packed repeated Int64.
func appendInt64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(uint64(v.Int()))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, uint64(v.Int()))
}
return b, nil
}
var coderInt64PackedSliceValue = valueCoderFuncs{
size: sizeInt64PackedSliceValue,
marshal: appendInt64PackedSliceValue,
unmarshal: consumeInt64SliceValue,
merge: mergeListValue,
}
// sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64.
func sizeSint64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int64()
return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
}
// appendSint64 wire encodes a int64 pointer as a Sint64.
func appendSint64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int64()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
return b, nil
}
// consumeSint64 wire decodes a int64 pointer as a Sint64.
func consumeSint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Int64() = protowire.DecodeZigZag(v)
out.n = n
return out, nil
}
var coderSint64 = pointerCoderFuncs{
size: sizeSint64,
marshal: appendSint64,
unmarshal: consumeSint64,
merge: mergeInt64,
}
// sizeSint64NoZero returns the size of wire encoding a int64 pointer as a Sint64.
// The zero value is not encoded.
func sizeSint64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int64()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
}
// appendSint64NoZero wire encodes a int64 pointer as a Sint64.
// The zero value is not encoded.
func appendSint64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int64()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
return b, nil
}
var coderSint64NoZero = pointerCoderFuncs{
size: sizeSint64NoZero,
marshal: appendSint64NoZero,
unmarshal: consumeSint64,
merge: mergeInt64NoZero,
}
// sizeSint64Ptr returns the size of wire encoding a *int64 pointer as a Sint64.
// It panics if the pointer is nil.
func sizeSint64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.Int64Ptr()
return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
}
// appendSint64Ptr wire encodes a *int64 pointer as a Sint64.
// It panics if the pointer is nil.
func appendSint64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Int64Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
return b, nil
}
// consumeSint64Ptr wire decodes a *int64 pointer as a Sint64.
func consumeSint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.Int64Ptr()
if *vp == nil {
*vp = new(int64)
}
**vp = protowire.DecodeZigZag(v)
out.n = n
return out, nil
}
var coderSint64Ptr = pointerCoderFuncs{
size: sizeSint64Ptr,
marshal: appendSint64Ptr,
unmarshal: consumeSint64Ptr,
merge: mergeInt64Ptr,
}
// sizeSint64Slice returns the size of wire encoding a []int64 pointer as a repeated Sint64.
func sizeSint64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int64Slice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
}
return size
}
// appendSint64Slice encodes a []int64 pointer as a repeated Sint64.
func appendSint64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int64Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
}
return b, nil
}
// consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64.
func consumeSint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Int64Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growInt64Slice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, protowire.DecodeZigZag(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, protowire.DecodeZigZag(v))
out.n = n
return out, nil
}
var coderSint64Slice = pointerCoderFuncs{
size: sizeSint64Slice,
marshal: appendSint64Slice,
unmarshal: consumeSint64Slice,
merge: mergeInt64Slice,
}
// sizeSint64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sint64.
func sizeSint64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int64Slice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(protowire.EncodeZigZag(v))
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64.
func appendSint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int64Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(protowire.EncodeZigZag(v))
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
}
return b, nil
}
var coderSint64PackedSlice = pointerCoderFuncs{
size: sizeSint64PackedSlice,
marshal: appendSint64PackedSlice,
unmarshal: consumeSint64Slice,
merge: mergeInt64Slice,
}
// sizeSint64Value returns the size of wire encoding a int64 value as a Sint64.
func sizeSint64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
}
// appendSint64Value encodes a int64 value as a Sint64.
func appendSint64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
return b, nil
}
// consumeSint64Value decodes a int64 value as a Sint64.
func consumeSint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), out, nil
}
var coderSint64Value = valueCoderFuncs{
size: sizeSint64Value,
marshal: appendSint64Value,
unmarshal: consumeSint64Value,
merge: mergeScalarValue,
}
// sizeSint64SliceValue returns the size of wire encoding a []int64 value as a repeated Sint64.
func sizeSint64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
}
return size
}
// appendSint64SliceValue encodes a []int64 value as a repeated Sint64.
func appendSint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
}
return b, nil
}
// consumeSint64SliceValue wire decodes a []int64 value as a repeated Sint64.
func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
out.n = n
return listv, out, nil
}
var coderSint64SliceValue = valueCoderFuncs{
size: sizeSint64SliceValue,
marshal: appendSint64SliceValue,
unmarshal: consumeSint64SliceValue,
merge: mergeListValue,
}
// sizeSint64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sint64.
func sizeSint64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
}
return tagsize + protowire.SizeBytes(n)
}
// appendSint64PackedSliceValue encodes a []int64 value as a packed repeated Sint64.
func appendSint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
}
return b, nil
}
var coderSint64PackedSliceValue = valueCoderFuncs{
size: sizeSint64PackedSliceValue,
marshal: appendSint64PackedSliceValue,
unmarshal: consumeSint64SliceValue,
merge: mergeListValue,
}
// sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64.
func sizeUint64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Uint64()
return f.tagsize + protowire.SizeVarint(v)
}
// appendUint64 wire encodes a uint64 pointer as a Uint64.
func appendUint64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint64()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, v)
return b, nil
}
// consumeUint64 wire decodes a uint64 pointer as a Uint64.
func consumeUint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*p.Uint64() = v
out.n = n
return out, nil
}
var coderUint64 = pointerCoderFuncs{
size: sizeUint64,
marshal: appendUint64,
unmarshal: consumeUint64,
merge: mergeUint64,
}
// sizeUint64NoZero returns the size of wire encoding a uint64 pointer as a Uint64.
// The zero value is not encoded.
func sizeUint64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Uint64()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeVarint(v)
}
// appendUint64NoZero wire encodes a uint64 pointer as a Uint64.
// The zero value is not encoded.
func appendUint64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint64()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, v)
return b, nil
}
var coderUint64NoZero = pointerCoderFuncs{
size: sizeUint64NoZero,
marshal: appendUint64NoZero,
unmarshal: consumeUint64,
merge: mergeUint64NoZero,
}
// sizeUint64Ptr returns the size of wire encoding a *uint64 pointer as a Uint64.
// It panics if the pointer is nil.
func sizeUint64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.Uint64Ptr()
return f.tagsize + protowire.SizeVarint(v)
}
// appendUint64Ptr wire encodes a *uint64 pointer as a Uint64.
// It panics if the pointer is nil.
func appendUint64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Uint64Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, v)
return b, nil
}
// consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64.
func consumeUint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
vp := p.Uint64Ptr()
if *vp == nil {
*vp = new(uint64)
}
**vp = v
out.n = n
return out, nil
}
var coderUint64Ptr = pointerCoderFuncs{
size: sizeUint64Ptr,
marshal: appendUint64Ptr,
unmarshal: consumeUint64Ptr,
merge: mergeUint64Ptr,
}
// sizeUint64Slice returns the size of wire encoding a []uint64 pointer as a repeated Uint64.
func sizeUint64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint64Slice()
for _, v := range s {
size += f.tagsize + protowire.SizeVarint(v)
}
return size
}
// appendUint64Slice encodes a []uint64 pointer as a repeated Uint64.
func appendUint64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint64Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendVarint(b, v)
}
return b, nil
}
// consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64.
func consumeUint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Uint64Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := 0
for _, v := range b {
if v < 0x80 {
count++
}
}
if count > 0 {
p.growUint64Slice(count)
}
s := *sp
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
s = append(s, v)
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.VarintType {
return out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return out, errDecode
}
*sp = append(*sp, v)
out.n = n
return out, nil
}
var coderUint64Slice = pointerCoderFuncs{
size: sizeUint64Slice,
marshal: appendUint64Slice,
unmarshal: consumeUint64Slice,
merge: mergeUint64Slice,
}
// sizeUint64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Uint64.
func sizeUint64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint64Slice()
if len(s) == 0 {
return 0
}
n := 0
for _, v := range s {
n += protowire.SizeVarint(v)
}
return f.tagsize + protowire.SizeBytes(n)
}
// appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64.
func appendUint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint64Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := 0
for _, v := range s {
n += protowire.SizeVarint(v)
}
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendVarint(b, v)
}
return b, nil
}
var coderUint64PackedSlice = pointerCoderFuncs{
size: sizeUint64PackedSlice,
marshal: appendUint64PackedSlice,
unmarshal: consumeUint64Slice,
merge: mergeUint64Slice,
}
// sizeUint64Value returns the size of wire encoding a uint64 value as a Uint64.
func sizeUint64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeVarint(v.Uint())
}
// appendUint64Value encodes a uint64 value as a Uint64.
func appendUint64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, v.Uint())
return b, nil
}
// consumeUint64Value decodes a uint64 value as a Uint64.
func consumeUint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfUint64(v), out, nil
}
var coderUint64Value = valueCoderFuncs{
size: sizeUint64Value,
marshal: appendUint64Value,
unmarshal: consumeUint64Value,
merge: mergeScalarValue,
}
// sizeUint64SliceValue returns the size of wire encoding a []uint64 value as a repeated Uint64.
func sizeUint64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeVarint(v.Uint())
}
return size
}
// appendUint64SliceValue encodes a []uint64 value as a repeated Uint64.
func appendUint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendVarint(b, v.Uint())
}
return b, nil
}
// consumeUint64SliceValue wire decodes a []uint64 value as a repeated Uint64.
func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint64(v))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.VarintType {
return protoreflect.Value{}, out, errUnknown
}
var v uint64
var n int
if len(b) >= 1 && b[0] < 0x80 {
v = uint64(b[0])
n = 1
} else if len(b) >= 2 && b[1] < 128 {
v = uint64(b[0]&0x7f) + uint64(b[1])<<7
n = 2
} else {
v, n = protowire.ConsumeVarint(b)
}
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint64(v))
out.n = n
return listv, out, nil
}
var coderUint64SliceValue = valueCoderFuncs{
size: sizeUint64SliceValue,
marshal: appendUint64SliceValue,
unmarshal: consumeUint64SliceValue,
merge: mergeListValue,
}
// sizeUint64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Uint64.
func sizeUint64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := 0
for i, llen := 0, llen; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(v.Uint())
}
return tagsize + protowire.SizeBytes(n)
}
// appendUint64PackedSliceValue encodes a []uint64 value as a packed repeated Uint64.
func appendUint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := 0
for i := 0; i < llen; i++ {
v := list.Get(i)
n += protowire.SizeVarint(v.Uint())
}
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, v.Uint())
}
return b, nil
}
var coderUint64PackedSliceValue = valueCoderFuncs{
size: sizeUint64PackedSliceValue,
marshal: appendUint64PackedSliceValue,
unmarshal: consumeUint64SliceValue,
merge: mergeListValue,
}
// sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32.
func sizeSfixed32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed32()
}
// appendSfixed32 wire encodes a int32 pointer as a Sfixed32.
func appendSfixed32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int32()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, uint32(v))
return b, nil
}
// consumeSfixed32 wire decodes a int32 pointer as a Sfixed32.
func consumeSfixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
*p.Int32() = int32(v)
out.n = n
return out, nil
}
var coderSfixed32 = pointerCoderFuncs{
size: sizeSfixed32,
marshal: appendSfixed32,
unmarshal: consumeSfixed32,
merge: mergeInt32,
}
// sizeSfixed32NoZero returns the size of wire encoding a int32 pointer as a Sfixed32.
// The zero value is not encoded.
func sizeSfixed32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int32()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeFixed32()
}
// appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32.
// The zero value is not encoded.
func appendSfixed32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int32()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, uint32(v))
return b, nil
}
var coderSfixed32NoZero = pointerCoderFuncs{
size: sizeSfixed32NoZero,
marshal: appendSfixed32NoZero,
unmarshal: consumeSfixed32,
merge: mergeInt32NoZero,
}
// sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32.
// It panics if the pointer is nil.
func sizeSfixed32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed32()
}
// appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32.
// It panics if the pointer is nil.
func appendSfixed32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Int32Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, uint32(v))
return b, nil
}
// consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32.
func consumeSfixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
vp := p.Int32Ptr()
if *vp == nil {
*vp = new(int32)
}
**vp = int32(v)
out.n = n
return out, nil
}
var coderSfixed32Ptr = pointerCoderFuncs{
size: sizeSfixed32Ptr,
marshal: appendSfixed32Ptr,
unmarshal: consumeSfixed32Ptr,
merge: mergeInt32Ptr,
}
// sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32.
func sizeSfixed32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int32Slice()
size = len(s) * (f.tagsize + protowire.SizeFixed32())
return size
}
// appendSfixed32Slice encodes a []int32 pointer as a repeated Sfixed32.
func appendSfixed32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int32Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, uint32(v))
}
return b, nil
}
// consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32.
func consumeSfixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Int32Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := len(b) / protowire.SizeFixed32()
if count > 0 {
p.growInt32Slice(count)
}
s := *sp
for len(b) > 0 {
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
s = append(s, int32(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, int32(v))
out.n = n
return out, nil
}
var coderSfixed32Slice = pointerCoderFuncs{
size: sizeSfixed32Slice,
marshal: appendSfixed32Slice,
unmarshal: consumeSfixed32Slice,
merge: mergeInt32Slice,
}
// sizeSfixed32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sfixed32.
func sizeSfixed32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int32Slice()
if len(s) == 0 {
return 0
}
n := len(s) * protowire.SizeFixed32()
return f.tagsize + protowire.SizeBytes(n)
}
// appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32.
func appendSfixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int32Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := len(s) * protowire.SizeFixed32()
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendFixed32(b, uint32(v))
}
return b, nil
}
var coderSfixed32PackedSlice = pointerCoderFuncs{
size: sizeSfixed32PackedSlice,
marshal: appendSfixed32PackedSlice,
unmarshal: consumeSfixed32Slice,
merge: mergeInt32Slice,
}
// sizeSfixed32Value returns the size of wire encoding a int32 value as a Sfixed32.
func sizeSfixed32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeFixed32()
}
// appendSfixed32Value encodes a int32 value as a Sfixed32.
func appendSfixed32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed32(b, uint32(v.Int()))
return b, nil
}
// consumeSfixed32Value decodes a int32 value as a Sfixed32.
func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfInt32(int32(v)), out, nil
}
var coderSfixed32Value = valueCoderFuncs{
size: sizeSfixed32Value,
marshal: appendSfixed32Value,
unmarshal: consumeSfixed32Value,
merge: mergeScalarValue,
}
// sizeSfixed32SliceValue returns the size of wire encoding a []int32 value as a repeated Sfixed32.
func sizeSfixed32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
size = list.Len() * (tagsize + protowire.SizeFixed32())
return size
}
// appendSfixed32SliceValue encodes a []int32 value as a repeated Sfixed32.
func appendSfixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed32(b, uint32(v.Int()))
}
return b, nil
}
// consumeSfixed32SliceValue wire decodes a []int32 value as a repeated Sfixed32.
func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.Fixed32Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(v)))
out.n = n
return listv, out, nil
}
var coderSfixed32SliceValue = valueCoderFuncs{
size: sizeSfixed32SliceValue,
marshal: appendSfixed32SliceValue,
unmarshal: consumeSfixed32SliceValue,
merge: mergeListValue,
}
// sizeSfixed32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sfixed32.
func sizeSfixed32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := llen * protowire.SizeFixed32()
return tagsize + protowire.SizeBytes(n)
}
// appendSfixed32PackedSliceValue encodes a []int32 value as a packed repeated Sfixed32.
func appendSfixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := llen * protowire.SizeFixed32()
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendFixed32(b, uint32(v.Int()))
}
return b, nil
}
var coderSfixed32PackedSliceValue = valueCoderFuncs{
size: sizeSfixed32PackedSliceValue,
marshal: appendSfixed32PackedSliceValue,
unmarshal: consumeSfixed32SliceValue,
merge: mergeListValue,
}
// sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32.
func sizeFixed32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed32()
}
// appendFixed32 wire encodes a uint32 pointer as a Fixed32.
func appendFixed32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint32()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, v)
return b, nil
}
// consumeFixed32 wire decodes a uint32 pointer as a Fixed32.
func consumeFixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
*p.Uint32() = v
out.n = n
return out, nil
}
var coderFixed32 = pointerCoderFuncs{
size: sizeFixed32,
marshal: appendFixed32,
unmarshal: consumeFixed32,
merge: mergeUint32,
}
// sizeFixed32NoZero returns the size of wire encoding a uint32 pointer as a Fixed32.
// The zero value is not encoded.
func sizeFixed32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Uint32()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeFixed32()
}
// appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32.
// The zero value is not encoded.
func appendFixed32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint32()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, v)
return b, nil
}
var coderFixed32NoZero = pointerCoderFuncs{
size: sizeFixed32NoZero,
marshal: appendFixed32NoZero,
unmarshal: consumeFixed32,
merge: mergeUint32NoZero,
}
// sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32.
// It panics if the pointer is nil.
func sizeFixed32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed32()
}
// appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32.
// It panics if the pointer is nil.
func appendFixed32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Uint32Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, v)
return b, nil
}
// consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.
func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
vp := p.Uint32Ptr()
if *vp == nil {
*vp = new(uint32)
}
**vp = v
out.n = n
return out, nil
}
var coderFixed32Ptr = pointerCoderFuncs{
size: sizeFixed32Ptr,
marshal: appendFixed32Ptr,
unmarshal: consumeFixed32Ptr,
merge: mergeUint32Ptr,
}
// sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32.
func sizeFixed32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint32Slice()
size = len(s) * (f.tagsize + protowire.SizeFixed32())
return size
}
// appendFixed32Slice encodes a []uint32 pointer as a repeated Fixed32.
func appendFixed32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint32Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, v)
}
return b, nil
}
// consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32.
func consumeFixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Uint32Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := len(b) / protowire.SizeFixed32()
if count > 0 {
p.growUint32Slice(count)
}
s := *sp
for len(b) > 0 {
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
s = append(s, v)
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, v)
out.n = n
return out, nil
}
var coderFixed32Slice = pointerCoderFuncs{
size: sizeFixed32Slice,
marshal: appendFixed32Slice,
unmarshal: consumeFixed32Slice,
merge: mergeUint32Slice,
}
// sizeFixed32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Fixed32.
func sizeFixed32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint32Slice()
if len(s) == 0 {
return 0
}
n := len(s) * protowire.SizeFixed32()
return f.tagsize + protowire.SizeBytes(n)
}
// appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32.
func appendFixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint32Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := len(s) * protowire.SizeFixed32()
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendFixed32(b, v)
}
return b, nil
}
var coderFixed32PackedSlice = pointerCoderFuncs{
size: sizeFixed32PackedSlice,
marshal: appendFixed32PackedSlice,
unmarshal: consumeFixed32Slice,
merge: mergeUint32Slice,
}
// sizeFixed32Value returns the size of wire encoding a uint32 value as a Fixed32.
func sizeFixed32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeFixed32()
}
// appendFixed32Value encodes a uint32 value as a Fixed32.
func appendFixed32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed32(b, uint32(v.Uint()))
return b, nil
}
// consumeFixed32Value decodes a uint32 value as a Fixed32.
func consumeFixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfUint32(uint32(v)), out, nil
}
var coderFixed32Value = valueCoderFuncs{
size: sizeFixed32Value,
marshal: appendFixed32Value,
unmarshal: consumeFixed32Value,
merge: mergeScalarValue,
}
// sizeFixed32SliceValue returns the size of wire encoding a []uint32 value as a repeated Fixed32.
func sizeFixed32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
size = list.Len() * (tagsize + protowire.SizeFixed32())
return size
}
// appendFixed32SliceValue encodes a []uint32 value as a repeated Fixed32.
func appendFixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed32(b, uint32(v.Uint()))
}
return b, nil
}
// consumeFixed32SliceValue wire decodes a []uint32 value as a repeated Fixed32.
func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint32(uint32(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.Fixed32Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint32(uint32(v)))
out.n = n
return listv, out, nil
}
var coderFixed32SliceValue = valueCoderFuncs{
size: sizeFixed32SliceValue,
marshal: appendFixed32SliceValue,
unmarshal: consumeFixed32SliceValue,
merge: mergeListValue,
}
// sizeFixed32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Fixed32.
func sizeFixed32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := llen * protowire.SizeFixed32()
return tagsize + protowire.SizeBytes(n)
}
// appendFixed32PackedSliceValue encodes a []uint32 value as a packed repeated Fixed32.
func appendFixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := llen * protowire.SizeFixed32()
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendFixed32(b, uint32(v.Uint()))
}
return b, nil
}
var coderFixed32PackedSliceValue = valueCoderFuncs{
size: sizeFixed32PackedSliceValue,
marshal: appendFixed32PackedSliceValue,
unmarshal: consumeFixed32SliceValue,
merge: mergeListValue,
}
// sizeFloat returns the size of wire encoding a float32 pointer as a Float.
func sizeFloat(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed32()
}
// appendFloat wire encodes a float32 pointer as a Float.
func appendFloat(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Float32()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, math.Float32bits(v))
return b, nil
}
// consumeFloat wire decodes a float32 pointer as a Float.
func consumeFloat(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
*p.Float32() = math.Float32frombits(v)
out.n = n
return out, nil
}
var coderFloat = pointerCoderFuncs{
size: sizeFloat,
marshal: appendFloat,
unmarshal: consumeFloat,
merge: mergeFloat32,
}
// sizeFloatNoZero returns the size of wire encoding a float32 pointer as a Float.
// The zero value is not encoded.
func sizeFloatNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Float32()
if v == 0 && !math.Signbit(float64(v)) {
return 0
}
return f.tagsize + protowire.SizeFixed32()
}
// appendFloatNoZero wire encodes a float32 pointer as a Float.
// The zero value is not encoded.
func appendFloatNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Float32()
if v == 0 && !math.Signbit(float64(v)) {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, math.Float32bits(v))
return b, nil
}
var coderFloatNoZero = pointerCoderFuncs{
size: sizeFloatNoZero,
marshal: appendFloatNoZero,
unmarshal: consumeFloat,
merge: mergeFloat32NoZero,
}
// sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float.
// It panics if the pointer is nil.
func sizeFloatPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed32()
}
// appendFloatPtr wire encodes a *float32 pointer as a Float.
// It panics if the pointer is nil.
func appendFloatPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Float32Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, math.Float32bits(v))
return b, nil
}
// consumeFloatPtr wire decodes a *float32 pointer as a Float.
func consumeFloatPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
vp := p.Float32Ptr()
if *vp == nil {
*vp = new(float32)
}
**vp = math.Float32frombits(v)
out.n = n
return out, nil
}
var coderFloatPtr = pointerCoderFuncs{
size: sizeFloatPtr,
marshal: appendFloatPtr,
unmarshal: consumeFloatPtr,
merge: mergeFloat32Ptr,
}
// sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float.
func sizeFloatSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Float32Slice()
size = len(s) * (f.tagsize + protowire.SizeFixed32())
return size
}
// appendFloatSlice encodes a []float32 pointer as a repeated Float.
func appendFloatSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Float32Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed32(b, math.Float32bits(v))
}
return b, nil
}
// consumeFloatSlice wire decodes a []float32 pointer as a repeated Float.
func consumeFloatSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Float32Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := len(b) / protowire.SizeFixed32()
if count > 0 {
p.growFloat32Slice(count)
}
s := *sp
for len(b) > 0 {
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
s = append(s, math.Float32frombits(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.Fixed32Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, math.Float32frombits(v))
out.n = n
return out, nil
}
var coderFloatSlice = pointerCoderFuncs{
size: sizeFloatSlice,
marshal: appendFloatSlice,
unmarshal: consumeFloatSlice,
merge: mergeFloat32Slice,
}
// sizeFloatPackedSlice returns the size of wire encoding a []float32 pointer as a packed repeated Float.
func sizeFloatPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Float32Slice()
if len(s) == 0 {
return 0
}
n := len(s) * protowire.SizeFixed32()
return f.tagsize + protowire.SizeBytes(n)
}
// appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float.
func appendFloatPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Float32Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := len(s) * protowire.SizeFixed32()
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendFixed32(b, math.Float32bits(v))
}
return b, nil
}
var coderFloatPackedSlice = pointerCoderFuncs{
size: sizeFloatPackedSlice,
marshal: appendFloatPackedSlice,
unmarshal: consumeFloatSlice,
merge: mergeFloat32Slice,
}
// sizeFloatValue returns the size of wire encoding a float32 value as a Float.
func sizeFloatValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeFixed32()
}
// appendFloatValue encodes a float32 value as a Float.
func appendFloatValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
return b, nil
}
// consumeFloatValue decodes a float32 value as a Float.
func consumeFloatValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.Fixed32Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), out, nil
}
var coderFloatValue = valueCoderFuncs{
size: sizeFloatValue,
marshal: appendFloatValue,
unmarshal: consumeFloatValue,
merge: mergeScalarValue,
}
// sizeFloatSliceValue returns the size of wire encoding a []float32 value as a repeated Float.
func sizeFloatSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
size = list.Len() * (tagsize + protowire.SizeFixed32())
return size
}
// appendFloatSliceValue encodes a []float32 value as a repeated Float.
func appendFloatSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
}
return b, nil
}
// consumeFloatSliceValue wire decodes a []float32 value as a repeated Float.
func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.Fixed32Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
out.n = n
return listv, out, nil
}
var coderFloatSliceValue = valueCoderFuncs{
size: sizeFloatSliceValue,
marshal: appendFloatSliceValue,
unmarshal: consumeFloatSliceValue,
merge: mergeListValue,
}
// sizeFloatPackedSliceValue returns the size of wire encoding a []float32 value as a packed repeated Float.
func sizeFloatPackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := llen * protowire.SizeFixed32()
return tagsize + protowire.SizeBytes(n)
}
// appendFloatPackedSliceValue encodes a []float32 value as a packed repeated Float.
func appendFloatPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := llen * protowire.SizeFixed32()
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
}
return b, nil
}
var coderFloatPackedSliceValue = valueCoderFuncs{
size: sizeFloatPackedSliceValue,
marshal: appendFloatPackedSliceValue,
unmarshal: consumeFloatSliceValue,
merge: mergeListValue,
}
// sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64.
func sizeSfixed64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed64()
}
// appendSfixed64 wire encodes a int64 pointer as a Sfixed64.
func appendSfixed64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int64()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, uint64(v))
return b, nil
}
// consumeSfixed64 wire decodes a int64 pointer as a Sfixed64.
func consumeSfixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
*p.Int64() = int64(v)
out.n = n
return out, nil
}
var coderSfixed64 = pointerCoderFuncs{
size: sizeSfixed64,
marshal: appendSfixed64,
unmarshal: consumeSfixed64,
merge: mergeInt64,
}
// sizeSfixed64NoZero returns the size of wire encoding a int64 pointer as a Sfixed64.
// The zero value is not encoded.
func sizeSfixed64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Int64()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeFixed64()
}
// appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64.
// The zero value is not encoded.
func appendSfixed64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Int64()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, uint64(v))
return b, nil
}
var coderSfixed64NoZero = pointerCoderFuncs{
size: sizeSfixed64NoZero,
marshal: appendSfixed64NoZero,
unmarshal: consumeSfixed64,
merge: mergeInt64NoZero,
}
// sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64.
// It panics if the pointer is nil.
func sizeSfixed64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed64()
}
// appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64.
// It panics if the pointer is nil.
func appendSfixed64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Int64Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, uint64(v))
return b, nil
}
// consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64.
func consumeSfixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
vp := p.Int64Ptr()
if *vp == nil {
*vp = new(int64)
}
**vp = int64(v)
out.n = n
return out, nil
}
var coderSfixed64Ptr = pointerCoderFuncs{
size: sizeSfixed64Ptr,
marshal: appendSfixed64Ptr,
unmarshal: consumeSfixed64Ptr,
merge: mergeInt64Ptr,
}
// sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64.
func sizeSfixed64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int64Slice()
size = len(s) * (f.tagsize + protowire.SizeFixed64())
return size
}
// appendSfixed64Slice encodes a []int64 pointer as a repeated Sfixed64.
func appendSfixed64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int64Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, uint64(v))
}
return b, nil
}
// consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64.
func consumeSfixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Int64Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := len(b) / protowire.SizeFixed64()
if count > 0 {
p.growInt64Slice(count)
}
s := *sp
for len(b) > 0 {
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
s = append(s, int64(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, int64(v))
out.n = n
return out, nil
}
var coderSfixed64Slice = pointerCoderFuncs{
size: sizeSfixed64Slice,
marshal: appendSfixed64Slice,
unmarshal: consumeSfixed64Slice,
merge: mergeInt64Slice,
}
// sizeSfixed64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sfixed64.
func sizeSfixed64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Int64Slice()
if len(s) == 0 {
return 0
}
n := len(s) * protowire.SizeFixed64()
return f.tagsize + protowire.SizeBytes(n)
}
// appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64.
func appendSfixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Int64Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := len(s) * protowire.SizeFixed64()
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendFixed64(b, uint64(v))
}
return b, nil
}
var coderSfixed64PackedSlice = pointerCoderFuncs{
size: sizeSfixed64PackedSlice,
marshal: appendSfixed64PackedSlice,
unmarshal: consumeSfixed64Slice,
merge: mergeInt64Slice,
}
// sizeSfixed64Value returns the size of wire encoding a int64 value as a Sfixed64.
func sizeSfixed64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeFixed64()
}
// appendSfixed64Value encodes a int64 value as a Sfixed64.
func appendSfixed64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed64(b, uint64(v.Int()))
return b, nil
}
// consumeSfixed64Value decodes a int64 value as a Sfixed64.
func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfInt64(int64(v)), out, nil
}
var coderSfixed64Value = valueCoderFuncs{
size: sizeSfixed64Value,
marshal: appendSfixed64Value,
unmarshal: consumeSfixed64Value,
merge: mergeScalarValue,
}
// sizeSfixed64SliceValue returns the size of wire encoding a []int64 value as a repeated Sfixed64.
func sizeSfixed64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
size = list.Len() * (tagsize + protowire.SizeFixed64())
return size
}
// appendSfixed64SliceValue encodes a []int64 value as a repeated Sfixed64.
func appendSfixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed64(b, uint64(v.Int()))
}
return b, nil
}
// consumeSfixed64SliceValue wire decodes a []int64 value as a repeated Sfixed64.
func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt64(int64(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.Fixed64Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfInt64(int64(v)))
out.n = n
return listv, out, nil
}
var coderSfixed64SliceValue = valueCoderFuncs{
size: sizeSfixed64SliceValue,
marshal: appendSfixed64SliceValue,
unmarshal: consumeSfixed64SliceValue,
merge: mergeListValue,
}
// sizeSfixed64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sfixed64.
func sizeSfixed64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := llen * protowire.SizeFixed64()
return tagsize + protowire.SizeBytes(n)
}
// appendSfixed64PackedSliceValue encodes a []int64 value as a packed repeated Sfixed64.
func appendSfixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := llen * protowire.SizeFixed64()
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendFixed64(b, uint64(v.Int()))
}
return b, nil
}
var coderSfixed64PackedSliceValue = valueCoderFuncs{
size: sizeSfixed64PackedSliceValue,
marshal: appendSfixed64PackedSliceValue,
unmarshal: consumeSfixed64SliceValue,
merge: mergeListValue,
}
// sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64.
func sizeFixed64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed64()
}
// appendFixed64 wire encodes a uint64 pointer as a Fixed64.
func appendFixed64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint64()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, v)
return b, nil
}
// consumeFixed64 wire decodes a uint64 pointer as a Fixed64.
func consumeFixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
*p.Uint64() = v
out.n = n
return out, nil
}
var coderFixed64 = pointerCoderFuncs{
size: sizeFixed64,
marshal: appendFixed64,
unmarshal: consumeFixed64,
merge: mergeUint64,
}
// sizeFixed64NoZero returns the size of wire encoding a uint64 pointer as a Fixed64.
// The zero value is not encoded.
func sizeFixed64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Uint64()
if v == 0 {
return 0
}
return f.tagsize + protowire.SizeFixed64()
}
// appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64.
// The zero value is not encoded.
func appendFixed64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Uint64()
if v == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, v)
return b, nil
}
var coderFixed64NoZero = pointerCoderFuncs{
size: sizeFixed64NoZero,
marshal: appendFixed64NoZero,
unmarshal: consumeFixed64,
merge: mergeUint64NoZero,
}
// sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64.
// It panics if the pointer is nil.
func sizeFixed64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed64()
}
// appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64.
// It panics if the pointer is nil.
func appendFixed64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Uint64Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, v)
return b, nil
}
// consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64.
func consumeFixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
vp := p.Uint64Ptr()
if *vp == nil {
*vp = new(uint64)
}
**vp = v
out.n = n
return out, nil
}
var coderFixed64Ptr = pointerCoderFuncs{
size: sizeFixed64Ptr,
marshal: appendFixed64Ptr,
unmarshal: consumeFixed64Ptr,
merge: mergeUint64Ptr,
}
// sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64.
func sizeFixed64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint64Slice()
size = len(s) * (f.tagsize + protowire.SizeFixed64())
return size
}
// appendFixed64Slice encodes a []uint64 pointer as a repeated Fixed64.
func appendFixed64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint64Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, v)
}
return b, nil
}
// consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64.
func consumeFixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Uint64Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := len(b) / protowire.SizeFixed64()
if count > 0 {
p.growUint64Slice(count)
}
s := *sp
for len(b) > 0 {
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
s = append(s, v)
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, v)
out.n = n
return out, nil
}
var coderFixed64Slice = pointerCoderFuncs{
size: sizeFixed64Slice,
marshal: appendFixed64Slice,
unmarshal: consumeFixed64Slice,
merge: mergeUint64Slice,
}
// sizeFixed64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Fixed64.
func sizeFixed64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Uint64Slice()
if len(s) == 0 {
return 0
}
n := len(s) * protowire.SizeFixed64()
return f.tagsize + protowire.SizeBytes(n)
}
// appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64.
func appendFixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Uint64Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := len(s) * protowire.SizeFixed64()
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendFixed64(b, v)
}
return b, nil
}
var coderFixed64PackedSlice = pointerCoderFuncs{
size: sizeFixed64PackedSlice,
marshal: appendFixed64PackedSlice,
unmarshal: consumeFixed64Slice,
merge: mergeUint64Slice,
}
// sizeFixed64Value returns the size of wire encoding a uint64 value as a Fixed64.
func sizeFixed64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeFixed64()
}
// appendFixed64Value encodes a uint64 value as a Fixed64.
func appendFixed64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed64(b, v.Uint())
return b, nil
}
// consumeFixed64Value decodes a uint64 value as a Fixed64.
func consumeFixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfUint64(v), out, nil
}
var coderFixed64Value = valueCoderFuncs{
size: sizeFixed64Value,
marshal: appendFixed64Value,
unmarshal: consumeFixed64Value,
merge: mergeScalarValue,
}
// sizeFixed64SliceValue returns the size of wire encoding a []uint64 value as a repeated Fixed64.
func sizeFixed64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
size = list.Len() * (tagsize + protowire.SizeFixed64())
return size
}
// appendFixed64SliceValue encodes a []uint64 value as a repeated Fixed64.
func appendFixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed64(b, v.Uint())
}
return b, nil
}
// consumeFixed64SliceValue wire decodes a []uint64 value as a repeated Fixed64.
func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint64(v))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.Fixed64Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfUint64(v))
out.n = n
return listv, out, nil
}
var coderFixed64SliceValue = valueCoderFuncs{
size: sizeFixed64SliceValue,
marshal: appendFixed64SliceValue,
unmarshal: consumeFixed64SliceValue,
merge: mergeListValue,
}
// sizeFixed64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Fixed64.
func sizeFixed64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := llen * protowire.SizeFixed64()
return tagsize + protowire.SizeBytes(n)
}
// appendFixed64PackedSliceValue encodes a []uint64 value as a packed repeated Fixed64.
func appendFixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := llen * protowire.SizeFixed64()
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendFixed64(b, v.Uint())
}
return b, nil
}
var coderFixed64PackedSliceValue = valueCoderFuncs{
size: sizeFixed64PackedSliceValue,
marshal: appendFixed64PackedSliceValue,
unmarshal: consumeFixed64SliceValue,
merge: mergeListValue,
}
// sizeDouble returns the size of wire encoding a float64 pointer as a Double.
func sizeDouble(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed64()
}
// appendDouble wire encodes a float64 pointer as a Double.
func appendDouble(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Float64()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, math.Float64bits(v))
return b, nil
}
// consumeDouble wire decodes a float64 pointer as a Double.
func consumeDouble(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
*p.Float64() = math.Float64frombits(v)
out.n = n
return out, nil
}
var coderDouble = pointerCoderFuncs{
size: sizeDouble,
marshal: appendDouble,
unmarshal: consumeDouble,
merge: mergeFloat64,
}
// sizeDoubleNoZero returns the size of wire encoding a float64 pointer as a Double.
// The zero value is not encoded.
func sizeDoubleNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Float64()
if v == 0 && !math.Signbit(float64(v)) {
return 0
}
return f.tagsize + protowire.SizeFixed64()
}
// appendDoubleNoZero wire encodes a float64 pointer as a Double.
// The zero value is not encoded.
func appendDoubleNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Float64()
if v == 0 && !math.Signbit(float64(v)) {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, math.Float64bits(v))
return b, nil
}
var coderDoubleNoZero = pointerCoderFuncs{
size: sizeDoubleNoZero,
marshal: appendDoubleNoZero,
unmarshal: consumeDouble,
merge: mergeFloat64NoZero,
}
// sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double.
// It panics if the pointer is nil.
func sizeDoublePtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
return f.tagsize + protowire.SizeFixed64()
}
// appendDoublePtr wire encodes a *float64 pointer as a Double.
// It panics if the pointer is nil.
func appendDoublePtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.Float64Ptr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, math.Float64bits(v))
return b, nil
}
// consumeDoublePtr wire decodes a *float64 pointer as a Double.
func consumeDoublePtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
vp := p.Float64Ptr()
if *vp == nil {
*vp = new(float64)
}
**vp = math.Float64frombits(v)
out.n = n
return out, nil
}
var coderDoublePtr = pointerCoderFuncs{
size: sizeDoublePtr,
marshal: appendDoublePtr,
unmarshal: consumeDoublePtr,
merge: mergeFloat64Ptr,
}
// sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double.
func sizeDoubleSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Float64Slice()
size = len(s) * (f.tagsize + protowire.SizeFixed64())
return size
}
// appendDoubleSlice encodes a []float64 pointer as a repeated Double.
func appendDoubleSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Float64Slice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendFixed64(b, math.Float64bits(v))
}
return b, nil
}
// consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double.
func consumeDoubleSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.Float64Slice()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
count := len(b) / protowire.SizeFixed64()
if count > 0 {
p.growFloat64Slice(count)
}
s := *sp
for len(b) > 0 {
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
s = append(s, math.Float64frombits(v))
b = b[n:]
}
*sp = s
out.n = n
return out, nil
}
if wtyp != protowire.Fixed64Type {
return out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, math.Float64frombits(v))
out.n = n
return out, nil
}
var coderDoubleSlice = pointerCoderFuncs{
size: sizeDoubleSlice,
marshal: appendDoubleSlice,
unmarshal: consumeDoubleSlice,
merge: mergeFloat64Slice,
}
// sizeDoublePackedSlice returns the size of wire encoding a []float64 pointer as a packed repeated Double.
func sizeDoublePackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.Float64Slice()
if len(s) == 0 {
return 0
}
n := len(s) * protowire.SizeFixed64()
return f.tagsize + protowire.SizeBytes(n)
}
// appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double.
func appendDoublePackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.Float64Slice()
if len(s) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
n := len(s) * protowire.SizeFixed64()
b = protowire.AppendVarint(b, uint64(n))
for _, v := range s {
b = protowire.AppendFixed64(b, math.Float64bits(v))
}
return b, nil
}
var coderDoublePackedSlice = pointerCoderFuncs{
size: sizeDoublePackedSlice,
marshal: appendDoublePackedSlice,
unmarshal: consumeDoubleSlice,
merge: mergeFloat64Slice,
}
// sizeDoubleValue returns the size of wire encoding a float64 value as a Double.
func sizeDoubleValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeFixed64()
}
// appendDoubleValue encodes a float64 value as a Double.
func appendDoubleValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
return b, nil
}
// consumeDoubleValue decodes a float64 value as a Double.
func consumeDoubleValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.Fixed64Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
}
var coderDoubleValue = valueCoderFuncs{
size: sizeDoubleValue,
marshal: appendDoubleValue,
unmarshal: consumeDoubleValue,
merge: mergeScalarValue,
}
// sizeDoubleSliceValue returns the size of wire encoding a []float64 value as a repeated Double.
func sizeDoubleSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
size = list.Len() * (tagsize + protowire.SizeFixed64())
return size
}
// appendDoubleSliceValue encodes a []float64 value as a repeated Double.
func appendDoubleSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
}
return b, nil
}
// consumeDoubleSliceValue wire decodes a []float64 value as a repeated Double.
func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp == protowire.BytesType {
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
for len(b) > 0 {
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
b = b[n:]
}
out.n = n
return listv, out, nil
}
if wtyp != protowire.Fixed64Type {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
out.n = n
return listv, out, nil
}
var coderDoubleSliceValue = valueCoderFuncs{
size: sizeDoubleSliceValue,
marshal: appendDoubleSliceValue,
unmarshal: consumeDoubleSliceValue,
merge: mergeListValue,
}
// sizeDoublePackedSliceValue returns the size of wire encoding a []float64 value as a packed repeated Double.
func sizeDoublePackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return 0
}
n := llen * protowire.SizeFixed64()
return tagsize + protowire.SizeBytes(n)
}
// appendDoublePackedSliceValue encodes a []float64 value as a packed repeated Double.
func appendDoublePackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
llen := list.Len()
if llen == 0 {
return b, nil
}
b = protowire.AppendVarint(b, wiretag)
n := llen * protowire.SizeFixed64()
b = protowire.AppendVarint(b, uint64(n))
for i := 0; i < llen; i++ {
v := list.Get(i)
b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
}
return b, nil
}
var coderDoublePackedSliceValue = valueCoderFuncs{
size: sizeDoublePackedSliceValue,
marshal: appendDoublePackedSliceValue,
unmarshal: consumeDoubleSliceValue,
merge: mergeListValue,
}
// sizeString returns the size of wire encoding a string pointer as a String.
func sizeString(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.String()
return f.tagsize + protowire.SizeBytes(len(v))
}
// appendString wire encodes a string pointer as a String.
func appendString(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.String()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
return b, nil
}
// consumeString wire decodes a string pointer as a String.
func consumeString(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
*p.String() = string(v)
out.n = n
return out, nil
}
var coderString = pointerCoderFuncs{
size: sizeString,
marshal: appendString,
unmarshal: consumeString,
merge: mergeString,
}
// appendStringValidateUTF8 wire encodes a string pointer as a String.
func appendStringValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.String()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
if !utf8.ValidString(v) {
return b, errInvalidUTF8{}
}
return b, nil
}
// consumeStringValidateUTF8 wire decodes a string pointer as a String.
func consumeStringValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if !utf8.Valid(v) {
return out, errInvalidUTF8{}
}
*p.String() = string(v)
out.n = n
return out, nil
}
var coderStringValidateUTF8 = pointerCoderFuncs{
size: sizeString,
marshal: appendStringValidateUTF8,
unmarshal: consumeStringValidateUTF8,
merge: mergeString,
}
// sizeStringNoZero returns the size of wire encoding a string pointer as a String.
// The zero value is not encoded.
func sizeStringNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.String()
if len(v) == 0 {
return 0
}
return f.tagsize + protowire.SizeBytes(len(v))
}
// appendStringNoZero wire encodes a string pointer as a String.
// The zero value is not encoded.
func appendStringNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.String()
if len(v) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
return b, nil
}
var coderStringNoZero = pointerCoderFuncs{
size: sizeStringNoZero,
marshal: appendStringNoZero,
unmarshal: consumeString,
merge: mergeStringNoZero,
}
// appendStringNoZeroValidateUTF8 wire encodes a string pointer as a String.
// The zero value is not encoded.
func appendStringNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.String()
if len(v) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
if !utf8.ValidString(v) {
return b, errInvalidUTF8{}
}
return b, nil
}
var coderStringNoZeroValidateUTF8 = pointerCoderFuncs{
size: sizeStringNoZero,
marshal: appendStringNoZeroValidateUTF8,
unmarshal: consumeStringValidateUTF8,
merge: mergeStringNoZero,
}
// sizeStringPtr returns the size of wire encoding a *string pointer as a String.
// It panics if the pointer is nil.
func sizeStringPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := **p.StringPtr()
return f.tagsize + protowire.SizeBytes(len(v))
}
// appendStringPtr wire encodes a *string pointer as a String.
// It panics if the pointer is nil.
func appendStringPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.StringPtr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
return b, nil
}
// consumeStringPtr wire decodes a *string pointer as a String.
func consumeStringPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
vp := p.StringPtr()
if *vp == nil {
*vp = new(string)
}
**vp = string(v)
out.n = n
return out, nil
}
var coderStringPtr = pointerCoderFuncs{
size: sizeStringPtr,
marshal: appendStringPtr,
unmarshal: consumeStringPtr,
merge: mergeStringPtr,
}
// appendStringPtrValidateUTF8 wire encodes a *string pointer as a String.
// It panics if the pointer is nil.
func appendStringPtrValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := **p.StringPtr()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
if !utf8.ValidString(v) {
return b, errInvalidUTF8{}
}
return b, nil
}
// consumeStringPtrValidateUTF8 wire decodes a *string pointer as a String.
func consumeStringPtrValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if !utf8.Valid(v) {
return out, errInvalidUTF8{}
}
vp := p.StringPtr()
if *vp == nil {
*vp = new(string)
}
**vp = string(v)
out.n = n
return out, nil
}
var coderStringPtrValidateUTF8 = pointerCoderFuncs{
size: sizeStringPtr,
marshal: appendStringPtrValidateUTF8,
unmarshal: consumeStringPtrValidateUTF8,
merge: mergeStringPtr,
}
// sizeStringSlice returns the size of wire encoding a []string pointer as a repeated String.
func sizeStringSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.StringSlice()
for _, v := range s {
size += f.tagsize + protowire.SizeBytes(len(v))
}
return size
}
// appendStringSlice encodes a []string pointer as a repeated String.
func appendStringSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.StringSlice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
}
return b, nil
}
// consumeStringSlice wire decodes a []string pointer as a repeated String.
func consumeStringSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.StringSlice()
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, string(v))
out.n = n
return out, nil
}
var coderStringSlice = pointerCoderFuncs{
size: sizeStringSlice,
marshal: appendStringSlice,
unmarshal: consumeStringSlice,
merge: mergeStringSlice,
}
// appendStringSliceValidateUTF8 encodes a []string pointer as a repeated String.
func appendStringSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.StringSlice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendString(b, v)
if !utf8.ValidString(v) {
return b, errInvalidUTF8{}
}
}
return b, nil
}
// consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String.
func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if !utf8.Valid(v) {
return out, errInvalidUTF8{}
}
sp := p.StringSlice()
*sp = append(*sp, string(v))
out.n = n
return out, nil
}
var coderStringSliceValidateUTF8 = pointerCoderFuncs{
size: sizeStringSlice,
marshal: appendStringSliceValidateUTF8,
unmarshal: consumeStringSliceValidateUTF8,
merge: mergeStringSlice,
}
// sizeStringValue returns the size of wire encoding a string value as a String.
func sizeStringValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeBytes(len(v.String()))
}
// appendStringValue encodes a string value as a String.
func appendStringValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendString(b, v.String())
return b, nil
}
// consumeStringValue decodes a string value as a String.
func consumeStringValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfString(string(v)), out, nil
}
var coderStringValue = valueCoderFuncs{
size: sizeStringValue,
marshal: appendStringValue,
unmarshal: consumeStringValue,
merge: mergeScalarValue,
}
// appendStringValueValidateUTF8 encodes a string value as a String.
func appendStringValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendString(b, v.String())
if !utf8.ValidString(v.String()) {
return b, errInvalidUTF8{}
}
return b, nil
}
// consumeStringValueValidateUTF8 decodes a string value as a String.
func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
if !utf8.Valid(v) {
return protoreflect.Value{}, out, errInvalidUTF8{}
}
out.n = n
return protoreflect.ValueOfString(string(v)), out, nil
}
var coderStringValueValidateUTF8 = valueCoderFuncs{
size: sizeStringValue,
marshal: appendStringValueValidateUTF8,
unmarshal: consumeStringValueValidateUTF8,
merge: mergeScalarValue,
}
// sizeStringSliceValue returns the size of wire encoding a []string value as a repeated String.
func sizeStringSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeBytes(len(v.String()))
}
return size
}
// appendStringSliceValue encodes a []string value as a repeated String.
func appendStringSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendString(b, v.String())
}
return b, nil
}
// consumeStringSliceValue wire decodes a []string value as a repeated String.
func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp != protowire.BytesType {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfString(string(v)))
out.n = n
return listv, out, nil
}
var coderStringSliceValue = valueCoderFuncs{
size: sizeStringSliceValue,
marshal: appendStringSliceValue,
unmarshal: consumeStringSliceValue,
merge: mergeListValue,
}
// sizeBytes returns the size of wire encoding a []byte pointer as a Bytes.
func sizeBytes(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Bytes()
return f.tagsize + protowire.SizeBytes(len(v))
}
// appendBytes wire encodes a []byte pointer as a Bytes.
func appendBytes(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Bytes()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendBytes(b, v)
return b, nil
}
// consumeBytes wire decodes a []byte pointer as a Bytes.
func consumeBytes(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
*p.Bytes() = append(emptyBuf[:], v...)
out.n = n
return out, nil
}
var coderBytes = pointerCoderFuncs{
size: sizeBytes,
marshal: appendBytes,
unmarshal: consumeBytes,
merge: mergeBytes,
}
// appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes.
func appendBytesValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Bytes()
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendBytes(b, v)
if !utf8.Valid(v) {
return b, errInvalidUTF8{}
}
return b, nil
}
// consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes.
func consumeBytesValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if !utf8.Valid(v) {
return out, errInvalidUTF8{}
}
*p.Bytes() = append(emptyBuf[:], v...)
out.n = n
return out, nil
}
var coderBytesValidateUTF8 = pointerCoderFuncs{
size: sizeBytes,
marshal: appendBytesValidateUTF8,
unmarshal: consumeBytesValidateUTF8,
merge: mergeBytes,
}
// sizeBytesNoZero returns the size of wire encoding a []byte pointer as a Bytes.
// The zero value is not encoded.
func sizeBytesNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
v := *p.Bytes()
if len(v) == 0 {
return 0
}
return f.tagsize + protowire.SizeBytes(len(v))
}
// appendBytesNoZero wire encodes a []byte pointer as a Bytes.
// The zero value is not encoded.
func appendBytesNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Bytes()
if len(v) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendBytes(b, v)
return b, nil
}
// consumeBytesNoZero wire decodes a []byte pointer as a Bytes.
// The zero value is not decoded.
func consumeBytesNoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
*p.Bytes() = append(([]byte)(nil), v...)
out.n = n
return out, nil
}
var coderBytesNoZero = pointerCoderFuncs{
size: sizeBytesNoZero,
marshal: appendBytesNoZero,
unmarshal: consumeBytesNoZero,
merge: mergeBytesNoZero,
}
// appendBytesNoZeroValidateUTF8 wire encodes a []byte pointer as a Bytes.
// The zero value is not encoded.
func appendBytesNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
v := *p.Bytes()
if len(v) == 0 {
return b, nil
}
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendBytes(b, v)
if !utf8.Valid(v) {
return b, errInvalidUTF8{}
}
return b, nil
}
// consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes.
func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if !utf8.Valid(v) {
return out, errInvalidUTF8{}
}
*p.Bytes() = append(([]byte)(nil), v...)
out.n = n
return out, nil
}
var coderBytesNoZeroValidateUTF8 = pointerCoderFuncs{
size: sizeBytesNoZero,
marshal: appendBytesNoZeroValidateUTF8,
unmarshal: consumeBytesNoZeroValidateUTF8,
merge: mergeBytesNoZero,
}
// sizeBytesSlice returns the size of wire encoding a [][]byte pointer as a repeated Bytes.
func sizeBytesSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
s := *p.BytesSlice()
for _, v := range s {
size += f.tagsize + protowire.SizeBytes(len(v))
}
return size
}
// appendBytesSlice encodes a [][]byte pointer as a repeated Bytes.
func appendBytesSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.BytesSlice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendBytes(b, v)
}
return b, nil
}
// consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes.
func consumeBytesSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
sp := p.BytesSlice()
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
*sp = append(*sp, append(emptyBuf[:], v...))
out.n = n
return out, nil
}
var coderBytesSlice = pointerCoderFuncs{
size: sizeBytesSlice,
marshal: appendBytesSlice,
unmarshal: consumeBytesSlice,
merge: mergeBytesSlice,
}
// appendBytesSliceValidateUTF8 encodes a [][]byte pointer as a repeated Bytes.
func appendBytesSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
s := *p.BytesSlice()
for _, v := range s {
b = protowire.AppendVarint(b, f.wiretag)
b = protowire.AppendBytes(b, v)
if !utf8.Valid(v) {
return b, errInvalidUTF8{}
}
}
return b, nil
}
// consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes.
func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
if !utf8.Valid(v) {
return out, errInvalidUTF8{}
}
sp := p.BytesSlice()
*sp = append(*sp, append(emptyBuf[:], v...))
out.n = n
return out, nil
}
var coderBytesSliceValidateUTF8 = pointerCoderFuncs{
size: sizeBytesSlice,
marshal: appendBytesSliceValidateUTF8,
unmarshal: consumeBytesSliceValidateUTF8,
merge: mergeBytesSlice,
}
// sizeBytesValue returns the size of wire encoding a []byte value as a Bytes.
func sizeBytesValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
return tagsize + protowire.SizeBytes(len(v.Bytes()))
}
// appendBytesValue encodes a []byte value as a Bytes.
func appendBytesValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendBytes(b, v.Bytes())
return b, nil
}
// consumeBytesValue decodes a []byte value as a Bytes.
func consumeBytesValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
out.n = n
return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), out, nil
}
var coderBytesValue = valueCoderFuncs{
size: sizeBytesValue,
marshal: appendBytesValue,
unmarshal: consumeBytesValue,
merge: mergeBytesValue,
}
// sizeBytesSliceValue returns the size of wire encoding a [][]byte value as a repeated Bytes.
func sizeBytesSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
size += tagsize + protowire.SizeBytes(len(v.Bytes()))
}
return size
}
// appendBytesSliceValue encodes a [][]byte value as a repeated Bytes.
func appendBytesSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ {
v := list.Get(i)
b = protowire.AppendVarint(b, wiretag)
b = protowire.AppendBytes(b, v.Bytes())
}
return b, nil
}
// consumeBytesSliceValue wire decodes a [][]byte value as a repeated Bytes.
func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List()
if wtyp != protowire.BytesType {
return protoreflect.Value{}, out, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return protoreflect.Value{}, out, errDecode
}
list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
out.n = n
return listv, out, nil
}
var coderBytesSliceValue = valueCoderFuncs{
size: sizeBytesSliceValue,
marshal: appendBytesSliceValue,
unmarshal: consumeBytesSliceValue,
merge: mergeBytesListValue,
}
// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
var emptyBuf [0]byte
var wireTypes = map[protoreflect.Kind]protowire.Type{
protoreflect.BoolKind: protowire.VarintType,
protoreflect.EnumKind: protowire.VarintType,
protoreflect.Int32Kind: protowire.VarintType,
protoreflect.Sint32Kind: protowire.VarintType,
protoreflect.Uint32Kind: protowire.VarintType,
protoreflect.Int64Kind: protowire.VarintType,
protoreflect.Sint64Kind: protowire.VarintType,
protoreflect.Uint64Kind: protowire.VarintType,
protoreflect.Sfixed32Kind: protowire.Fixed32Type,
protoreflect.Fixed32Kind: protowire.Fixed32Type,
protoreflect.FloatKind: protowire.Fixed32Type,
protoreflect.Sfixed64Kind: protowire.Fixed64Type,
protoreflect.Fixed64Kind: protowire.Fixed64Type,
protoreflect.DoubleKind: protowire.Fixed64Type,
protoreflect.StringKind: protowire.BytesType,
protoreflect.BytesKind: protowire.BytesType,
protoreflect.MessageKind: protowire.BytesType,
protoreflect.GroupKind: protowire.StartGroupType,
}
// 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 impl
import (
"reflect"
"sort"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect"
)
type mapInfo struct {
goType reflect.Type
keyWiretag uint64
valWiretag uint64
keyFuncs valueCoderFuncs
valFuncs valueCoderFuncs
keyZero protoreflect.Value
keyKind protoreflect.Kind
conv *mapConverter
}
func encoderFuncsForMap(fd protoreflect.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
// TODO: Consider generating specialized map coders.
keyField := fd.MapKey()
valField := fd.MapValue()
keyWiretag := protowire.EncodeTag(1, wireTypes[keyField.Kind()])
valWiretag := protowire.EncodeTag(2, wireTypes[valField.Kind()])
keyFuncs := encoderFuncsForValue(keyField)
valFuncs := encoderFuncsForValue(valField)
conv := newMapConverter(ft, fd)
mapi := &mapInfo{
goType: ft,
keyWiretag: keyWiretag,
valWiretag: valWiretag,
keyFuncs: keyFuncs,
valFuncs: valFuncs,
keyZero: keyField.Default(),
keyKind: keyField.Kind(),
conv: conv,
}
if valField.Kind() == protoreflect.MessageKind {
valueMessage = getMessageInfo(ft.Elem())
}
funcs = pointerCoderFuncs{
size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
return sizeMap(p.AsValueOf(ft).Elem(), mapi, f, opts)
},
marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
return appendMap(b, p.AsValueOf(ft).Elem(), mapi, f, opts)
},
unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
mp := p.AsValueOf(ft)
if mp.Elem().IsNil() {
mp.Elem().Set(reflect.MakeMap(mapi.goType))
}
if f.mi == nil {
return consumeMap(b, mp.Elem(), wtyp, mapi, f, opts)
} else {
return consumeMapOfMessage(b, mp.Elem(), wtyp, mapi, f, opts)
}
},
}
switch valField.Kind() {
case protoreflect.MessageKind:
funcs.merge = mergeMapOfMessage
case protoreflect.BytesKind:
funcs.merge = mergeMapOfBytes
default:
funcs.merge = mergeMap
}
if valFuncs.isInit != nil {
funcs.isInit = func(p pointer, f *coderFieldInfo) error {
return isInitMap(p.AsValueOf(ft).Elem(), mapi, f)
}
}
return valueMessage, funcs
}
const (
mapKeyTagSize = 1 // field 1, tag size 1.
mapValTagSize = 1 // field 2, tag size 2.
)
func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
if mapv.Len() == 0 {
return 0
}
n := 0
iter := mapv.MapRange()
for iter.Next() {
key := mapi.conv.keyConv.PBValueOf(iter.Key()).MapKey()
keySize := mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
var valSize int
value := mapi.conv.valConv.PBValueOf(iter.Value())
if f.mi == nil {
valSize = mapi.valFuncs.size(value, mapValTagSize, opts)
} else {
p := pointerOfValue(iter.Value())
valSize += mapValTagSize
valSize += protowire.SizeBytes(f.mi.sizePointer(p, opts))
}
n += f.tagsize + protowire.SizeBytes(keySize+valSize)
}
return n
}
func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
var (
key = mapi.keyZero
val = mapi.conv.valConv.New()
)
for len(b) > 0 {
num, wtyp, n := protowire.ConsumeTag(b)
if n < 0 {
return out, errDecode
}
if num > protowire.MaxValidNumber {
return out, errDecode
}
b = b[n:]
err := errUnknown
switch num {
case genid.MapEntry_Key_field_number:
var v protoreflect.Value
var o unmarshalOutput
v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
if err != nil {
break
}
key = v
n = o.n
case genid.MapEntry_Value_field_number:
var v protoreflect.Value
var o unmarshalOutput
v, o, err = mapi.valFuncs.unmarshal(b, val, num, wtyp, opts)
if err != nil {
break
}
val = v
n = o.n
}
if err == errUnknown {
n = protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return out, errDecode
}
} else if err != nil {
return out, err
}
b = b[n:]
}
mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), mapi.conv.valConv.GoValueOf(val))
out.n = n
return out, nil
}
func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
if wtyp != protowire.BytesType {
return out, errUnknown
}
b, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
var (
key = mapi.keyZero
val = reflect.New(f.mi.GoReflectType.Elem())
)
for len(b) > 0 {
num, wtyp, n := protowire.ConsumeTag(b)
if n < 0 {
return out, errDecode
}
if num > protowire.MaxValidNumber {
return out, errDecode
}
b = b[n:]
err := errUnknown
switch num {
case 1:
var v protoreflect.Value
var o unmarshalOutput
v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
if err != nil {
break
}
key = v
n = o.n
case 2:
if wtyp != protowire.BytesType {
break
}
var v []byte
v, n = protowire.ConsumeBytes(b)
if n < 0 {
return out, errDecode
}
var o unmarshalOutput
o, err = f.mi.unmarshalPointer(v, pointerOfValue(val), 0, opts)
if o.initialized {
// Consider this map item initialized so long as we see
// an initialized value.
out.initialized = true
}
}
if err == errUnknown {
n = protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return out, errDecode
}
} else if err != nil {
return out, err
}
b = b[n:]
}
mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), val)
out.n = n
return out, nil
}
func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
if f.mi == nil {
key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
val := mapi.conv.valConv.PBValueOf(valrv)
size := 0
size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
size += mapi.valFuncs.size(val, mapValTagSize, opts)
b = protowire.AppendVarint(b, uint64(size))
before := len(b)
b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
if err != nil {
return nil, err
}
b, err = mapi.valFuncs.marshal(b, val, mapi.valWiretag, opts)
if measuredSize := len(b) - before; size != measuredSize && err == nil {
return nil, errors.MismatchedSizeCalculation(size, measuredSize)
}
return b, err
} else {
key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
val := pointerOfValue(valrv)
valSize := f.mi.sizePointer(val, opts)
size := 0
size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
size += mapValTagSize + protowire.SizeBytes(valSize)
b = protowire.AppendVarint(b, uint64(size))
b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
if err != nil {
return nil, err
}
b = protowire.AppendVarint(b, mapi.valWiretag)
b = protowire.AppendVarint(b, uint64(valSize))
before := len(b)
b, err = f.mi.marshalAppendPointer(b, val, opts)
if measuredSize := len(b) - before; valSize != measuredSize && err == nil {
return nil, errors.MismatchedSizeCalculation(valSize, measuredSize)
}
return b, err
}
}
func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
if mapv.Len() == 0 {
return b, nil
}
if opts.Deterministic() {
return appendMapDeterministic(b, mapv, mapi, f, opts)
}
iter := mapv.MapRange()
for iter.Next() {
var err error
b = protowire.AppendVarint(b, f.wiretag)
b, err = appendMapItem(b, iter.Key(), iter.Value(), mapi, f, opts)
if err != nil {
return b, err
}
}
return b, nil
}
func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
keys := mapv.MapKeys()
sort.Slice(keys, func(i, j int) bool {
switch keys[i].Kind() {
case reflect.Bool:
return !keys[i].Bool() && keys[j].Bool()
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return keys[i].Int() < keys[j].Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return keys[i].Uint() < keys[j].Uint()
case reflect.Float32, reflect.Float64:
return keys[i].Float() < keys[j].Float()
case reflect.String:
return keys[i].String() < keys[j].String()
default:
panic("invalid kind: " + keys[i].Kind().String())
}
})
for _, key := range keys {
var err error
b = protowire.AppendVarint(b, f.wiretag)
b, err = appendMapItem(b, key, mapv.MapIndex(key), mapi, f, opts)
if err != nil {
return b, err
}
}
return b, nil
}
func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
if mi := f.mi; mi != nil {
mi.init()
if !mi.needsInitCheck {
return nil
}
iter := mapv.MapRange()
for iter.Next() {
val := pointerOfValue(iter.Value())
if err := mi.checkInitializedPointer(val); err != nil {
return err
}
}
} else {
iter := mapv.MapRange()
for iter.Next() {
val := mapi.conv.valConv.PBValueOf(iter.Value())
if err := mapi.valFuncs.isInit(val); err != nil {
return err
}
}
}
return nil
}
func mergeMap(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
dstm := dst.AsValueOf(f.ft).Elem()
srcm := src.AsValueOf(f.ft).Elem()
if srcm.Len() == 0 {
return
}
if dstm.IsNil() {
dstm.Set(reflect.MakeMap(f.ft))
}
iter := srcm.MapRange()
for iter.Next() {
dstm.SetMapIndex(iter.Key(), iter.Value())
}
}
func mergeMapOfBytes(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
dstm := dst.AsValueOf(f.ft).Elem()
srcm := src.AsValueOf(f.ft).Elem()
if srcm.Len() == 0 {
return
}
if dstm.IsNil() {
dstm.Set(reflect.MakeMap(f.ft))
}
iter := srcm.MapRange()
for iter.Next() {
dstm.SetMapIndex(iter.Key(), reflect.ValueOf(append(emptyBuf[:], iter.Value().Bytes()...)))
}
}
func mergeMapOfMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
dstm := dst.AsValueOf(f.ft).Elem()
srcm := src.AsValueOf(f.ft).Elem()
if srcm.Len() == 0 {
return
}
if dstm.IsNil() {
dstm.Set(reflect.MakeMap(f.ft))
}
iter := srcm.MapRange()
for iter.Next() {
val := reflect.New(f.ft.Elem().Elem())
if f.mi != nil {
f.mi.mergePointer(pointerOfValue(val), pointerOfValue(iter.Value()), opts)
} else {
opts.Merge(asMessage(val), asMessage(iter.Value()))
}
dstm.SetMapIndex(iter.Key(), val)
}
}
// 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 impl
import (
"fmt"
"reflect"
"sort"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/order"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// coderMessageInfo contains per-message information used by the fast-path functions.
// This is a different type from MessageInfo to keep MessageInfo as general-purpose as
// possible.
type coderMessageInfo struct {
methods protoiface.Methods
orderedCoderFields []*coderFieldInfo
denseCoderFields []*coderFieldInfo
coderFields map[protowire.Number]*coderFieldInfo
sizecacheOffset offset
unknownOffset offset
unknownPtrKind bool
extensionOffset offset
needsInitCheck bool
isMessageSet bool
numRequiredFields uint8
lazyOffset offset
presenceOffset offset
presenceSize presenceSize
}
type coderFieldInfo struct {
funcs pointerCoderFuncs // fast-path per-field functions
mi *MessageInfo // field's message
ft reflect.Type
validation validationInfo // information used by message validation
num protoreflect.FieldNumber // field number
offset offset // struct field offset
wiretag uint64 // field tag (number + wire type)
tagsize int // size of the varint-encoded tag
isPointer bool // true if IsNil may be called on the struct field
isRequired bool // true if field is required
isLazy bool
presenceIndex uint32
}
const noPresence = 0xffffffff
func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
mi.sizecacheOffset = invalidOffset
mi.unknownOffset = invalidOffset
mi.extensionOffset = invalidOffset
mi.lazyOffset = invalidOffset
mi.presenceOffset = si.presenceOffset
if si.sizecacheOffset.IsValid() && si.sizecacheType == sizecacheType {
mi.sizecacheOffset = si.sizecacheOffset
}
if si.unknownOffset.IsValid() && (si.unknownType == unknownFieldsAType || si.unknownType == unknownFieldsBType) {
mi.unknownOffset = si.unknownOffset
mi.unknownPtrKind = si.unknownType.Kind() == reflect.Ptr
}
if si.extensionOffset.IsValid() && si.extensionType == extensionFieldsType {
mi.extensionOffset = si.extensionOffset
}
mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
fields := mi.Desc.Fields()
preallocFields := make([]coderFieldInfo, fields.Len())
for i := 0; i < fields.Len(); i++ {
fd := fields.Get(i)
fs := si.fieldsByNumber[fd.Number()]
isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
if isOneof {
fs = si.oneofsByName[fd.ContainingOneof().Name()]
}
ft := fs.Type
var wiretag uint64
if !fd.IsPacked() {
wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
} else {
wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
}
var fieldOffset offset
var funcs pointerCoderFuncs
var childMessage *MessageInfo
switch {
case ft == nil:
// This never occurs for generated message types.
// It implies that a hand-crafted type has missing Go fields
// for specific protobuf message fields.
funcs = pointerCoderFuncs{
size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
return 0
},
marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
return nil, nil
},
unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
panic("missing Go struct field for " + string(fd.FullName()))
},
isInit: func(p pointer, f *coderFieldInfo) error {
panic("missing Go struct field for " + string(fd.FullName()))
},
merge: func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
panic("missing Go struct field for " + string(fd.FullName()))
},
}
case isOneof:
fieldOffset = offsetOf(fs)
default:
fieldOffset = offsetOf(fs)
childMessage, funcs = fieldCoder(fd, ft)
}
cf := &preallocFields[i]
*cf = coderFieldInfo{
num: fd.Number(),
offset: fieldOffset,
wiretag: wiretag,
ft: ft,
tagsize: protowire.SizeVarint(wiretag),
funcs: funcs,
mi: childMessage,
validation: newFieldValidationInfo(mi, si, fd, ft),
isPointer: fd.Cardinality() == protoreflect.Repeated || fd.HasPresence(),
isRequired: fd.Cardinality() == protoreflect.Required,
presenceIndex: noPresence,
}
mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
mi.coderFields[cf.num] = cf
}
for i, oneofs := 0, mi.Desc.Oneofs(); i < oneofs.Len(); i++ {
if od := oneofs.Get(i); !od.IsSynthetic() {
mi.initOneofFieldCoders(od, si)
}
}
if messageset.IsMessageSet(mi.Desc) {
if !mi.extensionOffset.IsValid() {
panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
}
if !mi.unknownOffset.IsValid() {
panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
}
mi.isMessageSet = true
}
sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
})
var maxDense protoreflect.FieldNumber
for _, cf := range mi.orderedCoderFields {
if cf.num >= 16 && cf.num >= 2*maxDense {
break
}
maxDense = cf.num
}
mi.denseCoderFields = make([]*coderFieldInfo, maxDense+1)
for _, cf := range mi.orderedCoderFields {
if int(cf.num) >= len(mi.denseCoderFields) {
break
}
mi.denseCoderFields[cf.num] = cf
}
// To preserve compatibility with historic wire output, marshal oneofs last.
if mi.Desc.Oneofs().Len() > 0 {
sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
fi := fields.ByNumber(mi.orderedCoderFields[i].num)
fj := fields.ByNumber(mi.orderedCoderFields[j].num)
return order.LegacyFieldOrder(fi, fj)
})
}
mi.needsInitCheck = needsInitCheck(mi.Desc)
if mi.methods.Marshal == nil && mi.methods.Size == nil {
mi.methods.Flags |= protoiface.SupportMarshalDeterministic
mi.methods.Marshal = mi.marshal
mi.methods.Size = mi.size
}
if mi.methods.Unmarshal == nil {
mi.methods.Flags |= protoiface.SupportUnmarshalDiscardUnknown
mi.methods.Unmarshal = mi.unmarshal
}
if mi.methods.CheckInitialized == nil {
mi.methods.CheckInitialized = mi.checkInitialized
}
if mi.methods.Merge == nil {
mi.methods.Merge = mi.merge
}
if mi.methods.Equal == nil {
mi.methods.Equal = equal
}
}
// getUnknownBytes returns a *[]byte for the unknown fields.
// It is the caller's responsibility to check whether the pointer is nil.
// This function is specially designed to be inlineable.
func (mi *MessageInfo) getUnknownBytes(p pointer) *[]byte {
if mi.unknownPtrKind {
return *p.Apply(mi.unknownOffset).BytesPtr()
} else {
return p.Apply(mi.unknownOffset).Bytes()
}
}
// mutableUnknownBytes returns a *[]byte for the unknown fields.
// The returned pointer is guaranteed to not be nil.
func (mi *MessageInfo) mutableUnknownBytes(p pointer) *[]byte {
if mi.unknownPtrKind {
bp := p.Apply(mi.unknownOffset).BytesPtr()
if *bp == nil {
*bp = new([]byte)
}
return *bp
} else {
return p.Apply(mi.unknownOffset).Bytes()
}
}
// Copyright 2024 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 impl
import (
"fmt"
"reflect"
"sort"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/order"
"google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface"
)
func (mi *MessageInfo) makeOpaqueCoderMethods(t reflect.Type, si opaqueStructInfo) {
mi.sizecacheOffset = si.sizecacheOffset
mi.unknownOffset = si.unknownOffset
mi.unknownPtrKind = si.unknownType.Kind() == reflect.Ptr
mi.extensionOffset = si.extensionOffset
mi.lazyOffset = si.lazyOffset
mi.presenceOffset = si.presenceOffset
mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
fields := mi.Desc.Fields()
for i := 0; i < fields.Len(); i++ {
fd := fields.Get(i)
fs := si.fieldsByNumber[fd.Number()]
if fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic() {
fs = si.oneofsByName[fd.ContainingOneof().Name()]
}
ft := fs.Type
var wiretag uint64
if !fd.IsPacked() {
wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
} else {
wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
}
var fieldOffset offset
var funcs pointerCoderFuncs
var childMessage *MessageInfo
switch {
case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
fieldOffset = offsetOf(fs)
case fd.Message() != nil && !fd.IsMap():
fieldOffset = offsetOf(fs)
if fd.IsList() {
childMessage, funcs = makeOpaqueRepeatedMessageFieldCoder(fd, ft)
} else {
childMessage, funcs = makeOpaqueMessageFieldCoder(fd, ft)
}
default:
fieldOffset = offsetOf(fs)
childMessage, funcs = fieldCoder(fd, ft)
}
cf := &coderFieldInfo{
num: fd.Number(),
offset: fieldOffset,
wiretag: wiretag,
ft: ft,
tagsize: protowire.SizeVarint(wiretag),
funcs: funcs,
mi: childMessage,
validation: newFieldValidationInfo(mi, si.structInfo, fd, ft),
isPointer: (fd.Cardinality() == protoreflect.Repeated ||
fd.Kind() == protoreflect.MessageKind ||
fd.Kind() == protoreflect.GroupKind),
isRequired: fd.Cardinality() == protoreflect.Required,
presenceIndex: noPresence,
}
// TODO: Use presence for all fields.
//
// In some cases, such as maps, presence means only "might be set" rather
// than "is definitely set", but every field should have a presence bit to
// permit us to skip over definitely-unset fields at marshal time.
var hasPresence bool
hasPresence, cf.isLazy = filedesc.UsePresenceForField(fd)
if hasPresence {
cf.presenceIndex, mi.presenceSize = presenceIndex(mi.Desc, fd)
}
mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
mi.coderFields[cf.num] = cf
}
for i, oneofs := 0, mi.Desc.Oneofs(); i < oneofs.Len(); i++ {
if od := oneofs.Get(i); !od.IsSynthetic() {
mi.initOneofFieldCoders(od, si.structInfo)
}
}
if messageset.IsMessageSet(mi.Desc) {
if !mi.extensionOffset.IsValid() {
panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
}
if !mi.unknownOffset.IsValid() {
panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
}
mi.isMessageSet = true
}
sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
})
var maxDense protoreflect.FieldNumber
for _, cf := range mi.orderedCoderFields {
if cf.num >= 16 && cf.num >= 2*maxDense {
break
}
maxDense = cf.num
}
mi.denseCoderFields = make([]*coderFieldInfo, maxDense+1)
for _, cf := range mi.orderedCoderFields {
if int(cf.num) > len(mi.denseCoderFields) {
break
}
mi.denseCoderFields[cf.num] = cf
}
// To preserve compatibility with historic wire output, marshal oneofs last.
if mi.Desc.Oneofs().Len() > 0 {
sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
fi := fields.ByNumber(mi.orderedCoderFields[i].num)
fj := fields.ByNumber(mi.orderedCoderFields[j].num)
return order.LegacyFieldOrder(fi, fj)
})
}
mi.needsInitCheck = needsInitCheck(mi.Desc)
if mi.methods.Marshal == nil && mi.methods.Size == nil {
mi.methods.Flags |= piface.SupportMarshalDeterministic
mi.methods.Marshal = mi.marshal
mi.methods.Size = mi.size
}
if mi.methods.Unmarshal == nil {
mi.methods.Flags |= piface.SupportUnmarshalDiscardUnknown
mi.methods.Unmarshal = mi.unmarshal
}
if mi.methods.CheckInitialized == nil {
mi.methods.CheckInitialized = mi.checkInitialized
}
if mi.methods.Merge == nil {
mi.methods.Merge = mi.merge
}
if mi.methods.Equal == nil {
mi.methods.Equal = equal
}
}
// 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 impl
import (
"sort"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/flags"
)
func sizeMessageSet(mi *MessageInfo, p pointer, opts marshalOptions) (size int) {
if !flags.ProtoLegacy {
return 0
}
ext := *p.Apply(mi.extensionOffset).Extensions()
for _, x := range ext {
xi := getExtensionFieldInfo(x.Type())
if xi.funcs.size == nil {
continue
}
num, _ := protowire.DecodeTag(xi.wiretag)
size += messageset.SizeField(num)
if fullyLazyExtensions(opts) {
// Don't expand the extension, instead use the buffer to calculate size
if lb := x.lazyBuffer(); lb != nil {
// We got hold of the buffer, so it's still lazy.
// Don't count the tag size in the extension buffer, it's already added.
size += protowire.SizeTag(messageset.FieldMessage) + len(lb) - xi.tagsize
continue
}
}
size += xi.funcs.size(x.Value(), protowire.SizeTag(messageset.FieldMessage), opts)
}
if u := mi.getUnknownBytes(p); u != nil {
size += messageset.SizeUnknown(*u)
}
return size
}
func marshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts marshalOptions) ([]byte, error) {
if !flags.ProtoLegacy {
return b, errors.New("no support for message_set_wire_format")
}
ext := *p.Apply(mi.extensionOffset).Extensions()
switch len(ext) {
case 0:
case 1:
// Fast-path for one extension: Don't bother sorting the keys.
for _, x := range ext {
var err error
b, err = marshalMessageSetField(mi, b, x, opts)
if err != nil {
return b, err
}
}
default:
// Sort the keys to provide a deterministic encoding.
// Not sure this is required, but the old code does it.
keys := make([]int, 0, len(ext))
for k := range ext {
keys = append(keys, int(k))
}
sort.Ints(keys)
for _, k := range keys {
var err error
b, err = marshalMessageSetField(mi, b, ext[int32(k)], opts)
if err != nil {
return b, err
}
}
}
if u := mi.getUnknownBytes(p); u != nil {
var err error
b, err = messageset.AppendUnknown(b, *u)
if err != nil {
return b, err
}
}
return b, nil
}
func marshalMessageSetField(mi *MessageInfo, b []byte, x ExtensionField, opts marshalOptions) ([]byte, error) {
xi := getExtensionFieldInfo(x.Type())
num, _ := protowire.DecodeTag(xi.wiretag)
b = messageset.AppendFieldStart(b, num)
if fullyLazyExtensions(opts) {
// Don't expand the extension if it's still in wire format, instead use the buffer content.
if lb := x.lazyBuffer(); lb != nil {
// The tag inside the lazy buffer is a different tag (the extension
// number), but what we need here is the tag for FieldMessage:
b = protowire.AppendVarint(b, protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType))
b = append(b, lb[xi.tagsize:]...)
b = messageset.AppendFieldEnd(b)
return b, nil
}
}
b, err := xi.funcs.marshal(b, x.Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), opts)
if err != nil {
return b, err
}
b = messageset.AppendFieldEnd(b)
return b, nil
}
func unmarshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts unmarshalOptions) (out unmarshalOutput, err error) {
if !flags.ProtoLegacy {
return out, errors.New("no support for message_set_wire_format")
}
ep := p.Apply(mi.extensionOffset).Extensions()
if *ep == nil {
*ep = make(map[int32]ExtensionField)
}
ext := *ep
initialized := true
err = messageset.Unmarshal(b, true, func(num protowire.Number, v []byte) error {
o, err := mi.unmarshalExtension(v, num, protowire.BytesType, ext, opts)
if err == errUnknown {
u := mi.mutableUnknownBytes(p)
*u = protowire.AppendTag(*u, num, protowire.BytesType)
*u = append(*u, v...)
return nil
}
if !o.initialized {
initialized = false
}
return err
})
out.n = len(b)
out.initialized = initialized
return out, err
}
// 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
// pointerCoderFuncs is a set of pointer encoding functions.
type pointerCoderFuncs struct {
mi *MessageInfo
size func(p pointer, f *coderFieldInfo, opts marshalOptions) int
marshal func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error)
unmarshal func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
isInit func(p pointer, f *coderFieldInfo) error
merge func(dst, src pointer, f *coderFieldInfo, opts mergeOptions)
}
// valueCoderFuncs is a set of protoreflect.Value encoding functions.
type valueCoderFuncs struct {
size func(v protoreflect.Value, tagsize int, opts marshalOptions) int
marshal func(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
unmarshal func(b []byte, v protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error)
isInit func(v protoreflect.Value) error
merge func(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value
}
// fieldCoder returns pointer functions for a field, used for operating on
// struct fields.
func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
switch {
case fd.IsMap():
return encoderFuncsForMap(fd, ft)
case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked():
// Repeated fields (not packed).
if ft.Kind() != reflect.Slice {
break
}
ft := ft.Elem()
switch fd.Kind() {
case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool {
return nil, coderBoolSlice
}
case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 {
return nil, coderEnumSlice
}
case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderInt32Slice
}
case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSint32Slice
}
case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderUint32Slice
}
case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderInt64Slice
}
case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSint64Slice
}
case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderUint64Slice
}
case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32Slice
}
case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32Slice
}
case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 {
return nil, coderFloatSlice
}
case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64Slice
}
case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64Slice
}
case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 {
return nil, coderDoubleSlice
}
case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringSliceValidateUTF8
}
if ft.Kind() == reflect.String {
return nil, coderStringSlice
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
return nil, coderBytesSliceValidateUTF8
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesSlice
}
case protoreflect.BytesKind:
if ft.Kind() == reflect.String {
return nil, coderStringSlice
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesSlice
}
case protoreflect.MessageKind:
return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft)
case protoreflect.GroupKind:
return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft)
}
case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked():
// Packed repeated fields.
//
// Only repeated fields of primitive numeric types
// (Varint, Fixed32, or Fixed64 wire type) can be packed.
if ft.Kind() != reflect.Slice {
break
}
ft := ft.Elem()
switch fd.Kind() {
case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool {
return nil, coderBoolPackedSlice
}
case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 {
return nil, coderEnumPackedSlice
}
case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderInt32PackedSlice
}
case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSint32PackedSlice
}
case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderUint32PackedSlice
}
case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderInt64PackedSlice
}
case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSint64PackedSlice
}
case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderUint64PackedSlice
}
case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32PackedSlice
}
case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32PackedSlice
}
case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 {
return nil, coderFloatPackedSlice
}
case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64PackedSlice
}
case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64PackedSlice
}
case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 {
return nil, coderDoublePackedSlice
}
}
case fd.Kind() == protoreflect.MessageKind:
return getMessageInfo(ft), makeMessageFieldCoder(fd, ft)
case fd.Kind() == protoreflect.GroupKind:
return getMessageInfo(ft), makeGroupFieldCoder(fd, ft)
case !fd.HasPresence() && fd.ContainingOneof() == nil:
// Populated oneof fields always encode even if set to the zero value,
// which normally are not encoded in proto3.
switch fd.Kind() {
case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool {
return nil, coderBoolNoZero
}
case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 {
return nil, coderEnumNoZero
}
case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderInt32NoZero
}
case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSint32NoZero
}
case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderUint32NoZero
}
case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderInt64NoZero
}
case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSint64NoZero
}
case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderUint64NoZero
}
case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32NoZero
}
case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32NoZero
}
case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 {
return nil, coderFloatNoZero
}
case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64NoZero
}
case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64NoZero
}
case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 {
return nil, coderDoubleNoZero
}
case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringNoZeroValidateUTF8
}
if ft.Kind() == reflect.String {
return nil, coderStringNoZero
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
return nil, coderBytesNoZeroValidateUTF8
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesNoZero
}
case protoreflect.BytesKind:
if ft.Kind() == reflect.String {
return nil, coderStringNoZero
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesNoZero
}
}
case ft.Kind() == reflect.Ptr:
ft := ft.Elem()
switch fd.Kind() {
case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool {
return nil, coderBoolPtr
}
case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 {
return nil, coderEnumPtr
}
case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderInt32Ptr
}
case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSint32Ptr
}
case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderUint32Ptr
}
case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderInt64Ptr
}
case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSint64Ptr
}
case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderUint64Ptr
}
case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32Ptr
}
case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32Ptr
}
case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 {
return nil, coderFloatPtr
}
case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64Ptr
}
case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64Ptr
}
case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 {
return nil, coderDoublePtr
}
case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringPtrValidateUTF8
}
if ft.Kind() == reflect.String {
return nil, coderStringPtr
}
case protoreflect.BytesKind:
if ft.Kind() == reflect.String {
return nil, coderStringPtr
}
}
default:
switch fd.Kind() {
case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool {
return nil, coderBool
}
case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 {
return nil, coderEnum
}
case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderInt32
}
case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSint32
}
case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderUint32
}
case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderInt64
}
case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSint64
}
case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderUint64
}
case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32
}
case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32
}
case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 {
return nil, coderFloat
}
case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64
}
case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64
}
case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 {
return nil, coderDouble
}
case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringValidateUTF8
}
if ft.Kind() == reflect.String {
return nil, coderString
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
return nil, coderBytesValidateUTF8
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytes
}
case protoreflect.BytesKind:
if ft.Kind() == reflect.String {
return nil, coderString
}
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytes
}
}
}
panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft))
}
// encoderFuncsForValue returns value functions for a field, used for
// extension values and map encoding.
func encoderFuncsForValue(fd protoreflect.FieldDescriptor) valueCoderFuncs {
switch {
case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked():
switch fd.Kind() {
case protoreflect.BoolKind:
return coderBoolSliceValue
case protoreflect.EnumKind:
return coderEnumSliceValue
case protoreflect.Int32Kind:
return coderInt32SliceValue
case protoreflect.Sint32Kind:
return coderSint32SliceValue
case protoreflect.Uint32Kind:
return coderUint32SliceValue
case protoreflect.Int64Kind:
return coderInt64SliceValue
case protoreflect.Sint64Kind:
return coderSint64SliceValue
case protoreflect.Uint64Kind:
return coderUint64SliceValue
case protoreflect.Sfixed32Kind:
return coderSfixed32SliceValue
case protoreflect.Fixed32Kind:
return coderFixed32SliceValue
case protoreflect.FloatKind:
return coderFloatSliceValue
case protoreflect.Sfixed64Kind:
return coderSfixed64SliceValue
case protoreflect.Fixed64Kind:
return coderFixed64SliceValue
case protoreflect.DoubleKind:
return coderDoubleSliceValue
case protoreflect.StringKind:
// We don't have a UTF-8 validating coder for repeated string fields.
// Value coders are used for extensions and maps.
// Extensions are never proto3, and maps never contain lists.
return coderStringSliceValue
case protoreflect.BytesKind:
return coderBytesSliceValue
case protoreflect.MessageKind:
return coderMessageSliceValue
case protoreflect.GroupKind:
return coderGroupSliceValue
}
case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked():
switch fd.Kind() {
case protoreflect.BoolKind:
return coderBoolPackedSliceValue
case protoreflect.EnumKind:
return coderEnumPackedSliceValue
case protoreflect.Int32Kind:
return coderInt32PackedSliceValue
case protoreflect.Sint32Kind:
return coderSint32PackedSliceValue
case protoreflect.Uint32Kind:
return coderUint32PackedSliceValue
case protoreflect.Int64Kind:
return coderInt64PackedSliceValue
case protoreflect.Sint64Kind:
return coderSint64PackedSliceValue
case protoreflect.Uint64Kind:
return coderUint64PackedSliceValue
case protoreflect.Sfixed32Kind:
return coderSfixed32PackedSliceValue
case protoreflect.Fixed32Kind:
return coderFixed32PackedSliceValue
case protoreflect.FloatKind:
return coderFloatPackedSliceValue
case protoreflect.Sfixed64Kind:
return coderSfixed64PackedSliceValue
case protoreflect.Fixed64Kind:
return coderFixed64PackedSliceValue
case protoreflect.DoubleKind:
return coderDoublePackedSliceValue
}
default:
switch fd.Kind() {
default:
case protoreflect.BoolKind:
return coderBoolValue
case protoreflect.EnumKind:
return coderEnumValue
case protoreflect.Int32Kind:
return coderInt32Value
case protoreflect.Sint32Kind:
return coderSint32Value
case protoreflect.Uint32Kind:
return coderUint32Value
case protoreflect.Int64Kind:
return coderInt64Value
case protoreflect.Sint64Kind:
return coderSint64Value
case protoreflect.Uint64Kind:
return coderUint64Value
case protoreflect.Sfixed32Kind:
return coderSfixed32Value
case protoreflect.Fixed32Kind:
return coderFixed32Value
case protoreflect.FloatKind:
return coderFloatValue
case protoreflect.Sfixed64Kind:
return coderSfixed64Value
case protoreflect.Fixed64Kind:
return coderFixed64Value
case protoreflect.DoubleKind:
return coderDoubleValue
case protoreflect.StringKind:
if strs.EnforceUTF8(fd) {
return coderStringValueValidateUTF8
}
return coderStringValue
case protoreflect.BytesKind:
return coderBytesValue
case protoreflect.MessageKind:
return coderMessageValue
case protoreflect.GroupKind:
return coderGroupValue
}
}
panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind()))
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
// unwrapper unwraps the value to the underlying value.
// This is implemented by List and Map.
type unwrapper interface {
protoUnwrap() any
}
// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
type Converter interface {
// PBValueOf converts a reflect.Value to a protoreflect.Value.
PBValueOf(reflect.Value) protoreflect.Value
// GoValueOf converts a protoreflect.Value to a reflect.Value.
GoValueOf(protoreflect.Value) reflect.Value
// IsValidPB returns whether a protoreflect.Value is compatible with this type.
IsValidPB(protoreflect.Value) bool
// IsValidGo returns whether a reflect.Value is compatible with this type.
IsValidGo(reflect.Value) bool
// New returns a new field value.
// For scalars, it returns the default value of the field.
// For composite types, it returns a new mutable value.
New() protoreflect.Value
// Zero returns a new field value.
// For scalars, it returns the default value of the field.
// For composite types, it returns an immutable, empty value.
Zero() protoreflect.Value
}
// NewConverter matches a Go type with a protobuf field and returns a Converter
// that converts between the two. Enums must be a named int32 kind that
// implements protoreflect.Enum, and messages must be pointer to a named
// struct type that implements protoreflect.ProtoMessage.
//
// This matcher deliberately supports a wider range of Go types than what
// protoc-gen-go historically generated to be able to automatically wrap some
// v1 messages generated by other forks of protoc-gen-go.
func NewConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
switch {
case fd.IsList():
return newListConverter(t, fd)
case fd.IsMap():
return newMapConverter(t, fd)
default:
return newSingularConverter(t, fd)
}
}
var (
boolType = reflect.TypeOf(bool(false))
int32Type = reflect.TypeOf(int32(0))
int64Type = reflect.TypeOf(int64(0))
uint32Type = reflect.TypeOf(uint32(0))
uint64Type = reflect.TypeOf(uint64(0))
float32Type = reflect.TypeOf(float32(0))
float64Type = reflect.TypeOf(float64(0))
stringType = reflect.TypeOf(string(""))
bytesType = reflect.TypeOf([]byte(nil))
byteType = reflect.TypeOf(byte(0))
)
var (
boolZero = protoreflect.ValueOfBool(false)
int32Zero = protoreflect.ValueOfInt32(0)
int64Zero = protoreflect.ValueOfInt64(0)
uint32Zero = protoreflect.ValueOfUint32(0)
uint64Zero = protoreflect.ValueOfUint64(0)
float32Zero = protoreflect.ValueOfFloat32(0)
float64Zero = protoreflect.ValueOfFloat64(0)
stringZero = protoreflect.ValueOfString("")
bytesZero = protoreflect.ValueOfBytes(nil)
)
func newSingularConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
defVal := func(fd protoreflect.FieldDescriptor, zero protoreflect.Value) protoreflect.Value {
if fd.Cardinality() == protoreflect.Repeated {
// Default isn't defined for repeated fields.
return zero
}
return fd.Default()
}
switch fd.Kind() {
case protoreflect.BoolKind:
if t.Kind() == reflect.Bool {
return &boolConverter{t, defVal(fd, boolZero)}
}
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if t.Kind() == reflect.Int32 {
return &int32Converter{t, defVal(fd, int32Zero)}
}
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if t.Kind() == reflect.Int64 {
return &int64Converter{t, defVal(fd, int64Zero)}
}
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if t.Kind() == reflect.Uint32 {
return &uint32Converter{t, defVal(fd, uint32Zero)}
}
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if t.Kind() == reflect.Uint64 {
return &uint64Converter{t, defVal(fd, uint64Zero)}
}
case protoreflect.FloatKind:
if t.Kind() == reflect.Float32 {
return &float32Converter{t, defVal(fd, float32Zero)}
}
case protoreflect.DoubleKind:
if t.Kind() == reflect.Float64 {
return &float64Converter{t, defVal(fd, float64Zero)}
}
case protoreflect.StringKind:
if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
return &stringConverter{t, defVal(fd, stringZero)}
}
case protoreflect.BytesKind:
if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
return &bytesConverter{t, defVal(fd, bytesZero)}
}
case protoreflect.EnumKind:
// Handle enums, which must be a named int32 type.
if t.Kind() == reflect.Int32 {
return newEnumConverter(t, fd)
}
case protoreflect.MessageKind, protoreflect.GroupKind:
return newMessageConverter(t)
}
panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
}
type boolConverter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *boolConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfBool(v.Bool())
}
func (c *boolConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(v.Bool()).Convert(c.goType)
}
func (c *boolConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(bool)
return ok
}
func (c *boolConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *boolConverter) New() protoreflect.Value { return c.def }
func (c *boolConverter) Zero() protoreflect.Value { return c.def }
type int32Converter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *int32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfInt32(int32(v.Int()))
}
func (c *int32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
}
func (c *int32Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(int32)
return ok
}
func (c *int32Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *int32Converter) New() protoreflect.Value { return c.def }
func (c *int32Converter) Zero() protoreflect.Value { return c.def }
type int64Converter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *int64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfInt64(int64(v.Int()))
}
func (c *int64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
}
func (c *int64Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(int64)
return ok
}
func (c *int64Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *int64Converter) New() protoreflect.Value { return c.def }
func (c *int64Converter) Zero() protoreflect.Value { return c.def }
type uint32Converter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *uint32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfUint32(uint32(v.Uint()))
}
func (c *uint32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
}
func (c *uint32Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(uint32)
return ok
}
func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *uint32Converter) New() protoreflect.Value { return c.def }
func (c *uint32Converter) Zero() protoreflect.Value { return c.def }
type uint64Converter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *uint64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfUint64(uint64(v.Uint()))
}
func (c *uint64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
}
func (c *uint64Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(uint64)
return ok
}
func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *uint64Converter) New() protoreflect.Value { return c.def }
func (c *uint64Converter) Zero() protoreflect.Value { return c.def }
type float32Converter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *float32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfFloat32(float32(v.Float()))
}
func (c *float32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
}
func (c *float32Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(float32)
return ok
}
func (c *float32Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *float32Converter) New() protoreflect.Value { return c.def }
func (c *float32Converter) Zero() protoreflect.Value { return c.def }
type float64Converter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *float64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfFloat64(float64(v.Float()))
}
func (c *float64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
}
func (c *float64Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(float64)
return ok
}
func (c *float64Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *float64Converter) New() protoreflect.Value { return c.def }
func (c *float64Converter) Zero() protoreflect.Value { return c.def }
type stringConverter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *stringConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfString(v.Convert(stringType).String())
}
func (c *stringConverter) GoValueOf(v protoreflect.Value) reflect.Value {
// protoreflect.Value.String never panics, so we go through an interface
// conversion here to check the type.
s := v.Interface().(string)
if c.goType.Kind() == reflect.Slice && s == "" {
return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
}
return reflect.ValueOf(s).Convert(c.goType)
}
func (c *stringConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(string)
return ok
}
func (c *stringConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *stringConverter) New() protoreflect.Value { return c.def }
func (c *stringConverter) Zero() protoreflect.Value { return c.def }
type bytesConverter struct {
goType reflect.Type
def protoreflect.Value
}
func (c *bytesConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
if c.goType.Kind() == reflect.String && v.Len() == 0 {
return protoreflect.ValueOfBytes(nil) // ensure empty string is []byte(nil)
}
return protoreflect.ValueOfBytes(v.Convert(bytesType).Bytes())
}
func (c *bytesConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(v.Bytes()).Convert(c.goType)
}
func (c *bytesConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().([]byte)
return ok
}
func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *bytesConverter) New() protoreflect.Value { return c.def }
func (c *bytesConverter) Zero() protoreflect.Value { return c.def }
type enumConverter struct {
goType reflect.Type
def protoreflect.Value
}
func newEnumConverter(goType reflect.Type, fd protoreflect.FieldDescriptor) Converter {
var def protoreflect.Value
if fd.Cardinality() == protoreflect.Repeated {
def = protoreflect.ValueOfEnum(fd.Enum().Values().Get(0).Number())
} else {
def = fd.Default()
}
return &enumConverter{goType, def}
}
func (c *enumConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v.Int()))
}
func (c *enumConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(v.Enum()).Convert(c.goType)
}
func (c *enumConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(protoreflect.EnumNumber)
return ok
}
func (c *enumConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *enumConverter) New() protoreflect.Value {
return c.def
}
func (c *enumConverter) Zero() protoreflect.Value {
return c.def
}
type messageConverter struct {
goType reflect.Type
}
func newMessageConverter(goType reflect.Type) Converter {
return &messageConverter{goType}
}
func (c *messageConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
if c.isNonPointer() {
if v.CanAddr() {
v = v.Addr() // T => *T
} else {
v = reflect.Zero(reflect.PtrTo(v.Type()))
}
}
if m, ok := v.Interface().(protoreflect.ProtoMessage); ok {
return protoreflect.ValueOfMessage(m.ProtoReflect())
}
return protoreflect.ValueOfMessage(legacyWrapMessage(v))
}
func (c *messageConverter) GoValueOf(v protoreflect.Value) reflect.Value {
m := v.Message()
var rv reflect.Value
if u, ok := m.(unwrapper); ok {
rv = reflect.ValueOf(u.protoUnwrap())
} else {
rv = reflect.ValueOf(m.Interface())
}
if c.isNonPointer() {
if rv.Type() != reflect.PtrTo(c.goType) {
panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), reflect.PtrTo(c.goType)))
}
if !rv.IsNil() {
rv = rv.Elem() // *T => T
} else {
rv = reflect.Zero(rv.Type().Elem())
}
}
if rv.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
}
return rv
}
func (c *messageConverter) IsValidPB(v protoreflect.Value) bool {
m := v.Message()
var rv reflect.Value
if u, ok := m.(unwrapper); ok {
rv = reflect.ValueOf(u.protoUnwrap())
} else {
rv = reflect.ValueOf(m.Interface())
}
if c.isNonPointer() {
return rv.Type() == reflect.PtrTo(c.goType)
}
return rv.Type() == c.goType
}
func (c *messageConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *messageConverter) New() protoreflect.Value {
if c.isNonPointer() {
return c.PBValueOf(reflect.New(c.goType).Elem())
}
return c.PBValueOf(reflect.New(c.goType.Elem()))
}
func (c *messageConverter) Zero() protoreflect.Value {
return c.PBValueOf(reflect.Zero(c.goType))
}
// isNonPointer reports whether the type is a non-pointer type.
// This never occurs for generated message types.
func (c *messageConverter) isNonPointer() bool {
return c.goType.Kind() != reflect.Ptr
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
func newListConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
switch {
case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Slice:
return &listPtrConverter{t, newSingularConverter(t.Elem().Elem(), fd)}
case t.Kind() == reflect.Slice:
return &listConverter{t, newSingularConverter(t.Elem(), fd)}
}
panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
}
type listConverter struct {
goType reflect.Type // []T
c Converter
}
func (c *listConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
pv := reflect.New(c.goType)
pv.Elem().Set(v)
return protoreflect.ValueOfList(&listReflect{pv, c.c})
}
func (c *listConverter) GoValueOf(v protoreflect.Value) reflect.Value {
rv := v.List().(*listReflect).v
if rv.IsNil() {
return reflect.Zero(c.goType)
}
return rv.Elem()
}
func (c *listConverter) IsValidPB(v protoreflect.Value) bool {
list, ok := v.Interface().(*listReflect)
if !ok {
return false
}
return list.v.Type().Elem() == c.goType
}
func (c *listConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *listConverter) New() protoreflect.Value {
return protoreflect.ValueOfList(&listReflect{reflect.New(c.goType), c.c})
}
func (c *listConverter) Zero() protoreflect.Value {
return protoreflect.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
}
type listPtrConverter struct {
goType reflect.Type // *[]T
c Converter
}
func (c *listPtrConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfList(&listReflect{v, c.c})
}
func (c *listPtrConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return v.List().(*listReflect).v
}
func (c *listPtrConverter) IsValidPB(v protoreflect.Value) bool {
list, ok := v.Interface().(*listReflect)
if !ok {
return false
}
return list.v.Type() == c.goType
}
func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *listPtrConverter) New() protoreflect.Value {
return c.PBValueOf(reflect.New(c.goType.Elem()))
}
func (c *listPtrConverter) Zero() protoreflect.Value {
return c.PBValueOf(reflect.Zero(c.goType))
}
type listReflect struct {
v reflect.Value // *[]T
conv Converter
}
func (ls *listReflect) Len() int {
if ls.v.IsNil() {
return 0
}
return ls.v.Elem().Len()
}
func (ls *listReflect) Get(i int) protoreflect.Value {
return ls.conv.PBValueOf(ls.v.Elem().Index(i))
}
func (ls *listReflect) Set(i int, v protoreflect.Value) {
ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v))
}
func (ls *listReflect) Append(v protoreflect.Value) {
ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
}
func (ls *listReflect) AppendMutable() protoreflect.Value {
if _, ok := ls.conv.(*messageConverter); !ok {
panic("invalid AppendMutable on list with non-message type")
}
v := ls.NewElement()
ls.Append(v)
return v
}
func (ls *listReflect) Truncate(i int) {
ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
}
func (ls *listReflect) NewElement() protoreflect.Value {
return ls.conv.New()
}
func (ls *listReflect) IsValid() bool {
return !ls.v.IsNil()
}
func (ls *listReflect) protoUnwrap() any {
return ls.v.Interface()
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
type mapConverter struct {
goType reflect.Type // map[K]V
keyConv, valConv Converter
}
func newMapConverter(t reflect.Type, fd protoreflect.FieldDescriptor) *mapConverter {
if t.Kind() != reflect.Map {
panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
}
return &mapConverter{
goType: t,
keyConv: newSingularConverter(t.Key(), fd.MapKey()),
valConv: newSingularConverter(t.Elem(), fd.MapValue()),
}
}
func (c *mapConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
return protoreflect.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
}
func (c *mapConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return v.Map().(*mapReflect).v
}
func (c *mapConverter) IsValidPB(v protoreflect.Value) bool {
mapv, ok := v.Interface().(*mapReflect)
if !ok {
return false
}
return mapv.v.Type() == c.goType
}
func (c *mapConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType
}
func (c *mapConverter) New() protoreflect.Value {
return c.PBValueOf(reflect.MakeMap(c.goType))
}
func (c *mapConverter) Zero() protoreflect.Value {
return c.PBValueOf(reflect.Zero(c.goType))
}
type mapReflect struct {
v reflect.Value // map[K]V
keyConv Converter
valConv Converter
}
func (ms *mapReflect) Len() int {
return ms.v.Len()
}
func (ms *mapReflect) Has(k protoreflect.MapKey) bool {
rk := ms.keyConv.GoValueOf(k.Value())
rv := ms.v.MapIndex(rk)
return rv.IsValid()
}
func (ms *mapReflect) Get(k protoreflect.MapKey) protoreflect.Value {
rk := ms.keyConv.GoValueOf(k.Value())
rv := ms.v.MapIndex(rk)
if !rv.IsValid() {
return protoreflect.Value{}
}
return ms.valConv.PBValueOf(rv)
}
func (ms *mapReflect) Set(k protoreflect.MapKey, v protoreflect.Value) {
rk := ms.keyConv.GoValueOf(k.Value())
rv := ms.valConv.GoValueOf(v)
ms.v.SetMapIndex(rk, rv)
}
func (ms *mapReflect) Clear(k protoreflect.MapKey) {
rk := ms.keyConv.GoValueOf(k.Value())
ms.v.SetMapIndex(rk, reflect.Value{})
}
func (ms *mapReflect) Mutable(k protoreflect.MapKey) protoreflect.Value {
if _, ok := ms.valConv.(*messageConverter); !ok {
panic("invalid Mutable on map with non-message value type")
}
v := ms.Get(k)
if !v.IsValid() {
v = ms.NewValue()
ms.Set(k, v)
}
return v
}
func (ms *mapReflect) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {
iter := ms.v.MapRange()
for iter.Next() {
k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
v := ms.valConv.PBValueOf(iter.Value())
if !f(k, v) {
return
}
}
}
func (ms *mapReflect) NewValue() protoreflect.Value {
return ms.valConv.New()
}
func (ms *mapReflect) IsValid() bool {
return !ms.v.IsNil()
}
func (ms *mapReflect) protoUnwrap() any {
return ms.v.Interface()
}
// 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 impl
import (
"math/bits"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
)
var errDecode = errors.New("cannot parse invalid wire-format data")
var errRecursionDepth = errors.New("exceeded maximum recursion depth")
type unmarshalOptions struct {
flags protoiface.UnmarshalInputFlags
resolver interface {
FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
}
depth int
}
func (o unmarshalOptions) Options() proto.UnmarshalOptions {
return proto.UnmarshalOptions{
Merge: true,
AllowPartial: true,
DiscardUnknown: o.DiscardUnknown(),
Resolver: o.resolver,
NoLazyDecoding: o.NoLazyDecoding(),
}
}
func (o unmarshalOptions) DiscardUnknown() bool {
return o.flags&protoiface.UnmarshalDiscardUnknown != 0
}
func (o unmarshalOptions) AliasBuffer() bool { return o.flags&protoiface.UnmarshalAliasBuffer != 0 }
func (o unmarshalOptions) Validated() bool { return o.flags&protoiface.UnmarshalValidated != 0 }
func (o unmarshalOptions) NoLazyDecoding() bool {
return o.flags&protoiface.UnmarshalNoLazyDecoding != 0
}
func (o unmarshalOptions) CanBeLazy() bool {
if o.resolver != protoregistry.GlobalTypes {
return false
}
// We ignore the UnmarshalInvalidateSizeCache even though it's not in the default set
return (o.flags & ^(protoiface.UnmarshalAliasBuffer | protoiface.UnmarshalValidated | protoiface.UnmarshalCheckRequired)) == 0
}
var lazyUnmarshalOptions = unmarshalOptions{
resolver: protoregistry.GlobalTypes,
flags: protoiface.UnmarshalAliasBuffer | protoiface.UnmarshalValidated,
depth: protowire.DefaultRecursionLimit,
}
type unmarshalOutput struct {
n int // number of bytes consumed
initialized bool
}
// unmarshal is protoreflect.Methods.Unmarshal.
func (mi *MessageInfo) unmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
var p pointer
if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer()
} else {
p = in.Message.(*messageReflectWrapper).pointer()
}
out, err := mi.unmarshalPointer(in.Buf, p, 0, unmarshalOptions{
flags: in.Flags,
resolver: in.Resolver,
depth: in.Depth,
})
var flags protoiface.UnmarshalOutputFlags
if out.initialized {
flags |= protoiface.UnmarshalInitialized
}
return protoiface.UnmarshalOutput{
Flags: flags,
}, err
}
// errUnknown is returned during unmarshaling to indicate a parse error that
// should result in a field being placed in the unknown fields section (for example,
// when the wire type doesn't match) as opposed to the entire unmarshal operation
// failing (for example, when a field extends past the available input).
//
// This is a sentinel error which should never be visible to the user.
var errUnknown = errors.New("unknown")
func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
mi.init()
opts.depth--
if opts.depth < 0 {
return out, errRecursionDepth
}
if flags.ProtoLegacy && mi.isMessageSet {
return unmarshalMessageSet(mi, b, p, opts)
}
lazyDecoding := LazyEnabled() // default
if opts.NoLazyDecoding() {
lazyDecoding = false // explicitly disabled
}
if mi.lazyOffset.IsValid() && lazyDecoding {
return mi.unmarshalPointerLazy(b, p, groupTag, opts)
}
return mi.unmarshalPointerEager(b, p, groupTag, opts)
}
// unmarshalPointerEager is the message unmarshalling function for all messages that are not lazy.
// The corresponding function for Lazy is in google_lazy.go.
func (mi *MessageInfo) unmarshalPointerEager(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
initialized := true
var requiredMask uint64
var exts *map[int32]ExtensionField
var presence presence
if mi.presenceOffset.IsValid() {
presence = p.Apply(mi.presenceOffset).PresenceInfo()
}
start := len(b)
for len(b) > 0 {
// Parse the tag (field number and wire type).
var tag uint64
if b[0] < 0x80 {
tag = uint64(b[0])
b = b[1:]
} else if len(b) >= 2 && b[1] < 128 {
tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
b = b[2:]
} else {
var n int
tag, n = protowire.ConsumeVarint(b)
if n < 0 {
return out, errDecode
}
b = b[n:]
}
var num protowire.Number
if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
return out, errDecode
} else {
num = protowire.Number(n)
}
wtyp := protowire.Type(tag & 7)
if wtyp == protowire.EndGroupType {
if num != groupTag {
return out, errDecode
}
groupTag = 0
break
}
var f *coderFieldInfo
if int(num) < len(mi.denseCoderFields) {
f = mi.denseCoderFields[num]
} else {
f = mi.coderFields[num]
}
var n int
err := errUnknown
switch {
case f != nil:
if f.funcs.unmarshal == nil {
break
}
var o unmarshalOutput
o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
n = o.n
if err != nil {
break
}
requiredMask |= f.validation.requiredBit
if f.funcs.isInit != nil && !o.initialized {
initialized = false
}
if f.presenceIndex != noPresence {
presence.SetPresentUnatomic(f.presenceIndex, mi.presenceSize)
}
default:
// Possible extension.
if exts == nil && mi.extensionOffset.IsValid() {
exts = p.Apply(mi.extensionOffset).Extensions()
if *exts == nil {
*exts = make(map[int32]ExtensionField)
}
}
if exts == nil {
break
}
var o unmarshalOutput
o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
if err != nil {
break
}
n = o.n
if !o.initialized {
initialized = false
}
}
if err != nil {
if err != errUnknown {
return out, err
}
n = protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return out, errDecode
}
if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
u := mi.mutableUnknownBytes(p)
*u = protowire.AppendTag(*u, num, wtyp)
*u = append(*u, b[:n]...)
}
}
b = b[n:]
}
if groupTag != 0 {
return out, errDecode
}
if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
initialized = false
}
if initialized {
out.initialized = true
}
out.n = start - len(b)
return out, nil
}
func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
x := exts[int32(num)]
xt := x.Type()
if xt == nil {
var err error
xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
if err != nil {
if err == protoregistry.NotFound {
return out, errUnknown
}
return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)
}
}
xi := getExtensionFieldInfo(xt)
if xi.funcs.unmarshal == nil {
return out, errUnknown
}
if flags.LazyUnmarshalExtensions {
if opts.CanBeLazy() && x.canLazy(xt) {
out, valid := skipExtension(b, xi, num, wtyp, opts)
switch valid {
case ValidationValid:
if out.initialized {
x.appendLazyBytes(xt, xi, num, wtyp, b[:out.n])
exts[int32(num)] = x
return out, nil
}
case ValidationInvalid:
return out, errDecode
case ValidationUnknown:
}
}
}
ival := x.Value()
if !ival.IsValid() && xi.unmarshalNeedsValue {
// Create a new message, list, or map value to fill in.
// For enums, create a prototype value to let the unmarshal func know the
// concrete type.
ival = xt.New()
}
v, out, err := xi.funcs.unmarshal(b, ival, num, wtyp, opts)
if err != nil {
return out, err
}
if xi.funcs.isInit == nil {
out.initialized = true
}
x.Set(xt, v)
exts[int32(num)] = x
return out, nil
}
func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
if xi.validation.mi == nil {
return out, ValidationUnknown
}
xi.validation.mi.init()
switch xi.validation.typ {
case validationTypeMessage:
if wtyp != protowire.BytesType {
return out, ValidationUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, ValidationUnknown
}
if opts.Validated() {
out.initialized = true
out.n = n
return out, ValidationValid
}
out, st := xi.validation.mi.validate(v, 0, opts)
out.n = n
return out, st
case validationTypeGroup:
if wtyp != protowire.StartGroupType {
return out, ValidationUnknown
}
out, st := xi.validation.mi.validate(b, num, opts)
return out, st
default:
return out, ValidationUnknown
}
}
// 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 impl
import (
"math"
"sort"
"sync/atomic"
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/internal/protolazy"
"google.golang.org/protobuf/proto"
piface "google.golang.org/protobuf/runtime/protoiface"
)
type marshalOptions struct {
flags piface.MarshalInputFlags
}
func (o marshalOptions) Options() proto.MarshalOptions {
return proto.MarshalOptions{
AllowPartial: true,
Deterministic: o.Deterministic(),
UseCachedSize: o.UseCachedSize(),
}
}
func (o marshalOptions) Deterministic() bool { return o.flags&piface.MarshalDeterministic != 0 }
func (o marshalOptions) UseCachedSize() bool { return o.flags&piface.MarshalUseCachedSize != 0 }
// size is protoreflect.Methods.Size.
func (mi *MessageInfo) size(in piface.SizeInput) piface.SizeOutput {
var p pointer
if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer()
} else {
p = in.Message.(*messageReflectWrapper).pointer()
}
size := mi.sizePointer(p, marshalOptions{
flags: in.Flags,
})
return piface.SizeOutput{Size: size}
}
func (mi *MessageInfo) sizePointer(p pointer, opts marshalOptions) (size int) {
mi.init()
if p.IsNil() {
return 0
}
if opts.UseCachedSize() && mi.sizecacheOffset.IsValid() {
// The size cache contains the size + 1, to allow the
// zero value to be invalid, while also allowing for a
// 0 size to be cached.
if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size > 0 {
return int(size - 1)
}
}
return mi.sizePointerSlow(p, opts)
}
func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int) {
if flags.ProtoLegacy && mi.isMessageSet {
size = sizeMessageSet(mi, p, opts)
if mi.sizecacheOffset.IsValid() {
atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size+1))
}
return size
}
if mi.extensionOffset.IsValid() {
e := p.Apply(mi.extensionOffset).Extensions()
size += mi.sizeExtensions(e, opts)
}
var lazy **protolazy.XXX_lazyUnmarshalInfo
var presence presence
if mi.presenceOffset.IsValid() {
presence = p.Apply(mi.presenceOffset).PresenceInfo()
if mi.lazyOffset.IsValid() {
lazy = p.Apply(mi.lazyOffset).LazyInfoPtr()
}
}
for _, f := range mi.orderedCoderFields {
if f.funcs.size == nil {
continue
}
fptr := p.Apply(f.offset)
if f.presenceIndex != noPresence {
if !presence.Present(f.presenceIndex) {
continue
}
if f.isLazy && fptr.AtomicGetPointer().IsNil() {
if lazyFields(opts) {
size += (*lazy).SizeField(uint32(f.num))
continue
} else {
mi.lazyUnmarshal(p, f.num)
}
}
size += f.funcs.size(fptr, f, opts)
continue
}
if f.isPointer && fptr.Elem().IsNil() {
continue
}
size += f.funcs.size(fptr, f, opts)
}
if mi.unknownOffset.IsValid() {
if u := mi.getUnknownBytes(p); u != nil {
size += len(*u)
}
}
if mi.sizecacheOffset.IsValid() {
if size > (math.MaxInt32 - 1) {
// The size is too large for the int32 sizecache field.
// We will need to recompute the size when encoding;
// unfortunately expensive, but better than invalid output.
atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), 0)
} else {
// The size cache contains the size + 1, to allow the
// zero value to be invalid, while also allowing for a
// 0 size to be cached.
atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size+1))
}
}
return size
}
// marshal is protoreflect.Methods.Marshal.
func (mi *MessageInfo) marshal(in piface.MarshalInput) (out piface.MarshalOutput, err error) {
var p pointer
if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer()
} else {
p = in.Message.(*messageReflectWrapper).pointer()
}
b, err := mi.marshalAppendPointer(in.Buf, p, marshalOptions{
flags: in.Flags,
})
return piface.MarshalOutput{Buf: b}, err
}
func (mi *MessageInfo) marshalAppendPointer(b []byte, p pointer, opts marshalOptions) ([]byte, error) {
mi.init()
if p.IsNil() {
return b, nil
}
if flags.ProtoLegacy && mi.isMessageSet {
return marshalMessageSet(mi, b, p, opts)
}
var err error
// The old marshaler encodes extensions at beginning.
if mi.extensionOffset.IsValid() {
e := p.Apply(mi.extensionOffset).Extensions()
// TODO: Special handling for MessageSet?
b, err = mi.appendExtensions(b, e, opts)
if err != nil {
return b, err
}
}
var lazy **protolazy.XXX_lazyUnmarshalInfo
var presence presence
if mi.presenceOffset.IsValid() {
presence = p.Apply(mi.presenceOffset).PresenceInfo()
if mi.lazyOffset.IsValid() {
lazy = p.Apply(mi.lazyOffset).LazyInfoPtr()
}
}
for _, f := range mi.orderedCoderFields {
if f.funcs.marshal == nil {
continue
}
fptr := p.Apply(f.offset)
if f.presenceIndex != noPresence {
if !presence.Present(f.presenceIndex) {
continue
}
if f.isLazy {
// Be careful, this field needs to be read atomically, like for a get
if f.isPointer && fptr.AtomicGetPointer().IsNil() {
if lazyFields(opts) {
b, _ = (*lazy).AppendField(b, uint32(f.num))
continue
} else {
mi.lazyUnmarshal(p, f.num)
}
}
b, err = f.funcs.marshal(b, fptr, f, opts)
if err != nil {
return b, err
}
continue
} else if f.isPointer && fptr.Elem().IsNil() {
continue
}
b, err = f.funcs.marshal(b, fptr, f, opts)
if err != nil {
return b, err
}
continue
}
if f.isPointer && fptr.Elem().IsNil() {
continue
}
b, err = f.funcs.marshal(b, fptr, f, opts)
if err != nil {
return b, err
}
}
if mi.unknownOffset.IsValid() && !mi.isMessageSet {
if u := mi.getUnknownBytes(p); u != nil {
b = append(b, (*u)...)
}
}
return b, nil
}
// fullyLazyExtensions returns true if we should attempt to keep extensions lazy over size and marshal.
func fullyLazyExtensions(opts marshalOptions) bool {
// When deterministic marshaling is requested, force an unmarshal for lazy
// extensions to produce a deterministic result, instead of passing through
// bytes lazily that may or may not match what Go Protobuf would produce.
return opts.flags&piface.MarshalDeterministic == 0
}
// lazyFields returns true if we should attempt to keep fields lazy over size and marshal.
func lazyFields(opts marshalOptions) bool {
// When deterministic marshaling is requested, force an unmarshal for lazy
// fields to produce a deterministic result, instead of passing through
// bytes lazily that may or may not match what Go Protobuf would produce.
return opts.flags&piface.MarshalDeterministic == 0
}
func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marshalOptions) (n int) {
if ext == nil {
return 0
}
for _, x := range *ext {
xi := getExtensionFieldInfo(x.Type())
if xi.funcs.size == nil {
continue
}
if fullyLazyExtensions(opts) {
// Don't expand the extension, instead use the buffer to calculate size
if lb := x.lazyBuffer(); lb != nil {
// We got hold of the buffer, so it's still lazy.
n += len(lb)
continue
}
}
n += xi.funcs.size(x.Value(), xi.tagsize, opts)
}
return n
}
func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, opts marshalOptions) ([]byte, error) {
if ext == nil {
return b, nil
}
switch len(*ext) {
case 0:
return b, nil
case 1:
// Fast-path for one extension: Don't bother sorting the keys.
var err error
for _, x := range *ext {
xi := getExtensionFieldInfo(x.Type())
if fullyLazyExtensions(opts) {
// Don't expand the extension if it's still in wire format, instead use the buffer content.
if lb := x.lazyBuffer(); lb != nil {
b = append(b, lb...)
continue
}
}
b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
}
return b, err
default:
// Sort the keys to provide a deterministic encoding.
// Not sure this is required, but the old code does it.
keys := make([]int, 0, len(*ext))
for k := range *ext {
keys = append(keys, int(k))
}
sort.Ints(keys)
var err error
for _, k := range keys {
x := (*ext)[int32(k)]
xi := getExtensionFieldInfo(x.Type())
if fullyLazyExtensions(opts) {
// Don't expand the extension if it's still in wire format, instead use the buffer content.
if lb := x.lazyBuffer(); lb != nil {
b = append(b, lb...)
continue
}
}
b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
if err != nil {
return b, err
}
}
return b, nil
}
}
// 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 impl
import (
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
type EnumInfo struct {
GoReflectType reflect.Type // int32 kind
Desc protoreflect.EnumDescriptor
}
func (t *EnumInfo) New(n protoreflect.EnumNumber) protoreflect.Enum {
return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(protoreflect.Enum)
}
func (t *EnumInfo) Descriptor() protoreflect.EnumDescriptor { return t.Desc }
// Copyright 2024 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 impl
import (
"bytes"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
func equal(in protoiface.EqualInput) protoiface.EqualOutput {
return protoiface.EqualOutput{Equal: equalMessage(in.MessageA, in.MessageB)}
}
// equalMessage is a fast-path variant of protoreflect.equalMessage.
// It takes advantage of the internal messageState type to avoid
// unnecessary allocations, type assertions.
func equalMessage(mx, my protoreflect.Message) bool {
if mx == nil || my == nil {
return mx == my
}
if mx.Descriptor() != my.Descriptor() {
return false
}
msx, ok := mx.(*messageState)
if !ok {
return protoreflect.ValueOfMessage(mx).Equal(protoreflect.ValueOfMessage(my))
}
msy, ok := my.(*messageState)
if !ok {
return protoreflect.ValueOfMessage(mx).Equal(protoreflect.ValueOfMessage(my))
}
mi := msx.messageInfo()
miy := msy.messageInfo()
if mi != miy {
return protoreflect.ValueOfMessage(mx).Equal(protoreflect.ValueOfMessage(my))
}
mi.init()
// Compares regular fields
// Modified Message.Range code that compares two messages of the same type
// while going over the fields.
for _, ri := range mi.rangeInfos {
var fd protoreflect.FieldDescriptor
var vx, vy protoreflect.Value
switch ri := ri.(type) {
case *fieldInfo:
hx := ri.has(msx.pointer())
hy := ri.has(msy.pointer())
if hx != hy {
return false
}
if !hx {
continue
}
fd = ri.fieldDesc
vx = ri.get(msx.pointer())
vy = ri.get(msy.pointer())
case *oneofInfo:
fnx := ri.which(msx.pointer())
fny := ri.which(msy.pointer())
if fnx != fny {
return false
}
if fnx <= 0 {
continue
}
fi := mi.fields[fnx]
fd = fi.fieldDesc
vx = fi.get(msx.pointer())
vy = fi.get(msy.pointer())
}
if !equalValue(fd, vx, vy) {
return false
}
}
// Compare extensions.
// This is more complicated because mx or my could have empty/nil extension maps,
// however some populated extension map values are equal to nil extension maps.
emx := mi.extensionMap(msx.pointer())
emy := mi.extensionMap(msy.pointer())
if emx != nil {
for k, x := range *emx {
xd := x.Type().TypeDescriptor()
xv := x.Value()
var y ExtensionField
ok := false
if emy != nil {
y, ok = (*emy)[k]
}
// We need to treat empty lists as equal to nil values
if emy == nil || !ok {
if xd.IsList() && xv.List().Len() == 0 {
continue
}
return false
}
if !equalValue(xd, xv, y.Value()) {
return false
}
}
}
if emy != nil {
// emy may have extensions emx does not have, need to check them as well
for k, y := range *emy {
if emx != nil {
// emx has the field, so we already checked it
if _, ok := (*emx)[k]; ok {
continue
}
}
// Empty lists are equal to nil
if y.Type().TypeDescriptor().IsList() && y.Value().List().Len() == 0 {
continue
}
// Cant be equal if the extension is populated
return false
}
}
return equalUnknown(mx.GetUnknown(), my.GetUnknown())
}
func equalValue(fd protoreflect.FieldDescriptor, vx, vy protoreflect.Value) bool {
// slow path
if fd.Kind() != protoreflect.MessageKind {
return vx.Equal(vy)
}
// fast path special cases
if fd.IsMap() {
if fd.MapValue().Kind() == protoreflect.MessageKind {
return equalMessageMap(vx.Map(), vy.Map())
}
return vx.Equal(vy)
}
if fd.IsList() {
return equalMessageList(vx.List(), vy.List())
}
return equalMessage(vx.Message(), vy.Message())
}
// Mostly copied from protoreflect.equalMap.
// This variant only works for messages as map types.
// All other map types should be handled via Value.Equal.
func equalMessageMap(mx, my protoreflect.Map) bool {
if mx.Len() != my.Len() {
return false
}
equal := true
mx.Range(func(k protoreflect.MapKey, vx protoreflect.Value) bool {
if !my.Has(k) {
equal = false
return false
}
vy := my.Get(k)
equal = equalMessage(vx.Message(), vy.Message())
return equal
})
return equal
}
// Mostly copied from protoreflect.equalList.
// The only change is the usage of equalImpl instead of protoreflect.equalValue.
func equalMessageList(lx, ly protoreflect.List) bool {
if lx.Len() != ly.Len() {
return false
}
for i := 0; i < lx.Len(); i++ {
// We only operate on messages here since equalImpl will not call us in any other case.
if !equalMessage(lx.Get(i).Message(), ly.Get(i).Message()) {
return false
}
}
return true
}
// equalUnknown compares unknown fields by direct comparison on the raw bytes
// of each individual field number.
// Copied from protoreflect.equalUnknown.
func equalUnknown(x, y protoreflect.RawFields) bool {
if len(x) != len(y) {
return false
}
if bytes.Equal([]byte(x), []byte(y)) {
return true
}
mx := make(map[protoreflect.FieldNumber]protoreflect.RawFields)
my := make(map[protoreflect.FieldNumber]protoreflect.RawFields)
for len(x) > 0 {
fnum, _, n := protowire.ConsumeField(x)
mx[fnum] = append(mx[fnum], x[:n]...)
x = x[n:]
}
for len(y) > 0 {
fnum, _, n := protowire.ConsumeField(y)
my[fnum] = append(my[fnum], y[:n]...)
y = y[n:]
}
if len(mx) != len(my) {
return false
}
for k, v1 := range mx {
if v2, ok := my[k]; !ok || !bytes.Equal([]byte(v1), []byte(v2)) {
return false
}
}
return true
}
// 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 impl
import (
"reflect"
"sync"
"sync/atomic"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// ExtensionInfo implements ExtensionType.
//
// This type contains a number of exported fields for legacy compatibility.
// The only non-deprecated use of this type is through the methods of the
// ExtensionType interface.
type ExtensionInfo struct {
// An ExtensionInfo may exist in several stages of initialization.
//
// extensionInfoUninitialized: Some or all of the legacy exported
// fields may be set, but none of the unexported fields have been
// initialized. This is the starting state for an ExtensionInfo
// in legacy generated code.
//
// extensionInfoDescInit: The desc field is set, but other unexported fields
// may not be initialized. Legacy exported fields may or may not be set.
// This is the starting state for an ExtensionInfo in newly generated code.
//
// extensionInfoFullInit: The ExtensionInfo is fully initialized.
// This state is only entered after lazy initialization is complete.
init uint32
mu sync.Mutex
goType reflect.Type
desc extensionTypeDescriptor
conv Converter
info *extensionFieldInfo // for fast-path method implementations
// ExtendedType is a typed nil-pointer to the parent message type that
// is being extended. It is possible for this to be unpopulated in v2
// since the message may no longer implement the MessageV1 interface.
//
// Deprecated: Use the ExtendedType method instead.
ExtendedType protoiface.MessageV1
// ExtensionType is the zero value of the extension type.
//
// For historical reasons, reflect.TypeOf(ExtensionType) and the
// type returned by InterfaceOf may not be identical.
//
// Deprecated: Use InterfaceOf(xt.Zero()) instead.
ExtensionType any
// Field is the field number of the extension.
//
// Deprecated: Use the Descriptor().Number method instead.
Field int32
// Name is the fully qualified name of extension.
//
// Deprecated: Use the Descriptor().FullName method instead.
Name string
// Tag is the protobuf struct tag used in the v1 API.
//
// Deprecated: Do not use.
Tag string
// Filename is the proto filename in which the extension is defined.
//
// Deprecated: Use Descriptor().ParentFile().Path() instead.
Filename string
}
// Stages of initialization: See the ExtensionInfo.init field.
const (
extensionInfoUninitialized = 0
extensionInfoDescInit = 1
extensionInfoFullInit = 2
)
func InitExtensionInfo(xi *ExtensionInfo, xd protoreflect.ExtensionDescriptor, goType reflect.Type) {
xi.goType = goType
xi.desc = extensionTypeDescriptor{xd, xi}
xi.init = extensionInfoDescInit
}
func (xi *ExtensionInfo) New() protoreflect.Value {
return xi.lazyInit().New()
}
func (xi *ExtensionInfo) Zero() protoreflect.Value {
return xi.lazyInit().Zero()
}
func (xi *ExtensionInfo) ValueOf(v any) protoreflect.Value {
return xi.lazyInit().PBValueOf(reflect.ValueOf(v))
}
func (xi *ExtensionInfo) InterfaceOf(v protoreflect.Value) any {
return xi.lazyInit().GoValueOf(v).Interface()
}
func (xi *ExtensionInfo) IsValidValue(v protoreflect.Value) bool {
return xi.lazyInit().IsValidPB(v)
}
func (xi *ExtensionInfo) IsValidInterface(v any) bool {
return xi.lazyInit().IsValidGo(reflect.ValueOf(v))
}
func (xi *ExtensionInfo) TypeDescriptor() protoreflect.ExtensionTypeDescriptor {
if atomic.LoadUint32(&xi.init) < extensionInfoDescInit {
xi.lazyInitSlow()
}
return &xi.desc
}
func (xi *ExtensionInfo) lazyInit() Converter {
if atomic.LoadUint32(&xi.init) < extensionInfoFullInit {
xi.lazyInitSlow()
}
return xi.conv
}
func (xi *ExtensionInfo) lazyInitSlow() {
xi.mu.Lock()
defer xi.mu.Unlock()
if xi.init == extensionInfoFullInit {
return
}
defer atomic.StoreUint32(&xi.init, extensionInfoFullInit)
if xi.desc.ExtensionDescriptor == nil {
xi.initFromLegacy()
}
if !xi.desc.ExtensionDescriptor.IsPlaceholder() {
if xi.ExtensionType == nil {
xi.initToLegacy()
}
xi.conv = NewConverter(xi.goType, xi.desc.ExtensionDescriptor)
xi.info = makeExtensionFieldInfo(xi.desc.ExtensionDescriptor)
xi.info.validation = newValidationInfo(xi.desc.ExtensionDescriptor, xi.goType)
}
}
type extensionTypeDescriptor struct {
protoreflect.ExtensionDescriptor
xi *ExtensionInfo
}
func (xtd *extensionTypeDescriptor) Type() protoreflect.ExtensionType {
return xtd.xi
}
func (xtd *extensionTypeDescriptor) Descriptor() protoreflect.ExtensionDescriptor {
return xtd.ExtensionDescriptor
}
// Copyright 2024 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 impl
import (
"fmt"
"math/bits"
"os"
"reflect"
"sort"
"sync/atomic"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/protolazy"
"google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry"
piface "google.golang.org/protobuf/runtime/protoiface"
)
var enableLazy int32 = func() int32 {
if os.Getenv("GOPROTODEBUG") == "nolazy" {
return 0
}
return 1
}()
// EnableLazyUnmarshal enables lazy unmarshaling.
func EnableLazyUnmarshal(enable bool) {
if enable {
atomic.StoreInt32(&enableLazy, 1)
return
}
atomic.StoreInt32(&enableLazy, 0)
}
// LazyEnabled reports whether lazy unmarshalling is currently enabled.
func LazyEnabled() bool {
return atomic.LoadInt32(&enableLazy) != 0
}
// UnmarshalField unmarshals a field in a message.
func UnmarshalField(m interface{}, num protowire.Number) {
switch m := m.(type) {
case *messageState:
m.messageInfo().lazyUnmarshal(m.pointer(), num)
case *messageReflectWrapper:
m.messageInfo().lazyUnmarshal(m.pointer(), num)
default:
panic(fmt.Sprintf("unsupported wrapper type %T", m))
}
}
func (mi *MessageInfo) lazyUnmarshal(p pointer, num protoreflect.FieldNumber) {
var f *coderFieldInfo
if int(num) < len(mi.denseCoderFields) {
f = mi.denseCoderFields[num]
} else {
f = mi.coderFields[num]
}
if f == nil {
panic(fmt.Sprintf("lazyUnmarshal: field info for %v.%v", mi.Desc.FullName(), num))
}
lazy := *p.Apply(mi.lazyOffset).LazyInfoPtr()
start, end, found, _, multipleEntries := lazy.FindFieldInProto(uint32(num))
if !found && multipleEntries == nil {
panic(fmt.Sprintf("lazyUnmarshal: can't find field data for %v.%v", mi.Desc.FullName(), num))
}
// The actual pointer in the message can not be set until the whole struct is filled in, otherwise we will have races.
// Create another pointer and set it atomically, if we won the race and the pointer in the original message is still nil.
fp := pointerOfValue(reflect.New(f.ft))
if multipleEntries != nil {
for _, entry := range multipleEntries {
mi.unmarshalField(lazy.Buffer()[entry.Start:entry.End], fp, f, lazy, lazy.UnmarshalFlags())
}
} else {
mi.unmarshalField(lazy.Buffer()[start:end], fp, f, lazy, lazy.UnmarshalFlags())
}
p.Apply(f.offset).AtomicSetPointerIfNil(fp.Elem())
}
func (mi *MessageInfo) unmarshalField(b []byte, p pointer, f *coderFieldInfo, lazyInfo *protolazy.XXX_lazyUnmarshalInfo, flags piface.UnmarshalInputFlags) error {
opts := lazyUnmarshalOptions
opts.flags |= flags
for len(b) > 0 {
// Parse the tag (field number and wire type).
var tag uint64
if b[0] < 0x80 {
tag = uint64(b[0])
b = b[1:]
} else if len(b) >= 2 && b[1] < 128 {
tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
b = b[2:]
} else {
var n int
tag, n = protowire.ConsumeVarint(b)
if n < 0 {
return errors.New("invalid wire data")
}
b = b[n:]
}
var num protowire.Number
if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
return errors.New("invalid wire data")
} else {
num = protowire.Number(n)
}
wtyp := protowire.Type(tag & 7)
if num == f.num {
o, err := f.funcs.unmarshal(b, p, wtyp, f, opts)
if err == nil {
b = b[o.n:]
continue
}
if err != errUnknown {
return err
}
}
n := protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return errors.New("invalid wire data")
}
b = b[n:]
}
return nil
}
func (mi *MessageInfo) skipField(b []byte, f *coderFieldInfo, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
fmi := f.validation.mi
if fmi == nil {
fd := mi.Desc.Fields().ByNumber(f.num)
if fd == nil {
return out, ValidationUnknown
}
messageName := fd.Message().FullName()
messageType, err := preg.GlobalTypes.FindMessageByName(messageName)
if err != nil {
return out, ValidationUnknown
}
var ok bool
fmi, ok = messageType.(*MessageInfo)
if !ok {
return out, ValidationUnknown
}
}
fmi.init()
switch f.validation.typ {
case validationTypeMessage:
if wtyp != protowire.BytesType {
return out, ValidationWrongWireType
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return out, ValidationInvalid
}
out, st := fmi.validate(v, 0, opts)
out.n = n
return out, st
case validationTypeGroup:
if wtyp != protowire.StartGroupType {
return out, ValidationWrongWireType
}
out, st := fmi.validate(b, f.num, opts)
return out, st
default:
return out, ValidationUnknown
}
}
// unmarshalPointerLazy is similar to unmarshalPointerEager, but it
// specifically handles lazy unmarshalling. it expects lazyOffset and
// presenceOffset to both be valid.
func (mi *MessageInfo) unmarshalPointerLazy(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
initialized := true
var requiredMask uint64
var lazy **protolazy.XXX_lazyUnmarshalInfo
var presence presence
var lazyIndex []protolazy.IndexEntry
var lastNum protowire.Number
outOfOrder := false
lazyDecode := false
presence = p.Apply(mi.presenceOffset).PresenceInfo()
lazy = p.Apply(mi.lazyOffset).LazyInfoPtr()
if !presence.AnyPresent(mi.presenceSize) {
if opts.CanBeLazy() {
// If the message contains existing data, we need to merge into it.
// Lazy unmarshaling doesn't merge, so only enable it when the
// message is empty (has no presence bitmap).
lazyDecode = true
if *lazy == nil {
*lazy = &protolazy.XXX_lazyUnmarshalInfo{}
}
(*lazy).SetUnmarshalFlags(opts.flags)
if !opts.AliasBuffer() {
// Make a copy of the buffer for lazy unmarshaling.
// Set the AliasBuffer flag so recursive unmarshal
// operations reuse the copy.
b = append([]byte{}, b...)
opts.flags |= piface.UnmarshalAliasBuffer
}
(*lazy).SetBuffer(b)
}
}
// Track special handling of lazy fields.
//
// In the common case, all fields are lazyValidateOnly (and lazyFields remains nil).
// In the event that validation for a field fails, this map tracks handling of the field.
type lazyAction uint8
const (
lazyValidateOnly lazyAction = iota // validate the field only
lazyUnmarshalNow // eagerly unmarshal the field
lazyUnmarshalLater // unmarshal the field after the message is fully processed
)
var lazyFields map[*coderFieldInfo]lazyAction
var exts *map[int32]ExtensionField
start := len(b)
pos := 0
for len(b) > 0 {
// Parse the tag (field number and wire type).
var tag uint64
if b[0] < 0x80 {
tag = uint64(b[0])
b = b[1:]
} else if len(b) >= 2 && b[1] < 128 {
tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
b = b[2:]
} else {
var n int
tag, n = protowire.ConsumeVarint(b)
if n < 0 {
return out, errDecode
}
b = b[n:]
}
var num protowire.Number
if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
return out, errors.New("invalid field number")
} else {
num = protowire.Number(n)
}
wtyp := protowire.Type(tag & 7)
if wtyp == protowire.EndGroupType {
if num != groupTag {
return out, errors.New("mismatching end group marker")
}
groupTag = 0
break
}
var f *coderFieldInfo
if int(num) < len(mi.denseCoderFields) {
f = mi.denseCoderFields[num]
} else {
f = mi.coderFields[num]
}
var n int
err := errUnknown
discardUnknown := false
Field:
switch {
case f != nil:
if f.funcs.unmarshal == nil {
break
}
if f.isLazy && lazyDecode {
switch {
case lazyFields == nil || lazyFields[f] == lazyValidateOnly:
// Attempt to validate this field and leave it for later lazy unmarshaling.
o, valid := mi.skipField(b, f, wtyp, opts)
switch valid {
case ValidationValid:
// Skip over the valid field and continue.
err = nil
presence.SetPresentUnatomic(f.presenceIndex, mi.presenceSize)
requiredMask |= f.validation.requiredBit
if !o.initialized {
initialized = false
}
n = o.n
break Field
case ValidationInvalid:
return out, errors.New("invalid proto wire format")
case ValidationWrongWireType:
break Field
case ValidationUnknown:
if lazyFields == nil {
lazyFields = make(map[*coderFieldInfo]lazyAction)
}
if presence.Present(f.presenceIndex) {
// We were unable to determine if the field is valid or not,
// and we've already skipped over at least one instance of this
// field. Clear the presence bit (so if we stop decoding early,
// we don't leave a partially-initialized field around) and flag
// the field for unmarshaling before we return.
presence.ClearPresent(f.presenceIndex)
lazyFields[f] = lazyUnmarshalLater
discardUnknown = true
break Field
} else {
// We were unable to determine if the field is valid or not,
// but this is the first time we've seen it. Flag it as needing
// eager unmarshaling and fall through to the eager unmarshal case below.
lazyFields[f] = lazyUnmarshalNow
}
}
case lazyFields[f] == lazyUnmarshalLater:
// This field will be unmarshaled in a separate pass below.
// Skip over it here.
discardUnknown = true
break Field
default:
// Eagerly unmarshal the field.
}
}
if f.isLazy && !lazyDecode && presence.Present(f.presenceIndex) {
if p.Apply(f.offset).AtomicGetPointer().IsNil() {
mi.lazyUnmarshal(p, f.num)
}
}
var o unmarshalOutput
o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
n = o.n
if err != nil {
break
}
requiredMask |= f.validation.requiredBit
if f.funcs.isInit != nil && !o.initialized {
initialized = false
}
if f.presenceIndex != noPresence {
presence.SetPresentUnatomic(f.presenceIndex, mi.presenceSize)
}
default:
// Possible extension.
if exts == nil && mi.extensionOffset.IsValid() {
exts = p.Apply(mi.extensionOffset).Extensions()
if *exts == nil {
*exts = make(map[int32]ExtensionField)
}
}
if exts == nil {
break
}
var o unmarshalOutput
o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
if err != nil {
break
}
n = o.n
if !o.initialized {
initialized = false
}
}
if err != nil {
if err != errUnknown {
return out, err
}
n = protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return out, errDecode
}
if !discardUnknown && !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
u := mi.mutableUnknownBytes(p)
*u = protowire.AppendTag(*u, num, wtyp)
*u = append(*u, b[:n]...)
}
}
b = b[n:]
end := start - len(b)
if lazyDecode && f != nil && f.isLazy {
if num != lastNum {
lazyIndex = append(lazyIndex, protolazy.IndexEntry{
FieldNum: uint32(num),
Start: uint32(pos),
End: uint32(end),
})
} else {
i := len(lazyIndex) - 1
lazyIndex[i].End = uint32(end)
lazyIndex[i].MultipleContiguous = true
}
}
if num < lastNum {
outOfOrder = true
}
pos = end
lastNum = num
}
if groupTag != 0 {
return out, errors.New("missing end group marker")
}
if lazyFields != nil {
// Some fields failed validation, and now need to be unmarshaled.
for f, action := range lazyFields {
if action != lazyUnmarshalLater {
continue
}
initialized = false
if *lazy == nil {
*lazy = &protolazy.XXX_lazyUnmarshalInfo{}
}
if err := mi.unmarshalField((*lazy).Buffer(), p.Apply(f.offset), f, *lazy, opts.flags); err != nil {
return out, err
}
presence.SetPresentUnatomic(f.presenceIndex, mi.presenceSize)
}
}
if lazyDecode {
if outOfOrder {
sort.Slice(lazyIndex, func(i, j int) bool {
return lazyIndex[i].FieldNum < lazyIndex[j].FieldNum ||
(lazyIndex[i].FieldNum == lazyIndex[j].FieldNum &&
lazyIndex[i].Start < lazyIndex[j].Start)
})
}
if *lazy == nil {
*lazy = &protolazy.XXX_lazyUnmarshalInfo{}
}
(*lazy).SetIndex(lazyIndex)
}
if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
initialized = false
}
if initialized {
out.initialized = true
}
out.n = start - len(b)
return out, nil
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"strings"
"sync"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
// legacyEnumName returns the name of enums used in legacy code.
// It is neither the protobuf full name nor the qualified Go name,
// but rather an odd hybrid of both.
func legacyEnumName(ed protoreflect.EnumDescriptor) string {
var protoPkg string
enumName := string(ed.FullName())
if fd := ed.ParentFile(); fd != nil {
protoPkg = string(fd.Package())
enumName = strings.TrimPrefix(enumName, protoPkg+".")
}
if protoPkg == "" {
return strs.GoCamelCase(enumName)
}
return protoPkg + "." + strs.GoCamelCase(enumName)
}
// legacyWrapEnum wraps v as a protoreflect.Enum,
// where v must be a int32 kind and not implement the v2 API already.
func legacyWrapEnum(v reflect.Value) protoreflect.Enum {
et := legacyLoadEnumType(v.Type())
return et.New(protoreflect.EnumNumber(v.Int()))
}
var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
// where t must be an int32 kind and not implement the v2 API already.
func legacyLoadEnumType(t reflect.Type) protoreflect.EnumType {
// Fast-path: check if a EnumType is cached for this concrete type.
if et, ok := legacyEnumTypeCache.Load(t); ok {
return et.(protoreflect.EnumType)
}
// Slow-path: derive enum descriptor and initialize EnumType.
var et protoreflect.EnumType
ed := LegacyLoadEnumDesc(t)
et = &legacyEnumType{
desc: ed,
goType: t,
}
if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
return et.(protoreflect.EnumType)
}
return et
}
type legacyEnumType struct {
desc protoreflect.EnumDescriptor
goType reflect.Type
m sync.Map // map[protoreflect.EnumNumber]proto.Enum
}
func (t *legacyEnumType) New(n protoreflect.EnumNumber) protoreflect.Enum {
if e, ok := t.m.Load(n); ok {
return e.(protoreflect.Enum)
}
e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
t.m.Store(n, e)
return e
}
func (t *legacyEnumType) Descriptor() protoreflect.EnumDescriptor {
return t.desc
}
type legacyEnumWrapper struct {
num protoreflect.EnumNumber
pbTyp protoreflect.EnumType
goTyp reflect.Type
}
func (e *legacyEnumWrapper) Descriptor() protoreflect.EnumDescriptor {
return e.pbTyp.Descriptor()
}
func (e *legacyEnumWrapper) Type() protoreflect.EnumType {
return e.pbTyp
}
func (e *legacyEnumWrapper) Number() protoreflect.EnumNumber {
return e.num
}
func (e *legacyEnumWrapper) ProtoReflect() protoreflect.Enum {
return e
}
func (e *legacyEnumWrapper) protoUnwrap() any {
v := reflect.New(e.goTyp).Elem()
v.SetInt(int64(e.num))
return v.Interface()
}
var (
_ protoreflect.Enum = (*legacyEnumWrapper)(nil)
_ unwrapper = (*legacyEnumWrapper)(nil)
)
var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
// LegacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
// which must be an int32 kind and not implement the v2 API already.
//
// This is exported for testing purposes.
func LegacyLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type.
if ed, ok := legacyEnumDescCache.Load(t); ok {
return ed.(protoreflect.EnumDescriptor)
}
// Slow-path: initialize EnumDescriptor from the raw descriptor.
ev := reflect.Zero(t).Interface()
if _, ok := ev.(protoreflect.Enum); ok {
panic(fmt.Sprintf("%v already implements proto.Enum", t))
}
edV1, ok := ev.(enumV1)
if !ok {
return aberrantLoadEnumDesc(t)
}
b, idxs := edV1.EnumDescriptor()
var ed protoreflect.EnumDescriptor
if len(idxs) == 1 {
ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
} else {
md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
for _, i := range idxs[1 : len(idxs)-1] {
md = md.Messages().Get(i)
}
ed = md.Enums().Get(idxs[len(idxs)-1])
}
if ed, ok := legacyEnumDescCache.LoadOrStore(t, ed); ok {
return ed.(protoreflect.EnumDescriptor)
}
return ed
}
var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
// aberrantLoadEnumDesc returns an EnumDescriptor derived from the Go type,
// which must not implement protoreflect.Enum or enumV1.
//
// If the type does not implement enumV1, then there is no reliable
// way to derive the original protobuf type information.
// We are unable to use the global enum registry since it is
// unfortunately keyed by the protobuf full name, which we also do not know.
// Thus, this produces some bogus enum descriptor based on the Go type name.
func aberrantLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type.
if ed, ok := aberrantEnumDescCache.Load(t); ok {
return ed.(protoreflect.EnumDescriptor)
}
// Slow-path: construct a bogus, but unique EnumDescriptor.
ed := &filedesc.Enum{L2: new(filedesc.EnumL2)}
ed.L0.FullName = AberrantDeriveFullName(t) // e.g., github_com.user.repo.MyEnum
ed.L0.ParentFile = filedesc.SurrogateProto3
ed.L1.EditionFeatures = ed.L0.ParentFile.L1.EditionFeatures
ed.L2.Values.List = append(ed.L2.Values.List, filedesc.EnumValue{})
// TODO: Use the presence of a UnmarshalJSON method to determine proto2?
vd := &ed.L2.Values.List[0]
vd.L0.FullName = ed.L0.FullName + "_UNKNOWN" // e.g., github_com.user.repo.MyEnum_UNKNOWN
vd.L0.ParentFile = ed.L0.ParentFile
vd.L0.Parent = ed
// TODO: We could use the String method to obtain some enum value names by
// starting at 0 and print the enum until it produces invalid identifiers.
// An exhaustive query is clearly impractical, but can be best-effort.
if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
return ed.(protoreflect.EnumDescriptor)
}
return ed
}
// AberrantDeriveFullName derives a fully qualified protobuf name for the given Go type
// The provided name is not guaranteed to be stable nor universally unique.
// It should be sufficiently unique within a program.
//
// This is exported for testing purposes.
func AberrantDeriveFullName(t reflect.Type) protoreflect.FullName {
sanitize := func(r rune) rune {
switch {
case r == '/':
return '.'
case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
return r
default:
return '_'
}
}
prefix := strings.Map(sanitize, t.PkgPath())
suffix := strings.Map(sanitize, t.Name())
if suffix == "" {
suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
}
ss := append(strings.Split(prefix, "."), suffix)
for i, s := range ss {
if s == "" || ('0' <= s[0] && s[0] <= '9') {
ss[i] = "x" + s
}
}
return protoreflect.FullName(strings.Join(ss, "."))
}
// 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 impl
import (
"encoding/binary"
"encoding/json"
"hash/crc32"
"math"
"reflect"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// These functions exist to support exported APIs in generated protobufs.
// While these are deprecated, they cannot be removed for compatibility reasons.
// LegacyEnumName returns the name of enums used in legacy code.
func (Export) LegacyEnumName(ed protoreflect.EnumDescriptor) string {
return legacyEnumName(ed)
}
// LegacyMessageTypeOf returns the protoreflect.MessageType for m,
// with name used as the message name if necessary.
func (Export) LegacyMessageTypeOf(m protoiface.MessageV1, name protoreflect.FullName) protoreflect.MessageType {
if mv := (Export{}).protoMessageV2Of(m); mv != nil {
return mv.ProtoReflect().Type()
}
return legacyLoadMessageType(reflect.TypeOf(m), name)
}
// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
// The input can either be a string representing the enum value by name,
// or a number representing the enum number itself.
func (Export) UnmarshalJSONEnum(ed protoreflect.EnumDescriptor, b []byte) (protoreflect.EnumNumber, error) {
if b[0] == '"' {
var name protoreflect.Name
if err := json.Unmarshal(b, &name); err != nil {
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
}
ev := ed.Values().ByName(name)
if ev == nil {
return 0, errors.New("invalid value for enum %v: %s", ed.FullName(), name)
}
return ev.Number(), nil
} else {
var num protoreflect.EnumNumber
if err := json.Unmarshal(b, &num); err != nil {
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
}
return num, nil
}
}
// CompressGZIP compresses the input as a GZIP-encoded file.
// The current implementation does no compression.
func (Export) CompressGZIP(in []byte) (out []byte) {
// RFC 1952, section 2.3.1.
var gzipHeader = [10]byte{0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}
// RFC 1951, section 3.2.4.
var blockHeader [5]byte
const maxBlockSize = math.MaxUint16
numBlocks := 1 + len(in)/maxBlockSize
// RFC 1952, section 2.3.1.
var gzipFooter [8]byte
binary.LittleEndian.PutUint32(gzipFooter[0:4], crc32.ChecksumIEEE(in))
binary.LittleEndian.PutUint32(gzipFooter[4:8], uint32(len(in)))
// Encode the input without compression using raw DEFLATE blocks.
out = make([]byte, 0, len(gzipHeader)+len(blockHeader)*numBlocks+len(in)+len(gzipFooter))
out = append(out, gzipHeader[:]...)
for blockHeader[0] == 0 {
blockSize := maxBlockSize
if blockSize > len(in) {
blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
blockSize = len(in)
}
binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize))
binary.LittleEndian.PutUint16(blockHeader[3:5], ^uint16(blockSize))
out = append(out, blockHeader[:]...)
out = append(out, in[:blockSize]...)
in = in[blockSize:]
}
out = append(out, gzipFooter[:]...)
return out
}
// Copyright 2018 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 impl
import (
"reflect"
"google.golang.org/protobuf/internal/descopts"
"google.golang.org/protobuf/internal/encoding/messageset"
ptag "google.golang.org/protobuf/internal/encoding/tag"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
)
func (xi *ExtensionInfo) initToLegacy() {
xd := xi.desc
var parent protoiface.MessageV1
messageName := xd.ContainingMessage().FullName()
if mt, _ := protoregistry.GlobalTypes.FindMessageByName(messageName); mt != nil {
// Create a new parent message and unwrap it if possible.
mv := mt.New().Interface()
t := reflect.TypeOf(mv)
if mv, ok := mv.(unwrapper); ok {
t = reflect.TypeOf(mv.protoUnwrap())
}
// Check whether the message implements the legacy v1 Message interface.
mz := reflect.Zero(t).Interface()
if mz, ok := mz.(protoiface.MessageV1); ok {
parent = mz
}
}
// Determine the v1 extension type, which is unfortunately not the same as
// the v2 ExtensionType.GoType.
extType := xi.goType
switch extType.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields
}
// Reconstruct the legacy enum full name.
var enumName string
if xd.Kind() == protoreflect.EnumKind {
enumName = legacyEnumName(xd.Enum())
}
// Derive the proto file that the extension was declared within.
var filename string
if fd := xd.ParentFile(); fd != nil {
filename = fd.Path()
}
// For MessageSet extensions, the name used is the parent message.
name := xd.FullName()
if messageset.IsMessageSetExtension(xd) {
name = name.Parent()
}
xi.ExtendedType = parent
xi.ExtensionType = reflect.Zero(extType).Interface()
xi.Field = int32(xd.Number())
xi.Name = string(name)
xi.Tag = ptag.Marshal(xd, enumName)
xi.Filename = filename
}
// initFromLegacy initializes an ExtensionInfo from
// the contents of the deprecated exported fields of the type.
func (xi *ExtensionInfo) initFromLegacy() {
// The v1 API returns "type incomplete" descriptors where only the
// field number is specified. In such a case, use a placeholder.
if xi.ExtendedType == nil || xi.ExtensionType == nil {
xd := placeholderExtension{
name: protoreflect.FullName(xi.Name),
number: protoreflect.FieldNumber(xi.Field),
}
xi.desc = extensionTypeDescriptor{xd, xi}
return
}
// Resolve enum or message dependencies.
var ed protoreflect.EnumDescriptor
var md protoreflect.MessageDescriptor
t := reflect.TypeOf(xi.ExtensionType)
isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
if isOptional || isRepeated {
t = t.Elem()
}
switch v := reflect.Zero(t).Interface().(type) {
case protoreflect.Enum:
ed = v.Descriptor()
case enumV1:
ed = LegacyLoadEnumDesc(t)
case protoreflect.ProtoMessage:
md = v.ProtoReflect().Descriptor()
case messageV1:
md = LegacyLoadMessageDesc(t)
}
// Derive basic field information from the struct tag.
var evs protoreflect.EnumValueDescriptors
if ed != nil {
evs = ed.Values()
}
fd := ptag.Unmarshal(xi.Tag, t, evs).(*filedesc.Field)
// Construct a v2 ExtensionType.
xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)}
xd.L0.ParentFile = filedesc.SurrogateProto2
xd.L0.FullName = protoreflect.FullName(xi.Name)
xd.L1.Number = protoreflect.FieldNumber(xi.Field)
xd.L1.Cardinality = fd.L1.Cardinality
xd.L1.Kind = fd.L1.Kind
xd.L1.EditionFeatures = fd.L1.EditionFeatures
xd.L2.Default = fd.L1.Default
xd.L1.Extendee = Export{}.MessageDescriptorOf(xi.ExtendedType)
xd.L2.Enum = ed
xd.L2.Message = md
// Derive real extension field name for MessageSets.
if messageset.IsMessageSet(xd.L1.Extendee) && md.FullName() == xd.L0.FullName {
xd.L0.FullName = xd.L0.FullName.Append(messageset.ExtensionName)
}
tt := reflect.TypeOf(xi.ExtensionType)
if isOptional {
tt = tt.Elem()
}
xi.goType = tt
xi.desc = extensionTypeDescriptor{xd, xi}
}
type placeholderExtension struct {
name protoreflect.FullName
number protoreflect.FieldNumber
}
func (x placeholderExtension) ParentFile() protoreflect.FileDescriptor { return nil }
func (x placeholderExtension) Parent() protoreflect.Descriptor { return nil }
func (x placeholderExtension) Index() int { return 0 }
func (x placeholderExtension) Syntax() protoreflect.Syntax { return 0 }
func (x placeholderExtension) Name() protoreflect.Name { return x.name.Name() }
func (x placeholderExtension) FullName() protoreflect.FullName { return x.name }
func (x placeholderExtension) IsPlaceholder() bool { return true }
func (x placeholderExtension) Options() protoreflect.ProtoMessage { return descopts.Field }
func (x placeholderExtension) Number() protoreflect.FieldNumber { return x.number }
func (x placeholderExtension) Cardinality() protoreflect.Cardinality { return 0 }
func (x placeholderExtension) Kind() protoreflect.Kind { return 0 }
func (x placeholderExtension) HasJSONName() bool { return false }
func (x placeholderExtension) JSONName() string { return "[" + string(x.name) + "]" }
func (x placeholderExtension) TextName() string { return "[" + string(x.name) + "]" }
func (x placeholderExtension) HasPresence() bool { return false }
func (x placeholderExtension) HasOptionalKeyword() bool { return false }
func (x placeholderExtension) IsExtension() bool { return true }
func (x placeholderExtension) IsWeak() bool { return false }
func (x placeholderExtension) IsLazy() bool { return false }
func (x placeholderExtension) IsPacked() bool { return false }
func (x placeholderExtension) IsList() bool { return false }
func (x placeholderExtension) IsMap() bool { return false }
func (x placeholderExtension) MapKey() protoreflect.FieldDescriptor { return nil }
func (x placeholderExtension) MapValue() protoreflect.FieldDescriptor { return nil }
func (x placeholderExtension) HasDefault() bool { return false }
func (x placeholderExtension) Default() protoreflect.Value { return protoreflect.Value{} }
func (x placeholderExtension) DefaultEnumValue() protoreflect.EnumValueDescriptor { return nil }
func (x placeholderExtension) ContainingOneof() protoreflect.OneofDescriptor { return nil }
func (x placeholderExtension) ContainingMessage() protoreflect.MessageDescriptor { return nil }
func (x placeholderExtension) Enum() protoreflect.EnumDescriptor { return nil }
func (x placeholderExtension) Message() protoreflect.MessageDescriptor { return nil }
func (x placeholderExtension) ProtoType(protoreflect.FieldDescriptor) { return }
func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement) { return }
// Copyright 2018 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 impl
import (
"bytes"
"compress/gzip"
"io"
"sync"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
// Every enum and message type generated by protoc-gen-go since commit 2fc053c5
// on February 25th, 2016 has had a method to get the raw descriptor.
// Types that were not generated by protoc-gen-go or were generated prior
// to that version are not supported.
//
// The []byte returned is the encoded form of a FileDescriptorProto message
// compressed using GZIP. The []int is the path from the top-level file
// to the specific message or enum declaration.
type (
enumV1 interface {
EnumDescriptor() ([]byte, []int)
}
messageV1 interface {
Descriptor() ([]byte, []int)
}
)
var legacyFileDescCache sync.Map // map[*byte]protoreflect.FileDescriptor
// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
//
// This assumes that b is immutable and that b does not refer to part of a
// concatenated series of GZIP files (which would require shenanigans that
// rely on the concatenation properties of both protobufs and GZIP).
// File descriptors generated by protoc-gen-go do not rely on that property.
func legacyLoadFileDesc(b []byte) protoreflect.FileDescriptor {
// Fast-path: check whether we already have a cached file descriptor.
if fd, ok := legacyFileDescCache.Load(&b[0]); ok {
return fd.(protoreflect.FileDescriptor)
}
// Slow-path: decompress and unmarshal the file descriptor proto.
zr, err := gzip.NewReader(bytes.NewReader(b))
if err != nil {
panic(err)
}
b2, err := io.ReadAll(zr)
if err != nil {
panic(err)
}
fd := filedesc.Builder{
RawDescriptor: b2,
FileRegistry: resolverOnly{protoregistry.GlobalFiles}, // do not register back to global registry
}.Build().File
if fd, ok := legacyFileDescCache.LoadOrStore(&b[0], fd); ok {
return fd.(protoreflect.FileDescriptor)
}
return fd
}
type resolverOnly struct {
reg *protoregistry.Files
}
func (r resolverOnly) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
return r.reg.FindFileByPath(path)
}
func (r resolverOnly) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
return r.reg.FindDescriptorByName(name)
}
func (resolverOnly) RegisterFile(protoreflect.FileDescriptor) error {
return nil
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"strings"
"sync"
"google.golang.org/protobuf/internal/descopts"
ptag "google.golang.org/protobuf/internal/encoding/tag"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// legacyWrapMessage wraps v as a protoreflect.Message,
// where v must be a *struct kind and not implement the v2 API already.
func legacyWrapMessage(v reflect.Value) protoreflect.Message {
t := v.Type()
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return aberrantMessage{v: v}
}
mt := legacyLoadMessageInfo(t, "")
return mt.MessageOf(v.Interface())
}
// legacyLoadMessageType dynamically loads a protoreflect.Type for t,
// where t must be not implement the v2 API already.
// The provided name is used if it cannot be determined from the message.
func legacyLoadMessageType(t reflect.Type, name protoreflect.FullName) protoreflect.MessageType {
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return aberrantMessageType{t}
}
return legacyLoadMessageInfo(t, name)
}
var legacyMessageTypeCache sync.Map // map[reflect.Type]*MessageInfo
// legacyLoadMessageInfo dynamically loads a *MessageInfo for t,
// where t must be a *struct kind and not implement the v2 API already.
// The provided name is used if it cannot be determined from the message.
func legacyLoadMessageInfo(t reflect.Type, name protoreflect.FullName) *MessageInfo {
// Fast-path: check if a MessageInfo is cached for this concrete type.
if mt, ok := legacyMessageTypeCache.Load(t); ok {
return mt.(*MessageInfo)
}
// Slow-path: derive message descriptor and initialize MessageInfo.
mi := &MessageInfo{
Desc: legacyLoadMessageDesc(t, name),
GoReflectType: t,
}
var hasMarshal, hasUnmarshal bool
v := reflect.Zero(t).Interface()
if _, hasMarshal = v.(legacyMarshaler); hasMarshal {
mi.methods.Marshal = legacyMarshal
// We have no way to tell whether the type's Marshal method
// supports deterministic serialization or not, but this
// preserves the v1 implementation's behavior of always
// calling Marshal methods when present.
mi.methods.Flags |= protoiface.SupportMarshalDeterministic
}
if _, hasUnmarshal = v.(legacyUnmarshaler); hasUnmarshal {
mi.methods.Unmarshal = legacyUnmarshal
}
if _, hasMerge := v.(legacyMerger); hasMerge || (hasMarshal && hasUnmarshal) {
mi.methods.Merge = legacyMerge
}
if mi, ok := legacyMessageTypeCache.LoadOrStore(t, mi); ok {
return mi.(*MessageInfo)
}
return mi
}
var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
// LegacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
// which should be a *struct kind and must not implement the v2 API already.
//
// This is exported for testing purposes.
func LegacyLoadMessageDesc(t reflect.Type) protoreflect.MessageDescriptor {
return legacyLoadMessageDesc(t, "")
}
func legacyLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
// Fast-path: check if a MessageDescriptor is cached for this concrete type.
if mi, ok := legacyMessageDescCache.Load(t); ok {
return mi.(protoreflect.MessageDescriptor)
}
// Slow-path: initialize MessageDescriptor from the raw descriptor.
mv := reflect.Zero(t).Interface()
if _, ok := mv.(protoreflect.ProtoMessage); ok {
panic(fmt.Sprintf("%v already implements proto.Message", t))
}
mdV1, ok := mv.(messageV1)
if !ok {
return aberrantLoadMessageDesc(t, name)
}
// If this is a dynamic message type where there isn't a 1-1 mapping between
// Go and protobuf types, calling the Descriptor method on the zero value of
// the message type isn't likely to work. If it panics, swallow the panic and
// continue as if the Descriptor method wasn't present.
b, idxs := func() ([]byte, []int) {
defer func() {
recover()
}()
return mdV1.Descriptor()
}()
if b == nil {
return aberrantLoadMessageDesc(t, name)
}
// If the Go type has no fields, then this might be a proto3 empty message
// from before the size cache was added. If there are any fields, check to
// see that at least one of them looks like something we generated.
if t.Elem().Kind() == reflect.Struct {
if nfield := t.Elem().NumField(); nfield > 0 {
hasProtoField := false
for i := 0; i < nfield; i++ {
f := t.Elem().Field(i)
if f.Tag.Get("protobuf") != "" || f.Tag.Get("protobuf_oneof") != "" || strings.HasPrefix(f.Name, "XXX_") {
hasProtoField = true
break
}
}
if !hasProtoField {
return aberrantLoadMessageDesc(t, name)
}
}
}
md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
for _, i := range idxs[1:] {
md = md.Messages().Get(i)
}
if name != "" && md.FullName() != name {
panic(fmt.Sprintf("mismatching message name: got %v, want %v", md.FullName(), name))
}
if md, ok := legacyMessageDescCache.LoadOrStore(t, md); ok {
return md.(protoreflect.MessageDescriptor)
}
return md
}
var (
aberrantMessageDescLock sync.Mutex
aberrantMessageDescCache map[reflect.Type]protoreflect.MessageDescriptor
)
// aberrantLoadMessageDesc returns an MessageDescriptor derived from the Go type,
// which must not implement protoreflect.ProtoMessage or messageV1.
//
// This is a best-effort derivation of the message descriptor using the protobuf
// tags on the struct fields.
func aberrantLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
aberrantMessageDescLock.Lock()
defer aberrantMessageDescLock.Unlock()
if aberrantMessageDescCache == nil {
aberrantMessageDescCache = make(map[reflect.Type]protoreflect.MessageDescriptor)
}
return aberrantLoadMessageDescReentrant(t, name)
}
func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
// Fast-path: check if an MessageDescriptor is cached for this concrete type.
if md, ok := aberrantMessageDescCache[t]; ok {
return md
}
// Slow-path: construct a descriptor from the Go struct type (best-effort).
// Cache the MessageDescriptor early on so that we can resolve internal
// cyclic references.
md := &filedesc.Message{L2: new(filedesc.MessageL2)}
md.L0.FullName = aberrantDeriveMessageName(t, name)
md.L0.ParentFile = filedesc.SurrogateProto2
aberrantMessageDescCache[t] = md
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return md
}
// Try to determine if the message is using proto3 by checking scalars.
for i := 0; i < t.Elem().NumField(); i++ {
f := t.Elem().Field(i)
if tag := f.Tag.Get("protobuf"); tag != "" {
switch f.Type.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
md.L0.ParentFile = filedesc.SurrogateProto3
}
for _, s := range strings.Split(tag, ",") {
if s == "proto3" {
md.L0.ParentFile = filedesc.SurrogateProto3
}
}
}
}
md.L1.EditionFeatures = md.L0.ParentFile.L1.EditionFeatures
// Obtain a list of oneof wrapper types.
var oneofWrappers []reflect.Type
methods := make([]reflect.Method, 0, 2)
if m, ok := t.MethodByName("XXX_OneofFuncs"); ok {
methods = append(methods, m)
}
if m, ok := t.MethodByName("XXX_OneofWrappers"); ok {
methods = append(methods, m)
}
for _, fn := range methods {
for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
if vs, ok := v.Interface().([]any); ok {
for _, v := range vs {
oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
}
}
}
}
// Obtain a list of the extension ranges.
if fn, ok := t.MethodByName("ExtensionRangeArray"); ok {
vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
for i := 0; i < vs.Len(); i++ {
v := vs.Index(i)
md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]protoreflect.FieldNumber{
protoreflect.FieldNumber(v.FieldByName("Start").Int()),
protoreflect.FieldNumber(v.FieldByName("End").Int() + 1),
})
md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil)
}
}
// Derive the message fields by inspecting the struct fields.
for i := 0; i < t.Elem().NumField(); i++ {
f := t.Elem().Field(i)
if tag := f.Tag.Get("protobuf"); tag != "" {
tagKey := f.Tag.Get("protobuf_key")
tagVal := f.Tag.Get("protobuf_val")
aberrantAppendField(md, f.Type, tag, tagKey, tagVal)
}
if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
n := len(md.L2.Oneofs.List)
md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{})
od := &md.L2.Oneofs.List[n]
od.L0.FullName = md.FullName().Append(protoreflect.Name(tag))
od.L0.ParentFile = md.L0.ParentFile
od.L1.EditionFeatures = md.L1.EditionFeatures
od.L0.Parent = md
od.L0.Index = n
for _, t := range oneofWrappers {
if t.Implements(f.Type) {
f := t.Elem().Field(0)
if tag := f.Tag.Get("protobuf"); tag != "" {
aberrantAppendField(md, f.Type, tag, "", "")
fd := &md.L2.Fields.List[len(md.L2.Fields.List)-1]
fd.L1.ContainingOneof = od
fd.L1.EditionFeatures = od.L1.EditionFeatures
od.L1.Fields.List = append(od.L1.Fields.List, fd)
}
}
}
}
}
return md
}
func aberrantDeriveMessageName(t reflect.Type, name protoreflect.FullName) protoreflect.FullName {
if name.IsValid() {
return name
}
func() {
defer func() { recover() }() // swallow possible nil panics
if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
name = protoreflect.FullName(m.XXX_MessageName())
}
}()
if name.IsValid() {
return name
}
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
return AberrantDeriveFullName(t)
}
func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
t := goType
isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
if isOptional || isRepeated {
t = t.Elem()
}
fd := ptag.Unmarshal(tag, t, placeholderEnumValues{}).(*filedesc.Field)
// Append field descriptor to the message.
n := len(md.L2.Fields.List)
md.L2.Fields.List = append(md.L2.Fields.List, *fd)
fd = &md.L2.Fields.List[n]
fd.L0.FullName = md.FullName().Append(fd.Name())
fd.L0.ParentFile = md.L0.ParentFile
fd.L0.Parent = md
fd.L0.Index = n
if fd.L1.EditionFeatures.IsPacked {
fd.L1.Options = func() protoreflect.ProtoMessage {
opts := descopts.Field.ProtoReflect().New()
if fd.L1.EditionFeatures.IsPacked {
opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.EditionFeatures.IsPacked))
}
return opts.Interface()
}
}
// Populate Enum and Message.
if fd.Enum() == nil && fd.Kind() == protoreflect.EnumKind {
switch v := reflect.Zero(t).Interface().(type) {
case protoreflect.Enum:
fd.L1.Enum = v.Descriptor()
default:
fd.L1.Enum = LegacyLoadEnumDesc(t)
}
}
if fd.Message() == nil && (fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind) {
switch v := reflect.Zero(t).Interface().(type) {
case protoreflect.ProtoMessage:
fd.L1.Message = v.ProtoReflect().Descriptor()
case messageV1:
fd.L1.Message = LegacyLoadMessageDesc(t)
default:
if t.Kind() == reflect.Map {
n := len(md.L1.Messages.List)
md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)})
md2 := &md.L1.Messages.List[n]
md2.L0.FullName = md.FullName().Append(protoreflect.Name(strs.MapEntryName(string(fd.Name()))))
md2.L0.ParentFile = md.L0.ParentFile
md2.L0.Parent = md
md2.L0.Index = n
md2.L1.EditionFeatures = md.L1.EditionFeatures
md2.L1.IsMapEntry = true
md2.L2.Options = func() protoreflect.ProtoMessage {
opts := descopts.Message.ProtoReflect().New()
opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
return opts.Interface()
}
aberrantAppendField(md2, t.Key(), tagKey, "", "")
aberrantAppendField(md2, t.Elem(), tagVal, "", "")
fd.L1.Message = md2
break
}
fd.L1.Message = aberrantLoadMessageDescReentrant(t, "")
}
}
}
type placeholderEnumValues struct {
protoreflect.EnumValueDescriptors
}
func (placeholderEnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
return filedesc.PlaceholderEnumValue(protoreflect.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
}
// legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder.
type legacyMarshaler interface {
Marshal() ([]byte, error)
}
// legacyUnmarshaler is the proto.Unmarshaler interface superseded by protoiface.Methoder.
type legacyUnmarshaler interface {
Unmarshal([]byte) error
}
// legacyMerger is the proto.Merger interface superseded by protoiface.Methoder.
type legacyMerger interface {
Merge(protoiface.MessageV1)
}
var aberrantProtoMethods = &protoiface.Methods{
Marshal: legacyMarshal,
Unmarshal: legacyUnmarshal,
Merge: legacyMerge,
// We have no way to tell whether the type's Marshal method
// supports deterministic serialization or not, but this
// preserves the v1 implementation's behavior of always
// calling Marshal methods when present.
Flags: protoiface.SupportMarshalDeterministic,
}
func legacyMarshal(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
v := in.Message.(unwrapper).protoUnwrap()
marshaler, ok := v.(legacyMarshaler)
if !ok {
return protoiface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
}
out, err := marshaler.Marshal()
if in.Buf != nil {
out = append(in.Buf, out...)
}
return protoiface.MarshalOutput{
Buf: out,
}, err
}
func legacyUnmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
v := in.Message.(unwrapper).protoUnwrap()
unmarshaler, ok := v.(legacyUnmarshaler)
if !ok {
return protoiface.UnmarshalOutput{}, errors.New("%T does not implement Unmarshal", v)
}
return protoiface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
}
func legacyMerge(in protoiface.MergeInput) protoiface.MergeOutput {
// Check whether this supports the legacy merger.
dstv := in.Destination.(unwrapper).protoUnwrap()
merger, ok := dstv.(legacyMerger)
if ok {
merger.Merge(Export{}.ProtoMessageV1Of(in.Source))
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
// If legacy merger is unavailable, implement merge in terms of
// a marshal and unmarshal operation.
srcv := in.Source.(unwrapper).protoUnwrap()
marshaler, ok := srcv.(legacyMarshaler)
if !ok {
return protoiface.MergeOutput{}
}
dstv = in.Destination.(unwrapper).protoUnwrap()
unmarshaler, ok := dstv.(legacyUnmarshaler)
if !ok {
return protoiface.MergeOutput{}
}
if !in.Source.IsValid() {
// Legacy Marshal methods may not function on nil messages.
// Check for a typed nil source only after we confirm that
// legacy Marshal/Unmarshal methods are present, for
// consistency.
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
b, err := marshaler.Marshal()
if err != nil {
return protoiface.MergeOutput{}
}
err = unmarshaler.Unmarshal(b)
if err != nil {
return protoiface.MergeOutput{}
}
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
// aberrantMessageType implements MessageType for all types other than pointer-to-struct.
type aberrantMessageType struct {
t reflect.Type
}
func (mt aberrantMessageType) New() protoreflect.Message {
if mt.t.Kind() == reflect.Ptr {
return aberrantMessage{reflect.New(mt.t.Elem())}
}
return aberrantMessage{reflect.Zero(mt.t)}
}
func (mt aberrantMessageType) Zero() protoreflect.Message {
return aberrantMessage{reflect.Zero(mt.t)}
}
func (mt aberrantMessageType) GoType() reflect.Type {
return mt.t
}
func (mt aberrantMessageType) Descriptor() protoreflect.MessageDescriptor {
return LegacyLoadMessageDesc(mt.t)
}
// aberrantMessage implements Message for all types other than pointer-to-struct.
//
// When the underlying type implements legacyMarshaler or legacyUnmarshaler,
// the aberrant Message can be marshaled or unmarshaled. Otherwise, there is
// not much that can be done with values of this type.
type aberrantMessage struct {
v reflect.Value
}
// Reset implements the v1 proto.Message.Reset method.
func (m aberrantMessage) Reset() {
if mr, ok := m.v.Interface().(interface{ Reset() }); ok {
mr.Reset()
return
}
if m.v.Kind() == reflect.Ptr && !m.v.IsNil() {
m.v.Elem().Set(reflect.Zero(m.v.Type().Elem()))
}
}
func (m aberrantMessage) ProtoReflect() protoreflect.Message {
return m
}
func (m aberrantMessage) Descriptor() protoreflect.MessageDescriptor {
return LegacyLoadMessageDesc(m.v.Type())
}
func (m aberrantMessage) Type() protoreflect.MessageType {
return aberrantMessageType{m.v.Type()}
}
func (m aberrantMessage) New() protoreflect.Message {
if m.v.Type().Kind() == reflect.Ptr {
return aberrantMessage{reflect.New(m.v.Type().Elem())}
}
return aberrantMessage{reflect.Zero(m.v.Type())}
}
func (m aberrantMessage) Interface() protoreflect.ProtoMessage {
return m
}
func (m aberrantMessage) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
return
}
func (m aberrantMessage) Has(protoreflect.FieldDescriptor) bool {
return false
}
func (m aberrantMessage) Clear(protoreflect.FieldDescriptor) {
panic("invalid Message.Clear on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
if fd.Default().IsValid() {
return fd.Default()
}
panic("invalid Message.Get on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) Set(protoreflect.FieldDescriptor, protoreflect.Value) {
panic("invalid Message.Set on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) Mutable(protoreflect.FieldDescriptor) protoreflect.Value {
panic("invalid Message.Mutable on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) NewField(protoreflect.FieldDescriptor) protoreflect.Value {
panic("invalid Message.NewField on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) WhichOneof(protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
panic("invalid Message.WhichOneof descriptor on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) GetUnknown() protoreflect.RawFields {
return nil
}
func (m aberrantMessage) SetUnknown(protoreflect.RawFields) {
// SetUnknown discards its input on messages which don't support unknown field storage.
}
func (m aberrantMessage) IsValid() bool {
if m.v.Kind() == reflect.Ptr {
return !m.v.IsNil()
}
return false
}
func (m aberrantMessage) ProtoMethods() *protoiface.Methods {
return aberrantProtoMethods
}
func (m aberrantMessage) protoUnwrap() any {
return m.v.Interface()
}
// Copyright 2020 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
type mergeOptions struct{}
func (o mergeOptions) Merge(dst, src proto.Message) {
proto.Merge(dst, src)
}
// merge is protoreflect.Methods.Merge.
func (mi *MessageInfo) merge(in protoiface.MergeInput) protoiface.MergeOutput {
dp, ok := mi.getPointer(in.Destination)
if !ok {
return protoiface.MergeOutput{}
}
sp, ok := mi.getPointer(in.Source)
if !ok {
return protoiface.MergeOutput{}
}
mi.mergePointer(dp, sp, mergeOptions{})
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
mi.init()
if dst.IsNil() {
panic(fmt.Sprintf("invalid value: merging into nil message"))
}
if src.IsNil() {
return
}
var presenceSrc presence
var presenceDst presence
if mi.presenceOffset.IsValid() {
presenceSrc = src.Apply(mi.presenceOffset).PresenceInfo()
presenceDst = dst.Apply(mi.presenceOffset).PresenceInfo()
}
for _, f := range mi.orderedCoderFields {
if f.funcs.merge == nil {
continue
}
sfptr := src.Apply(f.offset)
if f.presenceIndex != noPresence {
if !presenceSrc.Present(f.presenceIndex) {
continue
}
dfptr := dst.Apply(f.offset)
if f.isLazy {
if sfptr.AtomicGetPointer().IsNil() {
mi.lazyUnmarshal(src, f.num)
}
if presenceDst.Present(f.presenceIndex) && dfptr.AtomicGetPointer().IsNil() {
mi.lazyUnmarshal(dst, f.num)
}
}
f.funcs.merge(dst.Apply(f.offset), sfptr, f, opts)
presenceDst.SetPresentUnatomic(f.presenceIndex, mi.presenceSize)
continue
}
if f.isPointer && sfptr.Elem().IsNil() {
continue
}
f.funcs.merge(dst.Apply(f.offset), sfptr, f, opts)
}
if mi.extensionOffset.IsValid() {
sext := src.Apply(mi.extensionOffset).Extensions()
dext := dst.Apply(mi.extensionOffset).Extensions()
if *dext == nil {
*dext = make(map[int32]ExtensionField)
}
for num, sx := range *sext {
xt := sx.Type()
xi := getExtensionFieldInfo(xt)
if xi.funcs.merge == nil {
continue
}
dx := (*dext)[num]
var dv protoreflect.Value
if dx.Type() == sx.Type() {
dv = dx.Value()
}
if !dv.IsValid() && xi.unmarshalNeedsValue {
dv = xt.New()
}
dv = xi.funcs.merge(dv, sx.Value(), opts)
dx.Set(sx.Type(), dv)
(*dext)[num] = dx
}
}
if mi.unknownOffset.IsValid() {
su := mi.getUnknownBytes(src)
if su != nil && len(*su) > 0 {
du := mi.mutableUnknownBytes(dst)
*du = append(*du, *su...)
}
}
}
func mergeScalarValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
return src
}
func mergeBytesValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
return protoreflect.ValueOfBytes(append(emptyBuf[:], src.Bytes()...))
}
func mergeListValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
dstl := dst.List()
srcl := src.List()
for i, llen := 0, srcl.Len(); i < llen; i++ {
dstl.Append(srcl.Get(i))
}
return dst
}
func mergeBytesListValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
dstl := dst.List()
srcl := src.List()
for i, llen := 0, srcl.Len(); i < llen; i++ {
sb := srcl.Get(i).Bytes()
db := append(emptyBuf[:], sb...)
dstl.Append(protoreflect.ValueOfBytes(db))
}
return dst
}
func mergeMessageListValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
dstl := dst.List()
srcl := src.List()
for i, llen := 0, srcl.Len(); i < llen; i++ {
sm := srcl.Get(i).Message()
dm := proto.Clone(sm.Interface()).ProtoReflect()
dstl.Append(protoreflect.ValueOfMessage(dm))
}
return dst
}
func mergeMessageValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
opts.Merge(dst.Message().Interface(), src.Message().Interface())
return dst
}
func mergeMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
if f.mi != nil {
if dst.Elem().IsNil() {
dst.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
}
f.mi.mergePointer(dst.Elem(), src.Elem(), opts)
} else {
dm := dst.AsValueOf(f.ft).Elem()
sm := src.AsValueOf(f.ft).Elem()
if dm.IsNil() {
dm.Set(reflect.New(f.ft.Elem()))
}
opts.Merge(asMessage(dm), asMessage(sm))
}
}
func mergeMessageSlice(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
for _, sp := range src.PointerSlice() {
dm := reflect.New(f.ft.Elem().Elem())
if f.mi != nil {
f.mi.mergePointer(pointerOfValue(dm), sp, opts)
} else {
opts.Merge(asMessage(dm), asMessage(sp.AsValueOf(f.ft.Elem().Elem())))
}
dst.AppendPointerSlice(pointerOfValue(dm))
}
}
func mergeBytes(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Bytes() = append(emptyBuf[:], *src.Bytes()...)
}
func mergeBytesNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Bytes()
if len(v) > 0 {
*dst.Bytes() = append(emptyBuf[:], v...)
}
}
func mergeBytesSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.BytesSlice()
for _, v := range *src.BytesSlice() {
*ds = append(*ds, append(emptyBuf[:], v...))
}
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package impl
import ()
func mergeBool(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Bool() = *src.Bool()
}
func mergeBoolNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Bool()
if v != false {
*dst.Bool() = v
}
}
func mergeBoolPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.BoolPtr()
if p != nil {
v := *p
*dst.BoolPtr() = &v
}
}
func mergeBoolSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.BoolSlice()
ss := src.BoolSlice()
*ds = append(*ds, *ss...)
}
func mergeInt32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Int32() = *src.Int32()
}
func mergeInt32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Int32()
if v != 0 {
*dst.Int32() = v
}
}
func mergeInt32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.Int32Ptr()
if p != nil {
v := *p
*dst.Int32Ptr() = &v
}
}
func mergeInt32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.Int32Slice()
ss := src.Int32Slice()
*ds = append(*ds, *ss...)
}
func mergeUint32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Uint32() = *src.Uint32()
}
func mergeUint32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Uint32()
if v != 0 {
*dst.Uint32() = v
}
}
func mergeUint32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.Uint32Ptr()
if p != nil {
v := *p
*dst.Uint32Ptr() = &v
}
}
func mergeUint32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.Uint32Slice()
ss := src.Uint32Slice()
*ds = append(*ds, *ss...)
}
func mergeInt64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Int64() = *src.Int64()
}
func mergeInt64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Int64()
if v != 0 {
*dst.Int64() = v
}
}
func mergeInt64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.Int64Ptr()
if p != nil {
v := *p
*dst.Int64Ptr() = &v
}
}
func mergeInt64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.Int64Slice()
ss := src.Int64Slice()
*ds = append(*ds, *ss...)
}
func mergeUint64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Uint64() = *src.Uint64()
}
func mergeUint64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Uint64()
if v != 0 {
*dst.Uint64() = v
}
}
func mergeUint64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.Uint64Ptr()
if p != nil {
v := *p
*dst.Uint64Ptr() = &v
}
}
func mergeUint64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.Uint64Slice()
ss := src.Uint64Slice()
*ds = append(*ds, *ss...)
}
func mergeFloat32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Float32() = *src.Float32()
}
func mergeFloat32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Float32()
if v != 0 {
*dst.Float32() = v
}
}
func mergeFloat32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.Float32Ptr()
if p != nil {
v := *p
*dst.Float32Ptr() = &v
}
}
func mergeFloat32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.Float32Slice()
ss := src.Float32Slice()
*ds = append(*ds, *ss...)
}
func mergeFloat64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.Float64() = *src.Float64()
}
func mergeFloat64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.Float64()
if v != 0 {
*dst.Float64() = v
}
}
func mergeFloat64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.Float64Ptr()
if p != nil {
v := *p
*dst.Float64Ptr() = &v
}
}
func mergeFloat64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.Float64Slice()
ss := src.Float64Slice()
*ds = append(*ds, *ss...)
}
func mergeString(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
*dst.String() = *src.String()
}
func mergeStringNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
v := *src.String()
if v != "" {
*dst.String() = v
}
}
func mergeStringPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
p := *src.StringPtr()
if p != nil {
v := *p
*dst.StringPtr() = &v
}
}
func mergeStringSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
ds := dst.StringSlice()
ss := src.StringSlice()
*ds = append(*ds, *ss...)
}
// Copyright 2018 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 impl
import (
"fmt"
"reflect"
"strconv"
"strings"
"sync"
"sync/atomic"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect"
)
// MessageInfo provides protobuf related functionality for a given Go type
// that represents a message. A given instance of MessageInfo is tied to
// exactly one Go type, which must be a pointer to a struct type.
//
// The exported fields must be populated before any methods are called
// and cannot be mutated after set.
type MessageInfo struct {
// GoReflectType is the underlying message Go type and must be populated.
GoReflectType reflect.Type // pointer to struct
// Desc is the underlying message descriptor type and must be populated.
Desc protoreflect.MessageDescriptor
// Deprecated: Exporter will be removed the next time we bump
// protoimpl.GenVersion. See https://github.com/golang/protobuf/issues/1640
Exporter exporter
// OneofWrappers is list of pointers to oneof wrapper struct types.
OneofWrappers []any
initMu sync.Mutex // protects all unexported fields
initDone uint32
reflectMessageInfo // for reflection implementation
coderMessageInfo // for fast-path method implementations
}
// exporter is a function that returns a reference to the ith field of v,
// where v is a pointer to a struct. It returns nil if it does not support
// exporting the requested field (e.g., already exported).
type exporter func(v any, i int) any
// getMessageInfo returns the MessageInfo for any message type that
// is generated by our implementation of protoc-gen-go (for v2 and on).
// If it is unable to obtain a MessageInfo, it returns nil.
func getMessageInfo(mt reflect.Type) *MessageInfo {
m, ok := reflect.Zero(mt).Interface().(protoreflect.ProtoMessage)
if !ok {
return nil
}
mr, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *MessageInfo })
if !ok {
return nil
}
return mr.ProtoMessageInfo()
}
func (mi *MessageInfo) init() {
// This function is called in the hot path. Inline the sync.Once logic,
// since allocating a closure for Once.Do is expensive.
// Keep init small to ensure that it can be inlined.
if atomic.LoadUint32(&mi.initDone) == 0 {
mi.initOnce()
}
}
func (mi *MessageInfo) initOnce() {
mi.initMu.Lock()
defer mi.initMu.Unlock()
if mi.initDone == 1 {
return
}
if opaqueInitHook(mi) {
return
}
t := mi.GoReflectType
if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
panic(fmt.Sprintf("got %v, want *struct kind", t))
}
t = t.Elem()
si := mi.makeStructInfo(t)
mi.makeReflectFuncs(t, si)
mi.makeCoderMethods(t, si)
atomic.StoreUint32(&mi.initDone, 1)
}
// getPointer returns the pointer for a message, which should be of
// the type of the MessageInfo. If the message is of a different type,
// it returns ok==false.
func (mi *MessageInfo) getPointer(m protoreflect.Message) (p pointer, ok bool) {
switch m := m.(type) {
case *messageState:
return m.pointer(), m.messageInfo() == mi
case *messageReflectWrapper:
return m.pointer(), m.messageInfo() == mi
}
return pointer{}, false
}
type (
SizeCache = int32
WeakFields = map[int32]protoreflect.ProtoMessage
UnknownFields = unknownFieldsA // TODO: switch to unknownFieldsB
unknownFieldsA = []byte
unknownFieldsB = *[]byte
ExtensionFields = map[int32]ExtensionField
)
var (
sizecacheType = reflect.TypeOf(SizeCache(0))
unknownFieldsAType = reflect.TypeOf(unknownFieldsA(nil))
unknownFieldsBType = reflect.TypeOf(unknownFieldsB(nil))
extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
)
type structInfo struct {
sizecacheOffset offset
sizecacheType reflect.Type
unknownOffset offset
unknownType reflect.Type
extensionOffset offset
extensionType reflect.Type
lazyOffset offset
presenceOffset offset
fieldsByNumber map[protoreflect.FieldNumber]reflect.StructField
oneofsByName map[protoreflect.Name]reflect.StructField
oneofWrappersByType map[reflect.Type]protoreflect.FieldNumber
oneofWrappersByNumber map[protoreflect.FieldNumber]reflect.Type
}
func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
si := structInfo{
sizecacheOffset: invalidOffset,
unknownOffset: invalidOffset,
extensionOffset: invalidOffset,
lazyOffset: invalidOffset,
presenceOffset: invalidOffset,
fieldsByNumber: map[protoreflect.FieldNumber]reflect.StructField{},
oneofsByName: map[protoreflect.Name]reflect.StructField{},
oneofWrappersByType: map[reflect.Type]protoreflect.FieldNumber{},
oneofWrappersByNumber: map[protoreflect.FieldNumber]reflect.Type{},
}
fieldLoop:
for i := 0; i < t.NumField(); i++ {
switch f := t.Field(i); f.Name {
case genid.SizeCache_goname, genid.SizeCacheA_goname:
if f.Type == sizecacheType {
si.sizecacheOffset = offsetOf(f)
si.sizecacheType = f.Type
}
case genid.UnknownFields_goname, genid.UnknownFieldsA_goname:
if f.Type == unknownFieldsAType || f.Type == unknownFieldsBType {
si.unknownOffset = offsetOf(f)
si.unknownType = f.Type
}
case genid.ExtensionFields_goname, genid.ExtensionFieldsA_goname, genid.ExtensionFieldsB_goname:
if f.Type == extensionFieldsType {
si.extensionOffset = offsetOf(f)
si.extensionType = f.Type
}
case "lazyFields", "XXX_lazyUnmarshalInfo":
si.lazyOffset = offsetOf(f)
case "XXX_presence":
si.presenceOffset = offsetOf(f)
default:
for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
n, _ := strconv.ParseUint(s, 10, 64)
si.fieldsByNumber[protoreflect.FieldNumber(n)] = f
continue fieldLoop
}
}
if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
si.oneofsByName[protoreflect.Name(s)] = f
continue fieldLoop
}
}
}
// Derive a mapping of oneof wrappers to fields.
oneofWrappers := mi.OneofWrappers
methods := make([]reflect.Method, 0, 2)
if m, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
methods = append(methods, m)
}
if m, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
methods = append(methods, m)
}
for _, fn := range methods {
for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
if vs, ok := v.Interface().([]any); ok {
oneofWrappers = vs
}
}
}
for _, v := range oneofWrappers {
tf := reflect.TypeOf(v).Elem()
f := tf.Field(0)
for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
n, _ := strconv.ParseUint(s, 10, 64)
si.oneofWrappersByType[tf] = protoreflect.FieldNumber(n)
si.oneofWrappersByNumber[protoreflect.FieldNumber(n)] = tf
break
}
}
}
return si
}
func (mi *MessageInfo) New() protoreflect.Message {
m := reflect.New(mi.GoReflectType.Elem()).Interface()
if r, ok := m.(protoreflect.ProtoMessage); ok {
return r.ProtoReflect()
}
return mi.MessageOf(m)
}
func (mi *MessageInfo) Zero() protoreflect.Message {
return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
}
func (mi *MessageInfo) Descriptor() protoreflect.MessageDescriptor {
return mi.Desc
}
func (mi *MessageInfo) Enum(i int) protoreflect.EnumType {
mi.init()
fd := mi.Desc.Fields().Get(i)
return Export{}.EnumTypeOf(mi.fieldTypes[fd.Number()])
}
func (mi *MessageInfo) Message(i int) protoreflect.MessageType {
mi.init()
fd := mi.Desc.Fields().Get(i)
switch {
case fd.IsMap():
return mapEntryType{fd.Message(), mi.fieldTypes[fd.Number()]}
default:
return Export{}.MessageTypeOf(mi.fieldTypes[fd.Number()])
}
}
type mapEntryType struct {
desc protoreflect.MessageDescriptor
valType any // zero value of enum or message type
}
func (mt mapEntryType) New() protoreflect.Message {
return nil
}
func (mt mapEntryType) Zero() protoreflect.Message {
return nil
}
func (mt mapEntryType) Descriptor() protoreflect.MessageDescriptor {
return mt.desc
}
func (mt mapEntryType) Enum(i int) protoreflect.EnumType {
fd := mt.desc.Fields().Get(i)
if fd.Enum() == nil {
return nil
}
return Export{}.EnumTypeOf(mt.valType)
}
func (mt mapEntryType) Message(i int) protoreflect.MessageType {
fd := mt.desc.Fields().Get(i)
if fd.Message() == nil {
return nil
}
return Export{}.MessageTypeOf(mt.valType)
}
// Copyright 2024 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 impl
import (
"fmt"
"math"
"reflect"
"strings"
"sync/atomic"
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/reflect/protoreflect"
)
type opaqueStructInfo struct {
structInfo
}
// isOpaque determines whether a protobuf message type is on the Opaque API. It
// checks whether the type is a Go struct that protoc-gen-go would generate.
//
// This function only detects newly generated messages from the v2
// implementation of protoc-gen-go. It is unable to classify generated messages
// that are too old or those that are generated by a different generator
// such as protoc-gen-gogo.
func isOpaque(t reflect.Type) bool {
// The current detection mechanism is to simply check the first field
// for a struct tag with the "protogen" key.
if t.Kind() == reflect.Struct && t.NumField() > 0 {
pgt := t.Field(0).Tag.Get("protogen")
return strings.HasPrefix(pgt, "opaque.")
}
return false
}
func opaqueInitHook(mi *MessageInfo) bool {
mt := mi.GoReflectType.Elem()
si := opaqueStructInfo{
structInfo: mi.makeStructInfo(mt),
}
if !isOpaque(mt) {
return false
}
defer atomic.StoreUint32(&mi.initDone, 1)
mi.fields = map[protoreflect.FieldNumber]*fieldInfo{}
fds := mi.Desc.Fields()
for i := 0; i < fds.Len(); i++ {
fd := fds.Get(i)
fs := si.fieldsByNumber[fd.Number()]
var fi fieldInfo
usePresence, _ := filedesc.UsePresenceForField(fd)
switch {
case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
// Oneofs are no different for opaque.
fi = fieldInfoForOneof(fd, si.oneofsByName[fd.ContainingOneof().Name()], mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
case fd.IsMap():
fi = mi.fieldInfoForMapOpaque(si, fd, fs)
case fd.IsList() && fd.Message() == nil && usePresence:
fi = mi.fieldInfoForScalarListOpaque(si, fd, fs)
case fd.IsList() && fd.Message() == nil:
// Proto3 lists without presence can use same access methods as open
fi = fieldInfoForList(fd, fs, mi.Exporter)
case fd.IsList() && usePresence:
fi = mi.fieldInfoForMessageListOpaque(si, fd, fs)
case fd.IsList():
// Proto3 opaque messages that does not need presence bitmap.
// Different representation than open struct, but same logic
fi = mi.fieldInfoForMessageListOpaqueNoPresence(si, fd, fs)
case fd.Message() != nil && usePresence:
fi = mi.fieldInfoForMessageOpaque(si, fd, fs)
case fd.Message() != nil:
// Proto3 messages without presence can use same access methods as open
fi = fieldInfoForMessage(fd, fs, mi.Exporter)
default:
fi = mi.fieldInfoForScalarOpaque(si, fd, fs)
}
mi.fields[fd.Number()] = &fi
}
mi.oneofs = map[protoreflect.Name]*oneofInfo{}
for i := 0; i < mi.Desc.Oneofs().Len(); i++ {
od := mi.Desc.Oneofs().Get(i)
mi.oneofs[od.Name()] = makeOneofInfoOpaque(mi, od, si.structInfo, mi.Exporter)
}
mi.denseFields = make([]*fieldInfo, fds.Len()*2)
for i := 0; i < fds.Len(); i++ {
if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {
mi.denseFields[fd.Number()] = mi.fields[fd.Number()]
}
}
for i := 0; i < fds.Len(); {
fd := fds.Get(i)
if od := fd.ContainingOneof(); od != nil && !fd.ContainingOneof().IsSynthetic() {
mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])
i += od.Fields().Len()
} else {
mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])
i++
}
}
mi.makeExtensionFieldsFunc(mt, si.structInfo)
mi.makeUnknownFieldsFunc(mt, si.structInfo)
mi.makeOpaqueCoderMethods(mt, si)
mi.makeFieldTypes(si.structInfo)
return true
}
func makeOneofInfoOpaque(mi *MessageInfo, od protoreflect.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
oi := &oneofInfo{oneofDesc: od}
if od.IsSynthetic() {
fd := od.Fields().Get(0)
index, _ := presenceIndex(mi.Desc, fd)
oi.which = func(p pointer) protoreflect.FieldNumber {
if p.IsNil() {
return 0
}
if !mi.present(p, index) {
return 0
}
return od.Fields().Get(0).Number()
}
return oi
}
// Dispatch to non-opaque oneof implementation for non-synthetic oneofs.
return makeOneofInfo(od, si, x)
}
func (mi *MessageInfo) fieldInfoForMapOpaque(si opaqueStructInfo, fd protoreflect.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Map {
panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
}
fieldOffset := offsetOf(fs)
conv := NewConverter(ft, fd)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
// Don't bother checking presence bits, since we need to
// look at the map length even if the presence bit is set.
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return rv.Len() > 0
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.Len() == 0 {
return conv.Zero()
}
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
pv := conv.GoValueOf(v)
if pv.IsNil() {
panic(fmt.Sprintf("invalid value: setting map field to read-only value"))
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(pv)
},
mutable: func(p pointer) protoreflect.Value {
v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if v.IsNil() {
v.Set(reflect.MakeMap(fs.Type))
}
return conv.PBValueOf(v)
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func (mi *MessageInfo) fieldInfoForScalarListOpaque(si opaqueStructInfo, fd protoreflect.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
}
conv := NewConverter(reflect.PtrTo(ft), fd)
fieldOffset := offsetOf(fs)
index, _ := presenceIndex(mi.Desc, fd)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return rv.Len() > 0
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
if rv.Elem().Len() == 0 {
return conv.Zero()
}
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
pv := conv.GoValueOf(v)
if pv.IsNil() {
panic(fmt.Sprintf("invalid value: setting repeated field to read-only value"))
}
mi.setPresent(p, index)
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(pv.Elem())
},
mutable: func(p pointer) protoreflect.Value {
mi.setPresent(p, index)
return conv.PBValueOf(p.Apply(fieldOffset).AsValueOf(fs.Type))
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func (mi *MessageInfo) fieldInfoForMessageListOpaque(si opaqueStructInfo, fd protoreflect.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Ptr || ft.Elem().Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
}
conv := NewConverter(ft, fd)
fieldOffset := offsetOf(fs)
index, _ := presenceIndex(mi.Desc, fd)
fieldNumber := fd.Number()
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
if !mi.present(p, index) {
return false
}
sp := p.Apply(fieldOffset).AtomicGetPointer()
if sp.IsNil() {
// Lazily unmarshal this field.
mi.lazyUnmarshal(p, fieldNumber)
sp = p.Apply(fieldOffset).AtomicGetPointer()
}
rv := sp.AsValueOf(fs.Type.Elem())
return rv.Elem().Len() > 0
},
clear: func(p pointer) {
fp := p.Apply(fieldOffset)
sp := fp.AtomicGetPointer()
if sp.IsNil() {
sp = fp.AtomicSetPointerIfNil(pointerOfValue(reflect.New(fs.Type.Elem())))
mi.setPresent(p, index)
}
rv := sp.AsValueOf(fs.Type.Elem())
rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
if !mi.present(p, index) {
return conv.Zero()
}
sp := p.Apply(fieldOffset).AtomicGetPointer()
if sp.IsNil() {
// Lazily unmarshal this field.
mi.lazyUnmarshal(p, fieldNumber)
sp = p.Apply(fieldOffset).AtomicGetPointer()
}
rv := sp.AsValueOf(fs.Type.Elem())
if rv.Elem().Len() == 0 {
return conv.Zero()
}
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
fp := p.Apply(fieldOffset)
sp := fp.AtomicGetPointer()
if sp.IsNil() {
sp = fp.AtomicSetPointerIfNil(pointerOfValue(reflect.New(fs.Type.Elem())))
mi.setPresent(p, index)
}
rv := sp.AsValueOf(fs.Type.Elem())
val := conv.GoValueOf(v)
if val.IsNil() {
panic(fmt.Sprintf("invalid value: setting repeated field to read-only value"))
} else {
rv.Elem().Set(val.Elem())
}
},
mutable: func(p pointer) protoreflect.Value {
fp := p.Apply(fieldOffset)
sp := fp.AtomicGetPointer()
if sp.IsNil() {
if mi.present(p, index) {
// Lazily unmarshal this field.
mi.lazyUnmarshal(p, fieldNumber)
sp = p.Apply(fieldOffset).AtomicGetPointer()
} else {
sp = fp.AtomicSetPointerIfNil(pointerOfValue(reflect.New(fs.Type.Elem())))
mi.setPresent(p, index)
}
}
rv := sp.AsValueOf(fs.Type.Elem())
return conv.PBValueOf(rv)
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func (mi *MessageInfo) fieldInfoForMessageListOpaqueNoPresence(si opaqueStructInfo, fd protoreflect.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Ptr || ft.Elem().Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
}
conv := NewConverter(ft, fd)
fieldOffset := offsetOf(fs)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() {
return false
}
return rv.Elem().Len() > 0
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if !rv.IsNil() {
rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
}
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() {
return conv.Zero()
}
if rv.Elem().Len() == 0 {
return conv.Zero()
}
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() {
rv.Set(reflect.New(fs.Type.Elem()))
}
val := conv.GoValueOf(v)
if val.IsNil() {
panic(fmt.Sprintf("invalid value: setting repeated field to read-only value"))
} else {
rv.Elem().Set(val.Elem())
}
},
mutable: func(p pointer) protoreflect.Value {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() {
rv.Set(reflect.New(fs.Type.Elem()))
}
return conv.PBValueOf(rv)
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func (mi *MessageInfo) fieldInfoForScalarOpaque(si opaqueStructInfo, fd protoreflect.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
nullable := fd.HasPresence()
if oneof := fd.ContainingOneof(); oneof != nil && oneof.IsSynthetic() {
nullable = true
}
deref := false
if nullable && ft.Kind() == reflect.Ptr {
ft = ft.Elem()
deref = true
}
conv := NewConverter(ft, fd)
fieldOffset := offsetOf(fs)
index, _ := presenceIndex(mi.Desc, fd)
var getter func(p pointer) protoreflect.Value
if !nullable {
getter = getterForDirectScalar(fd, fs, conv, fieldOffset)
} else {
getter = getterForOpaqueNullableScalar(mi, index, fd, fs, conv, fieldOffset)
}
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
if nullable {
return mi.present(p, index)
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
switch rv.Kind() {
case reflect.Bool:
return rv.Bool()
case reflect.Int32, reflect.Int64:
return rv.Int() != 0
case reflect.Uint32, reflect.Uint64:
return rv.Uint() != 0
case reflect.Float32, reflect.Float64:
return rv.Float() != 0 || math.Signbit(rv.Float())
case reflect.String, reflect.Slice:
return rv.Len() > 0
default:
panic(fmt.Sprintf("invalid type: %v", rv.Type())) // should never happen
}
},
clear: func(p pointer) {
if nullable {
mi.clearPresent(p, index)
}
// This is only valuable for bytes and strings, but we do it unconditionally.
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: getter,
// TODO: Implement unsafe fast path for set?
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if deref {
if rv.IsNil() {
rv.Set(reflect.New(ft))
}
rv = rv.Elem()
}
rv.Set(conv.GoValueOf(v))
if nullable && rv.Kind() == reflect.Slice && rv.IsNil() {
rv.Set(emptyBytes)
}
if nullable {
mi.setPresent(p, index)
}
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func (mi *MessageInfo) fieldInfoForMessageOpaque(si opaqueStructInfo, fd protoreflect.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
conv := NewConverter(ft, fd)
fieldOffset := offsetOf(fs)
index, _ := presenceIndex(mi.Desc, fd)
fieldNumber := fd.Number()
elemType := fs.Type.Elem()
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
return mi.present(p, index)
},
clear: func(p pointer) {
mi.clearPresent(p, index)
p.Apply(fieldOffset).AtomicSetNilPointer()
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
fp := p.Apply(fieldOffset)
mp := fp.AtomicGetPointer()
if mp.IsNil() {
// Lazily unmarshal this field.
mi.lazyUnmarshal(p, fieldNumber)
mp = fp.AtomicGetPointer()
}
rv := mp.AsValueOf(elemType)
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
val := pointerOfValue(conv.GoValueOf(v))
if val.IsNil() {
panic("invalid nil pointer")
}
p.Apply(fieldOffset).AtomicSetPointer(val)
mi.setPresent(p, index)
},
mutable: func(p pointer) protoreflect.Value {
fp := p.Apply(fieldOffset)
mp := fp.AtomicGetPointer()
if mp.IsNil() {
if mi.present(p, index) {
// Lazily unmarshal this field.
mi.lazyUnmarshal(p, fieldNumber)
mp = fp.AtomicGetPointer()
} else {
mp = pointerOfValue(conv.GoValueOf(conv.New()))
fp.AtomicSetPointer(mp)
mi.setPresent(p, index)
}
}
return conv.PBValueOf(mp.AsValueOf(fs.Type.Elem()))
},
newMessage: func() protoreflect.Message {
return conv.New().Message()
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
// A presenceList wraps a List, updating presence bits as necessary when the
// list contents change.
type presenceList struct {
pvalueList
setPresence func(bool)
}
type pvalueList interface {
protoreflect.List
//Unwrapper
}
func (list presenceList) Append(v protoreflect.Value) {
list.pvalueList.Append(v)
list.setPresence(true)
}
func (list presenceList) Truncate(i int) {
list.pvalueList.Truncate(i)
list.setPresence(i > 0)
}
// presenceIndex returns the index to pass to presence functions.
//
// TODO: field.Desc.Index() would be simpler, and would give space to record the presence of oneof fields.
func presenceIndex(md protoreflect.MessageDescriptor, fd protoreflect.FieldDescriptor) (uint32, presenceSize) {
found := false
var index, numIndices uint32
for i := 0; i < md.Fields().Len(); i++ {
f := md.Fields().Get(i)
if f == fd {
found = true
index = numIndices
}
if f.ContainingOneof() == nil || isLastOneofField(f) {
numIndices++
}
}
if !found {
panic(fmt.Sprintf("BUG: %v not in %v", fd.Name(), md.FullName()))
}
return index, presenceSize(numIndices)
}
func isLastOneofField(fd protoreflect.FieldDescriptor) bool {
fields := fd.ContainingOneof().Fields()
return fields.Get(fields.Len()-1) == fd
}
func (mi *MessageInfo) setPresent(p pointer, index uint32) {
p.Apply(mi.presenceOffset).PresenceInfo().SetPresent(index, mi.presenceSize)
}
func (mi *MessageInfo) clearPresent(p pointer, index uint32) {
p.Apply(mi.presenceOffset).PresenceInfo().ClearPresent(index)
}
func (mi *MessageInfo) present(p pointer, index uint32) bool {
return p.Apply(mi.presenceOffset).PresenceInfo().Present(index)
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package impl
import (
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
func getterForOpaqueNullableScalar(mi *MessageInfo, index uint32, fd protoreflect.FieldDescriptor, fs reflect.StructField, conv Converter, fieldOffset offset) func(p pointer) protoreflect.Value {
ft := fs.Type
if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
if fd.Kind() == protoreflect.EnumKind {
// Enums for nullable opaque types.
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return conv.PBValueOf(rv)
}
}
switch ft.Kind() {
case reflect.Bool:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bool()
return protoreflect.ValueOfBool(*x)
}
case reflect.Int32:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Int32()
return protoreflect.ValueOfInt32(*x)
}
case reflect.Uint32:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Uint32()
return protoreflect.ValueOfUint32(*x)
}
case reflect.Int64:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Int64()
return protoreflect.ValueOfInt64(*x)
}
case reflect.Uint64:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Uint64()
return protoreflect.ValueOfUint64(*x)
}
case reflect.Float32:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Float32()
return protoreflect.ValueOfFloat32(*x)
}
case reflect.Float64:
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Float64()
return protoreflect.ValueOfFloat64(*x)
}
case reflect.String:
if fd.Kind() == protoreflect.BytesKind {
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).StringPtr()
if *x == nil {
return conv.Zero()
}
if len(**x) == 0 {
return protoreflect.ValueOfBytes(nil)
}
return protoreflect.ValueOfBytes([]byte(**x))
}
}
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).StringPtr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfString(**x)
}
case reflect.Slice:
if fd.Kind() == protoreflect.StringKind {
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bytes()
return protoreflect.ValueOfString(string(*x))
}
}
return func(p pointer) protoreflect.Value {
if p.IsNil() || !mi.present(p, index) {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bytes()
return protoreflect.ValueOfBytes(*x)
}
}
panic("unexpected protobuf kind: " + ft.Kind().String())
}
// 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 impl
import (
"fmt"
"reflect"
"google.golang.org/protobuf/internal/detrand"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
)
type reflectMessageInfo struct {
fields map[protoreflect.FieldNumber]*fieldInfo
oneofs map[protoreflect.Name]*oneofInfo
// fieldTypes contains the zero value of an enum or message field.
// For lists, it contains the element type.
// For maps, it contains the entry value type.
fieldTypes map[protoreflect.FieldNumber]any
// denseFields is a subset of fields where:
// 0 < fieldDesc.Number() < len(denseFields)
// It provides faster access to the fieldInfo, but may be incomplete.
denseFields []*fieldInfo
// rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.
rangeInfos []any // either *fieldInfo or *oneofInfo
getUnknown func(pointer) protoreflect.RawFields
setUnknown func(pointer, protoreflect.RawFields)
extensionMap func(pointer) *extensionMap
nilMessage atomicNilMessage
}
// makeReflectFuncs generates the set of functions to support reflection.
func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
mi.makeKnownFieldsFunc(si)
mi.makeUnknownFieldsFunc(t, si)
mi.makeExtensionFieldsFunc(t, si)
mi.makeFieldTypes(si)
}
// makeKnownFieldsFunc generates functions for operations that can be performed
// on each protobuf message field. It takes in a reflect.Type representing the
// Go struct and matches message fields with struct fields.
//
// This code assumes that the struct is well-formed and panics if there are
// any discrepancies.
func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
mi.fields = map[protoreflect.FieldNumber]*fieldInfo{}
md := mi.Desc
fds := md.Fields()
for i := 0; i < fds.Len(); i++ {
fd := fds.Get(i)
fs := si.fieldsByNumber[fd.Number()]
isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
if isOneof {
fs = si.oneofsByName[fd.ContainingOneof().Name()]
}
var fi fieldInfo
switch {
case fs.Type == nil:
fi = fieldInfoForMissing(fd) // never occurs for officially generated message types
case isOneof:
fi = fieldInfoForOneof(fd, fs, mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
case fd.IsMap():
fi = fieldInfoForMap(fd, fs, mi.Exporter)
case fd.IsList():
fi = fieldInfoForList(fd, fs, mi.Exporter)
case fd.Message() != nil:
fi = fieldInfoForMessage(fd, fs, mi.Exporter)
default:
fi = fieldInfoForScalar(fd, fs, mi.Exporter)
}
mi.fields[fd.Number()] = &fi
}
mi.oneofs = map[protoreflect.Name]*oneofInfo{}
for i := 0; i < md.Oneofs().Len(); i++ {
od := md.Oneofs().Get(i)
mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)
}
mi.denseFields = make([]*fieldInfo, fds.Len()*2)
for i := 0; i < fds.Len(); i++ {
if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {
mi.denseFields[fd.Number()] = mi.fields[fd.Number()]
}
}
for i := 0; i < fds.Len(); {
fd := fds.Get(i)
if od := fd.ContainingOneof(); od != nil && !od.IsSynthetic() {
mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])
i += od.Fields().Len()
} else {
mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])
i++
}
}
// Introduce instability to iteration order, but keep it deterministic.
if len(mi.rangeInfos) > 1 && detrand.Bool() {
i := detrand.Intn(len(mi.rangeInfos) - 1)
mi.rangeInfos[i], mi.rangeInfos[i+1] = mi.rangeInfos[i+1], mi.rangeInfos[i]
}
}
func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
switch {
case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsAType:
// Handle as []byte.
mi.getUnknown = func(p pointer) protoreflect.RawFields {
if p.IsNil() {
return nil
}
return *p.Apply(mi.unknownOffset).Bytes()
}
mi.setUnknown = func(p pointer, b protoreflect.RawFields) {
if p.IsNil() {
panic("invalid SetUnknown on nil Message")
}
*p.Apply(mi.unknownOffset).Bytes() = b
}
case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsBType:
// Handle as *[]byte.
mi.getUnknown = func(p pointer) protoreflect.RawFields {
if p.IsNil() {
return nil
}
bp := p.Apply(mi.unknownOffset).BytesPtr()
if *bp == nil {
return nil
}
return **bp
}
mi.setUnknown = func(p pointer, b protoreflect.RawFields) {
if p.IsNil() {
panic("invalid SetUnknown on nil Message")
}
bp := p.Apply(mi.unknownOffset).BytesPtr()
if *bp == nil {
*bp = new([]byte)
}
**bp = b
}
default:
mi.getUnknown = func(pointer) protoreflect.RawFields {
return nil
}
mi.setUnknown = func(p pointer, _ protoreflect.RawFields) {
if p.IsNil() {
panic("invalid SetUnknown on nil Message")
}
}
}
}
func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
if si.extensionOffset.IsValid() {
mi.extensionMap = func(p pointer) *extensionMap {
if p.IsNil() {
return (*extensionMap)(nil)
}
v := p.Apply(si.extensionOffset).AsValueOf(extensionFieldsType)
return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
}
} else {
mi.extensionMap = func(pointer) *extensionMap {
return (*extensionMap)(nil)
}
}
}
func (mi *MessageInfo) makeFieldTypes(si structInfo) {
md := mi.Desc
fds := md.Fields()
for i := 0; i < fds.Len(); i++ {
var ft reflect.Type
fd := fds.Get(i)
fs := si.fieldsByNumber[fd.Number()]
isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
if isOneof {
fs = si.oneofsByName[fd.ContainingOneof().Name()]
}
var isMessage bool
switch {
case fs.Type == nil:
continue // never occurs for officially generated message types
case isOneof:
if fd.Enum() != nil || fd.Message() != nil {
ft = si.oneofWrappersByNumber[fd.Number()].Field(0).Type
}
case fd.IsMap():
if fd.MapValue().Enum() != nil || fd.MapValue().Message() != nil {
ft = fs.Type.Elem()
}
isMessage = fd.MapValue().Message() != nil
case fd.IsList():
if fd.Enum() != nil || fd.Message() != nil {
ft = fs.Type.Elem()
if ft.Kind() == reflect.Slice {
ft = ft.Elem()
}
}
isMessage = fd.Message() != nil
case fd.Enum() != nil:
ft = fs.Type
if fd.HasPresence() && ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
case fd.Message() != nil:
ft = fs.Type
isMessage = true
}
if isMessage && ft != nil && ft.Kind() != reflect.Ptr {
ft = reflect.PtrTo(ft) // never occurs for officially generated message types
}
if ft != nil {
if mi.fieldTypes == nil {
mi.fieldTypes = make(map[protoreflect.FieldNumber]any)
}
mi.fieldTypes[fd.Number()] = reflect.Zero(ft).Interface()
}
}
}
type extensionMap map[int32]ExtensionField
func (m *extensionMap) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
if m != nil {
for _, x := range *m {
xd := x.Type().TypeDescriptor()
v := x.Value()
if xd.IsList() && v.List().Len() == 0 {
continue
}
if !f(xd, v) {
return
}
}
}
}
func (m *extensionMap) Has(xd protoreflect.ExtensionTypeDescriptor) (ok bool) {
if m == nil {
return false
}
x, ok := (*m)[int32(xd.Number())]
if !ok {
return false
}
if x.isUnexpandedLazy() {
// Avoid calling x.Value(), which triggers a lazy unmarshal.
return true
}
switch {
case xd.IsList():
return x.Value().List().Len() > 0
case xd.IsMap():
return x.Value().Map().Len() > 0
}
return true
}
func (m *extensionMap) Clear(xd protoreflect.ExtensionTypeDescriptor) {
delete(*m, int32(xd.Number()))
}
func (m *extensionMap) Get(xd protoreflect.ExtensionTypeDescriptor) protoreflect.Value {
if m != nil {
if x, ok := (*m)[int32(xd.Number())]; ok {
return x.Value()
}
}
return xd.Type().Zero()
}
func (m *extensionMap) Set(xd protoreflect.ExtensionTypeDescriptor, v protoreflect.Value) {
xt := xd.Type()
isValid := true
switch {
case !xt.IsValidValue(v):
isValid = false
case xd.IsList():
isValid = v.List().IsValid()
case xd.IsMap():
isValid = v.Map().IsValid()
case xd.Message() != nil:
isValid = v.Message().IsValid()
}
if !isValid {
panic(fmt.Sprintf("%v: assigning invalid value", xd.FullName()))
}
if *m == nil {
*m = make(map[int32]ExtensionField)
}
var x ExtensionField
x.Set(xt, v)
(*m)[int32(xd.Number())] = x
}
func (m *extensionMap) Mutable(xd protoreflect.ExtensionTypeDescriptor) protoreflect.Value {
if xd.Kind() != protoreflect.MessageKind && xd.Kind() != protoreflect.GroupKind && !xd.IsList() && !xd.IsMap() {
panic("invalid Mutable on field with non-composite type")
}
if x, ok := (*m)[int32(xd.Number())]; ok {
return x.Value()
}
v := xd.Type().New()
m.Set(xd, v)
return v
}
// MessageState is a data structure that is nested as the first field in a
// concrete message. It provides a way to implement the ProtoReflect method
// in an allocation-free way without needing to have a shadow Go type generated
// for every message type. This technique only works using unsafe.
//
// Example generated code:
//
// type M struct {
// state protoimpl.MessageState
//
// Field1 int32
// Field2 string
// Field3 *BarMessage
// ...
// }
//
// func (m *M) ProtoReflect() protoreflect.Message {
// mi := &file_fizz_buzz_proto_msgInfos[5]
// if protoimpl.UnsafeEnabled && m != nil {
// ms := protoimpl.X.MessageStateOf(Pointer(m))
// if ms.LoadMessageInfo() == nil {
// ms.StoreMessageInfo(mi)
// }
// return ms
// }
// return mi.MessageOf(m)
// }
//
// The MessageState type holds a *MessageInfo, which must be atomically set to
// the message info associated with a given message instance.
// By unsafely converting a *M into a *MessageState, the MessageState object
// has access to all the information needed to implement protobuf reflection.
// It has access to the message info as its first field, and a pointer to the
// MessageState is identical to a pointer to the concrete message value.
//
// Requirements:
// - The type M must implement protoreflect.ProtoMessage.
// - The address of m must not be nil.
// - The address of m and the address of m.state must be equal,
// even though they are different Go types.
type MessageState struct {
pragma.NoUnkeyedLiterals
pragma.DoNotCompare
pragma.DoNotCopy
atomicMessageInfo *MessageInfo
}
type messageState MessageState
var (
_ protoreflect.Message = (*messageState)(nil)
_ unwrapper = (*messageState)(nil)
)
// messageDataType is a tuple of a pointer to the message data and
// a pointer to the message type. It is a generalized way of providing a
// reflective view over a message instance. The disadvantage of this approach
// is the need to allocate this tuple of 16B.
type messageDataType struct {
p pointer
mi *MessageInfo
}
type (
messageReflectWrapper messageDataType
messageIfaceWrapper messageDataType
)
var (
_ protoreflect.Message = (*messageReflectWrapper)(nil)
_ unwrapper = (*messageReflectWrapper)(nil)
_ protoreflect.ProtoMessage = (*messageIfaceWrapper)(nil)
_ unwrapper = (*messageIfaceWrapper)(nil)
)
// MessageOf returns a reflective view over a message. The input must be a
// pointer to a named Go struct. If the provided type has a ProtoReflect method,
// it must be implemented by calling this method.
func (mi *MessageInfo) MessageOf(m any) protoreflect.Message {
if reflect.TypeOf(m) != mi.GoReflectType {
panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
}
p := pointerOfIface(m)
if p.IsNil() {
return mi.nilMessage.Init(mi)
}
return &messageReflectWrapper{p, mi}
}
func (m *messageReflectWrapper) pointer() pointer { return m.p }
func (m *messageReflectWrapper) messageInfo() *MessageInfo { return m.mi }
// Reset implements the v1 proto.Message.Reset method.
func (m *messageIfaceWrapper) Reset() {
if mr, ok := m.protoUnwrap().(interface{ Reset() }); ok {
mr.Reset()
return
}
rv := reflect.ValueOf(m.protoUnwrap())
if rv.Kind() == reflect.Ptr && !rv.IsNil() {
rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
}
}
func (m *messageIfaceWrapper) ProtoReflect() protoreflect.Message {
return (*messageReflectWrapper)(m)
}
func (m *messageIfaceWrapper) protoUnwrap() any {
return m.p.AsIfaceOf(m.mi.GoReflectType.Elem())
}
// checkField verifies that the provided field descriptor is valid.
// Exactly one of the returned values is populated.
func (mi *MessageInfo) checkField(fd protoreflect.FieldDescriptor) (*fieldInfo, protoreflect.ExtensionTypeDescriptor) {
var fi *fieldInfo
if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) {
fi = mi.denseFields[n]
} else {
fi = mi.fields[n]
}
if fi != nil {
if fi.fieldDesc != fd {
if got, want := fd.FullName(), fi.fieldDesc.FullName(); got != want {
panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
}
panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
}
return fi, nil
}
if fd.IsExtension() {
if got, want := fd.ContainingMessage().FullName(), mi.Desc.FullName(); got != want {
// TODO: Should this be exact containing message descriptor match?
panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
}
if !mi.Desc.ExtensionRanges().Has(fd.Number()) {
panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
}
xtd, ok := fd.(protoreflect.ExtensionTypeDescriptor)
if !ok {
panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
}
return nil, xtd
}
panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
}
// Copyright 2018 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 impl
import (
"fmt"
"math"
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
type fieldInfo struct {
fieldDesc protoreflect.FieldDescriptor
// These fields are used for protobuf reflection support.
has func(pointer) bool
clear func(pointer)
get func(pointer) protoreflect.Value
set func(pointer, protoreflect.Value)
mutable func(pointer) protoreflect.Value
newMessage func() protoreflect.Message
newField func() protoreflect.Value
}
func fieldInfoForMissing(fd protoreflect.FieldDescriptor) fieldInfo {
// This never occurs for generated message types.
// It implies that a hand-crafted type has missing Go fields
// for specific protobuf message fields.
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
return false
},
clear: func(p pointer) {
panic("missing Go struct field for " + string(fd.FullName()))
},
get: func(p pointer) protoreflect.Value {
return fd.Default()
},
set: func(p pointer, v protoreflect.Value) {
panic("missing Go struct field for " + string(fd.FullName()))
},
mutable: func(p pointer) protoreflect.Value {
panic("missing Go struct field for " + string(fd.FullName()))
},
newMessage: func() protoreflect.Message {
panic("missing Go struct field for " + string(fd.FullName()))
},
newField: func() protoreflect.Value {
if v := fd.Default(); v.IsValid() {
return v
}
panic("missing Go struct field for " + string(fd.FullName()))
},
}
}
func fieldInfoForOneof(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Interface {
panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
}
if ot.Kind() != reflect.Struct {
panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
}
if !reflect.PtrTo(ot).Implements(ft) {
panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
}
conv := NewConverter(ot.Field(0).Type, fd)
isMessage := fd.Message() != nil
// TODO: Implement unsafe fast path?
fieldOffset := offsetOf(fs)
return fieldInfo{
// NOTE: The logic below intentionally assumes that oneof fields are
// well-formatted. That is, the oneof interface never contains a
// typed nil pointer to one of the wrapper structs.
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
return false
}
return true
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() || rv.Elem().Type().Elem() != ot {
// NOTE: We intentionally don't check for rv.Elem().IsNil()
// so that (*OneofWrapperType)(nil) gets cleared to nil.
return
}
rv.Set(reflect.Zero(rv.Type()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
return conv.Zero()
}
rv = rv.Elem().Elem().Field(0)
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
rv.Set(reflect.New(ot))
}
rv = rv.Elem().Elem().Field(0)
rv.Set(conv.GoValueOf(v))
},
mutable: func(p pointer) protoreflect.Value {
if !isMessage {
panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
rv.Set(reflect.New(ot))
}
rv = rv.Elem().Elem().Field(0)
if rv.Kind() == reflect.Ptr && rv.IsNil() {
rv.Set(conv.GoValueOf(protoreflect.ValueOfMessage(conv.New().Message())))
}
return conv.PBValueOf(rv)
},
newMessage: func() protoreflect.Message {
return conv.New().Message()
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func fieldInfoForMap(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Map {
panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
}
conv := NewConverter(ft, fd)
// TODO: Implement unsafe fast path?
fieldOffset := offsetOf(fs)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return rv.Len() > 0
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.Len() == 0 {
return conv.Zero()
}
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
pv := conv.GoValueOf(v)
if pv.IsNil() {
panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
}
rv.Set(pv)
},
mutable: func(p pointer) protoreflect.Value {
v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if v.IsNil() {
v.Set(reflect.MakeMap(fs.Type))
}
return conv.PBValueOf(v)
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func fieldInfoForList(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Slice {
panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
}
conv := NewConverter(reflect.PtrTo(ft), fd)
// TODO: Implement unsafe fast path?
fieldOffset := offsetOf(fs)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return rv.Len() > 0
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
if rv.Elem().Len() == 0 {
return conv.Zero()
}
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
pv := conv.GoValueOf(v)
if pv.IsNil() {
panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
}
rv.Set(pv.Elem())
},
mutable: func(p pointer) protoreflect.Value {
v := p.Apply(fieldOffset).AsValueOf(fs.Type)
return conv.PBValueOf(v)
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
var (
nilBytes = reflect.ValueOf([]byte(nil))
emptyBytes = reflect.ValueOf([]byte{})
)
func fieldInfoForScalar(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
nullable := fd.HasPresence()
isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
var getter func(p pointer) protoreflect.Value
if nullable {
if ft.Kind() != reflect.Ptr && ft.Kind() != reflect.Slice {
// This never occurs for generated message types.
// Despite the protobuf type system specifying presence,
// the Go field type cannot represent it.
nullable = false
}
if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
}
conv := NewConverter(ft, fd)
fieldOffset := offsetOf(fs)
// Generate specialized getter functions to avoid going through reflect.Value
if nullable {
getter = getterForNullableScalar(fd, fs, conv, fieldOffset)
} else {
getter = getterForDirectScalar(fd, fs, conv, fieldOffset)
}
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
if nullable {
return !p.Apply(fieldOffset).Elem().IsNil()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
switch rv.Kind() {
case reflect.Bool:
return rv.Bool()
case reflect.Int32, reflect.Int64:
return rv.Int() != 0
case reflect.Uint32, reflect.Uint64:
return rv.Uint() != 0
case reflect.Float32, reflect.Float64:
return rv.Float() != 0 || math.Signbit(rv.Float())
case reflect.String, reflect.Slice:
return rv.Len() > 0
default:
panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
}
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: getter,
// TODO: Implement unsafe fast path for set?
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if nullable && rv.Kind() == reflect.Ptr {
if rv.IsNil() {
rv.Set(reflect.New(ft))
}
rv = rv.Elem()
}
rv.Set(conv.GoValueOf(v))
if isBytes && rv.Len() == 0 {
if nullable {
rv.Set(emptyBytes) // preserve presence
} else {
rv.Set(nilBytes) // do not preserve presence
}
}
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
func fieldInfoForMessage(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
conv := NewConverter(ft, fd)
// TODO: Implement unsafe fast path?
fieldOffset := offsetOf(fs)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
if p.IsNil() {
return false
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if fs.Type.Kind() != reflect.Ptr {
return !rv.IsZero()
}
return !rv.IsNil()
},
clear: func(p pointer) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type()))
},
get: func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return conv.PBValueOf(rv)
},
set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(conv.GoValueOf(v))
if fs.Type.Kind() == reflect.Ptr && rv.IsNil() {
panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
}
},
mutable: func(p pointer) protoreflect.Value {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if fs.Type.Kind() == reflect.Ptr && rv.IsNil() {
rv.Set(conv.GoValueOf(conv.New()))
}
return conv.PBValueOf(rv)
},
newMessage: func() protoreflect.Message {
return conv.New().Message()
},
newField: func() protoreflect.Value {
return conv.New()
},
}
}
type oneofInfo struct {
oneofDesc protoreflect.OneofDescriptor
which func(pointer) protoreflect.FieldNumber
}
func makeOneofInfo(od protoreflect.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
oi := &oneofInfo{oneofDesc: od}
if od.IsSynthetic() {
fs := si.fieldsByNumber[od.Fields().Get(0).Number()]
fieldOffset := offsetOf(fs)
oi.which = func(p pointer) protoreflect.FieldNumber {
if p.IsNil() {
return 0
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() { // valid on either *T or []byte
return 0
}
return od.Fields().Get(0).Number()
}
} else {
fs := si.oneofsByName[od.Name()]
fieldOffset := offsetOf(fs)
oi.which = func(p pointer) protoreflect.FieldNumber {
if p.IsNil() {
return 0
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() {
return 0
}
rv = rv.Elem()
if rv.IsNil() {
return 0
}
return si.oneofWrappersByType[rv.Type().Elem()]
}
}
return oi
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package impl
import (
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
)
func getterForNullableScalar(fd protoreflect.FieldDescriptor, fs reflect.StructField, conv Converter, fieldOffset offset) func(p pointer) protoreflect.Value {
ft := fs.Type
if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
if fd.Kind() == protoreflect.EnumKind {
elemType := fs.Type.Elem()
// Enums for nullable types.
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).Elem().AsValueOf(elemType)
if rv.IsNil() {
return conv.Zero()
}
return conv.PBValueOf(rv.Elem())
}
}
switch ft.Kind() {
case reflect.Bool:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).BoolPtr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfBool(**x)
}
case reflect.Int32:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Int32Ptr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfInt32(**x)
}
case reflect.Uint32:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Uint32Ptr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfUint32(**x)
}
case reflect.Int64:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Int64Ptr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfInt64(**x)
}
case reflect.Uint64:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Uint64Ptr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfUint64(**x)
}
case reflect.Float32:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Float32Ptr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfFloat32(**x)
}
case reflect.Float64:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Float64Ptr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfFloat64(**x)
}
case reflect.String:
if fd.Kind() == protoreflect.BytesKind {
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).StringPtr()
if *x == nil {
return conv.Zero()
}
if len(**x) == 0 {
return protoreflect.ValueOfBytes(nil)
}
return protoreflect.ValueOfBytes([]byte(**x))
}
}
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).StringPtr()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfString(**x)
}
case reflect.Slice:
if fd.Kind() == protoreflect.StringKind {
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bytes()
if len(*x) == 0 {
return conv.Zero()
}
return protoreflect.ValueOfString(string(*x))
}
}
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bytes()
if *x == nil {
return conv.Zero()
}
return protoreflect.ValueOfBytes(*x)
}
}
panic("unexpected protobuf kind: " + ft.Kind().String())
}
func getterForDirectScalar(fd protoreflect.FieldDescriptor, fs reflect.StructField, conv Converter, fieldOffset offset) func(p pointer) protoreflect.Value {
ft := fs.Type
if fd.Kind() == protoreflect.EnumKind {
// Enums for non nullable types.
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return conv.PBValueOf(rv)
}
}
switch ft.Kind() {
case reflect.Bool:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bool()
return protoreflect.ValueOfBool(*x)
}
case reflect.Int32:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Int32()
return protoreflect.ValueOfInt32(*x)
}
case reflect.Uint32:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Uint32()
return protoreflect.ValueOfUint32(*x)
}
case reflect.Int64:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Int64()
return protoreflect.ValueOfInt64(*x)
}
case reflect.Uint64:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Uint64()
return protoreflect.ValueOfUint64(*x)
}
case reflect.Float32:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Float32()
return protoreflect.ValueOfFloat32(*x)
}
case reflect.Float64:
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Float64()
return protoreflect.ValueOfFloat64(*x)
}
case reflect.String:
if fd.Kind() == protoreflect.BytesKind {
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).String()
if len(*x) == 0 {
return protoreflect.ValueOfBytes(nil)
}
return protoreflect.ValueOfBytes([]byte(*x))
}
}
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).String()
return protoreflect.ValueOfString(*x)
}
case reflect.Slice:
if fd.Kind() == protoreflect.StringKind {
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bytes()
return protoreflect.ValueOfString(string(*x))
}
}
return func(p pointer) protoreflect.Value {
if p.IsNil() {
return conv.Zero()
}
x := p.Apply(fieldOffset).Bytes()
return protoreflect.ValueOfBytes(*x)
}
}
panic("unexpected protobuf kind: " + ft.Kind().String())
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package impl
import (
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
func (m *messageState) Descriptor() protoreflect.MessageDescriptor {
return m.messageInfo().Desc
}
func (m *messageState) Type() protoreflect.MessageType {
return m.messageInfo()
}
func (m *messageState) New() protoreflect.Message {
return m.messageInfo().New()
}
func (m *messageState) Interface() protoreflect.ProtoMessage {
return m.protoUnwrap().(protoreflect.ProtoMessage)
}
func (m *messageState) protoUnwrap() any {
return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
}
func (m *messageState) ProtoMethods() *protoiface.Methods {
mi := m.messageInfo()
mi.init()
return &mi.methods
}
// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
// to be able to retrieve a v2 MessageInfo struct.
//
// WARNING: This method is exempt from the compatibility promise and
// may be removed in the future without warning.
func (m *messageState) ProtoMessageInfo() *MessageInfo {
return m.messageInfo()
}
func (m *messageState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
mi := m.messageInfo()
mi.init()
for _, ri := range mi.rangeInfos {
switch ri := ri.(type) {
case *fieldInfo:
if ri.has(m.pointer()) {
if !f(ri.fieldDesc, ri.get(m.pointer())) {
return
}
}
case *oneofInfo:
if n := ri.which(m.pointer()); n > 0 {
fi := mi.fields[n]
if !f(fi.fieldDesc, fi.get(m.pointer())) {
return
}
}
}
}
mi.extensionMap(m.pointer()).Range(f)
}
func (m *messageState) Has(fd protoreflect.FieldDescriptor) bool {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.has(m.pointer())
} else {
return mi.extensionMap(m.pointer()).Has(xd)
}
}
func (m *messageState) Clear(fd protoreflect.FieldDescriptor) {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
fi.clear(m.pointer())
} else {
mi.extensionMap(m.pointer()).Clear(xd)
}
}
func (m *messageState) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.get(m.pointer())
} else {
return mi.extensionMap(m.pointer()).Get(xd)
}
}
func (m *messageState) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
fi.set(m.pointer(), v)
} else {
mi.extensionMap(m.pointer()).Set(xd, v)
}
}
func (m *messageState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.mutable(m.pointer())
} else {
return mi.extensionMap(m.pointer()).Mutable(xd)
}
}
func (m *messageState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.newField()
} else {
return xd.Type().New()
}
}
func (m *messageState) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
mi := m.messageInfo()
mi.init()
if oi := mi.oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
return od.Fields().ByNumber(oi.which(m.pointer()))
}
panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
}
func (m *messageState) GetUnknown() protoreflect.RawFields {
mi := m.messageInfo()
mi.init()
return mi.getUnknown(m.pointer())
}
func (m *messageState) SetUnknown(b protoreflect.RawFields) {
mi := m.messageInfo()
mi.init()
mi.setUnknown(m.pointer(), b)
}
func (m *messageState) IsValid() bool {
return !m.pointer().IsNil()
}
func (m *messageReflectWrapper) Descriptor() protoreflect.MessageDescriptor {
return m.messageInfo().Desc
}
func (m *messageReflectWrapper) Type() protoreflect.MessageType {
return m.messageInfo()
}
func (m *messageReflectWrapper) New() protoreflect.Message {
return m.messageInfo().New()
}
func (m *messageReflectWrapper) Interface() protoreflect.ProtoMessage {
if m, ok := m.protoUnwrap().(protoreflect.ProtoMessage); ok {
return m
}
return (*messageIfaceWrapper)(m)
}
func (m *messageReflectWrapper) protoUnwrap() any {
return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
}
func (m *messageReflectWrapper) ProtoMethods() *protoiface.Methods {
mi := m.messageInfo()
mi.init()
return &mi.methods
}
// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
// to be able to retrieve a v2 MessageInfo struct.
//
// WARNING: This method is exempt from the compatibility promise and
// may be removed in the future without warning.
func (m *messageReflectWrapper) ProtoMessageInfo() *MessageInfo {
return m.messageInfo()
}
func (m *messageReflectWrapper) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
mi := m.messageInfo()
mi.init()
for _, ri := range mi.rangeInfos {
switch ri := ri.(type) {
case *fieldInfo:
if ri.has(m.pointer()) {
if !f(ri.fieldDesc, ri.get(m.pointer())) {
return
}
}
case *oneofInfo:
if n := ri.which(m.pointer()); n > 0 {
fi := mi.fields[n]
if !f(fi.fieldDesc, fi.get(m.pointer())) {
return
}
}
}
}
mi.extensionMap(m.pointer()).Range(f)
}
func (m *messageReflectWrapper) Has(fd protoreflect.FieldDescriptor) bool {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.has(m.pointer())
} else {
return mi.extensionMap(m.pointer()).Has(xd)
}
}
func (m *messageReflectWrapper) Clear(fd protoreflect.FieldDescriptor) {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
fi.clear(m.pointer())
} else {
mi.extensionMap(m.pointer()).Clear(xd)
}
}
func (m *messageReflectWrapper) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.get(m.pointer())
} else {
return mi.extensionMap(m.pointer()).Get(xd)
}
}
func (m *messageReflectWrapper) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
fi.set(m.pointer(), v)
} else {
mi.extensionMap(m.pointer()).Set(xd, v)
}
}
func (m *messageReflectWrapper) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.mutable(m.pointer())
} else {
return mi.extensionMap(m.pointer()).Mutable(xd)
}
}
func (m *messageReflectWrapper) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
mi := m.messageInfo()
mi.init()
if fi, xd := mi.checkField(fd); fi != nil {
return fi.newField()
} else {
return xd.Type().New()
}
}
func (m *messageReflectWrapper) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
mi := m.messageInfo()
mi.init()
if oi := mi.oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
return od.Fields().ByNumber(oi.which(m.pointer()))
}
panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
}
func (m *messageReflectWrapper) GetUnknown() protoreflect.RawFields {
mi := m.messageInfo()
mi.init()
return mi.getUnknown(m.pointer())
}
func (m *messageReflectWrapper) SetUnknown(b protoreflect.RawFields) {
mi := m.messageInfo()
mi.init()
mi.setUnknown(m.pointer(), b)
}
func (m *messageReflectWrapper) IsValid() bool {
return !m.pointer().IsNil()
}
// Copyright 2018 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 impl
import (
"reflect"
"sync/atomic"
"unsafe"
"google.golang.org/protobuf/internal/protolazy"
)
const UnsafeEnabled = true
// Pointer is an opaque pointer type.
type Pointer unsafe.Pointer
// offset represents the offset to a struct field, accessible from a pointer.
// The offset is the byte offset to the field from the start of the struct.
type offset uintptr
// offsetOf returns a field offset for the struct field.
func offsetOf(f reflect.StructField) offset {
return offset(f.Offset)
}
// IsValid reports whether the offset is valid.
func (f offset) IsValid() bool { return f != invalidOffset }
// invalidOffset is an invalid field offset.
var invalidOffset = ^offset(0)
// zeroOffset is a noop when calling pointer.Apply.
var zeroOffset = offset(0)
// pointer is a pointer to a message struct or field.
type pointer struct{ p unsafe.Pointer }
// pointerOf returns p as a pointer.
func pointerOf(p Pointer) pointer {
return pointer{p: unsafe.Pointer(p)}
}
// pointerOfValue returns v as a pointer.
func pointerOfValue(v reflect.Value) pointer {
return pointer{p: unsafe.Pointer(v.Pointer())}
}
// pointerOfIface returns the pointer portion of an interface.
func pointerOfIface(v any) pointer {
type ifaceHeader struct {
Type unsafe.Pointer
Data unsafe.Pointer
}
return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
}
// IsNil reports whether the pointer is nil.
func (p pointer) IsNil() bool {
return p.p == nil
}
// Apply adds an offset to the pointer to derive a new pointer
// to a specified field. The pointer must be valid and pointing at a struct.
func (p pointer) Apply(f offset) pointer {
if p.IsNil() {
panic("invalid nil pointer")
}
return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
}
// AsValueOf treats p as a pointer to an object of type t and returns the value.
// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
return reflect.NewAt(t, p.p)
}
// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
// It is equivalent to p.AsValueOf(t).Interface()
func (p pointer) AsIfaceOf(t reflect.Type) any {
// TODO: Use tricky unsafe magic to directly create ifaceHeader.
return p.AsValueOf(t).Interface()
}
func (p pointer) Bool() *bool { return (*bool)(p.p) }
func (p pointer) BoolPtr() **bool { return (**bool)(p.p) }
func (p pointer) BoolSlice() *[]bool { return (*[]bool)(p.p) }
func (p pointer) Int32() *int32 { return (*int32)(p.p) }
func (p pointer) Int32Ptr() **int32 { return (**int32)(p.p) }
func (p pointer) Int32Slice() *[]int32 { return (*[]int32)(p.p) }
func (p pointer) Int64() *int64 { return (*int64)(p.p) }
func (p pointer) Int64Ptr() **int64 { return (**int64)(p.p) }
func (p pointer) Int64Slice() *[]int64 { return (*[]int64)(p.p) }
func (p pointer) Uint32() *uint32 { return (*uint32)(p.p) }
func (p pointer) Uint32Ptr() **uint32 { return (**uint32)(p.p) }
func (p pointer) Uint32Slice() *[]uint32 { return (*[]uint32)(p.p) }
func (p pointer) Uint64() *uint64 { return (*uint64)(p.p) }
func (p pointer) Uint64Ptr() **uint64 { return (**uint64)(p.p) }
func (p pointer) Uint64Slice() *[]uint64 { return (*[]uint64)(p.p) }
func (p pointer) Float32() *float32 { return (*float32)(p.p) }
func (p pointer) Float32Ptr() **float32 { return (**float32)(p.p) }
func (p pointer) Float32Slice() *[]float32 { return (*[]float32)(p.p) }
func (p pointer) Float64() *float64 { return (*float64)(p.p) }
func (p pointer) Float64Ptr() **float64 { return (**float64)(p.p) }
func (p pointer) Float64Slice() *[]float64 { return (*[]float64)(p.p) }
func (p pointer) String() *string { return (*string)(p.p) }
func (p pointer) StringPtr() **string { return (**string)(p.p) }
func (p pointer) StringSlice() *[]string { return (*[]string)(p.p) }
func (p pointer) Bytes() *[]byte { return (*[]byte)(p.p) }
func (p pointer) BytesPtr() **[]byte { return (**[]byte)(p.p) }
func (p pointer) BytesSlice() *[][]byte { return (*[][]byte)(p.p) }
func (p pointer) Extensions() *map[int32]ExtensionField { return (*map[int32]ExtensionField)(p.p) }
func (p pointer) LazyInfoPtr() **protolazy.XXX_lazyUnmarshalInfo {
return (**protolazy.XXX_lazyUnmarshalInfo)(p.p)
}
func (p pointer) PresenceInfo() presence {
return presence{P: p.p}
}
func (p pointer) Elem() pointer {
return pointer{p: *(*unsafe.Pointer)(p.p)}
}
// PointerSlice loads []*T from p as a []pointer.
// The value returned is aliased with the original slice.
// This behavior differs from the implementation in pointer_reflect.go.
func (p pointer) PointerSlice() []pointer {
// Super-tricky - p should point to a []*T where T is a
// message type. We load it as []pointer.
return *(*[]pointer)(p.p)
}
// AppendPointerSlice appends v to p, which must be a []*T.
func (p pointer) AppendPointerSlice(v pointer) {
*(*[]pointer)(p.p) = append(*(*[]pointer)(p.p), v)
}
// SetPointer sets *p to v.
func (p pointer) SetPointer(v pointer) {
*(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
}
func (p pointer) growBoolSlice(addCap int) {
sp := p.BoolSlice()
s := make([]bool, 0, addCap+len(*sp))
s = s[:len(*sp)]
copy(s, *sp)
*sp = s
}
func (p pointer) growInt32Slice(addCap int) {
sp := p.Int32Slice()
s := make([]int32, 0, addCap+len(*sp))
s = s[:len(*sp)]
copy(s, *sp)
*sp = s
}
func (p pointer) growUint32Slice(addCap int) {
p.growInt32Slice(addCap)
}
func (p pointer) growFloat32Slice(addCap int) {
p.growInt32Slice(addCap)
}
func (p pointer) growInt64Slice(addCap int) {
sp := p.Int64Slice()
s := make([]int64, 0, addCap+len(*sp))
s = s[:len(*sp)]
copy(s, *sp)
*sp = s
}
func (p pointer) growUint64Slice(addCap int) {
p.growInt64Slice(addCap)
}
func (p pointer) growFloat64Slice(addCap int) {
p.growInt64Slice(addCap)
}
// Static check that MessageState does not exceed the size of a pointer.
const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
func (Export) MessageStateOf(p Pointer) *messageState {
// Super-tricky - see documentation on MessageState.
return (*messageState)(unsafe.Pointer(p))
}
func (ms *messageState) pointer() pointer {
// Super-tricky - see documentation on MessageState.
return pointer{p: unsafe.Pointer(ms)}
}
func (ms *messageState) messageInfo() *MessageInfo {
mi := ms.LoadMessageInfo()
if mi == nil {
panic("invalid nil message info; this suggests memory corruption due to a race or shallow copy on the message struct")
}
return mi
}
func (ms *messageState) LoadMessageInfo() *MessageInfo {
return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
}
func (ms *messageState) StoreMessageInfo(mi *MessageInfo) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
}
type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
if p := atomic.LoadPointer(&m.p); p != nil {
return (*messageReflectWrapper)(p)
}
w := &messageReflectWrapper{mi: mi}
atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
return (*messageReflectWrapper)(atomic.LoadPointer(&m.p))
}
// Copyright 2024 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 impl
import (
"sync/atomic"
"unsafe"
)
func (p pointer) AtomicGetPointer() pointer {
return pointer{p: atomic.LoadPointer((*unsafe.Pointer)(p.p))}
}
func (p pointer) AtomicSetPointer(v pointer) {
atomic.StorePointer((*unsafe.Pointer)(p.p), v.p)
}
func (p pointer) AtomicSetNilPointer() {
atomic.StorePointer((*unsafe.Pointer)(p.p), unsafe.Pointer(nil))
}
func (p pointer) AtomicSetPointerIfNil(v pointer) pointer {
if atomic.CompareAndSwapPointer((*unsafe.Pointer)(p.p), unsafe.Pointer(nil), v.p) {
return v
}
return pointer{p: atomic.LoadPointer((*unsafe.Pointer)(p.p))}
}
type atomicV1MessageInfo struct{ p Pointer }
func (mi *atomicV1MessageInfo) Get() Pointer {
return Pointer(atomic.LoadPointer((*unsafe.Pointer)(&mi.p)))
}
func (mi *atomicV1MessageInfo) SetIfNil(p Pointer) Pointer {
if atomic.CompareAndSwapPointer((*unsafe.Pointer)(&mi.p), nil, unsafe.Pointer(p)) {
return p
}
return mi.Get()
}
// Copyright 2024 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 impl
import (
"sync/atomic"
"unsafe"
)
// presenceSize represents the size of a presence set, which should be the largest index of the set+1
type presenceSize uint32
// presence is the internal representation of the bitmap array in a generated protobuf
type presence struct {
// This is a pointer to the beginning of an array of uint32
P unsafe.Pointer
}
func (p presence) toElem(num uint32) (ret *uint32) {
const (
bitsPerByte = 8
siz = unsafe.Sizeof(*ret)
)
// p.P points to an array of uint32, num is the bit in this array that the
// caller wants to check/manipulate. Calculate the index in the array that
// contains this specific bit. E.g.: 76 / 32 = 2 (integer division).
offset := uintptr(num) / (siz * bitsPerByte) * siz
return (*uint32)(unsafe.Pointer(uintptr(p.P) + offset))
}
// Present checks for the presence of a specific field number in a presence set.
func (p presence) Present(num uint32) bool {
return Export{}.Present(p.toElem(num), num)
}
// SetPresent adds presence for a specific field number in a presence set.
func (p presence) SetPresent(num uint32, size presenceSize) {
Export{}.SetPresent(p.toElem(num), num, uint32(size))
}
// SetPresentUnatomic adds presence for a specific field number in a presence set without using
// atomic operations. Only to be called during unmarshaling.
func (p presence) SetPresentUnatomic(num uint32, size presenceSize) {
Export{}.SetPresentNonAtomic(p.toElem(num), num, uint32(size))
}
// ClearPresent removes presence for a specific field number in a presence set.
func (p presence) ClearPresent(num uint32) {
Export{}.ClearPresent(p.toElem(num), num)
}
// LoadPresenceCache (together with PresentInCache) allows for a
// cached version of checking for presence without re-reading the word
// for every field. It is optimized for efficiency and assumes no
// simltaneous mutation of the presence set (or at least does not have
// a problem with simultaneous mutation giving inconsistent results).
func (p presence) LoadPresenceCache() (current uint32) {
if p.P == nil {
return 0
}
return atomic.LoadUint32((*uint32)(p.P))
}
// PresentInCache reads presence from a cached word in the presence
// bitmap. It caches up a new word if the bit is outside the
// word. This is for really fast iteration through bitmaps in cases
// where we either know that the bitmap will not be altered, or we
// don't care about inconsistencies caused by simultaneous writes.
func (p presence) PresentInCache(num uint32, cachedElement *uint32, current *uint32) bool {
if num/32 != *cachedElement {
o := uintptr(num/32) * unsafe.Sizeof(uint32(0))
q := (*uint32)(unsafe.Pointer(uintptr(p.P) + o))
*current = atomic.LoadUint32(q)
*cachedElement = num / 32
}
return (*current & (1 << (num % 32))) > 0
}
// AnyPresent checks if any field is marked as present in the bitmap.
func (p presence) AnyPresent(size presenceSize) bool {
n := uintptr((size + 31) / 32)
for j := uintptr(0); j < n; j++ {
o := j * unsafe.Sizeof(uint32(0))
q := (*uint32)(unsafe.Pointer(uintptr(p.P) + o))
b := atomic.LoadUint32(q)
if b > 0 {
return true
}
}
return false
}
// toRaceDetectData finds the preceding RaceDetectHookData in a
// message by using pointer arithmetic. As the type of the presence
// set (bitmap) varies with the number of fields in the protobuf, we
// can not have a struct type containing the array and the
// RaceDetectHookData. instead the RaceDetectHookData is placed
// immediately before the bitmap array, and we find it by walking
// backwards in the struct.
//
// This method is only called from the race-detect version of the code,
// so RaceDetectHookData is never an empty struct.
func (p presence) toRaceDetectData() *RaceDetectHookData {
var template struct {
d RaceDetectHookData
a [1]uint32
}
o := (uintptr(unsafe.Pointer(&template.a)) - uintptr(unsafe.Pointer(&template.d)))
return (*RaceDetectHookData)(unsafe.Pointer(uintptr(p.P) - o))
}
func atomicLoadShadowPresence(p **[]byte) *[]byte {
return (*[]byte)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func atomicStoreShadowPresence(p **[]byte, v *[]byte) {
atomic.CompareAndSwapPointer((*unsafe.Pointer)(unsafe.Pointer(p)), nil, unsafe.Pointer(v))
}
// findPointerToRaceDetectData finds the preceding RaceDetectHookData
// in a message by using pointer arithmetic. For the methods called
// directy from generated code, we don't have a pointer to the
// beginning of the presence set, but a pointer inside the array. As
// we know the index of the bit we're manipulating (num), we can
// calculate which element of the array ptr is pointing to. With that
// information we find the preceding RaceDetectHookData and can
// manipulate the shadow bitmap.
//
// This method is only called from the race-detect version of the
// code, so RaceDetectHookData is never an empty struct.
func findPointerToRaceDetectData(ptr *uint32, num uint32) *RaceDetectHookData {
var template struct {
d RaceDetectHookData
a [1]uint32
}
o := (uintptr(unsafe.Pointer(&template.a)) - uintptr(unsafe.Pointer(&template.d))) + uintptr(num/32)*unsafe.Sizeof(uint32(0))
return (*RaceDetectHookData)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) - o))
}
// 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 impl
import (
"fmt"
"math"
"math/bits"
"reflect"
"unicode/utf8"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
)
// ValidationStatus is the result of validating the wire-format encoding of a message.
type ValidationStatus int
const (
// ValidationUnknown indicates that unmarshaling the message might succeed or fail.
// The validator was unable to render a judgement.
//
// The only causes of this status are an aberrant message type appearing somewhere
// in the message or a failure in the extension resolver.
ValidationUnknown ValidationStatus = iota + 1
// ValidationInvalid indicates that unmarshaling the message will fail.
ValidationInvalid
// ValidationValid indicates that unmarshaling the message will succeed.
ValidationValid
// ValidationWrongWireType indicates that a validated field does not have
// the expected wire type.
ValidationWrongWireType
)
func (v ValidationStatus) String() string {
switch v {
case ValidationUnknown:
return "ValidationUnknown"
case ValidationInvalid:
return "ValidationInvalid"
case ValidationValid:
return "ValidationValid"
default:
return fmt.Sprintf("ValidationStatus(%d)", int(v))
}
}
// Validate determines whether the contents of the buffer are a valid wire encoding
// of the message type.
//
// This function is exposed for testing.
func Validate(mt protoreflect.MessageType, in protoiface.UnmarshalInput) (out protoiface.UnmarshalOutput, _ ValidationStatus) {
mi, ok := mt.(*MessageInfo)
if !ok {
return out, ValidationUnknown
}
if in.Resolver == nil {
in.Resolver = protoregistry.GlobalTypes
}
o, st := mi.validate(in.Buf, 0, unmarshalOptions{
flags: in.Flags,
resolver: in.Resolver,
})
if o.initialized {
out.Flags |= protoiface.UnmarshalInitialized
}
return out, st
}
type validationInfo struct {
mi *MessageInfo
typ validationType
keyType, valType validationType
// For non-required fields, requiredBit is 0.
//
// For required fields, requiredBit's nth bit is set, where n is a
// unique index in the range [0, MessageInfo.numRequiredFields).
//
// If there are more than 64 required fields, requiredBit is 0.
requiredBit uint64
}
type validationType uint8
const (
validationTypeOther validationType = iota
validationTypeMessage
validationTypeGroup
validationTypeMap
validationTypeRepeatedVarint
validationTypeRepeatedFixed32
validationTypeRepeatedFixed64
validationTypeVarint
validationTypeFixed32
validationTypeFixed64
validationTypeBytes
validationTypeUTF8String
validationTypeMessageSetItem
)
func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
var vi validationInfo
switch {
case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
switch fd.Kind() {
case protoreflect.MessageKind:
vi.typ = validationTypeMessage
if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
vi.mi = getMessageInfo(ot.Field(0).Type)
}
case protoreflect.GroupKind:
vi.typ = validationTypeGroup
if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
vi.mi = getMessageInfo(ot.Field(0).Type)
}
case protoreflect.StringKind:
if strs.EnforceUTF8(fd) {
vi.typ = validationTypeUTF8String
}
}
default:
vi = newValidationInfo(fd, ft)
}
if fd.Cardinality() == protoreflect.Required {
// Avoid overflow. The required field check is done with a 64-bit mask, with
// any message containing more than 64 required fields always reported as
// potentially uninitialized, so it is not important to get a precise count
// of the required fields past 64.
if mi.numRequiredFields < math.MaxUint8 {
mi.numRequiredFields++
vi.requiredBit = 1 << (mi.numRequiredFields - 1)
}
}
return vi
}
func newValidationInfo(fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
var vi validationInfo
switch {
case fd.IsList():
switch fd.Kind() {
case protoreflect.MessageKind:
vi.typ = validationTypeMessage
if ft.Kind() == reflect.Ptr {
// Repeated opaque message fields are *[]*T.
ft = ft.Elem()
}
if ft.Kind() == reflect.Slice {
vi.mi = getMessageInfo(ft.Elem())
}
case protoreflect.GroupKind:
vi.typ = validationTypeGroup
if ft.Kind() == reflect.Ptr {
// Repeated opaque message fields are *[]*T.
ft = ft.Elem()
}
if ft.Kind() == reflect.Slice {
vi.mi = getMessageInfo(ft.Elem())
}
case protoreflect.StringKind:
vi.typ = validationTypeBytes
if strs.EnforceUTF8(fd) {
vi.typ = validationTypeUTF8String
}
default:
switch wireTypes[fd.Kind()] {
case protowire.VarintType:
vi.typ = validationTypeRepeatedVarint
case protowire.Fixed32Type:
vi.typ = validationTypeRepeatedFixed32
case protowire.Fixed64Type:
vi.typ = validationTypeRepeatedFixed64
}
}
case fd.IsMap():
vi.typ = validationTypeMap
switch fd.MapKey().Kind() {
case protoreflect.StringKind:
if strs.EnforceUTF8(fd) {
vi.keyType = validationTypeUTF8String
}
}
switch fd.MapValue().Kind() {
case protoreflect.MessageKind:
vi.valType = validationTypeMessage
if ft.Kind() == reflect.Map {
vi.mi = getMessageInfo(ft.Elem())
}
case protoreflect.StringKind:
if strs.EnforceUTF8(fd) {
vi.valType = validationTypeUTF8String
}
}
default:
switch fd.Kind() {
case protoreflect.MessageKind:
vi.typ = validationTypeMessage
vi.mi = getMessageInfo(ft)
case protoreflect.GroupKind:
vi.typ = validationTypeGroup
vi.mi = getMessageInfo(ft)
case protoreflect.StringKind:
vi.typ = validationTypeBytes
if strs.EnforceUTF8(fd) {
vi.typ = validationTypeUTF8String
}
default:
switch wireTypes[fd.Kind()] {
case protowire.VarintType:
vi.typ = validationTypeVarint
case protowire.Fixed32Type:
vi.typ = validationTypeFixed32
case protowire.Fixed64Type:
vi.typ = validationTypeFixed64
case protowire.BytesType:
vi.typ = validationTypeBytes
}
}
}
return vi
}
func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
mi.init()
type validationState struct {
typ validationType
keyType, valType validationType
endGroup protowire.Number
mi *MessageInfo
tail []byte
requiredMask uint64
}
// Pre-allocate some slots to avoid repeated slice reallocation.
states := make([]validationState, 0, 16)
states = append(states, validationState{
typ: validationTypeMessage,
mi: mi,
})
if groupTag > 0 {
states[0].typ = validationTypeGroup
states[0].endGroup = groupTag
}
initialized := true
start := len(b)
State:
for len(states) > 0 {
st := &states[len(states)-1]
for len(b) > 0 {
// Parse the tag (field number and wire type).
var tag uint64
if b[0] < 0x80 {
tag = uint64(b[0])
b = b[1:]
} else if len(b) >= 2 && b[1] < 128 {
tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
b = b[2:]
} else {
var n int
tag, n = protowire.ConsumeVarint(b)
if n < 0 {
return out, ValidationInvalid
}
b = b[n:]
}
var num protowire.Number
if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
return out, ValidationInvalid
} else {
num = protowire.Number(n)
}
wtyp := protowire.Type(tag & 7)
if wtyp == protowire.EndGroupType {
if st.endGroup == num {
goto PopState
}
return out, ValidationInvalid
}
var vi validationInfo
switch {
case st.typ == validationTypeMap:
switch num {
case genid.MapEntry_Key_field_number:
vi.typ = st.keyType
case genid.MapEntry_Value_field_number:
vi.typ = st.valType
vi.mi = st.mi
vi.requiredBit = 1
}
case flags.ProtoLegacy && st.mi.isMessageSet:
switch num {
case messageset.FieldItem:
vi.typ = validationTypeMessageSetItem
}
default:
var f *coderFieldInfo
if int(num) < len(st.mi.denseCoderFields) {
f = st.mi.denseCoderFields[num]
} else {
f = st.mi.coderFields[num]
}
if f != nil {
vi = f.validation
break
}
// Possible extension field.
//
// TODO: We should return ValidationUnknown when:
// 1. The resolver is not frozen. (More extensions may be added to it.)
// 2. The resolver returns preg.NotFound.
// In this case, a type added to the resolver in the future could cause
// unmarshaling to begin failing. Supporting this requires some way to
// determine if the resolver is frozen.
xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
if err != nil && err != protoregistry.NotFound {
return out, ValidationUnknown
}
if err == nil {
vi = getExtensionFieldInfo(xt).validation
}
}
if vi.requiredBit != 0 {
// Check that the field has a compatible wire type.
// We only need to consider non-repeated field types,
// since repeated fields (and maps) can never be required.
ok := false
switch vi.typ {
case validationTypeVarint:
ok = wtyp == protowire.VarintType
case validationTypeFixed32:
ok = wtyp == protowire.Fixed32Type
case validationTypeFixed64:
ok = wtyp == protowire.Fixed64Type
case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
ok = wtyp == protowire.BytesType
case validationTypeGroup:
ok = wtyp == protowire.StartGroupType
}
if ok {
st.requiredMask |= vi.requiredBit
}
}
switch wtyp {
case protowire.VarintType:
if len(b) >= 10 {
switch {
case b[0] < 0x80:
b = b[1:]
case b[1] < 0x80:
b = b[2:]
case b[2] < 0x80:
b = b[3:]
case b[3] < 0x80:
b = b[4:]
case b[4] < 0x80:
b = b[5:]
case b[5] < 0x80:
b = b[6:]
case b[6] < 0x80:
b = b[7:]
case b[7] < 0x80:
b = b[8:]
case b[8] < 0x80:
b = b[9:]
case b[9] < 0x80 && b[9] < 2:
b = b[10:]
default:
return out, ValidationInvalid
}
} else {
switch {
case len(b) > 0 && b[0] < 0x80:
b = b[1:]
case len(b) > 1 && b[1] < 0x80:
b = b[2:]
case len(b) > 2 && b[2] < 0x80:
b = b[3:]
case len(b) > 3 && b[3] < 0x80:
b = b[4:]
case len(b) > 4 && b[4] < 0x80:
b = b[5:]
case len(b) > 5 && b[5] < 0x80:
b = b[6:]
case len(b) > 6 && b[6] < 0x80:
b = b[7:]
case len(b) > 7 && b[7] < 0x80:
b = b[8:]
case len(b) > 8 && b[8] < 0x80:
b = b[9:]
case len(b) > 9 && b[9] < 2:
b = b[10:]
default:
return out, ValidationInvalid
}
}
continue State
case protowire.BytesType:
var size uint64
if len(b) >= 1 && b[0] < 0x80 {
size = uint64(b[0])
b = b[1:]
} else if len(b) >= 2 && b[1] < 128 {
size = uint64(b[0]&0x7f) + uint64(b[1])<<7
b = b[2:]
} else {
var n int
size, n = protowire.ConsumeVarint(b)
if n < 0 {
return out, ValidationInvalid
}
b = b[n:]
}
if size > uint64(len(b)) {
return out, ValidationInvalid
}
v := b[:size]
b = b[size:]
switch vi.typ {
case validationTypeMessage:
if vi.mi == nil {
return out, ValidationUnknown
}
vi.mi.init()
fallthrough
case validationTypeMap:
if vi.mi != nil {
vi.mi.init()
}
states = append(states, validationState{
typ: vi.typ,
keyType: vi.keyType,
valType: vi.valType,
mi: vi.mi,
tail: b,
})
b = v
continue State
case validationTypeRepeatedVarint:
// Packed field.
for len(v) > 0 {
_, n := protowire.ConsumeVarint(v)
if n < 0 {
return out, ValidationInvalid
}
v = v[n:]
}
case validationTypeRepeatedFixed32:
// Packed field.
if len(v)%4 != 0 {
return out, ValidationInvalid
}
case validationTypeRepeatedFixed64:
// Packed field.
if len(v)%8 != 0 {
return out, ValidationInvalid
}
case validationTypeUTF8String:
if !utf8.Valid(v) {
return out, ValidationInvalid
}
}
case protowire.Fixed32Type:
if len(b) < 4 {
return out, ValidationInvalid
}
b = b[4:]
case protowire.Fixed64Type:
if len(b) < 8 {
return out, ValidationInvalid
}
b = b[8:]
case protowire.StartGroupType:
switch {
case vi.typ == validationTypeGroup:
if vi.mi == nil {
return out, ValidationUnknown
}
vi.mi.init()
states = append(states, validationState{
typ: validationTypeGroup,
mi: vi.mi,
endGroup: num,
})
continue State
case flags.ProtoLegacy && vi.typ == validationTypeMessageSetItem:
typeid, v, n, err := messageset.ConsumeFieldValue(b, false)
if err != nil {
return out, ValidationInvalid
}
xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
switch {
case err == protoregistry.NotFound:
b = b[n:]
case err != nil:
return out, ValidationUnknown
default:
xvi := getExtensionFieldInfo(xt).validation
if xvi.mi != nil {
xvi.mi.init()
}
states = append(states, validationState{
typ: xvi.typ,
mi: xvi.mi,
tail: b[n:],
})
b = v
continue State
}
default:
n := protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return out, ValidationInvalid
}
b = b[n:]
}
default:
return out, ValidationInvalid
}
}
if st.endGroup != 0 {
return out, ValidationInvalid
}
if len(b) != 0 {
return out, ValidationInvalid
}
b = st.tail
PopState:
numRequiredFields := 0
switch st.typ {
case validationTypeMessage, validationTypeGroup:
numRequiredFields = int(st.mi.numRequiredFields)
case validationTypeMap:
// If this is a map field with a message value that contains
// required fields, require that the value be present.
if st.mi != nil && st.mi.numRequiredFields > 0 {
numRequiredFields = 1
}
}
// If there are more than 64 required fields, this check will
// always fail and we will report that the message is potentially
// uninitialized.
if numRequiredFields > 0 && bits.OnesCount64(st.requiredMask) != numRequiredFields {
initialized = false
}
states = states[:len(states)-1]
}
out.n = start - len(b)
if initialized {
out.initialized = true
}
return out, ValidationValid
}
// Copyright 2020 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 order
import (
"google.golang.org/protobuf/reflect/protoreflect"
)
// FieldOrder specifies the ordering to visit message fields.
// It is a function that reports whether x is ordered before y.
type FieldOrder func(x, y protoreflect.FieldDescriptor) bool
var (
// AnyFieldOrder specifies no specific field ordering.
AnyFieldOrder FieldOrder = nil
// LegacyFieldOrder sorts fields in the same ordering as emitted by
// wire serialization in the github.com/golang/protobuf implementation.
LegacyFieldOrder FieldOrder = func(x, y protoreflect.FieldDescriptor) bool {
ox, oy := x.ContainingOneof(), y.ContainingOneof()
inOneof := func(od protoreflect.OneofDescriptor) bool {
return od != nil && !od.IsSynthetic()
}
// Extension fields sort before non-extension fields.
if x.IsExtension() != y.IsExtension() {
return x.IsExtension() && !y.IsExtension()
}
// Fields not within a oneof sort before those within a oneof.
if inOneof(ox) != inOneof(oy) {
return !inOneof(ox) && inOneof(oy)
}
// Fields in disjoint oneof sets are sorted by declaration index.
if inOneof(ox) && inOneof(oy) && ox != oy {
return ox.Index() < oy.Index()
}
// Fields sorted by field number.
return x.Number() < y.Number()
}
// NumberFieldOrder sorts fields by their field number.
NumberFieldOrder FieldOrder = func(x, y protoreflect.FieldDescriptor) bool {
return x.Number() < y.Number()
}
// IndexNameFieldOrder sorts non-extension fields before extension fields.
// Non-extensions are sorted according to their declaration index.
// Extensions are sorted according to their full name.
IndexNameFieldOrder FieldOrder = func(x, y protoreflect.FieldDescriptor) bool {
// Non-extension fields sort before extension fields.
if x.IsExtension() != y.IsExtension() {
return !x.IsExtension() && y.IsExtension()
}
// Extensions sorted by fullname.
if x.IsExtension() && y.IsExtension() {
return x.FullName() < y.FullName()
}
// Non-extensions sorted by declaration index.
return x.Index() < y.Index()
}
)
// KeyOrder specifies the ordering to visit map entries.
// It is a function that reports whether x is ordered before y.
type KeyOrder func(x, y protoreflect.MapKey) bool
var (
// AnyKeyOrder specifies no specific key ordering.
AnyKeyOrder KeyOrder = nil
// GenericKeyOrder sorts false before true, numeric keys in ascending order,
// and strings in lexicographical ordering according to UTF-8 codepoints.
GenericKeyOrder KeyOrder = func(x, y protoreflect.MapKey) bool {
switch x.Interface().(type) {
case bool:
return !x.Bool() && y.Bool()
case int32, int64:
return x.Int() < y.Int()
case uint32, uint64:
return x.Uint() < y.Uint()
case string:
return x.String() < y.String()
default:
panic("invalid map key type")
}
}
)
// Copyright 2020 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 order provides ordered access to messages and maps.
package order
import (
"sort"
"sync"
"google.golang.org/protobuf/reflect/protoreflect"
)
type messageField struct {
fd protoreflect.FieldDescriptor
v protoreflect.Value
}
var messageFieldPool = sync.Pool{
New: func() any { return new([]messageField) },
}
type (
// FieldRnger is an interface for visiting all fields in a message.
// The protoreflect.Message type implements this interface.
FieldRanger interface{ Range(VisitField) }
// VisitField is called every time a message field is visited.
VisitField = func(protoreflect.FieldDescriptor, protoreflect.Value) bool
)
// RangeFields iterates over the fields of fs according to the specified order.
func RangeFields(fs FieldRanger, less FieldOrder, fn VisitField) {
if less == nil {
fs.Range(fn)
return
}
// Obtain a pre-allocated scratch buffer.
p := messageFieldPool.Get().(*[]messageField)
fields := (*p)[:0]
defer func() {
if cap(fields) < 1024 {
*p = fields
messageFieldPool.Put(p)
}
}()
// Collect all fields in the message and sort them.
fs.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
fields = append(fields, messageField{fd, v})
return true
})
sort.Slice(fields, func(i, j int) bool {
return less(fields[i].fd, fields[j].fd)
})
// Visit the fields in the specified ordering.
for _, f := range fields {
if !fn(f.fd, f.v) {
return
}
}
}
type mapEntry struct {
k protoreflect.MapKey
v protoreflect.Value
}
var mapEntryPool = sync.Pool{
New: func() any { return new([]mapEntry) },
}
type (
// EntryRanger is an interface for visiting all fields in a message.
// The protoreflect.Map type implements this interface.
EntryRanger interface{ Range(VisitEntry) }
// VisitEntry is called every time a map entry is visited.
VisitEntry = func(protoreflect.MapKey, protoreflect.Value) bool
)
// RangeEntries iterates over the entries of es according to the specified order.
func RangeEntries(es EntryRanger, less KeyOrder, fn VisitEntry) {
if less == nil {
es.Range(fn)
return
}
// Obtain a pre-allocated scratch buffer.
p := mapEntryPool.Get().(*[]mapEntry)
entries := (*p)[:0]
defer func() {
if cap(entries) < 1024 {
*p = entries
mapEntryPool.Put(p)
}
}()
// Collect all entries in the map and sort them.
es.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
entries = append(entries, mapEntry{k, v})
return true
})
sort.Slice(entries, func(i, j int) bool {
return less(entries[i].k, entries[j].k)
})
// Visit the entries in the specified ordering.
for _, e := range entries {
if !fn(e.k, e.v) {
return
}
}
}
// Copyright 2024 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.
// Helper code for parsing a protocol buffer
package protolazy
import (
"errors"
"fmt"
"io"
"google.golang.org/protobuf/encoding/protowire"
)
// BufferReader is a structure encapsulating a protobuf and a current position
type BufferReader struct {
Buf []byte
Pos int
}
// NewBufferReader creates a new BufferRead from a protobuf
func NewBufferReader(buf []byte) BufferReader {
return BufferReader{Buf: buf, Pos: 0}
}
var errOutOfBounds = errors.New("protobuf decoding: out of bounds")
var errOverflow = errors.New("proto: integer overflow")
func (b *BufferReader) DecodeVarintSlow() (x uint64, err error) {
i := b.Pos
l := len(b.Buf)
for shift := uint(0); shift < 64; shift += 7 {
if i >= l {
err = io.ErrUnexpectedEOF
return
}
v := b.Buf[i]
i++
x |= (uint64(v) & 0x7F) << shift
if v < 0x80 {
b.Pos = i
return
}
}
// The number is too large to represent in a 64-bit value.
err = errOverflow
return
}
// decodeVarint decodes a varint at the current position
func (b *BufferReader) DecodeVarint() (x uint64, err error) {
i := b.Pos
buf := b.Buf
if i >= len(buf) {
return 0, io.ErrUnexpectedEOF
} else if buf[i] < 0x80 {
b.Pos++
return uint64(buf[i]), nil
} else if len(buf)-i < 10 {
return b.DecodeVarintSlow()
}
var v uint64
// we already checked the first byte
x = uint64(buf[i]) & 127
i++
v = uint64(buf[i])
i++
x |= (v & 127) << 7
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 14
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 21
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 28
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 35
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 42
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 49
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 56
if v < 128 {
goto done
}
v = uint64(buf[i])
i++
x |= (v & 127) << 63
if v < 128 {
goto done
}
return 0, errOverflow
done:
b.Pos = i
return
}
// decodeVarint32 decodes a varint32 at the current position
func (b *BufferReader) DecodeVarint32() (x uint32, err error) {
i := b.Pos
buf := b.Buf
if i >= len(buf) {
return 0, io.ErrUnexpectedEOF
} else if buf[i] < 0x80 {
b.Pos++
return uint32(buf[i]), nil
} else if len(buf)-i < 5 {
v, err := b.DecodeVarintSlow()
return uint32(v), err
}
var v uint32
// we already checked the first byte
x = uint32(buf[i]) & 127
i++
v = uint32(buf[i])
i++
x |= (v & 127) << 7
if v < 128 {
goto done
}
v = uint32(buf[i])
i++
x |= (v & 127) << 14
if v < 128 {
goto done
}
v = uint32(buf[i])
i++
x |= (v & 127) << 21
if v < 128 {
goto done
}
v = uint32(buf[i])
i++
x |= (v & 127) << 28
if v < 128 {
goto done
}
return 0, errOverflow
done:
b.Pos = i
return
}
// skipValue skips a value in the protobuf, based on the specified tag
func (b *BufferReader) SkipValue(tag uint32) (err error) {
wireType := tag & 0x7
switch protowire.Type(wireType) {
case protowire.VarintType:
err = b.SkipVarint()
case protowire.Fixed64Type:
err = b.SkipFixed64()
case protowire.BytesType:
var n uint32
n, err = b.DecodeVarint32()
if err == nil {
err = b.Skip(int(n))
}
case protowire.StartGroupType:
err = b.SkipGroup(tag)
case protowire.Fixed32Type:
err = b.SkipFixed32()
default:
err = fmt.Errorf("Unexpected wire type (%d)", wireType)
}
return
}
// skipGroup skips a group with the specified tag. It executes efficiently using a tag stack
func (b *BufferReader) SkipGroup(tag uint32) (err error) {
tagStack := make([]uint32, 0, 16)
tagStack = append(tagStack, tag)
var n uint32
for len(tagStack) > 0 {
tag, err = b.DecodeVarint32()
if err != nil {
return err
}
switch protowire.Type(tag & 0x7) {
case protowire.VarintType:
err = b.SkipVarint()
case protowire.Fixed64Type:
err = b.Skip(8)
case protowire.BytesType:
n, err = b.DecodeVarint32()
if err == nil {
err = b.Skip(int(n))
}
case protowire.StartGroupType:
tagStack = append(tagStack, tag)
case protowire.Fixed32Type:
err = b.SkipFixed32()
case protowire.EndGroupType:
if protoFieldNumber(tagStack[len(tagStack)-1]) == protoFieldNumber(tag) {
tagStack = tagStack[:len(tagStack)-1]
} else {
err = fmt.Errorf("end group tag %d does not match begin group tag %d at pos %d",
protoFieldNumber(tag), protoFieldNumber(tagStack[len(tagStack)-1]), b.Pos)
}
}
if err != nil {
return err
}
}
return nil
}
// skipVarint effiently skips a varint
func (b *BufferReader) SkipVarint() (err error) {
i := b.Pos
if len(b.Buf)-i < 10 {
// Use DecodeVarintSlow() to check for buffer overflow, but ignore result
if _, err := b.DecodeVarintSlow(); err != nil {
return err
}
return nil
}
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
i++
if b.Buf[i] < 0x80 {
goto out
}
return errOverflow
out:
b.Pos = i + 1
return nil
}
// skip skips the specified number of bytes
func (b *BufferReader) Skip(n int) (err error) {
if len(b.Buf) < b.Pos+n {
return io.ErrUnexpectedEOF
}
b.Pos += n
return
}
// skipFixed64 skips a fixed64
func (b *BufferReader) SkipFixed64() (err error) {
return b.Skip(8)
}
// skipFixed32 skips a fixed32
func (b *BufferReader) SkipFixed32() (err error) {
return b.Skip(4)
}
// skipBytes skips a set of bytes
func (b *BufferReader) SkipBytes() (err error) {
n, err := b.DecodeVarint32()
if err != nil {
return err
}
return b.Skip(int(n))
}
// Done returns whether we are at the end of the protobuf
func (b *BufferReader) Done() bool {
return b.Pos == len(b.Buf)
}
// Remaining returns how many bytes remain
func (b *BufferReader) Remaining() int {
return len(b.Buf) - b.Pos
}
// Copyright 2024 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 protolazy contains internal data structures for lazy message decoding.
package protolazy
import (
"fmt"
"sort"
"google.golang.org/protobuf/encoding/protowire"
piface "google.golang.org/protobuf/runtime/protoiface"
)
// IndexEntry is the structure for an index of the fields in a message of a
// proto (not descending to sub-messages)
type IndexEntry struct {
FieldNum uint32
// first byte of this tag/field
Start uint32
// first byte after a contiguous sequence of bytes for this tag/field, which could
// include a single encoding of the field, or multiple encodings for the field
End uint32
// True if this protobuf segment includes multiple encodings of the field
MultipleContiguous bool
}
// XXX_lazyUnmarshalInfo has information about a particular lazily decoded message
//
// Deprecated: Do not use. This will be deleted in the near future.
type XXX_lazyUnmarshalInfo struct {
// Index of fields and their positions in the protobuf for this
// message. Make index be a pointer to a slice so it can be updated
// atomically. The index pointer is only set once (lazily when/if
// the index is first needed), and must always be SET and LOADED
// ATOMICALLY.
index *[]IndexEntry
// The protobuf associated with this lazily decoded message. It is
// only set during proto.Unmarshal(). It doesn't need to be set and
// loaded atomically, since any simultaneous set (Unmarshal) and read
// (during a get) would already be a race in the app code.
Protobuf []byte
// The flags present when Unmarshal was originally called for this particular message
unmarshalFlags piface.UnmarshalInputFlags
}
// The Buffer and SetBuffer methods let v2/internal/impl interact with
// XXX_lazyUnmarshalInfo via an interface, to avoid an import cycle.
// Buffer returns the lazy unmarshal buffer.
//
// Deprecated: Do not use. This will be deleted in the near future.
func (lazy *XXX_lazyUnmarshalInfo) Buffer() []byte {
return lazy.Protobuf
}
// SetBuffer sets the lazy unmarshal buffer.
//
// Deprecated: Do not use. This will be deleted in the near future.
func (lazy *XXX_lazyUnmarshalInfo) SetBuffer(b []byte) {
lazy.Protobuf = b
}
// SetUnmarshalFlags is called to set a copy of the original unmarshalInputFlags.
// The flags should reflect how Unmarshal was called.
func (lazy *XXX_lazyUnmarshalInfo) SetUnmarshalFlags(f piface.UnmarshalInputFlags) {
lazy.unmarshalFlags = f
}
// UnmarshalFlags returns the original unmarshalInputFlags.
func (lazy *XXX_lazyUnmarshalInfo) UnmarshalFlags() piface.UnmarshalInputFlags {
return lazy.unmarshalFlags
}
// AllowedPartial returns true if the user originally unmarshalled this message with
// AllowPartial set to true
func (lazy *XXX_lazyUnmarshalInfo) AllowedPartial() bool {
return (lazy.unmarshalFlags & piface.UnmarshalCheckRequired) == 0
}
func protoFieldNumber(tag uint32) uint32 {
return tag >> 3
}
// buildIndex builds an index of the specified protobuf, return the index
// array and an error.
func buildIndex(buf []byte) ([]IndexEntry, error) {
index := make([]IndexEntry, 0, 16)
var lastProtoFieldNum uint32
var outOfOrder bool
var r BufferReader = NewBufferReader(buf)
for !r.Done() {
var tag uint32
var err error
var curPos = r.Pos
// INLINED: tag, err = r.DecodeVarint32()
{
i := r.Pos
buf := r.Buf
if i >= len(buf) {
return nil, errOutOfBounds
} else if buf[i] < 0x80 {
r.Pos++
tag = uint32(buf[i])
} else if r.Remaining() < 5 {
var v uint64
v, err = r.DecodeVarintSlow()
tag = uint32(v)
} else {
var v uint32
// we already checked the first byte
tag = uint32(buf[i]) & 127
i++
v = uint32(buf[i])
i++
tag |= (v & 127) << 7
if v < 128 {
goto done
}
v = uint32(buf[i])
i++
tag |= (v & 127) << 14
if v < 128 {
goto done
}
v = uint32(buf[i])
i++
tag |= (v & 127) << 21
if v < 128 {
goto done
}
v = uint32(buf[i])
i++
tag |= (v & 127) << 28
if v < 128 {
goto done
}
return nil, errOutOfBounds
done:
r.Pos = i
}
}
// DONE: tag, err = r.DecodeVarint32()
fieldNum := protoFieldNumber(tag)
if fieldNum < lastProtoFieldNum {
outOfOrder = true
}
// Skip the current value -- will skip over an entire group as well.
// INLINED: err = r.SkipValue(tag)
wireType := tag & 0x7
switch protowire.Type(wireType) {
case protowire.VarintType:
// INLINED: err = r.SkipVarint()
i := r.Pos
if len(r.Buf)-i < 10 {
// Use DecodeVarintSlow() to skip while
// checking for buffer overflow, but ignore result
_, err = r.DecodeVarintSlow()
goto out2
}
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
i++
if r.Buf[i] < 0x80 {
goto out
}
return nil, errOverflow
out:
r.Pos = i + 1
// DONE: err = r.SkipVarint()
case protowire.Fixed64Type:
err = r.SkipFixed64()
case protowire.BytesType:
var n uint32
n, err = r.DecodeVarint32()
if err == nil {
err = r.Skip(int(n))
}
case protowire.StartGroupType:
err = r.SkipGroup(tag)
case protowire.Fixed32Type:
err = r.SkipFixed32()
default:
err = fmt.Errorf("Unexpected wire type (%d)", wireType)
}
// DONE: err = r.SkipValue(tag)
out2:
if err != nil {
return nil, err
}
if fieldNum != lastProtoFieldNum {
index = append(index, IndexEntry{FieldNum: fieldNum,
Start: uint32(curPos),
End: uint32(r.Pos)},
)
} else {
index[len(index)-1].End = uint32(r.Pos)
index[len(index)-1].MultipleContiguous = true
}
lastProtoFieldNum = fieldNum
}
if outOfOrder {
sort.Slice(index, func(i, j int) bool {
return index[i].FieldNum < index[j].FieldNum ||
(index[i].FieldNum == index[j].FieldNum &&
index[i].Start < index[j].Start)
})
}
return index, nil
}
func (lazy *XXX_lazyUnmarshalInfo) SizeField(num uint32) (size int) {
start, end, found, _, multipleEntries := lazy.FindFieldInProto(num)
if multipleEntries != nil {
for _, entry := range multipleEntries {
size += int(entry.End - entry.Start)
}
return size
}
if !found {
return 0
}
return int(end - start)
}
func (lazy *XXX_lazyUnmarshalInfo) AppendField(b []byte, num uint32) ([]byte, bool) {
start, end, found, _, multipleEntries := lazy.FindFieldInProto(num)
if multipleEntries != nil {
for _, entry := range multipleEntries {
b = append(b, lazy.Protobuf[entry.Start:entry.End]...)
}
return b, true
}
if !found {
return nil, false
}
b = append(b, lazy.Protobuf[start:end]...)
return b, true
}
func (lazy *XXX_lazyUnmarshalInfo) SetIndex(index []IndexEntry) {
atomicStoreIndex(&lazy.index, &index)
}
// FindFieldInProto looks for field fieldNum in lazyUnmarshalInfo information
// (including protobuf), returns startOffset/endOffset/found.
func (lazy *XXX_lazyUnmarshalInfo) FindFieldInProto(fieldNum uint32) (start, end uint32, found, multipleContiguous bool, multipleEntries []IndexEntry) {
if lazy.Protobuf == nil {
// There is no backing protobuf for this message -- it was made from a builder
return 0, 0, false, false, nil
}
index := atomicLoadIndex(&lazy.index)
if index == nil {
r, err := buildIndex(lazy.Protobuf)
if err != nil {
panic(fmt.Sprintf("findFieldInfo: error building index when looking for field %d: %v", fieldNum, err))
}
// lazy.index is a pointer to the slice returned by BuildIndex
index = &r
atomicStoreIndex(&lazy.index, index)
}
return lookupField(index, fieldNum)
}
// lookupField returns the offset at which the indicated field starts using
// the index, offset immediately after field ends (including all instances of
// a repeated field), and bools indicating if field was found and if there
// are multiple encodings of the field in the byte range.
//
// To hande the uncommon case where there are repeated encodings for the same
// field which are not consecutive in the protobuf (so we need to returns
// multiple start/end offsets), we also return a slice multipleEntries. If
// multipleEntries is non-nil, then multiple entries were found, and the
// values in the slice should be used, rather than start/end/found.
func lookupField(indexp *[]IndexEntry, fieldNum uint32) (start, end uint32, found bool, multipleContiguous bool, multipleEntries []IndexEntry) {
// The pointer indexp to the index was already loaded atomically.
// The slice is uniquely associated with the pointer, so it doesn't
// need to be loaded atomically.
index := *indexp
for i, entry := range index {
if fieldNum == entry.FieldNum {
if i < len(index)-1 && entry.FieldNum == index[i+1].FieldNum {
// Handle the uncommon case where there are
// repeated entries for the same field which
// are not contiguous in the protobuf.
multiple := make([]IndexEntry, 1, 2)
multiple[0] = IndexEntry{fieldNum, entry.Start, entry.End, entry.MultipleContiguous}
i++
for i < len(index) && index[i].FieldNum == fieldNum {
multiple = append(multiple, IndexEntry{fieldNum, index[i].Start, index[i].End, index[i].MultipleContiguous})
i++
}
return 0, 0, false, false, multiple
}
return entry.Start, entry.End, true, entry.MultipleContiguous, nil
}
if fieldNum < entry.FieldNum {
return 0, 0, false, false, nil
}
}
return 0, 0, false, false, nil
}
// Copyright 2024 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 protolazy
import (
"sync/atomic"
"unsafe"
)
func atomicLoadIndex(p **[]IndexEntry) *[]IndexEntry {
return (*[]IndexEntry)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func atomicStoreIndex(p **[]IndexEntry, v *[]IndexEntry) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
}
// Copyright 2018 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 set provides simple set data structures for uint64s.
package set
import "math/bits"
// int64s represents a set of integers within the range of 0..63.
type int64s uint64
func (bs *int64s) Len() int {
return bits.OnesCount64(uint64(*bs))
}
func (bs *int64s) Has(n uint64) bool {
return uint64(*bs)&(uint64(1)<<n) > 0
}
func (bs *int64s) Set(n uint64) {
*(*uint64)(bs) |= uint64(1) << n
}
func (bs *int64s) Clear(n uint64) {
*(*uint64)(bs) &^= uint64(1) << n
}
// Ints represents a set of integers within the range of 0..math.MaxUint64.
type Ints struct {
lo int64s
hi map[uint64]struct{}
}
func (bs *Ints) Len() int {
return bs.lo.Len() + len(bs.hi)
}
func (bs *Ints) Has(n uint64) bool {
if n < 64 {
return bs.lo.Has(n)
}
_, ok := bs.hi[n]
return ok
}
func (bs *Ints) Set(n uint64) {
if n < 64 {
bs.lo.Set(n)
return
}
if bs.hi == nil {
bs.hi = make(map[uint64]struct{})
}
bs.hi[n] = struct{}{}
}
func (bs *Ints) Clear(n uint64) {
if n < 64 {
bs.lo.Clear(n)
return
}
delete(bs.hi, n)
}
// 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 strs provides string manipulation functionality specific to protobuf.
package strs
import (
"go/token"
"strings"
"unicode"
"unicode/utf8"
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/reflect/protoreflect"
)
// EnforceUTF8 reports whether to enforce strict UTF-8 validation.
func EnforceUTF8(fd protoreflect.FieldDescriptor) bool {
if flags.ProtoLegacy || fd.Syntax() == protoreflect.Editions {
if fd, ok := fd.(interface{ EnforceUTF8() bool }); ok {
return fd.EnforceUTF8()
}
}
return fd.Syntax() == protoreflect.Proto3
}
// GoCamelCase camel-cases a protobuf name for use as a Go identifier.
//
// If there is an interior underscore followed by a lower case letter,
// drop the underscore and convert the letter to upper case.
func GoCamelCase(s string) string {
// Invariant: if the next letter is lower case, it must be converted
// to upper case.
// That is, we process a word at a time, where words are marked by _ or
// upper case letter. Digits are treated as words.
var b []byte
for i := 0; i < len(s); i++ {
c := s[i]
switch {
case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
// Skip over '.' in ".{{lowercase}}".
case c == '.':
b = append(b, '_') // convert '.' to '_'
case c == '_' && (i == 0 || s[i-1] == '.'):
// Convert initial '_' to ensure we start with a capital letter.
// Do the same for '_' after '.' to match historic behavior.
b = append(b, 'X') // convert '_' to 'X'
case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
// Skip over '_' in "_{{lowercase}}".
case isASCIIDigit(c):
b = append(b, c)
default:
// Assume we have a letter now - if not, it's a bogus identifier.
// The next word is a sequence of characters that must start upper case.
if isASCIILower(c) {
c -= 'a' - 'A' // convert lowercase to uppercase
}
b = append(b, c)
// Accept lower case sequence that follows.
for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
b = append(b, s[i+1])
}
}
}
return string(b)
}
// GoSanitized converts a string to a valid Go identifier.
func GoSanitized(s string) string {
// Sanitize the input to the set of valid characters,
// which must be '_' or be in the Unicode L or N categories.
s = strings.Map(func(r rune) rune {
if unicode.IsLetter(r) || unicode.IsDigit(r) {
return r
}
return '_'
}, s)
// Prepend '_' in the event of a Go keyword conflict or if
// the identifier is invalid (does not start in the Unicode L category).
r, _ := utf8.DecodeRuneInString(s)
if token.Lookup(s).IsKeyword() || !unicode.IsLetter(r) {
return "_" + s
}
return s
}
// JSONCamelCase converts a snake_case identifier to a camelCase identifier,
// according to the protobuf JSON specification.
func JSONCamelCase(s string) string {
var b []byte
var wasUnderscore bool
for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
c := s[i]
if c != '_' {
if wasUnderscore && isASCIILower(c) {
c -= 'a' - 'A' // convert to uppercase
}
b = append(b, c)
}
wasUnderscore = c == '_'
}
return string(b)
}
// JSONSnakeCase converts a camelCase identifier to a snake_case identifier,
// according to the protobuf JSON specification.
func JSONSnakeCase(s string) string {
var b []byte
for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
c := s[i]
if isASCIIUpper(c) {
b = append(b, '_')
c += 'a' - 'A' // convert to lowercase
}
b = append(b, c)
}
return string(b)
}
// MapEntryName derives the name of the map entry message given the field name.
// See protoc v3.8.0: src/google/protobuf/descriptor.cc:254-276,6057
func MapEntryName(s string) string {
var b []byte
upperNext := true
for _, c := range s {
switch {
case c == '_':
upperNext = true
case upperNext:
b = append(b, byte(unicode.ToUpper(c)))
upperNext = false
default:
b = append(b, byte(c))
}
}
b = append(b, "Entry"...)
return string(b)
}
// EnumValueName derives the camel-cased enum value name.
// See protoc v3.8.0: src/google/protobuf/descriptor.cc:297-313
func EnumValueName(s string) string {
var b []byte
upperNext := true
for _, c := range s {
switch {
case c == '_':
upperNext = true
case upperNext:
b = append(b, byte(unicode.ToUpper(c)))
upperNext = false
default:
b = append(b, byte(unicode.ToLower(c)))
upperNext = false
}
}
return string(b)
}
// TrimEnumPrefix trims the enum name prefix from an enum value name,
// where the prefix is all lowercase without underscores.
// See protoc v3.8.0: src/google/protobuf/descriptor.cc:330-375
func TrimEnumPrefix(s, prefix string) string {
s0 := s // original input
for len(s) > 0 && len(prefix) > 0 {
if s[0] == '_' {
s = s[1:]
continue
}
if unicode.ToLower(rune(s[0])) != rune(prefix[0]) {
return s0 // no prefix match
}
s, prefix = s[1:], prefix[1:]
}
if len(prefix) > 0 {
return s0 // no prefix match
}
s = strings.TrimLeft(s, "_")
if len(s) == 0 {
return s0 // avoid returning empty string
}
return s
}
func isASCIILower(c byte) bool {
return 'a' <= c && c <= 'z'
}
func isASCIIUpper(c byte) bool {
return 'A' <= c && c <= 'Z'
}
func isASCIIDigit(c byte) bool {
return '0' <= c && c <= '9'
}
// Copyright 2018 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 strs
import (
"unsafe"
"google.golang.org/protobuf/reflect/protoreflect"
)
// UnsafeString returns an unsafe string reference of b.
// The caller must treat the input slice as immutable.
//
// WARNING: Use carefully. The returned result must not leak to the end user
// unless the input slice is provably immutable.
func UnsafeString(b []byte) string {
return unsafe.String(unsafe.SliceData(b), len(b))
}
// UnsafeBytes returns an unsafe bytes slice reference of s.
// The caller must treat returned slice as immutable.
//
// WARNING: Use carefully. The returned result must not leak to the end user.
func UnsafeBytes(s string) []byte {
return unsafe.Slice(unsafe.StringData(s), len(s))
}
// Builder builds a set of strings with shared lifetime.
// This differs from strings.Builder, which is for building a single string.
type Builder struct {
buf []byte
}
// AppendFullName is equivalent to protoreflect.FullName.Append,
// but optimized for large batches where each name has a shared lifetime.
func (sb *Builder) AppendFullName(prefix protoreflect.FullName, name protoreflect.Name) protoreflect.FullName {
n := len(prefix) + len(".") + len(name)
if len(prefix) == 0 {
n -= len(".")
}
sb.grow(n)
sb.buf = append(sb.buf, prefix...)
sb.buf = append(sb.buf, '.')
sb.buf = append(sb.buf, name...)
return protoreflect.FullName(sb.last(n))
}
// MakeString is equivalent to string(b), but optimized for large batches
// with a shared lifetime.
func (sb *Builder) MakeString(b []byte) string {
sb.grow(len(b))
sb.buf = append(sb.buf, b...)
return sb.last(len(b))
}
func (sb *Builder) grow(n int) {
if cap(sb.buf)-len(sb.buf) >= n {
return
}
// Unlike strings.Builder, we do not need to copy over the contents
// of the old buffer since our builder provides no API for
// retrieving previously created strings.
sb.buf = make([]byte, 0, 2*(cap(sb.buf)+n))
}
func (sb *Builder) last(n int) string {
return UnsafeString(sb.buf[len(sb.buf)-n:])
}
// Copyright 2021 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/enums/enums.proto
package enums
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type Enum int32
const (
Enum_DEFAULT Enum = 1337
Enum_ZERO Enum = 0
Enum_ONE Enum = 1
Enum_ELEVENT Enum = 11
Enum_SEVENTEEN Enum = 17
Enum_THIRTYSEVEN Enum = 37
Enum_SIXTYSEVEN Enum = 67
Enum_NEGATIVE Enum = -1
)
// Enum value maps for Enum.
var (
Enum_name = map[int32]string{
1337: "DEFAULT",
0: "ZERO",
1: "ONE",
11: "ELEVENT",
17: "SEVENTEEN",
37: "THIRTYSEVEN",
67: "SIXTYSEVEN",
-1: "NEGATIVE",
}
Enum_value = map[string]int32{
"DEFAULT": 1337,
"ZERO": 0,
"ONE": 1,
"ELEVENT": 11,
"SEVENTEEN": 17,
"THIRTYSEVEN": 37,
"SIXTYSEVEN": 67,
"NEGATIVE": -1,
}
)
func (x Enum) Enum() *Enum {
p := new(Enum)
*p = x
return p
}
func (x Enum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Enum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_enums_enums_proto_enumTypes[0].Descriptor()
}
func (Enum) Type() protoreflect.EnumType {
return &file_internal_testprotos_enums_enums_proto_enumTypes[0]
}
func (x Enum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use Enum.Descriptor instead.
func (Enum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_enums_enums_proto_rawDescGZIP(), []int{0}
}
var File_internal_testprotos_enums_enums_proto protoreflect.FileDescriptor
const file_internal_testprotos_enums_enums_proto_rawDesc = "" +
"\n" +
"%internal/testprotos/enums/enums.proto\x12\x13goproto.proto.enums*{\n" +
"\x04Enum\x12\f\n" +
"\aDEFAULT\x10\xb9\n" +
"\x12\b\n" +
"\x04ZERO\x10\x00\x12\a\n" +
"\x03ONE\x10\x01\x12\v\n" +
"\aELEVENT\x10\v\x12\r\n" +
"\tSEVENTEEN\x10\x11\x12\x0f\n" +
"\vTHIRTYSEVEN\x10%\x12\x0e\n" +
"\n" +
"SIXTYSEVEN\x10C\x12\x15\n" +
"\bNEGATIVE\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01B;Z4google.golang.org/protobuf/internal/testprotos/enums\x92\x03\x02\x10\x02b\beditionsp\xe8\a"
var (
file_internal_testprotos_enums_enums_proto_rawDescOnce sync.Once
file_internal_testprotos_enums_enums_proto_rawDescData []byte
)
func file_internal_testprotos_enums_enums_proto_rawDescGZIP() []byte {
file_internal_testprotos_enums_enums_proto_rawDescOnce.Do(func() {
file_internal_testprotos_enums_enums_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_enums_enums_proto_rawDesc), len(file_internal_testprotos_enums_enums_proto_rawDesc)))
})
return file_internal_testprotos_enums_enums_proto_rawDescData
}
var file_internal_testprotos_enums_enums_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_internal_testprotos_enums_enums_proto_goTypes = []any{
(Enum)(0), // 0: goproto.proto.enums.Enum
}
var file_internal_testprotos_enums_enums_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_internal_testprotos_enums_enums_proto_init() }
func file_internal_testprotos_enums_enums_proto_init() {
if File_internal_testprotos_enums_enums_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_enums_enums_proto_rawDesc), len(file_internal_testprotos_enums_enums_proto_rawDesc)),
NumEnums: 1,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_enums_enums_proto_goTypes,
DependencyIndexes: file_internal_testprotos_enums_enums_proto_depIdxs,
EnumInfos: file_internal_testprotos_enums_enums_proto_enumTypes,
}.Build()
File_internal_testprotos_enums_enums_proto = out.File
file_internal_testprotos_enums_enums_proto_goTypes = nil
file_internal_testprotos_enums_enums_proto_depIdxs = nil
}
// 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/fuzz/fuzz.proto
package fuzz
import (
test "google.golang.org/protobuf/internal/testprotos/test"
test3 "google.golang.org/protobuf/internal/testprotos/test3"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
// Fuzz is a container for every message we want to make available to the
// fuzzer.
type Fuzz struct {
state protoimpl.MessageState `protogen:"open.v1"`
TestAllTypes *test.TestAllTypes `protobuf:"bytes,1,opt,name=test_all_types,json=testAllTypes" json:"test_all_types,omitempty"`
TestAllExtensions *test.TestAllExtensions `protobuf:"bytes,2,opt,name=test_all_extensions,json=testAllExtensions" json:"test_all_extensions,omitempty"`
TestRequired *test.TestRequired `protobuf:"bytes,3,opt,name=test_required,json=testRequired" json:"test_required,omitempty"`
TestRequiredForeign *test.TestRequiredForeign `protobuf:"bytes,4,opt,name=test_required_foreign,json=testRequiredForeign" json:"test_required_foreign,omitempty"`
TestRequiredGroupFields *test.TestRequiredGroupFields `protobuf:"bytes,5,opt,name=test_required_group_fields,json=testRequiredGroupFields" json:"test_required_group_fields,omitempty"`
TestPackedTypes *test.TestPackedTypes `protobuf:"bytes,6,opt,name=test_packed_types,json=testPackedTypes" json:"test_packed_types,omitempty"`
TestPackedExtensions *test.TestPackedExtensions `protobuf:"bytes,7,opt,name=test_packed_extensions,json=testPackedExtensions" json:"test_packed_extensions,omitempty"`
TestAllTypes3 *test3.TestAllTypes `protobuf:"bytes,8,opt,name=test_all_types3,json=testAllTypes3" json:"test_all_types3,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Fuzz) Reset() {
*x = Fuzz{}
mi := &file_internal_testprotos_fuzz_fuzz_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Fuzz) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Fuzz) ProtoMessage() {}
func (x *Fuzz) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_fuzz_fuzz_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Fuzz.ProtoReflect.Descriptor instead.
func (*Fuzz) Descriptor() ([]byte, []int) {
return file_internal_testprotos_fuzz_fuzz_proto_rawDescGZIP(), []int{0}
}
func (x *Fuzz) GetTestAllTypes() *test.TestAllTypes {
if x != nil {
return x.TestAllTypes
}
return nil
}
func (x *Fuzz) GetTestAllExtensions() *test.TestAllExtensions {
if x != nil {
return x.TestAllExtensions
}
return nil
}
func (x *Fuzz) GetTestRequired() *test.TestRequired {
if x != nil {
return x.TestRequired
}
return nil
}
func (x *Fuzz) GetTestRequiredForeign() *test.TestRequiredForeign {
if x != nil {
return x.TestRequiredForeign
}
return nil
}
func (x *Fuzz) GetTestRequiredGroupFields() *test.TestRequiredGroupFields {
if x != nil {
return x.TestRequiredGroupFields
}
return nil
}
func (x *Fuzz) GetTestPackedTypes() *test.TestPackedTypes {
if x != nil {
return x.TestPackedTypes
}
return nil
}
func (x *Fuzz) GetTestPackedExtensions() *test.TestPackedExtensions {
if x != nil {
return x.TestPackedExtensions
}
return nil
}
func (x *Fuzz) GetTestAllTypes3() *test3.TestAllTypes {
if x != nil {
return x.TestAllTypes3
}
return nil
}
var File_internal_testprotos_fuzz_fuzz_proto protoreflect.FileDescriptor
const file_internal_testprotos_fuzz_fuzz_proto_rawDesc = "" +
"\n" +
"#internal/testprotos/fuzz/fuzz.proto\x12\x12goproto.proto.fuzz\x1a#internal/testprotos/test/test.proto\x1a$internal/testprotos/test3/test.proto\"\xaf\x05\n" +
"\x04Fuzz\x12F\n" +
"\x0etest_all_types\x18\x01 \x01(\v2 .goproto.proto.test.TestAllTypesR\ftestAllTypes\x12U\n" +
"\x13test_all_extensions\x18\x02 \x01(\v2%.goproto.proto.test.TestAllExtensionsR\x11testAllExtensions\x12E\n" +
"\rtest_required\x18\x03 \x01(\v2 .goproto.proto.test.TestRequiredR\ftestRequired\x12[\n" +
"\x15test_required_foreign\x18\x04 \x01(\v2'.goproto.proto.test.TestRequiredForeignR\x13testRequiredForeign\x12h\n" +
"\x1atest_required_group_fields\x18\x05 \x01(\v2+.goproto.proto.test.TestRequiredGroupFieldsR\x17testRequiredGroupFields\x12O\n" +
"\x11test_packed_types\x18\x06 \x01(\v2#.goproto.proto.test.TestPackedTypesR\x0ftestPackedTypes\x12^\n" +
"\x16test_packed_extensions\x18\a \x01(\v2(.goproto.proto.test.TestPackedExtensionsR\x14testPackedExtensions\x12I\n" +
"\x0ftest_all_types3\x18\b \x01(\v2!.goproto.proto.test3.TestAllTypesR\rtestAllTypes3B5Z3google.golang.org/protobuf/internal/testprotos/fuzz"
var (
file_internal_testprotos_fuzz_fuzz_proto_rawDescOnce sync.Once
file_internal_testprotos_fuzz_fuzz_proto_rawDescData []byte
)
func file_internal_testprotos_fuzz_fuzz_proto_rawDescGZIP() []byte {
file_internal_testprotos_fuzz_fuzz_proto_rawDescOnce.Do(func() {
file_internal_testprotos_fuzz_fuzz_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_fuzz_fuzz_proto_rawDesc), len(file_internal_testprotos_fuzz_fuzz_proto_rawDesc)))
})
return file_internal_testprotos_fuzz_fuzz_proto_rawDescData
}
var file_internal_testprotos_fuzz_fuzz_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_internal_testprotos_fuzz_fuzz_proto_goTypes = []any{
(*Fuzz)(nil), // 0: goproto.proto.fuzz.Fuzz
(*test.TestAllTypes)(nil), // 1: goproto.proto.test.TestAllTypes
(*test.TestAllExtensions)(nil), // 2: goproto.proto.test.TestAllExtensions
(*test.TestRequired)(nil), // 3: goproto.proto.test.TestRequired
(*test.TestRequiredForeign)(nil), // 4: goproto.proto.test.TestRequiredForeign
(*test.TestRequiredGroupFields)(nil), // 5: goproto.proto.test.TestRequiredGroupFields
(*test.TestPackedTypes)(nil), // 6: goproto.proto.test.TestPackedTypes
(*test.TestPackedExtensions)(nil), // 7: goproto.proto.test.TestPackedExtensions
(*test3.TestAllTypes)(nil), // 8: goproto.proto.test3.TestAllTypes
}
var file_internal_testprotos_fuzz_fuzz_proto_depIdxs = []int32{
1, // 0: goproto.proto.fuzz.Fuzz.test_all_types:type_name -> goproto.proto.test.TestAllTypes
2, // 1: goproto.proto.fuzz.Fuzz.test_all_extensions:type_name -> goproto.proto.test.TestAllExtensions
3, // 2: goproto.proto.fuzz.Fuzz.test_required:type_name -> goproto.proto.test.TestRequired
4, // 3: goproto.proto.fuzz.Fuzz.test_required_foreign:type_name -> goproto.proto.test.TestRequiredForeign
5, // 4: goproto.proto.fuzz.Fuzz.test_required_group_fields:type_name -> goproto.proto.test.TestRequiredGroupFields
6, // 5: goproto.proto.fuzz.Fuzz.test_packed_types:type_name -> goproto.proto.test.TestPackedTypes
7, // 6: goproto.proto.fuzz.Fuzz.test_packed_extensions:type_name -> goproto.proto.test.TestPackedExtensions
8, // 7: goproto.proto.fuzz.Fuzz.test_all_types3:type_name -> goproto.proto.test3.TestAllTypes
8, // [8:8] is the sub-list for method output_type
8, // [8:8] is the sub-list for method input_type
8, // [8:8] is the sub-list for extension type_name
8, // [8:8] is the sub-list for extension extendee
0, // [0:8] is the sub-list for field type_name
}
func init() { file_internal_testprotos_fuzz_fuzz_proto_init() }
func file_internal_testprotos_fuzz_fuzz_proto_init() {
if File_internal_testprotos_fuzz_fuzz_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_fuzz_fuzz_proto_rawDesc), len(file_internal_testprotos_fuzz_fuzz_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_fuzz_fuzz_proto_goTypes,
DependencyIndexes: file_internal_testprotos_fuzz_fuzz_proto_depIdxs,
MessageInfos: file_internal_testprotos_fuzz_fuzz_proto_msgTypes,
}.Build()
File_internal_testprotos_fuzz_fuzz_proto = out.File
file_internal_testprotos_fuzz_fuzz_proto_goTypes = nil
file_internal_testprotos_fuzz_fuzz_proto_depIdxs = nil
}
// Copyright 2020 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/required/required.proto
package required
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type Int32 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *int32 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Int32) Reset() {
*x = Int32{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Int32) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Int32) ProtoMessage() {}
func (x *Int32) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Int32.ProtoReflect.Descriptor instead.
func (*Int32) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{0}
}
func (x *Int32) GetV() int32 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Int64 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *int64 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Int64) Reset() {
*x = Int64{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Int64) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Int64) ProtoMessage() {}
func (x *Int64) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Int64.ProtoReflect.Descriptor instead.
func (*Int64) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{1}
}
func (x *Int64) GetV() int64 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Uint32 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *uint32 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Uint32) Reset() {
*x = Uint32{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Uint32) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Uint32) ProtoMessage() {}
func (x *Uint32) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Uint32.ProtoReflect.Descriptor instead.
func (*Uint32) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{2}
}
func (x *Uint32) GetV() uint32 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Uint64 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *uint64 `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Uint64) Reset() {
*x = Uint64{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Uint64) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Uint64) ProtoMessage() {}
func (x *Uint64) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Uint64.ProtoReflect.Descriptor instead.
func (*Uint64) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{3}
}
func (x *Uint64) GetV() uint64 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Sint32 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *int32 `protobuf:"zigzag32,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Sint32) Reset() {
*x = Sint32{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Sint32) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Sint32) ProtoMessage() {}
func (x *Sint32) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Sint32.ProtoReflect.Descriptor instead.
func (*Sint32) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{4}
}
func (x *Sint32) GetV() int32 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Sint64 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *int64 `protobuf:"zigzag64,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Sint64) Reset() {
*x = Sint64{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Sint64) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Sint64) ProtoMessage() {}
func (x *Sint64) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[5]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Sint64.ProtoReflect.Descriptor instead.
func (*Sint64) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{5}
}
func (x *Sint64) GetV() int64 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Fixed32 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *uint32 `protobuf:"fixed32,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Fixed32) Reset() {
*x = Fixed32{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Fixed32) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Fixed32) ProtoMessage() {}
func (x *Fixed32) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[6]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Fixed32.ProtoReflect.Descriptor instead.
func (*Fixed32) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{6}
}
func (x *Fixed32) GetV() uint32 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Fixed64 struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *uint64 `protobuf:"fixed64,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Fixed64) Reset() {
*x = Fixed64{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Fixed64) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Fixed64) ProtoMessage() {}
func (x *Fixed64) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[7]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Fixed64.ProtoReflect.Descriptor instead.
func (*Fixed64) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{7}
}
func (x *Fixed64) GetV() uint64 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Float struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *float32 `protobuf:"fixed32,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Float) Reset() {
*x = Float{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Float) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Float) ProtoMessage() {}
func (x *Float) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[8]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Float.ProtoReflect.Descriptor instead.
func (*Float) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{8}
}
func (x *Float) GetV() float32 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Double struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *float64 `protobuf:"fixed64,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Double) Reset() {
*x = Double{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Double) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Double) ProtoMessage() {}
func (x *Double) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[9]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Double.ProtoReflect.Descriptor instead.
func (*Double) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{9}
}
func (x *Double) GetV() float64 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
type Bool struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *bool `protobuf:"varint,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Bool) Reset() {
*x = Bool{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Bool) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Bool) ProtoMessage() {}
func (x *Bool) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[10]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Bool.ProtoReflect.Descriptor instead.
func (*Bool) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{10}
}
func (x *Bool) GetV() bool {
if x != nil && x.V != nil {
return *x.V
}
return false
}
type String struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *string `protobuf:"bytes,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *String) Reset() {
*x = String{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *String) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*String) ProtoMessage() {}
func (x *String) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[11]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use String.ProtoReflect.Descriptor instead.
func (*String) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{11}
}
func (x *String) GetV() string {
if x != nil && x.V != nil {
return *x.V
}
return ""
}
type Bytes struct {
state protoimpl.MessageState `protogen:"open.v1"`
V []byte `protobuf:"bytes,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Bytes) Reset() {
*x = Bytes{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Bytes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Bytes) ProtoMessage() {}
func (x *Bytes) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[12]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Bytes.ProtoReflect.Descriptor instead.
func (*Bytes) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{12}
}
func (x *Bytes) GetV() []byte {
if x != nil {
return x.V
}
return nil
}
type Message struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *Message_M `protobuf:"bytes,1,req,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Message) Reset() {
*x = Message{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Message) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Message) ProtoMessage() {}
func (x *Message) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[13]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Message.ProtoReflect.Descriptor instead.
func (*Message) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{13}
}
func (x *Message) GetV() *Message_M {
if x != nil {
return x.V
}
return nil
}
type Group struct {
state protoimpl.MessageState `protogen:"open.v1"`
Group *Group_Group `protobuf:"group,1,req,name=Group,json=group" json:"group,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Group) Reset() {
*x = Group{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Group) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Group) ProtoMessage() {}
func (x *Group) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[14]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Group.ProtoReflect.Descriptor instead.
func (*Group) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{14}
}
func (x *Group) GetGroup() *Group_Group {
if x != nil {
return x.Group
}
return nil
}
type Message_M struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Message_M) Reset() {
*x = Message_M{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Message_M) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Message_M) ProtoMessage() {}
func (x *Message_M) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[15]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Message_M.ProtoReflect.Descriptor instead.
func (*Message_M) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{13, 0}
}
type Group_Group struct {
state protoimpl.MessageState `protogen:"open.v1"`
V *int32 `protobuf:"varint,1,opt,name=v" json:"v,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Group_Group) Reset() {
*x = Group_Group{}
mi := &file_internal_testprotos_required_required_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Group_Group) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Group_Group) ProtoMessage() {}
func (x *Group_Group) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_required_required_proto_msgTypes[16]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Group_Group.ProtoReflect.Descriptor instead.
func (*Group_Group) Descriptor() ([]byte, []int) {
return file_internal_testprotos_required_required_proto_rawDescGZIP(), []int{14, 0}
}
func (x *Group_Group) GetV() int32 {
if x != nil && x.V != nil {
return *x.V
}
return 0
}
var File_internal_testprotos_required_required_proto protoreflect.FileDescriptor
const file_internal_testprotos_required_required_proto_rawDesc = "" +
"\n" +
"+internal/testprotos/required/required.proto\x12\x1agoproto.proto.testrequired\"\x1c\n" +
"\x05Int32\x12\x13\n" +
"\x01v\x18\x01 \x01(\x05B\x05\xaa\x01\x02\b\x03R\x01v\"\x1c\n" +
"\x05Int64\x12\x13\n" +
"\x01v\x18\x01 \x01(\x03B\x05\xaa\x01\x02\b\x03R\x01v\"\x1d\n" +
"\x06Uint32\x12\x13\n" +
"\x01v\x18\x01 \x01(\rB\x05\xaa\x01\x02\b\x03R\x01v\"\x1d\n" +
"\x06Uint64\x12\x13\n" +
"\x01v\x18\x01 \x01(\x04B\x05\xaa\x01\x02\b\x03R\x01v\"\x1d\n" +
"\x06Sint32\x12\x13\n" +
"\x01v\x18\x01 \x01(\x11B\x05\xaa\x01\x02\b\x03R\x01v\"\x1d\n" +
"\x06Sint64\x12\x13\n" +
"\x01v\x18\x01 \x01(\x12B\x05\xaa\x01\x02\b\x03R\x01v\"\x1e\n" +
"\aFixed32\x12\x13\n" +
"\x01v\x18\x01 \x01(\aB\x05\xaa\x01\x02\b\x03R\x01v\"\x1e\n" +
"\aFixed64\x12\x13\n" +
"\x01v\x18\x01 \x01(\x06B\x05\xaa\x01\x02\b\x03R\x01v\"\x1c\n" +
"\x05Float\x12\x13\n" +
"\x01v\x18\x01 \x01(\x02B\x05\xaa\x01\x02\b\x03R\x01v\"\x1d\n" +
"\x06Double\x12\x13\n" +
"\x01v\x18\x01 \x01(\x01B\x05\xaa\x01\x02\b\x03R\x01v\"\x1b\n" +
"\x04Bool\x12\x13\n" +
"\x01v\x18\x01 \x01(\bB\x05\xaa\x01\x02\b\x03R\x01v\"\x1d\n" +
"\x06String\x12\x13\n" +
"\x01v\x18\x01 \x01(\tB\x05\xaa\x01\x02\b\x03R\x01v\"\x1c\n" +
"\x05Bytes\x12\x13\n" +
"\x01v\x18\x01 \x01(\fB\x05\xaa\x01\x02\b\x03R\x01v\"J\n" +
"\aMessage\x12:\n" +
"\x01v\x18\x01 \x01(\v2%.goproto.proto.testrequired.Message.MB\x05\xaa\x01\x02\b\x03R\x01v\x1a\x03\n" +
"\x01M\"f\n" +
"\x05Group\x12F\n" +
"\x05group\x18\x01 \x01(\v2'.goproto.proto.testrequired.Group.GroupB\a\xaa\x01\x04\b\x03(\x02R\x05group\x1a\x15\n" +
"\x05Group\x12\f\n" +
"\x01v\x18\x01 \x01(\x05R\x01vB9Z7google.golang.org/protobuf/internal/testprotos/requiredb\beditionsp\xe8\a"
var (
file_internal_testprotos_required_required_proto_rawDescOnce sync.Once
file_internal_testprotos_required_required_proto_rawDescData []byte
)
func file_internal_testprotos_required_required_proto_rawDescGZIP() []byte {
file_internal_testprotos_required_required_proto_rawDescOnce.Do(func() {
file_internal_testprotos_required_required_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_required_required_proto_rawDesc), len(file_internal_testprotos_required_required_proto_rawDesc)))
})
return file_internal_testprotos_required_required_proto_rawDescData
}
var file_internal_testprotos_required_required_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
var file_internal_testprotos_required_required_proto_goTypes = []any{
(*Int32)(nil), // 0: goproto.proto.testrequired.Int32
(*Int64)(nil), // 1: goproto.proto.testrequired.Int64
(*Uint32)(nil), // 2: goproto.proto.testrequired.Uint32
(*Uint64)(nil), // 3: goproto.proto.testrequired.Uint64
(*Sint32)(nil), // 4: goproto.proto.testrequired.Sint32
(*Sint64)(nil), // 5: goproto.proto.testrequired.Sint64
(*Fixed32)(nil), // 6: goproto.proto.testrequired.Fixed32
(*Fixed64)(nil), // 7: goproto.proto.testrequired.Fixed64
(*Float)(nil), // 8: goproto.proto.testrequired.Float
(*Double)(nil), // 9: goproto.proto.testrequired.Double
(*Bool)(nil), // 10: goproto.proto.testrequired.Bool
(*String)(nil), // 11: goproto.proto.testrequired.String
(*Bytes)(nil), // 12: goproto.proto.testrequired.Bytes
(*Message)(nil), // 13: goproto.proto.testrequired.Message
(*Group)(nil), // 14: goproto.proto.testrequired.Group
(*Message_M)(nil), // 15: goproto.proto.testrequired.Message.M
(*Group_Group)(nil), // 16: goproto.proto.testrequired.Group.Group
}
var file_internal_testprotos_required_required_proto_depIdxs = []int32{
15, // 0: goproto.proto.testrequired.Message.v:type_name -> goproto.proto.testrequired.Message.M
16, // 1: goproto.proto.testrequired.Group.group:type_name -> goproto.proto.testrequired.Group.Group
2, // [2:2] is the sub-list for method output_type
2, // [2:2] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_internal_testprotos_required_required_proto_init() }
func file_internal_testprotos_required_required_proto_init() {
if File_internal_testprotos_required_required_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_required_required_proto_rawDesc), len(file_internal_testprotos_required_required_proto_rawDesc)),
NumEnums: 0,
NumMessages: 17,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_required_required_proto_goTypes,
DependencyIndexes: file_internal_testprotos_required_required_proto_depIdxs,
MessageInfos: file_internal_testprotos_required_required_proto_msgTypes,
}.Build()
File_internal_testprotos_required_required_proto = out.File
file_internal_testprotos_required_required_proto_goTypes = nil
file_internal_testprotos_required_required_proto_depIdxs = nil
}
// Copyright 2018 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test/ext.proto
package test
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
unsafe "unsafe"
)
var file_internal_testprotos_test_ext_proto_extTypes = []protoimpl.ExtensionInfo{
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 2000,
Name: "goproto.proto.test.foreign_int32_extension",
Tag: "varint,2000,opt,name=foreign_int32_extension",
Filename: "internal/testprotos/test/ext.proto",
},
}
// Extension fields to TestAllExtensions.
var (
// optional int32 foreign_int32_extension = 2000;
E_ForeignInt32Extension = &file_internal_testprotos_test_ext_proto_extTypes[0]
)
var File_internal_testprotos_test_ext_proto protoreflect.FileDescriptor
const file_internal_testprotos_test_ext_proto_rawDesc = "" +
"\n" +
"\"internal/testprotos/test/ext.proto\x12\x12goproto.proto.test\x1a#internal/testprotos/test/test.proto:^\n" +
"\x17foreign_int32_extension\x12%.goproto.proto.test.TestAllExtensions\x18\xd0\x0f \x01(\x05R\x15foreignInt32ExtensionB5Z3google.golang.org/protobuf/internal/testprotos/test"
var file_internal_testprotos_test_ext_proto_goTypes = []any{
(*TestAllExtensions)(nil), // 0: goproto.proto.test.TestAllExtensions
}
var file_internal_testprotos_test_ext_proto_depIdxs = []int32{
0, // 0: goproto.proto.test.foreign_int32_extension:extendee -> goproto.proto.test.TestAllExtensions
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
0, // [0:1] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test_ext_proto_init() }
func file_internal_testprotos_test_ext_proto_init() {
if File_internal_testprotos_test_ext_proto != nil {
return
}
file_internal_testprotos_test_test_proto_init()
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_ext_proto_rawDesc), len(file_internal_testprotos_test_ext_proto_rawDesc)),
NumEnums: 0,
NumMessages: 0,
NumExtensions: 1,
NumServices: 0,
},
GoTypes: file_internal_testprotos_test_ext_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test_ext_proto_depIdxs,
ExtensionInfos: file_internal_testprotos_test_ext_proto_extTypes,
}.Build()
File_internal_testprotos_test_ext_proto = out.File
file_internal_testprotos_test_ext_proto_goTypes = nil
file_internal_testprotos_test_ext_proto_depIdxs = nil
}
// Copyright 2018 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test/test.proto
package test
import (
enums "google.golang.org/protobuf/internal/testprotos/enums"
required "google.golang.org/protobuf/internal/testprotos/required"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type ForeignEnum int32
const (
ForeignEnum_FOREIGN_FOO ForeignEnum = 4
ForeignEnum_FOREIGN_BAR ForeignEnum = 5
ForeignEnum_FOREIGN_BAZ ForeignEnum = 6
)
// Enum value maps for ForeignEnum.
var (
ForeignEnum_name = map[int32]string{
4: "FOREIGN_FOO",
5: "FOREIGN_BAR",
6: "FOREIGN_BAZ",
}
ForeignEnum_value = map[string]int32{
"FOREIGN_FOO": 4,
"FOREIGN_BAR": 5,
"FOREIGN_BAZ": 6,
}
)
func (x ForeignEnum) Enum() *ForeignEnum {
p := new(ForeignEnum)
*p = x
return p
}
func (x ForeignEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ForeignEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test_test_proto_enumTypes[0].Descriptor()
}
func (ForeignEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test_test_proto_enumTypes[0]
}
func (x ForeignEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *ForeignEnum) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = ForeignEnum(num)
return nil
}
// Deprecated: Use ForeignEnum.Descriptor instead.
func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0}
}
type TestReservedEnumFields int32
const (
TestReservedEnumFields_RESERVED_ENUM TestReservedEnumFields = 0
)
// Enum value maps for TestReservedEnumFields.
var (
TestReservedEnumFields_name = map[int32]string{
0: "RESERVED_ENUM",
}
TestReservedEnumFields_value = map[string]int32{
"RESERVED_ENUM": 0,
}
)
func (x TestReservedEnumFields) Enum() *TestReservedEnumFields {
p := new(TestReservedEnumFields)
*p = x
return p
}
func (x TestReservedEnumFields) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (TestReservedEnumFields) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test_test_proto_enumTypes[1].Descriptor()
}
func (TestReservedEnumFields) Type() protoreflect.EnumType {
return &file_internal_testprotos_test_test_proto_enumTypes[1]
}
func (x TestReservedEnumFields) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *TestReservedEnumFields) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = TestReservedEnumFields(num)
return nil
}
// Deprecated: Use TestReservedEnumFields.Descriptor instead.
func (TestReservedEnumFields) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{1}
}
type TestAllTypes_NestedEnum int32
const (
TestAllTypes_FOO TestAllTypes_NestedEnum = 0
TestAllTypes_BAR TestAllTypes_NestedEnum = 1
TestAllTypes_BAZ TestAllTypes_NestedEnum = 2
TestAllTypes_NEG TestAllTypes_NestedEnum = -1 // Intentionally negative.
)
// Enum value maps for TestAllTypes_NestedEnum.
var (
TestAllTypes_NestedEnum_name = map[int32]string{
0: "FOO",
1: "BAR",
2: "BAZ",
-1: "NEG",
}
TestAllTypes_NestedEnum_value = map[string]int32{
"FOO": 0,
"BAR": 1,
"BAZ": 2,
"NEG": -1,
}
)
func (x TestAllTypes_NestedEnum) Enum() *TestAllTypes_NestedEnum {
p := new(TestAllTypes_NestedEnum)
*p = x
return p
}
func (x TestAllTypes_NestedEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (TestAllTypes_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test_test_proto_enumTypes[2].Descriptor()
}
func (TestAllTypes_NestedEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test_test_proto_enumTypes[2]
}
func (x TestAllTypes_NestedEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *TestAllTypes_NestedEnum) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = TestAllTypes_NestedEnum(num)
return nil
}
// Deprecated: Use TestAllTypes_NestedEnum.Descriptor instead.
func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 0}
}
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
type TestDeprecatedMessage_DeprecatedEnum int32
const (
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
TestDeprecatedMessage_DEPRECATED TestDeprecatedMessage_DeprecatedEnum = 0
)
// Enum value maps for TestDeprecatedMessage_DeprecatedEnum.
var (
TestDeprecatedMessage_DeprecatedEnum_name = map[int32]string{
0: "DEPRECATED",
}
TestDeprecatedMessage_DeprecatedEnum_value = map[string]int32{
"DEPRECATED": 0,
}
)
func (x TestDeprecatedMessage_DeprecatedEnum) Enum() *TestDeprecatedMessage_DeprecatedEnum {
p := new(TestDeprecatedMessage_DeprecatedEnum)
*p = x
return p
}
func (x TestDeprecatedMessage_DeprecatedEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (TestDeprecatedMessage_DeprecatedEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test_test_proto_enumTypes[3].Descriptor()
}
func (TestDeprecatedMessage_DeprecatedEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test_test_proto_enumTypes[3]
}
func (x TestDeprecatedMessage_DeprecatedEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *TestDeprecatedMessage_DeprecatedEnum) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = TestDeprecatedMessage_DeprecatedEnum(num)
return nil
}
// Deprecated: Use TestDeprecatedMessage_DeprecatedEnum.Descriptor instead.
func (TestDeprecatedMessage_DeprecatedEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{2, 0}
}
type TestAllTypes struct {
state protoimpl.MessageState `protogen:"open.v1"`
OptionalInt32 *int32 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
OptionalInt64 *int64 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
OptionalUint32 *uint32 `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
OptionalUint64 *uint64 `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
OptionalSint32 *int32 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
OptionalSint64 *int64 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
OptionalFixed32 *uint32 `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
OptionalFixed64 *uint64 `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
OptionalSfixed32 *int32 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
OptionalSfixed64 *int64 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
OptionalFloat *float32 `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
OptionalDouble *float64 `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
OptionalBool *bool `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
OptionalString *string `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
OptionalBytes []byte `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
Optionalgroup *TestAllTypes_OptionalGroup `protobuf:"group,16,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
OptionalForeignMessage *ForeignMessage `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage" json:"optional_foreign_message,omitempty"`
OptionalImportMessage *ImportMessage `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage" json:"optional_import_message,omitempty"`
OptionalNestedEnum *TestAllTypes_NestedEnum `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum" json:"optional_nested_enum,omitempty"`
OptionalForeignEnum *ForeignEnum `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,enum=goproto.proto.test.ForeignEnum" json:"optional_foreign_enum,omitempty"`
OptionalImportEnum *ImportEnum `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,enum=goproto.proto.test.ImportEnum" json:"optional_import_enum,omitempty"`
OptionalLazyNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,24,opt,name=optional_lazy_nested_message,json=optionalLazyNestedMessage" json:"optional_lazy_nested_message,omitempty"`
RepeatedInt32 []int32 `protobuf:"varint,31,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
RepeatedInt64 []int64 `protobuf:"varint,32,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
RepeatedUint32 []uint32 `protobuf:"varint,33,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
RepeatedUint64 []uint64 `protobuf:"varint,34,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
RepeatedSint32 []int32 `protobuf:"zigzag32,35,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
RepeatedSint64 []int64 `protobuf:"zigzag64,36,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
RepeatedFixed32 []uint32 `protobuf:"fixed32,37,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
RepeatedFixed64 []uint64 `protobuf:"fixed64,38,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
RepeatedSfixed32 []int32 `protobuf:"fixed32,39,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
RepeatedSfixed64 []int64 `protobuf:"fixed64,40,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
RepeatedFloat []float32 `protobuf:"fixed32,41,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
RepeatedDouble []float64 `protobuf:"fixed64,42,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
RepeatedBool []bool `protobuf:"varint,43,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
RepeatedString []string `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
RepeatedBytes [][]byte `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
Repeatedgroup []*TestAllTypes_RepeatedGroup `protobuf:"group,46,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
RepeatedNestedMessage []*TestAllTypes_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"`
RepeatedForeignMessage []*ForeignMessage `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"`
RepeatedImportmessage []*ImportMessage `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage" json:"repeated_importmessage,omitempty"`
RepeatedNestedEnum []TestAllTypes_NestedEnum `protobuf:"varint,51,rep,name=repeated_nested_enum,json=repeatedNestedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
RepeatedForeignEnum []ForeignEnum `protobuf:"varint,52,rep,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=goproto.proto.test.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
RepeatedImportenum []ImportEnum `protobuf:"varint,53,rep,name=repeated_importenum,json=repeatedImportenum,enum=goproto.proto.test.ImportEnum" json:"repeated_importenum,omitempty"`
MapInt32Int32 map[int32]int32 `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapInt64Int64 map[int64]int64 `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapUint32Uint32 map[uint32]uint32 `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapUint64Uint64 map[uint64]uint64 `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapSint32Sint32 map[int32]int32 `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
MapSint64Sint64 map[int64]int64 `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
MapFixed32Fixed32 map[uint32]uint32 `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
MapFixed64Fixed64 map[uint64]uint64 `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
MapSfixed32Sfixed32 map[int32]int32 `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
MapSfixed64Sfixed64 map[int64]int64 `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
MapInt32Float map[int32]float32 `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
MapInt32Double map[int32]float64 `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
MapBoolBool map[bool]bool `protobuf:"bytes,68,rep,name=map_bool_bool,json=mapBoolBool" json:"map_bool_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapStringString map[string]string `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MapStringBytes map[string][]byte `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MapStringNestedMessage map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MapStringNestedEnum map[string]TestAllTypes_NestedEnum `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=goproto.proto.test.TestAllTypes_NestedEnum"`
// Singular with defaults
DefaultInt32 *int32 `protobuf:"varint,81,opt,name=default_int32,json=defaultInt32,def=81" json:"default_int32,omitempty"`
DefaultInt64 *int64 `protobuf:"varint,82,opt,name=default_int64,json=defaultInt64,def=82" json:"default_int64,omitempty"`
DefaultUint32 *uint32 `protobuf:"varint,83,opt,name=default_uint32,json=defaultUint32,def=83" json:"default_uint32,omitempty"`
DefaultUint64 *uint64 `protobuf:"varint,84,opt,name=default_uint64,json=defaultUint64,def=84" json:"default_uint64,omitempty"`
DefaultSint32 *int32 `protobuf:"zigzag32,85,opt,name=default_sint32,json=defaultSint32,def=-85" json:"default_sint32,omitempty"`
DefaultSint64 *int64 `protobuf:"zigzag64,86,opt,name=default_sint64,json=defaultSint64,def=86" json:"default_sint64,omitempty"`
DefaultFixed32 *uint32 `protobuf:"fixed32,87,opt,name=default_fixed32,json=defaultFixed32,def=87" json:"default_fixed32,omitempty"`
DefaultFixed64 *uint64 `protobuf:"fixed64,88,opt,name=default_fixed64,json=defaultFixed64,def=88" json:"default_fixed64,omitempty"`
DefaultSfixed32 *int32 `protobuf:"fixed32,89,opt,name=default_sfixed32,json=defaultSfixed32,def=89" json:"default_sfixed32,omitempty"`
DefaultSfixed64 *int64 `protobuf:"fixed64,80,opt,name=default_sfixed64,json=defaultSfixed64,def=-90" json:"default_sfixed64,omitempty"`
DefaultFloat *float32 `protobuf:"fixed32,91,opt,name=default_float,json=defaultFloat,def=91.5" json:"default_float,omitempty"`
DefaultDouble *float64 `protobuf:"fixed64,92,opt,name=default_double,json=defaultDouble,def=92000" json:"default_double,omitempty"`
DefaultBool *bool `protobuf:"varint,93,opt,name=default_bool,json=defaultBool,def=1" json:"default_bool,omitempty"`
DefaultString *string `protobuf:"bytes,94,opt,name=default_string,json=defaultString,def=hello" json:"default_string,omitempty"`
DefaultBytes []byte `protobuf:"bytes,95,opt,name=default_bytes,json=defaultBytes,def=world" json:"default_bytes,omitempty"`
DefaultNestedEnum *TestAllTypes_NestedEnum `protobuf:"varint,96,opt,name=default_nested_enum,json=defaultNestedEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum,def=1" json:"default_nested_enum,omitempty"`
DefaultForeignEnum *ForeignEnum `protobuf:"varint,97,opt,name=default_foreign_enum,json=defaultForeignEnum,enum=goproto.proto.test.ForeignEnum,def=5" json:"default_foreign_enum,omitempty"`
// Types that are valid to be assigned to OneofField:
//
// *TestAllTypes_OneofUint32
// *TestAllTypes_OneofNestedMessage
// *TestAllTypes_OneofString
// *TestAllTypes_OneofBytes
// *TestAllTypes_OneofBool
// *TestAllTypes_OneofUint64
// *TestAllTypes_OneofFloat
// *TestAllTypes_OneofDouble
// *TestAllTypes_OneofEnum
// *TestAllTypes_Oneofgroup
OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
// A oneof with exactly one field.
//
// Types that are valid to be assigned to OneofOptional:
//
// *TestAllTypes_OneofOptionalUint32
OneofOptional isTestAllTypes_OneofOptional `protobuf_oneof:"oneof_optional"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for TestAllTypes fields.
const (
Default_TestAllTypes_DefaultInt32 = int32(81)
Default_TestAllTypes_DefaultInt64 = int64(82)
Default_TestAllTypes_DefaultUint32 = uint32(83)
Default_TestAllTypes_DefaultUint64 = uint64(84)
Default_TestAllTypes_DefaultSint32 = int32(-85)
Default_TestAllTypes_DefaultSint64 = int64(86)
Default_TestAllTypes_DefaultFixed32 = uint32(87)
Default_TestAllTypes_DefaultFixed64 = uint64(88)
Default_TestAllTypes_DefaultSfixed32 = int32(89)
Default_TestAllTypes_DefaultSfixed64 = int64(-90)
Default_TestAllTypes_DefaultFloat = float32(91.5)
Default_TestAllTypes_DefaultDouble = float64(92000)
Default_TestAllTypes_DefaultBool = bool(true)
Default_TestAllTypes_DefaultString = string("hello")
Default_TestAllTypes_DefaultNestedEnum = TestAllTypes_BAR
Default_TestAllTypes_DefaultForeignEnum = ForeignEnum_FOREIGN_BAR
)
// Default values for TestAllTypes fields.
var (
Default_TestAllTypes_DefaultBytes = []byte("world")
)
func (x *TestAllTypes) Reset() {
*x = TestAllTypes{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes) ProtoMessage() {}
func (x *TestAllTypes) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes.ProtoReflect.Descriptor instead.
func (*TestAllTypes) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0}
}
func (x *TestAllTypes) GetOptionalInt32() int32 {
if x != nil && x.OptionalInt32 != nil {
return *x.OptionalInt32
}
return 0
}
func (x *TestAllTypes) GetOptionalInt64() int64 {
if x != nil && x.OptionalInt64 != nil {
return *x.OptionalInt64
}
return 0
}
func (x *TestAllTypes) GetOptionalUint32() uint32 {
if x != nil && x.OptionalUint32 != nil {
return *x.OptionalUint32
}
return 0
}
func (x *TestAllTypes) GetOptionalUint64() uint64 {
if x != nil && x.OptionalUint64 != nil {
return *x.OptionalUint64
}
return 0
}
func (x *TestAllTypes) GetOptionalSint32() int32 {
if x != nil && x.OptionalSint32 != nil {
return *x.OptionalSint32
}
return 0
}
func (x *TestAllTypes) GetOptionalSint64() int64 {
if x != nil && x.OptionalSint64 != nil {
return *x.OptionalSint64
}
return 0
}
func (x *TestAllTypes) GetOptionalFixed32() uint32 {
if x != nil && x.OptionalFixed32 != nil {
return *x.OptionalFixed32
}
return 0
}
func (x *TestAllTypes) GetOptionalFixed64() uint64 {
if x != nil && x.OptionalFixed64 != nil {
return *x.OptionalFixed64
}
return 0
}
func (x *TestAllTypes) GetOptionalSfixed32() int32 {
if x != nil && x.OptionalSfixed32 != nil {
return *x.OptionalSfixed32
}
return 0
}
func (x *TestAllTypes) GetOptionalSfixed64() int64 {
if x != nil && x.OptionalSfixed64 != nil {
return *x.OptionalSfixed64
}
return 0
}
func (x *TestAllTypes) GetOptionalFloat() float32 {
if x != nil && x.OptionalFloat != nil {
return *x.OptionalFloat
}
return 0
}
func (x *TestAllTypes) GetOptionalDouble() float64 {
if x != nil && x.OptionalDouble != nil {
return *x.OptionalDouble
}
return 0
}
func (x *TestAllTypes) GetOptionalBool() bool {
if x != nil && x.OptionalBool != nil {
return *x.OptionalBool
}
return false
}
func (x *TestAllTypes) GetOptionalString() string {
if x != nil && x.OptionalString != nil {
return *x.OptionalString
}
return ""
}
func (x *TestAllTypes) GetOptionalBytes() []byte {
if x != nil {
return x.OptionalBytes
}
return nil
}
func (x *TestAllTypes) GetOptionalgroup() *TestAllTypes_OptionalGroup {
if x != nil {
return x.Optionalgroup
}
return nil
}
func (x *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
return x.OptionalNestedMessage
}
return nil
}
func (x *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage {
if x != nil {
return x.OptionalForeignMessage
}
return nil
}
func (x *TestAllTypes) GetOptionalImportMessage() *ImportMessage {
if x != nil {
return x.OptionalImportMessage
}
return nil
}
func (x *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
if x != nil && x.OptionalNestedEnum != nil {
return *x.OptionalNestedEnum
}
return TestAllTypes_FOO
}
func (x *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
if x != nil && x.OptionalForeignEnum != nil {
return *x.OptionalForeignEnum
}
return ForeignEnum_FOREIGN_FOO
}
func (x *TestAllTypes) GetOptionalImportEnum() ImportEnum {
if x != nil && x.OptionalImportEnum != nil {
return *x.OptionalImportEnum
}
return ImportEnum_IMPORT_ZERO
}
func (x *TestAllTypes) GetOptionalLazyNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
return x.OptionalLazyNestedMessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedInt32() []int32 {
if x != nil {
return x.RepeatedInt32
}
return nil
}
func (x *TestAllTypes) GetRepeatedInt64() []int64 {
if x != nil {
return x.RepeatedInt64
}
return nil
}
func (x *TestAllTypes) GetRepeatedUint32() []uint32 {
if x != nil {
return x.RepeatedUint32
}
return nil
}
func (x *TestAllTypes) GetRepeatedUint64() []uint64 {
if x != nil {
return x.RepeatedUint64
}
return nil
}
func (x *TestAllTypes) GetRepeatedSint32() []int32 {
if x != nil {
return x.RepeatedSint32
}
return nil
}
func (x *TestAllTypes) GetRepeatedSint64() []int64 {
if x != nil {
return x.RepeatedSint64
}
return nil
}
func (x *TestAllTypes) GetRepeatedFixed32() []uint32 {
if x != nil {
return x.RepeatedFixed32
}
return nil
}
func (x *TestAllTypes) GetRepeatedFixed64() []uint64 {
if x != nil {
return x.RepeatedFixed64
}
return nil
}
func (x *TestAllTypes) GetRepeatedSfixed32() []int32 {
if x != nil {
return x.RepeatedSfixed32
}
return nil
}
func (x *TestAllTypes) GetRepeatedSfixed64() []int64 {
if x != nil {
return x.RepeatedSfixed64
}
return nil
}
func (x *TestAllTypes) GetRepeatedFloat() []float32 {
if x != nil {
return x.RepeatedFloat
}
return nil
}
func (x *TestAllTypes) GetRepeatedDouble() []float64 {
if x != nil {
return x.RepeatedDouble
}
return nil
}
func (x *TestAllTypes) GetRepeatedBool() []bool {
if x != nil {
return x.RepeatedBool
}
return nil
}
func (x *TestAllTypes) GetRepeatedString() []string {
if x != nil {
return x.RepeatedString
}
return nil
}
func (x *TestAllTypes) GetRepeatedBytes() [][]byte {
if x != nil {
return x.RepeatedBytes
}
return nil
}
func (x *TestAllTypes) GetRepeatedgroup() []*TestAllTypes_RepeatedGroup {
if x != nil {
return x.Repeatedgroup
}
return nil
}
func (x *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
if x != nil {
return x.RepeatedNestedMessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
if x != nil {
return x.RepeatedForeignMessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedImportmessage() []*ImportMessage {
if x != nil {
return x.RepeatedImportmessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
if x != nil {
return x.RepeatedNestedEnum
}
return nil
}
func (x *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
if x != nil {
return x.RepeatedForeignEnum
}
return nil
}
func (x *TestAllTypes) GetRepeatedImportenum() []ImportEnum {
if x != nil {
return x.RepeatedImportenum
}
return nil
}
func (x *TestAllTypes) GetMapInt32Int32() map[int32]int32 {
if x != nil {
return x.MapInt32Int32
}
return nil
}
func (x *TestAllTypes) GetMapInt64Int64() map[int64]int64 {
if x != nil {
return x.MapInt64Int64
}
return nil
}
func (x *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 {
if x != nil {
return x.MapUint32Uint32
}
return nil
}
func (x *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 {
if x != nil {
return x.MapUint64Uint64
}
return nil
}
func (x *TestAllTypes) GetMapSint32Sint32() map[int32]int32 {
if x != nil {
return x.MapSint32Sint32
}
return nil
}
func (x *TestAllTypes) GetMapSint64Sint64() map[int64]int64 {
if x != nil {
return x.MapSint64Sint64
}
return nil
}
func (x *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 {
if x != nil {
return x.MapFixed32Fixed32
}
return nil
}
func (x *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 {
if x != nil {
return x.MapFixed64Fixed64
}
return nil
}
func (x *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 {
if x != nil {
return x.MapSfixed32Sfixed32
}
return nil
}
func (x *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 {
if x != nil {
return x.MapSfixed64Sfixed64
}
return nil
}
func (x *TestAllTypes) GetMapInt32Float() map[int32]float32 {
if x != nil {
return x.MapInt32Float
}
return nil
}
func (x *TestAllTypes) GetMapInt32Double() map[int32]float64 {
if x != nil {
return x.MapInt32Double
}
return nil
}
func (x *TestAllTypes) GetMapBoolBool() map[bool]bool {
if x != nil {
return x.MapBoolBool
}
return nil
}
func (x *TestAllTypes) GetMapStringString() map[string]string {
if x != nil {
return x.MapStringString
}
return nil
}
func (x *TestAllTypes) GetMapStringBytes() map[string][]byte {
if x != nil {
return x.MapStringBytes
}
return nil
}
func (x *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage {
if x != nil {
return x.MapStringNestedMessage
}
return nil
}
func (x *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum {
if x != nil {
return x.MapStringNestedEnum
}
return nil
}
func (x *TestAllTypes) GetDefaultInt32() int32 {
if x != nil && x.DefaultInt32 != nil {
return *x.DefaultInt32
}
return Default_TestAllTypes_DefaultInt32
}
func (x *TestAllTypes) GetDefaultInt64() int64 {
if x != nil && x.DefaultInt64 != nil {
return *x.DefaultInt64
}
return Default_TestAllTypes_DefaultInt64
}
func (x *TestAllTypes) GetDefaultUint32() uint32 {
if x != nil && x.DefaultUint32 != nil {
return *x.DefaultUint32
}
return Default_TestAllTypes_DefaultUint32
}
func (x *TestAllTypes) GetDefaultUint64() uint64 {
if x != nil && x.DefaultUint64 != nil {
return *x.DefaultUint64
}
return Default_TestAllTypes_DefaultUint64
}
func (x *TestAllTypes) GetDefaultSint32() int32 {
if x != nil && x.DefaultSint32 != nil {
return *x.DefaultSint32
}
return Default_TestAllTypes_DefaultSint32
}
func (x *TestAllTypes) GetDefaultSint64() int64 {
if x != nil && x.DefaultSint64 != nil {
return *x.DefaultSint64
}
return Default_TestAllTypes_DefaultSint64
}
func (x *TestAllTypes) GetDefaultFixed32() uint32 {
if x != nil && x.DefaultFixed32 != nil {
return *x.DefaultFixed32
}
return Default_TestAllTypes_DefaultFixed32
}
func (x *TestAllTypes) GetDefaultFixed64() uint64 {
if x != nil && x.DefaultFixed64 != nil {
return *x.DefaultFixed64
}
return Default_TestAllTypes_DefaultFixed64
}
func (x *TestAllTypes) GetDefaultSfixed32() int32 {
if x != nil && x.DefaultSfixed32 != nil {
return *x.DefaultSfixed32
}
return Default_TestAllTypes_DefaultSfixed32
}
func (x *TestAllTypes) GetDefaultSfixed64() int64 {
if x != nil && x.DefaultSfixed64 != nil {
return *x.DefaultSfixed64
}
return Default_TestAllTypes_DefaultSfixed64
}
func (x *TestAllTypes) GetDefaultFloat() float32 {
if x != nil && x.DefaultFloat != nil {
return *x.DefaultFloat
}
return Default_TestAllTypes_DefaultFloat
}
func (x *TestAllTypes) GetDefaultDouble() float64 {
if x != nil && x.DefaultDouble != nil {
return *x.DefaultDouble
}
return Default_TestAllTypes_DefaultDouble
}
func (x *TestAllTypes) GetDefaultBool() bool {
if x != nil && x.DefaultBool != nil {
return *x.DefaultBool
}
return Default_TestAllTypes_DefaultBool
}
func (x *TestAllTypes) GetDefaultString() string {
if x != nil && x.DefaultString != nil {
return *x.DefaultString
}
return Default_TestAllTypes_DefaultString
}
func (x *TestAllTypes) GetDefaultBytes() []byte {
if x != nil && x.DefaultBytes != nil {
return x.DefaultBytes
}
return append([]byte(nil), Default_TestAllTypes_DefaultBytes...)
}
func (x *TestAllTypes) GetDefaultNestedEnum() TestAllTypes_NestedEnum {
if x != nil && x.DefaultNestedEnum != nil {
return *x.DefaultNestedEnum
}
return Default_TestAllTypes_DefaultNestedEnum
}
func (x *TestAllTypes) GetDefaultForeignEnum() ForeignEnum {
if x != nil && x.DefaultForeignEnum != nil {
return *x.DefaultForeignEnum
}
return Default_TestAllTypes_DefaultForeignEnum
}
func (x *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
if x != nil {
return x.OneofField
}
return nil
}
func (x *TestAllTypes) GetOneofUint32() uint32 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofUint32); ok {
return x.OneofUint32
}
}
return 0
}
func (x *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofNestedMessage); ok {
return x.OneofNestedMessage
}
}
return nil
}
func (x *TestAllTypes) GetOneofString() string {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofString); ok {
return x.OneofString
}
}
return ""
}
func (x *TestAllTypes) GetOneofBytes() []byte {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofBytes); ok {
return x.OneofBytes
}
}
return nil
}
func (x *TestAllTypes) GetOneofBool() bool {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofBool); ok {
return x.OneofBool
}
}
return false
}
func (x *TestAllTypes) GetOneofUint64() uint64 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofUint64); ok {
return x.OneofUint64
}
}
return 0
}
func (x *TestAllTypes) GetOneofFloat() float32 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofFloat); ok {
return x.OneofFloat
}
}
return 0
}
func (x *TestAllTypes) GetOneofDouble() float64 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofDouble); ok {
return x.OneofDouble
}
}
return 0
}
func (x *TestAllTypes) GetOneofEnum() TestAllTypes_NestedEnum {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofEnum); ok {
return x.OneofEnum
}
}
return TestAllTypes_FOO
}
func (x *TestAllTypes) GetOneofgroup() *TestAllTypes_OneofGroup {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_Oneofgroup); ok {
return x.Oneofgroup
}
}
return nil
}
func (x *TestAllTypes) GetOneofOptional() isTestAllTypes_OneofOptional {
if x != nil {
return x.OneofOptional
}
return nil
}
func (x *TestAllTypes) GetOneofOptionalUint32() uint32 {
if x != nil {
if x, ok := x.OneofOptional.(*TestAllTypes_OneofOptionalUint32); ok {
return x.OneofOptionalUint32
}
}
return 0
}
type isTestAllTypes_OneofField interface {
isTestAllTypes_OneofField()
}
type TestAllTypes_OneofUint32 struct {
OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"`
}
type TestAllTypes_OneofNestedMessage struct {
OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"`
}
type TestAllTypes_OneofString struct {
OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"`
}
type TestAllTypes_OneofBytes struct {
OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,oneof"`
}
type TestAllTypes_OneofBool struct {
OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,oneof"`
}
type TestAllTypes_OneofUint64 struct {
OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,oneof"`
}
type TestAllTypes_OneofFloat struct {
OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,oneof"`
}
type TestAllTypes_OneofDouble struct {
OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,oneof"`
}
type TestAllTypes_OneofEnum struct {
OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,enum=goproto.proto.test.TestAllTypes_NestedEnum,oneof"`
}
type TestAllTypes_Oneofgroup struct {
Oneofgroup *TestAllTypes_OneofGroup `protobuf:"group,121,opt,name=OneofGroup,json=oneofgroup,oneof"`
}
func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofString) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofBool) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofUint64) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofFloat) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofDouble) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofEnum) isTestAllTypes_OneofField() {}
func (*TestAllTypes_Oneofgroup) isTestAllTypes_OneofField() {}
type isTestAllTypes_OneofOptional interface {
isTestAllTypes_OneofOptional()
}
type TestAllTypes_OneofOptionalUint32 struct {
OneofOptionalUint32 uint32 `protobuf:"varint,120,opt,name=oneof_optional_uint32,json=oneofOptionalUint32,oneof"`
}
func (*TestAllTypes_OneofOptionalUint32) isTestAllTypes_OneofOptional() {}
type TestManyMessageFieldsMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
F1 *TestAllTypes `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
F2 *TestAllTypes `protobuf:"bytes,2,opt,name=f2" json:"f2,omitempty"`
F3 *TestAllTypes `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
F4 *TestAllTypes `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
F5 *TestAllTypes `protobuf:"bytes,5,opt,name=f5" json:"f5,omitempty"`
F6 *TestAllTypes `protobuf:"bytes,6,opt,name=f6" json:"f6,omitempty"`
F7 *TestAllTypes `protobuf:"bytes,7,opt,name=f7" json:"f7,omitempty"`
F8 *TestAllTypes `protobuf:"bytes,8,opt,name=f8" json:"f8,omitempty"`
F9 *TestAllTypes `protobuf:"bytes,9,opt,name=f9" json:"f9,omitempty"`
F10 *TestAllTypes `protobuf:"bytes,10,opt,name=f10" json:"f10,omitempty"`
F11 *TestAllTypes `protobuf:"bytes,11,opt,name=f11" json:"f11,omitempty"`
F12 *TestAllTypes `protobuf:"bytes,12,opt,name=f12" json:"f12,omitempty"`
F13 *TestAllTypes `protobuf:"bytes,13,opt,name=f13" json:"f13,omitempty"`
F14 *TestAllTypes `protobuf:"bytes,14,opt,name=f14" json:"f14,omitempty"`
F15 *TestAllTypes `protobuf:"bytes,15,opt,name=f15" json:"f15,omitempty"`
F16 *TestAllTypes `protobuf:"bytes,16,opt,name=f16" json:"f16,omitempty"`
F17 *TestAllTypes `protobuf:"bytes,17,opt,name=f17" json:"f17,omitempty"`
F18 *TestAllTypes `protobuf:"bytes,18,opt,name=f18" json:"f18,omitempty"`
F19 *TestAllTypes `protobuf:"bytes,19,opt,name=f19" json:"f19,omitempty"`
F20 *TestAllTypes `protobuf:"bytes,20,opt,name=f20" json:"f20,omitempty"`
F21 *TestAllTypes `protobuf:"bytes,21,opt,name=f21" json:"f21,omitempty"`
F22 *TestAllTypes `protobuf:"bytes,22,opt,name=f22" json:"f22,omitempty"`
F23 *TestAllTypes `protobuf:"bytes,23,opt,name=f23" json:"f23,omitempty"`
F24 *TestAllTypes `protobuf:"bytes,24,opt,name=f24" json:"f24,omitempty"`
F25 *TestAllTypes `protobuf:"bytes,25,opt,name=f25" json:"f25,omitempty"`
F26 *TestAllTypes `protobuf:"bytes,26,opt,name=f26" json:"f26,omitempty"`
F27 *TestAllTypes `protobuf:"bytes,27,opt,name=f27" json:"f27,omitempty"`
F28 *TestAllTypes `protobuf:"bytes,28,opt,name=f28" json:"f28,omitempty"`
F29 *TestAllTypes `protobuf:"bytes,29,opt,name=f29" json:"f29,omitempty"`
F30 *TestAllTypes `protobuf:"bytes,30,opt,name=f30" json:"f30,omitempty"`
F31 *TestAllTypes `protobuf:"bytes,31,opt,name=f31" json:"f31,omitempty"`
F32 *TestAllTypes `protobuf:"bytes,32,opt,name=f32" json:"f32,omitempty"`
F33 *TestAllTypes `protobuf:"bytes,33,opt,name=f33" json:"f33,omitempty"`
F34 *TestAllTypes `protobuf:"bytes,34,opt,name=f34" json:"f34,omitempty"`
F35 *TestAllTypes `protobuf:"bytes,35,opt,name=f35" json:"f35,omitempty"`
F36 *TestAllTypes `protobuf:"bytes,36,opt,name=f36" json:"f36,omitempty"`
F37 *TestAllTypes `protobuf:"bytes,37,opt,name=f37" json:"f37,omitempty"`
F38 *TestAllTypes `protobuf:"bytes,38,opt,name=f38" json:"f38,omitempty"`
F39 *TestAllTypes `protobuf:"bytes,39,opt,name=f39" json:"f39,omitempty"`
F40 *TestAllTypes `protobuf:"bytes,40,opt,name=f40" json:"f40,omitempty"`
F41 *TestAllTypes `protobuf:"bytes,41,opt,name=f41" json:"f41,omitempty"`
F42 *TestAllTypes `protobuf:"bytes,42,opt,name=f42" json:"f42,omitempty"`
F43 *TestAllTypes `protobuf:"bytes,43,opt,name=f43" json:"f43,omitempty"`
F44 *TestAllTypes `protobuf:"bytes,44,opt,name=f44" json:"f44,omitempty"`
F45 *TestAllTypes `protobuf:"bytes,45,opt,name=f45" json:"f45,omitempty"`
F46 *TestAllTypes `protobuf:"bytes,46,opt,name=f46" json:"f46,omitempty"`
F47 *TestAllTypes `protobuf:"bytes,47,opt,name=f47" json:"f47,omitempty"`
F48 *TestAllTypes `protobuf:"bytes,48,opt,name=f48" json:"f48,omitempty"`
F49 *TestAllTypes `protobuf:"bytes,49,opt,name=f49" json:"f49,omitempty"`
F50 *TestAllTypes `protobuf:"bytes,50,opt,name=f50" json:"f50,omitempty"`
F51 *TestAllTypes `protobuf:"bytes,51,opt,name=f51" json:"f51,omitempty"`
F52 *TestAllTypes `protobuf:"bytes,52,opt,name=f52" json:"f52,omitempty"`
F53 *TestAllTypes `protobuf:"bytes,53,opt,name=f53" json:"f53,omitempty"`
F54 *TestAllTypes `protobuf:"bytes,54,opt,name=f54" json:"f54,omitempty"`
F55 *TestAllTypes `protobuf:"bytes,55,opt,name=f55" json:"f55,omitempty"`
F56 *TestAllTypes `protobuf:"bytes,56,opt,name=f56" json:"f56,omitempty"`
F57 *TestAllTypes `protobuf:"bytes,57,opt,name=f57" json:"f57,omitempty"`
F58 *TestAllTypes `protobuf:"bytes,58,opt,name=f58" json:"f58,omitempty"`
F59 *TestAllTypes `protobuf:"bytes,59,opt,name=f59" json:"f59,omitempty"`
F60 *TestAllTypes `protobuf:"bytes,60,opt,name=f60" json:"f60,omitempty"`
F61 *TestAllTypes `protobuf:"bytes,61,opt,name=f61" json:"f61,omitempty"`
F62 *TestAllTypes `protobuf:"bytes,62,opt,name=f62" json:"f62,omitempty"`
F63 *TestAllTypes `protobuf:"bytes,63,opt,name=f63" json:"f63,omitempty"`
F64 *TestAllTypes `protobuf:"bytes,64,opt,name=f64" json:"f64,omitempty"`
F65 *TestAllTypes `protobuf:"bytes,65,opt,name=f65" json:"f65,omitempty"`
F66 *TestAllTypes `protobuf:"bytes,66,opt,name=f66" json:"f66,omitempty"`
F67 *TestAllTypes `protobuf:"bytes,67,opt,name=f67" json:"f67,omitempty"`
F68 *TestAllTypes `protobuf:"bytes,68,opt,name=f68" json:"f68,omitempty"`
F69 *TestAllTypes `protobuf:"bytes,69,opt,name=f69" json:"f69,omitempty"`
F70 *TestAllTypes `protobuf:"bytes,70,opt,name=f70" json:"f70,omitempty"`
F71 *TestAllTypes `protobuf:"bytes,71,opt,name=f71" json:"f71,omitempty"`
F72 *TestAllTypes `protobuf:"bytes,72,opt,name=f72" json:"f72,omitempty"`
F73 *TestAllTypes `protobuf:"bytes,73,opt,name=f73" json:"f73,omitempty"`
F74 *TestAllTypes `protobuf:"bytes,74,opt,name=f74" json:"f74,omitempty"`
F75 *TestAllTypes `protobuf:"bytes,75,opt,name=f75" json:"f75,omitempty"`
F76 *TestAllTypes `protobuf:"bytes,76,opt,name=f76" json:"f76,omitempty"`
F77 *TestAllTypes `protobuf:"bytes,77,opt,name=f77" json:"f77,omitempty"`
F78 *TestAllTypes `protobuf:"bytes,78,opt,name=f78" json:"f78,omitempty"`
F79 *TestAllTypes `protobuf:"bytes,79,opt,name=f79" json:"f79,omitempty"`
F80 *TestAllTypes `protobuf:"bytes,80,opt,name=f80" json:"f80,omitempty"`
F81 *TestAllTypes `protobuf:"bytes,81,opt,name=f81" json:"f81,omitempty"`
F82 *TestAllTypes `protobuf:"bytes,82,opt,name=f82" json:"f82,omitempty"`
F83 *TestAllTypes `protobuf:"bytes,83,opt,name=f83" json:"f83,omitempty"`
F84 *TestAllTypes `protobuf:"bytes,84,opt,name=f84" json:"f84,omitempty"`
F85 *TestAllTypes `protobuf:"bytes,85,opt,name=f85" json:"f85,omitempty"`
F86 *TestAllTypes `protobuf:"bytes,86,opt,name=f86" json:"f86,omitempty"`
F87 *TestAllTypes `protobuf:"bytes,87,opt,name=f87" json:"f87,omitempty"`
F88 *TestAllTypes `protobuf:"bytes,88,opt,name=f88" json:"f88,omitempty"`
F89 *TestAllTypes `protobuf:"bytes,89,opt,name=f89" json:"f89,omitempty"`
F90 *TestAllTypes `protobuf:"bytes,90,opt,name=f90" json:"f90,omitempty"`
F91 *TestAllTypes `protobuf:"bytes,91,opt,name=f91" json:"f91,omitempty"`
F92 *TestAllTypes `protobuf:"bytes,92,opt,name=f92" json:"f92,omitempty"`
F93 *TestAllTypes `protobuf:"bytes,93,opt,name=f93" json:"f93,omitempty"`
F94 *TestAllTypes `protobuf:"bytes,94,opt,name=f94" json:"f94,omitempty"`
F95 *TestAllTypes `protobuf:"bytes,95,opt,name=f95" json:"f95,omitempty"`
F96 *TestAllTypes `protobuf:"bytes,96,opt,name=f96" json:"f96,omitempty"`
F97 *TestAllTypes `protobuf:"bytes,97,opt,name=f97" json:"f97,omitempty"`
F98 *TestAllTypes `protobuf:"bytes,98,opt,name=f98" json:"f98,omitempty"`
F99 *TestAllTypes `protobuf:"bytes,99,opt,name=f99" json:"f99,omitempty"`
F100 *TestAllTypes `protobuf:"bytes,100,opt,name=f100" json:"f100,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestManyMessageFieldsMessage) Reset() {
*x = TestManyMessageFieldsMessage{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestManyMessageFieldsMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestManyMessageFieldsMessage) ProtoMessage() {}
func (x *TestManyMessageFieldsMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestManyMessageFieldsMessage.ProtoReflect.Descriptor instead.
func (*TestManyMessageFieldsMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{1}
}
func (x *TestManyMessageFieldsMessage) GetF1() *TestAllTypes {
if x != nil {
return x.F1
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF2() *TestAllTypes {
if x != nil {
return x.F2
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF3() *TestAllTypes {
if x != nil {
return x.F3
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF4() *TestAllTypes {
if x != nil {
return x.F4
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF5() *TestAllTypes {
if x != nil {
return x.F5
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF6() *TestAllTypes {
if x != nil {
return x.F6
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF7() *TestAllTypes {
if x != nil {
return x.F7
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF8() *TestAllTypes {
if x != nil {
return x.F8
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF9() *TestAllTypes {
if x != nil {
return x.F9
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF10() *TestAllTypes {
if x != nil {
return x.F10
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF11() *TestAllTypes {
if x != nil {
return x.F11
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF12() *TestAllTypes {
if x != nil {
return x.F12
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF13() *TestAllTypes {
if x != nil {
return x.F13
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF14() *TestAllTypes {
if x != nil {
return x.F14
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF15() *TestAllTypes {
if x != nil {
return x.F15
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF16() *TestAllTypes {
if x != nil {
return x.F16
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF17() *TestAllTypes {
if x != nil {
return x.F17
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF18() *TestAllTypes {
if x != nil {
return x.F18
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF19() *TestAllTypes {
if x != nil {
return x.F19
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF20() *TestAllTypes {
if x != nil {
return x.F20
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF21() *TestAllTypes {
if x != nil {
return x.F21
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF22() *TestAllTypes {
if x != nil {
return x.F22
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF23() *TestAllTypes {
if x != nil {
return x.F23
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF24() *TestAllTypes {
if x != nil {
return x.F24
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF25() *TestAllTypes {
if x != nil {
return x.F25
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF26() *TestAllTypes {
if x != nil {
return x.F26
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF27() *TestAllTypes {
if x != nil {
return x.F27
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF28() *TestAllTypes {
if x != nil {
return x.F28
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF29() *TestAllTypes {
if x != nil {
return x.F29
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF30() *TestAllTypes {
if x != nil {
return x.F30
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF31() *TestAllTypes {
if x != nil {
return x.F31
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF32() *TestAllTypes {
if x != nil {
return x.F32
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF33() *TestAllTypes {
if x != nil {
return x.F33
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF34() *TestAllTypes {
if x != nil {
return x.F34
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF35() *TestAllTypes {
if x != nil {
return x.F35
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF36() *TestAllTypes {
if x != nil {
return x.F36
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF37() *TestAllTypes {
if x != nil {
return x.F37
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF38() *TestAllTypes {
if x != nil {
return x.F38
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF39() *TestAllTypes {
if x != nil {
return x.F39
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF40() *TestAllTypes {
if x != nil {
return x.F40
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF41() *TestAllTypes {
if x != nil {
return x.F41
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF42() *TestAllTypes {
if x != nil {
return x.F42
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF43() *TestAllTypes {
if x != nil {
return x.F43
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF44() *TestAllTypes {
if x != nil {
return x.F44
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF45() *TestAllTypes {
if x != nil {
return x.F45
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF46() *TestAllTypes {
if x != nil {
return x.F46
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF47() *TestAllTypes {
if x != nil {
return x.F47
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF48() *TestAllTypes {
if x != nil {
return x.F48
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF49() *TestAllTypes {
if x != nil {
return x.F49
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF50() *TestAllTypes {
if x != nil {
return x.F50
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF51() *TestAllTypes {
if x != nil {
return x.F51
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF52() *TestAllTypes {
if x != nil {
return x.F52
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF53() *TestAllTypes {
if x != nil {
return x.F53
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF54() *TestAllTypes {
if x != nil {
return x.F54
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF55() *TestAllTypes {
if x != nil {
return x.F55
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF56() *TestAllTypes {
if x != nil {
return x.F56
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF57() *TestAllTypes {
if x != nil {
return x.F57
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF58() *TestAllTypes {
if x != nil {
return x.F58
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF59() *TestAllTypes {
if x != nil {
return x.F59
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF60() *TestAllTypes {
if x != nil {
return x.F60
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF61() *TestAllTypes {
if x != nil {
return x.F61
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF62() *TestAllTypes {
if x != nil {
return x.F62
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF63() *TestAllTypes {
if x != nil {
return x.F63
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF64() *TestAllTypes {
if x != nil {
return x.F64
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF65() *TestAllTypes {
if x != nil {
return x.F65
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF66() *TestAllTypes {
if x != nil {
return x.F66
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF67() *TestAllTypes {
if x != nil {
return x.F67
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF68() *TestAllTypes {
if x != nil {
return x.F68
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF69() *TestAllTypes {
if x != nil {
return x.F69
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF70() *TestAllTypes {
if x != nil {
return x.F70
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF71() *TestAllTypes {
if x != nil {
return x.F71
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF72() *TestAllTypes {
if x != nil {
return x.F72
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF73() *TestAllTypes {
if x != nil {
return x.F73
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF74() *TestAllTypes {
if x != nil {
return x.F74
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF75() *TestAllTypes {
if x != nil {
return x.F75
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF76() *TestAllTypes {
if x != nil {
return x.F76
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF77() *TestAllTypes {
if x != nil {
return x.F77
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF78() *TestAllTypes {
if x != nil {
return x.F78
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF79() *TestAllTypes {
if x != nil {
return x.F79
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF80() *TestAllTypes {
if x != nil {
return x.F80
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF81() *TestAllTypes {
if x != nil {
return x.F81
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF82() *TestAllTypes {
if x != nil {
return x.F82
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF83() *TestAllTypes {
if x != nil {
return x.F83
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF84() *TestAllTypes {
if x != nil {
return x.F84
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF85() *TestAllTypes {
if x != nil {
return x.F85
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF86() *TestAllTypes {
if x != nil {
return x.F86
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF87() *TestAllTypes {
if x != nil {
return x.F87
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF88() *TestAllTypes {
if x != nil {
return x.F88
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF89() *TestAllTypes {
if x != nil {
return x.F89
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF90() *TestAllTypes {
if x != nil {
return x.F90
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF91() *TestAllTypes {
if x != nil {
return x.F91
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF92() *TestAllTypes {
if x != nil {
return x.F92
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF93() *TestAllTypes {
if x != nil {
return x.F93
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF94() *TestAllTypes {
if x != nil {
return x.F94
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF95() *TestAllTypes {
if x != nil {
return x.F95
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF96() *TestAllTypes {
if x != nil {
return x.F96
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF97() *TestAllTypes {
if x != nil {
return x.F97
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF98() *TestAllTypes {
if x != nil {
return x.F98
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF99() *TestAllTypes {
if x != nil {
return x.F99
}
return nil
}
func (x *TestManyMessageFieldsMessage) GetF100() *TestAllTypes {
if x != nil {
return x.F100
}
return nil
}
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
type TestDeprecatedMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
DeprecatedInt32 *int32 `protobuf:"varint,1,opt,name=deprecated_int32,json=deprecatedInt32" json:"deprecated_int32,omitempty"`
// Types that are valid to be assigned to DeprecatedOneof:
//
// *TestDeprecatedMessage_DeprecatedOneofField
DeprecatedOneof isTestDeprecatedMessage_DeprecatedOneof `protobuf_oneof:"deprecated_oneof"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestDeprecatedMessage) Reset() {
*x = TestDeprecatedMessage{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestDeprecatedMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestDeprecatedMessage) ProtoMessage() {}
func (x *TestDeprecatedMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestDeprecatedMessage.ProtoReflect.Descriptor instead.
func (*TestDeprecatedMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{2}
}
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
func (x *TestDeprecatedMessage) GetDeprecatedInt32() int32 {
if x != nil && x.DeprecatedInt32 != nil {
return *x.DeprecatedInt32
}
return 0
}
func (x *TestDeprecatedMessage) GetDeprecatedOneof() isTestDeprecatedMessage_DeprecatedOneof {
if x != nil {
return x.DeprecatedOneof
}
return nil
}
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
func (x *TestDeprecatedMessage) GetDeprecatedOneofField() int32 {
if x != nil {
if x, ok := x.DeprecatedOneof.(*TestDeprecatedMessage_DeprecatedOneofField); ok {
return x.DeprecatedOneofField
}
}
return 0
}
type isTestDeprecatedMessage_DeprecatedOneof interface {
isTestDeprecatedMessage_DeprecatedOneof()
}
type TestDeprecatedMessage_DeprecatedOneofField struct {
// Deprecated: Marked as deprecated in internal/testprotos/test/test.proto.
DeprecatedOneofField int32 `protobuf:"varint,2,opt,name=deprecated_oneof_field,json=deprecatedOneofField,oneof"`
}
func (*TestDeprecatedMessage_DeprecatedOneofField) isTestDeprecatedMessage_DeprecatedOneof() {}
type TestOneofWithRequired struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Types that are valid to be assigned to OneofField:
//
// *TestOneofWithRequired_OneofUint32
// *TestOneofWithRequired_OneofRequired
OneofField isTestOneofWithRequired_OneofField `protobuf_oneof:"oneof_field"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestOneofWithRequired) Reset() {
*x = TestOneofWithRequired{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestOneofWithRequired) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestOneofWithRequired) ProtoMessage() {}
func (x *TestOneofWithRequired) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestOneofWithRequired.ProtoReflect.Descriptor instead.
func (*TestOneofWithRequired) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{3}
}
func (x *TestOneofWithRequired) GetOneofField() isTestOneofWithRequired_OneofField {
if x != nil {
return x.OneofField
}
return nil
}
func (x *TestOneofWithRequired) GetOneofUint32() uint32 {
if x != nil {
if x, ok := x.OneofField.(*TestOneofWithRequired_OneofUint32); ok {
return x.OneofUint32
}
}
return 0
}
func (x *TestOneofWithRequired) GetOneofRequired() *required.Message {
if x != nil {
if x, ok := x.OneofField.(*TestOneofWithRequired_OneofRequired); ok {
return x.OneofRequired
}
}
return nil
}
type isTestOneofWithRequired_OneofField interface {
isTestOneofWithRequired_OneofField()
}
type TestOneofWithRequired_OneofUint32 struct {
OneofUint32 uint32 `protobuf:"varint,1,opt,name=oneof_uint32,json=oneofUint32,oneof"`
}
type TestOneofWithRequired_OneofRequired struct {
OneofRequired *required.Message `protobuf:"bytes,2,opt,name=oneof_required,json=oneofRequired,oneof"`
}
func (*TestOneofWithRequired_OneofUint32) isTestOneofWithRequired_OneofField() {}
func (*TestOneofWithRequired_OneofRequired) isTestOneofWithRequired_OneofField() {}
type ForeignMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
C *int32 `protobuf:"varint,1,opt,name=c" json:"c,omitempty"`
D *int32 `protobuf:"varint,2,opt,name=d" json:"d,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ForeignMessage) Reset() {
*x = ForeignMessage{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ForeignMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ForeignMessage) ProtoMessage() {}
func (x *ForeignMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ForeignMessage.ProtoReflect.Descriptor instead.
func (*ForeignMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{4}
}
func (x *ForeignMessage) GetC() int32 {
if x != nil && x.C != nil {
return *x.C
}
return 0
}
func (x *ForeignMessage) GetD() int32 {
if x != nil && x.D != nil {
return *x.D
}
return 0
}
type TestReservedFields struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestReservedFields) Reset() {
*x = TestReservedFields{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestReservedFields) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestReservedFields) ProtoMessage() {}
func (x *TestReservedFields) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[5]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestReservedFields.ProtoReflect.Descriptor instead.
func (*TestReservedFields) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{5}
}
type TestAllExtensions struct {
state protoimpl.MessageState `protogen:"open.v1"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllExtensions) Reset() {
*x = TestAllExtensions{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllExtensions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllExtensions) ProtoMessage() {}
func (x *TestAllExtensions) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[6]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllExtensions.ProtoReflect.Descriptor instead.
func (*TestAllExtensions) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{6}
}
type OptionalGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,17,opt,name=a" json:"a,omitempty"`
SameFieldNumber *int32 `protobuf:"varint,16,opt,name=same_field_number,json=sameFieldNumber" json:"same_field_number,omitempty"`
OptionalNestedMessage *TestAllExtensions_NestedMessage `protobuf:"bytes,1000,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *OptionalGroup) Reset() {
*x = OptionalGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *OptionalGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*OptionalGroup) ProtoMessage() {}
func (x *OptionalGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[7]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use OptionalGroup.ProtoReflect.Descriptor instead.
func (*OptionalGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{7}
}
func (x *OptionalGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *OptionalGroup) GetSameFieldNumber() int32 {
if x != nil && x.SameFieldNumber != nil {
return *x.SameFieldNumber
}
return 0
}
func (x *OptionalGroup) GetOptionalNestedMessage() *TestAllExtensions_NestedMessage {
if x != nil {
return x.OptionalNestedMessage
}
return nil
}
type RepeatedGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,47,opt,name=a" json:"a,omitempty"`
OptionalNestedMessage *TestAllExtensions_NestedMessage `protobuf:"bytes,1001,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *RepeatedGroup) Reset() {
*x = RepeatedGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *RepeatedGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RepeatedGroup) ProtoMessage() {}
func (x *RepeatedGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[8]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RepeatedGroup.ProtoReflect.Descriptor instead.
func (*RepeatedGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{8}
}
func (x *RepeatedGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *RepeatedGroup) GetOptionalNestedMessage() *TestAllExtensions_NestedMessage {
if x != nil {
return x.OptionalNestedMessage
}
return nil
}
type TestNestedExtension struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestNestedExtension) Reset() {
*x = TestNestedExtension{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestNestedExtension) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestNestedExtension) ProtoMessage() {}
func (x *TestNestedExtension) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[9]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestNestedExtension.ProtoReflect.Descriptor instead.
func (*TestNestedExtension) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{9}
}
type TestRequired struct {
state protoimpl.MessageState `protogen:"open.v1"`
RequiredField *int32 `protobuf:"varint,1,req,name=required_field,json=requiredField" json:"required_field,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestRequired) Reset() {
*x = TestRequired{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestRequired) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestRequired) ProtoMessage() {}
func (x *TestRequired) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[10]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestRequired.ProtoReflect.Descriptor instead.
func (*TestRequired) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{10}
}
func (x *TestRequired) GetRequiredField() int32 {
if x != nil && x.RequiredField != nil {
return *x.RequiredField
}
return 0
}
type TestRequiredForeign struct {
state protoimpl.MessageState `protogen:"open.v1"`
OptionalMessage *TestRequired `protobuf:"bytes,1,opt,name=optional_message,json=optionalMessage" json:"optional_message,omitempty"`
RepeatedMessage []*TestRequired `protobuf:"bytes,2,rep,name=repeated_message,json=repeatedMessage" json:"repeated_message,omitempty"`
MapMessage map[int32]*TestRequired `protobuf:"bytes,3,rep,name=map_message,json=mapMessage" json:"map_message,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Types that are valid to be assigned to OneofField:
//
// *TestRequiredForeign_OneofMessage
OneofField isTestRequiredForeign_OneofField `protobuf_oneof:"oneof_field"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestRequiredForeign) Reset() {
*x = TestRequiredForeign{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestRequiredForeign) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestRequiredForeign) ProtoMessage() {}
func (x *TestRequiredForeign) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[11]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestRequiredForeign.ProtoReflect.Descriptor instead.
func (*TestRequiredForeign) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{11}
}
func (x *TestRequiredForeign) GetOptionalMessage() *TestRequired {
if x != nil {
return x.OptionalMessage
}
return nil
}
func (x *TestRequiredForeign) GetRepeatedMessage() []*TestRequired {
if x != nil {
return x.RepeatedMessage
}
return nil
}
func (x *TestRequiredForeign) GetMapMessage() map[int32]*TestRequired {
if x != nil {
return x.MapMessage
}
return nil
}
func (x *TestRequiredForeign) GetOneofField() isTestRequiredForeign_OneofField {
if x != nil {
return x.OneofField
}
return nil
}
func (x *TestRequiredForeign) GetOneofMessage() *TestRequired {
if x != nil {
if x, ok := x.OneofField.(*TestRequiredForeign_OneofMessage); ok {
return x.OneofMessage
}
}
return nil
}
type isTestRequiredForeign_OneofField interface {
isTestRequiredForeign_OneofField()
}
type TestRequiredForeign_OneofMessage struct {
OneofMessage *TestRequired `protobuf:"bytes,4,opt,name=oneof_message,json=oneofMessage,oneof"`
}
func (*TestRequiredForeign_OneofMessage) isTestRequiredForeign_OneofField() {}
type TestRequiredGroupFields struct {
state protoimpl.MessageState `protogen:"open.v1"`
Optionalgroup *TestRequiredGroupFields_OptionalGroup `protobuf:"group,1,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
Repeatedgroup []*TestRequiredGroupFields_RepeatedGroup `protobuf:"group,3,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestRequiredGroupFields) Reset() {
*x = TestRequiredGroupFields{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestRequiredGroupFields) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestRequiredGroupFields) ProtoMessage() {}
func (x *TestRequiredGroupFields) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[12]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestRequiredGroupFields.ProtoReflect.Descriptor instead.
func (*TestRequiredGroupFields) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{12}
}
func (x *TestRequiredGroupFields) GetOptionalgroup() *TestRequiredGroupFields_OptionalGroup {
if x != nil {
return x.Optionalgroup
}
return nil
}
func (x *TestRequiredGroupFields) GetRepeatedgroup() []*TestRequiredGroupFields_RepeatedGroup {
if x != nil {
return x.Repeatedgroup
}
return nil
}
type TestRequiredLazy struct {
state protoimpl.MessageState `protogen:"open.v1"`
OptionalLazyMessage *TestRequired `protobuf:"bytes,1,opt,name=optional_lazy_message,json=optionalLazyMessage" json:"optional_lazy_message,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestRequiredLazy) Reset() {
*x = TestRequiredLazy{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestRequiredLazy) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestRequiredLazy) ProtoMessage() {}
func (x *TestRequiredLazy) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[13]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestRequiredLazy.ProtoReflect.Descriptor instead.
func (*TestRequiredLazy) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{13}
}
func (x *TestRequiredLazy) GetOptionalLazyMessage() *TestRequired {
if x != nil {
return x.OptionalLazyMessage
}
return nil
}
type TestPackedTypes struct {
state protoimpl.MessageState `protogen:"open.v1"`
PackedInt32 []int32 `protobuf:"varint,90,rep,packed,name=packed_int32,json=packedInt32" json:"packed_int32,omitempty"`
PackedInt64 []int64 `protobuf:"varint,91,rep,packed,name=packed_int64,json=packedInt64" json:"packed_int64,omitempty"`
PackedUint32 []uint32 `protobuf:"varint,92,rep,packed,name=packed_uint32,json=packedUint32" json:"packed_uint32,omitempty"`
PackedUint64 []uint64 `protobuf:"varint,93,rep,packed,name=packed_uint64,json=packedUint64" json:"packed_uint64,omitempty"`
PackedSint32 []int32 `protobuf:"zigzag32,94,rep,packed,name=packed_sint32,json=packedSint32" json:"packed_sint32,omitempty"`
PackedSint64 []int64 `protobuf:"zigzag64,95,rep,packed,name=packed_sint64,json=packedSint64" json:"packed_sint64,omitempty"`
PackedFixed32 []uint32 `protobuf:"fixed32,96,rep,packed,name=packed_fixed32,json=packedFixed32" json:"packed_fixed32,omitempty"`
PackedFixed64 []uint64 `protobuf:"fixed64,97,rep,packed,name=packed_fixed64,json=packedFixed64" json:"packed_fixed64,omitempty"`
PackedSfixed32 []int32 `protobuf:"fixed32,98,rep,packed,name=packed_sfixed32,json=packedSfixed32" json:"packed_sfixed32,omitempty"`
PackedSfixed64 []int64 `protobuf:"fixed64,99,rep,packed,name=packed_sfixed64,json=packedSfixed64" json:"packed_sfixed64,omitempty"`
PackedFloat []float32 `protobuf:"fixed32,100,rep,packed,name=packed_float,json=packedFloat" json:"packed_float,omitempty"`
PackedDouble []float64 `protobuf:"fixed64,101,rep,packed,name=packed_double,json=packedDouble" json:"packed_double,omitempty"`
PackedBool []bool `protobuf:"varint,102,rep,packed,name=packed_bool,json=packedBool" json:"packed_bool,omitempty"`
PackedEnum []ForeignEnum `protobuf:"varint,103,rep,packed,name=packed_enum,json=packedEnum,enum=goproto.proto.test.ForeignEnum" json:"packed_enum,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestPackedTypes) Reset() {
*x = TestPackedTypes{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestPackedTypes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestPackedTypes) ProtoMessage() {}
func (x *TestPackedTypes) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[14]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestPackedTypes.ProtoReflect.Descriptor instead.
func (*TestPackedTypes) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{14}
}
func (x *TestPackedTypes) GetPackedInt32() []int32 {
if x != nil {
return x.PackedInt32
}
return nil
}
func (x *TestPackedTypes) GetPackedInt64() []int64 {
if x != nil {
return x.PackedInt64
}
return nil
}
func (x *TestPackedTypes) GetPackedUint32() []uint32 {
if x != nil {
return x.PackedUint32
}
return nil
}
func (x *TestPackedTypes) GetPackedUint64() []uint64 {
if x != nil {
return x.PackedUint64
}
return nil
}
func (x *TestPackedTypes) GetPackedSint32() []int32 {
if x != nil {
return x.PackedSint32
}
return nil
}
func (x *TestPackedTypes) GetPackedSint64() []int64 {
if x != nil {
return x.PackedSint64
}
return nil
}
func (x *TestPackedTypes) GetPackedFixed32() []uint32 {
if x != nil {
return x.PackedFixed32
}
return nil
}
func (x *TestPackedTypes) GetPackedFixed64() []uint64 {
if x != nil {
return x.PackedFixed64
}
return nil
}
func (x *TestPackedTypes) GetPackedSfixed32() []int32 {
if x != nil {
return x.PackedSfixed32
}
return nil
}
func (x *TestPackedTypes) GetPackedSfixed64() []int64 {
if x != nil {
return x.PackedSfixed64
}
return nil
}
func (x *TestPackedTypes) GetPackedFloat() []float32 {
if x != nil {
return x.PackedFloat
}
return nil
}
func (x *TestPackedTypes) GetPackedDouble() []float64 {
if x != nil {
return x.PackedDouble
}
return nil
}
func (x *TestPackedTypes) GetPackedBool() []bool {
if x != nil {
return x.PackedBool
}
return nil
}
func (x *TestPackedTypes) GetPackedEnum() []ForeignEnum {
if x != nil {
return x.PackedEnum
}
return nil
}
type TestUnpackedTypes struct {
state protoimpl.MessageState `protogen:"open.v1"`
UnpackedInt32 []int32 `protobuf:"varint,90,rep,name=unpacked_int32,json=unpackedInt32" json:"unpacked_int32,omitempty"`
UnpackedInt64 []int64 `protobuf:"varint,91,rep,name=unpacked_int64,json=unpackedInt64" json:"unpacked_int64,omitempty"`
UnpackedUint32 []uint32 `protobuf:"varint,92,rep,name=unpacked_uint32,json=unpackedUint32" json:"unpacked_uint32,omitempty"`
UnpackedUint64 []uint64 `protobuf:"varint,93,rep,name=unpacked_uint64,json=unpackedUint64" json:"unpacked_uint64,omitempty"`
UnpackedSint32 []int32 `protobuf:"zigzag32,94,rep,name=unpacked_sint32,json=unpackedSint32" json:"unpacked_sint32,omitempty"`
UnpackedSint64 []int64 `protobuf:"zigzag64,95,rep,name=unpacked_sint64,json=unpackedSint64" json:"unpacked_sint64,omitempty"`
UnpackedFixed32 []uint32 `protobuf:"fixed32,96,rep,name=unpacked_fixed32,json=unpackedFixed32" json:"unpacked_fixed32,omitempty"`
UnpackedFixed64 []uint64 `protobuf:"fixed64,97,rep,name=unpacked_fixed64,json=unpackedFixed64" json:"unpacked_fixed64,omitempty"`
UnpackedSfixed32 []int32 `protobuf:"fixed32,98,rep,name=unpacked_sfixed32,json=unpackedSfixed32" json:"unpacked_sfixed32,omitempty"`
UnpackedSfixed64 []int64 `protobuf:"fixed64,99,rep,name=unpacked_sfixed64,json=unpackedSfixed64" json:"unpacked_sfixed64,omitempty"`
UnpackedFloat []float32 `protobuf:"fixed32,100,rep,name=unpacked_float,json=unpackedFloat" json:"unpacked_float,omitempty"`
UnpackedDouble []float64 `protobuf:"fixed64,101,rep,name=unpacked_double,json=unpackedDouble" json:"unpacked_double,omitempty"`
UnpackedBool []bool `protobuf:"varint,102,rep,name=unpacked_bool,json=unpackedBool" json:"unpacked_bool,omitempty"`
UnpackedEnum []ForeignEnum `protobuf:"varint,103,rep,name=unpacked_enum,json=unpackedEnum,enum=goproto.proto.test.ForeignEnum" json:"unpacked_enum,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestUnpackedTypes) Reset() {
*x = TestUnpackedTypes{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestUnpackedTypes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestUnpackedTypes) ProtoMessage() {}
func (x *TestUnpackedTypes) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[15]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestUnpackedTypes.ProtoReflect.Descriptor instead.
func (*TestUnpackedTypes) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{15}
}
func (x *TestUnpackedTypes) GetUnpackedInt32() []int32 {
if x != nil {
return x.UnpackedInt32
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedInt64() []int64 {
if x != nil {
return x.UnpackedInt64
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedUint32() []uint32 {
if x != nil {
return x.UnpackedUint32
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedUint64() []uint64 {
if x != nil {
return x.UnpackedUint64
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedSint32() []int32 {
if x != nil {
return x.UnpackedSint32
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedSint64() []int64 {
if x != nil {
return x.UnpackedSint64
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedFixed32() []uint32 {
if x != nil {
return x.UnpackedFixed32
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedFixed64() []uint64 {
if x != nil {
return x.UnpackedFixed64
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedSfixed32() []int32 {
if x != nil {
return x.UnpackedSfixed32
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedSfixed64() []int64 {
if x != nil {
return x.UnpackedSfixed64
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedFloat() []float32 {
if x != nil {
return x.UnpackedFloat
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedDouble() []float64 {
if x != nil {
return x.UnpackedDouble
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedBool() []bool {
if x != nil {
return x.UnpackedBool
}
return nil
}
func (x *TestUnpackedTypes) GetUnpackedEnum() []ForeignEnum {
if x != nil {
return x.UnpackedEnum
}
return nil
}
type TestPackedExtensions struct {
state protoimpl.MessageState `protogen:"open.v1"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestPackedExtensions) Reset() {
*x = TestPackedExtensions{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestPackedExtensions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestPackedExtensions) ProtoMessage() {}
func (x *TestPackedExtensions) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[16]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestPackedExtensions.ProtoReflect.Descriptor instead.
func (*TestPackedExtensions) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{16}
}
type TestUnpackedExtensions struct {
state protoimpl.MessageState `protogen:"open.v1"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestUnpackedExtensions) Reset() {
*x = TestUnpackedExtensions{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestUnpackedExtensions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestUnpackedExtensions) ProtoMessage() {}
func (x *TestUnpackedExtensions) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[17]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestUnpackedExtensions.ProtoReflect.Descriptor instead.
func (*TestUnpackedExtensions) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{17}
}
// Test that RPC services work.
type FooRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FooRequest) Reset() {
*x = FooRequest{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FooRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FooRequest) ProtoMessage() {}
func (x *FooRequest) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[18]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FooRequest.ProtoReflect.Descriptor instead.
func (*FooRequest) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{18}
}
type FooResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FooResponse) Reset() {
*x = FooResponse{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FooResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FooResponse) ProtoMessage() {}
func (x *FooResponse) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[19]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FooResponse.ProtoReflect.Descriptor instead.
func (*FooResponse) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{19}
}
type WeirdDefault struct {
state protoimpl.MessageState `protogen:"open.v1"`
WeirdDefault []byte `protobuf:"bytes,1,opt,name=weird_default,json=weirdDefault,def=hello, \\\"world!\\\"\\ndead\\336\\255\\276\\357beef\x60" json:"weird_default,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for WeirdDefault fields.
var (
Default_WeirdDefault_WeirdDefault = []byte("hello, \"world!\"\ndeadޭ\xbe\xefbeef`")
)
func (x *WeirdDefault) Reset() {
*x = WeirdDefault{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *WeirdDefault) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WeirdDefault) ProtoMessage() {}
func (x *WeirdDefault) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[20]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use WeirdDefault.ProtoReflect.Descriptor instead.
func (*WeirdDefault) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{20}
}
func (x *WeirdDefault) GetWeirdDefault() []byte {
if x != nil && x.WeirdDefault != nil {
return x.WeirdDefault
}
return append([]byte(nil), Default_WeirdDefault_WeirdDefault...)
}
type RemoteDefault struct {
state protoimpl.MessageState `protogen:"open.v1"`
Default *enums.Enum `protobuf:"varint,1,opt,name=default,enum=goproto.proto.enums.Enum" json:"default,omitempty"`
Zero *enums.Enum `protobuf:"varint,2,opt,name=zero,enum=goproto.proto.enums.Enum,def=0" json:"zero,omitempty"`
One *enums.Enum `protobuf:"varint,3,opt,name=one,enum=goproto.proto.enums.Enum,def=1" json:"one,omitempty"`
Elevent *enums.Enum `protobuf:"varint,4,opt,name=elevent,enum=goproto.proto.enums.Enum,def=11" json:"elevent,omitempty"`
Seventeen *enums.Enum `protobuf:"varint,5,opt,name=seventeen,enum=goproto.proto.enums.Enum,def=17" json:"seventeen,omitempty"`
Thirtyseven *enums.Enum `protobuf:"varint,6,opt,name=thirtyseven,enum=goproto.proto.enums.Enum,def=37" json:"thirtyseven,omitempty"`
Sixtyseven *enums.Enum `protobuf:"varint,7,opt,name=sixtyseven,enum=goproto.proto.enums.Enum,def=67" json:"sixtyseven,omitempty"`
Negative *enums.Enum `protobuf:"varint,8,opt,name=negative,enum=goproto.proto.enums.Enum,def=-1" json:"negative,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for RemoteDefault fields.
const (
Default_RemoteDefault_Zero = enums.Enum(0) // enums.Enum_ZERO
Default_RemoteDefault_One = enums.Enum(1) // enums.Enum_ONE
Default_RemoteDefault_Elevent = enums.Enum(11) // enums.Enum_ELEVENT
Default_RemoteDefault_Seventeen = enums.Enum(17) // enums.Enum_SEVENTEEN
Default_RemoteDefault_Thirtyseven = enums.Enum(37) // enums.Enum_THIRTYSEVEN
Default_RemoteDefault_Sixtyseven = enums.Enum(67) // enums.Enum_SIXTYSEVEN
Default_RemoteDefault_Negative = enums.Enum(-1) // enums.Enum_NEGATIVE
)
func (x *RemoteDefault) Reset() {
*x = RemoteDefault{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *RemoteDefault) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RemoteDefault) ProtoMessage() {}
func (x *RemoteDefault) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[21]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RemoteDefault.ProtoReflect.Descriptor instead.
func (*RemoteDefault) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{21}
}
func (x *RemoteDefault) GetDefault() enums.Enum {
if x != nil && x.Default != nil {
return *x.Default
}
return enums.Enum(1337)
}
func (x *RemoteDefault) GetZero() enums.Enum {
if x != nil && x.Zero != nil {
return *x.Zero
}
return Default_RemoteDefault_Zero
}
func (x *RemoteDefault) GetOne() enums.Enum {
if x != nil && x.One != nil {
return *x.One
}
return Default_RemoteDefault_One
}
func (x *RemoteDefault) GetElevent() enums.Enum {
if x != nil && x.Elevent != nil {
return *x.Elevent
}
return Default_RemoteDefault_Elevent
}
func (x *RemoteDefault) GetSeventeen() enums.Enum {
if x != nil && x.Seventeen != nil {
return *x.Seventeen
}
return Default_RemoteDefault_Seventeen
}
func (x *RemoteDefault) GetThirtyseven() enums.Enum {
if x != nil && x.Thirtyseven != nil {
return *x.Thirtyseven
}
return Default_RemoteDefault_Thirtyseven
}
func (x *RemoteDefault) GetSixtyseven() enums.Enum {
if x != nil && x.Sixtyseven != nil {
return *x.Sixtyseven
}
return Default_RemoteDefault_Sixtyseven
}
func (x *RemoteDefault) GetNegative() enums.Enum {
if x != nil && x.Negative != nil {
return *x.Negative
}
return Default_RemoteDefault_Negative
}
type TestAllTypes_NestedMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
Corecursive *TestAllTypes `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllTypes_NestedMessage) Reset() {
*x = TestAllTypes_NestedMessage{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes_NestedMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes_NestedMessage) ProtoMessage() {}
func (x *TestAllTypes_NestedMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[22]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes_NestedMessage.ProtoReflect.Descriptor instead.
func (*TestAllTypes_NestedMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 0}
}
func (x *TestAllTypes_NestedMessage) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
if x != nil {
return x.Corecursive
}
return nil
}
type TestAllTypes_OptionalGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,17,opt,name=a" json:"a,omitempty"`
OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,1000,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
SameFieldNumber *int32 `protobuf:"varint,16,opt,name=same_field_number,json=sameFieldNumber" json:"same_field_number,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllTypes_OptionalGroup) Reset() {
*x = TestAllTypes_OptionalGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes_OptionalGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes_OptionalGroup) ProtoMessage() {}
func (x *TestAllTypes_OptionalGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[23]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes_OptionalGroup.ProtoReflect.Descriptor instead.
func (*TestAllTypes_OptionalGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 1}
}
func (x *TestAllTypes_OptionalGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *TestAllTypes_OptionalGroup) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
return x.OptionalNestedMessage
}
return nil
}
func (x *TestAllTypes_OptionalGroup) GetSameFieldNumber() int32 {
if x != nil && x.SameFieldNumber != nil {
return *x.SameFieldNumber
}
return 0
}
type TestAllTypes_RepeatedGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,47,opt,name=a" json:"a,omitempty"`
OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,1001,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllTypes_RepeatedGroup) Reset() {
*x = TestAllTypes_RepeatedGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes_RepeatedGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes_RepeatedGroup) ProtoMessage() {}
func (x *TestAllTypes_RepeatedGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[24]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes_RepeatedGroup.ProtoReflect.Descriptor instead.
func (*TestAllTypes_RepeatedGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 2}
}
func (x *TestAllTypes_RepeatedGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *TestAllTypes_RepeatedGroup) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
return x.OptionalNestedMessage
}
return nil
}
type TestAllTypes_OneofGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
B *int32 `protobuf:"varint,2,opt,name=b" json:"b,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllTypes_OneofGroup) Reset() {
*x = TestAllTypes_OneofGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[42]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes_OneofGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes_OneofGroup) ProtoMessage() {}
func (x *TestAllTypes_OneofGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[42]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes_OneofGroup.ProtoReflect.Descriptor instead.
func (*TestAllTypes_OneofGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{0, 20}
}
func (x *TestAllTypes_OneofGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *TestAllTypes_OneofGroup) GetB() int32 {
if x != nil && x.B != nil {
return *x.B
}
return 0
}
type TestAllExtensions_NestedMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
Corecursive *TestAllExtensions `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllExtensions_NestedMessage) Reset() {
*x = TestAllExtensions_NestedMessage{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[43]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllExtensions_NestedMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllExtensions_NestedMessage) ProtoMessage() {}
func (x *TestAllExtensions_NestedMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[43]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllExtensions_NestedMessage.ProtoReflect.Descriptor instead.
func (*TestAllExtensions_NestedMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{6, 0}
}
func (x *TestAllExtensions_NestedMessage) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
func (x *TestAllExtensions_NestedMessage) GetCorecursive() *TestAllExtensions {
if x != nil {
return x.Corecursive
}
return nil
}
type TestRequiredGroupFields_OptionalGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,2,req,name=a" json:"a,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestRequiredGroupFields_OptionalGroup) Reset() {
*x = TestRequiredGroupFields_OptionalGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[45]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestRequiredGroupFields_OptionalGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestRequiredGroupFields_OptionalGroup) ProtoMessage() {}
func (x *TestRequiredGroupFields_OptionalGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[45]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestRequiredGroupFields_OptionalGroup.ProtoReflect.Descriptor instead.
func (*TestRequiredGroupFields_OptionalGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{12, 0}
}
func (x *TestRequiredGroupFields_OptionalGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
type TestRequiredGroupFields_RepeatedGroup struct {
state protoimpl.MessageState `protogen:"open.v1"`
A *int32 `protobuf:"varint,4,req,name=a" json:"a,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestRequiredGroupFields_RepeatedGroup) Reset() {
*x = TestRequiredGroupFields_RepeatedGroup{}
mi := &file_internal_testprotos_test_test_proto_msgTypes[46]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestRequiredGroupFields_RepeatedGroup) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestRequiredGroupFields_RepeatedGroup) ProtoMessage() {}
func (x *TestRequiredGroupFields_RepeatedGroup) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_proto_msgTypes[46]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestRequiredGroupFields_RepeatedGroup.ProtoReflect.Descriptor instead.
func (*TestRequiredGroupFields_RepeatedGroup) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_proto_rawDescGZIP(), []int{12, 1}
}
func (x *TestRequiredGroupFields_RepeatedGroup) GetA() int32 {
if x != nil && x.A != nil {
return *x.A
}
return 0
}
var file_internal_testprotos_test_test_proto_extTypes = []protoimpl.ExtensionInfo{
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 1,
Name: "goproto.proto.test.optional_int32",
Tag: "varint,1,opt,name=optional_int32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int64)(nil),
Field: 2,
Name: "goproto.proto.test.optional_int64",
Tag: "varint,2,opt,name=optional_int64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint32)(nil),
Field: 3,
Name: "goproto.proto.test.optional_uint32",
Tag: "varint,3,opt,name=optional_uint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint64)(nil),
Field: 4,
Name: "goproto.proto.test.optional_uint64",
Tag: "varint,4,opt,name=optional_uint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 5,
Name: "goproto.proto.test.optional_sint32",
Tag: "zigzag32,5,opt,name=optional_sint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int64)(nil),
Field: 6,
Name: "goproto.proto.test.optional_sint64",
Tag: "zigzag64,6,opt,name=optional_sint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint32)(nil),
Field: 7,
Name: "goproto.proto.test.optional_fixed32",
Tag: "fixed32,7,opt,name=optional_fixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint64)(nil),
Field: 8,
Name: "goproto.proto.test.optional_fixed64",
Tag: "fixed64,8,opt,name=optional_fixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 9,
Name: "goproto.proto.test.optional_sfixed32",
Tag: "fixed32,9,opt,name=optional_sfixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int64)(nil),
Field: 10,
Name: "goproto.proto.test.optional_sfixed64",
Tag: "fixed64,10,opt,name=optional_sfixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*float32)(nil),
Field: 11,
Name: "goproto.proto.test.optional_float",
Tag: "fixed32,11,opt,name=optional_float",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*float64)(nil),
Field: 12,
Name: "goproto.proto.test.optional_double",
Tag: "fixed64,12,opt,name=optional_double",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*bool)(nil),
Field: 13,
Name: "goproto.proto.test.optional_bool",
Tag: "varint,13,opt,name=optional_bool",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*string)(nil),
Field: 14,
Name: "goproto.proto.test.optional_string",
Tag: "bytes,14,opt,name=optional_string",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]byte)(nil),
Field: 15,
Name: "goproto.proto.test.optional_bytes",
Tag: "bytes,15,opt,name=optional_bytes",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*OptionalGroup)(nil),
Field: 16,
Name: "goproto.proto.test.optionalgroup",
Tag: "group,16,opt,name=OptionalGroup",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*TestAllExtensions_NestedMessage)(nil),
Field: 18,
Name: "goproto.proto.test.optional_nested_message",
Tag: "bytes,18,opt,name=optional_nested_message",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*TestAllTypes_NestedEnum)(nil),
Field: 21,
Name: "goproto.proto.test.optional_nested_enum",
Tag: "varint,21,opt,name=optional_nested_enum,enum=goproto.proto.test.TestAllTypes_NestedEnum",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 31,
Name: "goproto.proto.test.repeated_int32",
Tag: "varint,31,rep,name=repeated_int32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 32,
Name: "goproto.proto.test.repeated_int64",
Tag: "varint,32,rep,name=repeated_int64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 33,
Name: "goproto.proto.test.repeated_uint32",
Tag: "varint,33,rep,name=repeated_uint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 34,
Name: "goproto.proto.test.repeated_uint64",
Tag: "varint,34,rep,name=repeated_uint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 35,
Name: "goproto.proto.test.repeated_sint32",
Tag: "zigzag32,35,rep,name=repeated_sint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 36,
Name: "goproto.proto.test.repeated_sint64",
Tag: "zigzag64,36,rep,name=repeated_sint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 37,
Name: "goproto.proto.test.repeated_fixed32",
Tag: "fixed32,37,rep,name=repeated_fixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 38,
Name: "goproto.proto.test.repeated_fixed64",
Tag: "fixed64,38,rep,name=repeated_fixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 39,
Name: "goproto.proto.test.repeated_sfixed32",
Tag: "fixed32,39,rep,name=repeated_sfixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 40,
Name: "goproto.proto.test.repeated_sfixed64",
Tag: "fixed64,40,rep,name=repeated_sfixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]float32)(nil),
Field: 41,
Name: "goproto.proto.test.repeated_float",
Tag: "fixed32,41,rep,name=repeated_float",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]float64)(nil),
Field: 42,
Name: "goproto.proto.test.repeated_double",
Tag: "fixed64,42,rep,name=repeated_double",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]bool)(nil),
Field: 43,
Name: "goproto.proto.test.repeated_bool",
Tag: "varint,43,rep,name=repeated_bool",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]string)(nil),
Field: 44,
Name: "goproto.proto.test.repeated_string",
Tag: "bytes,44,rep,name=repeated_string",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([][]byte)(nil),
Field: 45,
Name: "goproto.proto.test.repeated_bytes",
Tag: "bytes,45,rep,name=repeated_bytes",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]*RepeatedGroup)(nil),
Field: 46,
Name: "goproto.proto.test.repeatedgroup",
Tag: "group,46,rep,name=RepeatedGroup",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]*TestAllExtensions_NestedMessage)(nil),
Field: 48,
Name: "goproto.proto.test.repeated_nested_message",
Tag: "bytes,48,rep,name=repeated_nested_message",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]TestAllTypes_NestedEnum)(nil),
Field: 51,
Name: "goproto.proto.test.repeated_nested_enum",
Tag: "varint,51,rep,name=repeated_nested_enum,enum=goproto.proto.test.TestAllTypes_NestedEnum",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 81,
Name: "goproto.proto.test.default_int32",
Tag: "varint,81,opt,name=default_int32,def=81",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int64)(nil),
Field: 82,
Name: "goproto.proto.test.default_int64",
Tag: "varint,82,opt,name=default_int64,def=82",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint32)(nil),
Field: 83,
Name: "goproto.proto.test.default_uint32",
Tag: "varint,83,opt,name=default_uint32,def=83",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint64)(nil),
Field: 84,
Name: "goproto.proto.test.default_uint64",
Tag: "varint,84,opt,name=default_uint64,def=84",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 85,
Name: "goproto.proto.test.default_sint32",
Tag: "zigzag32,85,opt,name=default_sint32,def=-85",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int64)(nil),
Field: 86,
Name: "goproto.proto.test.default_sint64",
Tag: "zigzag64,86,opt,name=default_sint64,def=86",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint32)(nil),
Field: 87,
Name: "goproto.proto.test.default_fixed32",
Tag: "fixed32,87,opt,name=default_fixed32,def=87",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*uint64)(nil),
Field: 88,
Name: "goproto.proto.test.default_fixed64",
Tag: "fixed64,88,opt,name=default_fixed64,def=88",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int32)(nil),
Field: 89,
Name: "goproto.proto.test.default_sfixed32",
Tag: "fixed32,89,opt,name=default_sfixed32,def=89",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*int64)(nil),
Field: 80,
Name: "goproto.proto.test.default_sfixed64",
Tag: "fixed64,80,opt,name=default_sfixed64,def=-90",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*float32)(nil),
Field: 91,
Name: "goproto.proto.test.default_float",
Tag: "fixed32,91,opt,name=default_float,def=91.5",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*float64)(nil),
Field: 92,
Name: "goproto.proto.test.default_double",
Tag: "fixed64,92,opt,name=default_double,def=92000",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*bool)(nil),
Field: 93,
Name: "goproto.proto.test.default_bool",
Tag: "varint,93,opt,name=default_bool,def=1",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*string)(nil),
Field: 94,
Name: "goproto.proto.test.default_string",
Tag: "bytes,94,opt,name=default_string,def=hello",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]byte)(nil),
Field: 95,
Name: "goproto.proto.test.default_bytes",
Tag: "bytes,95,opt,name=default_bytes,def=world",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 90,
Name: "goproto.proto.test.packed_int32",
Tag: "varint,90,rep,packed,name=packed_int32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 91,
Name: "goproto.proto.test.packed_int64",
Tag: "varint,91,rep,packed,name=packed_int64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 92,
Name: "goproto.proto.test.packed_uint32",
Tag: "varint,92,rep,packed,name=packed_uint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 93,
Name: "goproto.proto.test.packed_uint64",
Tag: "varint,93,rep,packed,name=packed_uint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 94,
Name: "goproto.proto.test.packed_sint32",
Tag: "zigzag32,94,rep,packed,name=packed_sint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 95,
Name: "goproto.proto.test.packed_sint64",
Tag: "zigzag64,95,rep,packed,name=packed_sint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 96,
Name: "goproto.proto.test.packed_fixed32",
Tag: "fixed32,96,rep,packed,name=packed_fixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 97,
Name: "goproto.proto.test.packed_fixed64",
Tag: "fixed64,97,rep,packed,name=packed_fixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 98,
Name: "goproto.proto.test.packed_sfixed32",
Tag: "fixed32,98,rep,packed,name=packed_sfixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 99,
Name: "goproto.proto.test.packed_sfixed64",
Tag: "fixed64,99,rep,packed,name=packed_sfixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]float32)(nil),
Field: 100,
Name: "goproto.proto.test.packed_float",
Tag: "fixed32,100,rep,packed,name=packed_float",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]float64)(nil),
Field: 101,
Name: "goproto.proto.test.packed_double",
Tag: "fixed64,101,rep,packed,name=packed_double",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]bool)(nil),
Field: 102,
Name: "goproto.proto.test.packed_bool",
Tag: "varint,102,rep,packed,name=packed_bool",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestPackedExtensions)(nil),
ExtensionType: ([]ForeignEnum)(nil),
Field: 103,
Name: "goproto.proto.test.packed_enum",
Tag: "varint,103,rep,packed,name=packed_enum,enum=goproto.proto.test.ForeignEnum",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 90,
Name: "goproto.proto.test.unpacked_int32",
Tag: "varint,90,rep,name=unpacked_int32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 91,
Name: "goproto.proto.test.unpacked_int64",
Tag: "varint,91,rep,name=unpacked_int64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 92,
Name: "goproto.proto.test.unpacked_uint32",
Tag: "varint,92,rep,name=unpacked_uint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 93,
Name: "goproto.proto.test.unpacked_uint64",
Tag: "varint,93,rep,name=unpacked_uint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 94,
Name: "goproto.proto.test.unpacked_sint32",
Tag: "zigzag32,94,rep,name=unpacked_sint32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 95,
Name: "goproto.proto.test.unpacked_sint64",
Tag: "zigzag64,95,rep,name=unpacked_sint64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 96,
Name: "goproto.proto.test.unpacked_fixed32",
Tag: "fixed32,96,rep,name=unpacked_fixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 97,
Name: "goproto.proto.test.unpacked_fixed64",
Tag: "fixed64,97,rep,name=unpacked_fixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]int32)(nil),
Field: 98,
Name: "goproto.proto.test.unpacked_sfixed32",
Tag: "fixed32,98,rep,name=unpacked_sfixed32",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]int64)(nil),
Field: 99,
Name: "goproto.proto.test.unpacked_sfixed64",
Tag: "fixed64,99,rep,name=unpacked_sfixed64",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]float32)(nil),
Field: 100,
Name: "goproto.proto.test.unpacked_float",
Tag: "fixed32,100,rep,name=unpacked_float",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]float64)(nil),
Field: 101,
Name: "goproto.proto.test.unpacked_double",
Tag: "fixed64,101,rep,name=unpacked_double",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]bool)(nil),
Field: 102,
Name: "goproto.proto.test.unpacked_bool",
Tag: "varint,102,rep,name=unpacked_bool",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestUnpackedExtensions)(nil),
ExtensionType: ([]ForeignEnum)(nil),
Field: 103,
Name: "goproto.proto.test.unpacked_enum",
Tag: "varint,103,rep,name=unpacked_enum,enum=goproto.proto.test.ForeignEnum",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*string)(nil),
Field: 1003,
Name: "goproto.proto.test.TestNestedExtension.nested_string_extension",
Tag: "bytes,1003,opt,name=nested_string_extension",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: (*TestRequired)(nil),
Field: 1000,
Name: "goproto.proto.test.TestRequired.single",
Tag: "bytes,1000,opt,name=single",
Filename: "internal/testprotos/test/test.proto",
},
{
ExtendedType: (*TestAllExtensions)(nil),
ExtensionType: ([]*TestRequired)(nil),
Field: 1001,
Name: "goproto.proto.test.TestRequired.multi",
Tag: "bytes,1001,rep,name=multi",
Filename: "internal/testprotos/test/test.proto",
},
}
// Extension fields to TestAllExtensions.
var (
// optional int32 optional_int32 = 1;
E_OptionalInt32 = &file_internal_testprotos_test_test_proto_extTypes[0]
// optional int64 optional_int64 = 2;
E_OptionalInt64 = &file_internal_testprotos_test_test_proto_extTypes[1]
// optional uint32 optional_uint32 = 3;
E_OptionalUint32 = &file_internal_testprotos_test_test_proto_extTypes[2]
// optional uint64 optional_uint64 = 4;
E_OptionalUint64 = &file_internal_testprotos_test_test_proto_extTypes[3]
// optional sint32 optional_sint32 = 5;
E_OptionalSint32 = &file_internal_testprotos_test_test_proto_extTypes[4]
// optional sint64 optional_sint64 = 6;
E_OptionalSint64 = &file_internal_testprotos_test_test_proto_extTypes[5]
// optional fixed32 optional_fixed32 = 7;
E_OptionalFixed32 = &file_internal_testprotos_test_test_proto_extTypes[6]
// optional fixed64 optional_fixed64 = 8;
E_OptionalFixed64 = &file_internal_testprotos_test_test_proto_extTypes[7]
// optional sfixed32 optional_sfixed32 = 9;
E_OptionalSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[8]
// optional sfixed64 optional_sfixed64 = 10;
E_OptionalSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[9]
// optional float optional_float = 11;
E_OptionalFloat = &file_internal_testprotos_test_test_proto_extTypes[10]
// optional double optional_double = 12;
E_OptionalDouble = &file_internal_testprotos_test_test_proto_extTypes[11]
// optional bool optional_bool = 13;
E_OptionalBool = &file_internal_testprotos_test_test_proto_extTypes[12]
// optional string optional_string = 14;
E_OptionalString = &file_internal_testprotos_test_test_proto_extTypes[13]
// optional bytes optional_bytes = 15;
E_OptionalBytes = &file_internal_testprotos_test_test_proto_extTypes[14]
// optional goproto.proto.test.OptionalGroup optionalgroup = 16;
E_Optionalgroup = &file_internal_testprotos_test_test_proto_extTypes[15]
// optional goproto.proto.test.TestAllExtensions.NestedMessage optional_nested_message = 18;
E_OptionalNestedMessage = &file_internal_testprotos_test_test_proto_extTypes[16]
// optional goproto.proto.test.TestAllTypes.NestedEnum optional_nested_enum = 21;
E_OptionalNestedEnum = &file_internal_testprotos_test_test_proto_extTypes[17]
// repeated int32 repeated_int32 = 31;
E_RepeatedInt32 = &file_internal_testprotos_test_test_proto_extTypes[18]
// repeated int64 repeated_int64 = 32;
E_RepeatedInt64 = &file_internal_testprotos_test_test_proto_extTypes[19]
// repeated uint32 repeated_uint32 = 33;
E_RepeatedUint32 = &file_internal_testprotos_test_test_proto_extTypes[20]
// repeated uint64 repeated_uint64 = 34;
E_RepeatedUint64 = &file_internal_testprotos_test_test_proto_extTypes[21]
// repeated sint32 repeated_sint32 = 35;
E_RepeatedSint32 = &file_internal_testprotos_test_test_proto_extTypes[22]
// repeated sint64 repeated_sint64 = 36;
E_RepeatedSint64 = &file_internal_testprotos_test_test_proto_extTypes[23]
// repeated fixed32 repeated_fixed32 = 37;
E_RepeatedFixed32 = &file_internal_testprotos_test_test_proto_extTypes[24]
// repeated fixed64 repeated_fixed64 = 38;
E_RepeatedFixed64 = &file_internal_testprotos_test_test_proto_extTypes[25]
// repeated sfixed32 repeated_sfixed32 = 39;
E_RepeatedSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[26]
// repeated sfixed64 repeated_sfixed64 = 40;
E_RepeatedSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[27]
// repeated float repeated_float = 41;
E_RepeatedFloat = &file_internal_testprotos_test_test_proto_extTypes[28]
// repeated double repeated_double = 42;
E_RepeatedDouble = &file_internal_testprotos_test_test_proto_extTypes[29]
// repeated bool repeated_bool = 43;
E_RepeatedBool = &file_internal_testprotos_test_test_proto_extTypes[30]
// repeated string repeated_string = 44;
E_RepeatedString = &file_internal_testprotos_test_test_proto_extTypes[31]
// repeated bytes repeated_bytes = 45;
E_RepeatedBytes = &file_internal_testprotos_test_test_proto_extTypes[32]
// repeated goproto.proto.test.RepeatedGroup repeatedgroup = 46;
E_Repeatedgroup = &file_internal_testprotos_test_test_proto_extTypes[33]
// repeated goproto.proto.test.TestAllExtensions.NestedMessage repeated_nested_message = 48;
E_RepeatedNestedMessage = &file_internal_testprotos_test_test_proto_extTypes[34]
// repeated goproto.proto.test.TestAllTypes.NestedEnum repeated_nested_enum = 51;
E_RepeatedNestedEnum = &file_internal_testprotos_test_test_proto_extTypes[35]
// optional int32 default_int32 = 81;
E_DefaultInt32 = &file_internal_testprotos_test_test_proto_extTypes[36]
// optional int64 default_int64 = 82;
E_DefaultInt64 = &file_internal_testprotos_test_test_proto_extTypes[37]
// optional uint32 default_uint32 = 83;
E_DefaultUint32 = &file_internal_testprotos_test_test_proto_extTypes[38]
// optional uint64 default_uint64 = 84;
E_DefaultUint64 = &file_internal_testprotos_test_test_proto_extTypes[39]
// optional sint32 default_sint32 = 85;
E_DefaultSint32 = &file_internal_testprotos_test_test_proto_extTypes[40]
// optional sint64 default_sint64 = 86;
E_DefaultSint64 = &file_internal_testprotos_test_test_proto_extTypes[41]
// optional fixed32 default_fixed32 = 87;
E_DefaultFixed32 = &file_internal_testprotos_test_test_proto_extTypes[42]
// optional fixed64 default_fixed64 = 88;
E_DefaultFixed64 = &file_internal_testprotos_test_test_proto_extTypes[43]
// optional sfixed32 default_sfixed32 = 89;
E_DefaultSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[44]
// optional sfixed64 default_sfixed64 = 80;
E_DefaultSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[45]
// optional float default_float = 91;
E_DefaultFloat = &file_internal_testprotos_test_test_proto_extTypes[46]
// optional double default_double = 92;
E_DefaultDouble = &file_internal_testprotos_test_test_proto_extTypes[47]
// optional bool default_bool = 93;
E_DefaultBool = &file_internal_testprotos_test_test_proto_extTypes[48]
// optional string default_string = 94;
E_DefaultString = &file_internal_testprotos_test_test_proto_extTypes[49]
// optional bytes default_bytes = 95;
E_DefaultBytes = &file_internal_testprotos_test_test_proto_extTypes[50]
// optional string nested_string_extension = 1003;
E_TestNestedExtension_NestedStringExtension = &file_internal_testprotos_test_test_proto_extTypes[79]
// optional goproto.proto.test.TestRequired single = 1000;
E_TestRequired_Single = &file_internal_testprotos_test_test_proto_extTypes[80]
// repeated goproto.proto.test.TestRequired multi = 1001;
E_TestRequired_Multi = &file_internal_testprotos_test_test_proto_extTypes[81]
)
// Extension fields to TestPackedExtensions.
var (
// repeated int32 packed_int32 = 90;
E_PackedInt32 = &file_internal_testprotos_test_test_proto_extTypes[51]
// repeated int64 packed_int64 = 91;
E_PackedInt64 = &file_internal_testprotos_test_test_proto_extTypes[52]
// repeated uint32 packed_uint32 = 92;
E_PackedUint32 = &file_internal_testprotos_test_test_proto_extTypes[53]
// repeated uint64 packed_uint64 = 93;
E_PackedUint64 = &file_internal_testprotos_test_test_proto_extTypes[54]
// repeated sint32 packed_sint32 = 94;
E_PackedSint32 = &file_internal_testprotos_test_test_proto_extTypes[55]
// repeated sint64 packed_sint64 = 95;
E_PackedSint64 = &file_internal_testprotos_test_test_proto_extTypes[56]
// repeated fixed32 packed_fixed32 = 96;
E_PackedFixed32 = &file_internal_testprotos_test_test_proto_extTypes[57]
// repeated fixed64 packed_fixed64 = 97;
E_PackedFixed64 = &file_internal_testprotos_test_test_proto_extTypes[58]
// repeated sfixed32 packed_sfixed32 = 98;
E_PackedSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[59]
// repeated sfixed64 packed_sfixed64 = 99;
E_PackedSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[60]
// repeated float packed_float = 100;
E_PackedFloat = &file_internal_testprotos_test_test_proto_extTypes[61]
// repeated double packed_double = 101;
E_PackedDouble = &file_internal_testprotos_test_test_proto_extTypes[62]
// repeated bool packed_bool = 102;
E_PackedBool = &file_internal_testprotos_test_test_proto_extTypes[63]
// repeated goproto.proto.test.ForeignEnum packed_enum = 103;
E_PackedEnum = &file_internal_testprotos_test_test_proto_extTypes[64]
)
// Extension fields to TestUnpackedExtensions.
var (
// repeated int32 unpacked_int32 = 90;
E_UnpackedInt32 = &file_internal_testprotos_test_test_proto_extTypes[65]
// repeated int64 unpacked_int64 = 91;
E_UnpackedInt64 = &file_internal_testprotos_test_test_proto_extTypes[66]
// repeated uint32 unpacked_uint32 = 92;
E_UnpackedUint32 = &file_internal_testprotos_test_test_proto_extTypes[67]
// repeated uint64 unpacked_uint64 = 93;
E_UnpackedUint64 = &file_internal_testprotos_test_test_proto_extTypes[68]
// repeated sint32 unpacked_sint32 = 94;
E_UnpackedSint32 = &file_internal_testprotos_test_test_proto_extTypes[69]
// repeated sint64 unpacked_sint64 = 95;
E_UnpackedSint64 = &file_internal_testprotos_test_test_proto_extTypes[70]
// repeated fixed32 unpacked_fixed32 = 96;
E_UnpackedFixed32 = &file_internal_testprotos_test_test_proto_extTypes[71]
// repeated fixed64 unpacked_fixed64 = 97;
E_UnpackedFixed64 = &file_internal_testprotos_test_test_proto_extTypes[72]
// repeated sfixed32 unpacked_sfixed32 = 98;
E_UnpackedSfixed32 = &file_internal_testprotos_test_test_proto_extTypes[73]
// repeated sfixed64 unpacked_sfixed64 = 99;
E_UnpackedSfixed64 = &file_internal_testprotos_test_test_proto_extTypes[74]
// repeated float unpacked_float = 100;
E_UnpackedFloat = &file_internal_testprotos_test_test_proto_extTypes[75]
// repeated double unpacked_double = 101;
E_UnpackedDouble = &file_internal_testprotos_test_test_proto_extTypes[76]
// repeated bool unpacked_bool = 102;
E_UnpackedBool = &file_internal_testprotos_test_test_proto_extTypes[77]
// repeated goproto.proto.test.ForeignEnum unpacked_enum = 103;
E_UnpackedEnum = &file_internal_testprotos_test_test_proto_extTypes[78]
)
var File_internal_testprotos_test_test_proto protoreflect.FileDescriptor
const file_internal_testprotos_test_test_proto_rawDesc = "" +
"\n" +
"#internal/testprotos/test/test.proto\x12\x12goproto.proto.test\x1a*internal/testprotos/test/test_public.proto\x1a%internal/testprotos/enums/enums.proto\x1a+internal/testprotos/required/required.proto\x1a*internal/testprotos/test/test_import.proto\"\x9a;\n" +
"\fTestAllTypes\x12%\n" +
"\x0eoptional_int32\x18\x01 \x01(\x05R\roptionalInt32\x12%\n" +
"\x0eoptional_int64\x18\x02 \x01(\x03R\roptionalInt64\x12'\n" +
"\x0foptional_uint32\x18\x03 \x01(\rR\x0eoptionalUint32\x12'\n" +
"\x0foptional_uint64\x18\x04 \x01(\x04R\x0eoptionalUint64\x12'\n" +
"\x0foptional_sint32\x18\x05 \x01(\x11R\x0eoptionalSint32\x12'\n" +
"\x0foptional_sint64\x18\x06 \x01(\x12R\x0eoptionalSint64\x12)\n" +
"\x10optional_fixed32\x18\a \x01(\aR\x0foptionalFixed32\x12)\n" +
"\x10optional_fixed64\x18\b \x01(\x06R\x0foptionalFixed64\x12+\n" +
"\x11optional_sfixed32\x18\t \x01(\x0fR\x10optionalSfixed32\x12+\n" +
"\x11optional_sfixed64\x18\n" +
" \x01(\x10R\x10optionalSfixed64\x12%\n" +
"\x0eoptional_float\x18\v \x01(\x02R\roptionalFloat\x12'\n" +
"\x0foptional_double\x18\f \x01(\x01R\x0eoptionalDouble\x12#\n" +
"\roptional_bool\x18\r \x01(\bR\foptionalBool\x12'\n" +
"\x0foptional_string\x18\x0e \x01(\tR\x0eoptionalString\x12%\n" +
"\x0eoptional_bytes\x18\x0f \x01(\fR\roptionalBytes\x12T\n" +
"\roptionalgroup\x18\x10 \x01(\n" +
"2..goproto.proto.test.TestAllTypes.OptionalGroupR\roptionalgroup\x12f\n" +
"\x17optional_nested_message\x18\x12 \x01(\v2..goproto.proto.test.TestAllTypes.NestedMessageR\x15optionalNestedMessage\x12\\\n" +
"\x18optional_foreign_message\x18\x13 \x01(\v2\".goproto.proto.test.ForeignMessageR\x16optionalForeignMessage\x12Y\n" +
"\x17optional_import_message\x18\x14 \x01(\v2!.goproto.proto.test.ImportMessageR\x15optionalImportMessage\x12]\n" +
"\x14optional_nested_enum\x18\x15 \x01(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnumR\x12optionalNestedEnum\x12S\n" +
"\x15optional_foreign_enum\x18\x16 \x01(\x0e2\x1f.goproto.proto.test.ForeignEnumR\x13optionalForeignEnum\x12P\n" +
"\x14optional_import_enum\x18\x17 \x01(\x0e2\x1e.goproto.proto.test.ImportEnumR\x12optionalImportEnum\x12s\n" +
"\x1coptional_lazy_nested_message\x18\x18 \x01(\v2..goproto.proto.test.TestAllTypes.NestedMessageB\x02(\x01R\x19optionalLazyNestedMessage\x12%\n" +
"\x0erepeated_int32\x18\x1f \x03(\x05R\rrepeatedInt32\x12%\n" +
"\x0erepeated_int64\x18 \x03(\x03R\rrepeatedInt64\x12'\n" +
"\x0frepeated_uint32\x18! \x03(\rR\x0erepeatedUint32\x12'\n" +
"\x0frepeated_uint64\x18\" \x03(\x04R\x0erepeatedUint64\x12'\n" +
"\x0frepeated_sint32\x18# \x03(\x11R\x0erepeatedSint32\x12'\n" +
"\x0frepeated_sint64\x18$ \x03(\x12R\x0erepeatedSint64\x12)\n" +
"\x10repeated_fixed32\x18% \x03(\aR\x0frepeatedFixed32\x12)\n" +
"\x10repeated_fixed64\x18& \x03(\x06R\x0frepeatedFixed64\x12+\n" +
"\x11repeated_sfixed32\x18' \x03(\x0fR\x10repeatedSfixed32\x12+\n" +
"\x11repeated_sfixed64\x18( \x03(\x10R\x10repeatedSfixed64\x12%\n" +
"\x0erepeated_float\x18) \x03(\x02R\rrepeatedFloat\x12'\n" +
"\x0frepeated_double\x18* \x03(\x01R\x0erepeatedDouble\x12#\n" +
"\rrepeated_bool\x18+ \x03(\bR\frepeatedBool\x12'\n" +
"\x0frepeated_string\x18, \x03(\tR\x0erepeatedString\x12%\n" +
"\x0erepeated_bytes\x18- \x03(\fR\rrepeatedBytes\x12T\n" +
"\rrepeatedgroup\x18. \x03(\n" +
"2..goproto.proto.test.TestAllTypes.RepeatedGroupR\rrepeatedgroup\x12f\n" +
"\x17repeated_nested_message\x180 \x03(\v2..goproto.proto.test.TestAllTypes.NestedMessageR\x15repeatedNestedMessage\x12\\\n" +
"\x18repeated_foreign_message\x181 \x03(\v2\".goproto.proto.test.ForeignMessageR\x16repeatedForeignMessage\x12X\n" +
"\x16repeated_importmessage\x182 \x03(\v2!.goproto.proto.test.ImportMessageR\x15repeatedImportmessage\x12]\n" +
"\x14repeated_nested_enum\x183 \x03(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnumR\x12repeatedNestedEnum\x12S\n" +
"\x15repeated_foreign_enum\x184 \x03(\x0e2\x1f.goproto.proto.test.ForeignEnumR\x13repeatedForeignEnum\x12O\n" +
"\x13repeated_importenum\x185 \x03(\x0e2\x1e.goproto.proto.test.ImportEnumR\x12repeatedImportenum\x12[\n" +
"\x0fmap_int32_int32\x188 \x03(\v23.goproto.proto.test.TestAllTypes.MapInt32Int32EntryR\rmapInt32Int32\x12[\n" +
"\x0fmap_int64_int64\x189 \x03(\v23.goproto.proto.test.TestAllTypes.MapInt64Int64EntryR\rmapInt64Int64\x12a\n" +
"\x11map_uint32_uint32\x18: \x03(\v25.goproto.proto.test.TestAllTypes.MapUint32Uint32EntryR\x0fmapUint32Uint32\x12a\n" +
"\x11map_uint64_uint64\x18; \x03(\v25.goproto.proto.test.TestAllTypes.MapUint64Uint64EntryR\x0fmapUint64Uint64\x12a\n" +
"\x11map_sint32_sint32\x18< \x03(\v25.goproto.proto.test.TestAllTypes.MapSint32Sint32EntryR\x0fmapSint32Sint32\x12a\n" +
"\x11map_sint64_sint64\x18= \x03(\v25.goproto.proto.test.TestAllTypes.MapSint64Sint64EntryR\x0fmapSint64Sint64\x12g\n" +
"\x13map_fixed32_fixed32\x18> \x03(\v27.goproto.proto.test.TestAllTypes.MapFixed32Fixed32EntryR\x11mapFixed32Fixed32\x12g\n" +
"\x13map_fixed64_fixed64\x18? \x03(\v27.goproto.proto.test.TestAllTypes.MapFixed64Fixed64EntryR\x11mapFixed64Fixed64\x12m\n" +
"\x15map_sfixed32_sfixed32\x18@ \x03(\v29.goproto.proto.test.TestAllTypes.MapSfixed32Sfixed32EntryR\x13mapSfixed32Sfixed32\x12m\n" +
"\x15map_sfixed64_sfixed64\x18A \x03(\v29.goproto.proto.test.TestAllTypes.MapSfixed64Sfixed64EntryR\x13mapSfixed64Sfixed64\x12[\n" +
"\x0fmap_int32_float\x18B \x03(\v23.goproto.proto.test.TestAllTypes.MapInt32FloatEntryR\rmapInt32Float\x12^\n" +
"\x10map_int32_double\x18C \x03(\v24.goproto.proto.test.TestAllTypes.MapInt32DoubleEntryR\x0emapInt32Double\x12U\n" +
"\rmap_bool_bool\x18D \x03(\v21.goproto.proto.test.TestAllTypes.MapBoolBoolEntryR\vmapBoolBool\x12a\n" +
"\x11map_string_string\x18E \x03(\v25.goproto.proto.test.TestAllTypes.MapStringStringEntryR\x0fmapStringString\x12^\n" +
"\x10map_string_bytes\x18F \x03(\v24.goproto.proto.test.TestAllTypes.MapStringBytesEntryR\x0emapStringBytes\x12w\n" +
"\x19map_string_nested_message\x18G \x03(\v2<.goproto.proto.test.TestAllTypes.MapStringNestedMessageEntryR\x16mapStringNestedMessage\x12n\n" +
"\x16map_string_nested_enum\x18I \x03(\v29.goproto.proto.test.TestAllTypes.MapStringNestedEnumEntryR\x13mapStringNestedEnum\x12'\n" +
"\rdefault_int32\x18Q \x01(\x05:\x0281R\fdefaultInt32\x12'\n" +
"\rdefault_int64\x18R \x01(\x03:\x0282R\fdefaultInt64\x12)\n" +
"\x0edefault_uint32\x18S \x01(\r:\x0283R\rdefaultUint32\x12)\n" +
"\x0edefault_uint64\x18T \x01(\x04:\x0284R\rdefaultUint64\x12*\n" +
"\x0edefault_sint32\x18U \x01(\x11:\x03-85R\rdefaultSint32\x12)\n" +
"\x0edefault_sint64\x18V \x01(\x12:\x0286R\rdefaultSint64\x12+\n" +
"\x0fdefault_fixed32\x18W \x01(\a:\x0287R\x0edefaultFixed32\x12+\n" +
"\x0fdefault_fixed64\x18X \x01(\x06:\x0288R\x0edefaultFixed64\x12-\n" +
"\x10default_sfixed32\x18Y \x01(\x0f:\x0289R\x0fdefaultSfixed32\x12.\n" +
"\x10default_sfixed64\x18P \x01(\x10:\x03-90R\x0fdefaultSfixed64\x12)\n" +
"\rdefault_float\x18[ \x01(\x02:\x0491.5R\fdefaultFloat\x12,\n" +
"\x0edefault_double\x18\\ \x01(\x01:\x0592000R\rdefaultDouble\x12'\n" +
"\fdefault_bool\x18] \x01(\b:\x04trueR\vdefaultBool\x12,\n" +
"\x0edefault_string\x18^ \x01(\t:\x05helloR\rdefaultString\x12*\n" +
"\rdefault_bytes\x18_ \x01(\f:\x05worldR\fdefaultBytes\x12`\n" +
"\x13default_nested_enum\x18` \x01(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnum:\x03BARR\x11defaultNestedEnum\x12^\n" +
"\x14default_foreign_enum\x18a \x01(\x0e2\x1f.goproto.proto.test.ForeignEnum:\vFOREIGN_BARR\x12defaultForeignEnum\x12#\n" +
"\foneof_uint32\x18o \x01(\rH\x00R\voneofUint32\x12b\n" +
"\x14oneof_nested_message\x18p \x01(\v2..goproto.proto.test.TestAllTypes.NestedMessageH\x00R\x12oneofNestedMessage\x12#\n" +
"\foneof_string\x18q \x01(\tH\x00R\voneofString\x12!\n" +
"\voneof_bytes\x18r \x01(\fH\x00R\n" +
"oneofBytes\x12\x1f\n" +
"\n" +
"oneof_bool\x18s \x01(\bH\x00R\toneofBool\x12#\n" +
"\foneof_uint64\x18t \x01(\x04H\x00R\voneofUint64\x12!\n" +
"\voneof_float\x18u \x01(\x02H\x00R\n" +
"oneofFloat\x12#\n" +
"\foneof_double\x18v \x01(\x01H\x00R\voneofDouble\x12L\n" +
"\n" +
"oneof_enum\x18w \x01(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnumH\x00R\toneofEnum\x12M\n" +
"\n" +
"oneofgroup\x18y \x01(\n" +
"2+.goproto.proto.test.TestAllTypes.OneofGroupH\x00R\n" +
"oneofgroup\x124\n" +
"\x15oneof_optional_uint32\x18x \x01(\rH\x01R\x13oneofOptionalUint32\x1aa\n" +
"\rNestedMessage\x12\f\n" +
"\x01a\x18\x01 \x01(\x05R\x01a\x12B\n" +
"\vcorecursive\x18\x02 \x01(\v2 .goproto.proto.test.TestAllTypesR\vcorecursive\x1a\xb2\x01\n" +
"\rOptionalGroup\x12\f\n" +
"\x01a\x18\x11 \x01(\x05R\x01a\x12g\n" +
"\x17optional_nested_message\x18\xe8\a \x01(\v2..goproto.proto.test.TestAllTypes.NestedMessageR\x15optionalNestedMessage\x12*\n" +
"\x11same_field_number\x18\x10 \x01(\x05R\x0fsameFieldNumber\x1a\x86\x01\n" +
"\rRepeatedGroup\x12\f\n" +
"\x01a\x18/ \x01(\x05R\x01a\x12g\n" +
"\x17optional_nested_message\x18\xe9\a \x01(\v2..goproto.proto.test.TestAllTypes.NestedMessageR\x15optionalNestedMessage\x1a@\n" +
"\x12MapInt32Int32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\x1a@\n" +
"\x12MapInt64Int64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x03R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x03R\x05value:\x028\x01\x1aB\n" +
"\x14MapUint32Uint32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\rR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\x1aB\n" +
"\x14MapUint64Uint64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x04R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\x1aB\n" +
"\x14MapSint32Sint32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x11R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x11R\x05value:\x028\x01\x1aB\n" +
"\x14MapSint64Sint64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x12R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x12R\x05value:\x028\x01\x1aD\n" +
"\x16MapFixed32Fixed32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\aR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\aR\x05value:\x028\x01\x1aD\n" +
"\x16MapFixed64Fixed64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x06R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x06R\x05value:\x028\x01\x1aF\n" +
"\x18MapSfixed32Sfixed32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x0fR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x0fR\x05value:\x028\x01\x1aF\n" +
"\x18MapSfixed64Sfixed64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x10R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x10R\x05value:\x028\x01\x1a@\n" +
"\x12MapInt32FloatEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x02R\x05value:\x028\x01\x1aA\n" +
"\x13MapInt32DoubleEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x01R\x05value:\x028\x01\x1a>\n" +
"\x10MapBoolBoolEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\bR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\bR\x05value:\x028\x01\x1aB\n" +
"\x14MapStringStringEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1aA\n" +
"\x13MapStringBytesEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\x1ay\n" +
"\x1bMapStringNestedMessageEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12D\n" +
"\x05value\x18\x02 \x01(\v2..goproto.proto.test.TestAllTypes.NestedMessageR\x05value:\x028\x01\x1as\n" +
"\x18MapStringNestedEnumEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12A\n" +
"\x05value\x18\x02 \x01(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnumR\x05value:\x028\x01\x1a(\n" +
"\n" +
"OneofGroup\x12\f\n" +
"\x01a\x18\x01 \x01(\x05R\x01a\x12\f\n" +
"\x01b\x18\x02 \x01(\x05R\x01b\"9\n" +
"\n" +
"NestedEnum\x12\a\n" +
"\x03FOO\x10\x00\x12\a\n" +
"\x03BAR\x10\x01\x12\a\n" +
"\x03BAZ\x10\x02\x12\x10\n" +
"\x03NEG\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01B\r\n" +
"\voneof_fieldB\x10\n" +
"\x0eoneof_optional\"\xde(\n" +
"\x1cTestManyMessageFieldsMessage\x120\n" +
"\x02f1\x18\x01 \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f1\x120\n" +
"\x02f2\x18\x02 \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f2\x120\n" +
"\x02f3\x18\x03 \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f3\x120\n" +
"\x02f4\x18\x04 \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f4\x120\n" +
"\x02f5\x18\x05 \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f5\x120\n" +
"\x02f6\x18\x06 \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f6\x120\n" +
"\x02f7\x18\a \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f7\x120\n" +
"\x02f8\x18\b \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f8\x120\n" +
"\x02f9\x18\t \x01(\v2 .goproto.proto.test.TestAllTypesR\x02f9\x122\n" +
"\x03f10\x18\n" +
" \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f10\x122\n" +
"\x03f11\x18\v \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f11\x122\n" +
"\x03f12\x18\f \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f12\x122\n" +
"\x03f13\x18\r \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f13\x122\n" +
"\x03f14\x18\x0e \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f14\x122\n" +
"\x03f15\x18\x0f \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f15\x122\n" +
"\x03f16\x18\x10 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f16\x122\n" +
"\x03f17\x18\x11 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f17\x122\n" +
"\x03f18\x18\x12 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f18\x122\n" +
"\x03f19\x18\x13 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f19\x122\n" +
"\x03f20\x18\x14 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f20\x122\n" +
"\x03f21\x18\x15 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f21\x122\n" +
"\x03f22\x18\x16 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f22\x122\n" +
"\x03f23\x18\x17 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f23\x122\n" +
"\x03f24\x18\x18 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f24\x122\n" +
"\x03f25\x18\x19 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f25\x122\n" +
"\x03f26\x18\x1a \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f26\x122\n" +
"\x03f27\x18\x1b \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f27\x122\n" +
"\x03f28\x18\x1c \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f28\x122\n" +
"\x03f29\x18\x1d \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f29\x122\n" +
"\x03f30\x18\x1e \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f30\x122\n" +
"\x03f31\x18\x1f \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f31\x122\n" +
"\x03f32\x18 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f32\x122\n" +
"\x03f33\x18! \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f33\x122\n" +
"\x03f34\x18\" \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f34\x122\n" +
"\x03f35\x18# \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f35\x122\n" +
"\x03f36\x18$ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f36\x122\n" +
"\x03f37\x18% \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f37\x122\n" +
"\x03f38\x18& \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f38\x122\n" +
"\x03f39\x18' \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f39\x122\n" +
"\x03f40\x18( \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f40\x122\n" +
"\x03f41\x18) \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f41\x122\n" +
"\x03f42\x18* \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f42\x122\n" +
"\x03f43\x18+ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f43\x122\n" +
"\x03f44\x18, \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f44\x122\n" +
"\x03f45\x18- \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f45\x122\n" +
"\x03f46\x18. \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f46\x122\n" +
"\x03f47\x18/ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f47\x122\n" +
"\x03f48\x180 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f48\x122\n" +
"\x03f49\x181 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f49\x122\n" +
"\x03f50\x182 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f50\x122\n" +
"\x03f51\x183 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f51\x122\n" +
"\x03f52\x184 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f52\x122\n" +
"\x03f53\x185 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f53\x122\n" +
"\x03f54\x186 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f54\x122\n" +
"\x03f55\x187 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f55\x122\n" +
"\x03f56\x188 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f56\x122\n" +
"\x03f57\x189 \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f57\x122\n" +
"\x03f58\x18: \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f58\x122\n" +
"\x03f59\x18; \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f59\x122\n" +
"\x03f60\x18< \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f60\x122\n" +
"\x03f61\x18= \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f61\x122\n" +
"\x03f62\x18> \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f62\x122\n" +
"\x03f63\x18? \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f63\x122\n" +
"\x03f64\x18@ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f64\x122\n" +
"\x03f65\x18A \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f65\x122\n" +
"\x03f66\x18B \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f66\x122\n" +
"\x03f67\x18C \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f67\x122\n" +
"\x03f68\x18D \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f68\x122\n" +
"\x03f69\x18E \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f69\x122\n" +
"\x03f70\x18F \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f70\x122\n" +
"\x03f71\x18G \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f71\x122\n" +
"\x03f72\x18H \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f72\x122\n" +
"\x03f73\x18I \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f73\x122\n" +
"\x03f74\x18J \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f74\x122\n" +
"\x03f75\x18K \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f75\x122\n" +
"\x03f76\x18L \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f76\x122\n" +
"\x03f77\x18M \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f77\x122\n" +
"\x03f78\x18N \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f78\x122\n" +
"\x03f79\x18O \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f79\x122\n" +
"\x03f80\x18P \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f80\x122\n" +
"\x03f81\x18Q \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f81\x122\n" +
"\x03f82\x18R \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f82\x122\n" +
"\x03f83\x18S \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f83\x122\n" +
"\x03f84\x18T \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f84\x122\n" +
"\x03f85\x18U \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f85\x122\n" +
"\x03f86\x18V \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f86\x122\n" +
"\x03f87\x18W \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f87\x122\n" +
"\x03f88\x18X \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f88\x122\n" +
"\x03f89\x18Y \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f89\x122\n" +
"\x03f90\x18Z \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f90\x122\n" +
"\x03f91\x18[ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f91\x122\n" +
"\x03f92\x18\\ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f92\x122\n" +
"\x03f93\x18] \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f93\x122\n" +
"\x03f94\x18^ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f94\x122\n" +
"\x03f95\x18_ \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f95\x122\n" +
"\x03f96\x18` \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f96\x122\n" +
"\x03f97\x18a \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f97\x122\n" +
"\x03f98\x18b \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f98\x122\n" +
"\x03f99\x18c \x01(\v2 .goproto.proto.test.TestAllTypesR\x03f99\x124\n" +
"\x04f100\x18d \x01(\v2 .goproto.proto.test.TestAllTypesR\x04f100\"\xc4\x01\n" +
"\x15TestDeprecatedMessage\x12-\n" +
"\x10deprecated_int32\x18\x01 \x01(\x05B\x02\x18\x01R\x0fdeprecatedInt32\x12:\n" +
"\x16deprecated_oneof_field\x18\x02 \x01(\x05B\x02\x18\x01H\x00R\x14deprecatedOneofField\"(\n" +
"\x0eDeprecatedEnum\x12\x12\n" +
"\n" +
"DEPRECATED\x10\x00\x1a\x02\b\x01\x1a\x02\x18\x01:\x02\x18\x01B\x12\n" +
"\x10deprecated_oneof\"\x99\x01\n" +
"\x15TestOneofWithRequired\x12#\n" +
"\foneof_uint32\x18\x01 \x01(\rH\x00R\voneofUint32\x12L\n" +
"\x0eoneof_required\x18\x02 \x01(\v2#.goproto.proto.testrequired.MessageH\x00R\roneofRequiredB\r\n" +
"\voneof_field\",\n" +
"\x0eForeignMessage\x12\f\n" +
"\x01c\x18\x01 \x01(\x05R\x01c\x12\f\n" +
"\x01d\x18\x02 \x01(\x05R\x01d\"0\n" +
"\x12TestReservedFieldsJ\x04\b\x02\x10\x03J\x04\b\x0f\x10\x10J\x04\b\t\x10\fR\x03barR\x03baz\"\x85\x01\n" +
"\x11TestAllExtensions\x1af\n" +
"\rNestedMessage\x12\f\n" +
"\x01a\x18\x01 \x01(\x05R\x01a\x12G\n" +
"\vcorecursive\x18\x02 \x01(\v2%.goproto.proto.test.TestAllExtensionsR\vcorecursive*\b\b\x01\x10\x80\x80\x80\x80\x02\"\xb7\x01\n" +
"\rOptionalGroup\x12\f\n" +
"\x01a\x18\x11 \x01(\x05R\x01a\x12*\n" +
"\x11same_field_number\x18\x10 \x01(\x05R\x0fsameFieldNumber\x12l\n" +
"\x17optional_nested_message\x18\xe8\a \x01(\v23.goproto.proto.test.TestAllExtensions.NestedMessageR\x15optionalNestedMessage\"\x8b\x01\n" +
"\rRepeatedGroup\x12\f\n" +
"\x01a\x18/ \x01(\x05R\x01a\x12l\n" +
"\x17optional_nested_message\x18\xe9\a \x01(\v23.goproto.proto.test.TestAllExtensions.NestedMessageR\x15optionalNestedMessage\"u\n" +
"\x13TestNestedExtension2^\n" +
"\x17nested_string_extension\x12%.goproto.proto.test.TestAllExtensions\x18\xeb\a \x01(\tR\x15nestedStringExtension\"\xf7\x01\n" +
"\fTestRequired\x12%\n" +
"\x0erequired_field\x18\x01 \x02(\x05R\rrequiredField2`\n" +
"\x06single\x12%.goproto.proto.test.TestAllExtensions\x18\xe8\a \x01(\v2 .goproto.proto.test.TestRequiredR\x06single2^\n" +
"\x05multi\x12%.goproto.proto.test.TestAllExtensions\x18\xe9\a \x03(\v2 .goproto.proto.test.TestRequiredR\x05multi\"\xc2\x03\n" +
"\x13TestRequiredForeign\x12K\n" +
"\x10optional_message\x18\x01 \x01(\v2 .goproto.proto.test.TestRequiredR\x0foptionalMessage\x12K\n" +
"\x10repeated_message\x18\x02 \x03(\v2 .goproto.proto.test.TestRequiredR\x0frepeatedMessage\x12X\n" +
"\vmap_message\x18\x03 \x03(\v27.goproto.proto.test.TestRequiredForeign.MapMessageEntryR\n" +
"mapMessage\x12G\n" +
"\roneof_message\x18\x04 \x01(\v2 .goproto.proto.test.TestRequiredH\x00R\foneofMessage\x1a_\n" +
"\x0fMapMessageEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x126\n" +
"\x05value\x18\x02 \x01(\v2 .goproto.proto.test.TestRequiredR\x05value:\x028\x01B\r\n" +
"\voneof_field\"\x99\x02\n" +
"\x17TestRequiredGroupFields\x12_\n" +
"\roptionalgroup\x18\x01 \x01(\n" +
"29.goproto.proto.test.TestRequiredGroupFields.OptionalGroupR\roptionalgroup\x12_\n" +
"\rrepeatedgroup\x18\x03 \x03(\n" +
"29.goproto.proto.test.TestRequiredGroupFields.RepeatedGroupR\rrepeatedgroup\x1a\x1d\n" +
"\rOptionalGroup\x12\f\n" +
"\x01a\x18\x02 \x02(\x05R\x01a\x1a\x1d\n" +
"\rRepeatedGroup\x12\f\n" +
"\x01a\x18\x04 \x02(\x05R\x01a\"l\n" +
"\x10TestRequiredLazy\x12X\n" +
"\x15optional_lazy_message\x18\x01 \x01(\v2 .goproto.proto.test.TestRequiredB\x02(\x01R\x13optionalLazyMessage\"\xee\x04\n" +
"\x0fTestPackedTypes\x12%\n" +
"\fpacked_int32\x18Z \x03(\x05B\x02\x10\x01R\vpackedInt32\x12%\n" +
"\fpacked_int64\x18[ \x03(\x03B\x02\x10\x01R\vpackedInt64\x12'\n" +
"\rpacked_uint32\x18\\ \x03(\rB\x02\x10\x01R\fpackedUint32\x12'\n" +
"\rpacked_uint64\x18] \x03(\x04B\x02\x10\x01R\fpackedUint64\x12'\n" +
"\rpacked_sint32\x18^ \x03(\x11B\x02\x10\x01R\fpackedSint32\x12'\n" +
"\rpacked_sint64\x18_ \x03(\x12B\x02\x10\x01R\fpackedSint64\x12)\n" +
"\x0epacked_fixed32\x18` \x03(\aB\x02\x10\x01R\rpackedFixed32\x12)\n" +
"\x0epacked_fixed64\x18a \x03(\x06B\x02\x10\x01R\rpackedFixed64\x12+\n" +
"\x0fpacked_sfixed32\x18b \x03(\x0fB\x02\x10\x01R\x0epackedSfixed32\x12+\n" +
"\x0fpacked_sfixed64\x18c \x03(\x10B\x02\x10\x01R\x0epackedSfixed64\x12%\n" +
"\fpacked_float\x18d \x03(\x02B\x02\x10\x01R\vpackedFloat\x12'\n" +
"\rpacked_double\x18e \x03(\x01B\x02\x10\x01R\fpackedDouble\x12#\n" +
"\vpacked_bool\x18f \x03(\bB\x02\x10\x01R\n" +
"packedBool\x12D\n" +
"\vpacked_enum\x18g \x03(\x0e2\x1f.goproto.proto.test.ForeignEnumB\x02\x10\x01R\n" +
"packedEnum\"\xa8\x05\n" +
"\x11TestUnpackedTypes\x12)\n" +
"\x0eunpacked_int32\x18Z \x03(\x05B\x02\x10\x00R\runpackedInt32\x12)\n" +
"\x0eunpacked_int64\x18[ \x03(\x03B\x02\x10\x00R\runpackedInt64\x12+\n" +
"\x0funpacked_uint32\x18\\ \x03(\rB\x02\x10\x00R\x0eunpackedUint32\x12+\n" +
"\x0funpacked_uint64\x18] \x03(\x04B\x02\x10\x00R\x0eunpackedUint64\x12+\n" +
"\x0funpacked_sint32\x18^ \x03(\x11B\x02\x10\x00R\x0eunpackedSint32\x12+\n" +
"\x0funpacked_sint64\x18_ \x03(\x12B\x02\x10\x00R\x0eunpackedSint64\x12-\n" +
"\x10unpacked_fixed32\x18` \x03(\aB\x02\x10\x00R\x0funpackedFixed32\x12-\n" +
"\x10unpacked_fixed64\x18a \x03(\x06B\x02\x10\x00R\x0funpackedFixed64\x12/\n" +
"\x11unpacked_sfixed32\x18b \x03(\x0fB\x02\x10\x00R\x10unpackedSfixed32\x12/\n" +
"\x11unpacked_sfixed64\x18c \x03(\x10B\x02\x10\x00R\x10unpackedSfixed64\x12)\n" +
"\x0eunpacked_float\x18d \x03(\x02B\x02\x10\x00R\runpackedFloat\x12+\n" +
"\x0funpacked_double\x18e \x03(\x01B\x02\x10\x00R\x0eunpackedDouble\x12'\n" +
"\runpacked_bool\x18f \x03(\bB\x02\x10\x00R\funpackedBool\x12H\n" +
"\runpacked_enum\x18g \x03(\x0e2\x1f.goproto.proto.test.ForeignEnumB\x02\x10\x00R\funpackedEnum\" \n" +
"\x14TestPackedExtensions*\b\b\x01\x10\x80\x80\x80\x80\x02\"\"\n" +
"\x16TestUnpackedExtensions*\b\b\x01\x10\x80\x80\x80\x80\x02\"\f\n" +
"\n" +
"FooRequest\"\r\n" +
"\vFooResponse\"a\n" +
"\fWeirdDefault\x12Q\n" +
"\rweird_default\x18\x01 \x01(\f:,hello, \\\"world!\\\"\\ndead\\336\\255\\276\\357beef`R\fweirdDefault\"\xff\x03\n" +
"\rRemoteDefault\x123\n" +
"\adefault\x18\x01 \x01(\x0e2\x19.goproto.proto.enums.EnumR\adefault\x123\n" +
"\x04zero\x18\x02 \x01(\x0e2\x19.goproto.proto.enums.Enum:\x04ZEROR\x04zero\x120\n" +
"\x03one\x18\x03 \x01(\x0e2\x19.goproto.proto.enums.Enum:\x03ONER\x03one\x12<\n" +
"\aelevent\x18\x04 \x01(\x0e2\x19.goproto.proto.enums.Enum:\aELEVENTR\aelevent\x12B\n" +
"\tseventeen\x18\x05 \x01(\x0e2\x19.goproto.proto.enums.Enum:\tSEVENTEENR\tseventeen\x12H\n" +
"\vthirtyseven\x18\x06 \x01(\x0e2\x19.goproto.proto.enums.Enum:\vTHIRTYSEVENR\vthirtyseven\x12E\n" +
"\n" +
"sixtyseven\x18\a \x01(\x0e2\x19.goproto.proto.enums.Enum:\n" +
"SIXTYSEVENR\n" +
"sixtyseven\x12?\n" +
"\bnegative\x18\b \x01(\x0e2\x19.goproto.proto.enums.Enum:\bNEGATIVER\bnegative*@\n" +
"\vForeignEnum\x12\x0f\n" +
"\vFOREIGN_FOO\x10\x04\x12\x0f\n" +
"\vFOREIGN_BAR\x10\x05\x12\x0f\n" +
"\vFOREIGN_BAZ\x10\x06*G\n" +
"\x16TestReservedEnumFields\x12\x11\n" +
"\rRESERVED_ENUM\x10\x00\"\x04\b\x02\x10\x02\"\x04\b\x0f\x10\x0f\"\x04\b\t\x10\v*\x03BAR*\x03BAZ2\xa8\x01\n" +
"\vTestService\x12F\n" +
"\x03Foo\x12\x1e.goproto.proto.test.FooRequest\x1a\x1f.goproto.proto.test.FooResponse\x12Q\n" +
"\n" +
"TestStream\x12\x1e.goproto.proto.test.FooRequest\x1a\x1f.goproto.proto.test.FooResponse(\x010\x012\x85\x01\n" +
"\x15TestDeprecatedService\x12g\n" +
"\n" +
"Deprecated\x12).goproto.proto.test.TestDeprecatedMessage\x1a).goproto.proto.test.TestDeprecatedMessage\"\x03\x88\x02\x01\x1a\x03\x88\x02\x01:L\n" +
"\x0eoptional_int32\x12%.goproto.proto.test.TestAllExtensions\x18\x01 \x01(\x05R\roptionalInt32:L\n" +
"\x0eoptional_int64\x12%.goproto.proto.test.TestAllExtensions\x18\x02 \x01(\x03R\roptionalInt64:N\n" +
"\x0foptional_uint32\x12%.goproto.proto.test.TestAllExtensions\x18\x03 \x01(\rR\x0eoptionalUint32:N\n" +
"\x0foptional_uint64\x12%.goproto.proto.test.TestAllExtensions\x18\x04 \x01(\x04R\x0eoptionalUint64:N\n" +
"\x0foptional_sint32\x12%.goproto.proto.test.TestAllExtensions\x18\x05 \x01(\x11R\x0eoptionalSint32:N\n" +
"\x0foptional_sint64\x12%.goproto.proto.test.TestAllExtensions\x18\x06 \x01(\x12R\x0eoptionalSint64:P\n" +
"\x10optional_fixed32\x12%.goproto.proto.test.TestAllExtensions\x18\a \x01(\aR\x0foptionalFixed32:P\n" +
"\x10optional_fixed64\x12%.goproto.proto.test.TestAllExtensions\x18\b \x01(\x06R\x0foptionalFixed64:R\n" +
"\x11optional_sfixed32\x12%.goproto.proto.test.TestAllExtensions\x18\t \x01(\x0fR\x10optionalSfixed32:R\n" +
"\x11optional_sfixed64\x12%.goproto.proto.test.TestAllExtensions\x18\n" +
" \x01(\x10R\x10optionalSfixed64:L\n" +
"\x0eoptional_float\x12%.goproto.proto.test.TestAllExtensions\x18\v \x01(\x02R\roptionalFloat:N\n" +
"\x0foptional_double\x12%.goproto.proto.test.TestAllExtensions\x18\f \x01(\x01R\x0eoptionalDouble:J\n" +
"\roptional_bool\x12%.goproto.proto.test.TestAllExtensions\x18\r \x01(\bR\foptionalBool:N\n" +
"\x0foptional_string\x12%.goproto.proto.test.TestAllExtensions\x18\x0e \x01(\tR\x0eoptionalString:L\n" +
"\x0eoptional_bytes\x12%.goproto.proto.test.TestAllExtensions\x18\x0f \x01(\fR\roptionalBytes:n\n" +
"\roptionalgroup\x12%.goproto.proto.test.TestAllExtensions\x18\x10 \x01(\n" +
"2!.goproto.proto.test.OptionalGroupR\roptionalgroup:\x92\x01\n" +
"\x17optional_nested_message\x12%.goproto.proto.test.TestAllExtensions\x18\x12 \x01(\v23.goproto.proto.test.TestAllExtensions.NestedMessageR\x15optionalNestedMessage:\x84\x01\n" +
"\x14optional_nested_enum\x12%.goproto.proto.test.TestAllExtensions\x18\x15 \x01(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnumR\x12optionalNestedEnum:L\n" +
"\x0erepeated_int32\x12%.goproto.proto.test.TestAllExtensions\x18\x1f \x03(\x05R\rrepeatedInt32:L\n" +
"\x0erepeated_int64\x12%.goproto.proto.test.TestAllExtensions\x18 \x03(\x03R\rrepeatedInt64:N\n" +
"\x0frepeated_uint32\x12%.goproto.proto.test.TestAllExtensions\x18! \x03(\rR\x0erepeatedUint32:N\n" +
"\x0frepeated_uint64\x12%.goproto.proto.test.TestAllExtensions\x18\" \x03(\x04R\x0erepeatedUint64:N\n" +
"\x0frepeated_sint32\x12%.goproto.proto.test.TestAllExtensions\x18# \x03(\x11R\x0erepeatedSint32:N\n" +
"\x0frepeated_sint64\x12%.goproto.proto.test.TestAllExtensions\x18$ \x03(\x12R\x0erepeatedSint64:P\n" +
"\x10repeated_fixed32\x12%.goproto.proto.test.TestAllExtensions\x18% \x03(\aR\x0frepeatedFixed32:P\n" +
"\x10repeated_fixed64\x12%.goproto.proto.test.TestAllExtensions\x18& \x03(\x06R\x0frepeatedFixed64:R\n" +
"\x11repeated_sfixed32\x12%.goproto.proto.test.TestAllExtensions\x18' \x03(\x0fR\x10repeatedSfixed32:R\n" +
"\x11repeated_sfixed64\x12%.goproto.proto.test.TestAllExtensions\x18( \x03(\x10R\x10repeatedSfixed64:L\n" +
"\x0erepeated_float\x12%.goproto.proto.test.TestAllExtensions\x18) \x03(\x02R\rrepeatedFloat:N\n" +
"\x0frepeated_double\x12%.goproto.proto.test.TestAllExtensions\x18* \x03(\x01R\x0erepeatedDouble:J\n" +
"\rrepeated_bool\x12%.goproto.proto.test.TestAllExtensions\x18+ \x03(\bR\frepeatedBool:N\n" +
"\x0frepeated_string\x12%.goproto.proto.test.TestAllExtensions\x18, \x03(\tR\x0erepeatedString:L\n" +
"\x0erepeated_bytes\x12%.goproto.proto.test.TestAllExtensions\x18- \x03(\fR\rrepeatedBytes:n\n" +
"\rrepeatedgroup\x12%.goproto.proto.test.TestAllExtensions\x18. \x03(\n" +
"2!.goproto.proto.test.RepeatedGroupR\rrepeatedgroup:\x92\x01\n" +
"\x17repeated_nested_message\x12%.goproto.proto.test.TestAllExtensions\x180 \x03(\v23.goproto.proto.test.TestAllExtensions.NestedMessageR\x15repeatedNestedMessage:\x84\x01\n" +
"\x14repeated_nested_enum\x12%.goproto.proto.test.TestAllExtensions\x183 \x03(\x0e2+.goproto.proto.test.TestAllTypes.NestedEnumR\x12repeatedNestedEnum:N\n" +
"\rdefault_int32\x12%.goproto.proto.test.TestAllExtensions\x18Q \x01(\x05:\x0281R\fdefaultInt32:N\n" +
"\rdefault_int64\x12%.goproto.proto.test.TestAllExtensions\x18R \x01(\x03:\x0282R\fdefaultInt64:P\n" +
"\x0edefault_uint32\x12%.goproto.proto.test.TestAllExtensions\x18S \x01(\r:\x0283R\rdefaultUint32:P\n" +
"\x0edefault_uint64\x12%.goproto.proto.test.TestAllExtensions\x18T \x01(\x04:\x0284R\rdefaultUint64:Q\n" +
"\x0edefault_sint32\x12%.goproto.proto.test.TestAllExtensions\x18U \x01(\x11:\x03-85R\rdefaultSint32:P\n" +
"\x0edefault_sint64\x12%.goproto.proto.test.TestAllExtensions\x18V \x01(\x12:\x0286R\rdefaultSint64:R\n" +
"\x0fdefault_fixed32\x12%.goproto.proto.test.TestAllExtensions\x18W \x01(\a:\x0287R\x0edefaultFixed32:R\n" +
"\x0fdefault_fixed64\x12%.goproto.proto.test.TestAllExtensions\x18X \x01(\x06:\x0288R\x0edefaultFixed64:T\n" +
"\x10default_sfixed32\x12%.goproto.proto.test.TestAllExtensions\x18Y \x01(\x0f:\x0289R\x0fdefaultSfixed32:U\n" +
"\x10default_sfixed64\x12%.goproto.proto.test.TestAllExtensions\x18P \x01(\x10:\x03-90R\x0fdefaultSfixed64:P\n" +
"\rdefault_float\x12%.goproto.proto.test.TestAllExtensions\x18[ \x01(\x02:\x0491.5R\fdefaultFloat:S\n" +
"\x0edefault_double\x12%.goproto.proto.test.TestAllExtensions\x18\\ \x01(\x01:\x0592000R\rdefaultDouble:N\n" +
"\fdefault_bool\x12%.goproto.proto.test.TestAllExtensions\x18] \x01(\b:\x04trueR\vdefaultBool:S\n" +
"\x0edefault_string\x12%.goproto.proto.test.TestAllExtensions\x18^ \x01(\t:\x05helloR\rdefaultString:Q\n" +
"\rdefault_bytes\x12%.goproto.proto.test.TestAllExtensions\x18_ \x01(\f:\x05worldR\fdefaultBytes:O\n" +
"\fpacked_int32\x12(.goproto.proto.test.TestPackedExtensions\x18Z \x03(\x05B\x02\x10\x01R\vpackedInt32:O\n" +
"\fpacked_int64\x12(.goproto.proto.test.TestPackedExtensions\x18[ \x03(\x03B\x02\x10\x01R\vpackedInt64:Q\n" +
"\rpacked_uint32\x12(.goproto.proto.test.TestPackedExtensions\x18\\ \x03(\rB\x02\x10\x01R\fpackedUint32:Q\n" +
"\rpacked_uint64\x12(.goproto.proto.test.TestPackedExtensions\x18] \x03(\x04B\x02\x10\x01R\fpackedUint64:Q\n" +
"\rpacked_sint32\x12(.goproto.proto.test.TestPackedExtensions\x18^ \x03(\x11B\x02\x10\x01R\fpackedSint32:Q\n" +
"\rpacked_sint64\x12(.goproto.proto.test.TestPackedExtensions\x18_ \x03(\x12B\x02\x10\x01R\fpackedSint64:S\n" +
"\x0epacked_fixed32\x12(.goproto.proto.test.TestPackedExtensions\x18` \x03(\aB\x02\x10\x01R\rpackedFixed32:S\n" +
"\x0epacked_fixed64\x12(.goproto.proto.test.TestPackedExtensions\x18a \x03(\x06B\x02\x10\x01R\rpackedFixed64:U\n" +
"\x0fpacked_sfixed32\x12(.goproto.proto.test.TestPackedExtensions\x18b \x03(\x0fB\x02\x10\x01R\x0epackedSfixed32:U\n" +
"\x0fpacked_sfixed64\x12(.goproto.proto.test.TestPackedExtensions\x18c \x03(\x10B\x02\x10\x01R\x0epackedSfixed64:O\n" +
"\fpacked_float\x12(.goproto.proto.test.TestPackedExtensions\x18d \x03(\x02B\x02\x10\x01R\vpackedFloat:Q\n" +
"\rpacked_double\x12(.goproto.proto.test.TestPackedExtensions\x18e \x03(\x01B\x02\x10\x01R\fpackedDouble:M\n" +
"\vpacked_bool\x12(.goproto.proto.test.TestPackedExtensions\x18f \x03(\bB\x02\x10\x01R\n" +
"packedBool:n\n" +
"\vpacked_enum\x12(.goproto.proto.test.TestPackedExtensions\x18g \x03(\x0e2\x1f.goproto.proto.test.ForeignEnumB\x02\x10\x01R\n" +
"packedEnum:U\n" +
"\x0eunpacked_int32\x12*.goproto.proto.test.TestUnpackedExtensions\x18Z \x03(\x05B\x02\x10\x00R\runpackedInt32:U\n" +
"\x0eunpacked_int64\x12*.goproto.proto.test.TestUnpackedExtensions\x18[ \x03(\x03B\x02\x10\x00R\runpackedInt64:W\n" +
"\x0funpacked_uint32\x12*.goproto.proto.test.TestUnpackedExtensions\x18\\ \x03(\rB\x02\x10\x00R\x0eunpackedUint32:W\n" +
"\x0funpacked_uint64\x12*.goproto.proto.test.TestUnpackedExtensions\x18] \x03(\x04B\x02\x10\x00R\x0eunpackedUint64:W\n" +
"\x0funpacked_sint32\x12*.goproto.proto.test.TestUnpackedExtensions\x18^ \x03(\x11B\x02\x10\x00R\x0eunpackedSint32:W\n" +
"\x0funpacked_sint64\x12*.goproto.proto.test.TestUnpackedExtensions\x18_ \x03(\x12B\x02\x10\x00R\x0eunpackedSint64:Y\n" +
"\x10unpacked_fixed32\x12*.goproto.proto.test.TestUnpackedExtensions\x18` \x03(\aB\x02\x10\x00R\x0funpackedFixed32:Y\n" +
"\x10unpacked_fixed64\x12*.goproto.proto.test.TestUnpackedExtensions\x18a \x03(\x06B\x02\x10\x00R\x0funpackedFixed64:[\n" +
"\x11unpacked_sfixed32\x12*.goproto.proto.test.TestUnpackedExtensions\x18b \x03(\x0fB\x02\x10\x00R\x10unpackedSfixed32:[\n" +
"\x11unpacked_sfixed64\x12*.goproto.proto.test.TestUnpackedExtensions\x18c \x03(\x10B\x02\x10\x00R\x10unpackedSfixed64:U\n" +
"\x0eunpacked_float\x12*.goproto.proto.test.TestUnpackedExtensions\x18d \x03(\x02B\x02\x10\x00R\runpackedFloat:W\n" +
"\x0funpacked_double\x12*.goproto.proto.test.TestUnpackedExtensions\x18e \x03(\x01B\x02\x10\x00R\x0eunpackedDouble:S\n" +
"\runpacked_bool\x12*.goproto.proto.test.TestUnpackedExtensions\x18f \x03(\bB\x02\x10\x00R\funpackedBool:t\n" +
"\runpacked_enum\x12*.goproto.proto.test.TestUnpackedExtensions\x18g \x03(\x0e2\x1f.goproto.proto.test.ForeignEnumB\x02\x10\x00R\funpackedEnumB5Z3google.golang.org/protobuf/internal/testprotos/testP\x00"
var (
file_internal_testprotos_test_test_proto_rawDescOnce sync.Once
file_internal_testprotos_test_test_proto_rawDescData []byte
)
func file_internal_testprotos_test_test_proto_rawDescGZIP() []byte {
file_internal_testprotos_test_test_proto_rawDescOnce.Do(func() {
file_internal_testprotos_test_test_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_test_proto_rawDesc), len(file_internal_testprotos_test_test_proto_rawDesc)))
})
return file_internal_testprotos_test_test_proto_rawDescData
}
var file_internal_testprotos_test_test_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_internal_testprotos_test_test_proto_msgTypes = make([]protoimpl.MessageInfo, 47)
var file_internal_testprotos_test_test_proto_goTypes = []any{
(ForeignEnum)(0), // 0: goproto.proto.test.ForeignEnum
(TestReservedEnumFields)(0), // 1: goproto.proto.test.TestReservedEnumFields
(TestAllTypes_NestedEnum)(0), // 2: goproto.proto.test.TestAllTypes.NestedEnum
(TestDeprecatedMessage_DeprecatedEnum)(0), // 3: goproto.proto.test.TestDeprecatedMessage.DeprecatedEnum
(*TestAllTypes)(nil), // 4: goproto.proto.test.TestAllTypes
(*TestManyMessageFieldsMessage)(nil), // 5: goproto.proto.test.TestManyMessageFieldsMessage
(*TestDeprecatedMessage)(nil), // 6: goproto.proto.test.TestDeprecatedMessage
(*TestOneofWithRequired)(nil), // 7: goproto.proto.test.TestOneofWithRequired
(*ForeignMessage)(nil), // 8: goproto.proto.test.ForeignMessage
(*TestReservedFields)(nil), // 9: goproto.proto.test.TestReservedFields
(*TestAllExtensions)(nil), // 10: goproto.proto.test.TestAllExtensions
(*OptionalGroup)(nil), // 11: goproto.proto.test.OptionalGroup
(*RepeatedGroup)(nil), // 12: goproto.proto.test.RepeatedGroup
(*TestNestedExtension)(nil), // 13: goproto.proto.test.TestNestedExtension
(*TestRequired)(nil), // 14: goproto.proto.test.TestRequired
(*TestRequiredForeign)(nil), // 15: goproto.proto.test.TestRequiredForeign
(*TestRequiredGroupFields)(nil), // 16: goproto.proto.test.TestRequiredGroupFields
(*TestRequiredLazy)(nil), // 17: goproto.proto.test.TestRequiredLazy
(*TestPackedTypes)(nil), // 18: goproto.proto.test.TestPackedTypes
(*TestUnpackedTypes)(nil), // 19: goproto.proto.test.TestUnpackedTypes
(*TestPackedExtensions)(nil), // 20: goproto.proto.test.TestPackedExtensions
(*TestUnpackedExtensions)(nil), // 21: goproto.proto.test.TestUnpackedExtensions
(*FooRequest)(nil), // 22: goproto.proto.test.FooRequest
(*FooResponse)(nil), // 23: goproto.proto.test.FooResponse
(*WeirdDefault)(nil), // 24: goproto.proto.test.WeirdDefault
(*RemoteDefault)(nil), // 25: goproto.proto.test.RemoteDefault
(*TestAllTypes_NestedMessage)(nil), // 26: goproto.proto.test.TestAllTypes.NestedMessage
(*TestAllTypes_OptionalGroup)(nil), // 27: goproto.proto.test.TestAllTypes.OptionalGroup
(*TestAllTypes_RepeatedGroup)(nil), // 28: goproto.proto.test.TestAllTypes.RepeatedGroup
nil, // 29: goproto.proto.test.TestAllTypes.MapInt32Int32Entry
nil, // 30: goproto.proto.test.TestAllTypes.MapInt64Int64Entry
nil, // 31: goproto.proto.test.TestAllTypes.MapUint32Uint32Entry
nil, // 32: goproto.proto.test.TestAllTypes.MapUint64Uint64Entry
nil, // 33: goproto.proto.test.TestAllTypes.MapSint32Sint32Entry
nil, // 34: goproto.proto.test.TestAllTypes.MapSint64Sint64Entry
nil, // 35: goproto.proto.test.TestAllTypes.MapFixed32Fixed32Entry
nil, // 36: goproto.proto.test.TestAllTypes.MapFixed64Fixed64Entry
nil, // 37: goproto.proto.test.TestAllTypes.MapSfixed32Sfixed32Entry
nil, // 38: goproto.proto.test.TestAllTypes.MapSfixed64Sfixed64Entry
nil, // 39: goproto.proto.test.TestAllTypes.MapInt32FloatEntry
nil, // 40: goproto.proto.test.TestAllTypes.MapInt32DoubleEntry
nil, // 41: goproto.proto.test.TestAllTypes.MapBoolBoolEntry
nil, // 42: goproto.proto.test.TestAllTypes.MapStringStringEntry
nil, // 43: goproto.proto.test.TestAllTypes.MapStringBytesEntry
nil, // 44: goproto.proto.test.TestAllTypes.MapStringNestedMessageEntry
nil, // 45: goproto.proto.test.TestAllTypes.MapStringNestedEnumEntry
(*TestAllTypes_OneofGroup)(nil), // 46: goproto.proto.test.TestAllTypes.OneofGroup
(*TestAllExtensions_NestedMessage)(nil), // 47: goproto.proto.test.TestAllExtensions.NestedMessage
nil, // 48: goproto.proto.test.TestRequiredForeign.MapMessageEntry
(*TestRequiredGroupFields_OptionalGroup)(nil), // 49: goproto.proto.test.TestRequiredGroupFields.OptionalGroup
(*TestRequiredGroupFields_RepeatedGroup)(nil), // 50: goproto.proto.test.TestRequiredGroupFields.RepeatedGroup
(*ImportMessage)(nil), // 51: goproto.proto.test.ImportMessage
(ImportEnum)(0), // 52: goproto.proto.test.ImportEnum
(*required.Message)(nil), // 53: goproto.proto.testrequired.Message
(enums.Enum)(0), // 54: goproto.proto.enums.Enum
}
var file_internal_testprotos_test_test_proto_depIdxs = []int32{
27, // 0: goproto.proto.test.TestAllTypes.optionalgroup:type_name -> goproto.proto.test.TestAllTypes.OptionalGroup
26, // 1: goproto.proto.test.TestAllTypes.optional_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
8, // 2: goproto.proto.test.TestAllTypes.optional_foreign_message:type_name -> goproto.proto.test.ForeignMessage
51, // 3: goproto.proto.test.TestAllTypes.optional_import_message:type_name -> goproto.proto.test.ImportMessage
2, // 4: goproto.proto.test.TestAllTypes.optional_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
0, // 5: goproto.proto.test.TestAllTypes.optional_foreign_enum:type_name -> goproto.proto.test.ForeignEnum
52, // 6: goproto.proto.test.TestAllTypes.optional_import_enum:type_name -> goproto.proto.test.ImportEnum
26, // 7: goproto.proto.test.TestAllTypes.optional_lazy_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
28, // 8: goproto.proto.test.TestAllTypes.repeatedgroup:type_name -> goproto.proto.test.TestAllTypes.RepeatedGroup
26, // 9: goproto.proto.test.TestAllTypes.repeated_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
8, // 10: goproto.proto.test.TestAllTypes.repeated_foreign_message:type_name -> goproto.proto.test.ForeignMessage
51, // 11: goproto.proto.test.TestAllTypes.repeated_importmessage:type_name -> goproto.proto.test.ImportMessage
2, // 12: goproto.proto.test.TestAllTypes.repeated_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
0, // 13: goproto.proto.test.TestAllTypes.repeated_foreign_enum:type_name -> goproto.proto.test.ForeignEnum
52, // 14: goproto.proto.test.TestAllTypes.repeated_importenum:type_name -> goproto.proto.test.ImportEnum
29, // 15: goproto.proto.test.TestAllTypes.map_int32_int32:type_name -> goproto.proto.test.TestAllTypes.MapInt32Int32Entry
30, // 16: goproto.proto.test.TestAllTypes.map_int64_int64:type_name -> goproto.proto.test.TestAllTypes.MapInt64Int64Entry
31, // 17: goproto.proto.test.TestAllTypes.map_uint32_uint32:type_name -> goproto.proto.test.TestAllTypes.MapUint32Uint32Entry
32, // 18: goproto.proto.test.TestAllTypes.map_uint64_uint64:type_name -> goproto.proto.test.TestAllTypes.MapUint64Uint64Entry
33, // 19: goproto.proto.test.TestAllTypes.map_sint32_sint32:type_name -> goproto.proto.test.TestAllTypes.MapSint32Sint32Entry
34, // 20: goproto.proto.test.TestAllTypes.map_sint64_sint64:type_name -> goproto.proto.test.TestAllTypes.MapSint64Sint64Entry
35, // 21: goproto.proto.test.TestAllTypes.map_fixed32_fixed32:type_name -> goproto.proto.test.TestAllTypes.MapFixed32Fixed32Entry
36, // 22: goproto.proto.test.TestAllTypes.map_fixed64_fixed64:type_name -> goproto.proto.test.TestAllTypes.MapFixed64Fixed64Entry
37, // 23: goproto.proto.test.TestAllTypes.map_sfixed32_sfixed32:type_name -> goproto.proto.test.TestAllTypes.MapSfixed32Sfixed32Entry
38, // 24: goproto.proto.test.TestAllTypes.map_sfixed64_sfixed64:type_name -> goproto.proto.test.TestAllTypes.MapSfixed64Sfixed64Entry
39, // 25: goproto.proto.test.TestAllTypes.map_int32_float:type_name -> goproto.proto.test.TestAllTypes.MapInt32FloatEntry
40, // 26: goproto.proto.test.TestAllTypes.map_int32_double:type_name -> goproto.proto.test.TestAllTypes.MapInt32DoubleEntry
41, // 27: goproto.proto.test.TestAllTypes.map_bool_bool:type_name -> goproto.proto.test.TestAllTypes.MapBoolBoolEntry
42, // 28: goproto.proto.test.TestAllTypes.map_string_string:type_name -> goproto.proto.test.TestAllTypes.MapStringStringEntry
43, // 29: goproto.proto.test.TestAllTypes.map_string_bytes:type_name -> goproto.proto.test.TestAllTypes.MapStringBytesEntry
44, // 30: goproto.proto.test.TestAllTypes.map_string_nested_message:type_name -> goproto.proto.test.TestAllTypes.MapStringNestedMessageEntry
45, // 31: goproto.proto.test.TestAllTypes.map_string_nested_enum:type_name -> goproto.proto.test.TestAllTypes.MapStringNestedEnumEntry
2, // 32: goproto.proto.test.TestAllTypes.default_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
0, // 33: goproto.proto.test.TestAllTypes.default_foreign_enum:type_name -> goproto.proto.test.ForeignEnum
26, // 34: goproto.proto.test.TestAllTypes.oneof_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
2, // 35: goproto.proto.test.TestAllTypes.oneof_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
46, // 36: goproto.proto.test.TestAllTypes.oneofgroup:type_name -> goproto.proto.test.TestAllTypes.OneofGroup
4, // 37: goproto.proto.test.TestManyMessageFieldsMessage.f1:type_name -> goproto.proto.test.TestAllTypes
4, // 38: goproto.proto.test.TestManyMessageFieldsMessage.f2:type_name -> goproto.proto.test.TestAllTypes
4, // 39: goproto.proto.test.TestManyMessageFieldsMessage.f3:type_name -> goproto.proto.test.TestAllTypes
4, // 40: goproto.proto.test.TestManyMessageFieldsMessage.f4:type_name -> goproto.proto.test.TestAllTypes
4, // 41: goproto.proto.test.TestManyMessageFieldsMessage.f5:type_name -> goproto.proto.test.TestAllTypes
4, // 42: goproto.proto.test.TestManyMessageFieldsMessage.f6:type_name -> goproto.proto.test.TestAllTypes
4, // 43: goproto.proto.test.TestManyMessageFieldsMessage.f7:type_name -> goproto.proto.test.TestAllTypes
4, // 44: goproto.proto.test.TestManyMessageFieldsMessage.f8:type_name -> goproto.proto.test.TestAllTypes
4, // 45: goproto.proto.test.TestManyMessageFieldsMessage.f9:type_name -> goproto.proto.test.TestAllTypes
4, // 46: goproto.proto.test.TestManyMessageFieldsMessage.f10:type_name -> goproto.proto.test.TestAllTypes
4, // 47: goproto.proto.test.TestManyMessageFieldsMessage.f11:type_name -> goproto.proto.test.TestAllTypes
4, // 48: goproto.proto.test.TestManyMessageFieldsMessage.f12:type_name -> goproto.proto.test.TestAllTypes
4, // 49: goproto.proto.test.TestManyMessageFieldsMessage.f13:type_name -> goproto.proto.test.TestAllTypes
4, // 50: goproto.proto.test.TestManyMessageFieldsMessage.f14:type_name -> goproto.proto.test.TestAllTypes
4, // 51: goproto.proto.test.TestManyMessageFieldsMessage.f15:type_name -> goproto.proto.test.TestAllTypes
4, // 52: goproto.proto.test.TestManyMessageFieldsMessage.f16:type_name -> goproto.proto.test.TestAllTypes
4, // 53: goproto.proto.test.TestManyMessageFieldsMessage.f17:type_name -> goproto.proto.test.TestAllTypes
4, // 54: goproto.proto.test.TestManyMessageFieldsMessage.f18:type_name -> goproto.proto.test.TestAllTypes
4, // 55: goproto.proto.test.TestManyMessageFieldsMessage.f19:type_name -> goproto.proto.test.TestAllTypes
4, // 56: goproto.proto.test.TestManyMessageFieldsMessage.f20:type_name -> goproto.proto.test.TestAllTypes
4, // 57: goproto.proto.test.TestManyMessageFieldsMessage.f21:type_name -> goproto.proto.test.TestAllTypes
4, // 58: goproto.proto.test.TestManyMessageFieldsMessage.f22:type_name -> goproto.proto.test.TestAllTypes
4, // 59: goproto.proto.test.TestManyMessageFieldsMessage.f23:type_name -> goproto.proto.test.TestAllTypes
4, // 60: goproto.proto.test.TestManyMessageFieldsMessage.f24:type_name -> goproto.proto.test.TestAllTypes
4, // 61: goproto.proto.test.TestManyMessageFieldsMessage.f25:type_name -> goproto.proto.test.TestAllTypes
4, // 62: goproto.proto.test.TestManyMessageFieldsMessage.f26:type_name -> goproto.proto.test.TestAllTypes
4, // 63: goproto.proto.test.TestManyMessageFieldsMessage.f27:type_name -> goproto.proto.test.TestAllTypes
4, // 64: goproto.proto.test.TestManyMessageFieldsMessage.f28:type_name -> goproto.proto.test.TestAllTypes
4, // 65: goproto.proto.test.TestManyMessageFieldsMessage.f29:type_name -> goproto.proto.test.TestAllTypes
4, // 66: goproto.proto.test.TestManyMessageFieldsMessage.f30:type_name -> goproto.proto.test.TestAllTypes
4, // 67: goproto.proto.test.TestManyMessageFieldsMessage.f31:type_name -> goproto.proto.test.TestAllTypes
4, // 68: goproto.proto.test.TestManyMessageFieldsMessage.f32:type_name -> goproto.proto.test.TestAllTypes
4, // 69: goproto.proto.test.TestManyMessageFieldsMessage.f33:type_name -> goproto.proto.test.TestAllTypes
4, // 70: goproto.proto.test.TestManyMessageFieldsMessage.f34:type_name -> goproto.proto.test.TestAllTypes
4, // 71: goproto.proto.test.TestManyMessageFieldsMessage.f35:type_name -> goproto.proto.test.TestAllTypes
4, // 72: goproto.proto.test.TestManyMessageFieldsMessage.f36:type_name -> goproto.proto.test.TestAllTypes
4, // 73: goproto.proto.test.TestManyMessageFieldsMessage.f37:type_name -> goproto.proto.test.TestAllTypes
4, // 74: goproto.proto.test.TestManyMessageFieldsMessage.f38:type_name -> goproto.proto.test.TestAllTypes
4, // 75: goproto.proto.test.TestManyMessageFieldsMessage.f39:type_name -> goproto.proto.test.TestAllTypes
4, // 76: goproto.proto.test.TestManyMessageFieldsMessage.f40:type_name -> goproto.proto.test.TestAllTypes
4, // 77: goproto.proto.test.TestManyMessageFieldsMessage.f41:type_name -> goproto.proto.test.TestAllTypes
4, // 78: goproto.proto.test.TestManyMessageFieldsMessage.f42:type_name -> goproto.proto.test.TestAllTypes
4, // 79: goproto.proto.test.TestManyMessageFieldsMessage.f43:type_name -> goproto.proto.test.TestAllTypes
4, // 80: goproto.proto.test.TestManyMessageFieldsMessage.f44:type_name -> goproto.proto.test.TestAllTypes
4, // 81: goproto.proto.test.TestManyMessageFieldsMessage.f45:type_name -> goproto.proto.test.TestAllTypes
4, // 82: goproto.proto.test.TestManyMessageFieldsMessage.f46:type_name -> goproto.proto.test.TestAllTypes
4, // 83: goproto.proto.test.TestManyMessageFieldsMessage.f47:type_name -> goproto.proto.test.TestAllTypes
4, // 84: goproto.proto.test.TestManyMessageFieldsMessage.f48:type_name -> goproto.proto.test.TestAllTypes
4, // 85: goproto.proto.test.TestManyMessageFieldsMessage.f49:type_name -> goproto.proto.test.TestAllTypes
4, // 86: goproto.proto.test.TestManyMessageFieldsMessage.f50:type_name -> goproto.proto.test.TestAllTypes
4, // 87: goproto.proto.test.TestManyMessageFieldsMessage.f51:type_name -> goproto.proto.test.TestAllTypes
4, // 88: goproto.proto.test.TestManyMessageFieldsMessage.f52:type_name -> goproto.proto.test.TestAllTypes
4, // 89: goproto.proto.test.TestManyMessageFieldsMessage.f53:type_name -> goproto.proto.test.TestAllTypes
4, // 90: goproto.proto.test.TestManyMessageFieldsMessage.f54:type_name -> goproto.proto.test.TestAllTypes
4, // 91: goproto.proto.test.TestManyMessageFieldsMessage.f55:type_name -> goproto.proto.test.TestAllTypes
4, // 92: goproto.proto.test.TestManyMessageFieldsMessage.f56:type_name -> goproto.proto.test.TestAllTypes
4, // 93: goproto.proto.test.TestManyMessageFieldsMessage.f57:type_name -> goproto.proto.test.TestAllTypes
4, // 94: goproto.proto.test.TestManyMessageFieldsMessage.f58:type_name -> goproto.proto.test.TestAllTypes
4, // 95: goproto.proto.test.TestManyMessageFieldsMessage.f59:type_name -> goproto.proto.test.TestAllTypes
4, // 96: goproto.proto.test.TestManyMessageFieldsMessage.f60:type_name -> goproto.proto.test.TestAllTypes
4, // 97: goproto.proto.test.TestManyMessageFieldsMessage.f61:type_name -> goproto.proto.test.TestAllTypes
4, // 98: goproto.proto.test.TestManyMessageFieldsMessage.f62:type_name -> goproto.proto.test.TestAllTypes
4, // 99: goproto.proto.test.TestManyMessageFieldsMessage.f63:type_name -> goproto.proto.test.TestAllTypes
4, // 100: goproto.proto.test.TestManyMessageFieldsMessage.f64:type_name -> goproto.proto.test.TestAllTypes
4, // 101: goproto.proto.test.TestManyMessageFieldsMessage.f65:type_name -> goproto.proto.test.TestAllTypes
4, // 102: goproto.proto.test.TestManyMessageFieldsMessage.f66:type_name -> goproto.proto.test.TestAllTypes
4, // 103: goproto.proto.test.TestManyMessageFieldsMessage.f67:type_name -> goproto.proto.test.TestAllTypes
4, // 104: goproto.proto.test.TestManyMessageFieldsMessage.f68:type_name -> goproto.proto.test.TestAllTypes
4, // 105: goproto.proto.test.TestManyMessageFieldsMessage.f69:type_name -> goproto.proto.test.TestAllTypes
4, // 106: goproto.proto.test.TestManyMessageFieldsMessage.f70:type_name -> goproto.proto.test.TestAllTypes
4, // 107: goproto.proto.test.TestManyMessageFieldsMessage.f71:type_name -> goproto.proto.test.TestAllTypes
4, // 108: goproto.proto.test.TestManyMessageFieldsMessage.f72:type_name -> goproto.proto.test.TestAllTypes
4, // 109: goproto.proto.test.TestManyMessageFieldsMessage.f73:type_name -> goproto.proto.test.TestAllTypes
4, // 110: goproto.proto.test.TestManyMessageFieldsMessage.f74:type_name -> goproto.proto.test.TestAllTypes
4, // 111: goproto.proto.test.TestManyMessageFieldsMessage.f75:type_name -> goproto.proto.test.TestAllTypes
4, // 112: goproto.proto.test.TestManyMessageFieldsMessage.f76:type_name -> goproto.proto.test.TestAllTypes
4, // 113: goproto.proto.test.TestManyMessageFieldsMessage.f77:type_name -> goproto.proto.test.TestAllTypes
4, // 114: goproto.proto.test.TestManyMessageFieldsMessage.f78:type_name -> goproto.proto.test.TestAllTypes
4, // 115: goproto.proto.test.TestManyMessageFieldsMessage.f79:type_name -> goproto.proto.test.TestAllTypes
4, // 116: goproto.proto.test.TestManyMessageFieldsMessage.f80:type_name -> goproto.proto.test.TestAllTypes
4, // 117: goproto.proto.test.TestManyMessageFieldsMessage.f81:type_name -> goproto.proto.test.TestAllTypes
4, // 118: goproto.proto.test.TestManyMessageFieldsMessage.f82:type_name -> goproto.proto.test.TestAllTypes
4, // 119: goproto.proto.test.TestManyMessageFieldsMessage.f83:type_name -> goproto.proto.test.TestAllTypes
4, // 120: goproto.proto.test.TestManyMessageFieldsMessage.f84:type_name -> goproto.proto.test.TestAllTypes
4, // 121: goproto.proto.test.TestManyMessageFieldsMessage.f85:type_name -> goproto.proto.test.TestAllTypes
4, // 122: goproto.proto.test.TestManyMessageFieldsMessage.f86:type_name -> goproto.proto.test.TestAllTypes
4, // 123: goproto.proto.test.TestManyMessageFieldsMessage.f87:type_name -> goproto.proto.test.TestAllTypes
4, // 124: goproto.proto.test.TestManyMessageFieldsMessage.f88:type_name -> goproto.proto.test.TestAllTypes
4, // 125: goproto.proto.test.TestManyMessageFieldsMessage.f89:type_name -> goproto.proto.test.TestAllTypes
4, // 126: goproto.proto.test.TestManyMessageFieldsMessage.f90:type_name -> goproto.proto.test.TestAllTypes
4, // 127: goproto.proto.test.TestManyMessageFieldsMessage.f91:type_name -> goproto.proto.test.TestAllTypes
4, // 128: goproto.proto.test.TestManyMessageFieldsMessage.f92:type_name -> goproto.proto.test.TestAllTypes
4, // 129: goproto.proto.test.TestManyMessageFieldsMessage.f93:type_name -> goproto.proto.test.TestAllTypes
4, // 130: goproto.proto.test.TestManyMessageFieldsMessage.f94:type_name -> goproto.proto.test.TestAllTypes
4, // 131: goproto.proto.test.TestManyMessageFieldsMessage.f95:type_name -> goproto.proto.test.TestAllTypes
4, // 132: goproto.proto.test.TestManyMessageFieldsMessage.f96:type_name -> goproto.proto.test.TestAllTypes
4, // 133: goproto.proto.test.TestManyMessageFieldsMessage.f97:type_name -> goproto.proto.test.TestAllTypes
4, // 134: goproto.proto.test.TestManyMessageFieldsMessage.f98:type_name -> goproto.proto.test.TestAllTypes
4, // 135: goproto.proto.test.TestManyMessageFieldsMessage.f99:type_name -> goproto.proto.test.TestAllTypes
4, // 136: goproto.proto.test.TestManyMessageFieldsMessage.f100:type_name -> goproto.proto.test.TestAllTypes
53, // 137: goproto.proto.test.TestOneofWithRequired.oneof_required:type_name -> goproto.proto.testrequired.Message
47, // 138: goproto.proto.test.OptionalGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
47, // 139: goproto.proto.test.RepeatedGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
14, // 140: goproto.proto.test.TestRequiredForeign.optional_message:type_name -> goproto.proto.test.TestRequired
14, // 141: goproto.proto.test.TestRequiredForeign.repeated_message:type_name -> goproto.proto.test.TestRequired
48, // 142: goproto.proto.test.TestRequiredForeign.map_message:type_name -> goproto.proto.test.TestRequiredForeign.MapMessageEntry
14, // 143: goproto.proto.test.TestRequiredForeign.oneof_message:type_name -> goproto.proto.test.TestRequired
49, // 144: goproto.proto.test.TestRequiredGroupFields.optionalgroup:type_name -> goproto.proto.test.TestRequiredGroupFields.OptionalGroup
50, // 145: goproto.proto.test.TestRequiredGroupFields.repeatedgroup:type_name -> goproto.proto.test.TestRequiredGroupFields.RepeatedGroup
14, // 146: goproto.proto.test.TestRequiredLazy.optional_lazy_message:type_name -> goproto.proto.test.TestRequired
0, // 147: goproto.proto.test.TestPackedTypes.packed_enum:type_name -> goproto.proto.test.ForeignEnum
0, // 148: goproto.proto.test.TestUnpackedTypes.unpacked_enum:type_name -> goproto.proto.test.ForeignEnum
54, // 149: goproto.proto.test.RemoteDefault.default:type_name -> goproto.proto.enums.Enum
54, // 150: goproto.proto.test.RemoteDefault.zero:type_name -> goproto.proto.enums.Enum
54, // 151: goproto.proto.test.RemoteDefault.one:type_name -> goproto.proto.enums.Enum
54, // 152: goproto.proto.test.RemoteDefault.elevent:type_name -> goproto.proto.enums.Enum
54, // 153: goproto.proto.test.RemoteDefault.seventeen:type_name -> goproto.proto.enums.Enum
54, // 154: goproto.proto.test.RemoteDefault.thirtyseven:type_name -> goproto.proto.enums.Enum
54, // 155: goproto.proto.test.RemoteDefault.sixtyseven:type_name -> goproto.proto.enums.Enum
54, // 156: goproto.proto.test.RemoteDefault.negative:type_name -> goproto.proto.enums.Enum
4, // 157: goproto.proto.test.TestAllTypes.NestedMessage.corecursive:type_name -> goproto.proto.test.TestAllTypes
26, // 158: goproto.proto.test.TestAllTypes.OptionalGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
26, // 159: goproto.proto.test.TestAllTypes.RepeatedGroup.optional_nested_message:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
26, // 160: goproto.proto.test.TestAllTypes.MapStringNestedMessageEntry.value:type_name -> goproto.proto.test.TestAllTypes.NestedMessage
2, // 161: goproto.proto.test.TestAllTypes.MapStringNestedEnumEntry.value:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
10, // 162: goproto.proto.test.TestAllExtensions.NestedMessage.corecursive:type_name -> goproto.proto.test.TestAllExtensions
14, // 163: goproto.proto.test.TestRequiredForeign.MapMessageEntry.value:type_name -> goproto.proto.test.TestRequired
10, // 164: goproto.proto.test.optional_int32:extendee -> goproto.proto.test.TestAllExtensions
10, // 165: goproto.proto.test.optional_int64:extendee -> goproto.proto.test.TestAllExtensions
10, // 166: goproto.proto.test.optional_uint32:extendee -> goproto.proto.test.TestAllExtensions
10, // 167: goproto.proto.test.optional_uint64:extendee -> goproto.proto.test.TestAllExtensions
10, // 168: goproto.proto.test.optional_sint32:extendee -> goproto.proto.test.TestAllExtensions
10, // 169: goproto.proto.test.optional_sint64:extendee -> goproto.proto.test.TestAllExtensions
10, // 170: goproto.proto.test.optional_fixed32:extendee -> goproto.proto.test.TestAllExtensions
10, // 171: goproto.proto.test.optional_fixed64:extendee -> goproto.proto.test.TestAllExtensions
10, // 172: goproto.proto.test.optional_sfixed32:extendee -> goproto.proto.test.TestAllExtensions
10, // 173: goproto.proto.test.optional_sfixed64:extendee -> goproto.proto.test.TestAllExtensions
10, // 174: goproto.proto.test.optional_float:extendee -> goproto.proto.test.TestAllExtensions
10, // 175: goproto.proto.test.optional_double:extendee -> goproto.proto.test.TestAllExtensions
10, // 176: goproto.proto.test.optional_bool:extendee -> goproto.proto.test.TestAllExtensions
10, // 177: goproto.proto.test.optional_string:extendee -> goproto.proto.test.TestAllExtensions
10, // 178: goproto.proto.test.optional_bytes:extendee -> goproto.proto.test.TestAllExtensions
10, // 179: goproto.proto.test.optionalgroup:extendee -> goproto.proto.test.TestAllExtensions
10, // 180: goproto.proto.test.optional_nested_message:extendee -> goproto.proto.test.TestAllExtensions
10, // 181: goproto.proto.test.optional_nested_enum:extendee -> goproto.proto.test.TestAllExtensions
10, // 182: goproto.proto.test.repeated_int32:extendee -> goproto.proto.test.TestAllExtensions
10, // 183: goproto.proto.test.repeated_int64:extendee -> goproto.proto.test.TestAllExtensions
10, // 184: goproto.proto.test.repeated_uint32:extendee -> goproto.proto.test.TestAllExtensions
10, // 185: goproto.proto.test.repeated_uint64:extendee -> goproto.proto.test.TestAllExtensions
10, // 186: goproto.proto.test.repeated_sint32:extendee -> goproto.proto.test.TestAllExtensions
10, // 187: goproto.proto.test.repeated_sint64:extendee -> goproto.proto.test.TestAllExtensions
10, // 188: goproto.proto.test.repeated_fixed32:extendee -> goproto.proto.test.TestAllExtensions
10, // 189: goproto.proto.test.repeated_fixed64:extendee -> goproto.proto.test.TestAllExtensions
10, // 190: goproto.proto.test.repeated_sfixed32:extendee -> goproto.proto.test.TestAllExtensions
10, // 191: goproto.proto.test.repeated_sfixed64:extendee -> goproto.proto.test.TestAllExtensions
10, // 192: goproto.proto.test.repeated_float:extendee -> goproto.proto.test.TestAllExtensions
10, // 193: goproto.proto.test.repeated_double:extendee -> goproto.proto.test.TestAllExtensions
10, // 194: goproto.proto.test.repeated_bool:extendee -> goproto.proto.test.TestAllExtensions
10, // 195: goproto.proto.test.repeated_string:extendee -> goproto.proto.test.TestAllExtensions
10, // 196: goproto.proto.test.repeated_bytes:extendee -> goproto.proto.test.TestAllExtensions
10, // 197: goproto.proto.test.repeatedgroup:extendee -> goproto.proto.test.TestAllExtensions
10, // 198: goproto.proto.test.repeated_nested_message:extendee -> goproto.proto.test.TestAllExtensions
10, // 199: goproto.proto.test.repeated_nested_enum:extendee -> goproto.proto.test.TestAllExtensions
10, // 200: goproto.proto.test.default_int32:extendee -> goproto.proto.test.TestAllExtensions
10, // 201: goproto.proto.test.default_int64:extendee -> goproto.proto.test.TestAllExtensions
10, // 202: goproto.proto.test.default_uint32:extendee -> goproto.proto.test.TestAllExtensions
10, // 203: goproto.proto.test.default_uint64:extendee -> goproto.proto.test.TestAllExtensions
10, // 204: goproto.proto.test.default_sint32:extendee -> goproto.proto.test.TestAllExtensions
10, // 205: goproto.proto.test.default_sint64:extendee -> goproto.proto.test.TestAllExtensions
10, // 206: goproto.proto.test.default_fixed32:extendee -> goproto.proto.test.TestAllExtensions
10, // 207: goproto.proto.test.default_fixed64:extendee -> goproto.proto.test.TestAllExtensions
10, // 208: goproto.proto.test.default_sfixed32:extendee -> goproto.proto.test.TestAllExtensions
10, // 209: goproto.proto.test.default_sfixed64:extendee -> goproto.proto.test.TestAllExtensions
10, // 210: goproto.proto.test.default_float:extendee -> goproto.proto.test.TestAllExtensions
10, // 211: goproto.proto.test.default_double:extendee -> goproto.proto.test.TestAllExtensions
10, // 212: goproto.proto.test.default_bool:extendee -> goproto.proto.test.TestAllExtensions
10, // 213: goproto.proto.test.default_string:extendee -> goproto.proto.test.TestAllExtensions
10, // 214: goproto.proto.test.default_bytes:extendee -> goproto.proto.test.TestAllExtensions
20, // 215: goproto.proto.test.packed_int32:extendee -> goproto.proto.test.TestPackedExtensions
20, // 216: goproto.proto.test.packed_int64:extendee -> goproto.proto.test.TestPackedExtensions
20, // 217: goproto.proto.test.packed_uint32:extendee -> goproto.proto.test.TestPackedExtensions
20, // 218: goproto.proto.test.packed_uint64:extendee -> goproto.proto.test.TestPackedExtensions
20, // 219: goproto.proto.test.packed_sint32:extendee -> goproto.proto.test.TestPackedExtensions
20, // 220: goproto.proto.test.packed_sint64:extendee -> goproto.proto.test.TestPackedExtensions
20, // 221: goproto.proto.test.packed_fixed32:extendee -> goproto.proto.test.TestPackedExtensions
20, // 222: goproto.proto.test.packed_fixed64:extendee -> goproto.proto.test.TestPackedExtensions
20, // 223: goproto.proto.test.packed_sfixed32:extendee -> goproto.proto.test.TestPackedExtensions
20, // 224: goproto.proto.test.packed_sfixed64:extendee -> goproto.proto.test.TestPackedExtensions
20, // 225: goproto.proto.test.packed_float:extendee -> goproto.proto.test.TestPackedExtensions
20, // 226: goproto.proto.test.packed_double:extendee -> goproto.proto.test.TestPackedExtensions
20, // 227: goproto.proto.test.packed_bool:extendee -> goproto.proto.test.TestPackedExtensions
20, // 228: goproto.proto.test.packed_enum:extendee -> goproto.proto.test.TestPackedExtensions
21, // 229: goproto.proto.test.unpacked_int32:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 230: goproto.proto.test.unpacked_int64:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 231: goproto.proto.test.unpacked_uint32:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 232: goproto.proto.test.unpacked_uint64:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 233: goproto.proto.test.unpacked_sint32:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 234: goproto.proto.test.unpacked_sint64:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 235: goproto.proto.test.unpacked_fixed32:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 236: goproto.proto.test.unpacked_fixed64:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 237: goproto.proto.test.unpacked_sfixed32:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 238: goproto.proto.test.unpacked_sfixed64:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 239: goproto.proto.test.unpacked_float:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 240: goproto.proto.test.unpacked_double:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 241: goproto.proto.test.unpacked_bool:extendee -> goproto.proto.test.TestUnpackedExtensions
21, // 242: goproto.proto.test.unpacked_enum:extendee -> goproto.proto.test.TestUnpackedExtensions
10, // 243: goproto.proto.test.TestNestedExtension.nested_string_extension:extendee -> goproto.proto.test.TestAllExtensions
10, // 244: goproto.proto.test.TestRequired.single:extendee -> goproto.proto.test.TestAllExtensions
10, // 245: goproto.proto.test.TestRequired.multi:extendee -> goproto.proto.test.TestAllExtensions
11, // 246: goproto.proto.test.optionalgroup:type_name -> goproto.proto.test.OptionalGroup
47, // 247: goproto.proto.test.optional_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
2, // 248: goproto.proto.test.optional_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
12, // 249: goproto.proto.test.repeatedgroup:type_name -> goproto.proto.test.RepeatedGroup
47, // 250: goproto.proto.test.repeated_nested_message:type_name -> goproto.proto.test.TestAllExtensions.NestedMessage
2, // 251: goproto.proto.test.repeated_nested_enum:type_name -> goproto.proto.test.TestAllTypes.NestedEnum
0, // 252: goproto.proto.test.packed_enum:type_name -> goproto.proto.test.ForeignEnum
0, // 253: goproto.proto.test.unpacked_enum:type_name -> goproto.proto.test.ForeignEnum
14, // 254: goproto.proto.test.TestRequired.single:type_name -> goproto.proto.test.TestRequired
14, // 255: goproto.proto.test.TestRequired.multi:type_name -> goproto.proto.test.TestRequired
22, // 256: goproto.proto.test.TestService.Foo:input_type -> goproto.proto.test.FooRequest
22, // 257: goproto.proto.test.TestService.TestStream:input_type -> goproto.proto.test.FooRequest
6, // 258: goproto.proto.test.TestDeprecatedService.Deprecated:input_type -> goproto.proto.test.TestDeprecatedMessage
23, // 259: goproto.proto.test.TestService.Foo:output_type -> goproto.proto.test.FooResponse
23, // 260: goproto.proto.test.TestService.TestStream:output_type -> goproto.proto.test.FooResponse
6, // 261: goproto.proto.test.TestDeprecatedService.Deprecated:output_type -> goproto.proto.test.TestDeprecatedMessage
259, // [259:262] is the sub-list for method output_type
256, // [256:259] is the sub-list for method input_type
246, // [246:256] is the sub-list for extension type_name
164, // [164:246] is the sub-list for extension extendee
0, // [0:164] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test_test_proto_init() }
func file_internal_testprotos_test_test_proto_init() {
if File_internal_testprotos_test_test_proto != nil {
return
}
file_internal_testprotos_test_test_public_proto_init()
file_internal_testprotos_test_test_import_proto_init()
file_internal_testprotos_test_test_proto_msgTypes[0].OneofWrappers = []any{
(*TestAllTypes_OneofUint32)(nil),
(*TestAllTypes_OneofNestedMessage)(nil),
(*TestAllTypes_OneofString)(nil),
(*TestAllTypes_OneofBytes)(nil),
(*TestAllTypes_OneofBool)(nil),
(*TestAllTypes_OneofUint64)(nil),
(*TestAllTypes_OneofFloat)(nil),
(*TestAllTypes_OneofDouble)(nil),
(*TestAllTypes_OneofEnum)(nil),
(*TestAllTypes_Oneofgroup)(nil),
(*TestAllTypes_OneofOptionalUint32)(nil),
}
file_internal_testprotos_test_test_proto_msgTypes[2].OneofWrappers = []any{
(*TestDeprecatedMessage_DeprecatedOneofField)(nil),
}
file_internal_testprotos_test_test_proto_msgTypes[3].OneofWrappers = []any{
(*TestOneofWithRequired_OneofUint32)(nil),
(*TestOneofWithRequired_OneofRequired)(nil),
}
file_internal_testprotos_test_test_proto_msgTypes[11].OneofWrappers = []any{
(*TestRequiredForeign_OneofMessage)(nil),
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_test_proto_rawDesc), len(file_internal_testprotos_test_test_proto_rawDesc)),
NumEnums: 4,
NumMessages: 47,
NumExtensions: 82,
NumServices: 2,
},
GoTypes: file_internal_testprotos_test_test_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test_test_proto_depIdxs,
EnumInfos: file_internal_testprotos_test_test_proto_enumTypes,
MessageInfos: file_internal_testprotos_test_test_proto_msgTypes,
ExtensionInfos: file_internal_testprotos_test_test_proto_extTypes,
}.Build()
File_internal_testprotos_test_test_proto = out.File
file_internal_testprotos_test_test_proto_goTypes = nil
file_internal_testprotos_test_test_proto_depIdxs = nil
}
// Copyright 2018 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test/test_import.proto
package test
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type ImportEnum int32
const (
ImportEnum_IMPORT_ZERO ImportEnum = 0
)
// Enum value maps for ImportEnum.
var (
ImportEnum_name = map[int32]string{
0: "IMPORT_ZERO",
}
ImportEnum_value = map[string]int32{
"IMPORT_ZERO": 0,
}
)
func (x ImportEnum) Enum() *ImportEnum {
p := new(ImportEnum)
*p = x
return p
}
func (x ImportEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ImportEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test_test_import_proto_enumTypes[0].Descriptor()
}
func (ImportEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test_test_import_proto_enumTypes[0]
}
func (x ImportEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *ImportEnum) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = ImportEnum(num)
return nil
}
// Deprecated: Use ImportEnum.Descriptor instead.
func (ImportEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_import_proto_rawDescGZIP(), []int{0}
}
type ImportMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ImportMessage) Reset() {
*x = ImportMessage{}
mi := &file_internal_testprotos_test_test_import_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ImportMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ImportMessage) ProtoMessage() {}
func (x *ImportMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_import_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ImportMessage.ProtoReflect.Descriptor instead.
func (*ImportMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_import_proto_rawDescGZIP(), []int{0}
}
var File_internal_testprotos_test_test_import_proto protoreflect.FileDescriptor
const file_internal_testprotos_test_test_import_proto_rawDesc = "" +
"\n" +
"*internal/testprotos/test/test_import.proto\x12\x12goproto.proto.test\"\x0f\n" +
"\rImportMessage*\x1d\n" +
"\n" +
"ImportEnum\x12\x0f\n" +
"\vIMPORT_ZERO\x10\x00B5Z3google.golang.org/protobuf/internal/testprotos/test"
var (
file_internal_testprotos_test_test_import_proto_rawDescOnce sync.Once
file_internal_testprotos_test_test_import_proto_rawDescData []byte
)
func file_internal_testprotos_test_test_import_proto_rawDescGZIP() []byte {
file_internal_testprotos_test_test_import_proto_rawDescOnce.Do(func() {
file_internal_testprotos_test_test_import_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_test_import_proto_rawDesc), len(file_internal_testprotos_test_test_import_proto_rawDesc)))
})
return file_internal_testprotos_test_test_import_proto_rawDescData
}
var file_internal_testprotos_test_test_import_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_internal_testprotos_test_test_import_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_internal_testprotos_test_test_import_proto_goTypes = []any{
(ImportEnum)(0), // 0: goproto.proto.test.ImportEnum
(*ImportMessage)(nil), // 1: goproto.proto.test.ImportMessage
}
var file_internal_testprotos_test_test_import_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test_test_import_proto_init() }
func file_internal_testprotos_test_test_import_proto_init() {
if File_internal_testprotos_test_test_import_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_test_import_proto_rawDesc), len(file_internal_testprotos_test_test_import_proto_rawDesc)),
NumEnums: 1,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_test_test_import_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test_test_import_proto_depIdxs,
EnumInfos: file_internal_testprotos_test_test_import_proto_enumTypes,
MessageInfos: file_internal_testprotos_test_test_import_proto_msgTypes,
}.Build()
File_internal_testprotos_test_test_import_proto = out.File
file_internal_testprotos_test_test_import_proto_goTypes = nil
file_internal_testprotos_test_test_import_proto_depIdxs = nil
}
// 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test/test_public.proto
package test
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type PublicImportMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *PublicImportMessage) Reset() {
*x = PublicImportMessage{}
mi := &file_internal_testprotos_test_test_public_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *PublicImportMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PublicImportMessage) ProtoMessage() {}
func (x *PublicImportMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test_test_public_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PublicImportMessage.ProtoReflect.Descriptor instead.
func (*PublicImportMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test_test_public_proto_rawDescGZIP(), []int{0}
}
var File_internal_testprotos_test_test_public_proto protoreflect.FileDescriptor
const file_internal_testprotos_test_test_public_proto_rawDesc = "" +
"\n" +
"*internal/testprotos/test/test_public.proto\x12\x12goproto.proto.test\"\x15\n" +
"\x13PublicImportMessageB5Z3google.golang.org/protobuf/internal/testprotos/test"
var (
file_internal_testprotos_test_test_public_proto_rawDescOnce sync.Once
file_internal_testprotos_test_test_public_proto_rawDescData []byte
)
func file_internal_testprotos_test_test_public_proto_rawDescGZIP() []byte {
file_internal_testprotos_test_test_public_proto_rawDescOnce.Do(func() {
file_internal_testprotos_test_test_public_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_test_public_proto_rawDesc), len(file_internal_testprotos_test_test_public_proto_rawDesc)))
})
return file_internal_testprotos_test_test_public_proto_rawDescData
}
var file_internal_testprotos_test_test_public_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_internal_testprotos_test_test_public_proto_goTypes = []any{
(*PublicImportMessage)(nil), // 0: goproto.proto.test.PublicImportMessage
}
var file_internal_testprotos_test_test_public_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test_test_public_proto_init() }
func file_internal_testprotos_test_test_public_proto_init() {
if File_internal_testprotos_test_test_public_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test_test_public_proto_rawDesc), len(file_internal_testprotos_test_test_public_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_test_test_public_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test_test_public_proto_depIdxs,
MessageInfos: file_internal_testprotos_test_test_public_proto_msgTypes,
}.Build()
File_internal_testprotos_test_test_public_proto = out.File
file_internal_testprotos_test_test_public_proto_goTypes = nil
file_internal_testprotos_test_test_public_proto_depIdxs = nil
}
// Copyright 2018 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test3/test.proto
package test3
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type ForeignEnum int32
const (
ForeignEnum_FOREIGN_ZERO ForeignEnum = 0
ForeignEnum_FOREIGN_FOO ForeignEnum = 4
ForeignEnum_FOREIGN_BAR ForeignEnum = 5
ForeignEnum_FOREIGN_BAZ ForeignEnum = 6
)
// Enum value maps for ForeignEnum.
var (
ForeignEnum_name = map[int32]string{
0: "FOREIGN_ZERO",
4: "FOREIGN_FOO",
5: "FOREIGN_BAR",
6: "FOREIGN_BAZ",
}
ForeignEnum_value = map[string]int32{
"FOREIGN_ZERO": 0,
"FOREIGN_FOO": 4,
"FOREIGN_BAR": 5,
"FOREIGN_BAZ": 6,
}
)
func (x ForeignEnum) Enum() *ForeignEnum {
p := new(ForeignEnum)
*p = x
return p
}
func (x ForeignEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ForeignEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test3_test_proto_enumTypes[0].Descriptor()
}
func (ForeignEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test3_test_proto_enumTypes[0]
}
func (x ForeignEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use ForeignEnum.Descriptor instead.
func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0}
}
type TestAllTypes_NestedEnum int32
const (
TestAllTypes_FOO TestAllTypes_NestedEnum = 0
TestAllTypes_BAR TestAllTypes_NestedEnum = 1
TestAllTypes_BAZ TestAllTypes_NestedEnum = 2
TestAllTypes_NEG TestAllTypes_NestedEnum = -1 // Intentionally negative.
)
// Enum value maps for TestAllTypes_NestedEnum.
var (
TestAllTypes_NestedEnum_name = map[int32]string{
0: "FOO",
1: "BAR",
2: "BAZ",
-1: "NEG",
}
TestAllTypes_NestedEnum_value = map[string]int32{
"FOO": 0,
"BAR": 1,
"BAZ": 2,
"NEG": -1,
}
)
func (x TestAllTypes_NestedEnum) Enum() *TestAllTypes_NestedEnum {
p := new(TestAllTypes_NestedEnum)
*p = x
return p
}
func (x TestAllTypes_NestedEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (TestAllTypes_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test3_test_proto_enumTypes[1].Descriptor()
}
func (TestAllTypes_NestedEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test3_test_proto_enumTypes[1]
}
func (x TestAllTypes_NestedEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use TestAllTypes_NestedEnum.Descriptor instead.
func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0, 0}
}
type TestAllTypes struct {
state protoimpl.MessageState `protogen:"open.v1"`
SingularInt32 int32 `protobuf:"varint,81,opt,name=singular_int32,json=singularInt32,proto3" json:"singular_int32,omitempty"`
SingularInt64 int64 `protobuf:"varint,82,opt,name=singular_int64,json=singularInt64,proto3" json:"singular_int64,omitempty"`
SingularUint32 uint32 `protobuf:"varint,83,opt,name=singular_uint32,json=singularUint32,proto3" json:"singular_uint32,omitempty"`
SingularUint64 uint64 `protobuf:"varint,84,opt,name=singular_uint64,json=singularUint64,proto3" json:"singular_uint64,omitempty"`
SingularSint32 int32 `protobuf:"zigzag32,85,opt,name=singular_sint32,json=singularSint32,proto3" json:"singular_sint32,omitempty"`
SingularSint64 int64 `protobuf:"zigzag64,86,opt,name=singular_sint64,json=singularSint64,proto3" json:"singular_sint64,omitempty"`
SingularFixed32 uint32 `protobuf:"fixed32,87,opt,name=singular_fixed32,json=singularFixed32,proto3" json:"singular_fixed32,omitempty"`
SingularFixed64 uint64 `protobuf:"fixed64,88,opt,name=singular_fixed64,json=singularFixed64,proto3" json:"singular_fixed64,omitempty"`
SingularSfixed32 int32 `protobuf:"fixed32,89,opt,name=singular_sfixed32,json=singularSfixed32,proto3" json:"singular_sfixed32,omitempty"`
SingularSfixed64 int64 `protobuf:"fixed64,90,opt,name=singular_sfixed64,json=singularSfixed64,proto3" json:"singular_sfixed64,omitempty"`
SingularFloat float32 `protobuf:"fixed32,91,opt,name=singular_float,json=singularFloat,proto3" json:"singular_float,omitempty"`
SingularDouble float64 `protobuf:"fixed64,92,opt,name=singular_double,json=singularDouble,proto3" json:"singular_double,omitempty"`
SingularBool bool `protobuf:"varint,93,opt,name=singular_bool,json=singularBool,proto3" json:"singular_bool,omitempty"`
SingularString string `protobuf:"bytes,94,opt,name=singular_string,json=singularString,proto3" json:"singular_string,omitempty"`
SingularBytes []byte `protobuf:"bytes,95,opt,name=singular_bytes,json=singularBytes,proto3" json:"singular_bytes,omitempty"`
SingularNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,98,opt,name=singular_nested_message,json=singularNestedMessage,proto3" json:"singular_nested_message,omitempty"`
SingularForeignMessage *ForeignMessage `protobuf:"bytes,99,opt,name=singular_foreign_message,json=singularForeignMessage,proto3" json:"singular_foreign_message,omitempty"`
SingularImportMessage *ImportMessage `protobuf:"bytes,100,opt,name=singular_import_message,json=singularImportMessage,proto3" json:"singular_import_message,omitempty"`
SingularNestedEnum TestAllTypes_NestedEnum `protobuf:"varint,101,opt,name=singular_nested_enum,json=singularNestedEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum" json:"singular_nested_enum,omitempty"`
SingularForeignEnum ForeignEnum `protobuf:"varint,102,opt,name=singular_foreign_enum,json=singularForeignEnum,proto3,enum=goproto.proto.test3.ForeignEnum" json:"singular_foreign_enum,omitempty"`
SingularImportEnum ImportEnum `protobuf:"varint,103,opt,name=singular_import_enum,json=singularImportEnum,proto3,enum=goproto.proto.test3.ImportEnum" json:"singular_import_enum,omitempty"`
OptionalInt32 *int32 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32,proto3,oneof" json:"optional_int32,omitempty"`
OptionalInt64 *int64 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64,proto3,oneof" json:"optional_int64,omitempty"`
OptionalUint32 *uint32 `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32,proto3,oneof" json:"optional_uint32,omitempty"`
OptionalUint64 *uint64 `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64,proto3,oneof" json:"optional_uint64,omitempty"`
OptionalSint32 *int32 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32,proto3,oneof" json:"optional_sint32,omitempty"`
OptionalSint64 *int64 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64,proto3,oneof" json:"optional_sint64,omitempty"`
OptionalFixed32 *uint32 `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32,proto3,oneof" json:"optional_fixed32,omitempty"`
OptionalFixed64 *uint64 `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64,proto3,oneof" json:"optional_fixed64,omitempty"`
OptionalSfixed32 *int32 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32,proto3,oneof" json:"optional_sfixed32,omitempty"`
OptionalSfixed64 *int64 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64,proto3,oneof" json:"optional_sfixed64,omitempty"`
OptionalFloat *float32 `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat,proto3,oneof" json:"optional_float,omitempty"`
OptionalDouble *float64 `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble,proto3,oneof" json:"optional_double,omitempty"`
OptionalBool *bool `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool,proto3,oneof" json:"optional_bool,omitempty"`
OptionalString *string `protobuf:"bytes,14,opt,name=optional_string,json=optionalString,proto3,oneof" json:"optional_string,omitempty"`
OptionalBytes []byte `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3,oneof" json:"optional_bytes,omitempty"`
OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage,proto3,oneof" json:"optional_nested_message,omitempty"`
OptionalForeignMessage *ForeignMessage `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage,proto3,oneof" json:"optional_foreign_message,omitempty"`
OptionalImportMessage *ImportMessage `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage,proto3,oneof" json:"optional_import_message,omitempty"`
OptionalNestedEnum *TestAllTypes_NestedEnum `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum,oneof" json:"optional_nested_enum,omitempty"`
OptionalForeignEnum *ForeignEnum `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,proto3,enum=goproto.proto.test3.ForeignEnum,oneof" json:"optional_foreign_enum,omitempty"`
OptionalImportEnum *ImportEnum `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,proto3,enum=goproto.proto.test3.ImportEnum,oneof" json:"optional_import_enum,omitempty"`
RepeatedInt32 []int32 `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32,proto3" json:"repeated_int32,omitempty"`
RepeatedInt64 []int64 `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64,proto3" json:"repeated_int64,omitempty"`
RepeatedUint32 []uint32 `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3" json:"repeated_uint32,omitempty"`
RepeatedUint64 []uint64 `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3" json:"repeated_uint64,omitempty"`
RepeatedSint32 []int32 `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3" json:"repeated_sint32,omitempty"`
RepeatedSint64 []int64 `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3" json:"repeated_sint64,omitempty"`
RepeatedFixed32 []uint32 `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3" json:"repeated_fixed32,omitempty"`
RepeatedFixed64 []uint64 `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3" json:"repeated_fixed64,omitempty"`
RepeatedSfixed32 []int32 `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3" json:"repeated_sfixed32,omitempty"`
RepeatedSfixed64 []int64 `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3" json:"repeated_sfixed64,omitempty"`
RepeatedFloat []float32 `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat,proto3" json:"repeated_float,omitempty"`
RepeatedDouble []float64 `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble,proto3" json:"repeated_double,omitempty"`
RepeatedBool []bool `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool,proto3" json:"repeated_bool,omitempty"`
RepeatedString []string `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString,proto3" json:"repeated_string,omitempty"`
RepeatedBytes [][]byte `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
RepeatedNestedMessage []*TestAllTypes_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage,proto3" json:"repeated_nested_message,omitempty"`
RepeatedForeignMessage []*ForeignMessage `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage,proto3" json:"repeated_foreign_message,omitempty"`
RepeatedImportmessage []*ImportMessage `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage,proto3" json:"repeated_importmessage,omitempty"`
RepeatedNestedEnum []TestAllTypes_NestedEnum `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
RepeatedForeignEnum []ForeignEnum `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,proto3,enum=goproto.proto.test3.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
RepeatedImportenum []ImportEnum `protobuf:"varint,53,rep,packed,name=repeated_importenum,json=repeatedImportenum,proto3,enum=goproto.proto.test3.ImportEnum" json:"repeated_importenum,omitempty"`
MapInt32Int32 map[int32]int32 `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32,proto3" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapInt64Int64 map[int64]int64 `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64,proto3" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapUint32Uint32 map[uint32]uint32 `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32,proto3" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapUint64Uint64 map[uint64]uint64 `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64,proto3" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapSint32Sint32 map[int32]int32 `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32,proto3" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
MapSint64Sint64 map[int64]int64 `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64,proto3" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
MapFixed32Fixed32 map[uint32]uint32 `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32,proto3" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
MapFixed64Fixed64 map[uint64]uint64 `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64,proto3" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
MapSfixed32Sfixed32 map[int32]int32 `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32,proto3" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
MapSfixed64Sfixed64 map[int64]int64 `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64,proto3" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
MapInt32Float map[int32]float32 `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float,proto3" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
MapInt32Double map[int32]float64 `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double,proto3" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
MapBoolBool map[bool]bool `protobuf:"bytes,68,rep,name=map_bool_bool,json=mapBoolBool,proto3" json:"map_bool_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MapStringString map[string]string `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString,proto3" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MapStringBytes map[string][]byte `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes,proto3" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MapStringNestedMessage map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage,proto3" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MapStringNestedEnum map[string]TestAllTypes_NestedEnum `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum,proto3" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=goproto.proto.test3.TestAllTypes_NestedEnum"`
// Types that are valid to be assigned to OneofField:
//
// *TestAllTypes_OneofUint32
// *TestAllTypes_OneofNestedMessage
// *TestAllTypes_OneofString
// *TestAllTypes_OneofBytes
// *TestAllTypes_OneofBool
// *TestAllTypes_OneofUint64
// *TestAllTypes_OneofFloat
// *TestAllTypes_OneofDouble
// *TestAllTypes_OneofEnum
OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllTypes) Reset() {
*x = TestAllTypes{}
mi := &file_internal_testprotos_test3_test_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes) ProtoMessage() {}
func (x *TestAllTypes) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test3_test_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes.ProtoReflect.Descriptor instead.
func (*TestAllTypes) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0}
}
func (x *TestAllTypes) GetSingularInt32() int32 {
if x != nil {
return x.SingularInt32
}
return 0
}
func (x *TestAllTypes) GetSingularInt64() int64 {
if x != nil {
return x.SingularInt64
}
return 0
}
func (x *TestAllTypes) GetSingularUint32() uint32 {
if x != nil {
return x.SingularUint32
}
return 0
}
func (x *TestAllTypes) GetSingularUint64() uint64 {
if x != nil {
return x.SingularUint64
}
return 0
}
func (x *TestAllTypes) GetSingularSint32() int32 {
if x != nil {
return x.SingularSint32
}
return 0
}
func (x *TestAllTypes) GetSingularSint64() int64 {
if x != nil {
return x.SingularSint64
}
return 0
}
func (x *TestAllTypes) GetSingularFixed32() uint32 {
if x != nil {
return x.SingularFixed32
}
return 0
}
func (x *TestAllTypes) GetSingularFixed64() uint64 {
if x != nil {
return x.SingularFixed64
}
return 0
}
func (x *TestAllTypes) GetSingularSfixed32() int32 {
if x != nil {
return x.SingularSfixed32
}
return 0
}
func (x *TestAllTypes) GetSingularSfixed64() int64 {
if x != nil {
return x.SingularSfixed64
}
return 0
}
func (x *TestAllTypes) GetSingularFloat() float32 {
if x != nil {
return x.SingularFloat
}
return 0
}
func (x *TestAllTypes) GetSingularDouble() float64 {
if x != nil {
return x.SingularDouble
}
return 0
}
func (x *TestAllTypes) GetSingularBool() bool {
if x != nil {
return x.SingularBool
}
return false
}
func (x *TestAllTypes) GetSingularString() string {
if x != nil {
return x.SingularString
}
return ""
}
func (x *TestAllTypes) GetSingularBytes() []byte {
if x != nil {
return x.SingularBytes
}
return nil
}
func (x *TestAllTypes) GetSingularNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
return x.SingularNestedMessage
}
return nil
}
func (x *TestAllTypes) GetSingularForeignMessage() *ForeignMessage {
if x != nil {
return x.SingularForeignMessage
}
return nil
}
func (x *TestAllTypes) GetSingularImportMessage() *ImportMessage {
if x != nil {
return x.SingularImportMessage
}
return nil
}
func (x *TestAllTypes) GetSingularNestedEnum() TestAllTypes_NestedEnum {
if x != nil {
return x.SingularNestedEnum
}
return TestAllTypes_FOO
}
func (x *TestAllTypes) GetSingularForeignEnum() ForeignEnum {
if x != nil {
return x.SingularForeignEnum
}
return ForeignEnum_FOREIGN_ZERO
}
func (x *TestAllTypes) GetSingularImportEnum() ImportEnum {
if x != nil {
return x.SingularImportEnum
}
return ImportEnum_IMPORT_ZERO
}
func (x *TestAllTypes) GetOptionalInt32() int32 {
if x != nil && x.OptionalInt32 != nil {
return *x.OptionalInt32
}
return 0
}
func (x *TestAllTypes) GetOptionalInt64() int64 {
if x != nil && x.OptionalInt64 != nil {
return *x.OptionalInt64
}
return 0
}
func (x *TestAllTypes) GetOptionalUint32() uint32 {
if x != nil && x.OptionalUint32 != nil {
return *x.OptionalUint32
}
return 0
}
func (x *TestAllTypes) GetOptionalUint64() uint64 {
if x != nil && x.OptionalUint64 != nil {
return *x.OptionalUint64
}
return 0
}
func (x *TestAllTypes) GetOptionalSint32() int32 {
if x != nil && x.OptionalSint32 != nil {
return *x.OptionalSint32
}
return 0
}
func (x *TestAllTypes) GetOptionalSint64() int64 {
if x != nil && x.OptionalSint64 != nil {
return *x.OptionalSint64
}
return 0
}
func (x *TestAllTypes) GetOptionalFixed32() uint32 {
if x != nil && x.OptionalFixed32 != nil {
return *x.OptionalFixed32
}
return 0
}
func (x *TestAllTypes) GetOptionalFixed64() uint64 {
if x != nil && x.OptionalFixed64 != nil {
return *x.OptionalFixed64
}
return 0
}
func (x *TestAllTypes) GetOptionalSfixed32() int32 {
if x != nil && x.OptionalSfixed32 != nil {
return *x.OptionalSfixed32
}
return 0
}
func (x *TestAllTypes) GetOptionalSfixed64() int64 {
if x != nil && x.OptionalSfixed64 != nil {
return *x.OptionalSfixed64
}
return 0
}
func (x *TestAllTypes) GetOptionalFloat() float32 {
if x != nil && x.OptionalFloat != nil {
return *x.OptionalFloat
}
return 0
}
func (x *TestAllTypes) GetOptionalDouble() float64 {
if x != nil && x.OptionalDouble != nil {
return *x.OptionalDouble
}
return 0
}
func (x *TestAllTypes) GetOptionalBool() bool {
if x != nil && x.OptionalBool != nil {
return *x.OptionalBool
}
return false
}
func (x *TestAllTypes) GetOptionalString() string {
if x != nil && x.OptionalString != nil {
return *x.OptionalString
}
return ""
}
func (x *TestAllTypes) GetOptionalBytes() []byte {
if x != nil {
return x.OptionalBytes
}
return nil
}
func (x *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
return x.OptionalNestedMessage
}
return nil
}
func (x *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage {
if x != nil {
return x.OptionalForeignMessage
}
return nil
}
func (x *TestAllTypes) GetOptionalImportMessage() *ImportMessage {
if x != nil {
return x.OptionalImportMessage
}
return nil
}
func (x *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
if x != nil && x.OptionalNestedEnum != nil {
return *x.OptionalNestedEnum
}
return TestAllTypes_FOO
}
func (x *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
if x != nil && x.OptionalForeignEnum != nil {
return *x.OptionalForeignEnum
}
return ForeignEnum_FOREIGN_ZERO
}
func (x *TestAllTypes) GetOptionalImportEnum() ImportEnum {
if x != nil && x.OptionalImportEnum != nil {
return *x.OptionalImportEnum
}
return ImportEnum_IMPORT_ZERO
}
func (x *TestAllTypes) GetRepeatedInt32() []int32 {
if x != nil {
return x.RepeatedInt32
}
return nil
}
func (x *TestAllTypes) GetRepeatedInt64() []int64 {
if x != nil {
return x.RepeatedInt64
}
return nil
}
func (x *TestAllTypes) GetRepeatedUint32() []uint32 {
if x != nil {
return x.RepeatedUint32
}
return nil
}
func (x *TestAllTypes) GetRepeatedUint64() []uint64 {
if x != nil {
return x.RepeatedUint64
}
return nil
}
func (x *TestAllTypes) GetRepeatedSint32() []int32 {
if x != nil {
return x.RepeatedSint32
}
return nil
}
func (x *TestAllTypes) GetRepeatedSint64() []int64 {
if x != nil {
return x.RepeatedSint64
}
return nil
}
func (x *TestAllTypes) GetRepeatedFixed32() []uint32 {
if x != nil {
return x.RepeatedFixed32
}
return nil
}
func (x *TestAllTypes) GetRepeatedFixed64() []uint64 {
if x != nil {
return x.RepeatedFixed64
}
return nil
}
func (x *TestAllTypes) GetRepeatedSfixed32() []int32 {
if x != nil {
return x.RepeatedSfixed32
}
return nil
}
func (x *TestAllTypes) GetRepeatedSfixed64() []int64 {
if x != nil {
return x.RepeatedSfixed64
}
return nil
}
func (x *TestAllTypes) GetRepeatedFloat() []float32 {
if x != nil {
return x.RepeatedFloat
}
return nil
}
func (x *TestAllTypes) GetRepeatedDouble() []float64 {
if x != nil {
return x.RepeatedDouble
}
return nil
}
func (x *TestAllTypes) GetRepeatedBool() []bool {
if x != nil {
return x.RepeatedBool
}
return nil
}
func (x *TestAllTypes) GetRepeatedString() []string {
if x != nil {
return x.RepeatedString
}
return nil
}
func (x *TestAllTypes) GetRepeatedBytes() [][]byte {
if x != nil {
return x.RepeatedBytes
}
return nil
}
func (x *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
if x != nil {
return x.RepeatedNestedMessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
if x != nil {
return x.RepeatedForeignMessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedImportmessage() []*ImportMessage {
if x != nil {
return x.RepeatedImportmessage
}
return nil
}
func (x *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
if x != nil {
return x.RepeatedNestedEnum
}
return nil
}
func (x *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
if x != nil {
return x.RepeatedForeignEnum
}
return nil
}
func (x *TestAllTypes) GetRepeatedImportenum() []ImportEnum {
if x != nil {
return x.RepeatedImportenum
}
return nil
}
func (x *TestAllTypes) GetMapInt32Int32() map[int32]int32 {
if x != nil {
return x.MapInt32Int32
}
return nil
}
func (x *TestAllTypes) GetMapInt64Int64() map[int64]int64 {
if x != nil {
return x.MapInt64Int64
}
return nil
}
func (x *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 {
if x != nil {
return x.MapUint32Uint32
}
return nil
}
func (x *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 {
if x != nil {
return x.MapUint64Uint64
}
return nil
}
func (x *TestAllTypes) GetMapSint32Sint32() map[int32]int32 {
if x != nil {
return x.MapSint32Sint32
}
return nil
}
func (x *TestAllTypes) GetMapSint64Sint64() map[int64]int64 {
if x != nil {
return x.MapSint64Sint64
}
return nil
}
func (x *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 {
if x != nil {
return x.MapFixed32Fixed32
}
return nil
}
func (x *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 {
if x != nil {
return x.MapFixed64Fixed64
}
return nil
}
func (x *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 {
if x != nil {
return x.MapSfixed32Sfixed32
}
return nil
}
func (x *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 {
if x != nil {
return x.MapSfixed64Sfixed64
}
return nil
}
func (x *TestAllTypes) GetMapInt32Float() map[int32]float32 {
if x != nil {
return x.MapInt32Float
}
return nil
}
func (x *TestAllTypes) GetMapInt32Double() map[int32]float64 {
if x != nil {
return x.MapInt32Double
}
return nil
}
func (x *TestAllTypes) GetMapBoolBool() map[bool]bool {
if x != nil {
return x.MapBoolBool
}
return nil
}
func (x *TestAllTypes) GetMapStringString() map[string]string {
if x != nil {
return x.MapStringString
}
return nil
}
func (x *TestAllTypes) GetMapStringBytes() map[string][]byte {
if x != nil {
return x.MapStringBytes
}
return nil
}
func (x *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage {
if x != nil {
return x.MapStringNestedMessage
}
return nil
}
func (x *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum {
if x != nil {
return x.MapStringNestedEnum
}
return nil
}
func (x *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
if x != nil {
return x.OneofField
}
return nil
}
func (x *TestAllTypes) GetOneofUint32() uint32 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofUint32); ok {
return x.OneofUint32
}
}
return 0
}
func (x *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofNestedMessage); ok {
return x.OneofNestedMessage
}
}
return nil
}
func (x *TestAllTypes) GetOneofString() string {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofString); ok {
return x.OneofString
}
}
return ""
}
func (x *TestAllTypes) GetOneofBytes() []byte {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofBytes); ok {
return x.OneofBytes
}
}
return nil
}
func (x *TestAllTypes) GetOneofBool() bool {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofBool); ok {
return x.OneofBool
}
}
return false
}
func (x *TestAllTypes) GetOneofUint64() uint64 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofUint64); ok {
return x.OneofUint64
}
}
return 0
}
func (x *TestAllTypes) GetOneofFloat() float32 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofFloat); ok {
return x.OneofFloat
}
}
return 0
}
func (x *TestAllTypes) GetOneofDouble() float64 {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofDouble); ok {
return x.OneofDouble
}
}
return 0
}
func (x *TestAllTypes) GetOneofEnum() TestAllTypes_NestedEnum {
if x != nil {
if x, ok := x.OneofField.(*TestAllTypes_OneofEnum); ok {
return x.OneofEnum
}
}
return TestAllTypes_FOO
}
type isTestAllTypes_OneofField interface {
isTestAllTypes_OneofField()
}
type TestAllTypes_OneofUint32 struct {
OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,proto3,oneof"`
}
type TestAllTypes_OneofNestedMessage struct {
OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,proto3,oneof"`
}
type TestAllTypes_OneofString struct {
OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,proto3,oneof"`
}
type TestAllTypes_OneofBytes struct {
OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
}
type TestAllTypes_OneofBool struct {
OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,proto3,oneof"`
}
type TestAllTypes_OneofUint64 struct {
OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,proto3,oneof"`
}
type TestAllTypes_OneofFloat struct {
OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,proto3,oneof"`
}
type TestAllTypes_OneofDouble struct {
OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,proto3,oneof"`
}
type TestAllTypes_OneofEnum struct {
OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,proto3,enum=goproto.proto.test3.TestAllTypes_NestedEnum,oneof"`
}
func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofString) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofBool) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofUint64) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofFloat) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofDouble) isTestAllTypes_OneofField() {}
func (*TestAllTypes_OneofEnum) isTestAllTypes_OneofField() {}
type ForeignMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
C int32 `protobuf:"varint,1,opt,name=c,proto3" json:"c,omitempty"`
D int32 `protobuf:"varint,2,opt,name=d,proto3" json:"d,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ForeignMessage) Reset() {
*x = ForeignMessage{}
mi := &file_internal_testprotos_test3_test_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ForeignMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ForeignMessage) ProtoMessage() {}
func (x *ForeignMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test3_test_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ForeignMessage.ProtoReflect.Descriptor instead.
func (*ForeignMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{1}
}
func (x *ForeignMessage) GetC() int32 {
if x != nil {
return x.C
}
return 0
}
func (x *ForeignMessage) GetD() int32 {
if x != nil {
return x.D
}
return 0
}
type TestAllTypes_NestedMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
A int32 `protobuf:"varint,1,opt,name=a,proto3" json:"a,omitempty"`
Corecursive *TestAllTypes `protobuf:"bytes,2,opt,name=corecursive,proto3" json:"corecursive,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TestAllTypes_NestedMessage) Reset() {
*x = TestAllTypes_NestedMessage{}
mi := &file_internal_testprotos_test3_test_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TestAllTypes_NestedMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TestAllTypes_NestedMessage) ProtoMessage() {}
func (x *TestAllTypes_NestedMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test3_test_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TestAllTypes_NestedMessage.ProtoReflect.Descriptor instead.
func (*TestAllTypes_NestedMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_proto_rawDescGZIP(), []int{0, 0}
}
func (x *TestAllTypes_NestedMessage) GetA() int32 {
if x != nil {
return x.A
}
return 0
}
func (x *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
if x != nil {
return x.Corecursive
}
return nil
}
var File_internal_testprotos_test3_test_proto protoreflect.FileDescriptor
const file_internal_testprotos_test3_test_proto_rawDesc = "" +
"\n" +
"$internal/testprotos/test3/test.proto\x12\x13goproto.proto.test3\x1a+internal/testprotos/test3/test_import.proto\"\x90<\n" +
"\fTestAllTypes\x12%\n" +
"\x0esingular_int32\x18Q \x01(\x05R\rsingularInt32\x12%\n" +
"\x0esingular_int64\x18R \x01(\x03R\rsingularInt64\x12'\n" +
"\x0fsingular_uint32\x18S \x01(\rR\x0esingularUint32\x12'\n" +
"\x0fsingular_uint64\x18T \x01(\x04R\x0esingularUint64\x12'\n" +
"\x0fsingular_sint32\x18U \x01(\x11R\x0esingularSint32\x12'\n" +
"\x0fsingular_sint64\x18V \x01(\x12R\x0esingularSint64\x12)\n" +
"\x10singular_fixed32\x18W \x01(\aR\x0fsingularFixed32\x12)\n" +
"\x10singular_fixed64\x18X \x01(\x06R\x0fsingularFixed64\x12+\n" +
"\x11singular_sfixed32\x18Y \x01(\x0fR\x10singularSfixed32\x12+\n" +
"\x11singular_sfixed64\x18Z \x01(\x10R\x10singularSfixed64\x12%\n" +
"\x0esingular_float\x18[ \x01(\x02R\rsingularFloat\x12'\n" +
"\x0fsingular_double\x18\\ \x01(\x01R\x0esingularDouble\x12#\n" +
"\rsingular_bool\x18] \x01(\bR\fsingularBool\x12'\n" +
"\x0fsingular_string\x18^ \x01(\tR\x0esingularString\x12%\n" +
"\x0esingular_bytes\x18_ \x01(\fR\rsingularBytes\x12g\n" +
"\x17singular_nested_message\x18b \x01(\v2/.goproto.proto.test3.TestAllTypes.NestedMessageR\x15singularNestedMessage\x12]\n" +
"\x18singular_foreign_message\x18c \x01(\v2#.goproto.proto.test3.ForeignMessageR\x16singularForeignMessage\x12Z\n" +
"\x17singular_import_message\x18d \x01(\v2\".goproto.proto.test3.ImportMessageR\x15singularImportMessage\x12^\n" +
"\x14singular_nested_enum\x18e \x01(\x0e2,.goproto.proto.test3.TestAllTypes.NestedEnumR\x12singularNestedEnum\x12T\n" +
"\x15singular_foreign_enum\x18f \x01(\x0e2 .goproto.proto.test3.ForeignEnumR\x13singularForeignEnum\x12Q\n" +
"\x14singular_import_enum\x18g \x01(\x0e2\x1f.goproto.proto.test3.ImportEnumR\x12singularImportEnum\x12*\n" +
"\x0eoptional_int32\x18\x01 \x01(\x05H\x01R\roptionalInt32\x88\x01\x01\x12*\n" +
"\x0eoptional_int64\x18\x02 \x01(\x03H\x02R\roptionalInt64\x88\x01\x01\x12,\n" +
"\x0foptional_uint32\x18\x03 \x01(\rH\x03R\x0eoptionalUint32\x88\x01\x01\x12,\n" +
"\x0foptional_uint64\x18\x04 \x01(\x04H\x04R\x0eoptionalUint64\x88\x01\x01\x12,\n" +
"\x0foptional_sint32\x18\x05 \x01(\x11H\x05R\x0eoptionalSint32\x88\x01\x01\x12,\n" +
"\x0foptional_sint64\x18\x06 \x01(\x12H\x06R\x0eoptionalSint64\x88\x01\x01\x12.\n" +
"\x10optional_fixed32\x18\a \x01(\aH\aR\x0foptionalFixed32\x88\x01\x01\x12.\n" +
"\x10optional_fixed64\x18\b \x01(\x06H\bR\x0foptionalFixed64\x88\x01\x01\x120\n" +
"\x11optional_sfixed32\x18\t \x01(\x0fH\tR\x10optionalSfixed32\x88\x01\x01\x120\n" +
"\x11optional_sfixed64\x18\n" +
" \x01(\x10H\n" +
"R\x10optionalSfixed64\x88\x01\x01\x12*\n" +
"\x0eoptional_float\x18\v \x01(\x02H\vR\roptionalFloat\x88\x01\x01\x12,\n" +
"\x0foptional_double\x18\f \x01(\x01H\fR\x0eoptionalDouble\x88\x01\x01\x12(\n" +
"\roptional_bool\x18\r \x01(\bH\rR\foptionalBool\x88\x01\x01\x12,\n" +
"\x0foptional_string\x18\x0e \x01(\tH\x0eR\x0eoptionalString\x88\x01\x01\x12*\n" +
"\x0eoptional_bytes\x18\x0f \x01(\fH\x0fR\roptionalBytes\x88\x01\x01\x12l\n" +
"\x17optional_nested_message\x18\x12 \x01(\v2/.goproto.proto.test3.TestAllTypes.NestedMessageH\x10R\x15optionalNestedMessage\x88\x01\x01\x12b\n" +
"\x18optional_foreign_message\x18\x13 \x01(\v2#.goproto.proto.test3.ForeignMessageH\x11R\x16optionalForeignMessage\x88\x01\x01\x12_\n" +
"\x17optional_import_message\x18\x14 \x01(\v2\".goproto.proto.test3.ImportMessageH\x12R\x15optionalImportMessage\x88\x01\x01\x12c\n" +
"\x14optional_nested_enum\x18\x15 \x01(\x0e2,.goproto.proto.test3.TestAllTypes.NestedEnumH\x13R\x12optionalNestedEnum\x88\x01\x01\x12Y\n" +
"\x15optional_foreign_enum\x18\x16 \x01(\x0e2 .goproto.proto.test3.ForeignEnumH\x14R\x13optionalForeignEnum\x88\x01\x01\x12V\n" +
"\x14optional_import_enum\x18\x17 \x01(\x0e2\x1f.goproto.proto.test3.ImportEnumH\x15R\x12optionalImportEnum\x88\x01\x01\x12%\n" +
"\x0erepeated_int32\x18\x1f \x03(\x05R\rrepeatedInt32\x12%\n" +
"\x0erepeated_int64\x18 \x03(\x03R\rrepeatedInt64\x12'\n" +
"\x0frepeated_uint32\x18! \x03(\rR\x0erepeatedUint32\x12'\n" +
"\x0frepeated_uint64\x18\" \x03(\x04R\x0erepeatedUint64\x12'\n" +
"\x0frepeated_sint32\x18# \x03(\x11R\x0erepeatedSint32\x12'\n" +
"\x0frepeated_sint64\x18$ \x03(\x12R\x0erepeatedSint64\x12)\n" +
"\x10repeated_fixed32\x18% \x03(\aR\x0frepeatedFixed32\x12)\n" +
"\x10repeated_fixed64\x18& \x03(\x06R\x0frepeatedFixed64\x12+\n" +
"\x11repeated_sfixed32\x18' \x03(\x0fR\x10repeatedSfixed32\x12+\n" +
"\x11repeated_sfixed64\x18( \x03(\x10R\x10repeatedSfixed64\x12%\n" +
"\x0erepeated_float\x18) \x03(\x02R\rrepeatedFloat\x12'\n" +
"\x0frepeated_double\x18* \x03(\x01R\x0erepeatedDouble\x12#\n" +
"\rrepeated_bool\x18+ \x03(\bR\frepeatedBool\x12'\n" +
"\x0frepeated_string\x18, \x03(\tR\x0erepeatedString\x12%\n" +
"\x0erepeated_bytes\x18- \x03(\fR\rrepeatedBytes\x12g\n" +
"\x17repeated_nested_message\x180 \x03(\v2/.goproto.proto.test3.TestAllTypes.NestedMessageR\x15repeatedNestedMessage\x12]\n" +
"\x18repeated_foreign_message\x181 \x03(\v2#.goproto.proto.test3.ForeignMessageR\x16repeatedForeignMessage\x12Y\n" +
"\x16repeated_importmessage\x182 \x03(\v2\".goproto.proto.test3.ImportMessageR\x15repeatedImportmessage\x12^\n" +
"\x14repeated_nested_enum\x183 \x03(\x0e2,.goproto.proto.test3.TestAllTypes.NestedEnumR\x12repeatedNestedEnum\x12T\n" +
"\x15repeated_foreign_enum\x184 \x03(\x0e2 .goproto.proto.test3.ForeignEnumR\x13repeatedForeignEnum\x12P\n" +
"\x13repeated_importenum\x185 \x03(\x0e2\x1f.goproto.proto.test3.ImportEnumR\x12repeatedImportenum\x12\\\n" +
"\x0fmap_int32_int32\x188 \x03(\v24.goproto.proto.test3.TestAllTypes.MapInt32Int32EntryR\rmapInt32Int32\x12\\\n" +
"\x0fmap_int64_int64\x189 \x03(\v24.goproto.proto.test3.TestAllTypes.MapInt64Int64EntryR\rmapInt64Int64\x12b\n" +
"\x11map_uint32_uint32\x18: \x03(\v26.goproto.proto.test3.TestAllTypes.MapUint32Uint32EntryR\x0fmapUint32Uint32\x12b\n" +
"\x11map_uint64_uint64\x18; \x03(\v26.goproto.proto.test3.TestAllTypes.MapUint64Uint64EntryR\x0fmapUint64Uint64\x12b\n" +
"\x11map_sint32_sint32\x18< \x03(\v26.goproto.proto.test3.TestAllTypes.MapSint32Sint32EntryR\x0fmapSint32Sint32\x12b\n" +
"\x11map_sint64_sint64\x18= \x03(\v26.goproto.proto.test3.TestAllTypes.MapSint64Sint64EntryR\x0fmapSint64Sint64\x12h\n" +
"\x13map_fixed32_fixed32\x18> \x03(\v28.goproto.proto.test3.TestAllTypes.MapFixed32Fixed32EntryR\x11mapFixed32Fixed32\x12h\n" +
"\x13map_fixed64_fixed64\x18? \x03(\v28.goproto.proto.test3.TestAllTypes.MapFixed64Fixed64EntryR\x11mapFixed64Fixed64\x12n\n" +
"\x15map_sfixed32_sfixed32\x18@ \x03(\v2:.goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32EntryR\x13mapSfixed32Sfixed32\x12n\n" +
"\x15map_sfixed64_sfixed64\x18A \x03(\v2:.goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64EntryR\x13mapSfixed64Sfixed64\x12\\\n" +
"\x0fmap_int32_float\x18B \x03(\v24.goproto.proto.test3.TestAllTypes.MapInt32FloatEntryR\rmapInt32Float\x12_\n" +
"\x10map_int32_double\x18C \x03(\v25.goproto.proto.test3.TestAllTypes.MapInt32DoubleEntryR\x0emapInt32Double\x12V\n" +
"\rmap_bool_bool\x18D \x03(\v22.goproto.proto.test3.TestAllTypes.MapBoolBoolEntryR\vmapBoolBool\x12b\n" +
"\x11map_string_string\x18E \x03(\v26.goproto.proto.test3.TestAllTypes.MapStringStringEntryR\x0fmapStringString\x12_\n" +
"\x10map_string_bytes\x18F \x03(\v25.goproto.proto.test3.TestAllTypes.MapStringBytesEntryR\x0emapStringBytes\x12x\n" +
"\x19map_string_nested_message\x18G \x03(\v2=.goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntryR\x16mapStringNestedMessage\x12o\n" +
"\x16map_string_nested_enum\x18I \x03(\v2:.goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntryR\x13mapStringNestedEnum\x12#\n" +
"\foneof_uint32\x18o \x01(\rH\x00R\voneofUint32\x12c\n" +
"\x14oneof_nested_message\x18p \x01(\v2/.goproto.proto.test3.TestAllTypes.NestedMessageH\x00R\x12oneofNestedMessage\x12#\n" +
"\foneof_string\x18q \x01(\tH\x00R\voneofString\x12!\n" +
"\voneof_bytes\x18r \x01(\fH\x00R\n" +
"oneofBytes\x12\x1f\n" +
"\n" +
"oneof_bool\x18s \x01(\bH\x00R\toneofBool\x12#\n" +
"\foneof_uint64\x18t \x01(\x04H\x00R\voneofUint64\x12!\n" +
"\voneof_float\x18u \x01(\x02H\x00R\n" +
"oneofFloat\x12#\n" +
"\foneof_double\x18v \x01(\x01H\x00R\voneofDouble\x12M\n" +
"\n" +
"oneof_enum\x18w \x01(\x0e2,.goproto.proto.test3.TestAllTypes.NestedEnumH\x00R\toneofEnum\x1ab\n" +
"\rNestedMessage\x12\f\n" +
"\x01a\x18\x01 \x01(\x05R\x01a\x12C\n" +
"\vcorecursive\x18\x02 \x01(\v2!.goproto.proto.test3.TestAllTypesR\vcorecursive\x1a@\n" +
"\x12MapInt32Int32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\x1a@\n" +
"\x12MapInt64Int64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x03R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x03R\x05value:\x028\x01\x1aB\n" +
"\x14MapUint32Uint32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\rR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\x1aB\n" +
"\x14MapUint64Uint64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x04R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\x1aB\n" +
"\x14MapSint32Sint32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x11R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x11R\x05value:\x028\x01\x1aB\n" +
"\x14MapSint64Sint64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x12R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x12R\x05value:\x028\x01\x1aD\n" +
"\x16MapFixed32Fixed32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\aR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\aR\x05value:\x028\x01\x1aD\n" +
"\x16MapFixed64Fixed64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x06R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x06R\x05value:\x028\x01\x1aF\n" +
"\x18MapSfixed32Sfixed32Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x0fR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x0fR\x05value:\x028\x01\x1aF\n" +
"\x18MapSfixed64Sfixed64Entry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x10R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x10R\x05value:\x028\x01\x1a@\n" +
"\x12MapInt32FloatEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x02R\x05value:\x028\x01\x1aA\n" +
"\x13MapInt32DoubleEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\x01R\x05value:\x028\x01\x1a>\n" +
"\x10MapBoolBoolEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\bR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\bR\x05value:\x028\x01\x1aB\n" +
"\x14MapStringStringEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1aA\n" +
"\x13MapStringBytesEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\x1az\n" +
"\x1bMapStringNestedMessageEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12E\n" +
"\x05value\x18\x02 \x01(\v2/.goproto.proto.test3.TestAllTypes.NestedMessageR\x05value:\x028\x01\x1at\n" +
"\x18MapStringNestedEnumEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12B\n" +
"\x05value\x18\x02 \x01(\x0e2,.goproto.proto.test3.TestAllTypes.NestedEnumR\x05value:\x028\x01\"9\n" +
"\n" +
"NestedEnum\x12\a\n" +
"\x03FOO\x10\x00\x12\a\n" +
"\x03BAR\x10\x01\x12\a\n" +
"\x03BAZ\x10\x02\x12\x10\n" +
"\x03NEG\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01B\r\n" +
"\voneof_fieldB\x11\n" +
"\x0f_optional_int32B\x11\n" +
"\x0f_optional_int64B\x12\n" +
"\x10_optional_uint32B\x12\n" +
"\x10_optional_uint64B\x12\n" +
"\x10_optional_sint32B\x12\n" +
"\x10_optional_sint64B\x13\n" +
"\x11_optional_fixed32B\x13\n" +
"\x11_optional_fixed64B\x14\n" +
"\x12_optional_sfixed32B\x14\n" +
"\x12_optional_sfixed64B\x11\n" +
"\x0f_optional_floatB\x12\n" +
"\x10_optional_doubleB\x10\n" +
"\x0e_optional_boolB\x12\n" +
"\x10_optional_stringB\x11\n" +
"\x0f_optional_bytesB\x1a\n" +
"\x18_optional_nested_messageB\x1b\n" +
"\x19_optional_foreign_messageB\x1a\n" +
"\x18_optional_import_messageB\x17\n" +
"\x15_optional_nested_enumB\x18\n" +
"\x16_optional_foreign_enumB\x17\n" +
"\x15_optional_import_enum\",\n" +
"\x0eForeignMessage\x12\f\n" +
"\x01c\x18\x01 \x01(\x05R\x01c\x12\f\n" +
"\x01d\x18\x02 \x01(\x05R\x01d*R\n" +
"\vForeignEnum\x12\x10\n" +
"\fFOREIGN_ZERO\x10\x00\x12\x0f\n" +
"\vFOREIGN_FOO\x10\x04\x12\x0f\n" +
"\vFOREIGN_BAR\x10\x05\x12\x0f\n" +
"\vFOREIGN_BAZ\x10\x06B6Z4google.golang.org/protobuf/internal/testprotos/test3b\x06proto3"
var (
file_internal_testprotos_test3_test_proto_rawDescOnce sync.Once
file_internal_testprotos_test3_test_proto_rawDescData []byte
)
func file_internal_testprotos_test3_test_proto_rawDescGZIP() []byte {
file_internal_testprotos_test3_test_proto_rawDescOnce.Do(func() {
file_internal_testprotos_test3_test_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_test3_test_proto_rawDesc), len(file_internal_testprotos_test3_test_proto_rawDesc)))
})
return file_internal_testprotos_test3_test_proto_rawDescData
}
var file_internal_testprotos_test3_test_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_internal_testprotos_test3_test_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_internal_testprotos_test3_test_proto_goTypes = []any{
(ForeignEnum)(0), // 0: goproto.proto.test3.ForeignEnum
(TestAllTypes_NestedEnum)(0), // 1: goproto.proto.test3.TestAllTypes.NestedEnum
(*TestAllTypes)(nil), // 2: goproto.proto.test3.TestAllTypes
(*ForeignMessage)(nil), // 3: goproto.proto.test3.ForeignMessage
(*TestAllTypes_NestedMessage)(nil), // 4: goproto.proto.test3.TestAllTypes.NestedMessage
nil, // 5: goproto.proto.test3.TestAllTypes.MapInt32Int32Entry
nil, // 6: goproto.proto.test3.TestAllTypes.MapInt64Int64Entry
nil, // 7: goproto.proto.test3.TestAllTypes.MapUint32Uint32Entry
nil, // 8: goproto.proto.test3.TestAllTypes.MapUint64Uint64Entry
nil, // 9: goproto.proto.test3.TestAllTypes.MapSint32Sint32Entry
nil, // 10: goproto.proto.test3.TestAllTypes.MapSint64Sint64Entry
nil, // 11: goproto.proto.test3.TestAllTypes.MapFixed32Fixed32Entry
nil, // 12: goproto.proto.test3.TestAllTypes.MapFixed64Fixed64Entry
nil, // 13: goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32Entry
nil, // 14: goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64Entry
nil, // 15: goproto.proto.test3.TestAllTypes.MapInt32FloatEntry
nil, // 16: goproto.proto.test3.TestAllTypes.MapInt32DoubleEntry
nil, // 17: goproto.proto.test3.TestAllTypes.MapBoolBoolEntry
nil, // 18: goproto.proto.test3.TestAllTypes.MapStringStringEntry
nil, // 19: goproto.proto.test3.TestAllTypes.MapStringBytesEntry
nil, // 20: goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry
nil, // 21: goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry
(*ImportMessage)(nil), // 22: goproto.proto.test3.ImportMessage
(ImportEnum)(0), // 23: goproto.proto.test3.ImportEnum
}
var file_internal_testprotos_test3_test_proto_depIdxs = []int32{
4, // 0: goproto.proto.test3.TestAllTypes.singular_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
3, // 1: goproto.proto.test3.TestAllTypes.singular_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
22, // 2: goproto.proto.test3.TestAllTypes.singular_import_message:type_name -> goproto.proto.test3.ImportMessage
1, // 3: goproto.proto.test3.TestAllTypes.singular_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
0, // 4: goproto.proto.test3.TestAllTypes.singular_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
23, // 5: goproto.proto.test3.TestAllTypes.singular_import_enum:type_name -> goproto.proto.test3.ImportEnum
4, // 6: goproto.proto.test3.TestAllTypes.optional_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
3, // 7: goproto.proto.test3.TestAllTypes.optional_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
22, // 8: goproto.proto.test3.TestAllTypes.optional_import_message:type_name -> goproto.proto.test3.ImportMessage
1, // 9: goproto.proto.test3.TestAllTypes.optional_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
0, // 10: goproto.proto.test3.TestAllTypes.optional_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
23, // 11: goproto.proto.test3.TestAllTypes.optional_import_enum:type_name -> goproto.proto.test3.ImportEnum
4, // 12: goproto.proto.test3.TestAllTypes.repeated_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
3, // 13: goproto.proto.test3.TestAllTypes.repeated_foreign_message:type_name -> goproto.proto.test3.ForeignMessage
22, // 14: goproto.proto.test3.TestAllTypes.repeated_importmessage:type_name -> goproto.proto.test3.ImportMessage
1, // 15: goproto.proto.test3.TestAllTypes.repeated_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
0, // 16: goproto.proto.test3.TestAllTypes.repeated_foreign_enum:type_name -> goproto.proto.test3.ForeignEnum
23, // 17: goproto.proto.test3.TestAllTypes.repeated_importenum:type_name -> goproto.proto.test3.ImportEnum
5, // 18: goproto.proto.test3.TestAllTypes.map_int32_int32:type_name -> goproto.proto.test3.TestAllTypes.MapInt32Int32Entry
6, // 19: goproto.proto.test3.TestAllTypes.map_int64_int64:type_name -> goproto.proto.test3.TestAllTypes.MapInt64Int64Entry
7, // 20: goproto.proto.test3.TestAllTypes.map_uint32_uint32:type_name -> goproto.proto.test3.TestAllTypes.MapUint32Uint32Entry
8, // 21: goproto.proto.test3.TestAllTypes.map_uint64_uint64:type_name -> goproto.proto.test3.TestAllTypes.MapUint64Uint64Entry
9, // 22: goproto.proto.test3.TestAllTypes.map_sint32_sint32:type_name -> goproto.proto.test3.TestAllTypes.MapSint32Sint32Entry
10, // 23: goproto.proto.test3.TestAllTypes.map_sint64_sint64:type_name -> goproto.proto.test3.TestAllTypes.MapSint64Sint64Entry
11, // 24: goproto.proto.test3.TestAllTypes.map_fixed32_fixed32:type_name -> goproto.proto.test3.TestAllTypes.MapFixed32Fixed32Entry
12, // 25: goproto.proto.test3.TestAllTypes.map_fixed64_fixed64:type_name -> goproto.proto.test3.TestAllTypes.MapFixed64Fixed64Entry
13, // 26: goproto.proto.test3.TestAllTypes.map_sfixed32_sfixed32:type_name -> goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32Entry
14, // 27: goproto.proto.test3.TestAllTypes.map_sfixed64_sfixed64:type_name -> goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64Entry
15, // 28: goproto.proto.test3.TestAllTypes.map_int32_float:type_name -> goproto.proto.test3.TestAllTypes.MapInt32FloatEntry
16, // 29: goproto.proto.test3.TestAllTypes.map_int32_double:type_name -> goproto.proto.test3.TestAllTypes.MapInt32DoubleEntry
17, // 30: goproto.proto.test3.TestAllTypes.map_bool_bool:type_name -> goproto.proto.test3.TestAllTypes.MapBoolBoolEntry
18, // 31: goproto.proto.test3.TestAllTypes.map_string_string:type_name -> goproto.proto.test3.TestAllTypes.MapStringStringEntry
19, // 32: goproto.proto.test3.TestAllTypes.map_string_bytes:type_name -> goproto.proto.test3.TestAllTypes.MapStringBytesEntry
20, // 33: goproto.proto.test3.TestAllTypes.map_string_nested_message:type_name -> goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry
21, // 34: goproto.proto.test3.TestAllTypes.map_string_nested_enum:type_name -> goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry
4, // 35: goproto.proto.test3.TestAllTypes.oneof_nested_message:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
1, // 36: goproto.proto.test3.TestAllTypes.oneof_enum:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
2, // 37: goproto.proto.test3.TestAllTypes.NestedMessage.corecursive:type_name -> goproto.proto.test3.TestAllTypes
4, // 38: goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry.value:type_name -> goproto.proto.test3.TestAllTypes.NestedMessage
1, // 39: goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry.value:type_name -> goproto.proto.test3.TestAllTypes.NestedEnum
40, // [40:40] is the sub-list for method output_type
40, // [40:40] is the sub-list for method input_type
40, // [40:40] is the sub-list for extension type_name
40, // [40:40] is the sub-list for extension extendee
0, // [0:40] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test3_test_proto_init() }
func file_internal_testprotos_test3_test_proto_init() {
if File_internal_testprotos_test3_test_proto != nil {
return
}
file_internal_testprotos_test3_test_import_proto_init()
file_internal_testprotos_test3_test_proto_msgTypes[0].OneofWrappers = []any{
(*TestAllTypes_OneofUint32)(nil),
(*TestAllTypes_OneofNestedMessage)(nil),
(*TestAllTypes_OneofString)(nil),
(*TestAllTypes_OneofBytes)(nil),
(*TestAllTypes_OneofBool)(nil),
(*TestAllTypes_OneofUint64)(nil),
(*TestAllTypes_OneofFloat)(nil),
(*TestAllTypes_OneofDouble)(nil),
(*TestAllTypes_OneofEnum)(nil),
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test3_test_proto_rawDesc), len(file_internal_testprotos_test3_test_proto_rawDesc)),
NumEnums: 2,
NumMessages: 20,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_test3_test_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test3_test_proto_depIdxs,
EnumInfos: file_internal_testprotos_test3_test_proto_enumTypes,
MessageInfos: file_internal_testprotos_test3_test_proto_msgTypes,
}.Build()
File_internal_testprotos_test3_test_proto = out.File
file_internal_testprotos_test3_test_proto_goTypes = nil
file_internal_testprotos_test3_test_proto_depIdxs = nil
}
// Copyright 2018 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test3/test_extension.proto
package test3
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
descriptorpb "google.golang.org/protobuf/types/descriptorpb"
reflect "reflect"
unsafe "unsafe"
)
var file_internal_testprotos_test3_test_extension_proto_extTypes = []protoimpl.ExtensionInfo{
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 1001,
Name: "goproto.proto.test3.optional_int32_ext",
Tag: "varint,1001,opt,name=optional_int32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int64)(nil),
Field: 1002,
Name: "goproto.proto.test3.optional_int64_ext",
Tag: "varint,1002,opt,name=optional_int64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint32)(nil),
Field: 1003,
Name: "goproto.proto.test3.optional_uint32_ext",
Tag: "varint,1003,opt,name=optional_uint32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint64)(nil),
Field: 1004,
Name: "goproto.proto.test3.optional_uint64_ext",
Tag: "varint,1004,opt,name=optional_uint64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 1005,
Name: "goproto.proto.test3.optional_sint32_ext",
Tag: "zigzag32,1005,opt,name=optional_sint32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int64)(nil),
Field: 1006,
Name: "goproto.proto.test3.optional_sint64_ext",
Tag: "zigzag64,1006,opt,name=optional_sint64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint32)(nil),
Field: 1007,
Name: "goproto.proto.test3.optional_fixed32_ext",
Tag: "fixed32,1007,opt,name=optional_fixed32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint64)(nil),
Field: 1008,
Name: "goproto.proto.test3.optional_fixed64_ext",
Tag: "fixed64,1008,opt,name=optional_fixed64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 1009,
Name: "goproto.proto.test3.optional_sfixed32_ext",
Tag: "fixed32,1009,opt,name=optional_sfixed32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int64)(nil),
Field: 1010,
Name: "goproto.proto.test3.optional_sfixed64_ext",
Tag: "fixed64,1010,opt,name=optional_sfixed64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*float32)(nil),
Field: 1011,
Name: "goproto.proto.test3.optional_float_ext",
Tag: "fixed32,1011,opt,name=optional_float_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*float64)(nil),
Field: 1012,
Name: "goproto.proto.test3.optional_double_ext",
Tag: "fixed64,1012,opt,name=optional_double_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*bool)(nil),
Field: 1013,
Name: "goproto.proto.test3.optional_bool_ext",
Tag: "varint,1013,opt,name=optional_bool_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*string)(nil),
Field: 1014,
Name: "goproto.proto.test3.optional_string_ext",
Tag: "bytes,1014,opt,name=optional_string_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]byte)(nil),
Field: 1015,
Name: "goproto.proto.test3.optional_bytes_ext",
Tag: "bytes,1015,opt,name=optional_bytes_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*ForeignMessage)(nil),
Field: 1016,
Name: "goproto.proto.test3.optional_foreign_message_ext",
Tag: "bytes,1016,opt,name=optional_foreign_message_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*ForeignEnum)(nil),
Field: 1017,
Name: "goproto.proto.test3.optional_foreign_enum_ext",
Tag: "varint,1017,opt,name=optional_foreign_enum_ext,enum=goproto.proto.test3.ForeignEnum",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 2001,
Name: "goproto.proto.test3.optional_optional_int32_ext",
Tag: "varint,2001,opt,name=optional_optional_int32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int64)(nil),
Field: 2002,
Name: "goproto.proto.test3.optional_optional_int64_ext",
Tag: "varint,2002,opt,name=optional_optional_int64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint32)(nil),
Field: 2003,
Name: "goproto.proto.test3.optional_optional_uint32_ext",
Tag: "varint,2003,opt,name=optional_optional_uint32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint64)(nil),
Field: 2004,
Name: "goproto.proto.test3.optional_optional_uint64_ext",
Tag: "varint,2004,opt,name=optional_optional_uint64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 2005,
Name: "goproto.proto.test3.optional_optional_sint32_ext",
Tag: "zigzag32,2005,opt,name=optional_optional_sint32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int64)(nil),
Field: 2006,
Name: "goproto.proto.test3.optional_optional_sint64_ext",
Tag: "zigzag64,2006,opt,name=optional_optional_sint64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint32)(nil),
Field: 2007,
Name: "goproto.proto.test3.optional_optional_fixed32_ext",
Tag: "fixed32,2007,opt,name=optional_optional_fixed32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*uint64)(nil),
Field: 2008,
Name: "goproto.proto.test3.optional_optional_fixed64_ext",
Tag: "fixed64,2008,opt,name=optional_optional_fixed64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 2009,
Name: "goproto.proto.test3.optional_optional_sfixed32_ext",
Tag: "fixed32,2009,opt,name=optional_optional_sfixed32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*int64)(nil),
Field: 2010,
Name: "goproto.proto.test3.optional_optional_sfixed64_ext",
Tag: "fixed64,2010,opt,name=optional_optional_sfixed64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*float32)(nil),
Field: 2011,
Name: "goproto.proto.test3.optional_optional_float_ext",
Tag: "fixed32,2011,opt,name=optional_optional_float_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*float64)(nil),
Field: 2012,
Name: "goproto.proto.test3.optional_optional_double_ext",
Tag: "fixed64,2012,opt,name=optional_optional_double_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*bool)(nil),
Field: 2013,
Name: "goproto.proto.test3.optional_optional_bool_ext",
Tag: "varint,2013,opt,name=optional_optional_bool_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*string)(nil),
Field: 2014,
Name: "goproto.proto.test3.optional_optional_string_ext",
Tag: "bytes,2014,opt,name=optional_optional_string_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]byte)(nil),
Field: 2015,
Name: "goproto.proto.test3.optional_optional_bytes_ext",
Tag: "bytes,2015,opt,name=optional_optional_bytes_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*ForeignMessage)(nil),
Field: 2016,
Name: "goproto.proto.test3.optional_optional_foreign_message_ext",
Tag: "bytes,2016,opt,name=optional_optional_foreign_message_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*ForeignEnum)(nil),
Field: 2017,
Name: "goproto.proto.test3.optional_optional_foreign_enum_ext",
Tag: "varint,2017,opt,name=optional_optional_foreign_enum_ext,enum=goproto.proto.test3.ForeignEnum",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]int32)(nil),
Field: 3001,
Name: "goproto.proto.test3.repeated_int32_ext",
Tag: "varint,3001,rep,packed,name=repeated_int32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]int64)(nil),
Field: 3002,
Name: "goproto.proto.test3.repeated_int64_ext",
Tag: "varint,3002,rep,packed,name=repeated_int64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 3003,
Name: "goproto.proto.test3.repeated_uint32_ext",
Tag: "varint,3003,rep,packed,name=repeated_uint32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 3004,
Name: "goproto.proto.test3.repeated_uint64_ext",
Tag: "varint,3004,rep,packed,name=repeated_uint64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]int32)(nil),
Field: 3005,
Name: "goproto.proto.test3.repeated_sint32_ext",
Tag: "zigzag32,3005,rep,packed,name=repeated_sint32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]int64)(nil),
Field: 3006,
Name: "goproto.proto.test3.repeated_sint64_ext",
Tag: "zigzag64,3006,rep,packed,name=repeated_sint64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]uint32)(nil),
Field: 3007,
Name: "goproto.proto.test3.repeated_fixed32_ext",
Tag: "fixed32,3007,rep,packed,name=repeated_fixed32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]uint64)(nil),
Field: 3008,
Name: "goproto.proto.test3.repeated_fixed64_ext",
Tag: "fixed64,3008,rep,packed,name=repeated_fixed64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]int32)(nil),
Field: 3009,
Name: "goproto.proto.test3.repeated_sfixed32_ext",
Tag: "fixed32,3009,rep,packed,name=repeated_sfixed32_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]int64)(nil),
Field: 3010,
Name: "goproto.proto.test3.repeated_sfixed64_ext",
Tag: "fixed64,3010,rep,packed,name=repeated_sfixed64_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]float32)(nil),
Field: 3011,
Name: "goproto.proto.test3.repeated_float_ext",
Tag: "fixed32,3011,rep,packed,name=repeated_float_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]float64)(nil),
Field: 3012,
Name: "goproto.proto.test3.repeated_double_ext",
Tag: "fixed64,3012,rep,packed,name=repeated_double_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]bool)(nil),
Field: 3013,
Name: "goproto.proto.test3.repeated_bool_ext",
Tag: "varint,3013,rep,packed,name=repeated_bool_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]string)(nil),
Field: 3014,
Name: "goproto.proto.test3.repeated_string_ext",
Tag: "bytes,3014,rep,name=repeated_string_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([][]byte)(nil),
Field: 3015,
Name: "goproto.proto.test3.repeated_bytes_ext",
Tag: "bytes,3015,rep,name=repeated_bytes_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]*ForeignMessage)(nil),
Field: 3016,
Name: "goproto.proto.test3.repeated_foreign_message_ext",
Tag: "bytes,3016,rep,name=repeated_foreign_message_ext",
Filename: "internal/testprotos/test3/test_extension.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: ([]ForeignEnum)(nil),
Field: 3017,
Name: "goproto.proto.test3.repeated_foreign_enum_ext",
Tag: "varint,3017,rep,packed,name=repeated_foreign_enum_ext,enum=goproto.proto.test3.ForeignEnum",
Filename: "internal/testprotos/test3/test_extension.proto",
},
}
// Extension fields to descriptorpb.MessageOptions.
var (
// optional int32 optional_int32_ext = 1001;
E_OptionalInt32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[0]
// optional int64 optional_int64_ext = 1002;
E_OptionalInt64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[1]
// optional uint32 optional_uint32_ext = 1003;
E_OptionalUint32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[2]
// optional uint64 optional_uint64_ext = 1004;
E_OptionalUint64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[3]
// optional sint32 optional_sint32_ext = 1005;
E_OptionalSint32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[4]
// optional sint64 optional_sint64_ext = 1006;
E_OptionalSint64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[5]
// optional fixed32 optional_fixed32_ext = 1007;
E_OptionalFixed32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[6]
// optional fixed64 optional_fixed64_ext = 1008;
E_OptionalFixed64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[7]
// optional sfixed32 optional_sfixed32_ext = 1009;
E_OptionalSfixed32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[8]
// optional sfixed64 optional_sfixed64_ext = 1010;
E_OptionalSfixed64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[9]
// optional float optional_float_ext = 1011;
E_OptionalFloatExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[10]
// optional double optional_double_ext = 1012;
E_OptionalDoubleExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[11]
// optional bool optional_bool_ext = 1013;
E_OptionalBoolExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[12]
// optional string optional_string_ext = 1014;
E_OptionalStringExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[13]
// optional bytes optional_bytes_ext = 1015;
E_OptionalBytesExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[14]
// optional goproto.proto.test3.ForeignMessage optional_foreign_message_ext = 1016;
E_OptionalForeignMessageExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[15]
// optional goproto.proto.test3.ForeignEnum optional_foreign_enum_ext = 1017;
E_OptionalForeignEnumExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[16]
// optional int32 optional_optional_int32_ext = 2001;
E_OptionalOptionalInt32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[17]
// optional int64 optional_optional_int64_ext = 2002;
E_OptionalOptionalInt64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[18]
// optional uint32 optional_optional_uint32_ext = 2003;
E_OptionalOptionalUint32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[19]
// optional uint64 optional_optional_uint64_ext = 2004;
E_OptionalOptionalUint64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[20]
// optional sint32 optional_optional_sint32_ext = 2005;
E_OptionalOptionalSint32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[21]
// optional sint64 optional_optional_sint64_ext = 2006;
E_OptionalOptionalSint64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[22]
// optional fixed32 optional_optional_fixed32_ext = 2007;
E_OptionalOptionalFixed32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[23]
// optional fixed64 optional_optional_fixed64_ext = 2008;
E_OptionalOptionalFixed64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[24]
// optional sfixed32 optional_optional_sfixed32_ext = 2009;
E_OptionalOptionalSfixed32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[25]
// optional sfixed64 optional_optional_sfixed64_ext = 2010;
E_OptionalOptionalSfixed64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[26]
// optional float optional_optional_float_ext = 2011;
E_OptionalOptionalFloatExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[27]
// optional double optional_optional_double_ext = 2012;
E_OptionalOptionalDoubleExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[28]
// optional bool optional_optional_bool_ext = 2013;
E_OptionalOptionalBoolExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[29]
// optional string optional_optional_string_ext = 2014;
E_OptionalOptionalStringExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[30]
// optional bytes optional_optional_bytes_ext = 2015;
E_OptionalOptionalBytesExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[31]
// optional goproto.proto.test3.ForeignMessage optional_optional_foreign_message_ext = 2016;
E_OptionalOptionalForeignMessageExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[32]
// optional goproto.proto.test3.ForeignEnum optional_optional_foreign_enum_ext = 2017;
E_OptionalOptionalForeignEnumExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[33]
// repeated int32 repeated_int32_ext = 3001;
E_RepeatedInt32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[34]
// repeated int64 repeated_int64_ext = 3002;
E_RepeatedInt64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[35]
// repeated uint32 repeated_uint32_ext = 3003;
E_RepeatedUint32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[36]
// repeated uint64 repeated_uint64_ext = 3004;
E_RepeatedUint64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[37]
// repeated sint32 repeated_sint32_ext = 3005;
E_RepeatedSint32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[38]
// repeated sint64 repeated_sint64_ext = 3006;
E_RepeatedSint64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[39]
// repeated fixed32 repeated_fixed32_ext = 3007;
E_RepeatedFixed32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[40]
// repeated fixed64 repeated_fixed64_ext = 3008;
E_RepeatedFixed64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[41]
// repeated sfixed32 repeated_sfixed32_ext = 3009;
E_RepeatedSfixed32Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[42]
// repeated sfixed64 repeated_sfixed64_ext = 3010;
E_RepeatedSfixed64Ext = &file_internal_testprotos_test3_test_extension_proto_extTypes[43]
// repeated float repeated_float_ext = 3011;
E_RepeatedFloatExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[44]
// repeated double repeated_double_ext = 3012;
E_RepeatedDoubleExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[45]
// repeated bool repeated_bool_ext = 3013;
E_RepeatedBoolExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[46]
// repeated string repeated_string_ext = 3014;
E_RepeatedStringExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[47]
// repeated bytes repeated_bytes_ext = 3015;
E_RepeatedBytesExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[48]
// repeated goproto.proto.test3.ForeignMessage repeated_foreign_message_ext = 3016;
E_RepeatedForeignMessageExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[49]
// repeated goproto.proto.test3.ForeignEnum repeated_foreign_enum_ext = 3017;
E_RepeatedForeignEnumExt = &file_internal_testprotos_test3_test_extension_proto_extTypes[50]
)
var File_internal_testprotos_test3_test_extension_proto protoreflect.FileDescriptor
const file_internal_testprotos_test3_test_extension_proto_rawDesc = "" +
"\n" +
".internal/testprotos/test3/test_extension.proto\x12\x13goproto.proto.test3\x1a google/protobuf/descriptor.proto\x1a$internal/testprotos/test3/test.proto:N\n" +
"\x12optional_int32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xe9\a \x01(\x05R\x10optionalInt32Ext:N\n" +
"\x12optional_int64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xea\a \x01(\x03R\x10optionalInt64Ext:P\n" +
"\x13optional_uint32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xeb\a \x01(\rR\x11optionalUint32Ext:P\n" +
"\x13optional_uint64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xec\a \x01(\x04R\x11optionalUint64Ext:P\n" +
"\x13optional_sint32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xed\a \x01(\x11R\x11optionalSint32Ext:P\n" +
"\x13optional_sint64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xee\a \x01(\x12R\x11optionalSint64Ext:R\n" +
"\x14optional_fixed32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xef\a \x01(\aR\x12optionalFixed32Ext:R\n" +
"\x14optional_fixed64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf0\a \x01(\x06R\x12optionalFixed64Ext:T\n" +
"\x15optional_sfixed32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf1\a \x01(\x0fR\x13optionalSfixed32Ext:T\n" +
"\x15optional_sfixed64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf2\a \x01(\x10R\x13optionalSfixed64Ext:N\n" +
"\x12optional_float_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf3\a \x01(\x02R\x10optionalFloatExt:P\n" +
"\x13optional_double_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf4\a \x01(\x01R\x11optionalDoubleExt:L\n" +
"\x11optional_bool_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf5\a \x01(\bR\x0foptionalBoolExt:P\n" +
"\x13optional_string_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf6\a \x01(\tR\x11optionalStringExt:N\n" +
"\x12optional_bytes_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf7\a \x01(\fR\x10optionalBytesExt:\x86\x01\n" +
"\x1coptional_foreign_message_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf8\a \x01(\v2#.goproto.proto.test3.ForeignMessageR\x19optionalForeignMessageExt:}\n" +
"\x19optional_foreign_enum_ext\x12\x1f.google.protobuf.MessageOptions\x18\xf9\a \x01(\x0e2 .goproto.proto.test3.ForeignEnumR\x16optionalForeignEnumExt:b\n" +
"\x1boptional_optional_int32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd1\x0f \x01(\x05R\x18optionalOptionalInt32Ext\x88\x01\x01:b\n" +
"\x1boptional_optional_int64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd2\x0f \x01(\x03R\x18optionalOptionalInt64Ext\x88\x01\x01:d\n" +
"\x1coptional_optional_uint32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd3\x0f \x01(\rR\x19optionalOptionalUint32Ext\x88\x01\x01:d\n" +
"\x1coptional_optional_uint64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd4\x0f \x01(\x04R\x19optionalOptionalUint64Ext\x88\x01\x01:d\n" +
"\x1coptional_optional_sint32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd5\x0f \x01(\x11R\x19optionalOptionalSint32Ext\x88\x01\x01:d\n" +
"\x1coptional_optional_sint64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd6\x0f \x01(\x12R\x19optionalOptionalSint64Ext\x88\x01\x01:f\n" +
"\x1doptional_optional_fixed32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd7\x0f \x01(\aR\x1aoptionalOptionalFixed32Ext\x88\x01\x01:f\n" +
"\x1doptional_optional_fixed64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd8\x0f \x01(\x06R\x1aoptionalOptionalFixed64Ext\x88\x01\x01:h\n" +
"\x1eoptional_optional_sfixed32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xd9\x0f \x01(\x0fR\x1boptionalOptionalSfixed32Ext\x88\x01\x01:h\n" +
"\x1eoptional_optional_sfixed64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xda\x0f \x01(\x10R\x1boptionalOptionalSfixed64Ext\x88\x01\x01:b\n" +
"\x1boptional_optional_float_ext\x12\x1f.google.protobuf.MessageOptions\x18\xdb\x0f \x01(\x02R\x18optionalOptionalFloatExt\x88\x01\x01:d\n" +
"\x1coptional_optional_double_ext\x12\x1f.google.protobuf.MessageOptions\x18\xdc\x0f \x01(\x01R\x19optionalOptionalDoubleExt\x88\x01\x01:`\n" +
"\x1aoptional_optional_bool_ext\x12\x1f.google.protobuf.MessageOptions\x18\xdd\x0f \x01(\bR\x17optionalOptionalBoolExt\x88\x01\x01:d\n" +
"\x1coptional_optional_string_ext\x12\x1f.google.protobuf.MessageOptions\x18\xde\x0f \x01(\tR\x19optionalOptionalStringExt\x88\x01\x01:b\n" +
"\x1boptional_optional_bytes_ext\x12\x1f.google.protobuf.MessageOptions\x18\xdf\x0f \x01(\fR\x18optionalOptionalBytesExt\x88\x01\x01:\x9a\x01\n" +
"%optional_optional_foreign_message_ext\x12\x1f.google.protobuf.MessageOptions\x18\xe0\x0f \x01(\v2#.goproto.proto.test3.ForeignMessageR!optionalOptionalForeignMessageExt\x88\x01\x01:\x91\x01\n" +
"\"optional_optional_foreign_enum_ext\x12\x1f.google.protobuf.MessageOptions\x18\xe1\x0f \x01(\x0e2 .goproto.proto.test3.ForeignEnumR\x1eoptionalOptionalForeignEnumExt\x88\x01\x01:N\n" +
"\x12repeated_int32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xb9\x17 \x03(\x05R\x10repeatedInt32Ext:N\n" +
"\x12repeated_int64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xba\x17 \x03(\x03R\x10repeatedInt64Ext:P\n" +
"\x13repeated_uint32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xbb\x17 \x03(\rR\x11repeatedUint32Ext:P\n" +
"\x13repeated_uint64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xbc\x17 \x03(\x04R\x11repeatedUint64Ext:P\n" +
"\x13repeated_sint32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xbd\x17 \x03(\x11R\x11repeatedSint32Ext:P\n" +
"\x13repeated_sint64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xbe\x17 \x03(\x12R\x11repeatedSint64Ext:R\n" +
"\x14repeated_fixed32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xbf\x17 \x03(\aR\x12repeatedFixed32Ext:R\n" +
"\x14repeated_fixed64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc0\x17 \x03(\x06R\x12repeatedFixed64Ext:T\n" +
"\x15repeated_sfixed32_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc1\x17 \x03(\x0fR\x13repeatedSfixed32Ext:T\n" +
"\x15repeated_sfixed64_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc2\x17 \x03(\x10R\x13repeatedSfixed64Ext:N\n" +
"\x12repeated_float_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc3\x17 \x03(\x02R\x10repeatedFloatExt:P\n" +
"\x13repeated_double_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc4\x17 \x03(\x01R\x11repeatedDoubleExt:L\n" +
"\x11repeated_bool_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc5\x17 \x03(\bR\x0frepeatedBoolExt:P\n" +
"\x13repeated_string_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc6\x17 \x03(\tR\x11repeatedStringExt:N\n" +
"\x12repeated_bytes_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc7\x17 \x03(\fR\x10repeatedBytesExt:\x86\x01\n" +
"\x1crepeated_foreign_message_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc8\x17 \x03(\v2#.goproto.proto.test3.ForeignMessageR\x19repeatedForeignMessageExt:}\n" +
"\x19repeated_foreign_enum_ext\x12\x1f.google.protobuf.MessageOptions\x18\xc9\x17 \x03(\x0e2 .goproto.proto.test3.ForeignEnumR\x16repeatedForeignEnumExtB6Z4google.golang.org/protobuf/internal/testprotos/test3b\x06proto3"
var file_internal_testprotos_test3_test_extension_proto_goTypes = []any{
(*descriptorpb.MessageOptions)(nil), // 0: google.protobuf.MessageOptions
(*ForeignMessage)(nil), // 1: goproto.proto.test3.ForeignMessage
(ForeignEnum)(0), // 2: goproto.proto.test3.ForeignEnum
}
var file_internal_testprotos_test3_test_extension_proto_depIdxs = []int32{
0, // 0: goproto.proto.test3.optional_int32_ext:extendee -> google.protobuf.MessageOptions
0, // 1: goproto.proto.test3.optional_int64_ext:extendee -> google.protobuf.MessageOptions
0, // 2: goproto.proto.test3.optional_uint32_ext:extendee -> google.protobuf.MessageOptions
0, // 3: goproto.proto.test3.optional_uint64_ext:extendee -> google.protobuf.MessageOptions
0, // 4: goproto.proto.test3.optional_sint32_ext:extendee -> google.protobuf.MessageOptions
0, // 5: goproto.proto.test3.optional_sint64_ext:extendee -> google.protobuf.MessageOptions
0, // 6: goproto.proto.test3.optional_fixed32_ext:extendee -> google.protobuf.MessageOptions
0, // 7: goproto.proto.test3.optional_fixed64_ext:extendee -> google.protobuf.MessageOptions
0, // 8: goproto.proto.test3.optional_sfixed32_ext:extendee -> google.protobuf.MessageOptions
0, // 9: goproto.proto.test3.optional_sfixed64_ext:extendee -> google.protobuf.MessageOptions
0, // 10: goproto.proto.test3.optional_float_ext:extendee -> google.protobuf.MessageOptions
0, // 11: goproto.proto.test3.optional_double_ext:extendee -> google.protobuf.MessageOptions
0, // 12: goproto.proto.test3.optional_bool_ext:extendee -> google.protobuf.MessageOptions
0, // 13: goproto.proto.test3.optional_string_ext:extendee -> google.protobuf.MessageOptions
0, // 14: goproto.proto.test3.optional_bytes_ext:extendee -> google.protobuf.MessageOptions
0, // 15: goproto.proto.test3.optional_foreign_message_ext:extendee -> google.protobuf.MessageOptions
0, // 16: goproto.proto.test3.optional_foreign_enum_ext:extendee -> google.protobuf.MessageOptions
0, // 17: goproto.proto.test3.optional_optional_int32_ext:extendee -> google.protobuf.MessageOptions
0, // 18: goproto.proto.test3.optional_optional_int64_ext:extendee -> google.protobuf.MessageOptions
0, // 19: goproto.proto.test3.optional_optional_uint32_ext:extendee -> google.protobuf.MessageOptions
0, // 20: goproto.proto.test3.optional_optional_uint64_ext:extendee -> google.protobuf.MessageOptions
0, // 21: goproto.proto.test3.optional_optional_sint32_ext:extendee -> google.protobuf.MessageOptions
0, // 22: goproto.proto.test3.optional_optional_sint64_ext:extendee -> google.protobuf.MessageOptions
0, // 23: goproto.proto.test3.optional_optional_fixed32_ext:extendee -> google.protobuf.MessageOptions
0, // 24: goproto.proto.test3.optional_optional_fixed64_ext:extendee -> google.protobuf.MessageOptions
0, // 25: goproto.proto.test3.optional_optional_sfixed32_ext:extendee -> google.protobuf.MessageOptions
0, // 26: goproto.proto.test3.optional_optional_sfixed64_ext:extendee -> google.protobuf.MessageOptions
0, // 27: goproto.proto.test3.optional_optional_float_ext:extendee -> google.protobuf.MessageOptions
0, // 28: goproto.proto.test3.optional_optional_double_ext:extendee -> google.protobuf.MessageOptions
0, // 29: goproto.proto.test3.optional_optional_bool_ext:extendee -> google.protobuf.MessageOptions
0, // 30: goproto.proto.test3.optional_optional_string_ext:extendee -> google.protobuf.MessageOptions
0, // 31: goproto.proto.test3.optional_optional_bytes_ext:extendee -> google.protobuf.MessageOptions
0, // 32: goproto.proto.test3.optional_optional_foreign_message_ext:extendee -> google.protobuf.MessageOptions
0, // 33: goproto.proto.test3.optional_optional_foreign_enum_ext:extendee -> google.protobuf.MessageOptions
0, // 34: goproto.proto.test3.repeated_int32_ext:extendee -> google.protobuf.MessageOptions
0, // 35: goproto.proto.test3.repeated_int64_ext:extendee -> google.protobuf.MessageOptions
0, // 36: goproto.proto.test3.repeated_uint32_ext:extendee -> google.protobuf.MessageOptions
0, // 37: goproto.proto.test3.repeated_uint64_ext:extendee -> google.protobuf.MessageOptions
0, // 38: goproto.proto.test3.repeated_sint32_ext:extendee -> google.protobuf.MessageOptions
0, // 39: goproto.proto.test3.repeated_sint64_ext:extendee -> google.protobuf.MessageOptions
0, // 40: goproto.proto.test3.repeated_fixed32_ext:extendee -> google.protobuf.MessageOptions
0, // 41: goproto.proto.test3.repeated_fixed64_ext:extendee -> google.protobuf.MessageOptions
0, // 42: goproto.proto.test3.repeated_sfixed32_ext:extendee -> google.protobuf.MessageOptions
0, // 43: goproto.proto.test3.repeated_sfixed64_ext:extendee -> google.protobuf.MessageOptions
0, // 44: goproto.proto.test3.repeated_float_ext:extendee -> google.protobuf.MessageOptions
0, // 45: goproto.proto.test3.repeated_double_ext:extendee -> google.protobuf.MessageOptions
0, // 46: goproto.proto.test3.repeated_bool_ext:extendee -> google.protobuf.MessageOptions
0, // 47: goproto.proto.test3.repeated_string_ext:extendee -> google.protobuf.MessageOptions
0, // 48: goproto.proto.test3.repeated_bytes_ext:extendee -> google.protobuf.MessageOptions
0, // 49: goproto.proto.test3.repeated_foreign_message_ext:extendee -> google.protobuf.MessageOptions
0, // 50: goproto.proto.test3.repeated_foreign_enum_ext:extendee -> google.protobuf.MessageOptions
1, // 51: goproto.proto.test3.optional_foreign_message_ext:type_name -> goproto.proto.test3.ForeignMessage
2, // 52: goproto.proto.test3.optional_foreign_enum_ext:type_name -> goproto.proto.test3.ForeignEnum
1, // 53: goproto.proto.test3.optional_optional_foreign_message_ext:type_name -> goproto.proto.test3.ForeignMessage
2, // 54: goproto.proto.test3.optional_optional_foreign_enum_ext:type_name -> goproto.proto.test3.ForeignEnum
1, // 55: goproto.proto.test3.repeated_foreign_message_ext:type_name -> goproto.proto.test3.ForeignMessage
2, // 56: goproto.proto.test3.repeated_foreign_enum_ext:type_name -> goproto.proto.test3.ForeignEnum
57, // [57:57] is the sub-list for method output_type
57, // [57:57] is the sub-list for method input_type
51, // [51:57] is the sub-list for extension type_name
0, // [0:51] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test3_test_extension_proto_init() }
func file_internal_testprotos_test3_test_extension_proto_init() {
if File_internal_testprotos_test3_test_extension_proto != nil {
return
}
file_internal_testprotos_test3_test_proto_init()
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test3_test_extension_proto_rawDesc), len(file_internal_testprotos_test3_test_extension_proto_rawDesc)),
NumEnums: 0,
NumMessages: 0,
NumExtensions: 51,
NumServices: 0,
},
GoTypes: file_internal_testprotos_test3_test_extension_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test3_test_extension_proto_depIdxs,
ExtensionInfos: file_internal_testprotos_test3_test_extension_proto_extTypes,
}.Build()
File_internal_testprotos_test3_test_extension_proto = out.File
file_internal_testprotos_test3_test_extension_proto_goTypes = nil
file_internal_testprotos_test3_test_extension_proto_depIdxs = nil
}
// Copyright 2018 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/test3/test_import.proto
package test3
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
type ImportEnum int32
const (
ImportEnum_IMPORT_ZERO ImportEnum = 0
)
// Enum value maps for ImportEnum.
var (
ImportEnum_name = map[int32]string{
0: "IMPORT_ZERO",
}
ImportEnum_value = map[string]int32{
"IMPORT_ZERO": 0,
}
)
func (x ImportEnum) Enum() *ImportEnum {
p := new(ImportEnum)
*p = x
return p
}
func (x ImportEnum) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ImportEnum) Descriptor() protoreflect.EnumDescriptor {
return file_internal_testprotos_test3_test_import_proto_enumTypes[0].Descriptor()
}
func (ImportEnum) Type() protoreflect.EnumType {
return &file_internal_testprotos_test3_test_import_proto_enumTypes[0]
}
func (x ImportEnum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use ImportEnum.Descriptor instead.
func (ImportEnum) EnumDescriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_import_proto_rawDescGZIP(), []int{0}
}
type ImportMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ImportMessage) Reset() {
*x = ImportMessage{}
mi := &file_internal_testprotos_test3_test_import_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ImportMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ImportMessage) ProtoMessage() {}
func (x *ImportMessage) ProtoReflect() protoreflect.Message {
mi := &file_internal_testprotos_test3_test_import_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ImportMessage.ProtoReflect.Descriptor instead.
func (*ImportMessage) Descriptor() ([]byte, []int) {
return file_internal_testprotos_test3_test_import_proto_rawDescGZIP(), []int{0}
}
var File_internal_testprotos_test3_test_import_proto protoreflect.FileDescriptor
const file_internal_testprotos_test3_test_import_proto_rawDesc = "" +
"\n" +
"+internal/testprotos/test3/test_import.proto\x12\x13goproto.proto.test3\"\x0f\n" +
"\rImportMessage*\x1d\n" +
"\n" +
"ImportEnum\x12\x0f\n" +
"\vIMPORT_ZERO\x10\x00B6Z4google.golang.org/protobuf/internal/testprotos/test3b\x06proto3"
var (
file_internal_testprotos_test3_test_import_proto_rawDescOnce sync.Once
file_internal_testprotos_test3_test_import_proto_rawDescData []byte
)
func file_internal_testprotos_test3_test_import_proto_rawDescGZIP() []byte {
file_internal_testprotos_test3_test_import_proto_rawDescOnce.Do(func() {
file_internal_testprotos_test3_test_import_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_internal_testprotos_test3_test_import_proto_rawDesc), len(file_internal_testprotos_test3_test_import_proto_rawDesc)))
})
return file_internal_testprotos_test3_test_import_proto_rawDescData
}
var file_internal_testprotos_test3_test_import_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_internal_testprotos_test3_test_import_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_internal_testprotos_test3_test_import_proto_goTypes = []any{
(ImportEnum)(0), // 0: goproto.proto.test3.ImportEnum
(*ImportMessage)(nil), // 1: goproto.proto.test3.ImportMessage
}
var file_internal_testprotos_test3_test_import_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_internal_testprotos_test3_test_import_proto_init() }
func file_internal_testprotos_test3_test_import_proto_init() {
if File_internal_testprotos_test3_test_import_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test3_test_import_proto_rawDesc), len(file_internal_testprotos_test3_test_import_proto_rawDesc)),
NumEnums: 1,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_internal_testprotos_test3_test_import_proto_goTypes,
DependencyIndexes: file_internal_testprotos_test3_test_import_proto_depIdxs,
EnumInfos: file_internal_testprotos_test3_test_import_proto_enumTypes,
MessageInfos: file_internal_testprotos_test3_test_import_proto_msgTypes,
}.Build()
File_internal_testprotos_test3_test_import_proto = out.File
file_internal_testprotos_test3_test_import_proto_goTypes = nil
file_internal_testprotos_test3_test_import_proto_depIdxs = nil
}
// 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 version records versioning information about this module.
package version
import (
"fmt"
"strings"
)
// These constants determine the current version of this module.
//
// For our release process, we enforce the following rules:
// - Tagged releases use a tag that is identical to String.
// - Tagged releases never reference a commit where the String
// contains "devel".
// - The set of all commits in this repository where String
// does not contain "devel" must have a unique String.
//
// Steps for tagging a new release:
//
// 1. Create a new CL.
//
// 2. Update Minor, Patch, and/or PreRelease as necessary.
// PreRelease must not contain the string "devel".
//
// 3. Since the last released minor version, have there been any changes to
// generator that relies on new functionality in the runtime?
// If yes, then increment RequiredGenerated.
//
// 4. Since the last released minor version, have there been any changes to
// the runtime that removes support for old .pb.go source code?
// If yes, then increment SupportMinimum.
//
// 5. Send out the CL for review and submit it.
// Note that the next CL in step 8 must be submitted after this CL
// without any other CLs in-between.
//
// 6. Tag a new version, where the tag is is the current String.
//
// 7. Write release notes for all notable changes
// between this release and the last release.
//
// 8. Create a new CL.
//
// 9. Update PreRelease to include the string "devel".
// For example: "" -> "devel" or "rc.1" -> "rc.1.devel"
//
// 10. Send out the CL for review and submit it.
const (
Major = 1
Minor = 36
Patch = 6
PreRelease = "devel"
)
// String formats the version string for this module in semver format.
//
// Examples:
//
// v1.20.1
// v1.21.0-rc.1
func String() string {
v := fmt.Sprintf("v%d.%d.%d", Major, Minor, Patch)
if PreRelease != "" {
v += "-" + PreRelease
// TODO: Add metadata about the commit or build hash.
// See https://golang.org/issue/29814
// See https://golang.org/issue/33533
var metadata string
if strings.Contains(PreRelease, "devel") && metadata != "" {
v += "+" + metadata
}
}
return v
}
// 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 (
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// CheckInitialized returns an error if any required fields in m are not set.
func CheckInitialized(m Message) error {
// Treat a nil message interface as an "untyped" empty message,
// which we assume to have no required fields.
if m == nil {
return nil
}
return checkInitialized(m.ProtoReflect())
}
// CheckInitialized returns an error if any required fields in m are not set.
func checkInitialized(m protoreflect.Message) error {
if methods := protoMethods(m); methods != nil && methods.CheckInitialized != nil {
_, err := methods.CheckInitialized(protoiface.CheckInitializedInput{
Message: m,
})
return err
}
return checkInitializedSlow(m)
}
func checkInitializedSlow(m protoreflect.Message) error {
md := m.Descriptor()
fds := md.Fields()
for i, nums := 0, md.RequiredNumbers(); i < nums.Len(); i++ {
fd := fds.ByNumber(nums.Get(i))
if !m.Has(fd) {
return errors.RequiredNotSet(string(fd.FullName()))
}
}
var err error
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
switch {
case fd.IsList():
if fd.Message() == nil {
return true
}
for i, list := 0, v.List(); i < list.Len() && err == nil; i++ {
err = checkInitialized(list.Get(i).Message())
}
case fd.IsMap():
if fd.MapValue().Message() == nil {
return true
}
v.Map().Range(func(key protoreflect.MapKey, v protoreflect.Value) bool {
err = checkInitialized(v.Message())
return err == nil
})
default:
if fd.Message() == nil {
return true
}
err = checkInitialized(v.Message())
}
return err == nil
})
return err
}
// Copyright 2018 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 (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
)
// UnmarshalOptions configures the unmarshaler.
//
// Example usage:
//
// err := UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, m)
type UnmarshalOptions struct {
pragma.NoUnkeyedLiterals
// Merge merges the input into the destination message.
// The default behavior is to always reset the message before unmarshaling,
// unless Merge is specified.
Merge bool
// AllowPartial accepts input for messages that will result in missing
// required fields. If AllowPartial is false (the default), Unmarshal will
// return an error if there are any missing required fields.
AllowPartial bool
// If DiscardUnknown is set, unknown fields are ignored.
DiscardUnknown bool
// Resolver is used for looking up types when unmarshaling extension fields.
// If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
}
// RecursionLimit limits how deeply messages may be nested.
// If zero, a default limit is applied.
RecursionLimit int
//
// NoLazyDecoding turns off lazy decoding, which otherwise is enabled by
// default. Lazy decoding only affects submessages (annotated with [lazy =
// true] in the .proto file) within messages that use the Opaque API.
NoLazyDecoding bool
}
// Unmarshal parses the wire-format message in b and places the result in m.
// The provided message must be mutable (e.g., a non-nil pointer to a message).
//
// See the [UnmarshalOptions] type if you need more control.
func Unmarshal(b []byte, m Message) error {
_, err := UnmarshalOptions{RecursionLimit: protowire.DefaultRecursionLimit}.unmarshal(b, m.ProtoReflect())
return err
}
// Unmarshal parses the wire-format message in b and places the result in m.
// The provided message must be mutable (e.g., a non-nil pointer to a message).
func (o UnmarshalOptions) Unmarshal(b []byte, m Message) error {
if o.RecursionLimit == 0 {
o.RecursionLimit = protowire.DefaultRecursionLimit
}
_, err := o.unmarshal(b, m.ProtoReflect())
return err
}
// UnmarshalState parses a wire-format message and places the result in m.
//
// This method permits fine-grained control over the unmarshaler.
// Most users should use [Unmarshal] instead.
func (o UnmarshalOptions) UnmarshalState(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
if o.RecursionLimit == 0 {
o.RecursionLimit = protowire.DefaultRecursionLimit
}
return o.unmarshal(in.Buf, in.Message)
}
// 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 protoreflect.Message) (out protoiface.UnmarshalOutput, err error) {
if o.Resolver == nil {
o.Resolver = protoregistry.GlobalTypes
}
if !o.Merge {
Reset(m.Interface())
}
allowPartial := o.AllowPartial
o.Merge = true
o.AllowPartial = true
methods := protoMethods(m)
if methods != nil && methods.Unmarshal != nil &&
!(o.DiscardUnknown && methods.Flags&protoiface.SupportUnmarshalDiscardUnknown == 0) {
in := protoiface.UnmarshalInput{
Message: m,
Buf: b,
Resolver: o.Resolver,
Depth: o.RecursionLimit,
}
if o.DiscardUnknown {
in.Flags |= protoiface.UnmarshalDiscardUnknown
}
if !allowPartial {
// This does not affect how current unmarshal functions work, it just allows them
// to record this for lazy the decoding case.
in.Flags |= protoiface.UnmarshalCheckRequired
}
if o.NoLazyDecoding {
in.Flags |= protoiface.UnmarshalNoLazyDecoding
}
out, err = methods.Unmarshal(in)
} else {
o.RecursionLimit--
if o.RecursionLimit < 0 {
return out, errors.New("exceeded max recursion depth")
}
err = o.unmarshalMessageSlow(b, m)
}
if err != nil {
return out, err
}
if allowPartial || (out.Flags&protoiface.UnmarshalInitialized != 0) {
return out, nil
}
return out, checkInitialized(m)
}
func (o UnmarshalOptions) unmarshalMessage(b []byte, m protoreflect.Message) error {
_, err := o.unmarshal(b, m)
return err
}
func (o UnmarshalOptions) unmarshalMessageSlow(b []byte, m protoreflect.Message) error {
md := m.Descriptor()
if messageset.IsMessageSet(md) {
return o.unmarshalMessageSet(b, m)
}
fields := md.Fields()
for len(b) > 0 {
// Parse the tag (field number and wire type).
num, wtyp, tagLen := protowire.ConsumeTag(b)
if tagLen < 0 {
return errDecode
}
if num > protowire.MaxValidNumber {
return errDecode
}
// Find the field descriptor for this field number.
fd := fields.ByNumber(num)
if fd == nil && md.ExtensionRanges().Has(num) {
extType, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
if err != nil && err != protoregistry.NotFound {
return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
}
if extType != nil {
fd = extType.TypeDescriptor()
}
}
var err error
if fd == nil {
err = errUnknown
}
// Parse the field value.
var valLen int
switch {
case err != nil:
case fd.IsList():
valLen, err = o.unmarshalList(b[tagLen:], wtyp, m.Mutable(fd).List(), fd)
case fd.IsMap():
valLen, err = o.unmarshalMap(b[tagLen:], wtyp, m.Mutable(fd).Map(), fd)
default:
valLen, err = o.unmarshalSingular(b[tagLen:], wtyp, m, fd)
}
if err != nil {
if err != errUnknown {
return err
}
valLen = protowire.ConsumeFieldValue(num, wtyp, b[tagLen:])
if valLen < 0 {
return errDecode
}
if !o.DiscardUnknown {
m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...))
}
}
b = b[tagLen+valLen:]
}
return nil
}
func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp protowire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) {
v, n, err := o.unmarshalScalar(b, wtyp, fd)
if err != nil {
return 0, err
}
switch fd.Kind() {
case protoreflect.GroupKind, protoreflect.MessageKind:
m2 := m.Mutable(fd).Message()
if err := o.unmarshalMessage(v.Bytes(), m2); err != nil {
return n, err
}
default:
// Non-message scalars replace the previous value.
m.Set(fd, v)
}
return n, nil
}
func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp protowire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) {
if wtyp != protowire.BytesType {
return 0, errUnknown
}
b, n = protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
var (
keyField = fd.MapKey()
valField = fd.MapValue()
key protoreflect.Value
val protoreflect.Value
haveKey bool
haveVal bool
)
switch valField.Kind() {
case protoreflect.GroupKind, protoreflect.MessageKind:
val = mapv.NewValue()
}
// Map entries are represented as a two-element message with fields
// containing the key and value.
for len(b) > 0 {
num, wtyp, n := protowire.ConsumeTag(b)
if n < 0 {
return 0, errDecode
}
if num > protowire.MaxValidNumber {
return 0, errDecode
}
b = b[n:]
err = errUnknown
switch num {
case genid.MapEntry_Key_field_number:
key, n, err = o.unmarshalScalar(b, wtyp, keyField)
if err != nil {
break
}
haveKey = true
case genid.MapEntry_Value_field_number:
var v protoreflect.Value
v, n, err = o.unmarshalScalar(b, wtyp, valField)
if err != nil {
break
}
switch valField.Kind() {
case protoreflect.GroupKind, protoreflect.MessageKind:
if err := o.unmarshalMessage(v.Bytes(), val.Message()); err != nil {
return 0, err
}
default:
val = v
}
haveVal = true
}
if err == errUnknown {
n = protowire.ConsumeFieldValue(num, wtyp, b)
if n < 0 {
return 0, errDecode
}
} else if err != nil {
return 0, err
}
b = b[n:]
}
// Every map entry should have entries for key and value, but this is not strictly required.
if !haveKey {
key = keyField.Default()
}
if !haveVal {
switch valField.Kind() {
case protoreflect.GroupKind, protoreflect.MessageKind:
default:
val = valField.Default()
}
}
mapv.Set(key.MapKey(), val)
return n, nil
}
// errUnknown is used internally to indicate fields which should be added
// to the unknown field set of a message. It is never returned from an exported
// function.
var errUnknown = errors.New("BUG: internal error (unknown)")
var errDecode = errors.New("cannot parse invalid wire-format data")
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package proto
import (
"math"
"unicode/utf8"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
// unmarshalScalar decodes a value of the given kind.
//
// Message values are decoded into a []byte which aliases the input data.
func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
switch fd.Kind() {
case protoreflect.BoolKind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
case protoreflect.EnumKind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
case protoreflect.Int32Kind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfInt32(int32(v)), n, nil
case protoreflect.Sint32Kind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
case protoreflect.Uint32Kind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfUint32(uint32(v)), n, nil
case protoreflect.Int64Kind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfInt64(int64(v)), n, nil
case protoreflect.Sint64Kind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
case protoreflect.Uint64Kind:
if wtyp != protowire.VarintType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfUint64(v), n, nil
case protoreflect.Sfixed32Kind:
if wtyp != protowire.Fixed32Type {
return val, 0, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfInt32(int32(v)), n, nil
case protoreflect.Fixed32Kind:
if wtyp != protowire.Fixed32Type {
return val, 0, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfUint32(uint32(v)), n, nil
case protoreflect.FloatKind:
if wtyp != protowire.Fixed32Type {
return val, 0, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
case protoreflect.Sfixed64Kind:
if wtyp != protowire.Fixed64Type {
return val, 0, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfInt64(int64(v)), n, nil
case protoreflect.Fixed64Kind:
if wtyp != protowire.Fixed64Type {
return val, 0, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfUint64(v), n, nil
case protoreflect.DoubleKind:
if wtyp != protowire.Fixed64Type {
return val, 0, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
case protoreflect.StringKind:
if wtyp != protowire.BytesType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return val, 0, errDecode
}
if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
}
return protoreflect.ValueOfString(string(v)), n, nil
case protoreflect.BytesKind:
if wtyp != protowire.BytesType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
case protoreflect.MessageKind:
if wtyp != protowire.BytesType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfBytes(v), n, nil
case protoreflect.GroupKind:
if wtyp != protowire.StartGroupType {
return val, 0, errUnknown
}
v, n := protowire.ConsumeGroup(fd.Number(), b)
if n < 0 {
return val, 0, errDecode
}
return protoreflect.ValueOfBytes(v), n, nil
default:
return val, 0, errUnknown
}
}
func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
switch fd.Kind() {
case protoreflect.BoolKind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
return n, nil
case protoreflect.EnumKind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
return n, nil
case protoreflect.Int32Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfInt32(int32(v)))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(v)))
return n, nil
case protoreflect.Sint32Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
return n, nil
case protoreflect.Uint32Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfUint32(uint32(v)))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfUint32(uint32(v)))
return n, nil
case protoreflect.Int64Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfInt64(int64(v)))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfInt64(int64(v)))
return n, nil
case protoreflect.Sint64Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
return n, nil
case protoreflect.Uint64Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeVarint(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfUint64(v))
}
return n, nil
}
if wtyp != protowire.VarintType {
return 0, errUnknown
}
v, n := protowire.ConsumeVarint(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfUint64(v))
return n, nil
case protoreflect.Sfixed32Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeFixed32(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfInt32(int32(v)))
}
return n, nil
}
if wtyp != protowire.Fixed32Type {
return 0, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfInt32(int32(v)))
return n, nil
case protoreflect.Fixed32Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeFixed32(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfUint32(uint32(v)))
}
return n, nil
}
if wtyp != protowire.Fixed32Type {
return 0, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfUint32(uint32(v)))
return n, nil
case protoreflect.FloatKind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeFixed32(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
}
return n, nil
}
if wtyp != protowire.Fixed32Type {
return 0, errUnknown
}
v, n := protowire.ConsumeFixed32(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
return n, nil
case protoreflect.Sfixed64Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeFixed64(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfInt64(int64(v)))
}
return n, nil
}
if wtyp != protowire.Fixed64Type {
return 0, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfInt64(int64(v)))
return n, nil
case protoreflect.Fixed64Kind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeFixed64(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfUint64(v))
}
return n, nil
}
if wtyp != protowire.Fixed64Type {
return 0, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfUint64(v))
return n, nil
case protoreflect.DoubleKind:
if wtyp == protowire.BytesType {
buf, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
for len(buf) > 0 {
v, n := protowire.ConsumeFixed64(buf)
if n < 0 {
return 0, errDecode
}
buf = buf[n:]
list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
}
return n, nil
}
if wtyp != protowire.Fixed64Type {
return 0, errUnknown
}
v, n := protowire.ConsumeFixed64(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
return n, nil
case protoreflect.StringKind:
if wtyp != protowire.BytesType {
return 0, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
return 0, errors.InvalidUTF8(string(fd.FullName()))
}
list.Append(protoreflect.ValueOfString(string(v)))
return n, nil
case protoreflect.BytesKind:
if wtyp != protowire.BytesType {
return 0, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
return n, nil
case protoreflect.MessageKind:
if wtyp != protowire.BytesType {
return 0, errUnknown
}
v, n := protowire.ConsumeBytes(b)
if n < 0 {
return 0, errDecode
}
m := list.NewElement()
if err := o.unmarshalMessage(v, m.Message()); err != nil {
return 0, err
}
list.Append(m)
return n, nil
case protoreflect.GroupKind:
if wtyp != protowire.StartGroupType {
return 0, errUnknown
}
v, n := protowire.ConsumeGroup(fd.Number(), b)
if n < 0 {
return 0, errDecode
}
m := list.NewElement()
if err := o.unmarshalMessage(v, m.Message()); err != nil {
return 0, err
}
list.Append(m)
return n, nil
default:
return 0, errUnknown
}
}
// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
var emptyBuf [0]byte
// 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/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/order"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
protoerrors "google.golang.org/protobuf/internal/errors"
)
// MarshalOptions configures the marshaler.
//
// Example usage:
//
// b, err := MarshalOptions{Deterministic: true}.Marshal(m)
type MarshalOptions struct {
pragma.NoUnkeyedLiterals
// AllowPartial allows messages that have missing required fields to marshal
// without returning an error. If AllowPartial is false (the default),
// Marshal will return an error if there are any missing required fields.
AllowPartial bool
// Deterministic controls whether the same message will always be
// serialized to the same bytes within the same binary.
//
// Setting this option guarantees that repeated serialization of
// the same message will return the same bytes, and that different
// processes of the same binary (which may be executing on different
// machines) will serialize equal messages to the same bytes.
// It has no effect on the resulting size of the encoded message compared
// to a non-deterministic marshal.
//
// 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.) must 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.
Deterministic bool
// UseCachedSize indicates that the result of a previous Size call
// may be reused.
//
// Setting this option asserts that:
//
// 1. Size has previously been called on this message with identical
// options (except for UseCachedSize itself).
//
// 2. The message and all its submessages have not changed in any
// way since the Size call. For lazily decoded messages, accessing
// a message results in decoding the message, which is a change.
//
// If either of these invariants is violated,
// the results are undefined and may include panics or corrupted output.
//
// Implementations MAY take this option into account to provide
// better performance, but there is no guarantee that they will do so.
// There is absolutely no guarantee that Size followed by Marshal with
// UseCachedSize set will perform equivalently to Marshal alone.
UseCachedSize bool
}
// flags turns the specified MarshalOptions (user-facing) into
// protoiface.MarshalInputFlags (used internally by the marshaler).
//
// See impl.marshalOptions.Options for the inverse operation.
func (o MarshalOptions) flags() protoiface.MarshalInputFlags {
var flags protoiface.MarshalInputFlags
// Note: o.AllowPartial is always forced to true by MarshalOptions.marshal,
// which is why it is not a part of MarshalInputFlags.
if o.Deterministic {
flags |= protoiface.MarshalDeterministic
}
if o.UseCachedSize {
flags |= protoiface.MarshalUseCachedSize
}
return flags
}
// Marshal returns the wire-format encoding of m.
//
// This is the most common entry point for encoding a Protobuf message.
//
// See the [MarshalOptions] type if you need more control.
func Marshal(m Message) ([]byte, error) {
// Treat nil message interface as an empty message; nothing to output.
if m == nil {
return nil, nil
}
out, err := MarshalOptions{}.marshal(nil, m.ProtoReflect())
if len(out.Buf) == 0 && err == nil {
out.Buf = emptyBytesForMessage(m)
}
return out.Buf, err
}
// Marshal returns the wire-format encoding of m.
func (o MarshalOptions) Marshal(m Message) ([]byte, error) {
// Treat nil message interface as an empty message; nothing to output.
if m == nil {
return nil, nil
}
out, err := o.marshal(nil, m.ProtoReflect())
if len(out.Buf) == 0 && err == nil {
out.Buf = emptyBytesForMessage(m)
}
return out.Buf, err
}
// emptyBytesForMessage returns a nil buffer if and only if m is invalid,
// otherwise it returns a non-nil empty buffer.
//
// This is to assist the edge-case where user-code does the following:
//
// m1.OptionalBytes, _ = proto.Marshal(m2)
//
// where they expect the proto2 "optional_bytes" field to be populated
// if any only if m2 is a valid message.
func emptyBytesForMessage(m Message) []byte {
if m == nil || !m.ProtoReflect().IsValid() {
return nil
}
return emptyBuf[:]
}
// MarshalAppend appends the wire-format encoding of m to b,
// returning the result.
//
// This is a less common entry point than [Marshal], which is only needed if you
// need to supply your own buffers for performance reasons.
func (o MarshalOptions) MarshalAppend(b []byte, m Message) ([]byte, error) {
// Treat nil message interface as an empty message; nothing to append.
if m == nil {
return b, nil
}
out, err := o.marshal(b, m.ProtoReflect())
return out.Buf, err
}
// MarshalState returns the wire-format encoding of a message.
//
// This method permits fine-grained control over the marshaler.
// Most users should use [Marshal] instead.
func (o MarshalOptions) MarshalState(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
return o.marshal(in.Buf, in.Message)
}
// 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(b []byte, m protoreflect.Message) (out protoiface.MarshalOutput, err error) {
allowPartial := o.AllowPartial
o.AllowPartial = true
if methods := protoMethods(m); methods != nil && methods.Marshal != nil &&
!(o.Deterministic && methods.Flags&protoiface.SupportMarshalDeterministic == 0) {
in := protoiface.MarshalInput{
Message: m,
Buf: b,
Flags: o.flags(),
}
if methods.Size != nil {
sout := methods.Size(protoiface.SizeInput{
Message: m,
Flags: in.Flags,
})
if cap(b) < len(b)+sout.Size {
in.Buf = make([]byte, len(b), growcap(cap(b), len(b)+sout.Size))
copy(in.Buf, b)
}
in.Flags |= protoiface.MarshalUseCachedSize
}
out, err = methods.Marshal(in)
} else {
out.Buf, err = o.marshalMessageSlow(b, m)
}
if err != nil {
var mismatch *protoerrors.SizeMismatchError
if errors.As(err, &mismatch) {
return out, fmt.Errorf("marshaling %s: %v", string(m.Descriptor().FullName()), err)
}
return out, err
}
if allowPartial {
return out, nil
}
return out, checkInitialized(m)
}
func (o MarshalOptions) marshalMessage(b []byte, m protoreflect.Message) ([]byte, error) {
out, err := o.marshal(b, m)
return out.Buf, err
}
// growcap scales up the capacity of a slice.
//
// Given a slice with a current capacity of oldcap and a desired
// capacity of wantcap, growcap returns a new capacity >= wantcap.
//
// The algorithm is mostly identical to the one used by append as of Go 1.14.
func growcap(oldcap, wantcap int) (newcap int) {
if wantcap > oldcap*2 {
newcap = wantcap
} else if oldcap < 1024 {
// The Go 1.14 runtime takes this case when len(s) < 1024,
// not when cap(s) < 1024. The difference doesn't seem
// significant here.
newcap = oldcap * 2
} else {
newcap = oldcap
for 0 < newcap && newcap < wantcap {
newcap += newcap / 4
}
if newcap <= 0 {
newcap = wantcap
}
}
return newcap
}
func (o MarshalOptions) marshalMessageSlow(b []byte, m protoreflect.Message) ([]byte, error) {
if messageset.IsMessageSet(m.Descriptor()) {
return o.marshalMessageSet(b, m)
}
fieldOrder := order.AnyFieldOrder
if o.Deterministic {
// TODO: This should use a more natural ordering like NumberFieldOrder,
// but doing so breaks golden tests that make invalid assumption about
// output stability of this implementation.
fieldOrder = order.LegacyFieldOrder
}
var err error
order.RangeFields(m, fieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
b, err = o.marshalField(b, fd, v)
return err == nil
})
if err != nil {
return b, err
}
b = append(b, m.GetUnknown()...)
return b, nil
}
func (o MarshalOptions) marshalField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) {
switch {
case fd.IsList():
return o.marshalList(b, fd, value.List())
case fd.IsMap():
return o.marshalMap(b, fd, value.Map())
default:
b = protowire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
return o.marshalSingular(b, fd, value)
}
}
func (o MarshalOptions) marshalList(b []byte, fd protoreflect.FieldDescriptor, list protoreflect.List) ([]byte, error) {
if fd.IsPacked() && list.Len() > 0 {
b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
b, pos := appendSpeculativeLength(b)
for i, llen := 0, list.Len(); i < llen; i++ {
var err error
b, err = o.marshalSingular(b, fd, list.Get(i))
if err != nil {
return b, err
}
}
b = finishSpeculativeLength(b, pos)
return b, nil
}
kind := fd.Kind()
for i, llen := 0, list.Len(); i < llen; i++ {
var err error
b = protowire.AppendTag(b, fd.Number(), wireTypes[kind])
b, err = o.marshalSingular(b, fd, list.Get(i))
if err != nil {
return b, err
}
}
return b, nil
}
func (o MarshalOptions) marshalMap(b []byte, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) ([]byte, error) {
keyf := fd.MapKey()
valf := fd.MapValue()
keyOrder := order.AnyKeyOrder
if o.Deterministic {
keyOrder = order.GenericKeyOrder
}
var err error
order.RangeEntries(mapv, keyOrder, func(key protoreflect.MapKey, value protoreflect.Value) bool {
b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
var pos int
b, pos = appendSpeculativeLength(b)
b, err = o.marshalField(b, keyf, key.Value())
if err != nil {
return false
}
b, err = o.marshalField(b, valf, value)
if err != nil {
return false
}
b = finishSpeculativeLength(b, pos)
return true
})
return b, err
}
// When encoding length-prefixed fields, we speculatively set aside some number of bytes
// for the length, encode the data, and then encode the length (shifting the data if necessary
// to make room).
const speculativeLength = 1
func appendSpeculativeLength(b []byte) ([]byte, int) {
pos := len(b)
b = append(b, "\x00\x00\x00\x00"[:speculativeLength]...)
return b, pos
}
func finishSpeculativeLength(b []byte, pos int) []byte {
mlen := len(b) - pos - speculativeLength
msiz := protowire.SizeVarint(uint64(mlen))
if msiz != speculativeLength {
for i := 0; i < msiz-speculativeLength; i++ {
b = append(b, 0)
}
copy(b[pos+msiz:], b[pos+speculativeLength:])
b = b[:pos+msiz+mlen]
}
protowire.AppendVarint(b[:pos], uint64(mlen))
return b
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package proto
import (
"math"
"unicode/utf8"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
)
var wireTypes = map[protoreflect.Kind]protowire.Type{
protoreflect.BoolKind: protowire.VarintType,
protoreflect.EnumKind: protowire.VarintType,
protoreflect.Int32Kind: protowire.VarintType,
protoreflect.Sint32Kind: protowire.VarintType,
protoreflect.Uint32Kind: protowire.VarintType,
protoreflect.Int64Kind: protowire.VarintType,
protoreflect.Sint64Kind: protowire.VarintType,
protoreflect.Uint64Kind: protowire.VarintType,
protoreflect.Sfixed32Kind: protowire.Fixed32Type,
protoreflect.Fixed32Kind: protowire.Fixed32Type,
protoreflect.FloatKind: protowire.Fixed32Type,
protoreflect.Sfixed64Kind: protowire.Fixed64Type,
protoreflect.Fixed64Kind: protowire.Fixed64Type,
protoreflect.DoubleKind: protowire.Fixed64Type,
protoreflect.StringKind: protowire.BytesType,
protoreflect.BytesKind: protowire.BytesType,
protoreflect.MessageKind: protowire.BytesType,
protoreflect.GroupKind: protowire.StartGroupType,
}
func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
switch fd.Kind() {
case protoreflect.BoolKind:
b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
case protoreflect.EnumKind:
b = protowire.AppendVarint(b, uint64(v.Enum()))
case protoreflect.Int32Kind:
b = protowire.AppendVarint(b, uint64(int32(v.Int())))
case protoreflect.Sint32Kind:
b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
case protoreflect.Uint32Kind:
b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
case protoreflect.Int64Kind:
b = protowire.AppendVarint(b, uint64(v.Int()))
case protoreflect.Sint64Kind:
b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
case protoreflect.Uint64Kind:
b = protowire.AppendVarint(b, v.Uint())
case protoreflect.Sfixed32Kind:
b = protowire.AppendFixed32(b, uint32(v.Int()))
case protoreflect.Fixed32Kind:
b = protowire.AppendFixed32(b, uint32(v.Uint()))
case protoreflect.FloatKind:
b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
case protoreflect.Sfixed64Kind:
b = protowire.AppendFixed64(b, uint64(v.Int()))
case protoreflect.Fixed64Kind:
b = protowire.AppendFixed64(b, v.Uint())
case protoreflect.DoubleKind:
b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
case protoreflect.StringKind:
if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
return b, errors.InvalidUTF8(string(fd.FullName()))
}
b = protowire.AppendString(b, v.String())
case protoreflect.BytesKind:
b = protowire.AppendBytes(b, v.Bytes())
case protoreflect.MessageKind:
var pos int
var err error
b, pos = appendSpeculativeLength(b)
b, err = o.marshalMessage(b, v.Message())
if err != nil {
return b, err
}
b = finishSpeculativeLength(b, pos)
case protoreflect.GroupKind:
var err error
b, err = o.marshalMessage(b, v.Message())
if err != nil {
return b, err
}
b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
default:
return b, errors.New("invalid kind %v", fd.Kind())
}
return b, nil
}
// 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 (
"reflect"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// Equal reports whether two messages are equal,
// by recursively comparing the fields of the message.
//
// - Bytes fields are equal if they contain identical bytes.
// Empty bytes (regardless of nil-ness) are considered equal.
//
// - Floating-point fields are equal if they contain the same value.
// Unlike the == operator, a NaN is equal to another NaN.
//
// - Other scalar fields are equal if they contain the same value.
//
// - Message fields are equal if they have
// the same set of populated known and extension field values, and
// the same set of unknown fields values.
//
// - Lists are equal if they are the same length and
// each corresponding element is equal.
//
// - Maps are equal if they have the same set of keys and
// the corresponding value for each key is equal.
//
// An invalid message is not equal to a valid message.
// An invalid message is only equal to another invalid message of the
// same type. An invalid message often corresponds to a nil pointer
// of the concrete message type. For example, (*pb.M)(nil) is not equal
// to &pb.M{}.
// If two valid messages marshal to the same bytes under deterministic
// serialization, then Equal is guaranteed to report true.
func Equal(x, y Message) bool {
if x == nil || y == nil {
return x == nil && y == nil
}
if reflect.TypeOf(x).Kind() == reflect.Ptr && x == y {
// Avoid an expensive comparison if both inputs are identical pointers.
return true
}
mx := x.ProtoReflect()
my := y.ProtoReflect()
if mx.IsValid() != my.IsValid() {
return false
}
// Only one of the messages needs to implement the fast-path for it to work.
pmx := protoMethods(mx)
pmy := protoMethods(my)
if pmx != nil && pmy != nil && pmx.Equal != nil && pmy.Equal != nil {
return pmx.Equal(protoiface.EqualInput{MessageA: mx, MessageB: my}).Equal
}
vx := protoreflect.ValueOfMessage(mx)
vy := protoreflect.ValueOfMessage(my)
return vx.Equal(vy)
}
// 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 (
"google.golang.org/protobuf/reflect/protoreflect"
)
// HasExtension reports whether an extension field is populated.
// It returns false if m is invalid or if xt does not extend m.
func HasExtension(m Message, xt protoreflect.ExtensionType) bool {
// Treat nil message interface or descriptor as an empty message; no populated
// fields.
if m == nil || xt == nil {
return false
}
// As a special-case, we reports invalid or mismatching descriptors
// as always not being populated (since they aren't).
mr := m.ProtoReflect()
xd := xt.TypeDescriptor()
if mr.Descriptor() != xd.ContainingMessage() {
return false
}
return mr.Has(xd)
}
// ClearExtension clears an extension field such that subsequent
// [HasExtension] calls return false.
// It panics if m is invalid or if xt does not extend m.
func ClearExtension(m Message, xt protoreflect.ExtensionType) {
m.ProtoReflect().Clear(xt.TypeDescriptor())
}
// GetExtension retrieves the value for an extension field.
// If the field is unpopulated, it returns the default value for
// scalars and an immutable, empty value for lists or messages.
// It panics if xt does not extend m.
//
// The type of the value is dependent on the field type of the extension.
// For extensions generated by protoc-gen-go, the Go type is as follows:
//
// ╔═══════════════════╤═════════════════════════╗
// ║ Go type │ Protobuf kind ║
// ╠═══════════════════╪═════════════════════════╣
// ║ bool │ bool ║
// ║ int32 │ int32, sint32, sfixed32 ║
// ║ int64 │ int64, sint64, sfixed64 ║
// ║ uint32 │ uint32, fixed32 ║
// ║ uint64 │ uint64, fixed64 ║
// ║ float32 │ float ║
// ║ float64 │ double ║
// ║ string │ string ║
// ║ []byte │ bytes ║
// ║ protoreflect.Enum │ enum ║
// ║ proto.Message │ message, group ║
// ╚═══════════════════╧═════════════════════════╝
//
// The protoreflect.Enum and proto.Message types are the concrete Go type
// associated with the named enum or message. Repeated fields are represented
// using a Go slice of the base element type.
//
// If a generated extension descriptor variable is directly passed to
// GetExtension, then the call should be followed immediately by a
// type assertion to the expected output value. For example:
//
// mm := proto.GetExtension(m, foopb.E_MyExtension).(*foopb.MyMessage)
//
// This pattern enables static analysis tools to verify that the asserted type
// matches the Go type associated with the extension field and
// also enables a possible future migration to a type-safe extension API.
//
// Since singular messages are the most common extension type, the pattern of
// calling HasExtension followed by GetExtension may be simplified to:
//
// if mm := proto.GetExtension(m, foopb.E_MyExtension).(*foopb.MyMessage); mm != nil {
// ... // make use of mm
// }
//
// The mm variable is non-nil if and only if HasExtension reports true.
func GetExtension(m Message, xt protoreflect.ExtensionType) any {
// Treat nil message interface as an empty message; return the default.
if m == nil {
return xt.InterfaceOf(xt.Zero())
}
return xt.InterfaceOf(m.ProtoReflect().Get(xt.TypeDescriptor()))
}
// SetExtension stores the value of an extension field.
// It panics if m is invalid, xt does not extend m, or if type of v
// is invalid for the specified extension field.
//
// The type of the value is dependent on the field type of the extension.
// For extensions generated by protoc-gen-go, the Go type is as follows:
//
// ╔═══════════════════╤═════════════════════════╗
// ║ Go type │ Protobuf kind ║
// ╠═══════════════════╪═════════════════════════╣
// ║ bool │ bool ║
// ║ int32 │ int32, sint32, sfixed32 ║
// ║ int64 │ int64, sint64, sfixed64 ║
// ║ uint32 │ uint32, fixed32 ║
// ║ uint64 │ uint64, fixed64 ║
// ║ float32 │ float ║
// ║ float64 │ double ║
// ║ string │ string ║
// ║ []byte │ bytes ║
// ║ protoreflect.Enum │ enum ║
// ║ proto.Message │ message, group ║
// ╚═══════════════════╧═════════════════════════╝
//
// The protoreflect.Enum and proto.Message types are the concrete Go type
// associated with the named enum or message. Repeated fields are represented
// using a Go slice of the base element type.
//
// If a generated extension descriptor variable is directly passed to
// SetExtension (e.g., foopb.E_MyExtension), then the value should be a
// concrete type that matches the expected Go type for the extension descriptor
// so that static analysis tools can verify type correctness.
// This also enables a possible future migration to a type-safe extension API.
func SetExtension(m Message, xt protoreflect.ExtensionType, v any) {
xd := xt.TypeDescriptor()
pv := xt.ValueOf(v)
// Specially treat an invalid list, map, or message as clear.
isValid := true
switch {
case xd.IsList():
isValid = pv.List().IsValid()
case xd.IsMap():
isValid = pv.Map().IsValid()
case xd.Message() != nil:
isValid = pv.Message().IsValid()
}
if !isValid {
m.ProtoReflect().Clear(xd)
return
}
m.ProtoReflect().Set(xd, pv)
}
// RangeExtensions iterates over every populated extension field in m in an
// undefined order, calling f for each extension type and value encountered.
// It returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current extension field.
func RangeExtensions(m Message, f func(protoreflect.ExtensionType, any) bool) {
// Treat nil message interface as an empty message; nothing to range over.
if m == nil {
return
}
m.ProtoReflect().Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
if fd.IsExtension() {
xt := fd.(protoreflect.ExtensionTypeDescriptor).Type()
vi := xt.InterfaceOf(v)
return f(xt, vi)
}
return true
})
}
// 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 (
"fmt"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// Merge merges src into dst, which must be a message with the same descriptor.
//
// Populated scalar fields in src are copied to dst, while populated
// singular messages in src are merged into dst by recursively calling Merge.
// The elements of every list field in src is appended to the corresponded
// list fields in dst. The entries of every map field in src is copied into
// the corresponding map field in dst, possibly replacing existing entries.
// The unknown fields of src are appended to the unknown fields of dst.
//
// It is semantically equivalent to unmarshaling the encoded form of src
// into dst with the [UnmarshalOptions.Merge] option specified.
func Merge(dst, src Message) {
// TODO: Should nil src be treated as semantically equivalent to a
// untyped, read-only, empty message? What about a nil dst?
dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
if dstMsg.Descriptor() != srcMsg.Descriptor() {
if got, want := dstMsg.Descriptor().FullName(), srcMsg.Descriptor().FullName(); got != want {
panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
}
panic("descriptor mismatch")
}
mergeOptions{}.mergeMessage(dstMsg, srcMsg)
}
// Clone returns a deep copy of m.
// If the top-level message is invalid, it returns an invalid message as well.
func Clone(m Message) Message {
// NOTE: Most usages of Clone assume the following properties:
// t := reflect.TypeOf(m)
// t == reflect.TypeOf(m.ProtoReflect().New().Interface())
// t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
//
// Embedding protobuf messages breaks this since the parent type will have
// a forwarded ProtoReflect method, but the Interface method will return
// the underlying embedded message type.
if m == nil {
return nil
}
src := m.ProtoReflect()
if !src.IsValid() {
return src.Type().Zero().Interface()
}
dst := src.New()
mergeOptions{}.mergeMessage(dst, src)
return dst.Interface()
}
// CloneOf returns a deep copy of m. If the top-level message is invalid,
// it returns an invalid message as well.
func CloneOf[M Message](m M) M {
return Clone(m).(M)
}
// mergeOptions provides a namespace for merge functions, and can be
// exported in the future if we add user-visible merge options.
type mergeOptions struct{}
func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
methods := protoMethods(dst)
if methods != nil && methods.Merge != nil {
in := protoiface.MergeInput{
Destination: dst,
Source: src,
}
out := methods.Merge(in)
if out.Flags&protoiface.MergeComplete != 0 {
return
}
}
if !dst.IsValid() {
panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
}
src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
switch {
case fd.IsList():
o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
case fd.IsMap():
o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
case fd.Message() != nil:
o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
case fd.Kind() == protoreflect.BytesKind:
dst.Set(fd, o.cloneBytes(v))
default:
dst.Set(fd, v)
}
return true
})
if len(src.GetUnknown()) > 0 {
dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
}
}
func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
// Merge semantics appends to the end of the existing list.
for i, n := 0, src.Len(); i < n; i++ {
switch v := src.Get(i); {
case fd.Message() != nil:
dstv := dst.NewElement()
o.mergeMessage(dstv.Message(), v.Message())
dst.Append(dstv)
case fd.Kind() == protoreflect.BytesKind:
dst.Append(o.cloneBytes(v))
default:
dst.Append(v)
}
}
}
func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
// Merge semantics replaces, rather than merges into existing entries.
src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
switch {
case fd.Message() != nil:
dstv := dst.NewValue()
o.mergeMessage(dstv.Message(), v.Message())
dst.Set(k, dstv)
case fd.Kind() == protoreflect.BytesKind:
dst.Set(k, o.cloneBytes(v))
default:
dst.Set(k, v)
}
return true
})
}
func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
}
// 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 (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/internal/order"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
func (o MarshalOptions) sizeMessageSet(m protoreflect.Message) (size int) {
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
size += messageset.SizeField(fd.Number())
size += protowire.SizeTag(messageset.FieldMessage)
size += protowire.SizeBytes(o.size(v.Message()))
return true
})
size += messageset.SizeUnknown(m.GetUnknown())
return size
}
func (o MarshalOptions) marshalMessageSet(b []byte, m protoreflect.Message) ([]byte, error) {
if !flags.ProtoLegacy {
return b, errors.New("no support for message_set_wire_format")
}
fieldOrder := order.AnyFieldOrder
if o.Deterministic {
fieldOrder = order.NumberFieldOrder
}
var err error
order.RangeFields(m, fieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
b, err = o.marshalMessageSetField(b, fd, v)
return err == nil
})
if err != nil {
return b, err
}
return messageset.AppendUnknown(b, m.GetUnknown())
}
func (o MarshalOptions) marshalMessageSetField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) {
b = messageset.AppendFieldStart(b, fd.Number())
b = protowire.AppendTag(b, messageset.FieldMessage, protowire.BytesType)
calculatedSize := o.Size(value.Message().Interface())
b = protowire.AppendVarint(b, uint64(calculatedSize))
before := len(b)
b, err := o.marshalMessage(b, value.Message())
if err != nil {
return b, err
}
if measuredSize := len(b) - before; calculatedSize != measuredSize {
return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize)
}
b = messageset.AppendFieldEnd(b)
return b, nil
}
func (o UnmarshalOptions) unmarshalMessageSet(b []byte, m protoreflect.Message) error {
if !flags.ProtoLegacy {
return errors.New("no support for message_set_wire_format")
}
return messageset.Unmarshal(b, false, func(num protowire.Number, v []byte) error {
err := o.unmarshalMessageSetField(m, num, v)
if err == errUnknown {
unknown := m.GetUnknown()
unknown = protowire.AppendTag(unknown, num, protowire.BytesType)
unknown = protowire.AppendBytes(unknown, v)
m.SetUnknown(unknown)
return nil
}
return err
})
}
func (o UnmarshalOptions) unmarshalMessageSetField(m protoreflect.Message, num protowire.Number, v []byte) error {
md := m.Descriptor()
if !md.ExtensionRanges().Has(num) {
return errUnknown
}
xt, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
if err == protoregistry.NotFound {
return errUnknown
}
if err != nil {
return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
}
xd := xt.TypeDescriptor()
if err := o.unmarshalMessage(v, m.Mutable(xd).Message()); err != nil {
return err
}
return nil
}
// Copyright 2018 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 (
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/reflect/protoreflect"
)
// Message is the top-level interface that all messages must implement.
// It provides access to a reflective view of a message.
// Any implementation of this interface may be used with all functions in the
// protobuf module that accept a Message, except where otherwise specified.
//
// This is the v2 interface definition for protobuf messages.
// The v1 interface definition is [github.com/golang/protobuf/proto.Message].
//
// - To convert a v1 message to a v2 message,
// use [google.golang.org/protobuf/protoadapt.MessageV2Of].
// - To convert a v2 message to a v1 message,
// use [google.golang.org/protobuf/protoadapt.MessageV1Of].
type Message = protoreflect.ProtoMessage
// Error matches all errors produced by packages in the protobuf module
// according to [errors.Is].
//
// Example usage:
//
// if errors.Is(err, proto.Error) { ... }
var Error error
func init() {
Error = errors.Error
}
// MessageName returns the full name of m.
// If m is nil, it returns an empty string.
func MessageName(m Message) protoreflect.FullName {
if m == nil {
return ""
}
return m.ProtoReflect().Descriptor().FullName()
}
// 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.
// The protoreflect build tag disables use of fast-path methods.
//go:build !protoreflect
// +build !protoreflect
package proto
import (
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
const hasProtoMethods = true
func protoMethods(m protoreflect.Message) *protoiface.Methods {
return m.ProtoMethods()
}
// 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 (
"fmt"
"google.golang.org/protobuf/reflect/protoreflect"
)
// Reset clears every field in the message.
// The resulting message shares no observable memory with its previous state
// other than the memory for the message itself.
func Reset(m Message) {
if mr, ok := m.(interface{ Reset() }); ok && hasProtoMethods {
mr.Reset()
return
}
resetMessage(m.ProtoReflect())
}
func resetMessage(m protoreflect.Message) {
if !m.IsValid() {
panic(fmt.Sprintf("cannot reset invalid %v message", m.Descriptor().FullName()))
}
// Clear all known fields.
fds := m.Descriptor().Fields()
for i := 0; i < fds.Len(); i++ {
m.Clear(fds.Get(i))
}
// Clear extension fields.
m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
m.Clear(fd)
return true
})
// Clear unknown fields.
m.SetUnknown(nil)
}
// 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 (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
)
// Size returns the size in bytes of the wire-format encoding of m.
//
// Note that Size might return more bytes than Marshal will write in the case of
// lazily decoded messages that arrive in non-minimal wire format: see
// https://protobuf.dev/reference/go/size/ for more details.
func Size(m Message) int {
return MarshalOptions{}.Size(m)
}
// Size returns the size in bytes of the wire-format encoding of m.
//
// Note that Size might return more bytes than Marshal will write in the case of
// lazily decoded messages that arrive in non-minimal wire format: see
// https://protobuf.dev/reference/go/size/ for more details.
func (o MarshalOptions) Size(m Message) int {
// Treat a nil message interface as an empty message; nothing to output.
if m == nil {
return 0
}
return o.size(m.ProtoReflect())
}
// size is a centralized function that all size operations go through.
// For profiling purposes, avoid changing the name of this function or
// introducing other code paths for size that do not go through this.
func (o MarshalOptions) size(m protoreflect.Message) (size int) {
methods := protoMethods(m)
if methods != nil && methods.Size != nil {
out := methods.Size(protoiface.SizeInput{
Message: m,
Flags: o.flags(),
})
return out.Size
}
if methods != nil && methods.Marshal != nil {
// This is not efficient, but we don't have any choice.
// This case is mainly used for legacy types with a Marshal method.
out, _ := methods.Marshal(protoiface.MarshalInput{
Message: m,
Flags: o.flags(),
})
return len(out.Buf)
}
return o.sizeMessageSlow(m)
}
func (o MarshalOptions) sizeMessageSlow(m protoreflect.Message) (size int) {
if messageset.IsMessageSet(m.Descriptor()) {
return o.sizeMessageSet(m)
}
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
size += o.sizeField(fd, v)
return true
})
size += len(m.GetUnknown())
return size
}
func (o MarshalOptions) sizeField(fd protoreflect.FieldDescriptor, value protoreflect.Value) (size int) {
num := fd.Number()
switch {
case fd.IsList():
return o.sizeList(num, fd, value.List())
case fd.IsMap():
return o.sizeMap(num, fd, value.Map())
default:
return protowire.SizeTag(num) + o.sizeSingular(num, fd.Kind(), value)
}
}
func (o MarshalOptions) sizeList(num protowire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
sizeTag := protowire.SizeTag(num)
if fd.IsPacked() && list.Len() > 0 {
content := 0
for i, llen := 0, list.Len(); i < llen; i++ {
content += o.sizeSingular(num, fd.Kind(), list.Get(i))
}
return sizeTag + protowire.SizeBytes(content)
}
for i, llen := 0, list.Len(); i < llen; i++ {
size += sizeTag + o.sizeSingular(num, fd.Kind(), list.Get(i))
}
return size
}
func (o MarshalOptions) sizeMap(num protowire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
sizeTag := protowire.SizeTag(num)
mapv.Range(func(key protoreflect.MapKey, value protoreflect.Value) bool {
size += sizeTag
size += protowire.SizeBytes(o.sizeField(fd.MapKey(), key.Value()) + o.sizeField(fd.MapValue(), value))
return true
})
return size
}
// Copyright 2018 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.
// Code generated by generate-types. DO NOT EDIT.
package proto
import (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/reflect/protoreflect"
)
func (o MarshalOptions) sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
switch kind {
case protoreflect.BoolKind:
return protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
case protoreflect.EnumKind:
return protowire.SizeVarint(uint64(v.Enum()))
case protoreflect.Int32Kind:
return protowire.SizeVarint(uint64(int32(v.Int())))
case protoreflect.Sint32Kind:
return protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
case protoreflect.Uint32Kind:
return protowire.SizeVarint(uint64(uint32(v.Uint())))
case protoreflect.Int64Kind:
return protowire.SizeVarint(uint64(v.Int()))
case protoreflect.Sint64Kind:
return protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
case protoreflect.Uint64Kind:
return protowire.SizeVarint(v.Uint())
case protoreflect.Sfixed32Kind:
return protowire.SizeFixed32()
case protoreflect.Fixed32Kind:
return protowire.SizeFixed32()
case protoreflect.FloatKind:
return protowire.SizeFixed32()
case protoreflect.Sfixed64Kind:
return protowire.SizeFixed64()
case protoreflect.Fixed64Kind:
return protowire.SizeFixed64()
case protoreflect.DoubleKind:
return protowire.SizeFixed64()
case protoreflect.StringKind:
return protowire.SizeBytes(len(v.String()))
case protoreflect.BytesKind:
return protowire.SizeBytes(len(v.Bytes()))
case protoreflect.MessageKind:
return protowire.SizeBytes(o.size(v.Message()))
case protoreflect.GroupKind:
return protowire.SizeGroup(num, o.size(v.Message()))
default:
return 0
}
}
// Copyright 2024 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
// ValueOrNil returns nil if has is false, or a pointer to a new variable
// containing the value returned by the specified getter.
//
// This function is similar to the wrappers (proto.Int32(), proto.String(),
// etc.), but is generic (works for any field type) and works with the hasser
// and getter of a field, as opposed to a value.
//
// This is convenient when populating builder fields.
//
// Example:
//
// hop := attr.GetDirectHop()
// injectedRoute := ripb.InjectedRoute_builder{
// Prefixes: route.GetPrefixes(),
// NextHop: proto.ValueOrNil(hop.HasAddress(), hop.GetAddress),
// }
func ValueOrNil[T any](has bool, getter func() T) *T {
if !has {
return nil
}
v := getter()
return &v
}
// ValueOrDefault returns the protobuf message val if val is not nil, otherwise
// it returns a pointer to an empty val message.
//
// This function allows for translating code from the old Open Struct API to the
// new Opaque API.
//
// The old Open Struct API represented oneof fields with a wrapper struct:
//
// var signedImg *accountpb.SignedImage
// profile := &accountpb.Profile{
// // The Avatar oneof will be set, with an empty SignedImage.
// Avatar: &accountpb.Profile_SignedImage{signedImg},
// }
//
// The new Opaque API treats oneof fields like regular fields, there are no more
// wrapper structs:
//
// var signedImg *accountpb.SignedImage
// profile := &accountpb.Profile{}
// profile.SetSignedImage(signedImg)
//
// For convenience, the Opaque API also offers Builders, which allow for a
// direct translation of struct initialization. However, because Builders use
// nilness to represent field presence (but there is no non-nil wrapper struct
// anymore), Builders cannot distinguish between an unset oneof and a set oneof
// with nil message. The above code would need to be translated with help of the
// ValueOrDefault function to retain the same behavior:
//
// var signedImg *accountpb.SignedImage
// return &accountpb.Profile_builder{
// SignedImage: proto.ValueOrDefault(signedImg),
// }.Build()
func ValueOrDefault[T interface {
*P
Message
}, P any](val T) T {
if val == nil {
return T(new(P))
}
return val
}
// ValueOrDefaultBytes is like ValueOrDefault but for working with fields of
// type []byte.
func ValueOrDefaultBytes(val []byte) []byte {
if val == nil {
return []byte{}
}
return val
}
// 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
// Bool stores v in a new bool value and returns a pointer to it.
func Bool(v bool) *bool { return &v }
// Int32 stores v in a new int32 value and returns a pointer to it.
func Int32(v int32) *int32 { return &v }
// Int64 stores v in a new int64 value and returns a pointer to it.
func Int64(v int64) *int64 { return &v }
// Float32 stores v in a new float32 value and returns a pointer to it.
func Float32(v float32) *float32 { return &v }
// Float64 stores v in a new float64 value and returns a pointer to it.
func Float64(v float64) *float64 { return &v }
// Uint32 stores v in a new uint32 value and returns a pointer to it.
func Uint32(v uint32) *uint32 { return &v }
// Uint64 stores v in a new uint64 value and returns a pointer to it.
func Uint64(v uint64) *uint64 { return &v }
// String stores v in a new string value and returns a pointer to it.
func String(v string) *string { return &v }
// Copyright 2018 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 protoreflect provides interfaces to dynamically manipulate messages.
//
// This package includes type descriptors which describe the structure of types
// defined in proto source files and value interfaces which provide the
// ability to examine and manipulate the contents of messages.
//
// # Protocol Buffer Descriptors
//
// Protobuf descriptors (e.g., [EnumDescriptor] or [MessageDescriptor])
// are immutable objects that represent protobuf type information.
// They are wrappers around the messages declared in descriptor.proto.
// Protobuf descriptors alone lack any information regarding Go types.
//
// Enums and messages generated by this module implement [Enum] and [ProtoMessage],
// where the Descriptor and ProtoReflect.Descriptor accessors respectively
// return the protobuf descriptor for the values.
//
// The protobuf descriptor interfaces are not meant to be implemented by
// user code since they might need to be extended in the future to support
// additions to the protobuf language.
// The [google.golang.org/protobuf/reflect/protodesc] package converts between
// google.protobuf.DescriptorProto messages and protobuf descriptors.
//
// # Go Type Descriptors
//
// A type descriptor (e.g., [EnumType] or [MessageType]) is a constructor for
// a concrete Go type that represents the associated protobuf descriptor.
// There is commonly a one-to-one relationship between protobuf descriptors and
// Go type descriptors, but it can potentially be a one-to-many relationship.
//
// Enums and messages generated by this module implement [Enum] and [ProtoMessage],
// where the Type and ProtoReflect.Type accessors respectively
// return the protobuf descriptor for the values.
//
// The [google.golang.org/protobuf/types/dynamicpb] package can be used to
// create Go type descriptors from protobuf descriptors.
//
// # Value Interfaces
//
// The [Enum] and [Message] interfaces provide a reflective view over an
// enum or message instance. For enums, it provides the ability to retrieve
// the enum value number for any concrete enum type. For messages, it provides
// the ability to access or manipulate fields of the message.
//
// To convert a [google.golang.org/protobuf/proto.Message] to a [protoreflect.Message], use the
// former's ProtoReflect method. Since the ProtoReflect method is new to the
// v2 message interface, it may not be present on older message implementations.
// The [github.com/golang/protobuf/proto.MessageReflect] function can be used
// to obtain a reflective view on older messages.
//
// # Relationships
//
// The following diagrams demonstrate the relationships between
// various types declared in this package.
//
// ┌───────────────────────────────────┐
// V │
// ┌────────────── New(n) ─────────────┐ │
// │ │ │
// │ ┌──── Descriptor() ──┐ │ ┌── Number() ──┐ │
// │ │ V V │ V │
// ╔════════════╗ ╔════════════════╗ ╔════════╗ ╔════════════╗
// ║ EnumType ║ ║ EnumDescriptor ║ ║ Enum ║ ║ EnumNumber ║
// ╚════════════╝ ╚════════════════╝ ╚════════╝ ╚════════════╝
// Λ Λ │ │
// │ └─── Descriptor() ──┘ │
// │ │
// └────────────────── Type() ───────┘
//
// • An [EnumType] describes a concrete Go enum type.
// It has an EnumDescriptor and can construct an Enum instance.
//
// • An [EnumDescriptor] describes an abstract protobuf enum type.
//
// • An [Enum] is a concrete enum instance. Generated enums implement Enum.
//
// ┌──────────────── New() ─────────────────┐
// │ │
// │ ┌─── Descriptor() ─────┐ │ ┌── Interface() ───┐
// │ │ V V │ V
// ╔═════════════╗ ╔═══════════════════╗ ╔═════════╗ ╔══════════════╗
// ║ MessageType ║ ║ MessageDescriptor ║ ║ Message ║ ║ ProtoMessage ║
// ╚═════════════╝ ╚═══════════════════╝ ╚═════════╝ ╚══════════════╝
// Λ Λ │ │ Λ │
// │ └──── Descriptor() ────┘ │ └─ ProtoReflect() ─┘
// │ │
// └─────────────────── Type() ─────────┘
//
// • A [MessageType] describes a concrete Go message type.
// It has a [MessageDescriptor] and can construct a [Message] instance.
// Just as how Go's [reflect.Type] is a reflective description of a Go type,
// a [MessageType] is a reflective description of a Go type for a protobuf message.
//
// • A [MessageDescriptor] describes an abstract protobuf message type.
// It has no understanding of Go types. In order to construct a [MessageType]
// from just a [MessageDescriptor], you can consider looking up the message type
// in the global registry using the FindMessageByName method on
// [google.golang.org/protobuf/reflect/protoregistry.GlobalTypes]
// or constructing a dynamic [MessageType] using
// [google.golang.org/protobuf/types/dynamicpb.NewMessageType].
//
// • A [Message] is a reflective view over a concrete message instance.
// Generated messages implement [ProtoMessage], which can convert to a [Message].
// Just as how Go's [reflect.Value] is a reflective view over a Go value,
// a [Message] is a reflective view over a concrete protobuf message instance.
// Using Go reflection as an analogy, the [ProtoMessage.ProtoReflect] method is similar to
// calling [reflect.ValueOf], and the [Message.Interface] method is similar to
// calling [reflect.Value.Interface].
//
// ┌── TypeDescriptor() ──┐ ┌───── Descriptor() ─────┐
// │ V │ V
// ╔═══════════════╗ ╔═════════════════════════╗ ╔═════════════════════╗
// ║ ExtensionType ║ ║ ExtensionTypeDescriptor ║ ║ ExtensionDescriptor ║
// ╚═══════════════╝ ╚═════════════════════════╝ ╚═════════════════════╝
// Λ │ │ Λ │ Λ
// └─────── Type() ───────┘ │ └─── may implement ────┘ │
// │ │
// └────── implements ────────┘
//
// • An [ExtensionType] describes a concrete Go implementation of an extension.
// It has an [ExtensionTypeDescriptor] and can convert to/from
// an abstract [Value] and a Go value.
//
// • An [ExtensionTypeDescriptor] is an [ExtensionDescriptor]
// which also has an [ExtensionType].
//
// • An [ExtensionDescriptor] describes an abstract protobuf extension field and
// may not always be an [ExtensionTypeDescriptor].
package protoreflect
import (
"fmt"
"strings"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/pragma"
)
type doNotImplement pragma.DoNotImplement
// ProtoMessage is the top-level interface that all proto messages implement.
// This is declared in the protoreflect package to avoid a cyclic dependency;
// use the [google.golang.org/protobuf/proto.Message] type instead, which aliases this type.
type ProtoMessage interface{ ProtoReflect() Message }
// Syntax is the language version of the proto file.
type Syntax syntax
type syntax int8 // keep exact type opaque as the int type may change
const (
Proto2 Syntax = 2
Proto3 Syntax = 3
Editions Syntax = 4
)
// IsValid reports whether the syntax is valid.
func (s Syntax) IsValid() bool {
switch s {
case Proto2, Proto3, Editions:
return true
default:
return false
}
}
// String returns s as a proto source identifier (e.g., "proto2").
func (s Syntax) String() string {
switch s {
case Proto2:
return "proto2"
case Proto3:
return "proto3"
case Editions:
return "editions"
default:
return fmt.Sprintf("<unknown:%d>", s)
}
}
// GoString returns s as a Go source identifier (e.g., "Proto2").
func (s Syntax) GoString() string {
switch s {
case Proto2:
return "Proto2"
case Proto3:
return "Proto3"
default:
return fmt.Sprintf("Syntax(%d)", s)
}
}
// Cardinality determines whether a field is optional, required, or repeated.
type Cardinality cardinality
type cardinality int8 // keep exact type opaque as the int type may change
// Constants as defined by the google.protobuf.Cardinality enumeration.
const (
Optional Cardinality = 1 // appears zero or one times
Required Cardinality = 2 // appears exactly one time; invalid with Proto3
Repeated Cardinality = 3 // appears zero or more times
)
// IsValid reports whether the cardinality is valid.
func (c Cardinality) IsValid() bool {
switch c {
case Optional, Required, Repeated:
return true
default:
return false
}
}
// String returns c as a proto source identifier (e.g., "optional").
func (c Cardinality) String() string {
switch c {
case Optional:
return "optional"
case Required:
return "required"
case Repeated:
return "repeated"
default:
return fmt.Sprintf("<unknown:%d>", c)
}
}
// GoString returns c as a Go source identifier (e.g., "Optional").
func (c Cardinality) GoString() string {
switch c {
case Optional:
return "Optional"
case Required:
return "Required"
case Repeated:
return "Repeated"
default:
return fmt.Sprintf("Cardinality(%d)", c)
}
}
// Kind indicates the basic proto kind of a field.
type Kind kind
type kind int8 // keep exact type opaque as the int type may change
// Constants as defined by the google.protobuf.Field.Kind enumeration.
const (
BoolKind Kind = 8
EnumKind Kind = 14
Int32Kind Kind = 5
Sint32Kind Kind = 17
Uint32Kind Kind = 13
Int64Kind Kind = 3
Sint64Kind Kind = 18
Uint64Kind Kind = 4
Sfixed32Kind Kind = 15
Fixed32Kind Kind = 7
FloatKind Kind = 2
Sfixed64Kind Kind = 16
Fixed64Kind Kind = 6
DoubleKind Kind = 1
StringKind Kind = 9
BytesKind Kind = 12
MessageKind Kind = 11
GroupKind Kind = 10
)
// IsValid reports whether the kind is valid.
func (k Kind) IsValid() bool {
switch k {
case BoolKind, EnumKind,
Int32Kind, Sint32Kind, Uint32Kind,
Int64Kind, Sint64Kind, Uint64Kind,
Sfixed32Kind, Fixed32Kind, FloatKind,
Sfixed64Kind, Fixed64Kind, DoubleKind,
StringKind, BytesKind, MessageKind, GroupKind:
return true
default:
return false
}
}
// String returns k as a proto source identifier (e.g., "bool").
func (k Kind) String() string {
switch k {
case BoolKind:
return "bool"
case EnumKind:
return "enum"
case Int32Kind:
return "int32"
case Sint32Kind:
return "sint32"
case Uint32Kind:
return "uint32"
case Int64Kind:
return "int64"
case Sint64Kind:
return "sint64"
case Uint64Kind:
return "uint64"
case Sfixed32Kind:
return "sfixed32"
case Fixed32Kind:
return "fixed32"
case FloatKind:
return "float"
case Sfixed64Kind:
return "sfixed64"
case Fixed64Kind:
return "fixed64"
case DoubleKind:
return "double"
case StringKind:
return "string"
case BytesKind:
return "bytes"
case MessageKind:
return "message"
case GroupKind:
return "group"
default:
return fmt.Sprintf("<unknown:%d>", k)
}
}
// GoString returns k as a Go source identifier (e.g., "BoolKind").
func (k Kind) GoString() string {
switch k {
case BoolKind:
return "BoolKind"
case EnumKind:
return "EnumKind"
case Int32Kind:
return "Int32Kind"
case Sint32Kind:
return "Sint32Kind"
case Uint32Kind:
return "Uint32Kind"
case Int64Kind:
return "Int64Kind"
case Sint64Kind:
return "Sint64Kind"
case Uint64Kind:
return "Uint64Kind"
case Sfixed32Kind:
return "Sfixed32Kind"
case Fixed32Kind:
return "Fixed32Kind"
case FloatKind:
return "FloatKind"
case Sfixed64Kind:
return "Sfixed64Kind"
case Fixed64Kind:
return "Fixed64Kind"
case DoubleKind:
return "DoubleKind"
case StringKind:
return "StringKind"
case BytesKind:
return "BytesKind"
case MessageKind:
return "MessageKind"
case GroupKind:
return "GroupKind"
default:
return fmt.Sprintf("Kind(%d)", k)
}
}
// FieldNumber is the field number in a message.
type FieldNumber = protowire.Number
// FieldNumbers represent a list of field numbers.
type FieldNumbers interface {
// Len reports the number of fields in the list.
Len() int
// Get returns the ith field number. It panics if out of bounds.
Get(i int) FieldNumber
// Has reports whether n is within the list of fields.
Has(n FieldNumber) bool
doNotImplement
}
// FieldRanges represent a list of field number ranges.
type FieldRanges interface {
// Len reports the number of ranges in the list.
Len() int
// Get returns the ith range. It panics if out of bounds.
Get(i int) [2]FieldNumber // start inclusive; end exclusive
// Has reports whether n is within any of the ranges.
Has(n FieldNumber) bool
doNotImplement
}
// EnumNumber is the numeric value for an enum.
type EnumNumber int32
// EnumRanges represent a list of enum number ranges.
type EnumRanges interface {
// Len reports the number of ranges in the list.
Len() int
// Get returns the ith range. It panics if out of bounds.
Get(i int) [2]EnumNumber // start inclusive; end inclusive
// Has reports whether n is within any of the ranges.
Has(n EnumNumber) bool
doNotImplement
}
// Name is the short name for a proto declaration. This is not the name
// as used in Go source code, which might not be identical to the proto name.
type Name string // e.g., "Kind"
// IsValid reports whether s is a syntactically valid name.
// An empty name is invalid.
func (s Name) IsValid() bool {
return consumeIdent(string(s)) == len(s)
}
// Names represent a list of names.
type Names interface {
// Len reports the number of names in the list.
Len() int
// Get returns the ith name. It panics if out of bounds.
Get(i int) Name
// Has reports whether s matches any names in the list.
Has(s Name) bool
doNotImplement
}
// FullName is a qualified name that uniquely identifies a proto declaration.
// A qualified name is the concatenation of the proto package along with the
// fully-declared name (i.e., name of parent preceding the name of the child),
// with a '.' delimiter placed between each [Name].
//
// This should not have any leading or trailing dots.
type FullName string // e.g., "google.protobuf.Field.Kind"
// IsValid reports whether s is a syntactically valid full name.
// An empty full name is invalid.
func (s FullName) IsValid() bool {
i := consumeIdent(string(s))
if i < 0 {
return false
}
for len(s) > i {
if s[i] != '.' {
return false
}
i++
n := consumeIdent(string(s[i:]))
if n < 0 {
return false
}
i += n
}
return true
}
func consumeIdent(s string) (i int) {
if len(s) == 0 || !isLetter(s[i]) {
return -1
}
i++
for len(s) > i && isLetterDigit(s[i]) {
i++
}
return i
}
func isLetter(c byte) bool {
return c == '_' || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
}
func isLetterDigit(c byte) bool {
return isLetter(c) || ('0' <= c && c <= '9')
}
// Name returns the short name, which is the last identifier segment.
// A single segment FullName is the [Name] itself.
func (n FullName) Name() Name {
if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
return Name(n[i+1:])
}
return Name(n)
}
// Parent returns the full name with the trailing identifier removed.
// A single segment FullName has no parent.
func (n FullName) Parent() FullName {
if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
return n[:i]
}
return ""
}
// Append returns the qualified name appended with the provided short name.
//
// Invariant: n == n.Parent().Append(n.Name()) // assuming n is valid
func (n FullName) Append(s Name) FullName {
if n == "" {
return FullName(s)
}
return n + "." + FullName(s)
}
// 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 protoreflect
import (
"strconv"
)
// SourceLocations is a list of source locations.
type SourceLocations interface {
// Len reports the number of source locations in the proto file.
Len() int
// Get returns the ith SourceLocation. It panics if out of bounds.
Get(int) SourceLocation
// ByPath returns the SourceLocation for the given path,
// returning the first location if multiple exist for the same path.
// If multiple locations exist for the same path,
// then SourceLocation.Next index can be used to identify the
// index of the next SourceLocation.
// If no location exists for this path, it returns the zero value.
ByPath(path SourcePath) SourceLocation
// ByDescriptor returns the SourceLocation for the given descriptor,
// returning the first location if multiple exist for the same path.
// If no location exists for this descriptor, it returns the zero value.
ByDescriptor(desc Descriptor) SourceLocation
doNotImplement
}
// SourceLocation describes a source location and
// corresponds with the google.protobuf.SourceCodeInfo.Location message.
type SourceLocation struct {
// Path is the path to the declaration from the root file descriptor.
// The contents of this slice must not be mutated.
Path SourcePath
// StartLine and StartColumn are the zero-indexed starting location
// in the source file for the declaration.
StartLine, StartColumn int
// EndLine and EndColumn are the zero-indexed ending location
// in the source file for the declaration.
// In the descriptor.proto, the end line may be omitted if it is identical
// to the start line. Here, it is always populated.
EndLine, EndColumn int
// LeadingDetachedComments are the leading detached comments
// for the declaration. The contents of this slice must not be mutated.
LeadingDetachedComments []string
// LeadingComments is the leading attached comment for the declaration.
LeadingComments string
// TrailingComments is the trailing attached comment for the declaration.
TrailingComments string
// Next is an index into SourceLocations for the next source location that
// has the same Path. It is zero if there is no next location.
Next int
}
// SourcePath identifies part of a file descriptor for a source location.
// The SourcePath is a sequence of either field numbers or indexes into
// a repeated field that form a path starting from the root file descriptor.
//
// See google.protobuf.SourceCodeInfo.Location.path.
type SourcePath []int32
// Equal reports whether p1 equals p2.
func (p1 SourcePath) Equal(p2 SourcePath) bool {
if len(p1) != len(p2) {
return false
}
for i := range p1 {
if p1[i] != p2[i] {
return false
}
}
return true
}
// String formats the path in a humanly readable manner.
// The output is guaranteed to be deterministic,
// making it suitable for use as a key into a Go map.
// It is not guaranteed to be stable as the exact output could change
// in a future version of this module.
//
// Example output:
//
// .message_type[6].nested_type[15].field[3]
func (p SourcePath) String() string {
b := p.appendFileDescriptorProto(nil)
for _, i := range p {
b = append(b, '.')
b = strconv.AppendInt(b, int64(i), 10)
}
return string(b)
}
type appendFunc func(*SourcePath, []byte) []byte
func (p *SourcePath) appendSingularField(b []byte, name string, f appendFunc) []byte {
if len(*p) == 0 {
return b
}
b = append(b, '.')
b = append(b, name...)
*p = (*p)[1:]
if f != nil {
b = f(p, b)
}
return b
}
func (p *SourcePath) appendRepeatedField(b []byte, name string, f appendFunc) []byte {
b = p.appendSingularField(b, name, nil)
if len(*p) == 0 || (*p)[0] < 0 {
return b
}
b = append(b, '[')
b = strconv.AppendUint(b, uint64((*p)[0]), 10)
b = append(b, ']')
*p = (*p)[1:]
if f != nil {
b = f(p, b)
}
return b
}
// 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.
// Code generated by generate-protos. DO NOT EDIT.
package protoreflect
func (p *SourcePath) appendFileDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendSingularField(b, "package", nil)
case 3:
b = p.appendRepeatedField(b, "dependency", nil)
case 10:
b = p.appendRepeatedField(b, "public_dependency", nil)
case 11:
b = p.appendRepeatedField(b, "weak_dependency", nil)
case 15:
b = p.appendRepeatedField(b, "option_dependency", nil)
case 4:
b = p.appendRepeatedField(b, "message_type", (*SourcePath).appendDescriptorProto)
case 5:
b = p.appendRepeatedField(b, "enum_type", (*SourcePath).appendEnumDescriptorProto)
case 6:
b = p.appendRepeatedField(b, "service", (*SourcePath).appendServiceDescriptorProto)
case 7:
b = p.appendRepeatedField(b, "extension", (*SourcePath).appendFieldDescriptorProto)
case 8:
b = p.appendSingularField(b, "options", (*SourcePath).appendFileOptions)
case 9:
b = p.appendSingularField(b, "source_code_info", (*SourcePath).appendSourceCodeInfo)
case 12:
b = p.appendSingularField(b, "syntax", nil)
case 14:
b = p.appendSingularField(b, "edition", nil)
}
return b
}
func (p *SourcePath) appendDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendRepeatedField(b, "field", (*SourcePath).appendFieldDescriptorProto)
case 6:
b = p.appendRepeatedField(b, "extension", (*SourcePath).appendFieldDescriptorProto)
case 3:
b = p.appendRepeatedField(b, "nested_type", (*SourcePath).appendDescriptorProto)
case 4:
b = p.appendRepeatedField(b, "enum_type", (*SourcePath).appendEnumDescriptorProto)
case 5:
b = p.appendRepeatedField(b, "extension_range", (*SourcePath).appendDescriptorProto_ExtensionRange)
case 8:
b = p.appendRepeatedField(b, "oneof_decl", (*SourcePath).appendOneofDescriptorProto)
case 7:
b = p.appendSingularField(b, "options", (*SourcePath).appendMessageOptions)
case 9:
b = p.appendRepeatedField(b, "reserved_range", (*SourcePath).appendDescriptorProto_ReservedRange)
case 10:
b = p.appendRepeatedField(b, "reserved_name", nil)
case 11:
b = p.appendSingularField(b, "visibility", nil)
}
return b
}
func (p *SourcePath) appendEnumDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendRepeatedField(b, "value", (*SourcePath).appendEnumValueDescriptorProto)
case 3:
b = p.appendSingularField(b, "options", (*SourcePath).appendEnumOptions)
case 4:
b = p.appendRepeatedField(b, "reserved_range", (*SourcePath).appendEnumDescriptorProto_EnumReservedRange)
case 5:
b = p.appendRepeatedField(b, "reserved_name", nil)
case 6:
b = p.appendSingularField(b, "visibility", nil)
}
return b
}
func (p *SourcePath) appendServiceDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendRepeatedField(b, "method", (*SourcePath).appendMethodDescriptorProto)
case 3:
b = p.appendSingularField(b, "options", (*SourcePath).appendServiceOptions)
}
return b
}
func (p *SourcePath) appendFieldDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 3:
b = p.appendSingularField(b, "number", nil)
case 4:
b = p.appendSingularField(b, "label", nil)
case 5:
b = p.appendSingularField(b, "type", nil)
case 6:
b = p.appendSingularField(b, "type_name", nil)
case 2:
b = p.appendSingularField(b, "extendee", nil)
case 7:
b = p.appendSingularField(b, "default_value", nil)
case 9:
b = p.appendSingularField(b, "oneof_index", nil)
case 10:
b = p.appendSingularField(b, "json_name", nil)
case 8:
b = p.appendSingularField(b, "options", (*SourcePath).appendFieldOptions)
case 17:
b = p.appendSingularField(b, "proto3_optional", nil)
}
return b
}
func (p *SourcePath) appendFileOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "java_package", nil)
case 8:
b = p.appendSingularField(b, "java_outer_classname", nil)
case 10:
b = p.appendSingularField(b, "java_multiple_files", nil)
case 20:
b = p.appendSingularField(b, "java_generate_equals_and_hash", nil)
case 27:
b = p.appendSingularField(b, "java_string_check_utf8", nil)
case 9:
b = p.appendSingularField(b, "optimize_for", nil)
case 11:
b = p.appendSingularField(b, "go_package", nil)
case 16:
b = p.appendSingularField(b, "cc_generic_services", nil)
case 17:
b = p.appendSingularField(b, "java_generic_services", nil)
case 18:
b = p.appendSingularField(b, "py_generic_services", nil)
case 23:
b = p.appendSingularField(b, "deprecated", nil)
case 31:
b = p.appendSingularField(b, "cc_enable_arenas", nil)
case 36:
b = p.appendSingularField(b, "objc_class_prefix", nil)
case 37:
b = p.appendSingularField(b, "csharp_namespace", nil)
case 39:
b = p.appendSingularField(b, "swift_prefix", nil)
case 40:
b = p.appendSingularField(b, "php_class_prefix", nil)
case 41:
b = p.appendSingularField(b, "php_namespace", nil)
case 44:
b = p.appendSingularField(b, "php_metadata_namespace", nil)
case 45:
b = p.appendSingularField(b, "ruby_package", nil)
case 50:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendSourceCodeInfo(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendRepeatedField(b, "location", (*SourcePath).appendSourceCodeInfo_Location)
}
return b
}
func (p *SourcePath) appendDescriptorProto_ExtensionRange(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "start", nil)
case 2:
b = p.appendSingularField(b, "end", nil)
case 3:
b = p.appendSingularField(b, "options", (*SourcePath).appendExtensionRangeOptions)
}
return b
}
func (p *SourcePath) appendOneofDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendSingularField(b, "options", (*SourcePath).appendOneofOptions)
}
return b
}
func (p *SourcePath) appendMessageOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "message_set_wire_format", nil)
case 2:
b = p.appendSingularField(b, "no_standard_descriptor_accessor", nil)
case 3:
b = p.appendSingularField(b, "deprecated", nil)
case 7:
b = p.appendSingularField(b, "map_entry", nil)
case 11:
b = p.appendSingularField(b, "deprecated_legacy_json_field_conflicts", nil)
case 12:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendDescriptorProto_ReservedRange(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "start", nil)
case 2:
b = p.appendSingularField(b, "end", nil)
}
return b
}
func (p *SourcePath) appendEnumValueDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendSingularField(b, "number", nil)
case 3:
b = p.appendSingularField(b, "options", (*SourcePath).appendEnumValueOptions)
}
return b
}
func (p *SourcePath) appendEnumOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 2:
b = p.appendSingularField(b, "allow_alias", nil)
case 3:
b = p.appendSingularField(b, "deprecated", nil)
case 6:
b = p.appendSingularField(b, "deprecated_legacy_json_field_conflicts", nil)
case 7:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendEnumDescriptorProto_EnumReservedRange(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "start", nil)
case 2:
b = p.appendSingularField(b, "end", nil)
}
return b
}
func (p *SourcePath) appendMethodDescriptorProto(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name", nil)
case 2:
b = p.appendSingularField(b, "input_type", nil)
case 3:
b = p.appendSingularField(b, "output_type", nil)
case 4:
b = p.appendSingularField(b, "options", (*SourcePath).appendMethodOptions)
case 5:
b = p.appendSingularField(b, "client_streaming", nil)
case 6:
b = p.appendSingularField(b, "server_streaming", nil)
}
return b
}
func (p *SourcePath) appendServiceOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 34:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 33:
b = p.appendSingularField(b, "deprecated", nil)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendFieldOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "ctype", nil)
case 2:
b = p.appendSingularField(b, "packed", nil)
case 6:
b = p.appendSingularField(b, "jstype", nil)
case 5:
b = p.appendSingularField(b, "lazy", nil)
case 15:
b = p.appendSingularField(b, "unverified_lazy", nil)
case 3:
b = p.appendSingularField(b, "deprecated", nil)
case 10:
b = p.appendSingularField(b, "weak", nil)
case 16:
b = p.appendSingularField(b, "debug_redact", nil)
case 17:
b = p.appendSingularField(b, "retention", nil)
case 19:
b = p.appendRepeatedField(b, "targets", nil)
case 20:
b = p.appendRepeatedField(b, "edition_defaults", (*SourcePath).appendFieldOptions_EditionDefault)
case 21:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 22:
b = p.appendSingularField(b, "feature_support", (*SourcePath).appendFieldOptions_FeatureSupport)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendFeatureSet(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "field_presence", nil)
case 2:
b = p.appendSingularField(b, "enum_type", nil)
case 3:
b = p.appendSingularField(b, "repeated_field_encoding", nil)
case 4:
b = p.appendSingularField(b, "utf8_validation", nil)
case 5:
b = p.appendSingularField(b, "message_encoding", nil)
case 6:
b = p.appendSingularField(b, "json_format", nil)
case 7:
b = p.appendSingularField(b, "enforce_naming_style", nil)
case 8:
b = p.appendSingularField(b, "default_symbol_visibility", nil)
}
return b
}
func (p *SourcePath) appendUninterpretedOption(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 2:
b = p.appendRepeatedField(b, "name", (*SourcePath).appendUninterpretedOption_NamePart)
case 3:
b = p.appendSingularField(b, "identifier_value", nil)
case 4:
b = p.appendSingularField(b, "positive_int_value", nil)
case 5:
b = p.appendSingularField(b, "negative_int_value", nil)
case 6:
b = p.appendSingularField(b, "double_value", nil)
case 7:
b = p.appendSingularField(b, "string_value", nil)
case 8:
b = p.appendSingularField(b, "aggregate_value", nil)
}
return b
}
func (p *SourcePath) appendSourceCodeInfo_Location(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendRepeatedField(b, "path", nil)
case 2:
b = p.appendRepeatedField(b, "span", nil)
case 3:
b = p.appendSingularField(b, "leading_comments", nil)
case 4:
b = p.appendSingularField(b, "trailing_comments", nil)
case 6:
b = p.appendRepeatedField(b, "leading_detached_comments", nil)
}
return b
}
func (p *SourcePath) appendExtensionRangeOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
case 2:
b = p.appendRepeatedField(b, "declaration", (*SourcePath).appendExtensionRangeOptions_Declaration)
case 50:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 3:
b = p.appendSingularField(b, "verification", nil)
}
return b
}
func (p *SourcePath) appendOneofOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendEnumValueOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "deprecated", nil)
case 2:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 3:
b = p.appendSingularField(b, "debug_redact", nil)
case 4:
b = p.appendSingularField(b, "feature_support", (*SourcePath).appendFieldOptions_FeatureSupport)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendMethodOptions(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 33:
b = p.appendSingularField(b, "deprecated", nil)
case 34:
b = p.appendSingularField(b, "idempotency_level", nil)
case 35:
b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet)
case 999:
b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption)
}
return b
}
func (p *SourcePath) appendFieldOptions_EditionDefault(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 3:
b = p.appendSingularField(b, "edition", nil)
case 2:
b = p.appendSingularField(b, "value", nil)
}
return b
}
func (p *SourcePath) appendFieldOptions_FeatureSupport(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "edition_introduced", nil)
case 2:
b = p.appendSingularField(b, "edition_deprecated", nil)
case 3:
b = p.appendSingularField(b, "deprecation_warning", nil)
case 4:
b = p.appendSingularField(b, "edition_removed", nil)
}
return b
}
func (p *SourcePath) appendUninterpretedOption_NamePart(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "name_part", nil)
case 2:
b = p.appendSingularField(b, "is_extension", nil)
}
return b
}
func (p *SourcePath) appendExtensionRangeOptions_Declaration(b []byte) []byte {
if len(*p) == 0 {
return b
}
switch (*p)[0] {
case 1:
b = p.appendSingularField(b, "number", nil)
case 2:
b = p.appendSingularField(b, "full_name", nil)
case 3:
b = p.appendSingularField(b, "type", nil)
case 5:
b = p.appendSingularField(b, "reserved", nil)
case 6:
b = p.appendSingularField(b, "repeated", nil)
}
return b
}
// Copyright 2018 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 protoreflect
import "google.golang.org/protobuf/encoding/protowire"
// Enum is a reflection interface for a concrete enum value,
// which provides type information and a getter for the enum number.
// Enum does not provide a mutable API since enums are commonly backed by
// Go constants, which are not addressable.
type Enum interface {
// Descriptor returns enum descriptor, which contains only the protobuf
// type information for the enum.
Descriptor() EnumDescriptor
// Type returns the enum type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the enum descriptor be used instead.
Type() EnumType
// Number returns the enum value as an integer.
Number() EnumNumber
}
// Message is a reflective interface for a concrete message value,
// encapsulating both type and value information for the message.
//
// Accessor/mutators for individual fields are keyed by [FieldDescriptor].
// For non-extension fields, the descriptor must exactly match the
// field known by the parent message.
// For extension fields, the descriptor must implement [ExtensionTypeDescriptor],
// extend the parent message (i.e., have the same message [FullName]), and
// be within the parent's extension range.
//
// Each field [Value] can be a scalar or a composite type ([Message], [List], or [Map]).
// See [Value] for the Go types associated with a [FieldDescriptor].
// Providing a [Value] that is invalid or of an incorrect type panics.
type Message interface {
// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
Descriptor() MessageDescriptor
// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
Type() MessageType
// New returns a newly allocated and mutable empty message.
New() Message
// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
Interface() ProtoMessage
// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
Range(f func(FieldDescriptor, Value) bool)
// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
Has(FieldDescriptor) bool
// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
Clear(FieldDescriptor)
// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
Get(FieldDescriptor) Value
// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
Set(FieldDescriptor, Value)
// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
Mutable(FieldDescriptor) Value
// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
NewField(FieldDescriptor) Value
// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
WhichOneof(OneofDescriptor) FieldDescriptor
// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
GetUnknown() RawFields
// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
SetUnknown(RawFields)
// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
IsValid() bool
// ProtoMethods returns optional fast-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// [google.golang.org/protobuf/runtime/protoiface.Methods].
// Consult the protoiface package documentation for details.
ProtoMethods() *methods
}
// RawFields is the raw bytes for an ordered sequence of fields.
// Each field contains both the tag (representing field number and wire type),
// and also the wire data itself.
type RawFields []byte
// IsValid reports whether b is syntactically correct wire format.
func (b RawFields) IsValid() bool {
for len(b) > 0 {
_, _, n := protowire.ConsumeField(b)
if n < 0 {
return false
}
b = b[n:]
}
return true
}
// List is a zero-indexed, ordered list.
// The element [Value] type is determined by [FieldDescriptor.Kind].
// Providing a [Value] that is invalid or of an incorrect type panics.
type List interface {
// Len reports the number of entries in the List.
// Get, Set, and Truncate panic with out of bound indexes.
Len() int
// Get retrieves the value at the given index.
// It never returns an invalid value.
Get(int) Value
// Set stores a value for the given index.
// When setting a composite type, it is unspecified whether the set
// value aliases the source's memory in any way.
//
// Set is a mutating operation and unsafe for concurrent use.
Set(int, Value)
// Append appends the provided value to the end of the list.
// When appending a composite type, it is unspecified whether the appended
// value aliases the source's memory in any way.
//
// Append is a mutating operation and unsafe for concurrent use.
Append(Value)
// AppendMutable appends a new, empty, mutable message value to the end
// of the list and returns it.
// It panics if the list does not contain a message type.
AppendMutable() Value
// Truncate truncates the list to a smaller length.
//
// Truncate is a mutating operation and unsafe for concurrent use.
Truncate(int)
// NewElement returns a new value for a list element.
// For enums, this returns the first enum value.
// For other scalars, this returns the zero value.
// For messages, this returns a new, empty, mutable value.
NewElement() Value
// IsValid reports whether the list is valid.
//
// An invalid list is an empty, read-only value.
//
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
IsValid() bool
}
// Map is an unordered, associative map.
// The entry [MapKey] type is determined by [FieldDescriptor.MapKey].Kind.
// The entry [Value] type is determined by [FieldDescriptor.MapValue].Kind.
// Providing a [MapKey] or [Value] that is invalid or of an incorrect type panics.
type Map interface {
// Len reports the number of elements in the map.
Len() int
// Range iterates over every map entry in an undefined order,
// calling f for each key and value encountered.
// Range calls f Len times unless f returns false, which stops iteration.
// While iterating, mutating operations may only be performed
// on the current map key.
Range(f func(MapKey, Value) bool)
// Has reports whether an entry with the given key is in the map.
Has(MapKey) bool
// Clear clears the entry associated with they given key.
// The operation does nothing if there is no entry associated with the key.
//
// Clear is a mutating operation and unsafe for concurrent use.
Clear(MapKey)
// Get retrieves the value for an entry with the given key.
// It returns an invalid value for non-existent entries.
Get(MapKey) Value
// Set stores the value for an entry with the given key.
// It panics when given a key or value that is invalid or the wrong type.
// When setting a composite type, it is unspecified whether the set
// value aliases the source's memory in any way.
//
// Set is a mutating operation and unsafe for concurrent use.
Set(MapKey, Value)
// Mutable retrieves a mutable reference to the entry for the given key.
// If no entry exists for the key, it creates a new, empty, mutable value
// and stores it as the entry for the key.
// It panics if the map value is not a message.
Mutable(MapKey) Value
// NewValue returns a new value assignable as a map value.
// For enums, this returns the first enum value.
// For other scalars, this returns the zero value.
// For messages, this returns a new, empty, mutable value.
NewValue() Value
// IsValid reports whether the map is valid.
//
// An invalid map is an empty, read-only value.
//
// An invalid message often corresponds to a nil Go map value,
// but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
IsValid() bool
}
// Copyright 2022 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 protoreflect
import (
"bytes"
"fmt"
"math"
"reflect"
"google.golang.org/protobuf/encoding/protowire"
)
// Equal reports whether v1 and v2 are recursively equal.
//
// - Values of different types are always unequal.
//
// - Bytes values are equal if they contain identical bytes.
// Empty bytes (regardless of nil-ness) are considered equal.
//
// - Floating point values are equal if they contain the same value.
// Unlike the == operator, a NaN is equal to another NaN.
//
// - Enums are equal if they contain the same number.
// Since [Value] does not contain an enum descriptor,
// enum values do not consider the type of the enum.
//
// - Other scalar values are equal if they contain the same value.
//
// - [Message] values are equal if they belong to the same message descriptor,
// have the same set of populated known and extension field values,
// and the same set of unknown fields values.
//
// - [List] values are equal if they are the same length and
// each corresponding element is equal.
//
// - [Map] values are equal if they have the same set of keys and
// the corresponding value for each key is equal.
func (v1 Value) Equal(v2 Value) bool {
return equalValue(v1, v2)
}
func equalValue(x, y Value) bool {
eqType := x.typ == y.typ
switch x.typ {
case nilType:
return eqType
case boolType:
return eqType && x.Bool() == y.Bool()
case int32Type, int64Type:
return eqType && x.Int() == y.Int()
case uint32Type, uint64Type:
return eqType && x.Uint() == y.Uint()
case float32Type, float64Type:
return eqType && equalFloat(x.Float(), y.Float())
case stringType:
return eqType && x.String() == y.String()
case bytesType:
return eqType && bytes.Equal(x.Bytes(), y.Bytes())
case enumType:
return eqType && x.Enum() == y.Enum()
default:
switch x := x.Interface().(type) {
case Message:
y, ok := y.Interface().(Message)
return ok && equalMessage(x, y)
case List:
y, ok := y.Interface().(List)
return ok && equalList(x, y)
case Map:
y, ok := y.Interface().(Map)
return ok && equalMap(x, y)
default:
panic(fmt.Sprintf("unknown type: %T", x))
}
}
}
// equalFloat compares two floats, where NaNs are treated as equal.
func equalFloat(x, y float64) bool {
if math.IsNaN(x) || math.IsNaN(y) {
return math.IsNaN(x) && math.IsNaN(y)
}
return x == y
}
// equalMessage compares two messages.
func equalMessage(mx, my Message) bool {
if mx.Descriptor() != my.Descriptor() {
return false
}
nx := 0
equal := true
mx.Range(func(fd FieldDescriptor, vx Value) bool {
nx++
vy := my.Get(fd)
equal = my.Has(fd) && equalValue(vx, vy)
return equal
})
if !equal {
return false
}
ny := 0
my.Range(func(fd FieldDescriptor, vx Value) bool {
ny++
return true
})
if nx != ny {
return false
}
return equalUnknown(mx.GetUnknown(), my.GetUnknown())
}
// equalList compares two lists.
func equalList(x, y List) bool {
if x.Len() != y.Len() {
return false
}
for i := x.Len() - 1; i >= 0; i-- {
if !equalValue(x.Get(i), y.Get(i)) {
return false
}
}
return true
}
// equalMap compares two maps.
func equalMap(x, y Map) bool {
if x.Len() != y.Len() {
return false
}
equal := true
x.Range(func(k MapKey, vx Value) bool {
vy := y.Get(k)
equal = y.Has(k) && equalValue(vx, vy)
return equal
})
return equal
}
// equalUnknown compares unknown fields by direct comparison on the raw bytes
// of each individual field number.
func equalUnknown(x, y RawFields) bool {
if len(x) != len(y) {
return false
}
if bytes.Equal([]byte(x), []byte(y)) {
return true
}
mx := make(map[FieldNumber]RawFields)
my := make(map[FieldNumber]RawFields)
for len(x) > 0 {
fnum, _, n := protowire.ConsumeField(x)
mx[fnum] = append(mx[fnum], x[:n]...)
x = x[n:]
}
for len(y) > 0 {
fnum, _, n := protowire.ConsumeField(y)
my[fnum] = append(my[fnum], y[:n]...)
y = y[n:]
}
return reflect.DeepEqual(mx, my)
}
// Copyright 2018 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 protoreflect
import (
"fmt"
"math"
)
// Value is a union where only one Go type may be set at a time.
// The Value is used to represent all possible values a field may take.
// The following shows which Go type is used to represent each proto [Kind]:
//
// ╔════════════╤═════════════════════════════════════╗
// ║ Go type │ Protobuf kind ║
// ╠════════════╪═════════════════════════════════════╣
// ║ bool │ BoolKind ║
// ║ int32 │ Int32Kind, Sint32Kind, Sfixed32Kind ║
// ║ int64 │ Int64Kind, Sint64Kind, Sfixed64Kind ║
// ║ uint32 │ Uint32Kind, Fixed32Kind ║
// ║ uint64 │ Uint64Kind, Fixed64Kind ║
// ║ float32 │ FloatKind ║
// ║ float64 │ DoubleKind ║
// ║ string │ StringKind ║
// ║ []byte │ BytesKind ║
// ║ EnumNumber │ EnumKind ║
// ║ Message │ MessageKind, GroupKind ║
// ╚════════════╧═════════════════════════════════════╝
//
// Multiple protobuf Kinds may be represented by a single Go type if the type
// can losslessly represent the information for the proto kind. For example,
// [Int64Kind], [Sint64Kind], and [Sfixed64Kind] are all represented by int64,
// but use different integer encoding methods.
//
// The [List] or [Map] types are used if the field cardinality is repeated.
// A field is a [List] if [FieldDescriptor.IsList] reports true.
// A field is a [Map] if [FieldDescriptor.IsMap] reports true.
//
// Converting to/from a Value and a concrete Go value panics on type mismatch.
// For example, [ValueOf]("hello").Int() panics because this attempts to
// retrieve an int64 from a string.
//
// [List], [Map], and [Message] Values are called "composite" values.
//
// A composite Value may alias (reference) memory at some location,
// such that changes to the Value updates the that location.
// A composite value acquired with a Mutable method, such as [Message.Mutable],
// always references the source object.
//
// For example:
//
// // Append a 0 to a "repeated int32" field.
// // Since the Value returned by Mutable is guaranteed to alias
// // the source message, modifying the Value modifies the message.
// message.Mutable(fieldDesc).List().Append(protoreflect.ValueOfInt32(0))
//
// // Assign [0] to a "repeated int32" field by creating a new Value,
// // modifying it, and assigning it.
// list := message.NewField(fieldDesc).List()
// list.Append(protoreflect.ValueOfInt32(0))
// message.Set(fieldDesc, list)
// // ERROR: Since it is not defined whether Set aliases the source,
// // appending to the List here may or may not modify the message.
// list.Append(protoreflect.ValueOfInt32(0))
//
// Some operations, such as [Message.Get], may return an "empty, read-only"
// composite Value. Modifying an empty, read-only value panics.
type Value value
// The protoreflect API uses a custom Value union type instead of any
// to keep the future open for performance optimizations. Using an any
// always incurs an allocation for primitives (e.g., int64) since it needs to
// be boxed on the heap (as interfaces can only contain pointers natively).
// Instead, we represent the Value union as a flat struct that internally keeps
// track of which type is set. Using unsafe, the Value union can be reduced
// down to 24B, which is identical in size to a slice.
//
// The latest compiler (Go1.11) currently suffers from some limitations:
// • With inlining, the compiler should be able to statically prove that
// only one of these switch cases are taken and inline one specific case.
// See https://golang.org/issue/22310.
// ValueOf returns a Value initialized with the concrete value stored in v.
// This panics if the type does not match one of the allowed types in the
// Value union.
func ValueOf(v any) Value {
switch v := v.(type) {
case nil:
return Value{}
case bool:
return ValueOfBool(v)
case int32:
return ValueOfInt32(v)
case int64:
return ValueOfInt64(v)
case uint32:
return ValueOfUint32(v)
case uint64:
return ValueOfUint64(v)
case float32:
return ValueOfFloat32(v)
case float64:
return ValueOfFloat64(v)
case string:
return ValueOfString(v)
case []byte:
return ValueOfBytes(v)
case EnumNumber:
return ValueOfEnum(v)
case Message, List, Map:
return valueOfIface(v)
case ProtoMessage:
panic(fmt.Sprintf("invalid proto.Message(%T) type, expected a protoreflect.Message type", v))
default:
panic(fmt.Sprintf("invalid type: %T", v))
}
}
// ValueOfBool returns a new boolean value.
func ValueOfBool(v bool) Value {
if v {
return Value{typ: boolType, num: 1}
} else {
return Value{typ: boolType, num: 0}
}
}
// ValueOfInt32 returns a new int32 value.
func ValueOfInt32(v int32) Value {
return Value{typ: int32Type, num: uint64(v)}
}
// ValueOfInt64 returns a new int64 value.
func ValueOfInt64(v int64) Value {
return Value{typ: int64Type, num: uint64(v)}
}
// ValueOfUint32 returns a new uint32 value.
func ValueOfUint32(v uint32) Value {
return Value{typ: uint32Type, num: uint64(v)}
}
// ValueOfUint64 returns a new uint64 value.
func ValueOfUint64(v uint64) Value {
return Value{typ: uint64Type, num: v}
}
// ValueOfFloat32 returns a new float32 value.
func ValueOfFloat32(v float32) Value {
return Value{typ: float32Type, num: uint64(math.Float64bits(float64(v)))}
}
// ValueOfFloat64 returns a new float64 value.
func ValueOfFloat64(v float64) Value {
return Value{typ: float64Type, num: uint64(math.Float64bits(float64(v)))}
}
// ValueOfString returns a new string value.
func ValueOfString(v string) Value {
return valueOfString(v)
}
// ValueOfBytes returns a new bytes value.
func ValueOfBytes(v []byte) Value {
return valueOfBytes(v[:len(v):len(v)])
}
// ValueOfEnum returns a new enum value.
func ValueOfEnum(v EnumNumber) Value {
return Value{typ: enumType, num: uint64(v)}
}
// ValueOfMessage returns a new Message value.
func ValueOfMessage(v Message) Value {
return valueOfIface(v)
}
// ValueOfList returns a new List value.
func ValueOfList(v List) Value {
return valueOfIface(v)
}
// ValueOfMap returns a new Map value.
func ValueOfMap(v Map) Value {
return valueOfIface(v)
}
// IsValid reports whether v is populated with a value.
func (v Value) IsValid() bool {
return v.typ != nilType
}
// Interface returns v as an any.
//
// Invariant: v == ValueOf(v).Interface()
func (v Value) Interface() any {
switch v.typ {
case nilType:
return nil
case boolType:
return v.Bool()
case int32Type:
return int32(v.Int())
case int64Type:
return int64(v.Int())
case uint32Type:
return uint32(v.Uint())
case uint64Type:
return uint64(v.Uint())
case float32Type:
return float32(v.Float())
case float64Type:
return float64(v.Float())
case stringType:
return v.String()
case bytesType:
return v.Bytes()
case enumType:
return v.Enum()
default:
return v.getIface()
}
}
func (v Value) typeName() string {
switch v.typ {
case nilType:
return "nil"
case boolType:
return "bool"
case int32Type:
return "int32"
case int64Type:
return "int64"
case uint32Type:
return "uint32"
case uint64Type:
return "uint64"
case float32Type:
return "float32"
case float64Type:
return "float64"
case stringType:
return "string"
case bytesType:
return "bytes"
case enumType:
return "enum"
default:
switch v := v.getIface().(type) {
case Message:
return "message"
case List:
return "list"
case Map:
return "map"
default:
return fmt.Sprintf("<unknown: %T>", v)
}
}
}
func (v Value) panicMessage(what string) string {
return fmt.Sprintf("type mismatch: cannot convert %v to %s", v.typeName(), what)
}
// Bool returns v as a bool and panics if the type is not a bool.
func (v Value) Bool() bool {
switch v.typ {
case boolType:
return v.num > 0
default:
panic(v.panicMessage("bool"))
}
}
// Int returns v as a int64 and panics if the type is not a int32 or int64.
func (v Value) Int() int64 {
switch v.typ {
case int32Type, int64Type:
return int64(v.num)
default:
panic(v.panicMessage("int"))
}
}
// Uint returns v as a uint64 and panics if the type is not a uint32 or uint64.
func (v Value) Uint() uint64 {
switch v.typ {
case uint32Type, uint64Type:
return uint64(v.num)
default:
panic(v.panicMessage("uint"))
}
}
// Float returns v as a float64 and panics if the type is not a float32 or float64.
func (v Value) Float() float64 {
switch v.typ {
case float32Type, float64Type:
return math.Float64frombits(uint64(v.num))
default:
panic(v.panicMessage("float"))
}
}
// String returns v as a string. Since this method implements [fmt.Stringer],
// this returns the formatted string value for any non-string type.
func (v Value) String() string {
switch v.typ {
case stringType:
return v.getString()
default:
return fmt.Sprint(v.Interface())
}
}
// Bytes returns v as a []byte and panics if the type is not a []byte.
func (v Value) Bytes() []byte {
switch v.typ {
case bytesType:
return v.getBytes()
default:
panic(v.panicMessage("bytes"))
}
}
// Enum returns v as a [EnumNumber] and panics if the type is not a [EnumNumber].
func (v Value) Enum() EnumNumber {
switch v.typ {
case enumType:
return EnumNumber(v.num)
default:
panic(v.panicMessage("enum"))
}
}
// Message returns v as a [Message] and panics if the type is not a [Message].
func (v Value) Message() Message {
switch vi := v.getIface().(type) {
case Message:
return vi
default:
panic(v.panicMessage("message"))
}
}
// List returns v as a [List] and panics if the type is not a [List].
func (v Value) List() List {
switch vi := v.getIface().(type) {
case List:
return vi
default:
panic(v.panicMessage("list"))
}
}
// Map returns v as a [Map] and panics if the type is not a [Map].
func (v Value) Map() Map {
switch vi := v.getIface().(type) {
case Map:
return vi
default:
panic(v.panicMessage("map"))
}
}
// MapKey returns v as a [MapKey] and panics for invalid [MapKey] types.
func (v Value) MapKey() MapKey {
switch v.typ {
case boolType, int32Type, int64Type, uint32Type, uint64Type, stringType:
return MapKey(v)
default:
panic(v.panicMessage("map key"))
}
}
// MapKey is used to index maps, where the Go type of the MapKey must match
// the specified key [Kind] (see [MessageDescriptor.IsMapEntry]).
// The following shows what Go type is used to represent each proto [Kind]:
//
// ╔═════════╤═════════════════════════════════════╗
// ║ Go type │ Protobuf kind ║
// ╠═════════╪═════════════════════════════════════╣
// ║ bool │ BoolKind ║
// ║ int32 │ Int32Kind, Sint32Kind, Sfixed32Kind ║
// ║ int64 │ Int64Kind, Sint64Kind, Sfixed64Kind ║
// ║ uint32 │ Uint32Kind, Fixed32Kind ║
// ║ uint64 │ Uint64Kind, Fixed64Kind ║
// ║ string │ StringKind ║
// ╚═════════╧═════════════════════════════════════╝
//
// A MapKey is constructed and accessed through a [Value]:
//
// k := ValueOf("hash").MapKey() // convert string to MapKey
// s := k.String() // convert MapKey to string
//
// The MapKey is a strict subset of valid types used in [Value];
// converting a [Value] to a MapKey with an invalid type panics.
type MapKey value
// IsValid reports whether k is populated with a value.
func (k MapKey) IsValid() bool {
return Value(k).IsValid()
}
// Interface returns k as an any.
func (k MapKey) Interface() any {
return Value(k).Interface()
}
// Bool returns k as a bool and panics if the type is not a bool.
func (k MapKey) Bool() bool {
return Value(k).Bool()
}
// Int returns k as a int64 and panics if the type is not a int32 or int64.
func (k MapKey) Int() int64 {
return Value(k).Int()
}
// Uint returns k as a uint64 and panics if the type is not a uint32 or uint64.
func (k MapKey) Uint() uint64 {
return Value(k).Uint()
}
// String returns k as a string. Since this method implements [fmt.Stringer],
// this returns the formatted string value for any non-string type.
func (k MapKey) String() string {
return Value(k).String()
}
// Value returns k as a [Value].
func (k MapKey) Value() Value {
return Value(k)
}
// Copyright 2018 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 protoreflect
import (
"unsafe"
"google.golang.org/protobuf/internal/pragma"
)
type (
ifaceHeader struct {
_ [0]any // if interfaces have greater alignment than unsafe.Pointer, this will enforce it.
Type unsafe.Pointer
Data unsafe.Pointer
}
)
var (
nilType = typeOf(nil)
boolType = typeOf(*new(bool))
int32Type = typeOf(*new(int32))
int64Type = typeOf(*new(int64))
uint32Type = typeOf(*new(uint32))
uint64Type = typeOf(*new(uint64))
float32Type = typeOf(*new(float32))
float64Type = typeOf(*new(float64))
stringType = typeOf(*new(string))
bytesType = typeOf(*new([]byte))
enumType = typeOf(*new(EnumNumber))
)
// typeOf returns a pointer to the Go type information.
// The pointer is comparable and equal if and only if the types are identical.
func typeOf(t any) unsafe.Pointer {
return (*ifaceHeader)(unsafe.Pointer(&t)).Type
}
// value is a union where only one type can be represented at a time.
// The struct is 24B large on 64-bit systems and requires the minimum storage
// necessary to represent each possible type.
//
// The Go GC needs to be able to scan variables containing pointers.
// As such, pointers and non-pointers cannot be intermixed.
type value struct {
pragma.DoNotCompare // 0B
// typ stores the type of the value as a pointer to the Go type.
typ unsafe.Pointer // 8B
// ptr stores the data pointer for a String, Bytes, or interface value.
ptr unsafe.Pointer // 8B
// num stores a Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, or
// Enum value as a raw uint64.
//
// It is also used to store the length of a String or Bytes value;
// the capacity is ignored.
num uint64 // 8B
}
func valueOfString(v string) Value {
return Value{typ: stringType, ptr: unsafe.Pointer(unsafe.StringData(v)), num: uint64(len(v))}
}
func valueOfBytes(v []byte) Value {
return Value{typ: bytesType, ptr: unsafe.Pointer(unsafe.SliceData(v)), num: uint64(len(v))}
}
func valueOfIface(v any) Value {
p := (*ifaceHeader)(unsafe.Pointer(&v))
return Value{typ: p.Type, ptr: p.Data}
}
func (v Value) getString() string {
return unsafe.String((*byte)(v.ptr), v.num)
}
func (v Value) getBytes() []byte {
return unsafe.Slice((*byte)(v.ptr), v.num)
}
func (v Value) getIface() (x any) {
*(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
return x
}
// Copyright 2018 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 protoregistry provides data structures to register and lookup
// protobuf descriptor types.
//
// The [Files] registry contains file descriptors and provides the ability
// to iterate over the files or lookup a specific descriptor within the files.
// [Files] only contains protobuf descriptors and has no understanding of Go
// type information that may be associated with each descriptor.
//
// The [Types] registry contains descriptor types for which there is a known
// Go type associated with that descriptor. It provides the ability to iterate
// over the registered types or lookup a type by name.
package protoregistry
import (
"fmt"
"os"
"strings"
"sync"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/reflect/protoreflect"
)
// conflictPolicy configures the policy for handling registration conflicts.
//
// It can be over-written at compile time with a linker-initialized variable:
//
// go build -ldflags "-X google.golang.org/protobuf/reflect/protoregistry.conflictPolicy=warn"
//
// It can be over-written at program execution with an environment variable:
//
// GOLANG_PROTOBUF_REGISTRATION_CONFLICT=warn ./main
//
// Neither of the above are covered by the compatibility promise and
// may be removed in a future release of this module.
var conflictPolicy = "panic" // "panic" | "warn" | "ignore"
// ignoreConflict reports whether to ignore a registration conflict
// given the descriptor being registered and the error.
// It is a variable so that the behavior is easily overridden in another file.
var ignoreConflict = func(d protoreflect.Descriptor, err error) bool {
const env = "GOLANG_PROTOBUF_REGISTRATION_CONFLICT"
const faq = "https://protobuf.dev/reference/go/faq#namespace-conflict"
policy := conflictPolicy
if v := os.Getenv(env); v != "" {
policy = v
}
switch policy {
case "panic":
panic(fmt.Sprintf("%v\nSee %v\n", err, faq))
case "warn":
fmt.Fprintf(os.Stderr, "WARNING: %v\nSee %v\n\n", err, faq)
return true
case "ignore":
return true
default:
panic("invalid " + env + " value: " + os.Getenv(env))
}
}
var globalMutex sync.RWMutex
// GlobalFiles is a global registry of file descriptors.
var GlobalFiles *Files = new(Files)
// GlobalTypes is the registry used by default for type lookups
// unless a local registry is provided by the user.
var GlobalTypes *Types = new(Types)
// NotFound is a sentinel error value to indicate that the type was not found.
//
// Since registry lookup can happen in the critical performance path, resolvers
// must return this exact error value, not an error wrapping it.
var NotFound = errors.New("not found")
// Files is a registry for looking up or iterating over files and the
// descriptors contained within them.
// The Find and Range methods are safe for concurrent use.
type Files struct {
// The map of descsByName contains:
// EnumDescriptor
// EnumValueDescriptor
// MessageDescriptor
// ExtensionDescriptor
// ServiceDescriptor
// *packageDescriptor
//
// Note that files are stored as a slice, since a package may contain
// multiple files. Only top-level declarations are registered.
// Note that enum values are in the top-level since that are in the same
// scope as the parent enum.
descsByName map[protoreflect.FullName]any
filesByPath map[string][]protoreflect.FileDescriptor
numFiles int
}
type packageDescriptor struct {
files []protoreflect.FileDescriptor
}
// RegisterFile registers the provided file descriptor.
//
// If any descriptor within the file conflicts with the descriptor of any
// previously registered file (e.g., two enums with the same full name),
// then the file is not registered and an error is returned.
//
// It is permitted for multiple files to have the same file path.
func (r *Files) RegisterFile(file protoreflect.FileDescriptor) error {
if r == GlobalFiles {
globalMutex.Lock()
defer globalMutex.Unlock()
}
if r.descsByName == nil {
r.descsByName = map[protoreflect.FullName]any{
"": &packageDescriptor{},
}
r.filesByPath = make(map[string][]protoreflect.FileDescriptor)
}
path := file.Path()
if prev := r.filesByPath[path]; len(prev) > 0 {
r.checkGenProtoConflict(path)
err := errors.New("file %q is already registered", file.Path())
err = amendErrorWithCaller(err, prev[0], file)
if !(r == GlobalFiles && ignoreConflict(file, err)) {
return err
}
}
for name := file.Package(); name != ""; name = name.Parent() {
switch prev := r.descsByName[name]; prev.(type) {
case nil, *packageDescriptor:
default:
err := errors.New("file %q has a package name conflict over %v", file.Path(), name)
err = amendErrorWithCaller(err, prev, file)
if r == GlobalFiles && ignoreConflict(file, err) {
err = nil
}
return err
}
}
var err error
var hasConflict bool
rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
if prev := r.descsByName[d.FullName()]; prev != nil {
hasConflict = true
err = errors.New("file %q has a name conflict over %v", file.Path(), d.FullName())
err = amendErrorWithCaller(err, prev, file)
if r == GlobalFiles && ignoreConflict(d, err) {
err = nil
}
}
})
if hasConflict {
return err
}
for name := file.Package(); name != ""; name = name.Parent() {
if r.descsByName[name] == nil {
r.descsByName[name] = &packageDescriptor{}
}
}
p := r.descsByName[file.Package()].(*packageDescriptor)
p.files = append(p.files, file)
rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
r.descsByName[d.FullName()] = d
})
r.filesByPath[path] = append(r.filesByPath[path], file)
r.numFiles++
return nil
}
// Several well-known types were hosted in the google.golang.org/genproto module
// but were later moved to this module. To avoid a weak dependency on the
// genproto module (and its relatively large set of transitive dependencies),
// we rely on a registration conflict to determine whether the genproto version
// is too old (i.e., does not contain aliases to the new type declarations).
func (r *Files) checkGenProtoConflict(path string) {
if r != GlobalFiles {
return
}
var prevPath string
const prevModule = "google.golang.org/genproto"
const prevVersion = "cb27e3aa (May 26th, 2020)"
switch path {
case "google/protobuf/field_mask.proto":
prevPath = prevModule + "/protobuf/field_mask"
case "google/protobuf/api.proto":
prevPath = prevModule + "/protobuf/api"
case "google/protobuf/type.proto":
prevPath = prevModule + "/protobuf/ptype"
case "google/protobuf/source_context.proto":
prevPath = prevModule + "/protobuf/source_context"
default:
return
}
pkgName := strings.TrimSuffix(strings.TrimPrefix(path, "google/protobuf/"), ".proto")
pkgName = strings.Replace(pkgName, "_", "", -1) + "pb" // e.g., "field_mask" => "fieldmaskpb"
currPath := "google.golang.org/protobuf/types/known/" + pkgName
panic(fmt.Sprintf(""+
"duplicate registration of %q\n"+
"\n"+
"The generated definition for this file has moved:\n"+
"\tfrom: %q\n"+
"\tto: %q\n"+
"A dependency on the %q module must\n"+
"be at version %v or higher.\n"+
"\n"+
"Upgrade the dependency by running:\n"+
"\tgo get -u %v\n",
path, prevPath, currPath, prevModule, prevVersion, prevPath))
}
// FindDescriptorByName looks up a descriptor by the full name.
//
// This returns (nil, [NotFound]) if not found.
func (r *Files) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
if r == nil {
return nil, NotFound
}
if r == GlobalFiles {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
prefix := name
suffix := nameSuffix("")
for prefix != "" {
if d, ok := r.descsByName[prefix]; ok {
switch d := d.(type) {
case protoreflect.EnumDescriptor:
if d.FullName() == name {
return d, nil
}
case protoreflect.EnumValueDescriptor:
if d.FullName() == name {
return d, nil
}
case protoreflect.MessageDescriptor:
if d.FullName() == name {
return d, nil
}
if d := findDescriptorInMessage(d, suffix); d != nil && d.FullName() == name {
return d, nil
}
case protoreflect.ExtensionDescriptor:
if d.FullName() == name {
return d, nil
}
case protoreflect.ServiceDescriptor:
if d.FullName() == name {
return d, nil
}
if d := d.Methods().ByName(suffix.Pop()); d != nil && d.FullName() == name {
return d, nil
}
}
return nil, NotFound
}
prefix = prefix.Parent()
suffix = nameSuffix(name[len(prefix)+len("."):])
}
return nil, NotFound
}
func findDescriptorInMessage(md protoreflect.MessageDescriptor, suffix nameSuffix) protoreflect.Descriptor {
name := suffix.Pop()
if suffix == "" {
if ed := md.Enums().ByName(name); ed != nil {
return ed
}
for i := md.Enums().Len() - 1; i >= 0; i-- {
if vd := md.Enums().Get(i).Values().ByName(name); vd != nil {
return vd
}
}
if xd := md.Extensions().ByName(name); xd != nil {
return xd
}
if fd := md.Fields().ByName(name); fd != nil {
return fd
}
if od := md.Oneofs().ByName(name); od != nil {
return od
}
}
if md := md.Messages().ByName(name); md != nil {
if suffix == "" {
return md
}
return findDescriptorInMessage(md, suffix)
}
return nil
}
type nameSuffix string
func (s *nameSuffix) Pop() (name protoreflect.Name) {
if i := strings.IndexByte(string(*s), '.'); i >= 0 {
name, *s = protoreflect.Name((*s)[:i]), (*s)[i+1:]
} else {
name, *s = protoreflect.Name((*s)), ""
}
return name
}
// FindFileByPath looks up a file by the path.
//
// This returns (nil, [NotFound]) if not found.
// This returns an error if multiple files have the same path.
func (r *Files) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
if r == nil {
return nil, NotFound
}
if r == GlobalFiles {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
fds := r.filesByPath[path]
switch len(fds) {
case 0:
return nil, NotFound
case 1:
return fds[0], nil
default:
return nil, errors.New("multiple files named %q", path)
}
}
// NumFiles reports the number of registered files,
// including duplicate files with the same name.
func (r *Files) NumFiles() int {
if r == nil {
return 0
}
if r == GlobalFiles {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
return r.numFiles
}
// RangeFiles iterates over all registered files while f returns true.
// If multiple files have the same name, RangeFiles iterates over all of them.
// The iteration order is undefined.
func (r *Files) RangeFiles(f func(protoreflect.FileDescriptor) bool) {
if r == nil {
return
}
if r == GlobalFiles {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
for _, files := range r.filesByPath {
for _, file := range files {
if !f(file) {
return
}
}
}
}
// NumFilesByPackage reports the number of registered files in a proto package.
func (r *Files) NumFilesByPackage(name protoreflect.FullName) int {
if r == nil {
return 0
}
if r == GlobalFiles {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
p, ok := r.descsByName[name].(*packageDescriptor)
if !ok {
return 0
}
return len(p.files)
}
// RangeFilesByPackage iterates over all registered files in a given proto package
// while f returns true. The iteration order is undefined.
func (r *Files) RangeFilesByPackage(name protoreflect.FullName, f func(protoreflect.FileDescriptor) bool) {
if r == nil {
return
}
if r == GlobalFiles {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
p, ok := r.descsByName[name].(*packageDescriptor)
if !ok {
return
}
for _, file := range p.files {
if !f(file) {
return
}
}
}
// rangeTopLevelDescriptors iterates over all top-level descriptors in a file
// which will be directly entered into the registry.
func rangeTopLevelDescriptors(fd protoreflect.FileDescriptor, f func(protoreflect.Descriptor)) {
eds := fd.Enums()
for i := eds.Len() - 1; i >= 0; i-- {
f(eds.Get(i))
vds := eds.Get(i).Values()
for i := vds.Len() - 1; i >= 0; i-- {
f(vds.Get(i))
}
}
mds := fd.Messages()
for i := mds.Len() - 1; i >= 0; i-- {
f(mds.Get(i))
}
xds := fd.Extensions()
for i := xds.Len() - 1; i >= 0; i-- {
f(xds.Get(i))
}
sds := fd.Services()
for i := sds.Len() - 1; i >= 0; i-- {
f(sds.Get(i))
}
}
// MessageTypeResolver is an interface for looking up messages.
//
// A compliant implementation must deterministically return the same type
// if no error is encountered.
//
// The [Types] type implements this interface.
type MessageTypeResolver interface {
// FindMessageByName looks up a message by its full name.
// E.g., "google.protobuf.Any"
//
// This return (nil, NotFound) if not found.
FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error)
// FindMessageByURL looks up a message by a URL identifier.
// See documentation on google.protobuf.Any.type_url for the URL format.
//
// This returns (nil, NotFound) if not found.
FindMessageByURL(url string) (protoreflect.MessageType, error)
}
// ExtensionTypeResolver is an interface for looking up extensions.
//
// A compliant implementation must deterministically return the same type
// if no error is encountered.
//
// The [Types] type implements this interface.
type ExtensionTypeResolver interface {
// FindExtensionByName looks up a extension field by the field's full name.
// Note that this is the full name of the field as determined by
// where the extension is declared and is unrelated to the full name of the
// message being extended.
//
// This returns (nil, NotFound) if not found.
FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
// FindExtensionByNumber looks up a extension field by the field number
// within some parent message, identified by full name.
//
// This returns (nil, NotFound) if not found.
FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
}
var (
_ MessageTypeResolver = (*Types)(nil)
_ ExtensionTypeResolver = (*Types)(nil)
)
// Types is a registry for looking up or iterating over descriptor types.
// The Find and Range methods are safe for concurrent use.
type Types struct {
typesByName typesByName
extensionsByMessage extensionsByMessage
numEnums int
numMessages int
numExtensions int
}
type (
typesByName map[protoreflect.FullName]any
extensionsByMessage map[protoreflect.FullName]extensionsByNumber
extensionsByNumber map[protoreflect.FieldNumber]protoreflect.ExtensionType
)
// RegisterMessage registers the provided message type.
//
// If a naming conflict occurs, the type is not registered and an error is returned.
func (r *Types) RegisterMessage(mt protoreflect.MessageType) error {
// Under rare circumstances getting the descriptor might recursively
// examine the registry, so fetch it before locking.
md := mt.Descriptor()
if r == GlobalTypes {
globalMutex.Lock()
defer globalMutex.Unlock()
}
if err := r.register("message", md, mt); err != nil {
return err
}
r.numMessages++
return nil
}
// RegisterEnum registers the provided enum type.
//
// If a naming conflict occurs, the type is not registered and an error is returned.
func (r *Types) RegisterEnum(et protoreflect.EnumType) error {
// Under rare circumstances getting the descriptor might recursively
// examine the registry, so fetch it before locking.
ed := et.Descriptor()
if r == GlobalTypes {
globalMutex.Lock()
defer globalMutex.Unlock()
}
if err := r.register("enum", ed, et); err != nil {
return err
}
r.numEnums++
return nil
}
// RegisterExtension registers the provided extension type.
//
// If a naming conflict occurs, the type is not registered and an error is returned.
func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error {
// Under rare circumstances getting the descriptor might recursively
// examine the registry, so fetch it before locking.
//
// A known case where this can happen: Fetching the TypeDescriptor for a
// legacy ExtensionDesc can consult the global registry.
xd := xt.TypeDescriptor()
if r == GlobalTypes {
globalMutex.Lock()
defer globalMutex.Unlock()
}
field := xd.Number()
message := xd.ContainingMessage().FullName()
if prev := r.extensionsByMessage[message][field]; prev != nil {
err := errors.New("extension number %d is already registered on message %v", field, message)
err = amendErrorWithCaller(err, prev, xt)
if !(r == GlobalTypes && ignoreConflict(xd, err)) {
return err
}
}
if err := r.register("extension", xd, xt); err != nil {
return err
}
if r.extensionsByMessage == nil {
r.extensionsByMessage = make(extensionsByMessage)
}
if r.extensionsByMessage[message] == nil {
r.extensionsByMessage[message] = make(extensionsByNumber)
}
r.extensionsByMessage[message][field] = xt
r.numExtensions++
return nil
}
func (r *Types) register(kind string, desc protoreflect.Descriptor, typ any) error {
name := desc.FullName()
prev := r.typesByName[name]
if prev != nil {
err := errors.New("%v %v is already registered", kind, name)
err = amendErrorWithCaller(err, prev, typ)
if !(r == GlobalTypes && ignoreConflict(desc, err)) {
return err
}
}
if r.typesByName == nil {
r.typesByName = make(typesByName)
}
r.typesByName[name] = typ
return nil
}
// FindEnumByName looks up an enum by its full name.
// E.g., "google.protobuf.Field.Kind".
//
// This returns (nil, [NotFound]) if not found.
func (r *Types) FindEnumByName(enum protoreflect.FullName) (protoreflect.EnumType, error) {
if r == nil {
return nil, NotFound
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
if v := r.typesByName[enum]; v != nil {
if et, _ := v.(protoreflect.EnumType); et != nil {
return et, nil
}
return nil, errors.New("found wrong type: got %v, want enum", typeName(v))
}
return nil, NotFound
}
// FindMessageByName looks up a message by its full name,
// e.g. "google.protobuf.Any".
//
// This returns (nil, [NotFound]) if not found.
func (r *Types) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
if r == nil {
return nil, NotFound
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
if v := r.typesByName[message]; v != nil {
if mt, _ := v.(protoreflect.MessageType); mt != nil {
return mt, nil
}
return nil, errors.New("found wrong type: got %v, want message", typeName(v))
}
return nil, NotFound
}
// FindMessageByURL looks up a message by a URL identifier.
// See documentation on google.protobuf.Any.type_url for the URL format.
//
// This returns (nil, [NotFound]) if not found.
func (r *Types) FindMessageByURL(url string) (protoreflect.MessageType, error) {
// This function is similar to FindMessageByName but
// truncates anything before and including '/' in the URL.
if r == nil {
return nil, NotFound
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
message := protoreflect.FullName(url)
if i := strings.LastIndexByte(url, '/'); i >= 0 {
message = message[i+len("/"):]
}
if v := r.typesByName[message]; v != nil {
if mt, _ := v.(protoreflect.MessageType); mt != nil {
return mt, nil
}
return nil, errors.New("found wrong type: got %v, want message", typeName(v))
}
return nil, NotFound
}
// FindExtensionByName looks up a extension field by the field's full name.
// Note that this is the full name of the field as determined by
// where the extension is declared and is unrelated to the full name of the
// message being extended.
//
// This returns (nil, [NotFound]) if not found.
func (r *Types) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
if r == nil {
return nil, NotFound
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
if v := r.typesByName[field]; v != nil {
if xt, _ := v.(protoreflect.ExtensionType); xt != nil {
return xt, nil
}
// MessageSet extensions are special in that the name of the extension
// is the name of the message type used to extend the MessageSet.
// This naming scheme is used by text and JSON serialization.
//
// This feature is protected by the ProtoLegacy flag since MessageSets
// are a proto1 feature that is long deprecated.
if flags.ProtoLegacy {
if _, ok := v.(protoreflect.MessageType); ok {
field := field.Append(messageset.ExtensionName)
if v := r.typesByName[field]; v != nil {
if xt, _ := v.(protoreflect.ExtensionType); xt != nil {
if messageset.IsMessageSetExtension(xt.TypeDescriptor()) {
return xt, nil
}
}
}
}
}
return nil, errors.New("found wrong type: got %v, want extension", typeName(v))
}
return nil, NotFound
}
// FindExtensionByNumber looks up a extension field by the field number
// within some parent message, identified by full name.
//
// This returns (nil, [NotFound]) if not found.
func (r *Types) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
if r == nil {
return nil, NotFound
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
if xt, ok := r.extensionsByMessage[message][field]; ok {
return xt, nil
}
return nil, NotFound
}
// NumEnums reports the number of registered enums.
func (r *Types) NumEnums() int {
if r == nil {
return 0
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
return r.numEnums
}
// RangeEnums iterates over all registered enums while f returns true.
// Iteration order is undefined.
func (r *Types) RangeEnums(f func(protoreflect.EnumType) bool) {
if r == nil {
return
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
for _, typ := range r.typesByName {
if et, ok := typ.(protoreflect.EnumType); ok {
if !f(et) {
return
}
}
}
}
// NumMessages reports the number of registered messages.
func (r *Types) NumMessages() int {
if r == nil {
return 0
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
return r.numMessages
}
// RangeMessages iterates over all registered messages while f returns true.
// Iteration order is undefined.
func (r *Types) RangeMessages(f func(protoreflect.MessageType) bool) {
if r == nil {
return
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
for _, typ := range r.typesByName {
if mt, ok := typ.(protoreflect.MessageType); ok {
if !f(mt) {
return
}
}
}
}
// NumExtensions reports the number of registered extensions.
func (r *Types) NumExtensions() int {
if r == nil {
return 0
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
return r.numExtensions
}
// RangeExtensions iterates over all registered extensions while f returns true.
// Iteration order is undefined.
func (r *Types) RangeExtensions(f func(protoreflect.ExtensionType) bool) {
if r == nil {
return
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
for _, typ := range r.typesByName {
if xt, ok := typ.(protoreflect.ExtensionType); ok {
if !f(xt) {
return
}
}
}
}
// NumExtensionsByMessage reports the number of registered extensions for
// a given message type.
func (r *Types) NumExtensionsByMessage(message protoreflect.FullName) int {
if r == nil {
return 0
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
return len(r.extensionsByMessage[message])
}
// RangeExtensionsByMessage iterates over all registered extensions filtered
// by a given message type while f returns true. Iteration order is undefined.
func (r *Types) RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool) {
if r == nil {
return
}
if r == GlobalTypes {
globalMutex.RLock()
defer globalMutex.RUnlock()
}
for _, xt := range r.extensionsByMessage[message] {
if !f(xt) {
return
}
}
}
func typeName(t any) string {
switch t.(type) {
case protoreflect.EnumType:
return "enum"
case protoreflect.MessageType:
return "message"
case protoreflect.ExtensionType:
return "extension"
default:
return fmt.Sprintf("%T", t)
}
}
func amendErrorWithCaller(err error, prev, curr any) error {
prevPkg := goPackage(prev)
currPkg := goPackage(curr)
if prevPkg == "" || currPkg == "" || prevPkg == currPkg {
return err
}
return errors.New("%s\n\tpreviously from: %q\n\tcurrently from: %q", err, prevPkg, currPkg)
}
func goPackage(v any) string {
switch d := v.(type) {
case protoreflect.EnumType:
v = d.Descriptor()
case protoreflect.MessageType:
v = d.Descriptor()
case protoreflect.ExtensionType:
v = d.TypeDescriptor()
}
if d, ok := v.(protoreflect.Descriptor); ok {
v = d.ParentFile()
}
if d, ok := v.(interface{ GoPackagePath() string }); ok {
return d.GoPackagePath()
}
return ""
}
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// The messages in this file describe the definitions found in .proto files.
// A valid .proto file can be translated directly to a FileDescriptorProto
// without any other information (e.g. without reading its imports).
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/descriptor.proto
package descriptorpb
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
// The full set of known editions.
type Edition int32
const (
// A placeholder for an unknown edition value.
Edition_EDITION_UNKNOWN Edition = 0
// A placeholder edition for specifying default behaviors *before* a feature
// was first introduced. This is effectively an "infinite past".
Edition_EDITION_LEGACY Edition = 900
// Legacy syntax "editions". These pre-date editions, but behave much like
// distinct editions. These can't be used to specify the edition of proto
// files, but feature definitions must supply proto2/proto3 defaults for
// backwards compatibility.
Edition_EDITION_PROTO2 Edition = 998
Edition_EDITION_PROTO3 Edition = 999
// Editions that have been released. The specific values are arbitrary and
// should not be depended on, but they will always be time-ordered for easy
// comparison.
Edition_EDITION_2023 Edition = 1000
Edition_EDITION_2024 Edition = 1001
// Placeholder editions for testing feature resolution. These should not be
// used or relied on outside of tests.
Edition_EDITION_1_TEST_ONLY Edition = 1
Edition_EDITION_2_TEST_ONLY Edition = 2
Edition_EDITION_99997_TEST_ONLY Edition = 99997
Edition_EDITION_99998_TEST_ONLY Edition = 99998
Edition_EDITION_99999_TEST_ONLY Edition = 99999
// Placeholder for specifying unbounded edition support. This should only
// ever be used by plugins that can expect to never require any changes to
// support a new edition.
Edition_EDITION_MAX Edition = 2147483647
)
// Enum value maps for Edition.
var (
Edition_name = map[int32]string{
0: "EDITION_UNKNOWN",
900: "EDITION_LEGACY",
998: "EDITION_PROTO2",
999: "EDITION_PROTO3",
1000: "EDITION_2023",
1001: "EDITION_2024",
1: "EDITION_1_TEST_ONLY",
2: "EDITION_2_TEST_ONLY",
99997: "EDITION_99997_TEST_ONLY",
99998: "EDITION_99998_TEST_ONLY",
99999: "EDITION_99999_TEST_ONLY",
2147483647: "EDITION_MAX",
}
Edition_value = map[string]int32{
"EDITION_UNKNOWN": 0,
"EDITION_LEGACY": 900,
"EDITION_PROTO2": 998,
"EDITION_PROTO3": 999,
"EDITION_2023": 1000,
"EDITION_2024": 1001,
"EDITION_1_TEST_ONLY": 1,
"EDITION_2_TEST_ONLY": 2,
"EDITION_99997_TEST_ONLY": 99997,
"EDITION_99998_TEST_ONLY": 99998,
"EDITION_99999_TEST_ONLY": 99999,
"EDITION_MAX": 2147483647,
}
)
func (x Edition) Enum() *Edition {
p := new(Edition)
*p = x
return p
}
func (x Edition) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Edition) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[0].Descriptor()
}
func (Edition) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[0]
}
func (x Edition) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *Edition) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = Edition(num)
return nil
}
// Deprecated: Use Edition.Descriptor instead.
func (Edition) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0}
}
// Describes the 'visibility' of a symbol with respect to the proto import
// system. Symbols can only be imported when the visibility rules do not prevent
// it (ex: local symbols cannot be imported). Visibility modifiers can only set
// on `message` and `enum` as they are the only types available to be referenced
// from other files.
type SymbolVisibility int32
const (
SymbolVisibility_VISIBILITY_UNSET SymbolVisibility = 0
SymbolVisibility_VISIBILITY_LOCAL SymbolVisibility = 1
SymbolVisibility_VISIBILITY_EXPORT SymbolVisibility = 2
)
// Enum value maps for SymbolVisibility.
var (
SymbolVisibility_name = map[int32]string{
0: "VISIBILITY_UNSET",
1: "VISIBILITY_LOCAL",
2: "VISIBILITY_EXPORT",
}
SymbolVisibility_value = map[string]int32{
"VISIBILITY_UNSET": 0,
"VISIBILITY_LOCAL": 1,
"VISIBILITY_EXPORT": 2,
}
)
func (x SymbolVisibility) Enum() *SymbolVisibility {
p := new(SymbolVisibility)
*p = x
return p
}
func (x SymbolVisibility) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (SymbolVisibility) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor()
}
func (SymbolVisibility) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[1]
}
func (x SymbolVisibility) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *SymbolVisibility) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = SymbolVisibility(num)
return nil
}
// Deprecated: Use SymbolVisibility.Descriptor instead.
func (SymbolVisibility) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1}
}
// The verification state of the extension range.
type ExtensionRangeOptions_VerificationState int32
const (
// All the extensions of the range must be declared.
ExtensionRangeOptions_DECLARATION ExtensionRangeOptions_VerificationState = 0
ExtensionRangeOptions_UNVERIFIED ExtensionRangeOptions_VerificationState = 1
)
// Enum value maps for ExtensionRangeOptions_VerificationState.
var (
ExtensionRangeOptions_VerificationState_name = map[int32]string{
0: "DECLARATION",
1: "UNVERIFIED",
}
ExtensionRangeOptions_VerificationState_value = map[string]int32{
"DECLARATION": 0,
"UNVERIFIED": 1,
}
)
func (x ExtensionRangeOptions_VerificationState) Enum() *ExtensionRangeOptions_VerificationState {
p := new(ExtensionRangeOptions_VerificationState)
*p = x
return p
}
func (x ExtensionRangeOptions_VerificationState) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ExtensionRangeOptions_VerificationState) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor()
}
func (ExtensionRangeOptions_VerificationState) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[2]
}
func (x ExtensionRangeOptions_VerificationState) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *ExtensionRangeOptions_VerificationState) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = ExtensionRangeOptions_VerificationState(num)
return nil
}
// Deprecated: Use ExtensionRangeOptions_VerificationState.Descriptor instead.
func (ExtensionRangeOptions_VerificationState) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3, 0}
}
type FieldDescriptorProto_Type int32
const (
// 0 is reserved for errors.
// Order is weird for historical reasons.
FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
// negative values are likely.
FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3
FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
// negative values are likely.
FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5
FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8
FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9
// Tag-delimited aggregate.
// Group type is deprecated and not supported after google.protobuf. However, Proto3
// implementations should still be able to parse the group wire format and
// treat group fields as unknown fields. In Editions, the group wire format
// can be enabled via the `message_encoding` feature.
FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10
FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 // Length-delimited aggregate.
// New in version 2.
FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12
FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13
FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14
FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 // Uses ZigZag encoding.
FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 // Uses ZigZag encoding.
)
// Enum value maps for FieldDescriptorProto_Type.
var (
FieldDescriptorProto_Type_name = map[int32]string{
1: "TYPE_DOUBLE",
2: "TYPE_FLOAT",
3: "TYPE_INT64",
4: "TYPE_UINT64",
5: "TYPE_INT32",
6: "TYPE_FIXED64",
7: "TYPE_FIXED32",
8: "TYPE_BOOL",
9: "TYPE_STRING",
10: "TYPE_GROUP",
11: "TYPE_MESSAGE",
12: "TYPE_BYTES",
13: "TYPE_UINT32",
14: "TYPE_ENUM",
15: "TYPE_SFIXED32",
16: "TYPE_SFIXED64",
17: "TYPE_SINT32",
18: "TYPE_SINT64",
}
FieldDescriptorProto_Type_value = map[string]int32{
"TYPE_DOUBLE": 1,
"TYPE_FLOAT": 2,
"TYPE_INT64": 3,
"TYPE_UINT64": 4,
"TYPE_INT32": 5,
"TYPE_FIXED64": 6,
"TYPE_FIXED32": 7,
"TYPE_BOOL": 8,
"TYPE_STRING": 9,
"TYPE_GROUP": 10,
"TYPE_MESSAGE": 11,
"TYPE_BYTES": 12,
"TYPE_UINT32": 13,
"TYPE_ENUM": 14,
"TYPE_SFIXED32": 15,
"TYPE_SFIXED64": 16,
"TYPE_SINT32": 17,
"TYPE_SINT64": 18,
}
)
func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
p := new(FieldDescriptorProto_Type)
*p = x
return p
}
func (x FieldDescriptorProto_Type) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FieldDescriptorProto_Type) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor()
}
func (FieldDescriptorProto_Type) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[3]
}
func (x FieldDescriptorProto_Type) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FieldDescriptorProto_Type) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FieldDescriptorProto_Type(num)
return nil
}
// Deprecated: Use FieldDescriptorProto_Type.Descriptor instead.
func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 0}
}
type FieldDescriptorProto_Label int32
const (
// 0 is reserved for errors
FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
// The required label is only allowed in google.protobuf. In proto3 and Editions
// it's explicitly prohibited. In Editions, the `field_presence` feature
// can be used to get this behavior.
FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
)
// Enum value maps for FieldDescriptorProto_Label.
var (
FieldDescriptorProto_Label_name = map[int32]string{
1: "LABEL_OPTIONAL",
3: "LABEL_REPEATED",
2: "LABEL_REQUIRED",
}
FieldDescriptorProto_Label_value = map[string]int32{
"LABEL_OPTIONAL": 1,
"LABEL_REPEATED": 3,
"LABEL_REQUIRED": 2,
}
)
func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
p := new(FieldDescriptorProto_Label)
*p = x
return p
}
func (x FieldDescriptorProto_Label) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FieldDescriptorProto_Label) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor()
}
func (FieldDescriptorProto_Label) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[4]
}
func (x FieldDescriptorProto_Label) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FieldDescriptorProto_Label) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FieldDescriptorProto_Label(num)
return nil
}
// Deprecated: Use FieldDescriptorProto_Label.Descriptor instead.
func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 1}
}
// Generated classes can be optimized for speed or code size.
type FileOptions_OptimizeMode int32
const (
FileOptions_SPEED FileOptions_OptimizeMode = 1 // Generate complete code for parsing, serialization,
// etc.
FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 // Use ReflectionOps to implement these methods.
FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 // Generate code using MessageLite and the lite runtime.
)
// Enum value maps for FileOptions_OptimizeMode.
var (
FileOptions_OptimizeMode_name = map[int32]string{
1: "SPEED",
2: "CODE_SIZE",
3: "LITE_RUNTIME",
}
FileOptions_OptimizeMode_value = map[string]int32{
"SPEED": 1,
"CODE_SIZE": 2,
"LITE_RUNTIME": 3,
}
)
func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
p := new(FileOptions_OptimizeMode)
*p = x
return p
}
func (x FileOptions_OptimizeMode) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FileOptions_OptimizeMode) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor()
}
func (FileOptions_OptimizeMode) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[5]
}
func (x FileOptions_OptimizeMode) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FileOptions_OptimizeMode) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FileOptions_OptimizeMode(num)
return nil
}
// Deprecated: Use FileOptions_OptimizeMode.Descriptor instead.
func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10, 0}
}
type FieldOptions_CType int32
const (
// Default mode.
FieldOptions_STRING FieldOptions_CType = 0
// The option [ctype=CORD] may be applied to a non-repeated field of type
// "bytes". It indicates that in C++, the data should be stored in a Cord
// instead of a string. For very large strings, this may reduce memory
// fragmentation. It may also allow better performance when parsing from a
// Cord, or when parsing with aliasing enabled, as the parsed Cord may then
// alias the original buffer.
FieldOptions_CORD FieldOptions_CType = 1
FieldOptions_STRING_PIECE FieldOptions_CType = 2
)
// Enum value maps for FieldOptions_CType.
var (
FieldOptions_CType_name = map[int32]string{
0: "STRING",
1: "CORD",
2: "STRING_PIECE",
}
FieldOptions_CType_value = map[string]int32{
"STRING": 0,
"CORD": 1,
"STRING_PIECE": 2,
}
)
func (x FieldOptions_CType) Enum() *FieldOptions_CType {
p := new(FieldOptions_CType)
*p = x
return p
}
func (x FieldOptions_CType) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FieldOptions_CType) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[6].Descriptor()
}
func (FieldOptions_CType) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[6]
}
func (x FieldOptions_CType) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FieldOptions_CType) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FieldOptions_CType(num)
return nil
}
// Deprecated: Use FieldOptions_CType.Descriptor instead.
func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0}
}
type FieldOptions_JSType int32
const (
// Use the default type.
FieldOptions_JS_NORMAL FieldOptions_JSType = 0
// Use JavaScript strings.
FieldOptions_JS_STRING FieldOptions_JSType = 1
// Use JavaScript numbers.
FieldOptions_JS_NUMBER FieldOptions_JSType = 2
)
// Enum value maps for FieldOptions_JSType.
var (
FieldOptions_JSType_name = map[int32]string{
0: "JS_NORMAL",
1: "JS_STRING",
2: "JS_NUMBER",
}
FieldOptions_JSType_value = map[string]int32{
"JS_NORMAL": 0,
"JS_STRING": 1,
"JS_NUMBER": 2,
}
)
func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
p := new(FieldOptions_JSType)
*p = x
return p
}
func (x FieldOptions_JSType) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FieldOptions_JSType) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[7].Descriptor()
}
func (FieldOptions_JSType) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[7]
}
func (x FieldOptions_JSType) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FieldOptions_JSType) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FieldOptions_JSType(num)
return nil
}
// Deprecated: Use FieldOptions_JSType.Descriptor instead.
func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 1}
}
// If set to RETENTION_SOURCE, the option will be omitted from the binary.
type FieldOptions_OptionRetention int32
const (
FieldOptions_RETENTION_UNKNOWN FieldOptions_OptionRetention = 0
FieldOptions_RETENTION_RUNTIME FieldOptions_OptionRetention = 1
FieldOptions_RETENTION_SOURCE FieldOptions_OptionRetention = 2
)
// Enum value maps for FieldOptions_OptionRetention.
var (
FieldOptions_OptionRetention_name = map[int32]string{
0: "RETENTION_UNKNOWN",
1: "RETENTION_RUNTIME",
2: "RETENTION_SOURCE",
}
FieldOptions_OptionRetention_value = map[string]int32{
"RETENTION_UNKNOWN": 0,
"RETENTION_RUNTIME": 1,
"RETENTION_SOURCE": 2,
}
)
func (x FieldOptions_OptionRetention) Enum() *FieldOptions_OptionRetention {
p := new(FieldOptions_OptionRetention)
*p = x
return p
}
func (x FieldOptions_OptionRetention) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FieldOptions_OptionRetention) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[8].Descriptor()
}
func (FieldOptions_OptionRetention) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[8]
}
func (x FieldOptions_OptionRetention) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FieldOptions_OptionRetention) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FieldOptions_OptionRetention(num)
return nil
}
// Deprecated: Use FieldOptions_OptionRetention.Descriptor instead.
func (FieldOptions_OptionRetention) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 2}
}
// This indicates the types of entities that the field may apply to when used
// as an option. If it is unset, then the field may be freely used as an
// option on any kind of entity.
type FieldOptions_OptionTargetType int32
const (
FieldOptions_TARGET_TYPE_UNKNOWN FieldOptions_OptionTargetType = 0
FieldOptions_TARGET_TYPE_FILE FieldOptions_OptionTargetType = 1
FieldOptions_TARGET_TYPE_EXTENSION_RANGE FieldOptions_OptionTargetType = 2
FieldOptions_TARGET_TYPE_MESSAGE FieldOptions_OptionTargetType = 3
FieldOptions_TARGET_TYPE_FIELD FieldOptions_OptionTargetType = 4
FieldOptions_TARGET_TYPE_ONEOF FieldOptions_OptionTargetType = 5
FieldOptions_TARGET_TYPE_ENUM FieldOptions_OptionTargetType = 6
FieldOptions_TARGET_TYPE_ENUM_ENTRY FieldOptions_OptionTargetType = 7
FieldOptions_TARGET_TYPE_SERVICE FieldOptions_OptionTargetType = 8
FieldOptions_TARGET_TYPE_METHOD FieldOptions_OptionTargetType = 9
)
// Enum value maps for FieldOptions_OptionTargetType.
var (
FieldOptions_OptionTargetType_name = map[int32]string{
0: "TARGET_TYPE_UNKNOWN",
1: "TARGET_TYPE_FILE",
2: "TARGET_TYPE_EXTENSION_RANGE",
3: "TARGET_TYPE_MESSAGE",
4: "TARGET_TYPE_FIELD",
5: "TARGET_TYPE_ONEOF",
6: "TARGET_TYPE_ENUM",
7: "TARGET_TYPE_ENUM_ENTRY",
8: "TARGET_TYPE_SERVICE",
9: "TARGET_TYPE_METHOD",
}
FieldOptions_OptionTargetType_value = map[string]int32{
"TARGET_TYPE_UNKNOWN": 0,
"TARGET_TYPE_FILE": 1,
"TARGET_TYPE_EXTENSION_RANGE": 2,
"TARGET_TYPE_MESSAGE": 3,
"TARGET_TYPE_FIELD": 4,
"TARGET_TYPE_ONEOF": 5,
"TARGET_TYPE_ENUM": 6,
"TARGET_TYPE_ENUM_ENTRY": 7,
"TARGET_TYPE_SERVICE": 8,
"TARGET_TYPE_METHOD": 9,
}
)
func (x FieldOptions_OptionTargetType) Enum() *FieldOptions_OptionTargetType {
p := new(FieldOptions_OptionTargetType)
*p = x
return p
}
func (x FieldOptions_OptionTargetType) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FieldOptions_OptionTargetType) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[9].Descriptor()
}
func (FieldOptions_OptionTargetType) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[9]
}
func (x FieldOptions_OptionTargetType) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FieldOptions_OptionTargetType) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FieldOptions_OptionTargetType(num)
return nil
}
// Deprecated: Use FieldOptions_OptionTargetType.Descriptor instead.
func (FieldOptions_OptionTargetType) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 3}
}
// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
// or neither? HTTP based RPC implementation may choose GET verb for safe
// methods, and PUT verb for idempotent methods instead of the default POST.
type MethodOptions_IdempotencyLevel int32
const (
MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1 // implies idempotent
MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2 // idempotent, but may have side effects
)
// Enum value maps for MethodOptions_IdempotencyLevel.
var (
MethodOptions_IdempotencyLevel_name = map[int32]string{
0: "IDEMPOTENCY_UNKNOWN",
1: "NO_SIDE_EFFECTS",
2: "IDEMPOTENT",
}
MethodOptions_IdempotencyLevel_value = map[string]int32{
"IDEMPOTENCY_UNKNOWN": 0,
"NO_SIDE_EFFECTS": 1,
"IDEMPOTENT": 2,
}
)
func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
p := new(MethodOptions_IdempotencyLevel)
*p = x
return p
}
func (x MethodOptions_IdempotencyLevel) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (MethodOptions_IdempotencyLevel) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[10].Descriptor()
}
func (MethodOptions_IdempotencyLevel) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[10]
}
func (x MethodOptions_IdempotencyLevel) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = MethodOptions_IdempotencyLevel(num)
return nil
}
// Deprecated: Use MethodOptions_IdempotencyLevel.Descriptor instead.
func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17, 0}
}
type FeatureSet_FieldPresence int32
const (
FeatureSet_FIELD_PRESENCE_UNKNOWN FeatureSet_FieldPresence = 0
FeatureSet_EXPLICIT FeatureSet_FieldPresence = 1
FeatureSet_IMPLICIT FeatureSet_FieldPresence = 2
FeatureSet_LEGACY_REQUIRED FeatureSet_FieldPresence = 3
)
// Enum value maps for FeatureSet_FieldPresence.
var (
FeatureSet_FieldPresence_name = map[int32]string{
0: "FIELD_PRESENCE_UNKNOWN",
1: "EXPLICIT",
2: "IMPLICIT",
3: "LEGACY_REQUIRED",
}
FeatureSet_FieldPresence_value = map[string]int32{
"FIELD_PRESENCE_UNKNOWN": 0,
"EXPLICIT": 1,
"IMPLICIT": 2,
"LEGACY_REQUIRED": 3,
}
)
func (x FeatureSet_FieldPresence) Enum() *FeatureSet_FieldPresence {
p := new(FeatureSet_FieldPresence)
*p = x
return p
}
func (x FeatureSet_FieldPresence) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_FieldPresence) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[11].Descriptor()
}
func (FeatureSet_FieldPresence) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[11]
}
func (x FeatureSet_FieldPresence) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_FieldPresence) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_FieldPresence(num)
return nil
}
// Deprecated: Use FeatureSet_FieldPresence.Descriptor instead.
func (FeatureSet_FieldPresence) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0}
}
type FeatureSet_EnumType int32
const (
FeatureSet_ENUM_TYPE_UNKNOWN FeatureSet_EnumType = 0
FeatureSet_OPEN FeatureSet_EnumType = 1
FeatureSet_CLOSED FeatureSet_EnumType = 2
)
// Enum value maps for FeatureSet_EnumType.
var (
FeatureSet_EnumType_name = map[int32]string{
0: "ENUM_TYPE_UNKNOWN",
1: "OPEN",
2: "CLOSED",
}
FeatureSet_EnumType_value = map[string]int32{
"ENUM_TYPE_UNKNOWN": 0,
"OPEN": 1,
"CLOSED": 2,
}
)
func (x FeatureSet_EnumType) Enum() *FeatureSet_EnumType {
p := new(FeatureSet_EnumType)
*p = x
return p
}
func (x FeatureSet_EnumType) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_EnumType) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[12].Descriptor()
}
func (FeatureSet_EnumType) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[12]
}
func (x FeatureSet_EnumType) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_EnumType) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_EnumType(num)
return nil
}
// Deprecated: Use FeatureSet_EnumType.Descriptor instead.
func (FeatureSet_EnumType) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 1}
}
type FeatureSet_RepeatedFieldEncoding int32
const (
FeatureSet_REPEATED_FIELD_ENCODING_UNKNOWN FeatureSet_RepeatedFieldEncoding = 0
FeatureSet_PACKED FeatureSet_RepeatedFieldEncoding = 1
FeatureSet_EXPANDED FeatureSet_RepeatedFieldEncoding = 2
)
// Enum value maps for FeatureSet_RepeatedFieldEncoding.
var (
FeatureSet_RepeatedFieldEncoding_name = map[int32]string{
0: "REPEATED_FIELD_ENCODING_UNKNOWN",
1: "PACKED",
2: "EXPANDED",
}
FeatureSet_RepeatedFieldEncoding_value = map[string]int32{
"REPEATED_FIELD_ENCODING_UNKNOWN": 0,
"PACKED": 1,
"EXPANDED": 2,
}
)
func (x FeatureSet_RepeatedFieldEncoding) Enum() *FeatureSet_RepeatedFieldEncoding {
p := new(FeatureSet_RepeatedFieldEncoding)
*p = x
return p
}
func (x FeatureSet_RepeatedFieldEncoding) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_RepeatedFieldEncoding) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[13].Descriptor()
}
func (FeatureSet_RepeatedFieldEncoding) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[13]
}
func (x FeatureSet_RepeatedFieldEncoding) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_RepeatedFieldEncoding) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_RepeatedFieldEncoding(num)
return nil
}
// Deprecated: Use FeatureSet_RepeatedFieldEncoding.Descriptor instead.
func (FeatureSet_RepeatedFieldEncoding) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 2}
}
type FeatureSet_Utf8Validation int32
const (
FeatureSet_UTF8_VALIDATION_UNKNOWN FeatureSet_Utf8Validation = 0
FeatureSet_VERIFY FeatureSet_Utf8Validation = 2
FeatureSet_NONE FeatureSet_Utf8Validation = 3
)
// Enum value maps for FeatureSet_Utf8Validation.
var (
FeatureSet_Utf8Validation_name = map[int32]string{
0: "UTF8_VALIDATION_UNKNOWN",
2: "VERIFY",
3: "NONE",
}
FeatureSet_Utf8Validation_value = map[string]int32{
"UTF8_VALIDATION_UNKNOWN": 0,
"VERIFY": 2,
"NONE": 3,
}
)
func (x FeatureSet_Utf8Validation) Enum() *FeatureSet_Utf8Validation {
p := new(FeatureSet_Utf8Validation)
*p = x
return p
}
func (x FeatureSet_Utf8Validation) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_Utf8Validation) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[14].Descriptor()
}
func (FeatureSet_Utf8Validation) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[14]
}
func (x FeatureSet_Utf8Validation) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_Utf8Validation) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_Utf8Validation(num)
return nil
}
// Deprecated: Use FeatureSet_Utf8Validation.Descriptor instead.
func (FeatureSet_Utf8Validation) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 3}
}
type FeatureSet_MessageEncoding int32
const (
FeatureSet_MESSAGE_ENCODING_UNKNOWN FeatureSet_MessageEncoding = 0
FeatureSet_LENGTH_PREFIXED FeatureSet_MessageEncoding = 1
FeatureSet_DELIMITED FeatureSet_MessageEncoding = 2
)
// Enum value maps for FeatureSet_MessageEncoding.
var (
FeatureSet_MessageEncoding_name = map[int32]string{
0: "MESSAGE_ENCODING_UNKNOWN",
1: "LENGTH_PREFIXED",
2: "DELIMITED",
}
FeatureSet_MessageEncoding_value = map[string]int32{
"MESSAGE_ENCODING_UNKNOWN": 0,
"LENGTH_PREFIXED": 1,
"DELIMITED": 2,
}
)
func (x FeatureSet_MessageEncoding) Enum() *FeatureSet_MessageEncoding {
p := new(FeatureSet_MessageEncoding)
*p = x
return p
}
func (x FeatureSet_MessageEncoding) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_MessageEncoding) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[15].Descriptor()
}
func (FeatureSet_MessageEncoding) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[15]
}
func (x FeatureSet_MessageEncoding) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_MessageEncoding) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_MessageEncoding(num)
return nil
}
// Deprecated: Use FeatureSet_MessageEncoding.Descriptor instead.
func (FeatureSet_MessageEncoding) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 4}
}
type FeatureSet_JsonFormat int32
const (
FeatureSet_JSON_FORMAT_UNKNOWN FeatureSet_JsonFormat = 0
FeatureSet_ALLOW FeatureSet_JsonFormat = 1
FeatureSet_LEGACY_BEST_EFFORT FeatureSet_JsonFormat = 2
)
// Enum value maps for FeatureSet_JsonFormat.
var (
FeatureSet_JsonFormat_name = map[int32]string{
0: "JSON_FORMAT_UNKNOWN",
1: "ALLOW",
2: "LEGACY_BEST_EFFORT",
}
FeatureSet_JsonFormat_value = map[string]int32{
"JSON_FORMAT_UNKNOWN": 0,
"ALLOW": 1,
"LEGACY_BEST_EFFORT": 2,
}
)
func (x FeatureSet_JsonFormat) Enum() *FeatureSet_JsonFormat {
p := new(FeatureSet_JsonFormat)
*p = x
return p
}
func (x FeatureSet_JsonFormat) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_JsonFormat) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[16].Descriptor()
}
func (FeatureSet_JsonFormat) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[16]
}
func (x FeatureSet_JsonFormat) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_JsonFormat) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_JsonFormat(num)
return nil
}
// Deprecated: Use FeatureSet_JsonFormat.Descriptor instead.
func (FeatureSet_JsonFormat) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 5}
}
type FeatureSet_EnforceNamingStyle int32
const (
FeatureSet_ENFORCE_NAMING_STYLE_UNKNOWN FeatureSet_EnforceNamingStyle = 0
FeatureSet_STYLE2024 FeatureSet_EnforceNamingStyle = 1
FeatureSet_STYLE_LEGACY FeatureSet_EnforceNamingStyle = 2
)
// Enum value maps for FeatureSet_EnforceNamingStyle.
var (
FeatureSet_EnforceNamingStyle_name = map[int32]string{
0: "ENFORCE_NAMING_STYLE_UNKNOWN",
1: "STYLE2024",
2: "STYLE_LEGACY",
}
FeatureSet_EnforceNamingStyle_value = map[string]int32{
"ENFORCE_NAMING_STYLE_UNKNOWN": 0,
"STYLE2024": 1,
"STYLE_LEGACY": 2,
}
)
func (x FeatureSet_EnforceNamingStyle) Enum() *FeatureSet_EnforceNamingStyle {
p := new(FeatureSet_EnforceNamingStyle)
*p = x
return p
}
func (x FeatureSet_EnforceNamingStyle) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_EnforceNamingStyle) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[17].Descriptor()
}
func (FeatureSet_EnforceNamingStyle) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[17]
}
func (x FeatureSet_EnforceNamingStyle) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_EnforceNamingStyle) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_EnforceNamingStyle(num)
return nil
}
// Deprecated: Use FeatureSet_EnforceNamingStyle.Descriptor instead.
func (FeatureSet_EnforceNamingStyle) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 6}
}
type FeatureSet_VisibilityFeature_DefaultSymbolVisibility int32
const (
FeatureSet_VisibilityFeature_DEFAULT_SYMBOL_VISIBILITY_UNKNOWN FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 0
// Default pre-EDITION_2024, all UNSET visibility are export.
FeatureSet_VisibilityFeature_EXPORT_ALL FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 1
// All top-level symbols default to export, nested default to local.
FeatureSet_VisibilityFeature_EXPORT_TOP_LEVEL FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 2
// All symbols default to local.
FeatureSet_VisibilityFeature_LOCAL_ALL FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 3
// All symbols local by default. Nested types cannot be exported.
// With special case caveat for message { enum {} reserved 1 to max; }
// This is the recommended setting for new protos.
FeatureSet_VisibilityFeature_STRICT FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 4
)
// Enum value maps for FeatureSet_VisibilityFeature_DefaultSymbolVisibility.
var (
FeatureSet_VisibilityFeature_DefaultSymbolVisibility_name = map[int32]string{
0: "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN",
1: "EXPORT_ALL",
2: "EXPORT_TOP_LEVEL",
3: "LOCAL_ALL",
4: "STRICT",
}
FeatureSet_VisibilityFeature_DefaultSymbolVisibility_value = map[string]int32{
"DEFAULT_SYMBOL_VISIBILITY_UNKNOWN": 0,
"EXPORT_ALL": 1,
"EXPORT_TOP_LEVEL": 2,
"LOCAL_ALL": 3,
"STRICT": 4,
}
)
func (x FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Enum() *FeatureSet_VisibilityFeature_DefaultSymbolVisibility {
p := new(FeatureSet_VisibilityFeature_DefaultSymbolVisibility)
*p = x
return p
}
func (x FeatureSet_VisibilityFeature_DefaultSymbolVisibility) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[18].Descriptor()
}
func (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[18]
}
func (x FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *FeatureSet_VisibilityFeature_DefaultSymbolVisibility) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = FeatureSet_VisibilityFeature_DefaultSymbolVisibility(num)
return nil
}
// Deprecated: Use FeatureSet_VisibilityFeature_DefaultSymbolVisibility.Descriptor instead.
func (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0, 0}
}
// Represents the identified object's effect on the element in the original
// .proto file.
type GeneratedCodeInfo_Annotation_Semantic int32
const (
// There is no effect or the effect is indescribable.
GeneratedCodeInfo_Annotation_NONE GeneratedCodeInfo_Annotation_Semantic = 0
// The element is set or otherwise mutated.
GeneratedCodeInfo_Annotation_SET GeneratedCodeInfo_Annotation_Semantic = 1
// An alias to the element is returned.
GeneratedCodeInfo_Annotation_ALIAS GeneratedCodeInfo_Annotation_Semantic = 2
)
// Enum value maps for GeneratedCodeInfo_Annotation_Semantic.
var (
GeneratedCodeInfo_Annotation_Semantic_name = map[int32]string{
0: "NONE",
1: "SET",
2: "ALIAS",
}
GeneratedCodeInfo_Annotation_Semantic_value = map[string]int32{
"NONE": 0,
"SET": 1,
"ALIAS": 2,
}
)
func (x GeneratedCodeInfo_Annotation_Semantic) Enum() *GeneratedCodeInfo_Annotation_Semantic {
p := new(GeneratedCodeInfo_Annotation_Semantic)
*p = x
return p
}
func (x GeneratedCodeInfo_Annotation_Semantic) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (GeneratedCodeInfo_Annotation_Semantic) Descriptor() protoreflect.EnumDescriptor {
return file_google_protobuf_descriptor_proto_enumTypes[19].Descriptor()
}
func (GeneratedCodeInfo_Annotation_Semantic) Type() protoreflect.EnumType {
return &file_google_protobuf_descriptor_proto_enumTypes[19]
}
func (x GeneratedCodeInfo_Annotation_Semantic) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Do not use.
func (x *GeneratedCodeInfo_Annotation_Semantic) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = GeneratedCodeInfo_Annotation_Semantic(num)
return nil
}
// Deprecated: Use GeneratedCodeInfo_Annotation_Semantic.Descriptor instead.
func (GeneratedCodeInfo_Annotation_Semantic) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{22, 0, 0}
}
// The protocol compiler can output a FileDescriptorSet containing the .proto
// files it parses.
type FileDescriptorSet struct {
state protoimpl.MessageState `protogen:"open.v1"`
File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FileDescriptorSet) Reset() {
*x = FileDescriptorSet{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FileDescriptorSet) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FileDescriptorSet) ProtoMessage() {}
func (x *FileDescriptorSet) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FileDescriptorSet.ProtoReflect.Descriptor instead.
func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0}
}
func (x *FileDescriptorSet) GetFile() []*FileDescriptorProto {
if x != nil {
return x.File
}
return nil
}
// Describes a complete .proto file.
type FileDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // file name, relative to root of source tree
Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` // e.g. "foo", "foo.bar", etc.
// Names of files imported by this file.
Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
// Indexes of the public imported files in the dependency list above.
PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
// Indexes of the weak imported files in the dependency list.
// For Google-internal migration only. Do not use.
WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
// Names of files imported by this file purely for the purpose of providing
// option extensions. These are excluded from the dependency list above.
OptionDependency []string `protobuf:"bytes,15,rep,name=option_dependency,json=optionDependency" json:"option_dependency,omitempty"`
// All top-level definitions in this file.
MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
// This field contains optional information about the original source code.
// You may safely remove this entire field without harming runtime
// functionality of the descriptors -- the information is needed only by
// development tools.
SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
// The syntax of the proto file.
// The supported values are "proto2", "proto3", and "editions".
//
// If `edition` is present, this value must be "editions".
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
// The edition of the proto file.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Edition *Edition `protobuf:"varint,14,opt,name=edition,enum=google.protobuf.Edition" json:"edition,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FileDescriptorProto) Reset() {
*x = FileDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FileDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FileDescriptorProto) ProtoMessage() {}
func (x *FileDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FileDescriptorProto.ProtoReflect.Descriptor instead.
func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1}
}
func (x *FileDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *FileDescriptorProto) GetPackage() string {
if x != nil && x.Package != nil {
return *x.Package
}
return ""
}
func (x *FileDescriptorProto) GetDependency() []string {
if x != nil {
return x.Dependency
}
return nil
}
func (x *FileDescriptorProto) GetPublicDependency() []int32 {
if x != nil {
return x.PublicDependency
}
return nil
}
func (x *FileDescriptorProto) GetWeakDependency() []int32 {
if x != nil {
return x.WeakDependency
}
return nil
}
func (x *FileDescriptorProto) GetOptionDependency() []string {
if x != nil {
return x.OptionDependency
}
return nil
}
func (x *FileDescriptorProto) GetMessageType() []*DescriptorProto {
if x != nil {
return x.MessageType
}
return nil
}
func (x *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
if x != nil {
return x.EnumType
}
return nil
}
func (x *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
if x != nil {
return x.Service
}
return nil
}
func (x *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
if x != nil {
return x.Extension
}
return nil
}
func (x *FileDescriptorProto) GetOptions() *FileOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
if x != nil {
return x.SourceCodeInfo
}
return nil
}
func (x *FileDescriptorProto) GetSyntax() string {
if x != nil && x.Syntax != nil {
return *x.Syntax
}
return ""
}
func (x *FileDescriptorProto) GetEdition() Edition {
if x != nil && x.Edition != nil {
return *x.Edition
}
return Edition_EDITION_UNKNOWN
}
// Describes a message type.
type DescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
// Reserved field names, which may not be used by fields in the same message.
// A given name may only be reserved once.
ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
// Support for `export` and `local` keywords on enums.
Visibility *SymbolVisibility `protobuf:"varint,11,opt,name=visibility,enum=google.protobuf.SymbolVisibility" json:"visibility,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *DescriptorProto) Reset() {
*x = DescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *DescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DescriptorProto) ProtoMessage() {}
func (x *DescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DescriptorProto.ProtoReflect.Descriptor instead.
func (*DescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2}
}
func (x *DescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *DescriptorProto) GetField() []*FieldDescriptorProto {
if x != nil {
return x.Field
}
return nil
}
func (x *DescriptorProto) GetExtension() []*FieldDescriptorProto {
if x != nil {
return x.Extension
}
return nil
}
func (x *DescriptorProto) GetNestedType() []*DescriptorProto {
if x != nil {
return x.NestedType
}
return nil
}
func (x *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
if x != nil {
return x.EnumType
}
return nil
}
func (x *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
if x != nil {
return x.ExtensionRange
}
return nil
}
func (x *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
if x != nil {
return x.OneofDecl
}
return nil
}
func (x *DescriptorProto) GetOptions() *MessageOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
if x != nil {
return x.ReservedRange
}
return nil
}
func (x *DescriptorProto) GetReservedName() []string {
if x != nil {
return x.ReservedName
}
return nil
}
func (x *DescriptorProto) GetVisibility() SymbolVisibility {
if x != nil && x.Visibility != nil {
return *x.Visibility
}
return SymbolVisibility_VISIBILITY_UNSET
}
type ExtensionRangeOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
// For external users: DO NOT USE. We are in the process of open sourcing
// extension declaration and executing internal cleanups before it can be
// used externally.
Declaration []*ExtensionRangeOptions_Declaration `protobuf:"bytes,2,rep,name=declaration" json:"declaration,omitempty"`
// Any features defined in the specific edition.
Features *FeatureSet `protobuf:"bytes,50,opt,name=features" json:"features,omitempty"`
// The verification state of the range.
// TODO: flip the default to DECLARATION once all empty ranges
// are marked as UNVERIFIED.
Verification *ExtensionRangeOptions_VerificationState `protobuf:"varint,3,opt,name=verification,enum=google.protobuf.ExtensionRangeOptions_VerificationState,def=1" json:"verification,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for ExtensionRangeOptions fields.
const (
Default_ExtensionRangeOptions_Verification = ExtensionRangeOptions_UNVERIFIED
)
func (x *ExtensionRangeOptions) Reset() {
*x = ExtensionRangeOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ExtensionRangeOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ExtensionRangeOptions) ProtoMessage() {}
func (x *ExtensionRangeOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor instead.
func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3}
}
func (x *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
func (x *ExtensionRangeOptions) GetDeclaration() []*ExtensionRangeOptions_Declaration {
if x != nil {
return x.Declaration
}
return nil
}
func (x *ExtensionRangeOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *ExtensionRangeOptions) GetVerification() ExtensionRangeOptions_VerificationState {
if x != nil && x.Verification != nil {
return *x.Verification
}
return Default_ExtensionRangeOptions_Verification
}
// Describes a field within a message.
type FieldDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
// If type_name is set, this need not be set. If both this and type_name
// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
// For message and enum types, this is the name of the type. If the name
// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
// rules are used to find the type (i.e. first the nested types within this
// message are searched, then within the parent, on up to the root
// namespace).
TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
// For extensions, this is the name of the type being extended. It is
// resolved in the same manner as type_name.
Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
// For numeric types, contains the original text representation of the value.
// For booleans, "true" or "false".
// For strings, contains the default text contents (not escaped in any way).
// For bytes, contains the C escaped value. All bytes >= 128 are escaped.
DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
// If set, gives the index of a oneof in the containing type's oneof_decl
// list. This field is a member of that oneof.
OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
// JSON name of this field. The value is set by protocol compiler. If the
// user has set a "json_name" option on this field, that option's value
// will be used. Otherwise, it's deduced from the field's name by converting
// it to camelCase.
JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
// If true, this is a proto3 "optional". When a proto3 field is optional, it
// tracks presence regardless of field type.
//
// When proto3_optional is true, this field must belong to a oneof to signal
// to old proto3 clients that presence is tracked for this field. This oneof
// is known as a "synthetic" oneof, and this field must be its sole member
// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
// exist in the descriptor only, and do not generate any API. Synthetic oneofs
// must be ordered after all "real" oneofs.
//
// For message fields, proto3_optional doesn't create any semantic change,
// since non-repeated message fields always track presence. However it still
// indicates the semantic detail of whether the user wrote "optional" or not.
// This can be useful for round-tripping the .proto file. For consistency we
// give message fields a synthetic oneof also, even though it is not required
// to track presence. This is especially important because the parser can't
// tell if a field is a message or an enum, so it must always create a
// synthetic oneof.
//
// Proto2 optional fields do not set this flag, because they already indicate
// optional with `LABEL_OPTIONAL`.
Proto3Optional *bool `protobuf:"varint,17,opt,name=proto3_optional,json=proto3Optional" json:"proto3_optional,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FieldDescriptorProto) Reset() {
*x = FieldDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FieldDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FieldDescriptorProto) ProtoMessage() {}
func (x *FieldDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FieldDescriptorProto.ProtoReflect.Descriptor instead.
func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4}
}
func (x *FieldDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *FieldDescriptorProto) GetNumber() int32 {
if x != nil && x.Number != nil {
return *x.Number
}
return 0
}
func (x *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
if x != nil && x.Label != nil {
return *x.Label
}
return FieldDescriptorProto_LABEL_OPTIONAL
}
func (x *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
if x != nil && x.Type != nil {
return *x.Type
}
return FieldDescriptorProto_TYPE_DOUBLE
}
func (x *FieldDescriptorProto) GetTypeName() string {
if x != nil && x.TypeName != nil {
return *x.TypeName
}
return ""
}
func (x *FieldDescriptorProto) GetExtendee() string {
if x != nil && x.Extendee != nil {
return *x.Extendee
}
return ""
}
func (x *FieldDescriptorProto) GetDefaultValue() string {
if x != nil && x.DefaultValue != nil {
return *x.DefaultValue
}
return ""
}
func (x *FieldDescriptorProto) GetOneofIndex() int32 {
if x != nil && x.OneofIndex != nil {
return *x.OneofIndex
}
return 0
}
func (x *FieldDescriptorProto) GetJsonName() string {
if x != nil && x.JsonName != nil {
return *x.JsonName
}
return ""
}
func (x *FieldDescriptorProto) GetOptions() *FieldOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *FieldDescriptorProto) GetProto3Optional() bool {
if x != nil && x.Proto3Optional != nil {
return *x.Proto3Optional
}
return false
}
// Describes a oneof.
type OneofDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *OneofDescriptorProto) Reset() {
*x = OneofDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *OneofDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*OneofDescriptorProto) ProtoMessage() {}
func (x *OneofDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use OneofDescriptorProto.ProtoReflect.Descriptor instead.
func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{5}
}
func (x *OneofDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *OneofDescriptorProto) GetOptions() *OneofOptions {
if x != nil {
return x.Options
}
return nil
}
// Describes an enum type.
type EnumDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
// Range of reserved numeric values. Reserved numeric values may not be used
// by enum values in the same enum declaration. Reserved ranges may not
// overlap.
ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
// Reserved enum value names, which may not be reused. A given name may only
// be reserved once.
ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
// Support for `export` and `local` keywords on enums.
Visibility *SymbolVisibility `protobuf:"varint,6,opt,name=visibility,enum=google.protobuf.SymbolVisibility" json:"visibility,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EnumDescriptorProto) Reset() {
*x = EnumDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnumDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnumDescriptorProto) ProtoMessage() {}
func (x *EnumDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnumDescriptorProto.ProtoReflect.Descriptor instead.
func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6}
}
func (x *EnumDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
if x != nil {
return x.Value
}
return nil
}
func (x *EnumDescriptorProto) GetOptions() *EnumOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
if x != nil {
return x.ReservedRange
}
return nil
}
func (x *EnumDescriptorProto) GetReservedName() []string {
if x != nil {
return x.ReservedName
}
return nil
}
func (x *EnumDescriptorProto) GetVisibility() SymbolVisibility {
if x != nil && x.Visibility != nil {
return *x.Visibility
}
return SymbolVisibility_VISIBILITY_UNSET
}
// Describes a value within an enum.
type EnumValueDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EnumValueDescriptorProto) Reset() {
*x = EnumValueDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnumValueDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnumValueDescriptorProto) ProtoMessage() {}
func (x *EnumValueDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnumValueDescriptorProto.ProtoReflect.Descriptor instead.
func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{7}
}
func (x *EnumValueDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *EnumValueDescriptorProto) GetNumber() int32 {
if x != nil && x.Number != nil {
return *x.Number
}
return 0
}
func (x *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
if x != nil {
return x.Options
}
return nil
}
// Describes a service.
type ServiceDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ServiceDescriptorProto) Reset() {
*x = ServiceDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServiceDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServiceDescriptorProto) ProtoMessage() {}
func (x *ServiceDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServiceDescriptorProto.ProtoReflect.Descriptor instead.
func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{8}
}
func (x *ServiceDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
if x != nil {
return x.Method
}
return nil
}
func (x *ServiceDescriptorProto) GetOptions() *ServiceOptions {
if x != nil {
return x.Options
}
return nil
}
// Describes a method of a service.
type MethodDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Input and output type names. These are resolved in the same way as
// FieldDescriptorProto.type_name, but must refer to a message type.
InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
// Identifies if client streams multiple client messages
ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
// Identifies if server streams multiple server messages
ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for MethodDescriptorProto fields.
const (
Default_MethodDescriptorProto_ClientStreaming = bool(false)
Default_MethodDescriptorProto_ServerStreaming = bool(false)
)
func (x *MethodDescriptorProto) Reset() {
*x = MethodDescriptorProto{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MethodDescriptorProto) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MethodDescriptorProto) ProtoMessage() {}
func (x *MethodDescriptorProto) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MethodDescriptorProto.ProtoReflect.Descriptor instead.
func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{9}
}
func (x *MethodDescriptorProto) GetName() string {
if x != nil && x.Name != nil {
return *x.Name
}
return ""
}
func (x *MethodDescriptorProto) GetInputType() string {
if x != nil && x.InputType != nil {
return *x.InputType
}
return ""
}
func (x *MethodDescriptorProto) GetOutputType() string {
if x != nil && x.OutputType != nil {
return *x.OutputType
}
return ""
}
func (x *MethodDescriptorProto) GetOptions() *MethodOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *MethodDescriptorProto) GetClientStreaming() bool {
if x != nil && x.ClientStreaming != nil {
return *x.ClientStreaming
}
return Default_MethodDescriptorProto_ClientStreaming
}
func (x *MethodDescriptorProto) GetServerStreaming() bool {
if x != nil && x.ServerStreaming != nil {
return *x.ServerStreaming
}
return Default_MethodDescriptorProto_ServerStreaming
}
type FileOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Sets the Java package where classes generated from this .proto will be
// placed. By default, the proto package is used, but this is often
// inappropriate because proto packages do not normally start with backwards
// domain names.
JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
// Controls the name of the wrapper Java class generated for the .proto file.
// That class will always contain the .proto file's getDescriptor() method as
// well as any top-level extensions defined in the .proto file.
// If java_multiple_files is disabled, then all the other classes from the
// .proto file will be nested inside the single wrapper outer class.
JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
// If enabled, then the Java code generator will generate a separate .java
// file for each top-level message, enum, and service defined in the .proto
// file. Thus, these types will *not* be nested inside the wrapper class
// named by java_outer_classname. However, the wrapper class will still be
// generated to contain the file's getDescriptor() method as well as any
// top-level extensions defined in the file.
JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
// This option does nothing.
//
// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto.
JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"`
// A proto2 file can set this to true to opt in to UTF-8 checking for Java,
// which will throw an exception if invalid UTF-8 is parsed from the wire or
// assigned to a string field.
//
// TODO: clarify exactly what kinds of field types this option
// applies to, and update these docs accordingly.
//
// Proto3 files already perform these checks. Setting the option explicitly to
// false has no effect: it cannot be used to opt proto3 files out of UTF-8
// checks.
JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
// Sets the Go package where structs generated from this .proto will be
// placed. If omitted, the Go package will be derived from the following:
// - The basename of the package import path, if provided.
// - Otherwise, the package statement in the .proto file, if present.
// - Otherwise, the basename of the .proto file, without extension.
GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
// Should generic services be generated in each language? "Generic" services
// are not specific to any particular RPC system. They are generated by the
// main code generators in each language (without additional plugins).
// Generic services were the only kind of service generation supported by
// early versions of google.protobuf.
//
// Generic services are now considered deprecated in favor of using plugins
// that generate code specific to your particular RPC system. Therefore,
// these default to false. Old code which depends on generic services should
// explicitly set them to true.
CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
// Is this file deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for everything in the file, or it will be completely ignored; in the very
// least, this is a formalization for deprecating files.
Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
// Enables the use of arenas for the proto messages in this file. This applies
// only to generated classes for C++.
CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=1" json:"cc_enable_arenas,omitempty"`
// Sets the objective c class prefix which is prepended to all objective c
// generated classes from this .proto. There is no default.
ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
// Namespace for generated classes; defaults to the package.
CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
// By default Swift generators will take the proto package and CamelCase it
// replacing '.' with underscore and use that to prefix the types/symbols
// defined. When this options is provided, they will use this value instead
// to prefix the types/symbols defined.
SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
// Sets the php class prefix which is prepended to all php generated classes
// from this .proto. Default is empty.
PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
// Use this option to change the namespace of php generated classes. Default
// is empty. When this option is empty, the package name will be used for
// determining the namespace.
PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
// Use this option to change the namespace of php generated metadata classes.
// Default is empty. When this option is empty, the proto file name will be
// used for determining the namespace.
PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
// Use this option to change the package of ruby generated classes. Default
// is empty. When this option is not set, the package name will be used for
// determining the ruby package.
RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,50,opt,name=features" json:"features,omitempty"`
// The parser stores options it doesn't recognize here.
// See the documentation for the "Options" section above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for FileOptions fields.
const (
Default_FileOptions_JavaMultipleFiles = bool(false)
Default_FileOptions_JavaStringCheckUtf8 = bool(false)
Default_FileOptions_OptimizeFor = FileOptions_SPEED
Default_FileOptions_CcGenericServices = bool(false)
Default_FileOptions_JavaGenericServices = bool(false)
Default_FileOptions_PyGenericServices = bool(false)
Default_FileOptions_Deprecated = bool(false)
Default_FileOptions_CcEnableArenas = bool(true)
)
func (x *FileOptions) Reset() {
*x = FileOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FileOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FileOptions) ProtoMessage() {}
func (x *FileOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FileOptions.ProtoReflect.Descriptor instead.
func (*FileOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10}
}
func (x *FileOptions) GetJavaPackage() string {
if x != nil && x.JavaPackage != nil {
return *x.JavaPackage
}
return ""
}
func (x *FileOptions) GetJavaOuterClassname() string {
if x != nil && x.JavaOuterClassname != nil {
return *x.JavaOuterClassname
}
return ""
}
func (x *FileOptions) GetJavaMultipleFiles() bool {
if x != nil && x.JavaMultipleFiles != nil {
return *x.JavaMultipleFiles
}
return Default_FileOptions_JavaMultipleFiles
}
// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto.
func (x *FileOptions) GetJavaGenerateEqualsAndHash() bool {
if x != nil && x.JavaGenerateEqualsAndHash != nil {
return *x.JavaGenerateEqualsAndHash
}
return false
}
func (x *FileOptions) GetJavaStringCheckUtf8() bool {
if x != nil && x.JavaStringCheckUtf8 != nil {
return *x.JavaStringCheckUtf8
}
return Default_FileOptions_JavaStringCheckUtf8
}
func (x *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
if x != nil && x.OptimizeFor != nil {
return *x.OptimizeFor
}
return Default_FileOptions_OptimizeFor
}
func (x *FileOptions) GetGoPackage() string {
if x != nil && x.GoPackage != nil {
return *x.GoPackage
}
return ""
}
func (x *FileOptions) GetCcGenericServices() bool {
if x != nil && x.CcGenericServices != nil {
return *x.CcGenericServices
}
return Default_FileOptions_CcGenericServices
}
func (x *FileOptions) GetJavaGenericServices() bool {
if x != nil && x.JavaGenericServices != nil {
return *x.JavaGenericServices
}
return Default_FileOptions_JavaGenericServices
}
func (x *FileOptions) GetPyGenericServices() bool {
if x != nil && x.PyGenericServices != nil {
return *x.PyGenericServices
}
return Default_FileOptions_PyGenericServices
}
func (x *FileOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_FileOptions_Deprecated
}
func (x *FileOptions) GetCcEnableArenas() bool {
if x != nil && x.CcEnableArenas != nil {
return *x.CcEnableArenas
}
return Default_FileOptions_CcEnableArenas
}
func (x *FileOptions) GetObjcClassPrefix() string {
if x != nil && x.ObjcClassPrefix != nil {
return *x.ObjcClassPrefix
}
return ""
}
func (x *FileOptions) GetCsharpNamespace() string {
if x != nil && x.CsharpNamespace != nil {
return *x.CsharpNamespace
}
return ""
}
func (x *FileOptions) GetSwiftPrefix() string {
if x != nil && x.SwiftPrefix != nil {
return *x.SwiftPrefix
}
return ""
}
func (x *FileOptions) GetPhpClassPrefix() string {
if x != nil && x.PhpClassPrefix != nil {
return *x.PhpClassPrefix
}
return ""
}
func (x *FileOptions) GetPhpNamespace() string {
if x != nil && x.PhpNamespace != nil {
return *x.PhpNamespace
}
return ""
}
func (x *FileOptions) GetPhpMetadataNamespace() string {
if x != nil && x.PhpMetadataNamespace != nil {
return *x.PhpMetadataNamespace
}
return ""
}
func (x *FileOptions) GetRubyPackage() string {
if x != nil && x.RubyPackage != nil {
return *x.RubyPackage
}
return ""
}
func (x *FileOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type MessageOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Set true to use the old proto1 MessageSet wire format for extensions.
// This is provided for backwards-compatibility with the MessageSet wire
// format. You should not use this for any other reason: It's less
// efficient, has fewer features, and is more complicated.
//
// The message must be defined exactly as follows:
//
// message Foo {
// option message_set_wire_format = true;
// extensions 4 to max;
// }
//
// Note that the message cannot have any defined fields; MessageSets only
// have extensions.
//
// All extensions of your type must be singular messages; e.g. they cannot
// be int32s, enums, or repeated messages.
//
// Because this is an option, the above two restrictions are not enforced by
// the protocol compiler.
MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
// Disables the generation of the standard "descriptor()" accessor, which can
// conflict with a field of the same name. This is meant to make migration
// from proto1 easier; new code should avoid fields named "descriptor".
NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
// Is this message deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the message, or it will be completely ignored; in the very least,
// this is a formalization for deprecating messages.
Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
// Whether the message is an automatically generated map entry type for the
// maps field.
//
// For maps fields:
//
// map<KeyType, ValueType> map_field = 1;
//
// The parsed descriptor looks like:
//
// message MapFieldEntry {
// option map_entry = true;
// optional KeyType key = 1;
// optional ValueType value = 2;
// }
// repeated MapFieldEntry map_field = 1;
//
// Implementations may choose not to generate the map_entry=true message, but
// use a native map in the target language to hold the keys and values.
// The reflection APIs in such implementations still need to work as
// if the field is a repeated message field.
//
// NOTE: Do not set the option in .proto files. Always use the maps syntax
// instead. The option should only be implicitly set by the proto compiler
// parser.
MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
// Enable the legacy handling of JSON field name conflicts. This lowercases
// and strips underscored from the fields before comparison in proto3 only.
// The new behavior takes `json_name` into account and applies to proto2 as
// well.
//
// This should only be used as a temporary measure against broken builds due
// to the change in behavior for JSON field name conflicts.
//
// TODO This is legacy behavior we plan to remove once downstream
// teams have had time to migrate.
//
// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto.
DeprecatedLegacyJsonFieldConflicts *bool `protobuf:"varint,11,opt,name=deprecated_legacy_json_field_conflicts,json=deprecatedLegacyJsonFieldConflicts" json:"deprecated_legacy_json_field_conflicts,omitempty"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,12,opt,name=features" json:"features,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for MessageOptions fields.
const (
Default_MessageOptions_MessageSetWireFormat = bool(false)
Default_MessageOptions_NoStandardDescriptorAccessor = bool(false)
Default_MessageOptions_Deprecated = bool(false)
)
func (x *MessageOptions) Reset() {
*x = MessageOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MessageOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MessageOptions) ProtoMessage() {}
func (x *MessageOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MessageOptions.ProtoReflect.Descriptor instead.
func (*MessageOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{11}
}
func (x *MessageOptions) GetMessageSetWireFormat() bool {
if x != nil && x.MessageSetWireFormat != nil {
return *x.MessageSetWireFormat
}
return Default_MessageOptions_MessageSetWireFormat
}
func (x *MessageOptions) GetNoStandardDescriptorAccessor() bool {
if x != nil && x.NoStandardDescriptorAccessor != nil {
return *x.NoStandardDescriptorAccessor
}
return Default_MessageOptions_NoStandardDescriptorAccessor
}
func (x *MessageOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_MessageOptions_Deprecated
}
func (x *MessageOptions) GetMapEntry() bool {
if x != nil && x.MapEntry != nil {
return *x.MapEntry
}
return false
}
// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto.
func (x *MessageOptions) GetDeprecatedLegacyJsonFieldConflicts() bool {
if x != nil && x.DeprecatedLegacyJsonFieldConflicts != nil {
return *x.DeprecatedLegacyJsonFieldConflicts
}
return false
}
func (x *MessageOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type FieldOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead.
// The ctype option instructs the C++ code generator to use a different
// representation of the field than it normally would. See the specific
// options below. This option is only implemented to support use of
// [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
// type "bytes" in the open source release.
// TODO: make ctype actually deprecated.
Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
// The packed option can be enabled for repeated primitive fields to enable
// a more efficient representation on the wire. Rather than repeatedly
// writing the tag and type for each element, the entire array is encoded as
// a single length-delimited blob. In proto3, only explicit setting it to
// false will avoid using packed encoding. This option is prohibited in
// Editions, but the `repeated_field_encoding` feature can be used to control
// the behavior.
Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
// The jstype option determines the JavaScript type used for values of the
// field. The option is permitted only for 64 bit integral and fixed types
// (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
// is represented as JavaScript string, which avoids loss of precision that
// can happen when a large value is converted to a floating point JavaScript.
// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
// use the JavaScript "number" type. The behavior of the default option
// JS_NORMAL is implementation dependent.
//
// This option is an enum to permit additional types to be added, e.g.
// goog.math.Integer.
Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
// Should this field be parsed lazily? Lazy applies only to message-type
// fields. It means that when the outer message is initially parsed, the
// inner message's contents will not be parsed but instead stored in encoded
// form. The inner message will actually be parsed when it is first accessed.
//
// This is only a hint. Implementations are free to choose whether to use
// eager or lazy parsing regardless of the value of this option. However,
// setting this option true suggests that the protocol author believes that
// using lazy parsing on this field is worth the additional bookkeeping
// overhead typically needed to implement it.
//
// This option does not affect the public interface of any generated code;
// all method signatures remain the same. Furthermore, thread-safety of the
// interface is not affected by this option; const methods remain safe to
// call from multiple threads concurrently, while non-const methods continue
// to require exclusive access.
//
// Note that lazy message fields are still eagerly verified to check
// ill-formed wireformat or missing required fields. Calling IsInitialized()
// on the outer message would fail if the inner message has missing required
// fields. Failed verification would result in parsing failure (except when
// uninitialized messages are acceptable).
Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
// unverified_lazy does no correctness checks on the byte stream. This should
// only be used where lazy with verification is prohibitive for performance
// reasons.
UnverifiedLazy *bool `protobuf:"varint,15,opt,name=unverified_lazy,json=unverifiedLazy,def=0" json:"unverified_lazy,omitempty"`
// Is this field deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for accessors, or it will be completely ignored; in the very least, this
// is a formalization for deprecating fields.
Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
// For Google-internal migration only. Do not use.
Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
// Indicate that the field value should not be printed out when using debug
// formats, e.g. when the field contains sensitive credentials.
DebugRedact *bool `protobuf:"varint,16,opt,name=debug_redact,json=debugRedact,def=0" json:"debug_redact,omitempty"`
Retention *FieldOptions_OptionRetention `protobuf:"varint,17,opt,name=retention,enum=google.protobuf.FieldOptions_OptionRetention" json:"retention,omitempty"`
Targets []FieldOptions_OptionTargetType `protobuf:"varint,19,rep,name=targets,enum=google.protobuf.FieldOptions_OptionTargetType" json:"targets,omitempty"`
EditionDefaults []*FieldOptions_EditionDefault `protobuf:"bytes,20,rep,name=edition_defaults,json=editionDefaults" json:"edition_defaults,omitempty"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,21,opt,name=features" json:"features,omitempty"`
FeatureSupport *FieldOptions_FeatureSupport `protobuf:"bytes,22,opt,name=feature_support,json=featureSupport" json:"feature_support,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for FieldOptions fields.
const (
Default_FieldOptions_Ctype = FieldOptions_STRING
Default_FieldOptions_Jstype = FieldOptions_JS_NORMAL
Default_FieldOptions_Lazy = bool(false)
Default_FieldOptions_UnverifiedLazy = bool(false)
Default_FieldOptions_Deprecated = bool(false)
Default_FieldOptions_Weak = bool(false)
Default_FieldOptions_DebugRedact = bool(false)
)
func (x *FieldOptions) Reset() {
*x = FieldOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FieldOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FieldOptions) ProtoMessage() {}
func (x *FieldOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FieldOptions.ProtoReflect.Descriptor instead.
func (*FieldOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12}
}
func (x *FieldOptions) GetCtype() FieldOptions_CType {
if x != nil && x.Ctype != nil {
return *x.Ctype
}
return Default_FieldOptions_Ctype
}
func (x *FieldOptions) GetPacked() bool {
if x != nil && x.Packed != nil {
return *x.Packed
}
return false
}
func (x *FieldOptions) GetJstype() FieldOptions_JSType {
if x != nil && x.Jstype != nil {
return *x.Jstype
}
return Default_FieldOptions_Jstype
}
func (x *FieldOptions) GetLazy() bool {
if x != nil && x.Lazy != nil {
return *x.Lazy
}
return Default_FieldOptions_Lazy
}
func (x *FieldOptions) GetUnverifiedLazy() bool {
if x != nil && x.UnverifiedLazy != nil {
return *x.UnverifiedLazy
}
return Default_FieldOptions_UnverifiedLazy
}
func (x *FieldOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_FieldOptions_Deprecated
}
func (x *FieldOptions) GetWeak() bool {
if x != nil && x.Weak != nil {
return *x.Weak
}
return Default_FieldOptions_Weak
}
func (x *FieldOptions) GetDebugRedact() bool {
if x != nil && x.DebugRedact != nil {
return *x.DebugRedact
}
return Default_FieldOptions_DebugRedact
}
func (x *FieldOptions) GetRetention() FieldOptions_OptionRetention {
if x != nil && x.Retention != nil {
return *x.Retention
}
return FieldOptions_RETENTION_UNKNOWN
}
func (x *FieldOptions) GetTargets() []FieldOptions_OptionTargetType {
if x != nil {
return x.Targets
}
return nil
}
func (x *FieldOptions) GetEditionDefaults() []*FieldOptions_EditionDefault {
if x != nil {
return x.EditionDefaults
}
return nil
}
func (x *FieldOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *FieldOptions) GetFeatureSupport() *FieldOptions_FeatureSupport {
if x != nil {
return x.FeatureSupport
}
return nil
}
func (x *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type OneofOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,1,opt,name=features" json:"features,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *OneofOptions) Reset() {
*x = OneofOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *OneofOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*OneofOptions) ProtoMessage() {}
func (x *OneofOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use OneofOptions.ProtoReflect.Descriptor instead.
func (*OneofOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{13}
}
func (x *OneofOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type EnumOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Set this option to true to allow mapping different tag names to the same
// value.
AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
// Is this enum deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the enum, or it will be completely ignored; in the very least, this
// is a formalization for deprecating enums.
Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
// Enable the legacy handling of JSON field name conflicts. This lowercases
// and strips underscored from the fields before comparison in proto3 only.
// The new behavior takes `json_name` into account and applies to proto2 as
// well.
// TODO Remove this legacy behavior once downstream teams have
// had time to migrate.
//
// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto.
DeprecatedLegacyJsonFieldConflicts *bool `protobuf:"varint,6,opt,name=deprecated_legacy_json_field_conflicts,json=deprecatedLegacyJsonFieldConflicts" json:"deprecated_legacy_json_field_conflicts,omitempty"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,7,opt,name=features" json:"features,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for EnumOptions fields.
const (
Default_EnumOptions_Deprecated = bool(false)
)
func (x *EnumOptions) Reset() {
*x = EnumOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnumOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnumOptions) ProtoMessage() {}
func (x *EnumOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnumOptions.ProtoReflect.Descriptor instead.
func (*EnumOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{14}
}
func (x *EnumOptions) GetAllowAlias() bool {
if x != nil && x.AllowAlias != nil {
return *x.AllowAlias
}
return false
}
func (x *EnumOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_EnumOptions_Deprecated
}
// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto.
func (x *EnumOptions) GetDeprecatedLegacyJsonFieldConflicts() bool {
if x != nil && x.DeprecatedLegacyJsonFieldConflicts != nil {
return *x.DeprecatedLegacyJsonFieldConflicts
}
return false
}
func (x *EnumOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type EnumValueOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Is this enum value deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the enum value, or it will be completely ignored; in the very least,
// this is a formalization for deprecating enum values.
Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,2,opt,name=features" json:"features,omitempty"`
// Indicate that fields annotated with this enum value should not be printed
// out when using debug formats, e.g. when the field contains sensitive
// credentials.
DebugRedact *bool `protobuf:"varint,3,opt,name=debug_redact,json=debugRedact,def=0" json:"debug_redact,omitempty"`
// Information about the support window of a feature value.
FeatureSupport *FieldOptions_FeatureSupport `protobuf:"bytes,4,opt,name=feature_support,json=featureSupport" json:"feature_support,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for EnumValueOptions fields.
const (
Default_EnumValueOptions_Deprecated = bool(false)
Default_EnumValueOptions_DebugRedact = bool(false)
)
func (x *EnumValueOptions) Reset() {
*x = EnumValueOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnumValueOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnumValueOptions) ProtoMessage() {}
func (x *EnumValueOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor instead.
func (*EnumValueOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{15}
}
func (x *EnumValueOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_EnumValueOptions_Deprecated
}
func (x *EnumValueOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *EnumValueOptions) GetDebugRedact() bool {
if x != nil && x.DebugRedact != nil {
return *x.DebugRedact
}
return Default_EnumValueOptions_DebugRedact
}
func (x *EnumValueOptions) GetFeatureSupport() *FieldOptions_FeatureSupport {
if x != nil {
return x.FeatureSupport
}
return nil
}
func (x *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type ServiceOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,34,opt,name=features" json:"features,omitempty"`
// Is this service deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the service, or it will be completely ignored; in the very least,
// this is a formalization for deprecating services.
Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for ServiceOptions fields.
const (
Default_ServiceOptions_Deprecated = bool(false)
)
func (x *ServiceOptions) Reset() {
*x = ServiceOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServiceOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServiceOptions) ProtoMessage() {}
func (x *ServiceOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor instead.
func (*ServiceOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{16}
}
func (x *ServiceOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *ServiceOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_ServiceOptions_Deprecated
}
func (x *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
type MethodOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Is this method deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for the method, or it will be completely ignored; in the very least,
// this is a formalization for deprecating methods.
Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
// Any features defined in the specific edition.
// WARNING: This field should only be used by protobuf plugins or special
// cases like the proto compiler. Other uses are discouraged and
// developers should rely on the protoreflect APIs for their client language.
Features *FeatureSet `protobuf:"bytes,35,opt,name=features" json:"features,omitempty"`
// The parser stores options it doesn't recognize here. See above.
UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
// Default values for MethodOptions fields.
const (
Default_MethodOptions_Deprecated = bool(false)
Default_MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
)
func (x *MethodOptions) Reset() {
*x = MethodOptions{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MethodOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MethodOptions) ProtoMessage() {}
func (x *MethodOptions) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MethodOptions.ProtoReflect.Descriptor instead.
func (*MethodOptions) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17}
}
func (x *MethodOptions) GetDeprecated() bool {
if x != nil && x.Deprecated != nil {
return *x.Deprecated
}
return Default_MethodOptions_Deprecated
}
func (x *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
if x != nil && x.IdempotencyLevel != nil {
return *x.IdempotencyLevel
}
return Default_MethodOptions_IdempotencyLevel
}
func (x *MethodOptions) GetFeatures() *FeatureSet {
if x != nil {
return x.Features
}
return nil
}
func (x *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
if x != nil {
return x.UninterpretedOption
}
return nil
}
// A message representing a option the parser does not recognize. This only
// appears in options protos created by the compiler::Parser class.
// DescriptorPool resolves these when building Descriptor objects. Therefore,
// options protos in descriptor objects (e.g. returned by Descriptor::options(),
// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
// in them.
type UninterpretedOption struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
// The value of the uninterpreted option, in whatever type the tokenizer
// identified it as during parsing. Exactly one of these should be set.
IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *UninterpretedOption) Reset() {
*x = UninterpretedOption{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *UninterpretedOption) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UninterpretedOption) ProtoMessage() {}
func (x *UninterpretedOption) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UninterpretedOption.ProtoReflect.Descriptor instead.
func (*UninterpretedOption) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18}
}
func (x *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
if x != nil {
return x.Name
}
return nil
}
func (x *UninterpretedOption) GetIdentifierValue() string {
if x != nil && x.IdentifierValue != nil {
return *x.IdentifierValue
}
return ""
}
func (x *UninterpretedOption) GetPositiveIntValue() uint64 {
if x != nil && x.PositiveIntValue != nil {
return *x.PositiveIntValue
}
return 0
}
func (x *UninterpretedOption) GetNegativeIntValue() int64 {
if x != nil && x.NegativeIntValue != nil {
return *x.NegativeIntValue
}
return 0
}
func (x *UninterpretedOption) GetDoubleValue() float64 {
if x != nil && x.DoubleValue != nil {
return *x.DoubleValue
}
return 0
}
func (x *UninterpretedOption) GetStringValue() []byte {
if x != nil {
return x.StringValue
}
return nil
}
func (x *UninterpretedOption) GetAggregateValue() string {
if x != nil && x.AggregateValue != nil {
return *x.AggregateValue
}
return ""
}
// TODO Enums in C++ gencode (and potentially other languages) are
// not well scoped. This means that each of the feature enums below can clash
// with each other. The short names we've chosen maximize call-site
// readability, but leave us very open to this scenario. A future feature will
// be designed and implemented to handle this, hopefully before we ever hit a
// conflict here.
type FeatureSet struct {
state protoimpl.MessageState `protogen:"open.v1"`
FieldPresence *FeatureSet_FieldPresence `protobuf:"varint,1,opt,name=field_presence,json=fieldPresence,enum=google.protobuf.FeatureSet_FieldPresence" json:"field_presence,omitempty"`
EnumType *FeatureSet_EnumType `protobuf:"varint,2,opt,name=enum_type,json=enumType,enum=google.protobuf.FeatureSet_EnumType" json:"enum_type,omitempty"`
RepeatedFieldEncoding *FeatureSet_RepeatedFieldEncoding `protobuf:"varint,3,opt,name=repeated_field_encoding,json=repeatedFieldEncoding,enum=google.protobuf.FeatureSet_RepeatedFieldEncoding" json:"repeated_field_encoding,omitempty"`
Utf8Validation *FeatureSet_Utf8Validation `protobuf:"varint,4,opt,name=utf8_validation,json=utf8Validation,enum=google.protobuf.FeatureSet_Utf8Validation" json:"utf8_validation,omitempty"`
MessageEncoding *FeatureSet_MessageEncoding `protobuf:"varint,5,opt,name=message_encoding,json=messageEncoding,enum=google.protobuf.FeatureSet_MessageEncoding" json:"message_encoding,omitempty"`
JsonFormat *FeatureSet_JsonFormat `protobuf:"varint,6,opt,name=json_format,json=jsonFormat,enum=google.protobuf.FeatureSet_JsonFormat" json:"json_format,omitempty"`
EnforceNamingStyle *FeatureSet_EnforceNamingStyle `protobuf:"varint,7,opt,name=enforce_naming_style,json=enforceNamingStyle,enum=google.protobuf.FeatureSet_EnforceNamingStyle" json:"enforce_naming_style,omitempty"`
DefaultSymbolVisibility *FeatureSet_VisibilityFeature_DefaultSymbolVisibility `protobuf:"varint,8,opt,name=default_symbol_visibility,json=defaultSymbolVisibility,enum=google.protobuf.FeatureSet_VisibilityFeature_DefaultSymbolVisibility" json:"default_symbol_visibility,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FeatureSet) Reset() {
*x = FeatureSet{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FeatureSet) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FeatureSet) ProtoMessage() {}
func (x *FeatureSet) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FeatureSet.ProtoReflect.Descriptor instead.
func (*FeatureSet) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19}
}
func (x *FeatureSet) GetFieldPresence() FeatureSet_FieldPresence {
if x != nil && x.FieldPresence != nil {
return *x.FieldPresence
}
return FeatureSet_FIELD_PRESENCE_UNKNOWN
}
func (x *FeatureSet) GetEnumType() FeatureSet_EnumType {
if x != nil && x.EnumType != nil {
return *x.EnumType
}
return FeatureSet_ENUM_TYPE_UNKNOWN
}
func (x *FeatureSet) GetRepeatedFieldEncoding() FeatureSet_RepeatedFieldEncoding {
if x != nil && x.RepeatedFieldEncoding != nil {
return *x.RepeatedFieldEncoding
}
return FeatureSet_REPEATED_FIELD_ENCODING_UNKNOWN
}
func (x *FeatureSet) GetUtf8Validation() FeatureSet_Utf8Validation {
if x != nil && x.Utf8Validation != nil {
return *x.Utf8Validation
}
return FeatureSet_UTF8_VALIDATION_UNKNOWN
}
func (x *FeatureSet) GetMessageEncoding() FeatureSet_MessageEncoding {
if x != nil && x.MessageEncoding != nil {
return *x.MessageEncoding
}
return FeatureSet_MESSAGE_ENCODING_UNKNOWN
}
func (x *FeatureSet) GetJsonFormat() FeatureSet_JsonFormat {
if x != nil && x.JsonFormat != nil {
return *x.JsonFormat
}
return FeatureSet_JSON_FORMAT_UNKNOWN
}
func (x *FeatureSet) GetEnforceNamingStyle() FeatureSet_EnforceNamingStyle {
if x != nil && x.EnforceNamingStyle != nil {
return *x.EnforceNamingStyle
}
return FeatureSet_ENFORCE_NAMING_STYLE_UNKNOWN
}
func (x *FeatureSet) GetDefaultSymbolVisibility() FeatureSet_VisibilityFeature_DefaultSymbolVisibility {
if x != nil && x.DefaultSymbolVisibility != nil {
return *x.DefaultSymbolVisibility
}
return FeatureSet_VisibilityFeature_DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
}
// A compiled specification for the defaults of a set of features. These
// messages are generated from FeatureSet extensions and can be used to seed
// feature resolution. The resolution with this object becomes a simple search
// for the closest matching edition, followed by proto merges.
type FeatureSetDefaults struct {
state protoimpl.MessageState `protogen:"open.v1"`
Defaults []*FeatureSetDefaults_FeatureSetEditionDefault `protobuf:"bytes,1,rep,name=defaults" json:"defaults,omitempty"`
// The minimum supported edition (inclusive) when this was constructed.
// Editions before this will not have defaults.
MinimumEdition *Edition `protobuf:"varint,4,opt,name=minimum_edition,json=minimumEdition,enum=google.protobuf.Edition" json:"minimum_edition,omitempty"`
// The maximum known edition (inclusive) when this was constructed. Editions
// after this will not have reliable defaults.
MaximumEdition *Edition `protobuf:"varint,5,opt,name=maximum_edition,json=maximumEdition,enum=google.protobuf.Edition" json:"maximum_edition,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FeatureSetDefaults) Reset() {
*x = FeatureSetDefaults{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FeatureSetDefaults) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FeatureSetDefaults) ProtoMessage() {}
func (x *FeatureSetDefaults) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FeatureSetDefaults.ProtoReflect.Descriptor instead.
func (*FeatureSetDefaults) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20}
}
func (x *FeatureSetDefaults) GetDefaults() []*FeatureSetDefaults_FeatureSetEditionDefault {
if x != nil {
return x.Defaults
}
return nil
}
func (x *FeatureSetDefaults) GetMinimumEdition() Edition {
if x != nil && x.MinimumEdition != nil {
return *x.MinimumEdition
}
return Edition_EDITION_UNKNOWN
}
func (x *FeatureSetDefaults) GetMaximumEdition() Edition {
if x != nil && x.MaximumEdition != nil {
return *x.MaximumEdition
}
return Edition_EDITION_UNKNOWN
}
// Encapsulates information about the original source file from which a
// FileDescriptorProto was generated.
type SourceCodeInfo struct {
state protoimpl.MessageState `protogen:"open.v1"`
// A Location identifies a piece of source code in a .proto file which
// corresponds to a particular definition. This information is intended
// to be useful to IDEs, code indexers, documentation generators, and similar
// tools.
//
// For example, say we have a file like:
//
// message Foo {
// optional string foo = 1;
// }
//
// Let's look at just the field definition:
//
// optional string foo = 1;
// ^ ^^ ^^ ^ ^^^
// a bc de f ghi
//
// We have the following locations:
//
// span path represents
// [a,i) [ 4, 0, 2, 0 ] The whole field definition.
// [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
// [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
// [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
// [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
//
// Notes:
// - A location may refer to a repeated field itself (i.e. not to any
// particular index within it). This is used whenever a set of elements are
// logically enclosed in a single code segment. For example, an entire
// extend block (possibly containing multiple extension definitions) will
// have an outer location whose path refers to the "extensions" repeated
// field without an index.
// - Multiple locations may have the same path. This happens when a single
// logical declaration is spread out across multiple places. The most
// obvious example is the "extend" block again -- there may be multiple
// extend blocks in the same scope, each of which will have the same path.
// - A location's span is not always a subset of its parent's span. For
// example, the "extendee" of an extension declaration appears at the
// beginning of the "extend" block and is shared by all extensions within
// the block.
// - Just because a location's span is a subset of some other location's span
// does not mean that it is a descendant. For example, a "group" defines
// both a type and a field in a single declaration. Thus, the locations
// corresponding to the type and field and their components will overlap.
// - Code which tries to interpret locations should probably be designed to
// ignore those that it doesn't understand, as more types of locations could
// be recorded in the future.
Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
extensionFields protoimpl.ExtensionFields
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *SourceCodeInfo) Reset() {
*x = SourceCodeInfo{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *SourceCodeInfo) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SourceCodeInfo) ProtoMessage() {}
func (x *SourceCodeInfo) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SourceCodeInfo.ProtoReflect.Descriptor instead.
func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{21}
}
func (x *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
if x != nil {
return x.Location
}
return nil
}
// Describes the relationship between generated code and its original source
// file. A GeneratedCodeInfo message is associated with only one generated
// source file, but may contain references to different source .proto files.
type GeneratedCodeInfo struct {
state protoimpl.MessageState `protogen:"open.v1"`
// An Annotation connects some span of text in generated code to an element
// of its generating .proto file.
Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GeneratedCodeInfo) Reset() {
*x = GeneratedCodeInfo{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GeneratedCodeInfo) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GeneratedCodeInfo) ProtoMessage() {}
func (x *GeneratedCodeInfo) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GeneratedCodeInfo.ProtoReflect.Descriptor instead.
func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{22}
}
func (x *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
if x != nil {
return x.Annotation
}
return nil
}
type DescriptorProto_ExtensionRange struct {
state protoimpl.MessageState `protogen:"open.v1"`
Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Exclusive.
Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *DescriptorProto_ExtensionRange) Reset() {
*x = DescriptorProto_ExtensionRange{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *DescriptorProto_ExtensionRange) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
func (x *DescriptorProto_ExtensionRange) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DescriptorProto_ExtensionRange.ProtoReflect.Descriptor instead.
func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 0}
}
func (x *DescriptorProto_ExtensionRange) GetStart() int32 {
if x != nil && x.Start != nil {
return *x.Start
}
return 0
}
func (x *DescriptorProto_ExtensionRange) GetEnd() int32 {
if x != nil && x.End != nil {
return *x.End
}
return 0
}
func (x *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
if x != nil {
return x.Options
}
return nil
}
// Range of reserved tag numbers. Reserved tag numbers may not be used by
// fields or extension ranges in the same message. Reserved ranges may
// not overlap.
type DescriptorProto_ReservedRange struct {
state protoimpl.MessageState `protogen:"open.v1"`
Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Exclusive.
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *DescriptorProto_ReservedRange) Reset() {
*x = DescriptorProto_ReservedRange{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *DescriptorProto_ReservedRange) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DescriptorProto_ReservedRange) ProtoMessage() {}
func (x *DescriptorProto_ReservedRange) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DescriptorProto_ReservedRange.ProtoReflect.Descriptor instead.
func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 1}
}
func (x *DescriptorProto_ReservedRange) GetStart() int32 {
if x != nil && x.Start != nil {
return *x.Start
}
return 0
}
func (x *DescriptorProto_ReservedRange) GetEnd() int32 {
if x != nil && x.End != nil {
return *x.End
}
return 0
}
type ExtensionRangeOptions_Declaration struct {
state protoimpl.MessageState `protogen:"open.v1"`
// The extension number declared within the extension range.
Number *int32 `protobuf:"varint,1,opt,name=number" json:"number,omitempty"`
// The fully-qualified name of the extension field. There must be a leading
// dot in front of the full name.
FullName *string `protobuf:"bytes,2,opt,name=full_name,json=fullName" json:"full_name,omitempty"`
// The fully-qualified type name of the extension field. Unlike
// Metadata.type, Declaration.type must have a leading dot for messages
// and enums.
Type *string `protobuf:"bytes,3,opt,name=type" json:"type,omitempty"`
// If true, indicates that the number is reserved in the extension range,
// and any extension field with the number will fail to compile. Set this
// when a declared extension field is deleted.
Reserved *bool `protobuf:"varint,5,opt,name=reserved" json:"reserved,omitempty"`
// If true, indicates that the extension must be defined as repeated.
// Otherwise the extension must be defined as optional.
Repeated *bool `protobuf:"varint,6,opt,name=repeated" json:"repeated,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ExtensionRangeOptions_Declaration) Reset() {
*x = ExtensionRangeOptions_Declaration{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ExtensionRangeOptions_Declaration) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ExtensionRangeOptions_Declaration) ProtoMessage() {}
func (x *ExtensionRangeOptions_Declaration) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ExtensionRangeOptions_Declaration.ProtoReflect.Descriptor instead.
func (*ExtensionRangeOptions_Declaration) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3, 0}
}
func (x *ExtensionRangeOptions_Declaration) GetNumber() int32 {
if x != nil && x.Number != nil {
return *x.Number
}
return 0
}
func (x *ExtensionRangeOptions_Declaration) GetFullName() string {
if x != nil && x.FullName != nil {
return *x.FullName
}
return ""
}
func (x *ExtensionRangeOptions_Declaration) GetType() string {
if x != nil && x.Type != nil {
return *x.Type
}
return ""
}
func (x *ExtensionRangeOptions_Declaration) GetReserved() bool {
if x != nil && x.Reserved != nil {
return *x.Reserved
}
return false
}
func (x *ExtensionRangeOptions_Declaration) GetRepeated() bool {
if x != nil && x.Repeated != nil {
return *x.Repeated
}
return false
}
// Range of reserved numeric values. Reserved values may not be used by
// entries in the same enum. Reserved ranges may not overlap.
//
// Note that this is distinct from DescriptorProto.ReservedRange in that it
// is inclusive such that it can appropriately represent the entire int32
// domain.
type EnumDescriptorProto_EnumReservedRange struct {
state protoimpl.MessageState `protogen:"open.v1"`
Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Inclusive.
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EnumDescriptorProto_EnumReservedRange) Reset() {
*x = EnumDescriptorProto_EnumReservedRange{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnumDescriptorProto_EnumReservedRange) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
func (x *EnumDescriptorProto_EnumReservedRange) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnumDescriptorProto_EnumReservedRange.ProtoReflect.Descriptor instead.
func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6, 0}
}
func (x *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
if x != nil && x.Start != nil {
return *x.Start
}
return 0
}
func (x *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
if x != nil && x.End != nil {
return *x.End
}
return 0
}
type FieldOptions_EditionDefault struct {
state protoimpl.MessageState `protogen:"open.v1"`
Edition *Edition `protobuf:"varint,3,opt,name=edition,enum=google.protobuf.Edition" json:"edition,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` // Textproto value.
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FieldOptions_EditionDefault) Reset() {
*x = FieldOptions_EditionDefault{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FieldOptions_EditionDefault) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FieldOptions_EditionDefault) ProtoMessage() {}
func (x *FieldOptions_EditionDefault) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[27]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FieldOptions_EditionDefault.ProtoReflect.Descriptor instead.
func (*FieldOptions_EditionDefault) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0}
}
func (x *FieldOptions_EditionDefault) GetEdition() Edition {
if x != nil && x.Edition != nil {
return *x.Edition
}
return Edition_EDITION_UNKNOWN
}
func (x *FieldOptions_EditionDefault) GetValue() string {
if x != nil && x.Value != nil {
return *x.Value
}
return ""
}
// Information about the support window of a feature.
type FieldOptions_FeatureSupport struct {
state protoimpl.MessageState `protogen:"open.v1"`
// The edition that this feature was first available in. In editions
// earlier than this one, the default assigned to EDITION_LEGACY will be
// used, and proto files will not be able to override it.
EditionIntroduced *Edition `protobuf:"varint,1,opt,name=edition_introduced,json=editionIntroduced,enum=google.protobuf.Edition" json:"edition_introduced,omitempty"`
// The edition this feature becomes deprecated in. Using this after this
// edition may trigger warnings.
EditionDeprecated *Edition `protobuf:"varint,2,opt,name=edition_deprecated,json=editionDeprecated,enum=google.protobuf.Edition" json:"edition_deprecated,omitempty"`
// The deprecation warning text if this feature is used after the edition it
// was marked deprecated in.
DeprecationWarning *string `protobuf:"bytes,3,opt,name=deprecation_warning,json=deprecationWarning" json:"deprecation_warning,omitempty"`
// The edition this feature is no longer available in. In editions after
// this one, the last default assigned will be used, and proto files will
// not be able to override it.
EditionRemoved *Edition `protobuf:"varint,4,opt,name=edition_removed,json=editionRemoved,enum=google.protobuf.Edition" json:"edition_removed,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FieldOptions_FeatureSupport) Reset() {
*x = FieldOptions_FeatureSupport{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FieldOptions_FeatureSupport) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FieldOptions_FeatureSupport) ProtoMessage() {}
func (x *FieldOptions_FeatureSupport) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[28]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FieldOptions_FeatureSupport.ProtoReflect.Descriptor instead.
func (*FieldOptions_FeatureSupport) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 1}
}
func (x *FieldOptions_FeatureSupport) GetEditionIntroduced() Edition {
if x != nil && x.EditionIntroduced != nil {
return *x.EditionIntroduced
}
return Edition_EDITION_UNKNOWN
}
func (x *FieldOptions_FeatureSupport) GetEditionDeprecated() Edition {
if x != nil && x.EditionDeprecated != nil {
return *x.EditionDeprecated
}
return Edition_EDITION_UNKNOWN
}
func (x *FieldOptions_FeatureSupport) GetDeprecationWarning() string {
if x != nil && x.DeprecationWarning != nil {
return *x.DeprecationWarning
}
return ""
}
func (x *FieldOptions_FeatureSupport) GetEditionRemoved() Edition {
if x != nil && x.EditionRemoved != nil {
return *x.EditionRemoved
}
return Edition_EDITION_UNKNOWN
}
// The name of the uninterpreted option. Each string represents a segment in
// a dot-separated name. is_extension is true iff a segment represents an
// extension (denoted with parentheses in options specs in .proto files).
// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
// "foo.(bar.baz).moo".
type UninterpretedOption_NamePart struct {
state protoimpl.MessageState `protogen:"open.v1"`
NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *UninterpretedOption_NamePart) Reset() {
*x = UninterpretedOption_NamePart{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *UninterpretedOption_NamePart) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UninterpretedOption_NamePart) ProtoMessage() {}
func (x *UninterpretedOption_NamePart) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[29]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UninterpretedOption_NamePart.ProtoReflect.Descriptor instead.
func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18, 0}
}
func (x *UninterpretedOption_NamePart) GetNamePart() string {
if x != nil && x.NamePart != nil {
return *x.NamePart
}
return ""
}
func (x *UninterpretedOption_NamePart) GetIsExtension() bool {
if x != nil && x.IsExtension != nil {
return *x.IsExtension
}
return false
}
type FeatureSet_VisibilityFeature struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FeatureSet_VisibilityFeature) Reset() {
*x = FeatureSet_VisibilityFeature{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FeatureSet_VisibilityFeature) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FeatureSet_VisibilityFeature) ProtoMessage() {}
func (x *FeatureSet_VisibilityFeature) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FeatureSet_VisibilityFeature.ProtoReflect.Descriptor instead.
func (*FeatureSet_VisibilityFeature) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0}
}
// A map from every known edition with a unique set of defaults to its
// defaults. Not all editions may be contained here. For a given edition,
// the defaults at the closest matching edition ordered at or before it should
// be used. This field must be in strict ascending order by edition.
type FeatureSetDefaults_FeatureSetEditionDefault struct {
state protoimpl.MessageState `protogen:"open.v1"`
Edition *Edition `protobuf:"varint,3,opt,name=edition,enum=google.protobuf.Edition" json:"edition,omitempty"`
// Defaults of features that can be overridden in this edition.
OverridableFeatures *FeatureSet `protobuf:"bytes,4,opt,name=overridable_features,json=overridableFeatures" json:"overridable_features,omitempty"`
// Defaults of features that can't be overridden in this edition.
FixedFeatures *FeatureSet `protobuf:"bytes,5,opt,name=fixed_features,json=fixedFeatures" json:"fixed_features,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) Reset() {
*x = FeatureSetDefaults_FeatureSetEditionDefault{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FeatureSetDefaults_FeatureSetEditionDefault) ProtoMessage() {}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FeatureSetDefaults_FeatureSetEditionDefault.ProtoReflect.Descriptor instead.
func (*FeatureSetDefaults_FeatureSetEditionDefault) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20, 0}
}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) GetEdition() Edition {
if x != nil && x.Edition != nil {
return *x.Edition
}
return Edition_EDITION_UNKNOWN
}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) GetOverridableFeatures() *FeatureSet {
if x != nil {
return x.OverridableFeatures
}
return nil
}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) GetFixedFeatures() *FeatureSet {
if x != nil {
return x.FixedFeatures
}
return nil
}
type SourceCodeInfo_Location struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Identifies which part of the FileDescriptorProto was defined at this
// location.
//
// Each element is a field number or an index. They form a path from
// the root FileDescriptorProto to the place where the definition appears.
// For example, this path:
//
// [ 4, 3, 2, 7, 1 ]
//
// refers to:
//
// file.message_type(3) // 4, 3
// .field(7) // 2, 7
// .name() // 1
//
// This is because FileDescriptorProto.message_type has field number 4:
//
// repeated DescriptorProto message_type = 4;
//
// and DescriptorProto.field has field number 2:
//
// repeated FieldDescriptorProto field = 2;
//
// and FieldDescriptorProto.name has field number 1:
//
// optional string name = 1;
//
// Thus, the above path gives the location of a field name. If we removed
// the last element:
//
// [ 4, 3, 2, 7 ]
//
// this path refers to the whole field declaration (from the beginning
// of the label to the terminating semicolon).
Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
// Always has exactly three or four elements: start line, start column,
// end line (optional, otherwise assumed same as start line), end column.
// These are packed into a single field for efficiency. Note that line
// and column numbers are zero-based -- typically you will want to add
// 1 to each before displaying to a user.
Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
// If this SourceCodeInfo represents a complete declaration, these are any
// comments appearing before and after the declaration which appear to be
// attached to the declaration.
//
// A series of line comments appearing on consecutive lines, with no other
// tokens appearing on those lines, will be treated as a single comment.
//
// leading_detached_comments will keep paragraphs of comments that appear
// before (but not connected to) the current element. Each paragraph,
// separated by empty lines, will be one comment element in the repeated
// field.
//
// Only the comment content is provided; comment markers (e.g. //) are
// stripped out. For block comments, leading whitespace and an asterisk
// will be stripped from the beginning of each line other than the first.
// Newlines are included in the output.
//
// Examples:
//
// optional int32 foo = 1; // Comment attached to foo.
// // Comment attached to bar.
// optional int32 bar = 2;
//
// optional string baz = 3;
// // Comment attached to baz.
// // Another line attached to baz.
//
// // Comment attached to moo.
// //
// // Another line attached to moo.
// optional double moo = 4;
//
// // Detached comment for corge. This is not leading or trailing comments
// // to moo or corge because there are blank lines separating it from
// // both.
//
// // Detached comment for corge paragraph 2.
//
// optional string corge = 5;
// /* Block comment attached
// * to corge. Leading asterisks
// * will be removed. */
// /* Block comment attached to
// * grault. */
// optional int32 grault = 6;
//
// // ignored detached comments.
LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *SourceCodeInfo_Location) Reset() {
*x = SourceCodeInfo_Location{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *SourceCodeInfo_Location) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SourceCodeInfo_Location) ProtoMessage() {}
func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SourceCodeInfo_Location.ProtoReflect.Descriptor instead.
func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{21, 0}
}
func (x *SourceCodeInfo_Location) GetPath() []int32 {
if x != nil {
return x.Path
}
return nil
}
func (x *SourceCodeInfo_Location) GetSpan() []int32 {
if x != nil {
return x.Span
}
return nil
}
func (x *SourceCodeInfo_Location) GetLeadingComments() string {
if x != nil && x.LeadingComments != nil {
return *x.LeadingComments
}
return ""
}
func (x *SourceCodeInfo_Location) GetTrailingComments() string {
if x != nil && x.TrailingComments != nil {
return *x.TrailingComments
}
return ""
}
func (x *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
if x != nil {
return x.LeadingDetachedComments
}
return nil
}
type GeneratedCodeInfo_Annotation struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Identifies the element in the original source .proto file. This field
// is formatted the same as SourceCodeInfo.Location.path.
Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
// Identifies the filesystem path to the original source .proto.
SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
// Identifies the starting offset in bytes in the generated code
// that relates to the identified object.
Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
// Identifies the ending offset in bytes in the generated code that
// relates to the identified object. The end offset should be one past
// the last relevant byte (so the length of the text = end - begin).
End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
Semantic *GeneratedCodeInfo_Annotation_Semantic `protobuf:"varint,5,opt,name=semantic,enum=google.protobuf.GeneratedCodeInfo_Annotation_Semantic" json:"semantic,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *GeneratedCodeInfo_Annotation) Reset() {
*x = GeneratedCodeInfo_Annotation{}
mi := &file_google_protobuf_descriptor_proto_msgTypes[33]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *GeneratedCodeInfo_Annotation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message {
mi := &file_google_protobuf_descriptor_proto_msgTypes[33]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GeneratedCodeInfo_Annotation.ProtoReflect.Descriptor instead.
func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{22, 0}
}
func (x *GeneratedCodeInfo_Annotation) GetPath() []int32 {
if x != nil {
return x.Path
}
return nil
}
func (x *GeneratedCodeInfo_Annotation) GetSourceFile() string {
if x != nil && x.SourceFile != nil {
return *x.SourceFile
}
return ""
}
func (x *GeneratedCodeInfo_Annotation) GetBegin() int32 {
if x != nil && x.Begin != nil {
return *x.Begin
}
return 0
}
func (x *GeneratedCodeInfo_Annotation) GetEnd() int32 {
if x != nil && x.End != nil {
return *x.End
}
return 0
}
func (x *GeneratedCodeInfo_Annotation) GetSemantic() GeneratedCodeInfo_Annotation_Semantic {
if x != nil && x.Semantic != nil {
return *x.Semantic
}
return GeneratedCodeInfo_Annotation_NONE
}
var File_google_protobuf_descriptor_proto protoreflect.FileDescriptor
const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\n" +
" google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"[\n" +
"\x11FileDescriptorSet\x128\n" +
"\x04file\x18\x01 \x03(\v2$.google.protobuf.FileDescriptorProtoR\x04file*\f\b\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xc5\x05\n" +
"\x13FileDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
"\apackage\x18\x02 \x01(\tR\apackage\x12\x1e\n" +
"\n" +
"dependency\x18\x03 \x03(\tR\n" +
"dependency\x12+\n" +
"\x11public_dependency\x18\n" +
" \x03(\x05R\x10publicDependency\x12'\n" +
"\x0fweak_dependency\x18\v \x03(\x05R\x0eweakDependency\x12+\n" +
"\x11option_dependency\x18\x0f \x03(\tR\x10optionDependency\x12C\n" +
"\fmessage_type\x18\x04 \x03(\v2 .google.protobuf.DescriptorProtoR\vmessageType\x12A\n" +
"\tenum_type\x18\x05 \x03(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\x12A\n" +
"\aservice\x18\x06 \x03(\v2'.google.protobuf.ServiceDescriptorProtoR\aservice\x12C\n" +
"\textension\x18\a \x03(\v2%.google.protobuf.FieldDescriptorProtoR\textension\x126\n" +
"\aoptions\x18\b \x01(\v2\x1c.google.protobuf.FileOptionsR\aoptions\x12I\n" +
"\x10source_code_info\x18\t \x01(\v2\x1f.google.protobuf.SourceCodeInfoR\x0esourceCodeInfo\x12\x16\n" +
"\x06syntax\x18\f \x01(\tR\x06syntax\x122\n" +
"\aedition\x18\x0e \x01(\x0e2\x18.google.protobuf.EditionR\aedition\"\xfc\x06\n" +
"\x0fDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12;\n" +
"\x05field\x18\x02 \x03(\v2%.google.protobuf.FieldDescriptorProtoR\x05field\x12C\n" +
"\textension\x18\x06 \x03(\v2%.google.protobuf.FieldDescriptorProtoR\textension\x12A\n" +
"\vnested_type\x18\x03 \x03(\v2 .google.protobuf.DescriptorProtoR\n" +
"nestedType\x12A\n" +
"\tenum_type\x18\x04 \x03(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\x12X\n" +
"\x0fextension_range\x18\x05 \x03(\v2/.google.protobuf.DescriptorProto.ExtensionRangeR\x0eextensionRange\x12D\n" +
"\n" +
"oneof_decl\x18\b \x03(\v2%.google.protobuf.OneofDescriptorProtoR\toneofDecl\x129\n" +
"\aoptions\x18\a \x01(\v2\x1f.google.protobuf.MessageOptionsR\aoptions\x12U\n" +
"\x0ereserved_range\x18\t \x03(\v2..google.protobuf.DescriptorProto.ReservedRangeR\rreservedRange\x12#\n" +
"\rreserved_name\x18\n" +
" \x03(\tR\freservedName\x12A\n" +
"\n" +
"visibility\x18\v \x01(\x0e2!.google.protobuf.SymbolVisibilityR\n" +
"visibility\x1az\n" +
"\x0eExtensionRange\x12\x14\n" +
"\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n" +
"\x03end\x18\x02 \x01(\x05R\x03end\x12@\n" +
"\aoptions\x18\x03 \x01(\v2&.google.protobuf.ExtensionRangeOptionsR\aoptions\x1a7\n" +
"\rReservedRange\x12\x14\n" +
"\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n" +
"\x03end\x18\x02 \x01(\x05R\x03end\"\xcc\x04\n" +
"\x15ExtensionRangeOptions\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x12Y\n" +
"\vdeclaration\x18\x02 \x03(\v22.google.protobuf.ExtensionRangeOptions.DeclarationB\x03\x88\x01\x02R\vdeclaration\x127\n" +
"\bfeatures\x182 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12m\n" +
"\fverification\x18\x03 \x01(\x0e28.google.protobuf.ExtensionRangeOptions.VerificationState:\n" +
"UNVERIFIEDB\x03\x88\x01\x02R\fverification\x1a\x94\x01\n" +
"\vDeclaration\x12\x16\n" +
"\x06number\x18\x01 \x01(\x05R\x06number\x12\x1b\n" +
"\tfull_name\x18\x02 \x01(\tR\bfullName\x12\x12\n" +
"\x04type\x18\x03 \x01(\tR\x04type\x12\x1a\n" +
"\breserved\x18\x05 \x01(\bR\breserved\x12\x1a\n" +
"\brepeated\x18\x06 \x01(\bR\brepeatedJ\x04\b\x04\x10\x05\"4\n" +
"\x11VerificationState\x12\x0f\n" +
"\vDECLARATION\x10\x00\x12\x0e\n" +
"\n" +
"UNVERIFIED\x10\x01*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xc1\x06\n" +
"\x14FieldDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
"\x06number\x18\x03 \x01(\x05R\x06number\x12A\n" +
"\x05label\x18\x04 \x01(\x0e2+.google.protobuf.FieldDescriptorProto.LabelR\x05label\x12>\n" +
"\x04type\x18\x05 \x01(\x0e2*.google.protobuf.FieldDescriptorProto.TypeR\x04type\x12\x1b\n" +
"\ttype_name\x18\x06 \x01(\tR\btypeName\x12\x1a\n" +
"\bextendee\x18\x02 \x01(\tR\bextendee\x12#\n" +
"\rdefault_value\x18\a \x01(\tR\fdefaultValue\x12\x1f\n" +
"\voneof_index\x18\t \x01(\x05R\n" +
"oneofIndex\x12\x1b\n" +
"\tjson_name\x18\n" +
" \x01(\tR\bjsonName\x127\n" +
"\aoptions\x18\b \x01(\v2\x1d.google.protobuf.FieldOptionsR\aoptions\x12'\n" +
"\x0fproto3_optional\x18\x11 \x01(\bR\x0eproto3Optional\"\xb6\x02\n" +
"\x04Type\x12\x0f\n" +
"\vTYPE_DOUBLE\x10\x01\x12\x0e\n" +
"\n" +
"TYPE_FLOAT\x10\x02\x12\x0e\n" +
"\n" +
"TYPE_INT64\x10\x03\x12\x0f\n" +
"\vTYPE_UINT64\x10\x04\x12\x0e\n" +
"\n" +
"TYPE_INT32\x10\x05\x12\x10\n" +
"\fTYPE_FIXED64\x10\x06\x12\x10\n" +
"\fTYPE_FIXED32\x10\a\x12\r\n" +
"\tTYPE_BOOL\x10\b\x12\x0f\n" +
"\vTYPE_STRING\x10\t\x12\x0e\n" +
"\n" +
"TYPE_GROUP\x10\n" +
"\x12\x10\n" +
"\fTYPE_MESSAGE\x10\v\x12\x0e\n" +
"\n" +
"TYPE_BYTES\x10\f\x12\x0f\n" +
"\vTYPE_UINT32\x10\r\x12\r\n" +
"\tTYPE_ENUM\x10\x0e\x12\x11\n" +
"\rTYPE_SFIXED32\x10\x0f\x12\x11\n" +
"\rTYPE_SFIXED64\x10\x10\x12\x0f\n" +
"\vTYPE_SINT32\x10\x11\x12\x0f\n" +
"\vTYPE_SINT64\x10\x12\"C\n" +
"\x05Label\x12\x12\n" +
"\x0eLABEL_OPTIONAL\x10\x01\x12\x12\n" +
"\x0eLABEL_REPEATED\x10\x03\x12\x12\n" +
"\x0eLABEL_REQUIRED\x10\x02\"c\n" +
"\x14OneofDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x127\n" +
"\aoptions\x18\x02 \x01(\v2\x1d.google.protobuf.OneofOptionsR\aoptions\"\xa6\x03\n" +
"\x13EnumDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12?\n" +
"\x05value\x18\x02 \x03(\v2).google.protobuf.EnumValueDescriptorProtoR\x05value\x126\n" +
"\aoptions\x18\x03 \x01(\v2\x1c.google.protobuf.EnumOptionsR\aoptions\x12]\n" +
"\x0ereserved_range\x18\x04 \x03(\v26.google.protobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\x12#\n" +
"\rreserved_name\x18\x05 \x03(\tR\freservedName\x12A\n" +
"\n" +
"visibility\x18\x06 \x01(\x0e2!.google.protobuf.SymbolVisibilityR\n" +
"visibility\x1a;\n" +
"\x11EnumReservedRange\x12\x14\n" +
"\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n" +
"\x03end\x18\x02 \x01(\x05R\x03end\"\x83\x01\n" +
"\x18EnumValueDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
"\x06number\x18\x02 \x01(\x05R\x06number\x12;\n" +
"\aoptions\x18\x03 \x01(\v2!.google.protobuf.EnumValueOptionsR\aoptions\"\xa7\x01\n" +
"\x16ServiceDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12>\n" +
"\x06method\x18\x02 \x03(\v2&.google.protobuf.MethodDescriptorProtoR\x06method\x129\n" +
"\aoptions\x18\x03 \x01(\v2\x1f.google.protobuf.ServiceOptionsR\aoptions\"\x89\x02\n" +
"\x15MethodDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x1d\n" +
"\n" +
"input_type\x18\x02 \x01(\tR\tinputType\x12\x1f\n" +
"\voutput_type\x18\x03 \x01(\tR\n" +
"outputType\x128\n" +
"\aoptions\x18\x04 \x01(\v2\x1e.google.protobuf.MethodOptionsR\aoptions\x120\n" +
"\x10client_streaming\x18\x05 \x01(\b:\x05falseR\x0fclientStreaming\x120\n" +
"\x10server_streaming\x18\x06 \x01(\b:\x05falseR\x0fserverStreaming\"\xad\t\n" +
"\vFileOptions\x12!\n" +
"\fjava_package\x18\x01 \x01(\tR\vjavaPackage\x120\n" +
"\x14java_outer_classname\x18\b \x01(\tR\x12javaOuterClassname\x125\n" +
"\x13java_multiple_files\x18\n" +
" \x01(\b:\x05falseR\x11javaMultipleFiles\x12D\n" +
"\x1djava_generate_equals_and_hash\x18\x14 \x01(\bB\x02\x18\x01R\x19javaGenerateEqualsAndHash\x12:\n" +
"\x16java_string_check_utf8\x18\x1b \x01(\b:\x05falseR\x13javaStringCheckUtf8\x12S\n" +
"\foptimize_for\x18\t \x01(\x0e2).google.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\voptimizeFor\x12\x1d\n" +
"\n" +
"go_package\x18\v \x01(\tR\tgoPackage\x125\n" +
"\x13cc_generic_services\x18\x10 \x01(\b:\x05falseR\x11ccGenericServices\x129\n" +
"\x15java_generic_services\x18\x11 \x01(\b:\x05falseR\x13javaGenericServices\x125\n" +
"\x13py_generic_services\x18\x12 \x01(\b:\x05falseR\x11pyGenericServices\x12%\n" +
"\n" +
"deprecated\x18\x17 \x01(\b:\x05falseR\n" +
"deprecated\x12.\n" +
"\x10cc_enable_arenas\x18\x1f \x01(\b:\x04trueR\x0eccEnableArenas\x12*\n" +
"\x11objc_class_prefix\x18$ \x01(\tR\x0fobjcClassPrefix\x12)\n" +
"\x10csharp_namespace\x18% \x01(\tR\x0fcsharpNamespace\x12!\n" +
"\fswift_prefix\x18' \x01(\tR\vswiftPrefix\x12(\n" +
"\x10php_class_prefix\x18( \x01(\tR\x0ephpClassPrefix\x12#\n" +
"\rphp_namespace\x18) \x01(\tR\fphpNamespace\x124\n" +
"\x16php_metadata_namespace\x18, \x01(\tR\x14phpMetadataNamespace\x12!\n" +
"\fruby_package\x18- \x01(\tR\vrubyPackage\x127\n" +
"\bfeatures\x182 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\":\n" +
"\fOptimizeMode\x12\t\n" +
"\x05SPEED\x10\x01\x12\r\n" +
"\tCODE_SIZE\x10\x02\x12\x10\n" +
"\fLITE_RUNTIME\x10\x03*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b*\x10+J\x04\b&\x10'R\x14php_generic_services\"\xf4\x03\n" +
"\x0eMessageOptions\x12<\n" +
"\x17message_set_wire_format\x18\x01 \x01(\b:\x05falseR\x14messageSetWireFormat\x12L\n" +
"\x1fno_standard_descriptor_accessor\x18\x02 \x01(\b:\x05falseR\x1cnoStandardDescriptorAccessor\x12%\n" +
"\n" +
"deprecated\x18\x03 \x01(\b:\x05falseR\n" +
"deprecated\x12\x1b\n" +
"\tmap_entry\x18\a \x01(\bR\bmapEntry\x12V\n" +
"&deprecated_legacy_json_field_conflicts\x18\v \x01(\bB\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x127\n" +
"\bfeatures\x18\f \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x04\x10\x05J\x04\b\x05\x10\x06J\x04\b\x06\x10\aJ\x04\b\b\x10\tJ\x04\b\t\x10\n" +
"\"\x9d\r\n" +
"\fFieldOptions\x12A\n" +
"\x05ctype\x18\x01 \x01(\x0e2#.google.protobuf.FieldOptions.CType:\x06STRINGR\x05ctype\x12\x16\n" +
"\x06packed\x18\x02 \x01(\bR\x06packed\x12G\n" +
"\x06jstype\x18\x06 \x01(\x0e2$.google.protobuf.FieldOptions.JSType:\tJS_NORMALR\x06jstype\x12\x19\n" +
"\x04lazy\x18\x05 \x01(\b:\x05falseR\x04lazy\x12.\n" +
"\x0funverified_lazy\x18\x0f \x01(\b:\x05falseR\x0eunverifiedLazy\x12%\n" +
"\n" +
"deprecated\x18\x03 \x01(\b:\x05falseR\n" +
"deprecated\x12\x19\n" +
"\x04weak\x18\n" +
" \x01(\b:\x05falseR\x04weak\x12(\n" +
"\fdebug_redact\x18\x10 \x01(\b:\x05falseR\vdebugRedact\x12K\n" +
"\tretention\x18\x11 \x01(\x0e2-.google.protobuf.FieldOptions.OptionRetentionR\tretention\x12H\n" +
"\atargets\x18\x13 \x03(\x0e2..google.protobuf.FieldOptions.OptionTargetTypeR\atargets\x12W\n" +
"\x10edition_defaults\x18\x14 \x03(\v2,.google.protobuf.FieldOptions.EditionDefaultR\x0feditionDefaults\x127\n" +
"\bfeatures\x18\x15 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12U\n" +
"\x0ffeature_support\x18\x16 \x01(\v2,.google.protobuf.FieldOptions.FeatureSupportR\x0efeatureSupport\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x1aZ\n" +
"\x0eEditionDefault\x122\n" +
"\aedition\x18\x03 \x01(\x0e2\x18.google.protobuf.EditionR\aedition\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value\x1a\x96\x02\n" +
"\x0eFeatureSupport\x12G\n" +
"\x12edition_introduced\x18\x01 \x01(\x0e2\x18.google.protobuf.EditionR\x11editionIntroduced\x12G\n" +
"\x12edition_deprecated\x18\x02 \x01(\x0e2\x18.google.protobuf.EditionR\x11editionDeprecated\x12/\n" +
"\x13deprecation_warning\x18\x03 \x01(\tR\x12deprecationWarning\x12A\n" +
"\x0fedition_removed\x18\x04 \x01(\x0e2\x18.google.protobuf.EditionR\x0eeditionRemoved\"/\n" +
"\x05CType\x12\n" +
"\n" +
"\x06STRING\x10\x00\x12\b\n" +
"\x04CORD\x10\x01\x12\x10\n" +
"\fSTRING_PIECE\x10\x02\"5\n" +
"\x06JSType\x12\r\n" +
"\tJS_NORMAL\x10\x00\x12\r\n" +
"\tJS_STRING\x10\x01\x12\r\n" +
"\tJS_NUMBER\x10\x02\"U\n" +
"\x0fOptionRetention\x12\x15\n" +
"\x11RETENTION_UNKNOWN\x10\x00\x12\x15\n" +
"\x11RETENTION_RUNTIME\x10\x01\x12\x14\n" +
"\x10RETENTION_SOURCE\x10\x02\"\x8c\x02\n" +
"\x10OptionTargetType\x12\x17\n" +
"\x13TARGET_TYPE_UNKNOWN\x10\x00\x12\x14\n" +
"\x10TARGET_TYPE_FILE\x10\x01\x12\x1f\n" +
"\x1bTARGET_TYPE_EXTENSION_RANGE\x10\x02\x12\x17\n" +
"\x13TARGET_TYPE_MESSAGE\x10\x03\x12\x15\n" +
"\x11TARGET_TYPE_FIELD\x10\x04\x12\x15\n" +
"\x11TARGET_TYPE_ONEOF\x10\x05\x12\x14\n" +
"\x10TARGET_TYPE_ENUM\x10\x06\x12\x1a\n" +
"\x16TARGET_TYPE_ENUM_ENTRY\x10\a\x12\x17\n" +
"\x13TARGET_TYPE_SERVICE\x10\b\x12\x16\n" +
"\x12TARGET_TYPE_METHOD\x10\t*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x04\x10\x05J\x04\b\x12\x10\x13\"\xac\x01\n" +
"\fOneofOptions\x127\n" +
"\bfeatures\x18\x01 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xd1\x02\n" +
"\vEnumOptions\x12\x1f\n" +
"\vallow_alias\x18\x02 \x01(\bR\n" +
"allowAlias\x12%\n" +
"\n" +
"deprecated\x18\x03 \x01(\b:\x05falseR\n" +
"deprecated\x12V\n" +
"&deprecated_legacy_json_field_conflicts\x18\x06 \x01(\bB\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x127\n" +
"\bfeatures\x18\a \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x05\x10\x06\"\xd8\x02\n" +
"\x10EnumValueOptions\x12%\n" +
"\n" +
"deprecated\x18\x01 \x01(\b:\x05falseR\n" +
"deprecated\x127\n" +
"\bfeatures\x18\x02 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12(\n" +
"\fdebug_redact\x18\x03 \x01(\b:\x05falseR\vdebugRedact\x12U\n" +
"\x0ffeature_support\x18\x04 \x01(\v2,.google.protobuf.FieldOptions.FeatureSupportR\x0efeatureSupport\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xd5\x01\n" +
"\x0eServiceOptions\x127\n" +
"\bfeatures\x18\" \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12%\n" +
"\n" +
"deprecated\x18! \x01(\b:\x05falseR\n" +
"deprecated\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\x99\x03\n" +
"\rMethodOptions\x12%\n" +
"\n" +
"deprecated\x18! \x01(\b:\x05falseR\n" +
"deprecated\x12q\n" +
"\x11idempotency_level\x18\" \x01(\x0e2/.google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UNKNOWNR\x10idempotencyLevel\x127\n" +
"\bfeatures\x18# \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\"P\n" +
"\x10IdempotencyLevel\x12\x17\n" +
"\x13IDEMPOTENCY_UNKNOWN\x10\x00\x12\x13\n" +
"\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n" +
"\n" +
"IDEMPOTENT\x10\x02*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\x9a\x03\n" +
"\x13UninterpretedOption\x12A\n" +
"\x04name\x18\x02 \x03(\v2-.google.protobuf.UninterpretedOption.NamePartR\x04name\x12)\n" +
"\x10identifier_value\x18\x03 \x01(\tR\x0fidentifierValue\x12,\n" +
"\x12positive_int_value\x18\x04 \x01(\x04R\x10positiveIntValue\x12,\n" +
"\x12negative_int_value\x18\x05 \x01(\x03R\x10negativeIntValue\x12!\n" +
"\fdouble_value\x18\x06 \x01(\x01R\vdoubleValue\x12!\n" +
"\fstring_value\x18\a \x01(\fR\vstringValue\x12'\n" +
"\x0faggregate_value\x18\b \x01(\tR\x0eaggregateValue\x1aJ\n" +
"\bNamePart\x12\x1b\n" +
"\tname_part\x18\x01 \x02(\tR\bnamePart\x12!\n" +
"\fis_extension\x18\x02 \x02(\bR\visExtension\"\x8e\x0f\n" +
"\n" +
"FeatureSet\x12\x91\x01\n" +
"\x0efield_presence\x18\x01 \x01(\x0e2).google.protobuf.FeatureSet.FieldPresenceB?\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\bEXPLICIT\x18\x84\a\xa2\x01\r\x12\bIMPLICIT\x18\xe7\a\xa2\x01\r\x12\bEXPLICIT\x18\xe8\a\xb2\x01\x03\b\xe8\aR\rfieldPresence\x12l\n" +
"\tenum_type\x18\x02 \x01(\x0e2$.google.protobuf.FeatureSet.EnumTypeB)\x88\x01\x01\x98\x01\x06\x98\x01\x01\xa2\x01\v\x12\x06CLOSED\x18\x84\a\xa2\x01\t\x12\x04OPEN\x18\xe7\a\xb2\x01\x03\b\xe8\aR\benumType\x12\x98\x01\n" +
"\x17repeated_field_encoding\x18\x03 \x01(\x0e21.google.protobuf.FeatureSet.RepeatedFieldEncodingB-\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\bEXPANDED\x18\x84\a\xa2\x01\v\x12\x06PACKED\x18\xe7\a\xb2\x01\x03\b\xe8\aR\x15repeatedFieldEncoding\x12~\n" +
"\x0futf8_validation\x18\x04 \x01(\x0e2*.google.protobuf.FeatureSet.Utf8ValidationB)\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\t\x12\x04NONE\x18\x84\a\xa2\x01\v\x12\x06VERIFY\x18\xe7\a\xb2\x01\x03\b\xe8\aR\x0eutf8Validation\x12~\n" +
"\x10message_encoding\x18\x05 \x01(\x0e2+.google.protobuf.FeatureSet.MessageEncodingB&\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\x14\x12\x0fLENGTH_PREFIXED\x18\x84\a\xb2\x01\x03\b\xe8\aR\x0fmessageEncoding\x12\x82\x01\n" +
"\vjson_format\x18\x06 \x01(\x0e2&.google.protobuf.FeatureSet.JsonFormatB9\x88\x01\x01\x98\x01\x03\x98\x01\x06\x98\x01\x01\xa2\x01\x17\x12\x12LEGACY_BEST_EFFORT\x18\x84\a\xa2\x01\n" +
"\x12\x05ALLOW\x18\xe7\a\xb2\x01\x03\b\xe8\aR\n" +
"jsonFormat\x12\xab\x01\n" +
"\x14enforce_naming_style\x18\a \x01(\x0e2..google.protobuf.FeatureSet.EnforceNamingStyleBI\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\a\x98\x01\b\x98\x01\t\xa2\x01\x11\x12\fSTYLE_LEGACY\x18\x84\a\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x12enforceNamingStyle\x12\xb9\x01\n" +
"\x19default_symbol_visibility\x18\b \x01(\x0e2E.google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibilityB6\x88\x01\x02\x98\x01\x01\xa2\x01\x0f\x12\n" +
"EXPORT_ALL\x18\x84\a\xa2\x01\x15\x12\x10EXPORT_TOP_LEVEL\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x17defaultSymbolVisibility\x1a\xa1\x01\n" +
"\x11VisibilityFeature\"\x81\x01\n" +
"\x17DefaultSymbolVisibility\x12%\n" +
"!DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\x10\x00\x12\x0e\n" +
"\n" +
"EXPORT_ALL\x10\x01\x12\x14\n" +
"\x10EXPORT_TOP_LEVEL\x10\x02\x12\r\n" +
"\tLOCAL_ALL\x10\x03\x12\n" +
"\n" +
"\x06STRICT\x10\x04J\b\b\x01\x10\x80\x80\x80\x80\x02\"\\\n" +
"\rFieldPresence\x12\x1a\n" +
"\x16FIELD_PRESENCE_UNKNOWN\x10\x00\x12\f\n" +
"\bEXPLICIT\x10\x01\x12\f\n" +
"\bIMPLICIT\x10\x02\x12\x13\n" +
"\x0fLEGACY_REQUIRED\x10\x03\"7\n" +
"\bEnumType\x12\x15\n" +
"\x11ENUM_TYPE_UNKNOWN\x10\x00\x12\b\n" +
"\x04OPEN\x10\x01\x12\n" +
"\n" +
"\x06CLOSED\x10\x02\"V\n" +
"\x15RepeatedFieldEncoding\x12#\n" +
"\x1fREPEATED_FIELD_ENCODING_UNKNOWN\x10\x00\x12\n" +
"\n" +
"\x06PACKED\x10\x01\x12\f\n" +
"\bEXPANDED\x10\x02\"I\n" +
"\x0eUtf8Validation\x12\x1b\n" +
"\x17UTF8_VALIDATION_UNKNOWN\x10\x00\x12\n" +
"\n" +
"\x06VERIFY\x10\x02\x12\b\n" +
"\x04NONE\x10\x03\"\x04\b\x01\x10\x01\"S\n" +
"\x0fMessageEncoding\x12\x1c\n" +
"\x18MESSAGE_ENCODING_UNKNOWN\x10\x00\x12\x13\n" +
"\x0fLENGTH_PREFIXED\x10\x01\x12\r\n" +
"\tDELIMITED\x10\x02\"H\n" +
"\n" +
"JsonFormat\x12\x17\n" +
"\x13JSON_FORMAT_UNKNOWN\x10\x00\x12\t\n" +
"\x05ALLOW\x10\x01\x12\x16\n" +
"\x12LEGACY_BEST_EFFORT\x10\x02\"W\n" +
"\x12EnforceNamingStyle\x12 \n" +
"\x1cENFORCE_NAMING_STYLE_UNKNOWN\x10\x00\x12\r\n" +
"\tSTYLE2024\x10\x01\x12\x10\n" +
"\fSTYLE_LEGACY\x10\x02*\x06\b\xe8\a\x10\x8bN*\x06\b\x8bN\x10\x90N*\x06\b\x90N\x10\x91NJ\x06\b\xe7\a\x10\xe8\a\"\xef\x03\n" +
"\x12FeatureSetDefaults\x12X\n" +
"\bdefaults\x18\x01 \x03(\v2<.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefaultR\bdefaults\x12A\n" +
"\x0fminimum_edition\x18\x04 \x01(\x0e2\x18.google.protobuf.EditionR\x0eminimumEdition\x12A\n" +
"\x0fmaximum_edition\x18\x05 \x01(\x0e2\x18.google.protobuf.EditionR\x0emaximumEdition\x1a\xf8\x01\n" +
"\x18FeatureSetEditionDefault\x122\n" +
"\aedition\x18\x03 \x01(\x0e2\x18.google.protobuf.EditionR\aedition\x12N\n" +
"\x14overridable_features\x18\x04 \x01(\v2\x1b.google.protobuf.FeatureSetR\x13overridableFeatures\x12B\n" +
"\x0efixed_features\x18\x05 \x01(\v2\x1b.google.protobuf.FeatureSetR\rfixedFeaturesJ\x04\b\x01\x10\x02J\x04\b\x02\x10\x03R\bfeatures\"\xb5\x02\n" +
"\x0eSourceCodeInfo\x12D\n" +
"\blocation\x18\x01 \x03(\v2(.google.protobuf.SourceCodeInfo.LocationR\blocation\x1a\xce\x01\n" +
"\bLocation\x12\x16\n" +
"\x04path\x18\x01 \x03(\x05B\x02\x10\x01R\x04path\x12\x16\n" +
"\x04span\x18\x02 \x03(\x05B\x02\x10\x01R\x04span\x12)\n" +
"\x10leading_comments\x18\x03 \x01(\tR\x0fleadingComments\x12+\n" +
"\x11trailing_comments\x18\x04 \x01(\tR\x10trailingComments\x12:\n" +
"\x19leading_detached_comments\x18\x06 \x03(\tR\x17leadingDetachedComments*\f\b\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xd0\x02\n" +
"\x11GeneratedCodeInfo\x12M\n" +
"\n" +
"annotation\x18\x01 \x03(\v2-.google.protobuf.GeneratedCodeInfo.AnnotationR\n" +
"annotation\x1a\xeb\x01\n" +
"\n" +
"Annotation\x12\x16\n" +
"\x04path\x18\x01 \x03(\x05B\x02\x10\x01R\x04path\x12\x1f\n" +
"\vsource_file\x18\x02 \x01(\tR\n" +
"sourceFile\x12\x14\n" +
"\x05begin\x18\x03 \x01(\x05R\x05begin\x12\x10\n" +
"\x03end\x18\x04 \x01(\x05R\x03end\x12R\n" +
"\bsemantic\x18\x05 \x01(\x0e26.google.protobuf.GeneratedCodeInfo.Annotation.SemanticR\bsemantic\"(\n" +
"\bSemantic\x12\b\n" +
"\x04NONE\x10\x00\x12\a\n" +
"\x03SET\x10\x01\x12\t\n" +
"\x05ALIAS\x10\x02*\xa7\x02\n" +
"\aEdition\x12\x13\n" +
"\x0fEDITION_UNKNOWN\x10\x00\x12\x13\n" +
"\x0eEDITION_LEGACY\x10\x84\a\x12\x13\n" +
"\x0eEDITION_PROTO2\x10\xe6\a\x12\x13\n" +
"\x0eEDITION_PROTO3\x10\xe7\a\x12\x11\n" +
"\fEDITION_2023\x10\xe8\a\x12\x11\n" +
"\fEDITION_2024\x10\xe9\a\x12\x17\n" +
"\x13EDITION_1_TEST_ONLY\x10\x01\x12\x17\n" +
"\x13EDITION_2_TEST_ONLY\x10\x02\x12\x1d\n" +
"\x17EDITION_99997_TEST_ONLY\x10\x9d\x8d\x06\x12\x1d\n" +
"\x17EDITION_99998_TEST_ONLY\x10\x9e\x8d\x06\x12\x1d\n" +
"\x17EDITION_99999_TEST_ONLY\x10\x9f\x8d\x06\x12\x13\n" +
"\vEDITION_MAX\x10\xff\xff\xff\xff\a*U\n" +
"\x10SymbolVisibility\x12\x14\n" +
"\x10VISIBILITY_UNSET\x10\x00\x12\x14\n" +
"\x10VISIBILITY_LOCAL\x10\x01\x12\x15\n" +
"\x11VISIBILITY_EXPORT\x10\x02B~\n" +
"\x13com.google.protobufB\x10DescriptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.Reflection"
var (
file_google_protobuf_descriptor_proto_rawDescOnce sync.Once
file_google_protobuf_descriptor_proto_rawDescData []byte
)
func file_google_protobuf_descriptor_proto_rawDescGZIP() []byte {
file_google_protobuf_descriptor_proto_rawDescOnce.Do(func() {
file_google_protobuf_descriptor_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_google_protobuf_descriptor_proto_rawDesc), len(file_google_protobuf_descriptor_proto_rawDesc)))
})
return file_google_protobuf_descriptor_proto_rawDescData
}
var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 20)
var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 34)
var file_google_protobuf_descriptor_proto_goTypes = []any{
(Edition)(0), // 0: google.protobuf.Edition
(SymbolVisibility)(0), // 1: google.protobuf.SymbolVisibility
(ExtensionRangeOptions_VerificationState)(0), // 2: google.protobuf.ExtensionRangeOptions.VerificationState
(FieldDescriptorProto_Type)(0), // 3: google.protobuf.FieldDescriptorProto.Type
(FieldDescriptorProto_Label)(0), // 4: google.protobuf.FieldDescriptorProto.Label
(FileOptions_OptimizeMode)(0), // 5: google.protobuf.FileOptions.OptimizeMode
(FieldOptions_CType)(0), // 6: google.protobuf.FieldOptions.CType
(FieldOptions_JSType)(0), // 7: google.protobuf.FieldOptions.JSType
(FieldOptions_OptionRetention)(0), // 8: google.protobuf.FieldOptions.OptionRetention
(FieldOptions_OptionTargetType)(0), // 9: google.protobuf.FieldOptions.OptionTargetType
(MethodOptions_IdempotencyLevel)(0), // 10: google.protobuf.MethodOptions.IdempotencyLevel
(FeatureSet_FieldPresence)(0), // 11: google.protobuf.FeatureSet.FieldPresence
(FeatureSet_EnumType)(0), // 12: google.protobuf.FeatureSet.EnumType
(FeatureSet_RepeatedFieldEncoding)(0), // 13: google.protobuf.FeatureSet.RepeatedFieldEncoding
(FeatureSet_Utf8Validation)(0), // 14: google.protobuf.FeatureSet.Utf8Validation
(FeatureSet_MessageEncoding)(0), // 15: google.protobuf.FeatureSet.MessageEncoding
(FeatureSet_JsonFormat)(0), // 16: google.protobuf.FeatureSet.JsonFormat
(FeatureSet_EnforceNamingStyle)(0), // 17: google.protobuf.FeatureSet.EnforceNamingStyle
(FeatureSet_VisibilityFeature_DefaultSymbolVisibility)(0), // 18: google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility
(GeneratedCodeInfo_Annotation_Semantic)(0), // 19: google.protobuf.GeneratedCodeInfo.Annotation.Semantic
(*FileDescriptorSet)(nil), // 20: google.protobuf.FileDescriptorSet
(*FileDescriptorProto)(nil), // 21: google.protobuf.FileDescriptorProto
(*DescriptorProto)(nil), // 22: google.protobuf.DescriptorProto
(*ExtensionRangeOptions)(nil), // 23: google.protobuf.ExtensionRangeOptions
(*FieldDescriptorProto)(nil), // 24: google.protobuf.FieldDescriptorProto
(*OneofDescriptorProto)(nil), // 25: google.protobuf.OneofDescriptorProto
(*EnumDescriptorProto)(nil), // 26: google.protobuf.EnumDescriptorProto
(*EnumValueDescriptorProto)(nil), // 27: google.protobuf.EnumValueDescriptorProto
(*ServiceDescriptorProto)(nil), // 28: google.protobuf.ServiceDescriptorProto
(*MethodDescriptorProto)(nil), // 29: google.protobuf.MethodDescriptorProto
(*FileOptions)(nil), // 30: google.protobuf.FileOptions
(*MessageOptions)(nil), // 31: google.protobuf.MessageOptions
(*FieldOptions)(nil), // 32: google.protobuf.FieldOptions
(*OneofOptions)(nil), // 33: google.protobuf.OneofOptions
(*EnumOptions)(nil), // 34: google.protobuf.EnumOptions
(*EnumValueOptions)(nil), // 35: google.protobuf.EnumValueOptions
(*ServiceOptions)(nil), // 36: google.protobuf.ServiceOptions
(*MethodOptions)(nil), // 37: google.protobuf.MethodOptions
(*UninterpretedOption)(nil), // 38: google.protobuf.UninterpretedOption
(*FeatureSet)(nil), // 39: google.protobuf.FeatureSet
(*FeatureSetDefaults)(nil), // 40: google.protobuf.FeatureSetDefaults
(*SourceCodeInfo)(nil), // 41: google.protobuf.SourceCodeInfo
(*GeneratedCodeInfo)(nil), // 42: google.protobuf.GeneratedCodeInfo
(*DescriptorProto_ExtensionRange)(nil), // 43: google.protobuf.DescriptorProto.ExtensionRange
(*DescriptorProto_ReservedRange)(nil), // 44: google.protobuf.DescriptorProto.ReservedRange
(*ExtensionRangeOptions_Declaration)(nil), // 45: google.protobuf.ExtensionRangeOptions.Declaration
(*EnumDescriptorProto_EnumReservedRange)(nil), // 46: google.protobuf.EnumDescriptorProto.EnumReservedRange
(*FieldOptions_EditionDefault)(nil), // 47: google.protobuf.FieldOptions.EditionDefault
(*FieldOptions_FeatureSupport)(nil), // 48: google.protobuf.FieldOptions.FeatureSupport
(*UninterpretedOption_NamePart)(nil), // 49: google.protobuf.UninterpretedOption.NamePart
(*FeatureSet_VisibilityFeature)(nil), // 50: google.protobuf.FeatureSet.VisibilityFeature
(*FeatureSetDefaults_FeatureSetEditionDefault)(nil), // 51: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
(*SourceCodeInfo_Location)(nil), // 52: google.protobuf.SourceCodeInfo.Location
(*GeneratedCodeInfo_Annotation)(nil), // 53: google.protobuf.GeneratedCodeInfo.Annotation
}
var file_google_protobuf_descriptor_proto_depIdxs = []int32{
21, // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto
22, // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto
26, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
28, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto
24, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
30, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions
41, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo
0, // 7: google.protobuf.FileDescriptorProto.edition:type_name -> google.protobuf.Edition
24, // 8: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto
24, // 9: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
22, // 10: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto
26, // 11: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
43, // 12: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange
25, // 13: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto
31, // 14: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions
44, // 15: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange
1, // 16: google.protobuf.DescriptorProto.visibility:type_name -> google.protobuf.SymbolVisibility
38, // 17: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
45, // 18: google.protobuf.ExtensionRangeOptions.declaration:type_name -> google.protobuf.ExtensionRangeOptions.Declaration
39, // 19: google.protobuf.ExtensionRangeOptions.features:type_name -> google.protobuf.FeatureSet
2, // 20: google.protobuf.ExtensionRangeOptions.verification:type_name -> google.protobuf.ExtensionRangeOptions.VerificationState
4, // 21: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label
3, // 22: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type
32, // 23: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions
33, // 24: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions
27, // 25: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto
34, // 26: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions
46, // 27: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange
1, // 28: google.protobuf.EnumDescriptorProto.visibility:type_name -> google.protobuf.SymbolVisibility
35, // 29: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions
29, // 30: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto
36, // 31: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions
37, // 32: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions
5, // 33: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode
39, // 34: google.protobuf.FileOptions.features:type_name -> google.protobuf.FeatureSet
38, // 35: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
39, // 36: google.protobuf.MessageOptions.features:type_name -> google.protobuf.FeatureSet
38, // 37: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
6, // 38: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType
7, // 39: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType
8, // 40: google.protobuf.FieldOptions.retention:type_name -> google.protobuf.FieldOptions.OptionRetention
9, // 41: google.protobuf.FieldOptions.targets:type_name -> google.protobuf.FieldOptions.OptionTargetType
47, // 42: google.protobuf.FieldOptions.edition_defaults:type_name -> google.protobuf.FieldOptions.EditionDefault
39, // 43: google.protobuf.FieldOptions.features:type_name -> google.protobuf.FeatureSet
48, // 44: google.protobuf.FieldOptions.feature_support:type_name -> google.protobuf.FieldOptions.FeatureSupport
38, // 45: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
39, // 46: google.protobuf.OneofOptions.features:type_name -> google.protobuf.FeatureSet
38, // 47: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
39, // 48: google.protobuf.EnumOptions.features:type_name -> google.protobuf.FeatureSet
38, // 49: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
39, // 50: google.protobuf.EnumValueOptions.features:type_name -> google.protobuf.FeatureSet
48, // 51: google.protobuf.EnumValueOptions.feature_support:type_name -> google.protobuf.FieldOptions.FeatureSupport
38, // 52: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
39, // 53: google.protobuf.ServiceOptions.features:type_name -> google.protobuf.FeatureSet
38, // 54: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
10, // 55: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel
39, // 56: google.protobuf.MethodOptions.features:type_name -> google.protobuf.FeatureSet
38, // 57: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
49, // 58: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart
11, // 59: google.protobuf.FeatureSet.field_presence:type_name -> google.protobuf.FeatureSet.FieldPresence
12, // 60: google.protobuf.FeatureSet.enum_type:type_name -> google.protobuf.FeatureSet.EnumType
13, // 61: google.protobuf.FeatureSet.repeated_field_encoding:type_name -> google.protobuf.FeatureSet.RepeatedFieldEncoding
14, // 62: google.protobuf.FeatureSet.utf8_validation:type_name -> google.protobuf.FeatureSet.Utf8Validation
15, // 63: google.protobuf.FeatureSet.message_encoding:type_name -> google.protobuf.FeatureSet.MessageEncoding
16, // 64: google.protobuf.FeatureSet.json_format:type_name -> google.protobuf.FeatureSet.JsonFormat
17, // 65: google.protobuf.FeatureSet.enforce_naming_style:type_name -> google.protobuf.FeatureSet.EnforceNamingStyle
18, // 66: google.protobuf.FeatureSet.default_symbol_visibility:type_name -> google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility
51, // 67: google.protobuf.FeatureSetDefaults.defaults:type_name -> google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
0, // 68: google.protobuf.FeatureSetDefaults.minimum_edition:type_name -> google.protobuf.Edition
0, // 69: google.protobuf.FeatureSetDefaults.maximum_edition:type_name -> google.protobuf.Edition
52, // 70: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location
53, // 71: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation
23, // 72: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions
0, // 73: google.protobuf.FieldOptions.EditionDefault.edition:type_name -> google.protobuf.Edition
0, // 74: google.protobuf.FieldOptions.FeatureSupport.edition_introduced:type_name -> google.protobuf.Edition
0, // 75: google.protobuf.FieldOptions.FeatureSupport.edition_deprecated:type_name -> google.protobuf.Edition
0, // 76: google.protobuf.FieldOptions.FeatureSupport.edition_removed:type_name -> google.protobuf.Edition
0, // 77: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition:type_name -> google.protobuf.Edition
39, // 78: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.overridable_features:type_name -> google.protobuf.FeatureSet
39, // 79: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fixed_features:type_name -> google.protobuf.FeatureSet
19, // 80: google.protobuf.GeneratedCodeInfo.Annotation.semantic:type_name -> google.protobuf.GeneratedCodeInfo.Annotation.Semantic
81, // [81:81] is the sub-list for method output_type
81, // [81:81] is the sub-list for method input_type
81, // [81:81] is the sub-list for extension type_name
81, // [81:81] is the sub-list for extension extendee
0, // [0:81] is the sub-list for field type_name
}
func init() { file_google_protobuf_descriptor_proto_init() }
func file_google_protobuf_descriptor_proto_init() {
if File_google_protobuf_descriptor_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_google_protobuf_descriptor_proto_rawDesc), len(file_google_protobuf_descriptor_proto_rawDesc)),
NumEnums: 20,
NumMessages: 34,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_google_protobuf_descriptor_proto_goTypes,
DependencyIndexes: file_google_protobuf_descriptor_proto_depIdxs,
EnumInfos: file_google_protobuf_descriptor_proto_enumTypes,
MessageInfos: file_google_protobuf_descriptor_proto_msgTypes,
}.Build()
File_google_protobuf_descriptor_proto = out.File
file_google_protobuf_descriptor_proto_goTypes = nil
file_google_protobuf_descriptor_proto_depIdxs = nil
}