mirror of
https://github.com/cwinfo/matterbridge.git
synced 2025-07-04 06:37:45 +00:00
Update mattermost library (#2152)
* Update mattermost library * Fix linting
This commit is contained in:
Wim
685
vendor/google.golang.org/protobuf/encoding/protojson/decode.go
generated
vendored
Normal file
685
vendor/google.golang.org/protobuf/encoding/protojson/decode.go
generated
vendored
Normal file
@ -0,0 +1,685 @@
|
||||
// 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 ...interface{}) 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 ...interface{}) 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 flags.ProtoLegacy {
|
||||
if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
|
||||
fd = nil // reset since the weak reference is not linked in
|
||||
}
|
||||
}
|
||||
|
||||
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 type: %v", kind, 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())
|
||||
}
|
||||
11
vendor/google.golang.org/protobuf/encoding/protojson/doc.go
generated
vendored
Normal file
11
vendor/google.golang.org/protobuf/encoding/protojson/doc.go
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
// 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 marshals and unmarshals protocol buffer messages as JSON
|
||||
// format. It follows the guide at
|
||||
// https://protobuf.dev/programming-guides/proto3#json.
|
||||
//
|
||||
// This package produces a different output than the standard [encoding/json]
|
||||
// package, which does not operate correctly on protocol buffer messages.
|
||||
package protojson
|
||||
378
vendor/google.golang.org/protobuf/encoding/protojson/encode.go
generated
vendored
Normal file
378
vendor/google.golang.org/protobuf/encoding/protojson/encode.go
generated
vendored
Normal file
@ -0,0 +1,378 @@
|
||||
// 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. It may change over time across
|
||||
// different versions of the program.
|
||||
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. It may change over time across
|
||||
// different versions of the program.
|
||||
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. It may change over time across
|
||||
// different versions of the program.
|
||||
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
|
||||
// MarshalOptions. Do not depend on the output being stable. It may change over
|
||||
// time across different versions of the program.
|
||||
func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
|
||||
return o.marshal(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)
|
||||
isProto2Scalar := fd.Syntax() == protoreflect.Proto2 && fd.Default().IsValid()
|
||||
isSingularMessage := fd.Cardinality() != protoreflect.Repeated && fd.Message() != nil
|
||||
if isProto2Scalar || isSingularMessage {
|
||||
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
|
||||
}
|
||||
876
vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
generated
vendored
Normal file
876
vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
generated
vendored
Normal file
@ -0,0 +1,876 @@
|
||||
// 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 {
|
||||
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
|
||||
}
|
||||
340
vendor/google.golang.org/protobuf/internal/encoding/json/decode.go
generated
vendored
Normal file
340
vendor/google.golang.org/protobuf/internal/encoding/json/decode.go
generated
vendored
Normal file
@ -0,0 +1,340 @@
|
||||
// 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 ...interface{}) 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
|
||||
}
|
||||
254
vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go
generated
vendored
Normal file
254
vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go
generated
vendored
Normal file
@ -0,0 +1,254 @@
|
||||
// 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
|
||||
}
|
||||
91
vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go
generated
vendored
Normal file
91
vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go
generated
vendored
Normal file
@ -0,0 +1,91 @@
|
||||
// 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)) }
|
||||
192
vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go
generated
vendored
Normal file
192
vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go
generated
vendored
Normal file
@ -0,0 +1,192 @@
|
||||
// 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
|
||||
}
|
||||
278
vendor/google.golang.org/protobuf/internal/encoding/json/encode.go
generated
vendored
Normal file
278
vendor/google.golang.org/protobuf/internal/encoding/json/encode.go
generated
vendored
Normal file
@ -0,0 +1,278 @@
|
||||
// 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, ' ')
|
||||
}
|
||||
}
|
||||
}
|
||||
31
vendor/google.golang.org/protobuf/protoadapt/convert.go
generated
vendored
Normal file
31
vendor/google.golang.org/protobuf/protoadapt/convert.go
generated
vendored
Normal file
@ -0,0 +1,31 @@
|
||||
// Copyright 2023 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 protoadapt bridges the original and new proto APIs.
|
||||
package protoadapt
|
||||
|
||||
import (
|
||||
"google.golang.org/protobuf/proto"
|
||||
"google.golang.org/protobuf/runtime/protoiface"
|
||||
"google.golang.org/protobuf/runtime/protoimpl"
|
||||
)
|
||||
|
||||
// MessageV1 is the original [github.com/golang/protobuf/proto.Message] type.
|
||||
type MessageV1 = protoiface.MessageV1
|
||||
|
||||
// MessageV2 is the [google.golang.org/protobuf/proto.Message] type used by the
|
||||
// current [google.golang.org/protobuf] module, adding support for reflection.
|
||||
type MessageV2 = proto.Message
|
||||
|
||||
// MessageV1Of converts a v2 message to a v1 message.
|
||||
// It returns nil if m is nil.
|
||||
func MessageV1Of(m MessageV2) MessageV1 {
|
||||
return protoimpl.X.ProtoMessageV1Of(m)
|
||||
}
|
||||
|
||||
// MessageV2Of converts a v1 message to a v2 message.
|
||||
// It returns nil if m is nil.
|
||||
func MessageV2Of(m MessageV1) MessageV2 {
|
||||
return protoimpl.X.ProtoMessageV2Of(m)
|
||||
}
|
||||
496
vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
generated
vendored
Normal file
496
vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
generated
vendored
Normal file
@ -0,0 +1,496 @@
|
||||
// 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.
|
||||
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/any.proto
|
||||
|
||||
// Package anypb contains generated types for google/protobuf/any.proto.
|
||||
//
|
||||
// The Any message is a dynamic representation of any other message value.
|
||||
// It is functionally a tuple of the full name of the remote message type and
|
||||
// the serialized bytes of the remote message value.
|
||||
//
|
||||
// # Constructing an Any
|
||||
//
|
||||
// An Any message containing another message value is constructed using New:
|
||||
//
|
||||
// any, err := anypb.New(m)
|
||||
// if err != nil {
|
||||
// ... // handle error
|
||||
// }
|
||||
// ... // make use of any
|
||||
//
|
||||
// # Unmarshaling an Any
|
||||
//
|
||||
// With a populated Any message, the underlying message can be serialized into
|
||||
// a remote concrete message value in a few ways.
|
||||
//
|
||||
// If the exact concrete type is known, then a new (or pre-existing) instance
|
||||
// of that message can be passed to the UnmarshalTo method:
|
||||
//
|
||||
// m := new(foopb.MyMessage)
|
||||
// if err := any.UnmarshalTo(m); err != nil {
|
||||
// ... // handle error
|
||||
// }
|
||||
// ... // make use of m
|
||||
//
|
||||
// If the exact concrete type is not known, then the UnmarshalNew method can be
|
||||
// used to unmarshal the contents into a new instance of the remote message type:
|
||||
//
|
||||
// m, err := any.UnmarshalNew()
|
||||
// if err != nil {
|
||||
// ... // handle error
|
||||
// }
|
||||
// ... // make use of m
|
||||
//
|
||||
// UnmarshalNew uses the global type registry to resolve the message type and
|
||||
// construct a new instance of that message to unmarshal into. In order for a
|
||||
// message type to appear in the global registry, the Go type representing that
|
||||
// protobuf message type must be linked into the Go binary. For messages
|
||||
// generated by protoc-gen-go, this is achieved through an import of the
|
||||
// generated Go package representing a .proto file.
|
||||
//
|
||||
// A common pattern with UnmarshalNew is to use a type switch with the resulting
|
||||
// proto.Message value:
|
||||
//
|
||||
// switch m := m.(type) {
|
||||
// case *foopb.MyMessage:
|
||||
// ... // make use of m as a *foopb.MyMessage
|
||||
// case *barpb.OtherMessage:
|
||||
// ... // make use of m as a *barpb.OtherMessage
|
||||
// case *bazpb.SomeMessage:
|
||||
// ... // make use of m as a *bazpb.SomeMessage
|
||||
// }
|
||||
//
|
||||
// This pattern ensures that the generated packages containing the message types
|
||||
// listed in the case clauses are linked into the Go binary and therefore also
|
||||
// registered in the global registry.
|
||||
//
|
||||
// # Type checking an Any
|
||||
//
|
||||
// In order to type check whether an Any message represents some other message,
|
||||
// then use the MessageIs method:
|
||||
//
|
||||
// if any.MessageIs((*foopb.MyMessage)(nil)) {
|
||||
// ... // make use of any, knowing that it contains a foopb.MyMessage
|
||||
// }
|
||||
//
|
||||
// The MessageIs method can also be used with an allocated instance of the target
|
||||
// message type if the intention is to unmarshal into it if the type matches:
|
||||
//
|
||||
// m := new(foopb.MyMessage)
|
||||
// if any.MessageIs(m) {
|
||||
// if err := any.UnmarshalTo(m); err != nil {
|
||||
// ... // handle error
|
||||
// }
|
||||
// ... // make use of m
|
||||
// }
|
||||
package anypb
|
||||
|
||||
import (
|
||||
proto "google.golang.org/protobuf/proto"
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoregistry "google.golang.org/protobuf/reflect/protoregistry"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
strings "strings"
|
||||
sync "sync"
|
||||
)
|
||||
|
||||
// `Any` contains an arbitrary serialized protocol buffer message along with a
|
||||
// URL that describes the type of the serialized message.
|
||||
//
|
||||
// Protobuf library provides support to pack/unpack Any values in the form
|
||||
// of utility functions or additional generated methods of the Any type.
|
||||
//
|
||||
// Example 1: Pack and unpack a message in C++.
|
||||
//
|
||||
// Foo foo = ...;
|
||||
// Any any;
|
||||
// any.PackFrom(foo);
|
||||
// ...
|
||||
// if (any.UnpackTo(&foo)) {
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// Example 2: Pack and unpack a message in Java.
|
||||
//
|
||||
// Foo foo = ...;
|
||||
// Any any = Any.pack(foo);
|
||||
// ...
|
||||
// if (any.is(Foo.class)) {
|
||||
// foo = any.unpack(Foo.class);
|
||||
// }
|
||||
// // or ...
|
||||
// if (any.isSameTypeAs(Foo.getDefaultInstance())) {
|
||||
// foo = any.unpack(Foo.getDefaultInstance());
|
||||
// }
|
||||
//
|
||||
// Example 3: Pack and unpack a message in Python.
|
||||
//
|
||||
// foo = Foo(...)
|
||||
// any = Any()
|
||||
// any.Pack(foo)
|
||||
// ...
|
||||
// if any.Is(Foo.DESCRIPTOR):
|
||||
// any.Unpack(foo)
|
||||
// ...
|
||||
//
|
||||
// Example 4: Pack and unpack a message in Go
|
||||
//
|
||||
// foo := &pb.Foo{...}
|
||||
// any, err := anypb.New(foo)
|
||||
// if err != nil {
|
||||
// ...
|
||||
// }
|
||||
// ...
|
||||
// foo := &pb.Foo{}
|
||||
// if err := any.UnmarshalTo(foo); err != nil {
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// The pack methods provided by protobuf library will by default use
|
||||
// 'type.googleapis.com/full.type.name' as the type URL and the unpack
|
||||
// methods only use the fully qualified type name after the last '/'
|
||||
// in the type URL, for example "foo.bar.com/x/y.z" will yield type
|
||||
// name "y.z".
|
||||
//
|
||||
// JSON
|
||||
// ====
|
||||
// The JSON representation of an `Any` value uses the regular
|
||||
// representation of the deserialized, embedded message, with an
|
||||
// additional field `@type` which contains the type URL. Example:
|
||||
//
|
||||
// package google.profile;
|
||||
// message Person {
|
||||
// string first_name = 1;
|
||||
// string last_name = 2;
|
||||
// }
|
||||
//
|
||||
// {
|
||||
// "@type": "type.googleapis.com/google.profile.Person",
|
||||
// "firstName": <string>,
|
||||
// "lastName": <string>
|
||||
// }
|
||||
//
|
||||
// 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. Example (for message [google.protobuf.Duration][]):
|
||||
//
|
||||
// {
|
||||
// "@type": "type.googleapis.com/google.protobuf.Duration",
|
||||
// "value": "1.212s"
|
||||
// }
|
||||
type Any struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// A URL/resource name that uniquely identifies the type of the serialized
|
||||
// protocol buffer message. This string must contain at least
|
||||
// one "/" character. The last segment of the URL's path must represent
|
||||
// the fully qualified name of the type (as in
|
||||
// `path/google.protobuf.Duration`). The name should be in a canonical form
|
||||
// (e.g., leading "." is not accepted).
|
||||
//
|
||||
// In practice, teams usually precompile into the binary all types that they
|
||||
// expect it to use in the context of Any. However, for URLs which use the
|
||||
// scheme `http`, `https`, or no scheme, one can optionally set up a type
|
||||
// server that maps type URLs to message definitions as follows:
|
||||
//
|
||||
// - If no scheme is provided, `https` is assumed.
|
||||
// - An HTTP GET on the URL must yield a [google.protobuf.Type][]
|
||||
// value in binary format, or produce an error.
|
||||
// - Applications are allowed to cache lookup results based on the
|
||||
// URL, or have them precompiled into a binary to avoid any
|
||||
// lookup. Therefore, binary compatibility needs to be preserved
|
||||
// on changes to types. (Use versioned type names to manage
|
||||
// breaking changes.)
|
||||
//
|
||||
// Note: this functionality is not currently available in the official
|
||||
// protobuf release, and it is not used for type URLs beginning with
|
||||
// type.googleapis.com. As of May 2023, there are no widely used type server
|
||||
// implementations and no plans to implement one.
|
||||
//
|
||||
// Schemes other than `http`, `https` (or the empty scheme) might be
|
||||
// used with implementation specific semantics.
|
||||
TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
|
||||
// Must be a valid serialized protocol buffer of the above specified type.
|
||||
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
||||
}
|
||||
|
||||
// New marshals src into a new Any instance.
|
||||
func New(src proto.Message) (*Any, error) {
|
||||
dst := new(Any)
|
||||
if err := dst.MarshalFrom(src); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
// MarshalFrom marshals src into dst as the underlying message
|
||||
// using the provided marshal options.
|
||||
//
|
||||
// If no options are specified, call dst.MarshalFrom instead.
|
||||
func MarshalFrom(dst *Any, src proto.Message, opts proto.MarshalOptions) error {
|
||||
const urlPrefix = "type.googleapis.com/"
|
||||
if src == nil {
|
||||
return protoimpl.X.NewError("invalid nil source message")
|
||||
}
|
||||
b, err := opts.Marshal(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
dst.TypeUrl = urlPrefix + string(src.ProtoReflect().Descriptor().FullName())
|
||||
dst.Value = b
|
||||
return nil
|
||||
}
|
||||
|
||||
// UnmarshalTo unmarshals the underlying message from src into dst
|
||||
// using the provided unmarshal options.
|
||||
// It reports an error if dst is not of the right message type.
|
||||
//
|
||||
// If no options are specified, call src.UnmarshalTo instead.
|
||||
func UnmarshalTo(src *Any, dst proto.Message, opts proto.UnmarshalOptions) error {
|
||||
if src == nil {
|
||||
return protoimpl.X.NewError("invalid nil source message")
|
||||
}
|
||||
if !src.MessageIs(dst) {
|
||||
got := dst.ProtoReflect().Descriptor().FullName()
|
||||
want := src.MessageName()
|
||||
return protoimpl.X.NewError("mismatched message type: got %q, want %q", got, want)
|
||||
}
|
||||
return opts.Unmarshal(src.GetValue(), dst)
|
||||
}
|
||||
|
||||
// UnmarshalNew unmarshals the underlying message from src into dst,
|
||||
// which is newly created message using a type resolved from the type URL.
|
||||
// The message type is resolved according to opt.Resolver,
|
||||
// which should implement protoregistry.MessageTypeResolver.
|
||||
// It reports an error if the underlying message type could not be resolved.
|
||||
//
|
||||
// If no options are specified, call src.UnmarshalNew instead.
|
||||
func UnmarshalNew(src *Any, opts proto.UnmarshalOptions) (dst proto.Message, err error) {
|
||||
if src.GetTypeUrl() == "" {
|
||||
return nil, protoimpl.X.NewError("invalid empty type URL")
|
||||
}
|
||||
if opts.Resolver == nil {
|
||||
opts.Resolver = protoregistry.GlobalTypes
|
||||
}
|
||||
r, ok := opts.Resolver.(protoregistry.MessageTypeResolver)
|
||||
if !ok {
|
||||
return nil, protoregistry.NotFound
|
||||
}
|
||||
mt, err := r.FindMessageByURL(src.GetTypeUrl())
|
||||
if err != nil {
|
||||
if err == protoregistry.NotFound {
|
||||
return nil, err
|
||||
}
|
||||
return nil, protoimpl.X.NewError("could not resolve %q: %v", src.GetTypeUrl(), err)
|
||||
}
|
||||
dst = mt.New().Interface()
|
||||
return dst, opts.Unmarshal(src.GetValue(), dst)
|
||||
}
|
||||
|
||||
// MessageIs reports whether the underlying message is of the same type as m.
|
||||
func (x *Any) MessageIs(m proto.Message) bool {
|
||||
if m == nil {
|
||||
return false
|
||||
}
|
||||
url := x.GetTypeUrl()
|
||||
name := string(m.ProtoReflect().Descriptor().FullName())
|
||||
if !strings.HasSuffix(url, name) {
|
||||
return false
|
||||
}
|
||||
return len(url) == len(name) || url[len(url)-len(name)-1] == '/'
|
||||
}
|
||||
|
||||
// MessageName reports the full name of the underlying message,
|
||||
// returning an empty string if invalid.
|
||||
func (x *Any) MessageName() protoreflect.FullName {
|
||||
url := x.GetTypeUrl()
|
||||
name := protoreflect.FullName(url)
|
||||
if i := strings.LastIndexByte(url, '/'); i >= 0 {
|
||||
name = name[i+len("/"):]
|
||||
}
|
||||
if !name.IsValid() {
|
||||
return ""
|
||||
}
|
||||
return name
|
||||
}
|
||||
|
||||
// MarshalFrom marshals m into x as the underlying message.
|
||||
func (x *Any) MarshalFrom(m proto.Message) error {
|
||||
return MarshalFrom(x, m, proto.MarshalOptions{})
|
||||
}
|
||||
|
||||
// UnmarshalTo unmarshals the contents of the underlying message of x into m.
|
||||
// It resets m before performing the unmarshal operation.
|
||||
// It reports an error if m is not of the right message type.
|
||||
func (x *Any) UnmarshalTo(m proto.Message) error {
|
||||
return UnmarshalTo(x, m, proto.UnmarshalOptions{})
|
||||
}
|
||||
|
||||
// UnmarshalNew unmarshals the contents of the underlying message of x into
|
||||
// a newly allocated message of the specified type.
|
||||
// It reports an error if the underlying message type could not be resolved.
|
||||
func (x *Any) UnmarshalNew() (proto.Message, error) {
|
||||
return UnmarshalNew(x, proto.UnmarshalOptions{})
|
||||
}
|
||||
|
||||
func (x *Any) Reset() {
|
||||
*x = Any{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_google_protobuf_any_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Any) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*Any) ProtoMessage() {}
|
||||
|
||||
func (x *Any) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_google_protobuf_any_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use Any.ProtoReflect.Descriptor instead.
|
||||
func (*Any) Descriptor() ([]byte, []int) {
|
||||
return file_google_protobuf_any_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *Any) GetTypeUrl() string {
|
||||
if x != nil {
|
||||
return x.TypeUrl
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *Any) GetValue() []byte {
|
||||
if x != nil {
|
||||
return x.Value
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var File_google_protobuf_any_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_google_protobuf_any_proto_rawDesc = []byte{
|
||||
0x0a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
|
||||
0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f,
|
||||
0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x36, 0x0a, 0x03,
|
||||
0x41, 0x6e, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18,
|
||||
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x14,
|
||||
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76,
|
||||
0x61, 0x6c, 0x75, 0x65, 0x42, 0x76, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
|
||||
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x08, 0x41, 0x6e, 0x79,
|
||||
0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
|
||||
0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
|
||||
0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x2f,
|
||||
0x61, 0x6e, 0x79, 0x70, 0x62, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f,
|
||||
0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65,
|
||||
0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72,
|
||||
0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_google_protobuf_any_proto_rawDescOnce sync.Once
|
||||
file_google_protobuf_any_proto_rawDescData = file_google_protobuf_any_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_google_protobuf_any_proto_rawDescGZIP() []byte {
|
||||
file_google_protobuf_any_proto_rawDescOnce.Do(func() {
|
||||
file_google_protobuf_any_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_any_proto_rawDescData)
|
||||
})
|
||||
return file_google_protobuf_any_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_google_protobuf_any_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
|
||||
var file_google_protobuf_any_proto_goTypes = []interface{}{
|
||||
(*Any)(nil), // 0: google.protobuf.Any
|
||||
}
|
||||
var file_google_protobuf_any_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_google_protobuf_any_proto_init() }
|
||||
func file_google_protobuf_any_proto_init() {
|
||||
if File_google_protobuf_any_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_google_protobuf_any_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*Any); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_google_protobuf_any_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 1,
|
||||
NumExtensions: 0,
|
||||
NumServices: 0,
|
||||
},
|
||||
GoTypes: file_google_protobuf_any_proto_goTypes,
|
||||
DependencyIndexes: file_google_protobuf_any_proto_depIdxs,
|
||||
MessageInfos: file_google_protobuf_any_proto_msgTypes,
|
||||
}.Build()
|
||||
File_google_protobuf_any_proto = out.File
|
||||
file_google_protobuf_any_proto_rawDesc = nil
|
||||
file_google_protobuf_any_proto_goTypes = nil
|
||||
file_google_protobuf_any_proto_depIdxs = nil
|
||||
}
|
||||
374
vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
generated
vendored
Normal file
374
vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
generated
vendored
Normal file
@ -0,0 +1,374 @@
|
||||
// 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.
|
||||
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/duration.proto
|
||||
|
||||
// Package durationpb contains generated types for google/protobuf/duration.proto.
|
||||
//
|
||||
// The Duration message represents a signed span of time.
|
||||
//
|
||||
// # Conversion to a Go Duration
|
||||
//
|
||||
// The AsDuration method can be used to convert a Duration message to a
|
||||
// standard Go time.Duration value:
|
||||
//
|
||||
// d := dur.AsDuration()
|
||||
// ... // make use of d as a time.Duration
|
||||
//
|
||||
// Converting to a time.Duration is a common operation so that the extensive
|
||||
// set of time-based operations provided by the time package can be leveraged.
|
||||
// See https://golang.org/pkg/time for more information.
|
||||
//
|
||||
// The AsDuration method performs the conversion on a best-effort basis.
|
||||
// Durations with denormal values (e.g., nanoseconds beyond -99999999 and
|
||||
// +99999999, inclusive; or seconds and nanoseconds with opposite signs)
|
||||
// are normalized during the conversion to a time.Duration. To manually check for
|
||||
// invalid Duration per the documented limitations in duration.proto,
|
||||
// additionally call the CheckValid method:
|
||||
//
|
||||
// if err := dur.CheckValid(); err != nil {
|
||||
// ... // handle error
|
||||
// }
|
||||
//
|
||||
// Note that the documented limitations in duration.proto does not protect a
|
||||
// Duration from overflowing the representable range of a time.Duration in Go.
|
||||
// The AsDuration method uses saturation arithmetic such that an overflow clamps
|
||||
// the resulting value to the closest representable value (e.g., math.MaxInt64
|
||||
// for positive overflow and math.MinInt64 for negative overflow).
|
||||
//
|
||||
// # Conversion from a Go Duration
|
||||
//
|
||||
// The durationpb.New function can be used to construct a Duration message
|
||||
// from a standard Go time.Duration value:
|
||||
//
|
||||
// dur := durationpb.New(d)
|
||||
// ... // make use of d as a *durationpb.Duration
|
||||
package durationpb
|
||||
|
||||
import (
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
math "math"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
time "time"
|
||||
)
|
||||
|
||||
// A Duration represents a signed, fixed-length span of time represented
|
||||
// as a count of seconds and fractions of seconds at nanosecond
|
||||
// resolution. It is independent of any calendar and concepts like "day"
|
||||
// or "month". It is related to Timestamp in that the difference between
|
||||
// two Timestamp values is a Duration and it can be added or subtracted
|
||||
// from a Timestamp. Range is approximately +-10,000 years.
|
||||
//
|
||||
// # Examples
|
||||
//
|
||||
// Example 1: Compute Duration from two Timestamps in pseudo code.
|
||||
//
|
||||
// Timestamp start = ...;
|
||||
// Timestamp end = ...;
|
||||
// Duration duration = ...;
|
||||
//
|
||||
// duration.seconds = end.seconds - start.seconds;
|
||||
// duration.nanos = end.nanos - start.nanos;
|
||||
//
|
||||
// if (duration.seconds < 0 && duration.nanos > 0) {
|
||||
// duration.seconds += 1;
|
||||
// duration.nanos -= 1000000000;
|
||||
// } else if (duration.seconds > 0 && duration.nanos < 0) {
|
||||
// duration.seconds -= 1;
|
||||
// duration.nanos += 1000000000;
|
||||
// }
|
||||
//
|
||||
// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
|
||||
//
|
||||
// Timestamp start = ...;
|
||||
// Duration duration = ...;
|
||||
// Timestamp end = ...;
|
||||
//
|
||||
// end.seconds = start.seconds + duration.seconds;
|
||||
// end.nanos = start.nanos + duration.nanos;
|
||||
//
|
||||
// if (end.nanos < 0) {
|
||||
// end.seconds -= 1;
|
||||
// end.nanos += 1000000000;
|
||||
// } else if (end.nanos >= 1000000000) {
|
||||
// end.seconds += 1;
|
||||
// end.nanos -= 1000000000;
|
||||
// }
|
||||
//
|
||||
// Example 3: Compute Duration from datetime.timedelta in Python.
|
||||
//
|
||||
// td = datetime.timedelta(days=3, minutes=10)
|
||||
// duration = Duration()
|
||||
// duration.FromTimedelta(td)
|
||||
//
|
||||
// # JSON Mapping
|
||||
//
|
||||
// In JSON format, the Duration type is encoded as a string rather than an
|
||||
// object, where the string ends in the suffix "s" (indicating seconds) and
|
||||
// is preceded by the number of seconds, with nanoseconds expressed as
|
||||
// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
|
||||
// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
|
||||
// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
|
||||
// microsecond should be expressed in JSON format as "3.000001s".
|
||||
type Duration struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Signed seconds of the span of time. Must be from -315,576,000,000
|
||||
// to +315,576,000,000 inclusive. Note: these bounds are computed from:
|
||||
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
|
||||
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
|
||||
// Signed fractions of a second at nanosecond resolution of the span
|
||||
// of time. 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. Must be from -999,999,999
|
||||
// to +999,999,999 inclusive.
|
||||
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
|
||||
}
|
||||
|
||||
// New constructs a new Duration from the provided time.Duration.
|
||||
func New(d time.Duration) *Duration {
|
||||
nanos := d.Nanoseconds()
|
||||
secs := nanos / 1e9
|
||||
nanos -= secs * 1e9
|
||||
return &Duration{Seconds: int64(secs), Nanos: int32(nanos)}
|
||||
}
|
||||
|
||||
// AsDuration converts x to a time.Duration,
|
||||
// returning the closest duration value in the event of overflow.
|
||||
func (x *Duration) AsDuration() time.Duration {
|
||||
secs := x.GetSeconds()
|
||||
nanos := x.GetNanos()
|
||||
d := time.Duration(secs) * time.Second
|
||||
overflow := d/time.Second != time.Duration(secs)
|
||||
d += time.Duration(nanos) * time.Nanosecond
|
||||
overflow = overflow || (secs < 0 && nanos < 0 && d > 0)
|
||||
overflow = overflow || (secs > 0 && nanos > 0 && d < 0)
|
||||
if overflow {
|
||||
switch {
|
||||
case secs < 0:
|
||||
return time.Duration(math.MinInt64)
|
||||
case secs > 0:
|
||||
return time.Duration(math.MaxInt64)
|
||||
}
|
||||
}
|
||||
return d
|
||||
}
|
||||
|
||||
// IsValid reports whether the duration is valid.
|
||||
// It is equivalent to CheckValid == nil.
|
||||
func (x *Duration) IsValid() bool {
|
||||
return x.check() == 0
|
||||
}
|
||||
|
||||
// CheckValid returns an error if the duration is invalid.
|
||||
// In particular, it checks whether the value is within the range of
|
||||
// -10000 years to +10000 years inclusive.
|
||||
// An error is reported for a nil Duration.
|
||||
func (x *Duration) CheckValid() error {
|
||||
switch x.check() {
|
||||
case invalidNil:
|
||||
return protoimpl.X.NewError("invalid nil Duration")
|
||||
case invalidUnderflow:
|
||||
return protoimpl.X.NewError("duration (%v) exceeds -10000 years", x)
|
||||
case invalidOverflow:
|
||||
return protoimpl.X.NewError("duration (%v) exceeds +10000 years", x)
|
||||
case invalidNanosRange:
|
||||
return protoimpl.X.NewError("duration (%v) has out-of-range nanos", x)
|
||||
case invalidNanosSign:
|
||||
return protoimpl.X.NewError("duration (%v) has seconds and nanos with different signs", x)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
const (
|
||||
_ = iota
|
||||
invalidNil
|
||||
invalidUnderflow
|
||||
invalidOverflow
|
||||
invalidNanosRange
|
||||
invalidNanosSign
|
||||
)
|
||||
|
||||
func (x *Duration) check() uint {
|
||||
const absDuration = 315576000000 // 10000yr * 365.25day/yr * 24hr/day * 60min/hr * 60sec/min
|
||||
secs := x.GetSeconds()
|
||||
nanos := x.GetNanos()
|
||||
switch {
|
||||
case x == nil:
|
||||
return invalidNil
|
||||
case secs < -absDuration:
|
||||
return invalidUnderflow
|
||||
case secs > +absDuration:
|
||||
return invalidOverflow
|
||||
case nanos <= -1e9 || nanos >= +1e9:
|
||||
return invalidNanosRange
|
||||
case (secs > 0 && nanos < 0) || (secs < 0 && nanos > 0):
|
||||
return invalidNanosSign
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Duration) Reset() {
|
||||
*x = Duration{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_google_protobuf_duration_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Duration) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*Duration) ProtoMessage() {}
|
||||
|
||||
func (x *Duration) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_google_protobuf_duration_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use Duration.ProtoReflect.Descriptor instead.
|
||||
func (*Duration) Descriptor() ([]byte, []int) {
|
||||
return file_google_protobuf_duration_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *Duration) GetSeconds() int64 {
|
||||
if x != nil {
|
||||
return x.Seconds
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *Duration) GetNanos() int32 {
|
||||
if x != nil {
|
||||
return x.Nanos
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
var File_google_protobuf_duration_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_google_protobuf_duration_proto_rawDesc = []byte{
|
||||
0x0a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
|
||||
0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
|
||||
0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
|
||||
0x66, 0x22, 0x3a, 0x0a, 0x08, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a,
|
||||
0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07,
|
||||
0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73,
|
||||
0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42, 0x83, 0x01,
|
||||
0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
|
||||
0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0d, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
|
||||
0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67,
|
||||
0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
|
||||
0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x2f, 0x64,
|
||||
0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x70, 0x62, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47,
|
||||
0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74,
|
||||
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79,
|
||||
0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_google_protobuf_duration_proto_rawDescOnce sync.Once
|
||||
file_google_protobuf_duration_proto_rawDescData = file_google_protobuf_duration_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_google_protobuf_duration_proto_rawDescGZIP() []byte {
|
||||
file_google_protobuf_duration_proto_rawDescOnce.Do(func() {
|
||||
file_google_protobuf_duration_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_duration_proto_rawDescData)
|
||||
})
|
||||
return file_google_protobuf_duration_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_google_protobuf_duration_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
|
||||
var file_google_protobuf_duration_proto_goTypes = []interface{}{
|
||||
(*Duration)(nil), // 0: google.protobuf.Duration
|
||||
}
|
||||
var file_google_protobuf_duration_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_google_protobuf_duration_proto_init() }
|
||||
func file_google_protobuf_duration_proto_init() {
|
||||
if File_google_protobuf_duration_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_google_protobuf_duration_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*Duration); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_google_protobuf_duration_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 1,
|
||||
NumExtensions: 0,
|
||||
NumServices: 0,
|
||||
},
|
||||
GoTypes: file_google_protobuf_duration_proto_goTypes,
|
||||
DependencyIndexes: file_google_protobuf_duration_proto_depIdxs,
|
||||
MessageInfos: file_google_protobuf_duration_proto_msgTypes,
|
||||
}.Build()
|
||||
File_google_protobuf_duration_proto = out.File
|
||||
file_google_protobuf_duration_proto_rawDesc = nil
|
||||
file_google_protobuf_duration_proto_goTypes = nil
|
||||
file_google_protobuf_duration_proto_depIdxs = nil
|
||||
}
|
||||
166
vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
generated
vendored
Normal file
166
vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
generated
vendored
Normal file
@ -0,0 +1,166 @@
|
||||
// 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.
|
||||
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/empty.proto
|
||||
|
||||
package emptypb
|
||||
|
||||
import (
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
)
|
||||
|
||||
// A generic empty message that you can re-use to avoid defining duplicated
|
||||
// empty messages in your APIs. A typical example is to use it as the request
|
||||
// or the response type of an API method. For instance:
|
||||
//
|
||||
// service Foo {
|
||||
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
|
||||
// }
|
||||
type Empty struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
}
|
||||
|
||||
func (x *Empty) Reset() {
|
||||
*x = Empty{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_google_protobuf_empty_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Empty) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*Empty) ProtoMessage() {}
|
||||
|
||||
func (x *Empty) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_google_protobuf_empty_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
|
||||
func (*Empty) Descriptor() ([]byte, []int) {
|
||||
return file_google_protobuf_empty_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
var File_google_protobuf_empty_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_google_protobuf_empty_proto_rawDesc = []byte{
|
||||
0x0a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
|
||||
0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67,
|
||||
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x07,
|
||||
0x0a, 0x05, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x7d, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
|
||||
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0a,
|
||||
0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2e, 0x67, 0x6f,
|
||||
0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
|
||||
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x6b,
|
||||
0x6e, 0x6f, 0x77, 0x6e, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x70, 0x62, 0xf8, 0x01, 0x01, 0xa2,
|
||||
0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50,
|
||||
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77,
|
||||
0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_google_protobuf_empty_proto_rawDescOnce sync.Once
|
||||
file_google_protobuf_empty_proto_rawDescData = file_google_protobuf_empty_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_google_protobuf_empty_proto_rawDescGZIP() []byte {
|
||||
file_google_protobuf_empty_proto_rawDescOnce.Do(func() {
|
||||
file_google_protobuf_empty_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_empty_proto_rawDescData)
|
||||
})
|
||||
return file_google_protobuf_empty_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_google_protobuf_empty_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
|
||||
var file_google_protobuf_empty_proto_goTypes = []interface{}{
|
||||
(*Empty)(nil), // 0: google.protobuf.Empty
|
||||
}
|
||||
var file_google_protobuf_empty_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_google_protobuf_empty_proto_init() }
|
||||
func file_google_protobuf_empty_proto_init() {
|
||||
if File_google_protobuf_empty_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_google_protobuf_empty_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*Empty); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_google_protobuf_empty_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 1,
|
||||
NumExtensions: 0,
|
||||
NumServices: 0,
|
||||
},
|
||||
GoTypes: file_google_protobuf_empty_proto_goTypes,
|
||||
DependencyIndexes: file_google_protobuf_empty_proto_depIdxs,
|
||||
MessageInfos: file_google_protobuf_empty_proto_msgTypes,
|
||||
}.Build()
|
||||
File_google_protobuf_empty_proto = out.File
|
||||
file_google_protobuf_empty_proto_rawDesc = nil
|
||||
file_google_protobuf_empty_proto_goTypes = nil
|
||||
file_google_protobuf_empty_proto_depIdxs = nil
|
||||
}
|
||||
383
vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
generated
vendored
Normal file
383
vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
generated
vendored
Normal file
@ -0,0 +1,383 @@
|
||||
// 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.
|
||||
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/timestamp.proto
|
||||
|
||||
// Package timestamppb contains generated types for google/protobuf/timestamp.proto.
|
||||
//
|
||||
// The Timestamp message represents a timestamp,
|
||||
// an instant in time since the Unix epoch (January 1st, 1970).
|
||||
//
|
||||
// # Conversion to a Go Time
|
||||
//
|
||||
// The AsTime method can be used to convert a Timestamp message to a
|
||||
// standard Go time.Time value in UTC:
|
||||
//
|
||||
// t := ts.AsTime()
|
||||
// ... // make use of t as a time.Time
|
||||
//
|
||||
// Converting to a time.Time is a common operation so that the extensive
|
||||
// set of time-based operations provided by the time package can be leveraged.
|
||||
// See https://golang.org/pkg/time for more information.
|
||||
//
|
||||
// The AsTime method performs the conversion on a best-effort basis. Timestamps
|
||||
// with denormal values (e.g., nanoseconds beyond 0 and 99999999, inclusive)
|
||||
// are normalized during the conversion to a time.Time. To manually check for
|
||||
// invalid Timestamps per the documented limitations in timestamp.proto,
|
||||
// additionally call the CheckValid method:
|
||||
//
|
||||
// if err := ts.CheckValid(); err != nil {
|
||||
// ... // handle error
|
||||
// }
|
||||
//
|
||||
// # Conversion from a Go Time
|
||||
//
|
||||
// The timestamppb.New function can be used to construct a Timestamp message
|
||||
// from a standard Go time.Time value:
|
||||
//
|
||||
// ts := timestamppb.New(t)
|
||||
// ... // make use of ts as a *timestamppb.Timestamp
|
||||
//
|
||||
// In order to construct a Timestamp representing the current time, use Now:
|
||||
//
|
||||
// ts := timestamppb.Now()
|
||||
// ... // make use of ts as a *timestamppb.Timestamp
|
||||
package timestamppb
|
||||
|
||||
import (
|
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
||||
reflect "reflect"
|
||||
sync "sync"
|
||||
time "time"
|
||||
)
|
||||
|
||||
// A Timestamp represents a point in time independent of any time zone or local
|
||||
// calendar, encoded as a count of seconds and fractions of seconds at
|
||||
// nanosecond resolution. The count is relative to an epoch at UTC midnight on
|
||||
// January 1, 1970, in the proleptic Gregorian calendar which extends the
|
||||
// Gregorian calendar backwards to year one.
|
||||
//
|
||||
// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
|
||||
// second table is needed for interpretation, using a [24-hour linear
|
||||
// smear](https://developers.google.com/time/smear).
|
||||
//
|
||||
// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
|
||||
// restricting to that range, we ensure that we can convert to and from [RFC
|
||||
// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
|
||||
//
|
||||
// # Examples
|
||||
//
|
||||
// Example 1: Compute Timestamp from POSIX `time()`.
|
||||
//
|
||||
// Timestamp timestamp;
|
||||
// timestamp.set_seconds(time(NULL));
|
||||
// timestamp.set_nanos(0);
|
||||
//
|
||||
// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
|
||||
//
|
||||
// struct timeval tv;
|
||||
// gettimeofday(&tv, NULL);
|
||||
//
|
||||
// Timestamp timestamp;
|
||||
// timestamp.set_seconds(tv.tv_sec);
|
||||
// timestamp.set_nanos(tv.tv_usec * 1000);
|
||||
//
|
||||
// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
|
||||
//
|
||||
// FILETIME ft;
|
||||
// GetSystemTimeAsFileTime(&ft);
|
||||
// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
|
||||
//
|
||||
// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
|
||||
// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
|
||||
// Timestamp timestamp;
|
||||
// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
|
||||
// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
|
||||
//
|
||||
// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
|
||||
//
|
||||
// long millis = System.currentTimeMillis();
|
||||
//
|
||||
// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
|
||||
// .setNanos((int) ((millis % 1000) * 1000000)).build();
|
||||
//
|
||||
// Example 5: Compute Timestamp from Java `Instant.now()`.
|
||||
//
|
||||
// Instant now = Instant.now();
|
||||
//
|
||||
// Timestamp timestamp =
|
||||
// Timestamp.newBuilder().setSeconds(now.getEpochSecond())
|
||||
// .setNanos(now.getNano()).build();
|
||||
//
|
||||
// Example 6: Compute Timestamp from current time in Python.
|
||||
//
|
||||
// timestamp = Timestamp()
|
||||
// timestamp.GetCurrentTime()
|
||||
//
|
||||
// # JSON Mapping
|
||||
//
|
||||
// In JSON format, the Timestamp type is encoded as a string in the
|
||||
// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
|
||||
// format is "{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 (i.e. up to 1 nanosecond resolution),
|
||||
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
|
||||
// is required. A proto3 JSON serializer should always use UTC (as indicated by
|
||||
// "Z") when printing the Timestamp type and a proto3 JSON parser should be
|
||||
// able to accept both UTC and other timezones (as indicated by an offset).
|
||||
//
|
||||
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
|
||||
// 01:30 UTC on January 15, 2017.
|
||||
//
|
||||
// In JavaScript, one can convert a Date object to this format using the
|
||||
// standard
|
||||
// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
|
||||
// method. In Python, a standard `datetime.datetime` object can be converted
|
||||
// to this format using
|
||||
// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
|
||||
// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
|
||||
// the Joda Time's [`ISODateTimeFormat.dateTime()`](
|
||||
// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
|
||||
// ) to obtain a formatter capable of generating timestamps in this format.
|
||||
type Timestamp struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
// Represents seconds of UTC time since Unix epoch
|
||||
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
|
||||
// 9999-12-31T23:59:59Z inclusive.
|
||||
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
|
||||
// Non-negative fractions of a second at nanosecond resolution. Negative
|
||||
// second values with fractions must still have non-negative nanos values
|
||||
// that count forward in time. Must be from 0 to 999,999,999
|
||||
// inclusive.
|
||||
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
|
||||
}
|
||||
|
||||
// Now constructs a new Timestamp from the current time.
|
||||
func Now() *Timestamp {
|
||||
return New(time.Now())
|
||||
}
|
||||
|
||||
// New constructs a new Timestamp from the provided time.Time.
|
||||
func New(t time.Time) *Timestamp {
|
||||
return &Timestamp{Seconds: int64(t.Unix()), Nanos: int32(t.Nanosecond())}
|
||||
}
|
||||
|
||||
// AsTime converts x to a time.Time.
|
||||
func (x *Timestamp) AsTime() time.Time {
|
||||
return time.Unix(int64(x.GetSeconds()), int64(x.GetNanos())).UTC()
|
||||
}
|
||||
|
||||
// IsValid reports whether the timestamp is valid.
|
||||
// It is equivalent to CheckValid == nil.
|
||||
func (x *Timestamp) IsValid() bool {
|
||||
return x.check() == 0
|
||||
}
|
||||
|
||||
// CheckValid returns an error if the timestamp is invalid.
|
||||
// In particular, it checks whether the value represents a date that is
|
||||
// in the range of 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
|
||||
// An error is reported for a nil Timestamp.
|
||||
func (x *Timestamp) CheckValid() error {
|
||||
switch x.check() {
|
||||
case invalidNil:
|
||||
return protoimpl.X.NewError("invalid nil Timestamp")
|
||||
case invalidUnderflow:
|
||||
return protoimpl.X.NewError("timestamp (%v) before 0001-01-01", x)
|
||||
case invalidOverflow:
|
||||
return protoimpl.X.NewError("timestamp (%v) after 9999-12-31", x)
|
||||
case invalidNanos:
|
||||
return protoimpl.X.NewError("timestamp (%v) has out-of-range nanos", x)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
const (
|
||||
_ = iota
|
||||
invalidNil
|
||||
invalidUnderflow
|
||||
invalidOverflow
|
||||
invalidNanos
|
||||
)
|
||||
|
||||
func (x *Timestamp) check() uint {
|
||||
const minTimestamp = -62135596800 // Seconds between 1970-01-01T00:00:00Z and 0001-01-01T00:00:00Z, inclusive
|
||||
const maxTimestamp = +253402300799 // Seconds between 1970-01-01T00:00:00Z and 9999-12-31T23:59:59Z, inclusive
|
||||
secs := x.GetSeconds()
|
||||
nanos := x.GetNanos()
|
||||
switch {
|
||||
case x == nil:
|
||||
return invalidNil
|
||||
case secs < minTimestamp:
|
||||
return invalidUnderflow
|
||||
case secs > maxTimestamp:
|
||||
return invalidOverflow
|
||||
case nanos < 0 || nanos >= 1e9:
|
||||
return invalidNanos
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Timestamp) Reset() {
|
||||
*x = Timestamp{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *Timestamp) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*Timestamp) ProtoMessage() {}
|
||||
|
||||
func (x *Timestamp) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
|
||||
if protoimpl.UnsafeEnabled && x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use Timestamp.ProtoReflect.Descriptor instead.
|
||||
func (*Timestamp) Descriptor() ([]byte, []int) {
|
||||
return file_google_protobuf_timestamp_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *Timestamp) GetSeconds() int64 {
|
||||
if x != nil {
|
||||
return x.Seconds
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *Timestamp) GetNanos() int32 {
|
||||
if x != nil {
|
||||
return x.Nanos
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
var File_google_protobuf_timestamp_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_google_protobuf_timestamp_proto_rawDesc = []byte{
|
||||
0x0a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
|
||||
0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74,
|
||||
0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
|
||||
0x75, 0x66, 0x22, 0x3b, 0x0a, 0x09, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12,
|
||||
0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
|
||||
0x52, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e,
|
||||
0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42,
|
||||
0x85, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
|
||||
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
|
||||
0x6d, 0x70, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
|
||||
0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f,
|
||||
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x6b, 0x6e, 0x6f, 0x77,
|
||||
0x6e, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x70, 0x62, 0xf8, 0x01, 0x01,
|
||||
0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
|
||||
0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f,
|
||||
0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_google_protobuf_timestamp_proto_rawDescOnce sync.Once
|
||||
file_google_protobuf_timestamp_proto_rawDescData = file_google_protobuf_timestamp_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_google_protobuf_timestamp_proto_rawDescGZIP() []byte {
|
||||
file_google_protobuf_timestamp_proto_rawDescOnce.Do(func() {
|
||||
file_google_protobuf_timestamp_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_timestamp_proto_rawDescData)
|
||||
})
|
||||
return file_google_protobuf_timestamp_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_google_protobuf_timestamp_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
|
||||
var file_google_protobuf_timestamp_proto_goTypes = []interface{}{
|
||||
(*Timestamp)(nil), // 0: google.protobuf.Timestamp
|
||||
}
|
||||
var file_google_protobuf_timestamp_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_google_protobuf_timestamp_proto_init() }
|
||||
func file_google_protobuf_timestamp_proto_init() {
|
||||
if File_google_protobuf_timestamp_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_google_protobuf_timestamp_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
|
||||
switch v := v.(*Timestamp); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: file_google_protobuf_timestamp_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 1,
|
||||
NumExtensions: 0,
|
||||
NumServices: 0,
|
||||
},
|
||||
GoTypes: file_google_protobuf_timestamp_proto_goTypes,
|
||||
DependencyIndexes: file_google_protobuf_timestamp_proto_depIdxs,
|
||||
MessageInfos: file_google_protobuf_timestamp_proto_msgTypes,
|
||||
}.Build()
|
||||
File_google_protobuf_timestamp_proto = out.File
|
||||
file_google_protobuf_timestamp_proto_rawDesc = nil
|
||||
file_google_protobuf_timestamp_proto_goTypes = nil
|
||||
file_google_protobuf_timestamp_proto_depIdxs = nil
|
||||
}
|
||||
Reference in New Issue
Block a user