[VOL-3889] missing device reason update from flow removal after ONU reboot
Signed-off-by: mpagenko <michael.pagenkopf@adtran.com>
Change-Id: I1e3eb63e044901c814f453b99388db56ae171d00
diff --git a/VERSION b/VERSION
index c322f2e..e5ec1cc 100755
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.2.6-dev175
+1.2.6-dev176
diff --git a/go.mod b/go.mod
index 81f8227..3eade05 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@
github.com/boguslaw-wojcik/crc32a v1.0.0
github.com/cevaris/ordered_map v0.0.0-20190319150403-3adeae072e73
github.com/gogo/protobuf v1.3.2
- github.com/golang/protobuf v1.4.2
+ github.com/golang/protobuf v1.3.2
github.com/google/gopacket v1.1.17
github.com/looplab/fsm v0.1.0
github.com/opencord/omci-lib-go v0.15.4
diff --git a/go.sum b/go.sum
index a0fd282..918cb85 100644
--- a/go.sum
+++ b/go.sum
@@ -84,23 +84,13 @@
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=
github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/gopacket v1.1.17 h1:rMrlX2ZY2UbvT+sdz3+6J+pp2z+msCq9MxTU6ymxbBY=
github.com/google/gopacket v1.1.17/go.mod h1:UdDNZ1OO62aGYVnPhxT1U6aI7ukYtA/kB8vaU0diBUM=
@@ -336,13 +326,6 @@
google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA=
google.golang.org/grpc v1.25.1 h1:wdKvqQk7IttEw92GoRyKG2IDrUIpgpj6H6m81yfeMW0=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/internal/pkg/onuadaptercore/device_handler.go b/internal/pkg/onuadaptercore/device_handler.go
index 59cd8d0..b720f4f 100644
--- a/internal/pkg/onuadaptercore/device_handler.go
+++ b/internal/pkg/onuadaptercore/device_handler.go
@@ -1669,23 +1669,20 @@
// FSM stop maybe encapsulated as OnuTP method - perhaps later in context of module splitting
if dh.pOnuTP.pAniConfigFsm != nil {
for uniTP := range dh.pOnuTP.pAniConfigFsm {
- _ = dh.pOnuTP.pAniConfigFsm[uniTP].pAdaptFsm.pFsm.Event(aniEvReset)
+ dh.pOnuTP.pAniConfigFsm[uniTP].CancelProcessing()
}
}
for _, uniPort := range dh.uniEntityMap {
// reset the possibly existing VlanConfigFsm
dh.lockVlanConfig.RLock()
if pVlanFilterFsm, exist := dh.UniVlanConfigFsmMap[uniPort.uniID]; exist {
- dh.lockVlanConfig.RUnlock()
//VlanFilterFsm exists and was already started
- pVlanFilterStatemachine := pVlanFilterFsm.pAdaptFsm.pFsm
- if pVlanFilterStatemachine != nil {
- //reset of all Fsm is always accompanied by global persistency data removal
- // no need to remove specific data
- pVlanFilterFsm.RequestClearPersistency(false)
- //and reset the UniVlanConfig FSM
- _ = pVlanFilterStatemachine.Event(vlanEvReset)
- }
+ dh.lockVlanConfig.RUnlock()
+ //reset of all Fsm is always accompanied by global persistency data removal
+ // no need to remove specific data
+ pVlanFilterFsm.RequestClearPersistency(false)
+ //ensure the FSM processing is stopped in case waiting for some response
+ pVlanFilterFsm.CancelProcessing()
} else {
dh.lockVlanConfig.RUnlock()
}
@@ -1708,6 +1705,7 @@
}
dh.lockUpgradeFsm.RUnlock()
+ logger.Infow(ctx, "resetFsms done", log.Fields{"device-id": dh.deviceID})
return nil
}
@@ -2596,8 +2594,10 @@
dh.pOpenOnuAc.AcceptIncrementalEvto, aCookieSlice, aMatchVlan, aSetVlan, aSetPcp)
if pVlanFilterFsm != nil {
dh.lockVlanConfig.Lock()
+ //ensure the mutex is locked throughout the state transition to 'starting' to prevent unintended (ignored) events to be sent there
+ // (from parallel processing)
+ defer dh.lockVlanConfig.Unlock()
dh.UniVlanConfigFsmMap[apUniPort.uniID] = pVlanFilterFsm
- dh.lockVlanConfig.Unlock()
pVlanFilterStatemachine := pVlanFilterFsm.pAdaptFsm.pFsm
if pVlanFilterStatemachine != nil {
if pVlanFilterStatemachine.Is(vlanStDisabled) {
diff --git a/internal/pkg/onuadaptercore/omci_ani_config.go b/internal/pkg/onuadaptercore/omci_ani_config.go
index db0b916..01b2f34 100644
--- a/internal/pkg/onuadaptercore/omci_ani_config.go
+++ b/internal/pkg/onuadaptercore/omci_ani_config.go
@@ -23,6 +23,7 @@
"fmt"
"net"
"strconv"
+ "sync"
"time"
"github.com/cevaris/ordered_map"
@@ -112,6 +113,8 @@
techProfileID uint8
uniTpKey uniTP
requestEvent OnuDeviceEvent
+ mutexIsAwaitingResponse sync.RWMutex
+ isAwaitingResponse bool
omciMIdsResponseReceived chan bool //separate channel needed for checking multiInstance OMCI message responses
pAdaptFsm *AdapterFsm
chSuccess chan<- uint8
@@ -235,6 +238,27 @@
oFsm.chanSet = true
}
+//CancelProcessing ensures that suspended processing at waiting on some response is aborted and reset of FSM
+func (oFsm *uniPonAniConfigFsm) CancelProcessing() {
+ //mutex protection is required for possible concurrent access to FSM members
+ oFsm.mutexIsAwaitingResponse.RLock()
+ defer oFsm.mutexIsAwaitingResponse.RUnlock()
+ if oFsm.isAwaitingResponse {
+ //use channel to indicate that the response waiting shall be aborted
+ oFsm.omciMIdsResponseReceived <- false
+ }
+ // in any case (even if it might be automatically requested by above cancellation of waiting) ensure resetting the FSM
+ pAdaptFsm := oFsm.pAdaptFsm
+ if pAdaptFsm != nil {
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm.pFsm != nil {
+ _ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+ }
+ }(pAdaptFsm)
+ }
+}
+
func (oFsm *uniPonAniConfigFsm) prepareAndEnterConfigState(ctx context.Context, aPAFsm *AdapterFsm) {
if aPAFsm != nil && aPAFsm.pFsm != nil {
//stick to pythonAdapter numbering scheme
@@ -1191,20 +1215,32 @@
}
func (oFsm *uniPonAniConfigFsm) waitforOmciResponse(ctx context.Context) error {
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = true
+ oFsm.mutexIsAwaitingResponse.Unlock()
select {
// maybe be also some outside cancel (but no context modeled for the moment ...)
// case <-ctx.Done():
// logger.Infow("LockState-bridge-init message reception canceled", log.Fields{"for device-id": oFsm.deviceID})
case <-time.After(30 * time.Second): //3s was detected to be to less in 8*8 bbsim test with debug Info/Debug
logger.Warnw(ctx, "UniPonAniConfigFsm multi entity timeout", log.Fields{"for device-id": oFsm.deviceID})
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = false
+ oFsm.mutexIsAwaitingResponse.Unlock()
return fmt.Errorf("uniPonAniConfigFsm multi entity timeout %s", oFsm.deviceID)
case success := <-oFsm.omciMIdsResponseReceived:
if success {
logger.Debug(ctx, "uniPonAniConfigFsm multi entity response received")
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = false
+ oFsm.mutexIsAwaitingResponse.Unlock()
return nil
}
- // should not happen so far
- logger.Warnw(ctx, "uniPonAniConfigFsm multi entity response error", log.Fields{"for device-id": oFsm.deviceID})
- return fmt.Errorf("uniPonAniConfigFsm multi entity responseError %s", oFsm.deviceID)
+ // waiting was aborted (probably on external request)
+ logger.Debugw(ctx, "uniPonAniConfigFsm wait for multi entity response aborted", log.Fields{"for device-id": oFsm.deviceID})
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = false
+ oFsm.mutexIsAwaitingResponse.Unlock()
+ return fmt.Errorf(cErrWaitAborted)
}
}
diff --git a/internal/pkg/onuadaptercore/omci_vlan_config.go b/internal/pkg/onuadaptercore/omci_vlan_config.go
index 912af08..39a7bee 100644
--- a/internal/pkg/onuadaptercore/omci_vlan_config.go
+++ b/internal/pkg/onuadaptercore/omci_vlan_config.go
@@ -157,6 +157,8 @@
pAdaptFsm *AdapterFsm
acceptIncrementalEvtoOption bool
clearPersistency bool
+ isAwaitingResponse bool
+ mutexIsAwaitingResponse sync.RWMutex
mutexFlowParams sync.RWMutex
chCookieDeleted chan bool //channel to indicate that a specificly indicated cookie was deleted
actualUniVlanConfigRule uniVlanRuleParams
@@ -327,6 +329,27 @@
return nil
}
+//CancelProcessing ensures that suspended processing at waiting on some response is aborted and reset of FSM
+func (oFsm *UniVlanConfigFsm) CancelProcessing() {
+ //mutex protection is required for possible concurrent access to FSM members
+ oFsm.mutexIsAwaitingResponse.RLock()
+ defer oFsm.mutexIsAwaitingResponse.RUnlock()
+ if oFsm.isAwaitingResponse {
+ //use channel to indicate that the response waiting shall be aborted
+ oFsm.omciMIdsResponseReceived <- false
+ }
+ // in any case (even if it might be automatically requested by above cancellation of waiting) ensure resetting the FSM
+ pAdaptFsm := oFsm.pAdaptFsm
+ if pAdaptFsm != nil {
+ // obviously calling some FSM event here directly does not work - so trying to decouple it ...
+ go func(aPAFsm *AdapterFsm) {
+ if aPAFsm.pFsm != nil {
+ _ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+ }
+ }(pAdaptFsm)
+ }
+}
+
//GetWaitingTpID returns the TpId that the FSM might be waiting for continuation (0 if none)
func (oFsm *UniVlanConfigFsm) GetWaitingTpID() uint8 {
//mutex protection is required for possible concurrent access to FSM members
@@ -2095,21 +2118,33 @@
}
func (oFsm *UniVlanConfigFsm) waitforOmciResponse(ctx context.Context) error {
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = true
+ oFsm.mutexIsAwaitingResponse.Unlock()
select {
// maybe be also some outside cancel (but no context modeled for the moment ...)
// case <-ctx.Done():
// logger.Infow(ctx,"LockState-bridge-init message reception canceled", log.Fields{"for device-id": oFsm.deviceID})
case <-time.After(30 * time.Second): //AS FOR THE OTHER OMCI FSM's
logger.Warnw(ctx, "UniVlanConfigFsm multi entity timeout", log.Fields{"for device-id": oFsm.deviceID})
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = false
+ oFsm.mutexIsAwaitingResponse.Unlock()
return fmt.Errorf("uniVlanConfigFsm multi entity timeout %s", oFsm.deviceID)
case success := <-oFsm.omciMIdsResponseReceived:
if success {
logger.Debug(ctx, "UniVlanConfigFsm multi entity response received")
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = false
+ oFsm.mutexIsAwaitingResponse.Unlock()
return nil
}
- // should not happen so far
- logger.Warnw(ctx, "UniVlanConfigFsm multi entity response error", log.Fields{"for device-id": oFsm.deviceID})
- return fmt.Errorf("uniVlanConfigFsm multi entity responseError %s", oFsm.deviceID)
+ // waiting was aborted (probably on external request)
+ logger.Debugw(ctx, "UniVlanConfigFsm wait for multi entity response aborted", log.Fields{"for device-id": oFsm.deviceID})
+ oFsm.mutexIsAwaitingResponse.Lock()
+ oFsm.isAwaitingResponse = false
+ oFsm.mutexIsAwaitingResponse.Unlock()
+ return fmt.Errorf(cErrWaitAborted)
}
}
diff --git a/internal/pkg/onuadaptercore/onu_device_entry.go b/internal/pkg/onuadaptercore/onu_device_entry.go
index 86c34cf..db33270 100644
--- a/internal/pkg/onuadaptercore/onu_device_entry.go
+++ b/internal/pkg/onuadaptercore/onu_device_entry.go
@@ -160,6 +160,11 @@
// Add other events here as needed (alarms separate???)
)
+//AdapterFsm related error string
+//error string could be checked on waitforOmciResponse() e.g. to avoid misleading error log
+// but not used that way so far (permit error log even for wanted cancellation)
+const cErrWaitAborted = "waitResponse aborted"
+
type activityDescr struct {
databaseClass func(context.Context) error
//advertiseEvents bool
diff --git a/internal/pkg/onuadaptercore/onu_uni_tp.go b/internal/pkg/onuadaptercore/onu_uni_tp.go
index 3fdbe19..ac59445 100644
--- a/internal/pkg/onuadaptercore/onu_uni_tp.go
+++ b/internal/pkg/onuadaptercore/onu_uni_tp.go
@@ -552,6 +552,7 @@
"device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString, "Resource": aResource})
uniTPKey := uniTP{uniID: aUniID, tpID: aTpID}
+ bDeviceProcStatusUpdate := true
if cResourceGemPort == aResource {
logger.Debugw(ctx, "remove GemPort from the list of existing ones of the TP", log.Fields{
"device-id": onuTP.deviceID, "uni-id": aUniID, "path": aPathString, "GemPort": aEntryID})
@@ -640,6 +641,12 @@
return
}
} else {
+ //if we can't do the OMCI processing we also suppress the ProcStatusUpdate
+ //this is needed as in the device-down case where all FSM's are getting reset and internal data gets cleared
+ //as a consequence a possible remove-flow does not see any dependency on the TechProfile anymore and is executed (pro forma) directly
+ //a later TechProfile removal would cause the device-reason to be updated to 'techProfile-delete-success' which is not the expected state
+ // and anyway is no real useful information at that stage
+ bDeviceProcStatusUpdate = false
logger.Debugw(ctx, "uniPonAniConfigFsm delete Gem on OMCI skipped based on device state", log.Fields{
"device-id": onuTP.deviceID, "device-state": onuTP.baseDeviceHandler.getDeviceReasonString()})
}
@@ -720,6 +727,8 @@
return
}
} else {
+ //see gemPort comments
+ bDeviceProcStatusUpdate = false
logger.Debugw(ctx, "uniPonAniConfigFsm TCont cleanup on OMCI skipped based on device state", log.Fields{
"device-id": onuTP.deviceID, "device-state": onuTP.baseDeviceHandler.getDeviceReasonString()})
}
@@ -729,8 +738,10 @@
// FSM stop maybe encapsulated as OnuTP method - perhaps later in context of module splitting
_ = onuTP.pAniConfigFsm[uniTPKey].pAdaptFsm.pFsm.Event(aniEvReset)
}
- // generate deviceHandler StatusEvent in case the FSM was not invoked
- go onuTP.baseDeviceHandler.deviceProcStatusUpdate(ctx, OmciAniResourceRemoved)
+ if bDeviceProcStatusUpdate {
+ // generate deviceHandler StatusEvent in case the FSM was not invoked and OMCI processing not locked due to device state
+ go onuTP.baseDeviceHandler.deviceProcStatusUpdate(ctx, OmciAniResourceRemoved)
+ }
}
func (onuTP *onuUniTechProf) waitForTimeoutOrCompletion(
diff --git a/vendor/github.com/golang/protobuf/proto/buffer.go b/vendor/github.com/golang/protobuf/proto/buffer.go
deleted file mode 100644
index e810e6f..0000000
--- a/vendor/github.com/golang/protobuf/proto/buffer.go
+++ /dev/null
@@ -1,324 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "errors"
- "fmt"
-
- "google.golang.org/protobuf/encoding/prototext"
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/runtime/protoimpl"
-)
-
-const (
- WireVarint = 0
- WireFixed32 = 5
- WireFixed64 = 1
- WireBytes = 2
- WireStartGroup = 3
- WireEndGroup = 4
-)
-
-// EncodeVarint returns the varint encoded bytes of v.
-func EncodeVarint(v uint64) []byte {
- return protowire.AppendVarint(nil, v)
-}
-
-// SizeVarint returns the length of the varint encoded bytes of v.
-// This is equal to len(EncodeVarint(v)).
-func SizeVarint(v uint64) int {
- return protowire.SizeVarint(v)
-}
-
-// DecodeVarint parses a varint encoded integer from b,
-// returning the integer value and the length of the varint.
-// It returns (0, 0) if there is a parse error.
-func DecodeVarint(b []byte) (uint64, int) {
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, 0
- }
- return v, n
-}
-
-// Buffer is a buffer for encoding and decoding the protobuf wire format.
-// It may be reused between invocations to reduce memory usage.
-type Buffer struct {
- buf []byte
- idx int
- deterministic bool
-}
-
-// NewBuffer allocates a new Buffer initialized with buf,
-// where the contents of buf are considered the unread portion of the buffer.
-func NewBuffer(buf []byte) *Buffer {
- return &Buffer{buf: buf}
-}
-
-// SetDeterministic specifies whether to use deterministic serialization.
-//
-// Deterministic serialization guarantees that for a given binary, equal
-// messages will always be serialized to the same bytes. This implies:
-//
-// - Repeated serialization of a message will return the same bytes.
-// - Different processes of the same binary (which may be executing on
-// different machines) will serialize equal messages to the same bytes.
-//
-// Note that the deterministic serialization is NOT canonical across
-// languages. It is not guaranteed to remain stable over time. It is unstable
-// across different builds with schema changes due to unknown fields.
-// Users who need canonical serialization (e.g., persistent storage in a
-// canonical form, fingerprinting, etc.) should define their own
-// canonicalization specification and implement their own serializer rather
-// than relying on this API.
-//
-// If deterministic serialization is requested, map entries will be sorted
-// by keys in lexographical order. This is an implementation detail and
-// subject to change.
-func (b *Buffer) SetDeterministic(deterministic bool) {
- b.deterministic = deterministic
-}
-
-// SetBuf sets buf as the internal buffer,
-// where the contents of buf are considered the unread portion of the buffer.
-func (b *Buffer) SetBuf(buf []byte) {
- b.buf = buf
- b.idx = 0
-}
-
-// Reset clears the internal buffer of all written and unread data.
-func (b *Buffer) Reset() {
- b.buf = b.buf[:0]
- b.idx = 0
-}
-
-// Bytes returns the internal buffer.
-func (b *Buffer) Bytes() []byte {
- return b.buf
-}
-
-// Unread returns the unread portion of the buffer.
-func (b *Buffer) Unread() []byte {
- return b.buf[b.idx:]
-}
-
-// Marshal appends the wire-format encoding of m to the buffer.
-func (b *Buffer) Marshal(m Message) error {
- var err error
- b.buf, err = marshalAppend(b.buf, m, b.deterministic)
- return err
-}
-
-// Unmarshal parses the wire-format message in the buffer and
-// places the decoded results in m.
-// It does not reset m before unmarshaling.
-func (b *Buffer) Unmarshal(m Message) error {
- err := UnmarshalMerge(b.Unread(), m)
- b.idx = len(b.buf)
- return err
-}
-
-type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields }
-
-func (m *unknownFields) String() string { panic("not implemented") }
-func (m *unknownFields) Reset() { panic("not implemented") }
-func (m *unknownFields) ProtoMessage() { panic("not implemented") }
-
-// DebugPrint dumps the encoded bytes of b with a header and footer including s
-// to stdout. This is only intended for debugging.
-func (*Buffer) DebugPrint(s string, b []byte) {
- m := MessageReflect(new(unknownFields))
- m.SetUnknown(b)
- b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface())
- fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s)
-}
-
-// EncodeVarint appends an unsigned varint encoding to the buffer.
-func (b *Buffer) EncodeVarint(v uint64) error {
- b.buf = protowire.AppendVarint(b.buf, v)
- return nil
-}
-
-// EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.
-func (b *Buffer) EncodeZigzag32(v uint64) error {
- return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
-}
-
-// EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.
-func (b *Buffer) EncodeZigzag64(v uint64) error {
- return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63))))
-}
-
-// EncodeFixed32 appends a 32-bit little-endian integer to the buffer.
-func (b *Buffer) EncodeFixed32(v uint64) error {
- b.buf = protowire.AppendFixed32(b.buf, uint32(v))
- return nil
-}
-
-// EncodeFixed64 appends a 64-bit little-endian integer to the buffer.
-func (b *Buffer) EncodeFixed64(v uint64) error {
- b.buf = protowire.AppendFixed64(b.buf, uint64(v))
- return nil
-}
-
-// EncodeRawBytes appends a length-prefixed raw bytes to the buffer.
-func (b *Buffer) EncodeRawBytes(v []byte) error {
- b.buf = protowire.AppendBytes(b.buf, v)
- return nil
-}
-
-// EncodeStringBytes appends a length-prefixed raw bytes to the buffer.
-// It does not validate whether v contains valid UTF-8.
-func (b *Buffer) EncodeStringBytes(v string) error {
- b.buf = protowire.AppendString(b.buf, v)
- return nil
-}
-
-// EncodeMessage appends a length-prefixed encoded message to the buffer.
-func (b *Buffer) EncodeMessage(m Message) error {
- var err error
- b.buf = protowire.AppendVarint(b.buf, uint64(Size(m)))
- b.buf, err = marshalAppend(b.buf, m, b.deterministic)
- return err
-}
-
-// DecodeVarint consumes an encoded unsigned varint from the buffer.
-func (b *Buffer) DecodeVarint() (uint64, error) {
- v, n := protowire.ConsumeVarint(b.buf[b.idx:])
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- b.idx += n
- return uint64(v), nil
-}
-
-// DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.
-func (b *Buffer) DecodeZigzag32() (uint64, error) {
- v, err := b.DecodeVarint()
- if err != nil {
- return 0, err
- }
- return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil
-}
-
-// DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.
-func (b *Buffer) DecodeZigzag64() (uint64, error) {
- v, err := b.DecodeVarint()
- if err != nil {
- return 0, err
- }
- return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil
-}
-
-// DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.
-func (b *Buffer) DecodeFixed32() (uint64, error) {
- v, n := protowire.ConsumeFixed32(b.buf[b.idx:])
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- b.idx += n
- return uint64(v), nil
-}
-
-// DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.
-func (b *Buffer) DecodeFixed64() (uint64, error) {
- v, n := protowire.ConsumeFixed64(b.buf[b.idx:])
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- b.idx += n
- return uint64(v), nil
-}
-
-// DecodeRawBytes consumes a length-prefixed raw bytes from the buffer.
-// If alloc is specified, it returns a copy the raw bytes
-// rather than a sub-slice of the buffer.
-func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) {
- v, n := protowire.ConsumeBytes(b.buf[b.idx:])
- if n < 0 {
- return nil, protowire.ParseError(n)
- }
- b.idx += n
- if alloc {
- v = append([]byte(nil), v...)
- }
- return v, nil
-}
-
-// DecodeStringBytes consumes a length-prefixed raw bytes from the buffer.
-// It does not validate whether the raw bytes contain valid UTF-8.
-func (b *Buffer) DecodeStringBytes() (string, error) {
- v, n := protowire.ConsumeString(b.buf[b.idx:])
- if n < 0 {
- return "", protowire.ParseError(n)
- }
- b.idx += n
- return v, nil
-}
-
-// DecodeMessage consumes a length-prefixed message from the buffer.
-// It does not reset m before unmarshaling.
-func (b *Buffer) DecodeMessage(m Message) error {
- v, err := b.DecodeRawBytes(false)
- if err != nil {
- return err
- }
- return UnmarshalMerge(v, m)
-}
-
-// DecodeGroup consumes a message group from the buffer.
-// It assumes that the start group marker has already been consumed and
-// consumes all bytes until (and including the end group marker).
-// It does not reset m before unmarshaling.
-func (b *Buffer) DecodeGroup(m Message) error {
- v, n, err := consumeGroup(b.buf[b.idx:])
- if err != nil {
- return err
- }
- b.idx += n
- return UnmarshalMerge(v, m)
-}
-
-// consumeGroup parses b until it finds an end group marker, returning
-// the raw bytes of the message (excluding the end group marker) and the
-// the total length of the message (including the end group marker).
-func consumeGroup(b []byte) ([]byte, int, error) {
- b0 := b
- depth := 1 // assume this follows a start group marker
- for {
- _, wtyp, tagLen := protowire.ConsumeTag(b)
- if tagLen < 0 {
- return nil, 0, protowire.ParseError(tagLen)
- }
- b = b[tagLen:]
-
- var valLen int
- switch wtyp {
- case protowire.VarintType:
- _, valLen = protowire.ConsumeVarint(b)
- case protowire.Fixed32Type:
- _, valLen = protowire.ConsumeFixed32(b)
- case protowire.Fixed64Type:
- _, valLen = protowire.ConsumeFixed64(b)
- case protowire.BytesType:
- _, valLen = protowire.ConsumeBytes(b)
- case protowire.StartGroupType:
- depth++
- case protowire.EndGroupType:
- depth--
- default:
- return nil, 0, errors.New("proto: cannot parse reserved wire type")
- }
- if valLen < 0 {
- return nil, 0, protowire.ParseError(valLen)
- }
- b = b[valLen:]
-
- if depth == 0 {
- return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil
- }
- }
-}
diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go
new file mode 100644
index 0000000..3cd3249
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/clone.go
@@ -0,0 +1,253 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+// Protocol buffer deep copy and merge.
+// TODO: RawMessage.
+
+package proto
+
+import (
+ "fmt"
+ "log"
+ "reflect"
+ "strings"
+)
+
+// Clone returns a deep copy of a protocol buffer.
+func Clone(src Message) Message {
+ in := reflect.ValueOf(src)
+ if in.IsNil() {
+ return src
+ }
+ out := reflect.New(in.Type().Elem())
+ dst := out.Interface().(Message)
+ Merge(dst, src)
+ return dst
+}
+
+// Merger is the interface representing objects that can merge messages of the same type.
+type Merger interface {
+ // Merge merges src into this message.
+ // Required and optional fields that are set in src will be set to that value in dst.
+ // Elements of repeated fields will be appended.
+ //
+ // Merge may panic if called with a different argument type than the receiver.
+ Merge(src Message)
+}
+
+// generatedMerger is the custom merge method that generated protos will have.
+// We must add this method since a generate Merge method will conflict with
+// many existing protos that have a Merge data field already defined.
+type generatedMerger interface {
+ XXX_Merge(src Message)
+}
+
+// Merge merges src into dst.
+// Required and optional fields that are set in src will be set to that value in dst.
+// Elements of repeated fields will be appended.
+// Merge panics if src and dst are not the same type, or if dst is nil.
+func Merge(dst, src Message) {
+ if m, ok := dst.(Merger); ok {
+ m.Merge(src)
+ return
+ }
+
+ in := reflect.ValueOf(src)
+ out := reflect.ValueOf(dst)
+ if out.IsNil() {
+ panic("proto: nil destination")
+ }
+ if in.Type() != out.Type() {
+ panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
+ }
+ if in.IsNil() {
+ return // Merge from nil src is a noop
+ }
+ if m, ok := dst.(generatedMerger); ok {
+ m.XXX_Merge(src)
+ return
+ }
+ mergeStruct(out.Elem(), in.Elem())
+}
+
+func mergeStruct(out, in reflect.Value) {
+ sprop := GetProperties(in.Type())
+ for i := 0; i < in.NumField(); i++ {
+ f := in.Type().Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
+ }
+
+ if emIn, err := extendable(in.Addr().Interface()); err == nil {
+ emOut, _ := extendable(out.Addr().Interface())
+ mIn, muIn := emIn.extensionsRead()
+ if mIn != nil {
+ mOut := emOut.extensionsWrite()
+ muIn.Lock()
+ mergeExtension(mOut, mIn)
+ muIn.Unlock()
+ }
+ }
+
+ uf := in.FieldByName("XXX_unrecognized")
+ if !uf.IsValid() {
+ return
+ }
+ uin := uf.Bytes()
+ if len(uin) > 0 {
+ out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
+ }
+}
+
+// mergeAny performs a merge between two values of the same type.
+// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
+// prop is set if this is a struct field (it may be nil).
+func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
+ if in.Type() == protoMessageType {
+ if !in.IsNil() {
+ if out.IsNil() {
+ out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
+ } else {
+ Merge(out.Interface().(Message), in.Interface().(Message))
+ }
+ }
+ return
+ }
+ switch in.Kind() {
+ case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+ reflect.String, reflect.Uint32, reflect.Uint64:
+ if !viaPtr && isProto3Zero(in) {
+ return
+ }
+ out.Set(in)
+ case reflect.Interface:
+ // Probably a oneof field; copy non-nil values.
+ if in.IsNil() {
+ return
+ }
+ // Allocate destination if it is not set, or set to a different type.
+ // Otherwise we will merge as normal.
+ if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
+ out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
+ }
+ mergeAny(out.Elem(), in.Elem(), false, nil)
+ case reflect.Map:
+ if in.Len() == 0 {
+ return
+ }
+ if out.IsNil() {
+ out.Set(reflect.MakeMap(in.Type()))
+ }
+ // For maps with value types of *T or []byte we need to deep copy each value.
+ elemKind := in.Type().Elem().Kind()
+ for _, key := range in.MapKeys() {
+ var val reflect.Value
+ switch elemKind {
+ case reflect.Ptr:
+ val = reflect.New(in.Type().Elem().Elem())
+ mergeAny(val, in.MapIndex(key), false, nil)
+ case reflect.Slice:
+ val = in.MapIndex(key)
+ val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+ default:
+ val = in.MapIndex(key)
+ }
+ out.SetMapIndex(key, val)
+ }
+ case reflect.Ptr:
+ if in.IsNil() {
+ return
+ }
+ if out.IsNil() {
+ out.Set(reflect.New(in.Elem().Type()))
+ }
+ mergeAny(out.Elem(), in.Elem(), true, nil)
+ case reflect.Slice:
+ if in.IsNil() {
+ return
+ }
+ if in.Type().Elem().Kind() == reflect.Uint8 {
+ // []byte is a scalar bytes field, not a repeated field.
+
+ // Edge case: if this is in a proto3 message, a zero length
+ // bytes field is considered the zero value, and should not
+ // be merged.
+ if prop != nil && prop.proto3 && in.Len() == 0 {
+ return
+ }
+
+ // Make a deep copy.
+ // Append to []byte{} instead of []byte(nil) so that we never end up
+ // with a nil result.
+ out.SetBytes(append([]byte{}, in.Bytes()...))
+ return
+ }
+ n := in.Len()
+ if out.IsNil() {
+ out.Set(reflect.MakeSlice(in.Type(), 0, n))
+ }
+ switch in.Type().Elem().Kind() {
+ case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+ reflect.String, reflect.Uint32, reflect.Uint64:
+ out.Set(reflect.AppendSlice(out, in))
+ default:
+ for i := 0; i < n; i++ {
+ x := reflect.Indirect(reflect.New(in.Type().Elem()))
+ mergeAny(x, in.Index(i), false, nil)
+ out.Set(reflect.Append(out, x))
+ }
+ }
+ case reflect.Struct:
+ mergeStruct(out, in)
+ default:
+ // unknown type, so not a protocol buffer
+ log.Printf("proto: don't know how to copy %v", in)
+ }
+}
+
+func mergeExtension(out, in map[int32]Extension) {
+ for extNum, eIn := range in {
+ eOut := Extension{desc: eIn.desc}
+ if eIn.value != nil {
+ v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
+ mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
+ eOut.value = v.Interface()
+ }
+ if eIn.enc != nil {
+ eOut.enc = make([]byte, len(eIn.enc))
+ copy(eOut.enc, eIn.enc)
+ }
+
+ out[extNum] = eOut
+ }
+}
diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
new file mode 100644
index 0000000..63b0f08
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/decode.go
@@ -0,0 +1,427 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+/*
+ * Routines for decoding protocol buffer data to construct in-memory representations.
+ */
+
+import (
+ "errors"
+ "fmt"
+ "io"
+)
+
+// errOverflow is returned when an integer is too large to be represented.
+var errOverflow = errors.New("proto: integer overflow")
+
+// ErrInternalBadWireType is returned by generated code when an incorrect
+// wire type is encountered. It does not get returned to user code.
+var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
+
+// DecodeVarint reads a varint-encoded integer from the slice.
+// It returns the integer and the number of bytes consumed, or
+// zero if there is not enough.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func DecodeVarint(buf []byte) (x uint64, n int) {
+ for shift := uint(0); shift < 64; shift += 7 {
+ if n >= len(buf) {
+ return 0, 0
+ }
+ b := uint64(buf[n])
+ n++
+ x |= (b & 0x7F) << shift
+ if (b & 0x80) == 0 {
+ return x, n
+ }
+ }
+
+ // The number is too large to represent in a 64-bit value.
+ return 0, 0
+}
+
+func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
+ i := p.index
+ l := len(p.buf)
+
+ for shift := uint(0); shift < 64; shift += 7 {
+ if i >= l {
+ err = io.ErrUnexpectedEOF
+ return
+ }
+ b := p.buf[i]
+ i++
+ x |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ p.index = i
+ return
+ }
+ }
+
+ // The number is too large to represent in a 64-bit value.
+ err = errOverflow
+ return
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) DecodeVarint() (x uint64, err error) {
+ i := p.index
+ buf := p.buf
+
+ if i >= len(buf) {
+ return 0, io.ErrUnexpectedEOF
+ } else if buf[i] < 0x80 {
+ p.index++
+ return uint64(buf[i]), nil
+ } else if len(buf)-i < 10 {
+ return p.decodeVarintSlow()
+ }
+
+ var b uint64
+ // we already checked the first byte
+ x = uint64(buf[i]) - 0x80
+ i++
+
+ b = uint64(buf[i])
+ i++
+ x += b << 7
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 7
+
+ b = uint64(buf[i])
+ i++
+ x += b << 14
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 14
+
+ b = uint64(buf[i])
+ i++
+ x += b << 21
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 21
+
+ b = uint64(buf[i])
+ i++
+ x += b << 28
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 28
+
+ b = uint64(buf[i])
+ i++
+ x += b << 35
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 35
+
+ b = uint64(buf[i])
+ i++
+ x += b << 42
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 42
+
+ b = uint64(buf[i])
+ i++
+ x += b << 49
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 49
+
+ b = uint64(buf[i])
+ i++
+ x += b << 56
+ if b&0x80 == 0 {
+ goto done
+ }
+ x -= 0x80 << 56
+
+ b = uint64(buf[i])
+ i++
+ x += b << 63
+ if b&0x80 == 0 {
+ goto done
+ }
+
+ return 0, errOverflow
+
+done:
+ p.index = i
+ return x, nil
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) DecodeFixed64() (x uint64, err error) {
+ // x, err already 0
+ i := p.index + 8
+ if i < 0 || i > len(p.buf) {
+ err = io.ErrUnexpectedEOF
+ return
+ }
+ p.index = i
+
+ x = uint64(p.buf[i-8])
+ x |= uint64(p.buf[i-7]) << 8
+ x |= uint64(p.buf[i-6]) << 16
+ x |= uint64(p.buf[i-5]) << 24
+ x |= uint64(p.buf[i-4]) << 32
+ x |= uint64(p.buf[i-3]) << 40
+ x |= uint64(p.buf[i-2]) << 48
+ x |= uint64(p.buf[i-1]) << 56
+ return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) DecodeFixed32() (x uint64, err error) {
+ // x, err already 0
+ i := p.index + 4
+ if i < 0 || i > len(p.buf) {
+ err = io.ErrUnexpectedEOF
+ return
+ }
+ p.index = i
+
+ x = uint64(p.buf[i-4])
+ x |= uint64(p.buf[i-3]) << 8
+ x |= uint64(p.buf[i-2]) << 16
+ x |= uint64(p.buf[i-1]) << 24
+ return
+}
+
+// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
+// from the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
+ x, err = p.DecodeVarint()
+ if err != nil {
+ return
+ }
+ x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
+ return
+}
+
+// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
+// from the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
+ x, err = p.DecodeVarint()
+ if err != nil {
+ return
+ }
+ x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
+ return
+}
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+ n, err := p.DecodeVarint()
+ if err != nil {
+ return nil, err
+ }
+
+ nb := int(n)
+ if nb < 0 {
+ return nil, fmt.Errorf("proto: bad byte length %d", nb)
+ }
+ end := p.index + nb
+ if end < p.index || end > len(p.buf) {
+ return nil, io.ErrUnexpectedEOF
+ }
+
+ if !alloc {
+ // todo: check if can get more uses of alloc=false
+ buf = p.buf[p.index:end]
+ p.index += nb
+ return
+ }
+
+ buf = make([]byte, nb)
+ copy(buf, p.buf[p.index:])
+ p.index += nb
+ return
+}
+
+// DecodeStringBytes reads an encoded string from the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) DecodeStringBytes() (s string, err error) {
+ buf, err := p.DecodeRawBytes(false)
+ if err != nil {
+ return
+ }
+ return string(buf), nil
+}
+
+// Unmarshaler is the interface representing objects that can
+// unmarshal themselves. The argument points to data that may be
+// overwritten, so implementations should not keep references to the
+// buffer.
+// Unmarshal implementations should not clear the receiver.
+// Any unmarshaled data should be merged into the receiver.
+// Callers of Unmarshal that do not want to retain existing data
+// should Reset the receiver before calling Unmarshal.
+type Unmarshaler interface {
+ Unmarshal([]byte) error
+}
+
+// newUnmarshaler is the interface representing objects that can
+// unmarshal themselves. The semantics are identical to Unmarshaler.
+//
+// This exists to support protoc-gen-go generated messages.
+// The proto package will stop type-asserting to this interface in the future.
+//
+// DO NOT DEPEND ON THIS.
+type newUnmarshaler interface {
+ XXX_Unmarshal([]byte) error
+}
+
+// Unmarshal parses the protocol buffer representation in buf and places the
+// decoded result in pb. If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// Unmarshal resets pb before starting to unmarshal, so any
+// existing data in pb is always removed. Use UnmarshalMerge
+// to preserve and append to existing data.
+func Unmarshal(buf []byte, pb Message) error {
+ pb.Reset()
+ if u, ok := pb.(newUnmarshaler); ok {
+ return u.XXX_Unmarshal(buf)
+ }
+ if u, ok := pb.(Unmarshaler); ok {
+ return u.Unmarshal(buf)
+ }
+ return NewBuffer(buf).Unmarshal(pb)
+}
+
+// UnmarshalMerge parses the protocol buffer representation in buf and
+// writes the decoded result to pb. If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// UnmarshalMerge merges into existing data in pb.
+// Most code should use Unmarshal instead.
+func UnmarshalMerge(buf []byte, pb Message) error {
+ if u, ok := pb.(newUnmarshaler); ok {
+ return u.XXX_Unmarshal(buf)
+ }
+ if u, ok := pb.(Unmarshaler); ok {
+ // NOTE: The history of proto have unfortunately been inconsistent
+ // whether Unmarshaler should or should not implicitly clear itself.
+ // Some implementations do, most do not.
+ // Thus, calling this here may or may not do what people want.
+ //
+ // See https://github.com/golang/protobuf/issues/424
+ return u.Unmarshal(buf)
+ }
+ return NewBuffer(buf).Unmarshal(pb)
+}
+
+// DecodeMessage reads a count-delimited message from the Buffer.
+func (p *Buffer) DecodeMessage(pb Message) error {
+ enc, err := p.DecodeRawBytes(false)
+ if err != nil {
+ return err
+ }
+ return NewBuffer(enc).Unmarshal(pb)
+}
+
+// DecodeGroup reads a tag-delimited group from the Buffer.
+// StartGroup tag is already consumed. This function consumes
+// EndGroup tag.
+func (p *Buffer) DecodeGroup(pb Message) error {
+ b := p.buf[p.index:]
+ x, y := findEndGroup(b)
+ if x < 0 {
+ return io.ErrUnexpectedEOF
+ }
+ err := Unmarshal(b[:x], pb)
+ p.index += y
+ return err
+}
+
+// Unmarshal parses the protocol buffer representation in the
+// Buffer and places the decoded result in pb. If the struct
+// underlying pb does not match the data in the buffer, the results can be
+// unpredictable.
+//
+// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
+func (p *Buffer) Unmarshal(pb Message) error {
+ // If the object can unmarshal itself, let it.
+ if u, ok := pb.(newUnmarshaler); ok {
+ err := u.XXX_Unmarshal(p.buf[p.index:])
+ p.index = len(p.buf)
+ return err
+ }
+ if u, ok := pb.(Unmarshaler); ok {
+ // NOTE: The history of proto have unfortunately been inconsistent
+ // whether Unmarshaler should or should not implicitly clear itself.
+ // Some implementations do, most do not.
+ // Thus, calling this here may or may not do what people want.
+ //
+ // See https://github.com/golang/protobuf/issues/424
+ err := u.Unmarshal(p.buf[p.index:])
+ p.index = len(p.buf)
+ return err
+ }
+
+ // Slow workaround for messages that aren't Unmarshalers.
+ // This includes some hand-coded .pb.go files and
+ // bootstrap protos.
+ // TODO: fix all of those and then add Unmarshal to
+ // the Message interface. Then:
+ // The cast above and code below can be deleted.
+ // The old unmarshaler can be deleted.
+ // Clients can call Unmarshal directly (can already do that, actually).
+ var info InternalMessageInfo
+ err := info.Unmarshal(pb, p.buf[p.index:])
+ p.index = len(p.buf)
+ return err
+}
diff --git a/vendor/github.com/golang/protobuf/proto/defaults.go b/vendor/github.com/golang/protobuf/proto/defaults.go
deleted file mode 100644
index d399bf0..0000000
--- a/vendor/github.com/golang/protobuf/proto/defaults.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// SetDefaults sets unpopulated scalar fields to their default values.
-// Fields within a oneof are not set even if they have a default value.
-// SetDefaults is recursively called upon any populated message fields.
-func SetDefaults(m Message) {
- if m != nil {
- setDefaults(MessageReflect(m))
- }
-}
-
-func setDefaults(m protoreflect.Message) {
- fds := m.Descriptor().Fields()
- for i := 0; i < fds.Len(); i++ {
- fd := fds.Get(i)
- if !m.Has(fd) {
- if fd.HasDefault() && fd.ContainingOneof() == nil {
- v := fd.Default()
- if fd.Kind() == protoreflect.BytesKind {
- v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes
- }
- m.Set(fd, v)
- }
- continue
- }
- }
-
- m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- switch {
- // Handle singular message.
- case fd.Cardinality() != protoreflect.Repeated:
- if fd.Message() != nil {
- setDefaults(m.Get(fd).Message())
- }
- // Handle list of messages.
- case fd.IsList():
- if fd.Message() != nil {
- ls := m.Get(fd).List()
- for i := 0; i < ls.Len(); i++ {
- setDefaults(ls.Get(i).Message())
- }
- }
- // Handle map of messages.
- case fd.IsMap():
- if fd.MapValue().Message() != nil {
- ms := m.Get(fd).Map()
- ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
- setDefaults(v.Message())
- return true
- })
- }
- }
- return true
- })
-}
diff --git a/vendor/github.com/golang/protobuf/proto/deprecated.go b/vendor/github.com/golang/protobuf/proto/deprecated.go
index e8db57e..35b882c 100644
--- a/vendor/github.com/golang/protobuf/proto/deprecated.go
+++ b/vendor/github.com/golang/protobuf/proto/deprecated.go
@@ -1,113 +1,63 @@
-// 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.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2018 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package proto
-import (
- "encoding/json"
- "errors"
- "fmt"
- "strconv"
+import "errors"
- protoV2 "google.golang.org/protobuf/proto"
-)
-
-var (
- // Deprecated: No longer returned.
- ErrNil = errors.New("proto: Marshal called with nil")
-
- // Deprecated: No longer returned.
- ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
-
- // Deprecated: No longer returned.
- ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
-)
-
-// Deprecated: Do not use.
+// Deprecated: do not use.
type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
-// Deprecated: Do not use.
+// Deprecated: do not use.
func GetStats() Stats { return Stats{} }
-// Deprecated: Do not use.
+// Deprecated: do not use.
func MarshalMessageSet(interface{}) ([]byte, error) {
return nil, errors.New("proto: not implemented")
}
-// Deprecated: Do not use.
+// Deprecated: do not use.
func UnmarshalMessageSet([]byte, interface{}) error {
return errors.New("proto: not implemented")
}
-// Deprecated: Do not use.
+// Deprecated: do not use.
func MarshalMessageSetJSON(interface{}) ([]byte, error) {
return nil, errors.New("proto: not implemented")
}
-// Deprecated: Do not use.
+// Deprecated: do not use.
func UnmarshalMessageSetJSON([]byte, interface{}) error {
return errors.New("proto: not implemented")
}
-// Deprecated: Do not use.
+// Deprecated: do not use.
func RegisterMessageSetType(Message, int32, string) {}
-
-// Deprecated: Do not use.
-func EnumName(m map[int32]string, v int32) string {
- s, ok := m[v]
- if ok {
- return s
- }
- return strconv.Itoa(int(v))
-}
-
-// Deprecated: Do not use.
-func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
- if data[0] == '"' {
- // New style: enums are strings.
- var repr string
- if err := json.Unmarshal(data, &repr); err != nil {
- return -1, err
- }
- val, ok := m[repr]
- if !ok {
- return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
- }
- return val, nil
- }
- // Old style: enums are ints.
- var val int32
- if err := json.Unmarshal(data, &val); err != nil {
- return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
- }
- return val, nil
-}
-
-// Deprecated: Do not use; this type existed for intenal-use only.
-type InternalMessageInfo struct{}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) DiscardUnknown(m Message) {
- DiscardUnknown(m)
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Marshal(b []byte, m Message, deterministic bool) ([]byte, error) {
- return protoV2.MarshalOptions{Deterministic: deterministic}.MarshalAppend(b, MessageV2(m))
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Merge(dst, src Message) {
- protoV2.Merge(MessageV2(dst), MessageV2(src))
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Size(m Message) int {
- return protoV2.Size(MessageV2(m))
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Unmarshal(m Message, b []byte) error {
- return protoV2.UnmarshalOptions{Merge: true}.Unmarshal(b, MessageV2(m))
-}
diff --git a/vendor/github.com/golang/protobuf/proto/discard.go b/vendor/github.com/golang/protobuf/proto/discard.go
index 2187e87..dea2617 100644
--- a/vendor/github.com/golang/protobuf/proto/discard.go
+++ b/vendor/github.com/golang/protobuf/proto/discard.go
@@ -1,13 +1,48 @@
-// 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.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2017 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package proto
import (
- "google.golang.org/protobuf/reflect/protoreflect"
+ "fmt"
+ "reflect"
+ "strings"
+ "sync"
+ "sync/atomic"
)
+type generatedDiscarder interface {
+ XXX_DiscardUnknown()
+}
+
// DiscardUnknown recursively discards all unknown fields from this message
// and all embedded messages.
//
@@ -16,43 +51,300 @@
// marshal to be able to produce a message that continues to have those
// unrecognized fields. To avoid this, DiscardUnknown is used to
// explicitly clear the unknown fields after unmarshaling.
+//
+// For proto2 messages, the unknown fields of message extensions are only
+// discarded from messages that have been accessed via GetExtension.
func DiscardUnknown(m Message) {
- if m != nil {
- discardUnknown(MessageReflect(m))
+ if m, ok := m.(generatedDiscarder); ok {
+ m.XXX_DiscardUnknown()
+ return
+ }
+ // TODO: Dynamically populate a InternalMessageInfo for legacy messages,
+ // but the master branch has no implementation for InternalMessageInfo,
+ // so it would be more work to replicate that approach.
+ discardLegacy(m)
+}
+
+// DiscardUnknown recursively discards all unknown fields.
+func (a *InternalMessageInfo) DiscardUnknown(m Message) {
+ di := atomicLoadDiscardInfo(&a.discard)
+ if di == nil {
+ di = getDiscardInfo(reflect.TypeOf(m).Elem())
+ atomicStoreDiscardInfo(&a.discard, di)
+ }
+ di.discard(toPointer(&m))
+}
+
+type discardInfo struct {
+ typ reflect.Type
+
+ initialized int32 // 0: only typ is valid, 1: everything is valid
+ lock sync.Mutex
+
+ fields []discardFieldInfo
+ unrecognized field
+}
+
+type discardFieldInfo struct {
+ field field // Offset of field, guaranteed to be valid
+ discard func(src pointer)
+}
+
+var (
+ discardInfoMap = map[reflect.Type]*discardInfo{}
+ discardInfoLock sync.Mutex
+)
+
+func getDiscardInfo(t reflect.Type) *discardInfo {
+ discardInfoLock.Lock()
+ defer discardInfoLock.Unlock()
+ di := discardInfoMap[t]
+ if di == nil {
+ di = &discardInfo{typ: t}
+ discardInfoMap[t] = di
+ }
+ return di
+}
+
+func (di *discardInfo) discard(src pointer) {
+ if src.isNil() {
+ return // Nothing to do.
+ }
+
+ if atomic.LoadInt32(&di.initialized) == 0 {
+ di.computeDiscardInfo()
+ }
+
+ for _, fi := range di.fields {
+ sfp := src.offset(fi.field)
+ fi.discard(sfp)
+ }
+
+ // For proto2 messages, only discard unknown fields in message extensions
+ // that have been accessed via GetExtension.
+ if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
+ // Ignore lock since DiscardUnknown is not concurrency safe.
+ emm, _ := em.extensionsRead()
+ for _, mx := range emm {
+ if m, ok := mx.value.(Message); ok {
+ DiscardUnknown(m)
+ }
+ }
+ }
+
+ if di.unrecognized.IsValid() {
+ *src.offset(di.unrecognized).toBytes() = nil
}
}
-func discardUnknown(m protoreflect.Message) {
- m.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
- switch {
- // Handle singular message.
- case fd.Cardinality() != protoreflect.Repeated:
- if fd.Message() != nil {
- discardUnknown(m.Get(fd).Message())
- }
- // Handle list of messages.
- case fd.IsList():
- if fd.Message() != nil {
- ls := m.Get(fd).List()
- for i := 0; i < ls.Len(); i++ {
- discardUnknown(ls.Get(i).Message())
+func (di *discardInfo) computeDiscardInfo() {
+ di.lock.Lock()
+ defer di.lock.Unlock()
+ if di.initialized != 0 {
+ return
+ }
+ t := di.typ
+ n := t.NumField()
+
+ for i := 0; i < n; i++ {
+ f := t.Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+
+ dfi := discardFieldInfo{field: toField(&f)}
+ tf := f.Type
+
+ // Unwrap tf to get its most basic type.
+ var isPointer, isSlice bool
+ if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+ isSlice = true
+ tf = tf.Elem()
+ }
+ if tf.Kind() == reflect.Ptr {
+ isPointer = true
+ tf = tf.Elem()
+ }
+ if isPointer && isSlice && tf.Kind() != reflect.Struct {
+ panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
+ }
+
+ switch tf.Kind() {
+ case reflect.Struct:
+ switch {
+ case !isPointer:
+ panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
+ case isSlice: // E.g., []*pb.T
+ di := getDiscardInfo(tf)
+ dfi.discard = func(src pointer) {
+ sps := src.getPointerSlice()
+ for _, sp := range sps {
+ if !sp.isNil() {
+ di.discard(sp)
+ }
+ }
+ }
+ default: // E.g., *pb.T
+ di := getDiscardInfo(tf)
+ dfi.discard = func(src pointer) {
+ sp := src.getPointer()
+ if !sp.isNil() {
+ di.discard(sp)
+ }
}
}
- // Handle map of messages.
- case fd.IsMap():
- if fd.MapValue().Message() != nil {
- ms := m.Get(fd).Map()
- ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
- discardUnknown(v.Message())
- return true
- })
+ case reflect.Map:
+ switch {
+ case isPointer || isSlice:
+ panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
+ default: // E.g., map[K]V
+ if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
+ dfi.discard = func(src pointer) {
+ sm := src.asPointerTo(tf).Elem()
+ if sm.Len() == 0 {
+ return
+ }
+ for _, key := range sm.MapKeys() {
+ val := sm.MapIndex(key)
+ DiscardUnknown(val.Interface().(Message))
+ }
+ }
+ } else {
+ dfi.discard = func(pointer) {} // Noop
+ }
+ }
+ case reflect.Interface:
+ // Must be oneof field.
+ switch {
+ case isPointer || isSlice:
+ panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
+ default: // E.g., interface{}
+ // TODO: Make this faster?
+ dfi.discard = func(src pointer) {
+ su := src.asPointerTo(tf).Elem()
+ if !su.IsNil() {
+ sv := su.Elem().Elem().Field(0)
+ if sv.Kind() == reflect.Ptr && sv.IsNil() {
+ return
+ }
+ switch sv.Type().Kind() {
+ case reflect.Ptr: // Proto struct (e.g., *T)
+ DiscardUnknown(sv.Interface().(Message))
+ }
+ }
+ }
+ }
+ default:
+ continue
+ }
+ di.fields = append(di.fields, dfi)
+ }
+
+ di.unrecognized = invalidField
+ if f, ok := t.FieldByName("XXX_unrecognized"); ok {
+ if f.Type != reflect.TypeOf([]byte{}) {
+ panic("expected XXX_unrecognized to be of type []byte")
+ }
+ di.unrecognized = toField(&f)
+ }
+
+ atomic.StoreInt32(&di.initialized, 1)
+}
+
+func discardLegacy(m Message) {
+ v := reflect.ValueOf(m)
+ if v.Kind() != reflect.Ptr || v.IsNil() {
+ return
+ }
+ v = v.Elem()
+ if v.Kind() != reflect.Struct {
+ return
+ }
+ t := v.Type()
+
+ for i := 0; i < v.NumField(); i++ {
+ f := t.Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ vf := v.Field(i)
+ tf := f.Type
+
+ // Unwrap tf to get its most basic type.
+ var isPointer, isSlice bool
+ if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+ isSlice = true
+ tf = tf.Elem()
+ }
+ if tf.Kind() == reflect.Ptr {
+ isPointer = true
+ tf = tf.Elem()
+ }
+ if isPointer && isSlice && tf.Kind() != reflect.Struct {
+ panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
+ }
+
+ switch tf.Kind() {
+ case reflect.Struct:
+ switch {
+ case !isPointer:
+ panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
+ case isSlice: // E.g., []*pb.T
+ for j := 0; j < vf.Len(); j++ {
+ discardLegacy(vf.Index(j).Interface().(Message))
+ }
+ default: // E.g., *pb.T
+ discardLegacy(vf.Interface().(Message))
+ }
+ case reflect.Map:
+ switch {
+ case isPointer || isSlice:
+ panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
+ default: // E.g., map[K]V
+ tv := vf.Type().Elem()
+ if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
+ for _, key := range vf.MapKeys() {
+ val := vf.MapIndex(key)
+ discardLegacy(val.Interface().(Message))
+ }
+ }
+ }
+ case reflect.Interface:
+ // Must be oneof field.
+ switch {
+ case isPointer || isSlice:
+ panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
+ default: // E.g., test_proto.isCommunique_Union interface
+ if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
+ vf = vf.Elem() // E.g., *test_proto.Communique_Msg
+ if !vf.IsNil() {
+ vf = vf.Elem() // E.g., test_proto.Communique_Msg
+ vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
+ if vf.Kind() == reflect.Ptr {
+ discardLegacy(vf.Interface().(Message))
+ }
+ }
+ }
}
}
- return true
- })
+ }
- // Discard unknown fields.
- if len(m.GetUnknown()) > 0 {
- m.SetUnknown(nil)
+ if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
+ if vf.Type() != reflect.TypeOf([]byte{}) {
+ panic("expected XXX_unrecognized to be of type []byte")
+ }
+ vf.Set(reflect.ValueOf([]byte(nil)))
+ }
+
+ // For proto2 messages, only discard unknown fields in message extensions
+ // that have been accessed via GetExtension.
+ if em, err := extendable(m); err == nil {
+ // Ignore lock since discardLegacy is not concurrency safe.
+ emm, _ := em.extensionsRead()
+ for _, mx := range emm {
+ if m, ok := mx.value.(Message); ok {
+ discardLegacy(m)
+ }
+ }
}
}
diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go
new file mode 100644
index 0000000..3abfed2
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/encode.go
@@ -0,0 +1,203 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+ "errors"
+ "reflect"
+)
+
+var (
+ // errRepeatedHasNil is the error returned if Marshal is called with
+ // a struct with a repeated field containing a nil element.
+ errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+
+ // errOneofHasNil is the error returned if Marshal is called with
+ // a struct with a oneof field containing a nil element.
+ errOneofHasNil = errors.New("proto: oneof field has nil value")
+
+ // ErrNil is the error returned if Marshal is called with nil.
+ ErrNil = errors.New("proto: Marshal called with nil")
+
+ // ErrTooLarge is the error returned if Marshal is called with a
+ // message that encodes to >2GB.
+ ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
+)
+
+// The fundamental encoders that put bytes on the wire.
+// Those that take integer types all accept uint64 and are
+// therefore of type valueEncoder.
+
+const maxVarintBytes = 10 // maximum length of a varint
+
+// EncodeVarint returns the varint encoding of x.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+// Not used by the package itself, but helpful to clients
+// wishing to use the same encoding.
+func EncodeVarint(x uint64) []byte {
+ var buf [maxVarintBytes]byte
+ var n int
+ for n = 0; x > 127; n++ {
+ buf[n] = 0x80 | uint8(x&0x7F)
+ x >>= 7
+ }
+ buf[n] = uint8(x)
+ n++
+ return buf[0:n]
+}
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) EncodeVarint(x uint64) error {
+ for x >= 1<<7 {
+ p.buf = append(p.buf, uint8(x&0x7f|0x80))
+ x >>= 7
+ }
+ p.buf = append(p.buf, uint8(x))
+ return nil
+}
+
+// SizeVarint returns the varint encoding size of an integer.
+func SizeVarint(x uint64) int {
+ switch {
+ case x < 1<<7:
+ return 1
+ case x < 1<<14:
+ return 2
+ case x < 1<<21:
+ return 3
+ case x < 1<<28:
+ return 4
+ case x < 1<<35:
+ return 5
+ case x < 1<<42:
+ return 6
+ case x < 1<<49:
+ return 7
+ case x < 1<<56:
+ return 8
+ case x < 1<<63:
+ return 9
+ }
+ return 10
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) EncodeFixed64(x uint64) error {
+ p.buf = append(p.buf,
+ uint8(x),
+ uint8(x>>8),
+ uint8(x>>16),
+ uint8(x>>24),
+ uint8(x>>32),
+ uint8(x>>40),
+ uint8(x>>48),
+ uint8(x>>56))
+ return nil
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) EncodeFixed32(x uint64) error {
+ p.buf = append(p.buf,
+ uint8(x),
+ uint8(x>>8),
+ uint8(x>>16),
+ uint8(x>>24))
+ return nil
+}
+
+// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
+// to the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) EncodeZigzag64(x uint64) error {
+ // use signed number to get arithmetic right shift.
+ return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
+// to the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) EncodeZigzag32(x uint64) error {
+ // use signed number to get arithmetic right shift.
+ return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) EncodeRawBytes(b []byte) error {
+ p.EncodeVarint(uint64(len(b)))
+ p.buf = append(p.buf, b...)
+ return nil
+}
+
+// EncodeStringBytes writes an encoded string to the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) EncodeStringBytes(s string) error {
+ p.EncodeVarint(uint64(len(s)))
+ p.buf = append(p.buf, s...)
+ return nil
+}
+
+// Marshaler is the interface representing objects that can marshal themselves.
+type Marshaler interface {
+ Marshal() ([]byte, error)
+}
+
+// EncodeMessage writes the protocol buffer to the Buffer,
+// prefixed by a varint-encoded length.
+func (p *Buffer) EncodeMessage(pb Message) error {
+ siz := Size(pb)
+ p.EncodeVarint(uint64(siz))
+ return p.Marshal(pb)
+}
+
+// All protocol buffer fields are nillable, but be careful.
+func isNil(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+ return v.IsNil()
+ }
+ return false
+}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
new file mode 100644
index 0000000..f9b6e41
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/equal.go
@@ -0,0 +1,301 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+// Protocol buffer comparison.
+
+package proto
+
+import (
+ "bytes"
+ "log"
+ "reflect"
+ "strings"
+)
+
+/*
+Equal returns true iff protocol buffers a and b are equal.
+The arguments must both be pointers to protocol buffer structs.
+
+Equality is defined in this way:
+ - Two messages are equal iff they are the same type,
+ corresponding fields are equal, unknown field sets
+ are equal, and extensions sets are equal.
+ - Two set scalar fields are equal iff their values are equal.
+ If the fields are of a floating-point type, remember that
+ NaN != x for all x, including NaN. If the message is defined
+ in a proto3 .proto file, fields are not "set"; specifically,
+ zero length proto3 "bytes" fields are equal (nil == {}).
+ - Two repeated fields are equal iff their lengths are the same,
+ and their corresponding elements are equal. Note a "bytes" field,
+ although represented by []byte, is not a repeated field and the
+ rule for the scalar fields described above applies.
+ - Two unset fields are equal.
+ - Two unknown field sets are equal if their current
+ encoded state is equal.
+ - Two extension sets are equal iff they have corresponding
+ elements that are pairwise equal.
+ - Two map fields are equal iff their lengths are the same,
+ and they contain the same set of elements. Zero-length map
+ fields are equal.
+ - Every other combination of things are not equal.
+
+The return value is undefined if a and b are not protocol buffers.
+*/
+func Equal(a, b Message) bool {
+ if a == nil || b == nil {
+ return a == b
+ }
+ v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
+ if v1.Type() != v2.Type() {
+ return false
+ }
+ if v1.Kind() == reflect.Ptr {
+ if v1.IsNil() {
+ return v2.IsNil()
+ }
+ if v2.IsNil() {
+ return false
+ }
+ v1, v2 = v1.Elem(), v2.Elem()
+ }
+ if v1.Kind() != reflect.Struct {
+ return false
+ }
+ return equalStruct(v1, v2)
+}
+
+// v1 and v2 are known to have the same type.
+func equalStruct(v1, v2 reflect.Value) bool {
+ sprop := GetProperties(v1.Type())
+ for i := 0; i < v1.NumField(); i++ {
+ f := v1.Type().Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ f1, f2 := v1.Field(i), v2.Field(i)
+ if f.Type.Kind() == reflect.Ptr {
+ if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
+ // both unset
+ continue
+ } else if n1 != n2 {
+ // set/unset mismatch
+ return false
+ }
+ f1, f2 = f1.Elem(), f2.Elem()
+ }
+ if !equalAny(f1, f2, sprop.Prop[i]) {
+ return false
+ }
+ }
+
+ if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
+ em2 := v2.FieldByName("XXX_InternalExtensions")
+ if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
+ return false
+ }
+ }
+
+ if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
+ em2 := v2.FieldByName("XXX_extensions")
+ if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+ return false
+ }
+ }
+
+ uf := v1.FieldByName("XXX_unrecognized")
+ if !uf.IsValid() {
+ return true
+ }
+
+ u1 := uf.Bytes()
+ u2 := v2.FieldByName("XXX_unrecognized").Bytes()
+ return bytes.Equal(u1, u2)
+}
+
+// v1 and v2 are known to have the same type.
+// prop may be nil.
+func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
+ if v1.Type() == protoMessageType {
+ m1, _ := v1.Interface().(Message)
+ m2, _ := v2.Interface().(Message)
+ return Equal(m1, m2)
+ }
+ switch v1.Kind() {
+ case reflect.Bool:
+ return v1.Bool() == v2.Bool()
+ case reflect.Float32, reflect.Float64:
+ return v1.Float() == v2.Float()
+ case reflect.Int32, reflect.Int64:
+ return v1.Int() == v2.Int()
+ case reflect.Interface:
+ // Probably a oneof field; compare the inner values.
+ n1, n2 := v1.IsNil(), v2.IsNil()
+ if n1 || n2 {
+ return n1 == n2
+ }
+ e1, e2 := v1.Elem(), v2.Elem()
+ if e1.Type() != e2.Type() {
+ return false
+ }
+ return equalAny(e1, e2, nil)
+ case reflect.Map:
+ if v1.Len() != v2.Len() {
+ return false
+ }
+ for _, key := range v1.MapKeys() {
+ val2 := v2.MapIndex(key)
+ if !val2.IsValid() {
+ // This key was not found in the second map.
+ return false
+ }
+ if !equalAny(v1.MapIndex(key), val2, nil) {
+ return false
+ }
+ }
+ return true
+ case reflect.Ptr:
+ // Maps may have nil values in them, so check for nil.
+ if v1.IsNil() && v2.IsNil() {
+ return true
+ }
+ if v1.IsNil() != v2.IsNil() {
+ return false
+ }
+ return equalAny(v1.Elem(), v2.Elem(), prop)
+ case reflect.Slice:
+ if v1.Type().Elem().Kind() == reflect.Uint8 {
+ // short circuit: []byte
+
+ // Edge case: if this is in a proto3 message, a zero length
+ // bytes field is considered the zero value.
+ if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
+ return true
+ }
+ if v1.IsNil() != v2.IsNil() {
+ return false
+ }
+ return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
+ }
+
+ if v1.Len() != v2.Len() {
+ return false
+ }
+ for i := 0; i < v1.Len(); i++ {
+ if !equalAny(v1.Index(i), v2.Index(i), prop) {
+ return false
+ }
+ }
+ return true
+ case reflect.String:
+ return v1.Interface().(string) == v2.Interface().(string)
+ case reflect.Struct:
+ return equalStruct(v1, v2)
+ case reflect.Uint32, reflect.Uint64:
+ return v1.Uint() == v2.Uint()
+ }
+
+ // unknown type, so not a protocol buffer
+ log.Printf("proto: don't know how to compare %v", v1)
+ return false
+}
+
+// base is the struct type that the extensions are based on.
+// x1 and x2 are InternalExtensions.
+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
+ em1, _ := x1.extensionsRead()
+ em2, _ := x2.extensionsRead()
+ return equalExtMap(base, em1, em2)
+}
+
+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
+ if len(em1) != len(em2) {
+ return false
+ }
+
+ for extNum, e1 := range em1 {
+ e2, ok := em2[extNum]
+ if !ok {
+ return false
+ }
+
+ m1 := extensionAsLegacyType(e1.value)
+ m2 := extensionAsLegacyType(e2.value)
+
+ if m1 == nil && m2 == nil {
+ // Both have only encoded form.
+ if bytes.Equal(e1.enc, e2.enc) {
+ continue
+ }
+ // The bytes are different, but the extensions might still be
+ // equal. We need to decode them to compare.
+ }
+
+ if m1 != nil && m2 != nil {
+ // Both are unencoded.
+ if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+ return false
+ }
+ continue
+ }
+
+ // At least one is encoded. To do a semantically correct comparison
+ // we need to unmarshal them first.
+ var desc *ExtensionDesc
+ if m := extensionMaps[base]; m != nil {
+ desc = m[extNum]
+ }
+ if desc == nil {
+ // If both have only encoded form and the bytes are the same,
+ // it is handled above. We get here when the bytes are different.
+ // We don't know how to decode it, so just compare them as byte
+ // slices.
+ log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
+ return false
+ }
+ var err error
+ if m1 == nil {
+ m1, err = decodeExtension(e1.enc, desc)
+ }
+ if m2 == nil && err == nil {
+ m2, err = decodeExtension(e2.enc, desc)
+ }
+ if err != nil {
+ // The encoded form is invalid.
+ log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
+ return false
+ }
+ if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+ return false
+ }
+ }
+
+ return true
+}
diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
index 42fc120..fa88add 100644
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -1,356 +1,607 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package proto
+/*
+ * Types and routines for supporting protocol buffer extensions.
+ */
+
import (
"errors"
"fmt"
+ "io"
"reflect"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
- "google.golang.org/protobuf/runtime/protoiface"
- "google.golang.org/protobuf/runtime/protoimpl"
+ "strconv"
+ "sync"
)
-type (
- // ExtensionDesc represents an extension descriptor and
- // is used to interact with an extension field in a message.
- //
- // Variables of this type are generated in code by protoc-gen-go.
- ExtensionDesc = protoimpl.ExtensionInfo
-
- // ExtensionRange represents a range of message extensions.
- // Used in code generated by protoc-gen-go.
- ExtensionRange = protoiface.ExtensionRangeV1
-
- // Deprecated: Do not use; this is an internal type.
- Extension = protoimpl.ExtensionFieldV1
-
- // Deprecated: Do not use; this is an internal type.
- XXX_InternalExtensions = protoimpl.ExtensionFields
-)
-
-// ErrMissingExtension reports whether the extension was not present.
+// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
var ErrMissingExtension = errors.New("proto: missing extension")
+// ExtensionRange represents a range of message extensions for a protocol buffer.
+// Used in code generated by the protocol compiler.
+type ExtensionRange struct {
+ Start, End int32 // both inclusive
+}
+
+// extendableProto is an interface implemented by any protocol buffer generated by the current
+// proto compiler that may be extended.
+type extendableProto interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+ extensionsWrite() map[int32]Extension
+ extensionsRead() (map[int32]Extension, sync.Locker)
+}
+
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
+// version of the proto compiler that may be extended.
+type extendableProtoV1 interface {
+ Message
+ ExtensionRangeArray() []ExtensionRange
+ ExtensionMap() map[int32]Extension
+}
+
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
+type extensionAdapter struct {
+ extendableProtoV1
+}
+
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
+ return e.ExtensionMap()
+}
+
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+ return e.ExtensionMap(), notLocker{}
+}
+
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
+type notLocker struct{}
+
+func (n notLocker) Lock() {}
+func (n notLocker) Unlock() {}
+
+// extendable returns the extendableProto interface for the given generated proto message.
+// If the proto message has the old extension format, it returns a wrapper that implements
+// the extendableProto interface.
+func extendable(p interface{}) (extendableProto, error) {
+ switch p := p.(type) {
+ case extendableProto:
+ if isNilPtr(p) {
+ return nil, fmt.Errorf("proto: nil %T is not extendable", p)
+ }
+ return p, nil
+ case extendableProtoV1:
+ if isNilPtr(p) {
+ return nil, fmt.Errorf("proto: nil %T is not extendable", p)
+ }
+ return extensionAdapter{p}, nil
+ }
+ // Don't allocate a specific error containing %T:
+ // this is the hot path for Clone and MarshalText.
+ return nil, errNotExtendable
+}
+
var errNotExtendable = errors.New("proto: not an extendable proto.Message")
-// HasExtension reports whether the extension field is present in m
-// either as an explicitly populated field or as an unknown field.
-func HasExtension(m Message, xt *ExtensionDesc) (has bool) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() {
+func isNilPtr(x interface{}) bool {
+ v := reflect.ValueOf(x)
+ return v.Kind() == reflect.Ptr && v.IsNil()
+}
+
+// XXX_InternalExtensions is an internal representation of proto extensions.
+//
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
+//
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
+// but calls to logically read-only methods such as has and get may be executed concurrently.
+type XXX_InternalExtensions struct {
+ // The struct must be indirect so that if a user inadvertently copies a
+ // generated message and its embedded XXX_InternalExtensions, they
+ // avoid the mayhem of a copied mutex.
+ //
+ // The mutex serializes all logically read-only operations to p.extensionMap.
+ // It is up to the client to ensure that write operations to p.extensionMap are
+ // mutually exclusive with other accesses.
+ p *struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ }
+}
+
+// extensionsWrite returns the extension map, creating it on first use.
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
+ if e.p == nil {
+ e.p = new(struct {
+ mu sync.Mutex
+ extensionMap map[int32]Extension
+ })
+ e.p.extensionMap = make(map[int32]Extension)
+ }
+ return e.p.extensionMap
+}
+
+// extensionsRead returns the extensions map for read-only use. It may be nil.
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
+ if e.p == nil {
+ return nil, nil
+ }
+ return e.p.extensionMap, &e.p.mu
+}
+
+// ExtensionDesc represents an extension specification.
+// Used in generated code from the protocol compiler.
+type ExtensionDesc struct {
+ ExtendedType Message // nil pointer to the type that is being extended
+ ExtensionType interface{} // nil pointer to the extension type
+ Field int32 // field number
+ Name string // fully-qualified name of extension, for text formatting
+ Tag string // protobuf tag style
+ Filename string // name of the file in which the extension is defined
+}
+
+func (ed *ExtensionDesc) repeated() bool {
+ t := reflect.TypeOf(ed.ExtensionType)
+ return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+}
+
+// Extension represents an extension in a message.
+type Extension struct {
+ // When an extension is stored in a message using SetExtension
+ // only desc and value are set. When the message is marshaled
+ // enc will be set to the encoded form of the message.
+ //
+ // When a message is unmarshaled and contains extensions, each
+ // extension will have only enc set. When such an extension is
+ // accessed using GetExtension (or GetExtensions) desc and value
+ // will be set.
+ desc *ExtensionDesc
+
+ // value is a concrete value for the extension field. Let the type of
+ // desc.ExtensionType be the "API type" and the type of Extension.value
+ // be the "storage type". The API type and storage type are the same except:
+ // * For scalars (except []byte), the API type uses *T,
+ // while the storage type uses T.
+ // * For repeated fields, the API type uses []T, while the storage type
+ // uses *[]T.
+ //
+ // The reason for the divergence is so that the storage type more naturally
+ // matches what is expected of when retrieving the values through the
+ // protobuf reflection APIs.
+ //
+ // The value may only be populated if desc is also populated.
+ value interface{}
+
+ // enc is the raw bytes for the extension field.
+ enc []byte
+}
+
+// SetRawExtension is for testing only.
+func SetRawExtension(base Message, id int32, b []byte) {
+ epb, err := extendable(base)
+ if err != nil {
+ return
+ }
+ extmap := epb.extensionsWrite()
+ extmap[id] = Extension{enc: b}
+}
+
+// isExtensionField returns true iff the given field number is in an extension range.
+func isExtensionField(pb extendableProto, field int32) bool {
+ for _, er := range pb.ExtensionRangeArray() {
+ if er.Start <= field && field <= er.End {
+ return true
+ }
+ }
+ return false
+}
+
+// checkExtensionTypes checks that the given extension is valid for pb.
+func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+ var pbi interface{} = pb
+ // Check the extended type.
+ if ea, ok := pbi.(extensionAdapter); ok {
+ pbi = ea.extendableProtoV1
+ }
+ if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
+ return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
+ }
+ // Check the range.
+ if !isExtensionField(pb, extension.Field) {
+ return errors.New("proto: bad extension number; not in declared ranges")
+ }
+ return nil
+}
+
+// extPropKey is sufficient to uniquely identify an extension.
+type extPropKey struct {
+ base reflect.Type
+ field int32
+}
+
+var extProp = struct {
+ sync.RWMutex
+ m map[extPropKey]*Properties
+}{
+ m: make(map[extPropKey]*Properties),
+}
+
+func extensionProperties(ed *ExtensionDesc) *Properties {
+ key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
+
+ extProp.RLock()
+ if prop, ok := extProp.m[key]; ok {
+ extProp.RUnlock()
+ return prop
+ }
+ extProp.RUnlock()
+
+ extProp.Lock()
+ defer extProp.Unlock()
+ // Check again.
+ if prop, ok := extProp.m[key]; ok {
+ return prop
+ }
+
+ prop := new(Properties)
+ prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
+ extProp.m[key] = prop
+ return prop
+}
+
+// HasExtension returns whether the given extension is present in pb.
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
+ // TODO: Check types, field numbers, etc.?
+ epb, err := extendable(pb)
+ if err != nil {
return false
}
-
- // Check whether any populated known field matches the field number.
- xtd := xt.TypeDescriptor()
- if isValidExtension(mr.Descriptor(), xtd) {
- has = mr.Has(xtd)
- } else {
- mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
- has = int32(fd.Number()) == xt.Field
- return !has
- })
+ extmap, mu := epb.extensionsRead()
+ if extmap == nil {
+ return false
}
-
- // Check whether any unknown field matches the field number.
- for b := mr.GetUnknown(); !has && len(b) > 0; {
- num, _, n := protowire.ConsumeField(b)
- has = int32(num) == xt.Field
- b = b[n:]
- }
- return has
+ mu.Lock()
+ _, ok := extmap[extension.Field]
+ mu.Unlock()
+ return ok
}
-// ClearExtension removes the extension field from m
-// either as an explicitly populated field or as an unknown field.
-func ClearExtension(m Message, xt *ExtensionDesc) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() {
+// ClearExtension removes the given extension from pb.
+func ClearExtension(pb Message, extension *ExtensionDesc) {
+ epb, err := extendable(pb)
+ if err != nil {
return
}
-
- xtd := xt.TypeDescriptor()
- if isValidExtension(mr.Descriptor(), xtd) {
- mr.Clear(xtd)
- } else {
- mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
- if int32(fd.Number()) == xt.Field {
- mr.Clear(fd)
- return false
- }
- return true
- })
- }
- clearUnknown(mr, fieldNum(xt.Field))
+ // TODO: Check types, field numbers, etc.?
+ extmap := epb.extensionsWrite()
+ delete(extmap, extension.Field)
}
-// ClearAllExtensions clears all extensions from m.
-// This includes populated fields and unknown fields in the extension range.
-func ClearAllExtensions(m Message) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() {
- return
- }
-
- mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
- if fd.IsExtension() {
- mr.Clear(fd)
- }
- return true
- })
- clearUnknown(mr, mr.Descriptor().ExtensionRanges())
-}
-
-// GetExtension retrieves a proto2 extended field from m.
+// GetExtension retrieves a proto2 extended field from pb.
//
// If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
// then GetExtension parses the encoded field and returns a Go value of the specified type.
// If the field is not present, then the default value is returned (if one is specified),
// otherwise ErrMissingExtension is reported.
//
-// If the descriptor is type incomplete (i.e., ExtensionDesc.ExtensionType is nil),
-// then GetExtension returns the raw encoded bytes for the extension field.
-func GetExtension(m Message, xt *ExtensionDesc) (interface{}, error) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
- return nil, errNotExtendable
+// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
+// then GetExtension returns the raw encoded bytes of the field extension.
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
+ epb, err := extendable(pb)
+ if err != nil {
+ return nil, err
}
- // Retrieve the unknown fields for this extension field.
- var bo protoreflect.RawFields
- for bi := mr.GetUnknown(); len(bi) > 0; {
- num, _, n := protowire.ConsumeField(bi)
- if int32(num) == xt.Field {
- bo = append(bo, bi[:n]...)
- }
- bi = bi[n:]
- }
-
- // For type incomplete descriptors, only retrieve the unknown fields.
- if xt.ExtensionType == nil {
- return []byte(bo), nil
- }
-
- // If the extension field only exists as unknown fields, unmarshal it.
- // This is rarely done since proto.Unmarshal eagerly unmarshals extensions.
- xtd := xt.TypeDescriptor()
- if !isValidExtension(mr.Descriptor(), xtd) {
- return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
- }
- if !mr.Has(xtd) && len(bo) > 0 {
- m2 := mr.New()
- if err := (proto.UnmarshalOptions{
- Resolver: extensionResolver{xt},
- }.Unmarshal(bo, m2.Interface())); err != nil {
+ if extension.ExtendedType != nil {
+ // can only check type if this is a complete descriptor
+ if err := checkExtensionTypes(epb, extension); err != nil {
return nil, err
}
- if m2.Has(xtd) {
- mr.Set(xtd, m2.Get(xtd))
- clearUnknown(mr, fieldNum(xt.Field))
- }
}
- // Check whether the message has the extension field set or a default.
- var pv protoreflect.Value
- switch {
- case mr.Has(xtd):
- pv = mr.Get(xtd)
- case xtd.HasDefault():
- pv = xtd.Default()
- default:
+ emap, mu := epb.extensionsRead()
+ if emap == nil {
+ return defaultExtensionValue(extension)
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ e, ok := emap[extension.Field]
+ if !ok {
+ // defaultExtensionValue returns the default value or
+ // ErrMissingExtension if there is no default.
+ return defaultExtensionValue(extension)
+ }
+
+ if e.value != nil {
+ // Already decoded. Check the descriptor, though.
+ if e.desc != extension {
+ // This shouldn't happen. If it does, it means that
+ // GetExtension was called twice with two different
+ // descriptors with the same field number.
+ return nil, errors.New("proto: descriptor conflict")
+ }
+ return extensionAsLegacyType(e.value), nil
+ }
+
+ if extension.ExtensionType == nil {
+ // incomplete descriptor
+ return e.enc, nil
+ }
+
+ v, err := decodeExtension(e.enc, extension)
+ if err != nil {
+ return nil, err
+ }
+
+ // Remember the decoded version and drop the encoded version.
+ // That way it is safe to mutate what we return.
+ e.value = extensionAsStorageType(v)
+ e.desc = extension
+ e.enc = nil
+ emap[extension.Field] = e
+ return extensionAsLegacyType(e.value), nil
+}
+
+// defaultExtensionValue returns the default value for extension.
+// If no default for an extension is defined ErrMissingExtension is returned.
+func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
+ if extension.ExtensionType == nil {
+ // incomplete descriptor, so no default
return nil, ErrMissingExtension
}
- v := xt.InterfaceOf(pv)
- rv := reflect.ValueOf(v)
- if isScalarKind(rv.Kind()) {
- rv2 := reflect.New(rv.Type())
- rv2.Elem().Set(rv)
- v = rv2.Interface()
+ t := reflect.TypeOf(extension.ExtensionType)
+ props := extensionProperties(extension)
+
+ sf, _, err := fieldDefault(t, props)
+ if err != nil {
+ return nil, err
}
- return v, nil
+
+ if sf == nil || sf.value == nil {
+ // There is no default value.
+ return nil, ErrMissingExtension
+ }
+
+ if t.Kind() != reflect.Ptr {
+ // We do not need to return a Ptr, we can directly return sf.value.
+ return sf.value, nil
+ }
+
+ // We need to return an interface{} that is a pointer to sf.value.
+ value := reflect.New(t).Elem()
+ value.Set(reflect.New(value.Type().Elem()))
+ if sf.kind == reflect.Int32 {
+ // We may have an int32 or an enum, but the underlying data is int32.
+ // Since we can't set an int32 into a non int32 reflect.value directly
+ // set it as a int32.
+ value.Elem().SetInt(int64(sf.value.(int32)))
+ } else {
+ value.Elem().Set(reflect.ValueOf(sf.value))
+ }
+ return value.Interface(), nil
}
-// extensionResolver is a custom extension resolver that stores a single
-// extension type that takes precedence over the global registry.
-type extensionResolver struct{ xt protoreflect.ExtensionType }
+// decodeExtension decodes an extension encoded in b.
+func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
+ t := reflect.TypeOf(extension.ExtensionType)
+ unmarshal := typeUnmarshaler(t, extension.Tag)
-func (r extensionResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
- if xtd := r.xt.TypeDescriptor(); xtd.FullName() == field {
- return r.xt, nil
- }
- return protoregistry.GlobalTypes.FindExtensionByName(field)
-}
+ // t is a pointer to a struct, pointer to basic type or a slice.
+ // Allocate space to store the pointer/slice.
+ value := reflect.New(t).Elem()
-func (r extensionResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
- if xtd := r.xt.TypeDescriptor(); xtd.ContainingMessage().FullName() == message && xtd.Number() == field {
- return r.xt, nil
- }
- return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
-}
+ var err error
+ for {
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ wire := int(x) & 7
-// GetExtensions returns a list of the extensions values present in m,
-// corresponding with the provided list of extension descriptors, xts.
-// If an extension is missing in m, the corresponding value is nil.
-func GetExtensions(m Message, xts []*ExtensionDesc) ([]interface{}, error) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() {
- return nil, errNotExtendable
- }
-
- vs := make([]interface{}, len(xts))
- for i, xt := range xts {
- v, err := GetExtension(m, xt)
+ b, err = unmarshal(b, valToPointer(value.Addr()), wire)
if err != nil {
- if err == ErrMissingExtension {
- continue
- }
- return vs, err
+ return nil, err
}
- vs[i] = v
+
+ if len(b) == 0 {
+ break
+ }
}
- return vs, nil
+ return value.Interface(), nil
}
-// SetExtension sets an extension field in m to the provided value.
-func SetExtension(m Message, xt *ExtensionDesc, v interface{}) error {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
- return errNotExtendable
+// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
+// The returned slice has the same length as es; missing extensions will appear as nil elements.
+func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
+ epb, err := extendable(pb)
+ if err != nil {
+ return nil, err
}
-
- rv := reflect.ValueOf(v)
- if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) {
- return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType)
- }
- if rv.Kind() == reflect.Ptr {
- if rv.IsNil() {
- return fmt.Errorf("proto: SetExtension called with nil value of type %T", v)
+ extensions = make([]interface{}, len(es))
+ for i, e := range es {
+ extensions[i], err = GetExtension(epb, e)
+ if err == ErrMissingExtension {
+ err = nil
}
- if isScalarKind(rv.Elem().Kind()) {
- v = rv.Elem().Interface()
+ if err != nil {
+ return
}
}
+ return
+}
- xtd := xt.TypeDescriptor()
- if !isValidExtension(mr.Descriptor(), xtd) {
- return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
+// just the Field field, which defines the extension's field number.
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
+ epb, err := extendable(pb)
+ if err != nil {
+ return nil, err
}
- mr.Set(xtd, xt.ValueOf(v))
- clearUnknown(mr, fieldNum(xt.Field))
+ registeredExtensions := RegisteredExtensions(pb)
+
+ emap, mu := epb.extensionsRead()
+ if emap == nil {
+ return nil, nil
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ extensions := make([]*ExtensionDesc, 0, len(emap))
+ for extid, e := range emap {
+ desc := e.desc
+ if desc == nil {
+ desc = registeredExtensions[extid]
+ if desc == nil {
+ desc = &ExtensionDesc{Field: extid}
+ }
+ }
+
+ extensions = append(extensions, desc)
+ }
+ return extensions, nil
+}
+
+// SetExtension sets the specified extension of pb to the specified value.
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
+ epb, err := extendable(pb)
+ if err != nil {
+ return err
+ }
+ if err := checkExtensionTypes(epb, extension); err != nil {
+ return err
+ }
+ typ := reflect.TypeOf(extension.ExtensionType)
+ if typ != reflect.TypeOf(value) {
+ return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
+ }
+ // nil extension values need to be caught early, because the
+ // encoder can't distinguish an ErrNil due to a nil extension
+ // from an ErrNil due to a missing field. Extensions are
+ // always optional, so the encoder would just swallow the error
+ // and drop all the extensions from the encoded message.
+ if reflect.ValueOf(value).IsNil() {
+ return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+ }
+
+ extmap := epb.extensionsWrite()
+ extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
return nil
}
-// SetRawExtension inserts b into the unknown fields of m.
-//
-// Deprecated: Use Message.ProtoReflect.SetUnknown instead.
-func SetRawExtension(m Message, fnum int32, b []byte) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() {
+// ClearAllExtensions clears all extensions from pb.
+func ClearAllExtensions(pb Message) {
+ epb, err := extendable(pb)
+ if err != nil {
return
}
-
- // Verify that the raw field is valid.
- for b0 := b; len(b0) > 0; {
- num, _, n := protowire.ConsumeField(b0)
- if int32(num) != fnum {
- panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum))
- }
- b0 = b0[n:]
+ m := epb.extensionsWrite()
+ for k := range m {
+ delete(m, k)
}
-
- ClearExtension(m, &ExtensionDesc{Field: fnum})
- mr.SetUnknown(append(mr.GetUnknown(), b...))
}
-// ExtensionDescs returns a list of extension descriptors found in m,
-// containing descriptors for both populated extension fields in m and
-// also unknown fields of m that are in the extension range.
-// For the later case, an type incomplete descriptor is provided where only
-// the ExtensionDesc.Field field is populated.
-// The order of the extension descriptors is undefined.
-func ExtensionDescs(m Message) ([]*ExtensionDesc, error) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
- return nil, errNotExtendable
- }
+// A global registry of extensions.
+// The generated code will register the generated descriptors by calling RegisterExtension.
- // Collect a set of known extension descriptors.
- extDescs := make(map[protoreflect.FieldNumber]*ExtensionDesc)
- mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- if fd.IsExtension() {
- xt := fd.(protoreflect.ExtensionTypeDescriptor)
- if xd, ok := xt.Type().(*ExtensionDesc); ok {
- extDescs[fd.Number()] = xd
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
+// RegisterExtension is called from the generated code.
+func RegisterExtension(desc *ExtensionDesc) {
+ st := reflect.TypeOf(desc.ExtendedType).Elem()
+ m := extensionMaps[st]
+ if m == nil {
+ m = make(map[int32]*ExtensionDesc)
+ extensionMaps[st] = m
+ }
+ if _, ok := m[desc.Field]; ok {
+ panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+ }
+ m[desc.Field] = desc
+}
+
+// RegisteredExtensions returns a map of the registered extensions of a
+// protocol buffer struct, indexed by the extension number.
+// The argument pb should be a nil pointer to the struct type.
+func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
+ return extensionMaps[reflect.TypeOf(pb).Elem()]
+}
+
+// extensionAsLegacyType converts an value in the storage type as the API type.
+// See Extension.value.
+func extensionAsLegacyType(v interface{}) interface{} {
+ switch rv := reflect.ValueOf(v); rv.Kind() {
+ case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+ // Represent primitive types as a pointer to the value.
+ rv2 := reflect.New(rv.Type())
+ rv2.Elem().Set(rv)
+ v = rv2.Interface()
+ case reflect.Ptr:
+ // Represent slice types as the value itself.
+ switch rv.Type().Elem().Kind() {
+ case reflect.Slice:
+ if rv.IsNil() {
+ v = reflect.Zero(rv.Type().Elem()).Interface()
+ } else {
+ v = rv.Elem().Interface()
}
}
- return true
- })
+ }
+ return v
+}
- // Collect a set of unknown extension descriptors.
- extRanges := mr.Descriptor().ExtensionRanges()
- for b := mr.GetUnknown(); len(b) > 0; {
- num, _, n := protowire.ConsumeField(b)
- if extRanges.Has(num) && extDescs[num] == nil {
- extDescs[num] = nil
+// extensionAsStorageType converts an value in the API type as the storage type.
+// See Extension.value.
+func extensionAsStorageType(v interface{}) interface{} {
+ switch rv := reflect.ValueOf(v); rv.Kind() {
+ case reflect.Ptr:
+ // Represent slice types as the value itself.
+ switch rv.Type().Elem().Kind() {
+ case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+ if rv.IsNil() {
+ v = reflect.Zero(rv.Type().Elem()).Interface()
+ } else {
+ v = rv.Elem().Interface()
+ }
}
- b = b[n:]
- }
-
- // Transpose the set of descriptors into a list.
- var xts []*ExtensionDesc
- for num, xt := range extDescs {
- if xt == nil {
- xt = &ExtensionDesc{Field: int32(num)}
+ case reflect.Slice:
+ // Represent slice types as a pointer to the value.
+ if rv.Type().Elem().Kind() != reflect.Uint8 {
+ rv2 := reflect.New(rv.Type())
+ rv2.Elem().Set(rv)
+ v = rv2.Interface()
}
- xts = append(xts, xt)
}
- return xts, nil
-}
-
-// isValidExtension reports whether xtd is a valid extension descriptor for md.
-func isValidExtension(md protoreflect.MessageDescriptor, xtd protoreflect.ExtensionTypeDescriptor) bool {
- return xtd.ContainingMessage() == md && md.ExtensionRanges().Has(xtd.Number())
-}
-
-// isScalarKind reports whether k is a protobuf scalar kind (except bytes).
-// This function exists for historical reasons since the representation of
-// scalars differs between v1 and v2, where v1 uses *T and v2 uses T.
-func isScalarKind(k reflect.Kind) bool {
- switch k {
- case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
- return true
- default:
- return false
- }
-}
-
-// clearUnknown removes unknown fields from m where remover.Has reports true.
-func clearUnknown(m protoreflect.Message, remover interface {
- Has(protoreflect.FieldNumber) bool
-}) {
- var bo protoreflect.RawFields
- for bi := m.GetUnknown(); len(bi) > 0; {
- num, _, n := protowire.ConsumeField(bi)
- if !remover.Has(num) {
- bo = append(bo, bi[:n]...)
- }
- bi = bi[n:]
- }
- if bi := m.GetUnknown(); len(bi) != len(bo) {
- m.SetUnknown(bo)
- }
-}
-
-type fieldNum protoreflect.FieldNumber
-
-func (n1 fieldNum) Has(n2 protoreflect.FieldNumber) bool {
- return protoreflect.FieldNumber(n1) == n2
+ return v
}
diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
new file mode 100644
index 0000000..fdd328b
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/lib.go
@@ -0,0 +1,965 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+/*
+Package proto converts data structures to and from the wire format of
+protocol buffers. It works in concert with the Go source code generated
+for .proto files by the protocol compiler.
+
+A summary of the properties of the protocol buffer interface
+for a protocol buffer variable v:
+
+ - Names are turned from camel_case to CamelCase for export.
+ - There are no methods on v to set fields; just treat
+ them as structure fields.
+ - There are getters that return a field's value if set,
+ and return the field's default value if unset.
+ The getters work even if the receiver is a nil message.
+ - The zero value for a struct is its correct initialization state.
+ All desired fields must be set before marshaling.
+ - A Reset() method will restore a protobuf struct to its zero state.
+ - Non-repeated fields are pointers to the values; nil means unset.
+ That is, optional or required field int32 f becomes F *int32.
+ - Repeated fields are slices.
+ - Helper functions are available to aid the setting of fields.
+ msg.Foo = proto.String("hello") // set field
+ - Constants are defined to hold the default values of all fields that
+ have them. They have the form Default_StructName_FieldName.
+ Because the getter methods handle defaulted values,
+ direct use of these constants should be rare.
+ - Enums are given type names and maps from names to values.
+ Enum values are prefixed by the enclosing message's name, or by the
+ enum's type name if it is a top-level enum. Enum types have a String
+ method, and a Enum method to assist in message construction.
+ - Nested messages, groups and enums have type names prefixed with the name of
+ the surrounding message type.
+ - Extensions are given descriptor names that start with E_,
+ followed by an underscore-delimited list of the nested messages
+ that contain it (if any) followed by the CamelCased name of the
+ extension field itself. HasExtension, ClearExtension, GetExtension
+ and SetExtension are functions for manipulating extensions.
+ - Oneof field sets are given a single field in their message,
+ with distinguished wrapper types for each possible field value.
+ - Marshal and Unmarshal are functions to encode and decode the wire format.
+
+When the .proto file specifies `syntax="proto3"`, there are some differences:
+
+ - Non-repeated fields of non-message type are values instead of pointers.
+ - Enum types do not get an Enum method.
+
+The simplest way to describe this is to see an example.
+Given file test.proto, containing
+
+ package example;
+
+ enum FOO { X = 17; }
+
+ message Test {
+ required string label = 1;
+ optional int32 type = 2 [default=77];
+ repeated int64 reps = 3;
+ optional group OptionalGroup = 4 {
+ required string RequiredField = 5;
+ }
+ oneof union {
+ int32 number = 6;
+ string name = 7;
+ }
+ }
+
+The resulting file, test.pb.go, is:
+
+ package example
+
+ import proto "github.com/golang/protobuf/proto"
+ import math "math"
+
+ type FOO int32
+ const (
+ FOO_X FOO = 17
+ )
+ var FOO_name = map[int32]string{
+ 17: "X",
+ }
+ var FOO_value = map[string]int32{
+ "X": 17,
+ }
+
+ func (x FOO) Enum() *FOO {
+ p := new(FOO)
+ *p = x
+ return p
+ }
+ func (x FOO) String() string {
+ return proto.EnumName(FOO_name, int32(x))
+ }
+ func (x *FOO) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FOO_value, data)
+ if err != nil {
+ return err
+ }
+ *x = FOO(value)
+ return nil
+ }
+
+ type Test struct {
+ Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+ Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
+ Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
+ Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
+ // Types that are valid to be assigned to Union:
+ // *Test_Number
+ // *Test_Name
+ Union isTest_Union `protobuf_oneof:"union"`
+ XXX_unrecognized []byte `json:"-"`
+ }
+ func (m *Test) Reset() { *m = Test{} }
+ func (m *Test) String() string { return proto.CompactTextString(m) }
+ func (*Test) ProtoMessage() {}
+
+ type isTest_Union interface {
+ isTest_Union()
+ }
+
+ type Test_Number struct {
+ Number int32 `protobuf:"varint,6,opt,name=number"`
+ }
+ type Test_Name struct {
+ Name string `protobuf:"bytes,7,opt,name=name"`
+ }
+
+ func (*Test_Number) isTest_Union() {}
+ func (*Test_Name) isTest_Union() {}
+
+ func (m *Test) GetUnion() isTest_Union {
+ if m != nil {
+ return m.Union
+ }
+ return nil
+ }
+ const Default_Test_Type int32 = 77
+
+ func (m *Test) GetLabel() string {
+ if m != nil && m.Label != nil {
+ return *m.Label
+ }
+ return ""
+ }
+
+ func (m *Test) GetType() int32 {
+ if m != nil && m.Type != nil {
+ return *m.Type
+ }
+ return Default_Test_Type
+ }
+
+ func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
+ if m != nil {
+ return m.Optionalgroup
+ }
+ return nil
+ }
+
+ type Test_OptionalGroup struct {
+ RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
+ }
+ func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} }
+ func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
+
+ func (m *Test_OptionalGroup) GetRequiredField() string {
+ if m != nil && m.RequiredField != nil {
+ return *m.RequiredField
+ }
+ return ""
+ }
+
+ func (m *Test) GetNumber() int32 {
+ if x, ok := m.GetUnion().(*Test_Number); ok {
+ return x.Number
+ }
+ return 0
+ }
+
+ func (m *Test) GetName() string {
+ if x, ok := m.GetUnion().(*Test_Name); ok {
+ return x.Name
+ }
+ return ""
+ }
+
+ func init() {
+ proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+ }
+
+To create and play with a Test object:
+
+ package main
+
+ import (
+ "log"
+
+ "github.com/golang/protobuf/proto"
+ pb "./example.pb"
+ )
+
+ func main() {
+ test := &pb.Test{
+ Label: proto.String("hello"),
+ Type: proto.Int32(17),
+ Reps: []int64{1, 2, 3},
+ Optionalgroup: &pb.Test_OptionalGroup{
+ RequiredField: proto.String("good bye"),
+ },
+ Union: &pb.Test_Name{"fred"},
+ }
+ data, err := proto.Marshal(test)
+ if err != nil {
+ log.Fatal("marshaling error: ", err)
+ }
+ newTest := &pb.Test{}
+ err = proto.Unmarshal(data, newTest)
+ if err != nil {
+ log.Fatal("unmarshaling error: ", err)
+ }
+ // Now test and newTest contain the same data.
+ if test.GetLabel() != newTest.GetLabel() {
+ log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
+ }
+ // Use a type switch to determine which oneof was set.
+ switch u := test.Union.(type) {
+ case *pb.Test_Number: // u.Number contains the number.
+ case *pb.Test_Name: // u.Name contains the string.
+ }
+ // etc.
+ }
+*/
+package proto
+
+import (
+ "encoding/json"
+ "fmt"
+ "log"
+ "reflect"
+ "sort"
+ "strconv"
+ "sync"
+)
+
+// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
+// Marshal reports this when a required field is not initialized.
+// Unmarshal reports this when a required field is missing from the wire data.
+type RequiredNotSetError struct{ field string }
+
+func (e *RequiredNotSetError) Error() string {
+ if e.field == "" {
+ return fmt.Sprintf("proto: required field not set")
+ }
+ return fmt.Sprintf("proto: required field %q not set", e.field)
+}
+func (e *RequiredNotSetError) RequiredNotSet() bool {
+ return true
+}
+
+type invalidUTF8Error struct{ field string }
+
+func (e *invalidUTF8Error) Error() string {
+ if e.field == "" {
+ return "proto: invalid UTF-8 detected"
+ }
+ return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)
+}
+func (e *invalidUTF8Error) InvalidUTF8() bool {
+ return true
+}
+
+// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
+// This error should not be exposed to the external API as such errors should
+// be recreated with the field information.
+var errInvalidUTF8 = &invalidUTF8Error{}
+
+// isNonFatal reports whether the error is either a RequiredNotSet error
+// or a InvalidUTF8 error.
+func isNonFatal(err error) bool {
+ if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {
+ return true
+ }
+ if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {
+ return true
+ }
+ return false
+}
+
+type nonFatal struct{ E error }
+
+// Merge merges err into nf and reports whether it was successful.
+// Otherwise it returns false for any fatal non-nil errors.
+func (nf *nonFatal) Merge(err error) (ok bool) {
+ if err == nil {
+ return true // not an error
+ }
+ if !isNonFatal(err) {
+ return false // fatal error
+ }
+ if nf.E == nil {
+ nf.E = err // store first instance of non-fatal error
+ }
+ return true
+}
+
+// Message is implemented by generated protocol buffer messages.
+type Message interface {
+ Reset()
+ String() string
+ ProtoMessage()
+}
+
+// A Buffer is a buffer manager for marshaling and unmarshaling
+// protocol buffers. It may be reused between invocations to
+// reduce memory usage. It is not necessary to use a Buffer;
+// the global functions Marshal and Unmarshal create a
+// temporary Buffer and are fine for most applications.
+type Buffer struct {
+ buf []byte // encode/decode byte stream
+ index int // read point
+
+ deterministic bool
+}
+
+// NewBuffer allocates a new Buffer and initializes its internal data to
+// the contents of the argument slice.
+func NewBuffer(e []byte) *Buffer {
+ return &Buffer{buf: e}
+}
+
+// Reset resets the Buffer, ready for marshaling a new protocol buffer.
+func (p *Buffer) Reset() {
+ p.buf = p.buf[0:0] // for reading/writing
+ p.index = 0 // for reading
+}
+
+// SetBuf replaces the internal buffer with the slice,
+// ready for unmarshaling the contents of the slice.
+func (p *Buffer) SetBuf(s []byte) {
+ p.buf = s
+ p.index = 0
+}
+
+// Bytes returns the contents of the Buffer.
+func (p *Buffer) Bytes() []byte { return p.buf }
+
+// SetDeterministic sets whether to use deterministic serialization.
+//
+// Deterministic serialization guarantees that for a given binary, equal
+// messages will always be serialized to the same bytes. This implies:
+//
+// - Repeated serialization of a message will return the same bytes.
+// - Different processes of the same binary (which may be executing on
+// different machines) will serialize equal messages to the same bytes.
+//
+// Note that the deterministic serialization is NOT canonical across
+// languages. It is not guaranteed to remain stable over time. It is unstable
+// across different builds with schema changes due to unknown fields.
+// Users who need canonical serialization (e.g., persistent storage in a
+// canonical form, fingerprinting, etc.) should define their own
+// canonicalization specification and implement their own serializer rather
+// than relying on this API.
+//
+// If deterministic serialization is requested, map entries will be sorted
+// by keys in lexographical order. This is an implementation detail and
+// subject to change.
+func (p *Buffer) SetDeterministic(deterministic bool) {
+ p.deterministic = deterministic
+}
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool {
+ return &v
+}
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 {
+ return &v
+}
+
+// Int is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it, but unlike Int32
+// its argument value is an int.
+func Int(v int) *int32 {
+ p := new(int32)
+ *p = int32(v)
+ return p
+}
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 {
+ return &v
+}
+
+// Float32 is a helper routine that allocates a new float32 value
+// to store v and returns a pointer to it.
+func Float32(v float32) *float32 {
+ return &v
+}
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 {
+ return &v
+}
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 {
+ return &v
+}
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 {
+ return &v
+}
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string {
+ return &v
+}
+
+// EnumName is a helper function to simplify printing protocol buffer enums
+// by name. Given an enum map and a value, it returns a useful string.
+func EnumName(m map[int32]string, v int32) string {
+ s, ok := m[v]
+ if ok {
+ return s
+ }
+ return strconv.Itoa(int(v))
+}
+
+// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
+// from their JSON-encoded representation. Given a map from the enum's symbolic
+// names to its int values, and a byte buffer containing the JSON-encoded
+// value, it returns an int32 that can be cast to the enum type by the caller.
+//
+// The function can deal with both JSON representations, numeric and symbolic.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+ if data[0] == '"' {
+ // New style: enums are strings.
+ var repr string
+ if err := json.Unmarshal(data, &repr); err != nil {
+ return -1, err
+ }
+ val, ok := m[repr]
+ if !ok {
+ return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+ }
+ return val, nil
+ }
+ // Old style: enums are ints.
+ var val int32
+ if err := json.Unmarshal(data, &val); err != nil {
+ return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+ }
+ return val, nil
+}
+
+// DebugPrint dumps the encoded data in b in a debugging format with a header
+// including the string s. Used in testing but made available for general debugging.
+func (p *Buffer) DebugPrint(s string, b []byte) {
+ var u uint64
+
+ obuf := p.buf
+ index := p.index
+ p.buf = b
+ p.index = 0
+ depth := 0
+
+ fmt.Printf("\n--- %s ---\n", s)
+
+out:
+ for {
+ for i := 0; i < depth; i++ {
+ fmt.Print(" ")
+ }
+
+ index := p.index
+ if index == len(p.buf) {
+ break
+ }
+
+ op, err := p.DecodeVarint()
+ if err != nil {
+ fmt.Printf("%3d: fetching op err %v\n", index, err)
+ break out
+ }
+ tag := op >> 3
+ wire := op & 7
+
+ switch wire {
+ default:
+ fmt.Printf("%3d: t=%3d unknown wire=%d\n",
+ index, tag, wire)
+ break out
+
+ case WireBytes:
+ var r []byte
+
+ r, err = p.DecodeRawBytes(false)
+ if err != nil {
+ break out
+ }
+ fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
+ if len(r) <= 6 {
+ for i := 0; i < len(r); i++ {
+ fmt.Printf(" %.2x", r[i])
+ }
+ } else {
+ for i := 0; i < 3; i++ {
+ fmt.Printf(" %.2x", r[i])
+ }
+ fmt.Printf(" ..")
+ for i := len(r) - 3; i < len(r); i++ {
+ fmt.Printf(" %.2x", r[i])
+ }
+ }
+ fmt.Printf("\n")
+
+ case WireFixed32:
+ u, err = p.DecodeFixed32()
+ if err != nil {
+ fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
+ break out
+ }
+ fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
+
+ case WireFixed64:
+ u, err = p.DecodeFixed64()
+ if err != nil {
+ fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
+ break out
+ }
+ fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
+
+ case WireVarint:
+ u, err = p.DecodeVarint()
+ if err != nil {
+ fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
+ break out
+ }
+ fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
+
+ case WireStartGroup:
+ fmt.Printf("%3d: t=%3d start\n", index, tag)
+ depth++
+
+ case WireEndGroup:
+ depth--
+ fmt.Printf("%3d: t=%3d end\n", index, tag)
+ }
+ }
+
+ if depth != 0 {
+ fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
+ }
+ fmt.Printf("\n")
+
+ p.buf = obuf
+ p.index = index
+}
+
+// SetDefaults sets unset protocol buffer fields to their default values.
+// It only modifies fields that are both unset and have defined defaults.
+// It recursively sets default values in any non-nil sub-messages.
+func SetDefaults(pb Message) {
+ setDefaults(reflect.ValueOf(pb), true, false)
+}
+
+// v is a pointer to a struct.
+func setDefaults(v reflect.Value, recur, zeros bool) {
+ v = v.Elem()
+
+ defaultMu.RLock()
+ dm, ok := defaults[v.Type()]
+ defaultMu.RUnlock()
+ if !ok {
+ dm = buildDefaultMessage(v.Type())
+ defaultMu.Lock()
+ defaults[v.Type()] = dm
+ defaultMu.Unlock()
+ }
+
+ for _, sf := range dm.scalars {
+ f := v.Field(sf.index)
+ if !f.IsNil() {
+ // field already set
+ continue
+ }
+ dv := sf.value
+ if dv == nil && !zeros {
+ // no explicit default, and don't want to set zeros
+ continue
+ }
+ fptr := f.Addr().Interface() // **T
+ // TODO: Consider batching the allocations we do here.
+ switch sf.kind {
+ case reflect.Bool:
+ b := new(bool)
+ if dv != nil {
+ *b = dv.(bool)
+ }
+ *(fptr.(**bool)) = b
+ case reflect.Float32:
+ f := new(float32)
+ if dv != nil {
+ *f = dv.(float32)
+ }
+ *(fptr.(**float32)) = f
+ case reflect.Float64:
+ f := new(float64)
+ if dv != nil {
+ *f = dv.(float64)
+ }
+ *(fptr.(**float64)) = f
+ case reflect.Int32:
+ // might be an enum
+ if ft := f.Type(); ft != int32PtrType {
+ // enum
+ f.Set(reflect.New(ft.Elem()))
+ if dv != nil {
+ f.Elem().SetInt(int64(dv.(int32)))
+ }
+ } else {
+ // int32 field
+ i := new(int32)
+ if dv != nil {
+ *i = dv.(int32)
+ }
+ *(fptr.(**int32)) = i
+ }
+ case reflect.Int64:
+ i := new(int64)
+ if dv != nil {
+ *i = dv.(int64)
+ }
+ *(fptr.(**int64)) = i
+ case reflect.String:
+ s := new(string)
+ if dv != nil {
+ *s = dv.(string)
+ }
+ *(fptr.(**string)) = s
+ case reflect.Uint8:
+ // exceptional case: []byte
+ var b []byte
+ if dv != nil {
+ db := dv.([]byte)
+ b = make([]byte, len(db))
+ copy(b, db)
+ } else {
+ b = []byte{}
+ }
+ *(fptr.(*[]byte)) = b
+ case reflect.Uint32:
+ u := new(uint32)
+ if dv != nil {
+ *u = dv.(uint32)
+ }
+ *(fptr.(**uint32)) = u
+ case reflect.Uint64:
+ u := new(uint64)
+ if dv != nil {
+ *u = dv.(uint64)
+ }
+ *(fptr.(**uint64)) = u
+ default:
+ log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
+ }
+ }
+
+ for _, ni := range dm.nested {
+ f := v.Field(ni)
+ // f is *T or []*T or map[T]*T
+ switch f.Kind() {
+ case reflect.Ptr:
+ if f.IsNil() {
+ continue
+ }
+ setDefaults(f, recur, zeros)
+
+ case reflect.Slice:
+ for i := 0; i < f.Len(); i++ {
+ e := f.Index(i)
+ if e.IsNil() {
+ continue
+ }
+ setDefaults(e, recur, zeros)
+ }
+
+ case reflect.Map:
+ for _, k := range f.MapKeys() {
+ e := f.MapIndex(k)
+ if e.IsNil() {
+ continue
+ }
+ setDefaults(e, recur, zeros)
+ }
+ }
+ }
+}
+
+var (
+ // defaults maps a protocol buffer struct type to a slice of the fields,
+ // with its scalar fields set to their proto-declared non-zero default values.
+ defaultMu sync.RWMutex
+ defaults = make(map[reflect.Type]defaultMessage)
+
+ int32PtrType = reflect.TypeOf((*int32)(nil))
+)
+
+// defaultMessage represents information about the default values of a message.
+type defaultMessage struct {
+ scalars []scalarField
+ nested []int // struct field index of nested messages
+}
+
+type scalarField struct {
+ index int // struct field index
+ kind reflect.Kind // element type (the T in *T or []T)
+ value interface{} // the proto-declared default value, or nil
+}
+
+// t is a struct type.
+func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
+ sprop := GetProperties(t)
+ for _, prop := range sprop.Prop {
+ fi, ok := sprop.decoderTags.get(prop.Tag)
+ if !ok {
+ // XXX_unrecognized
+ continue
+ }
+ ft := t.Field(fi).Type
+
+ sf, nested, err := fieldDefault(ft, prop)
+ switch {
+ case err != nil:
+ log.Print(err)
+ case nested:
+ dm.nested = append(dm.nested, fi)
+ case sf != nil:
+ sf.index = fi
+ dm.scalars = append(dm.scalars, *sf)
+ }
+ }
+
+ return dm
+}
+
+// fieldDefault returns the scalarField for field type ft.
+// sf will be nil if the field can not have a default.
+// nestedMessage will be true if this is a nested message.
+// Note that sf.index is not set on return.
+func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
+ var canHaveDefault bool
+ switch ft.Kind() {
+ case reflect.Ptr:
+ if ft.Elem().Kind() == reflect.Struct {
+ nestedMessage = true
+ } else {
+ canHaveDefault = true // proto2 scalar field
+ }
+
+ case reflect.Slice:
+ switch ft.Elem().Kind() {
+ case reflect.Ptr:
+ nestedMessage = true // repeated message
+ case reflect.Uint8:
+ canHaveDefault = true // bytes field
+ }
+
+ case reflect.Map:
+ if ft.Elem().Kind() == reflect.Ptr {
+ nestedMessage = true // map with message values
+ }
+ }
+
+ if !canHaveDefault {
+ if nestedMessage {
+ return nil, true, nil
+ }
+ return nil, false, nil
+ }
+
+ // We now know that ft is a pointer or slice.
+ sf = &scalarField{kind: ft.Elem().Kind()}
+
+ // scalar fields without defaults
+ if !prop.HasDefault {
+ return sf, false, nil
+ }
+
+ // a scalar field: either *T or []byte
+ switch ft.Elem().Kind() {
+ case reflect.Bool:
+ x, err := strconv.ParseBool(prop.Default)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ case reflect.Float32:
+ x, err := strconv.ParseFloat(prop.Default, 32)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
+ }
+ sf.value = float32(x)
+ case reflect.Float64:
+ x, err := strconv.ParseFloat(prop.Default, 64)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ case reflect.Int32:
+ x, err := strconv.ParseInt(prop.Default, 10, 32)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
+ }
+ sf.value = int32(x)
+ case reflect.Int64:
+ x, err := strconv.ParseInt(prop.Default, 10, 64)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ case reflect.String:
+ sf.value = prop.Default
+ case reflect.Uint8:
+ // []byte (not *uint8)
+ sf.value = []byte(prop.Default)
+ case reflect.Uint32:
+ x, err := strconv.ParseUint(prop.Default, 10, 32)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
+ }
+ sf.value = uint32(x)
+ case reflect.Uint64:
+ x, err := strconv.ParseUint(prop.Default, 10, 64)
+ if err != nil {
+ return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
+ }
+ sf.value = x
+ default:
+ return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
+ }
+
+ return sf, false, nil
+}
+
+// mapKeys returns a sort.Interface to be used for sorting the map keys.
+// Map fields may have key types of non-float scalars, strings and enums.
+func mapKeys(vs []reflect.Value) sort.Interface {
+ s := mapKeySorter{vs: vs}
+
+ // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
+ if len(vs) == 0 {
+ return s
+ }
+ switch vs[0].Kind() {
+ case reflect.Int32, reflect.Int64:
+ s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
+ case reflect.Uint32, reflect.Uint64:
+ s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
+ case reflect.Bool:
+ s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
+ case reflect.String:
+ s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
+ default:
+ panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
+ }
+
+ return s
+}
+
+type mapKeySorter struct {
+ vs []reflect.Value
+ less func(a, b reflect.Value) bool
+}
+
+func (s mapKeySorter) Len() int { return len(s.vs) }
+func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
+func (s mapKeySorter) Less(i, j int) bool {
+ return s.less(s.vs[i], s.vs[j])
+}
+
+// isProto3Zero reports whether v is a zero proto3 value.
+func isProto3Zero(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint32, reflect.Uint64:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.String:
+ return v.String() == ""
+ }
+ return false
+}
+
+const (
+ // ProtoPackageIsVersion3 is referenced from generated protocol buffer files
+ // to assert that that code is compatible with this version of the proto package.
+ ProtoPackageIsVersion3 = true
+
+ // ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+ // to assert that that code is compatible with this version of the proto package.
+ ProtoPackageIsVersion2 = true
+
+ // ProtoPackageIsVersion1 is referenced from generated protocol buffer files
+ // to assert that that code is compatible with this version of the proto package.
+ ProtoPackageIsVersion1 = true
+)
+
+// InternalMessageInfo is a type used internally by generated .pb.go files.
+// This type is not intended to be used by non-generated code.
+// This type is not subject to any compatibility guarantee.
+type InternalMessageInfo struct {
+ marshal *marshalInfo
+ unmarshal *unmarshalInfo
+ merge *mergeInfo
+ discard *discardInfo
+}
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
new file mode 100644
index 0000000..f48a756
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/message_set.go
@@ -0,0 +1,181 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+/*
+ * Support for message sets.
+ */
+
+import (
+ "errors"
+)
+
+// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
+// A message type ID is required for storing a protocol buffer in a message set.
+var errNoMessageTypeID = errors.New("proto does not have a message type ID")
+
+// The first two types (_MessageSet_Item and messageSet)
+// model what the protocol compiler produces for the following protocol message:
+// message MessageSet {
+// repeated group Item = 1 {
+// required int32 type_id = 2;
+// required string message = 3;
+// };
+// }
+// That is the MessageSet wire format. We can't use a proto to generate these
+// because that would introduce a circular dependency between it and this package.
+
+type _MessageSet_Item struct {
+ TypeId *int32 `protobuf:"varint,2,req,name=type_id"`
+ Message []byte `protobuf:"bytes,3,req,name=message"`
+}
+
+type messageSet struct {
+ Item []*_MessageSet_Item `protobuf:"group,1,rep"`
+ XXX_unrecognized []byte
+ // TODO: caching?
+}
+
+// Make sure messageSet is a Message.
+var _ Message = (*messageSet)(nil)
+
+// messageTypeIder is an interface satisfied by a protocol buffer type
+// that may be stored in a MessageSet.
+type messageTypeIder interface {
+ MessageTypeId() int32
+}
+
+func (ms *messageSet) find(pb Message) *_MessageSet_Item {
+ mti, ok := pb.(messageTypeIder)
+ if !ok {
+ return nil
+ }
+ id := mti.MessageTypeId()
+ for _, item := range ms.Item {
+ if *item.TypeId == id {
+ return item
+ }
+ }
+ return nil
+}
+
+func (ms *messageSet) Has(pb Message) bool {
+ return ms.find(pb) != nil
+}
+
+func (ms *messageSet) Unmarshal(pb Message) error {
+ if item := ms.find(pb); item != nil {
+ return Unmarshal(item.Message, pb)
+ }
+ if _, ok := pb.(messageTypeIder); !ok {
+ return errNoMessageTypeID
+ }
+ return nil // TODO: return error instead?
+}
+
+func (ms *messageSet) Marshal(pb Message) error {
+ msg, err := Marshal(pb)
+ if err != nil {
+ return err
+ }
+ if item := ms.find(pb); item != nil {
+ // reuse existing item
+ item.Message = msg
+ return nil
+ }
+
+ mti, ok := pb.(messageTypeIder)
+ if !ok {
+ return errNoMessageTypeID
+ }
+
+ mtid := mti.MessageTypeId()
+ ms.Item = append(ms.Item, &_MessageSet_Item{
+ TypeId: &mtid,
+ Message: msg,
+ })
+ return nil
+}
+
+func (ms *messageSet) Reset() { *ms = messageSet{} }
+func (ms *messageSet) String() string { return CompactTextString(ms) }
+func (*messageSet) ProtoMessage() {}
+
+// Support for the message_set_wire_format message option.
+
+func skipVarint(buf []byte) []byte {
+ i := 0
+ for ; buf[i]&0x80 != 0; i++ {
+ }
+ return buf[i+1:]
+}
+
+// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
+func unmarshalMessageSet(buf []byte, exts interface{}) error {
+ var m map[int32]Extension
+ switch exts := exts.(type) {
+ case *XXX_InternalExtensions:
+ m = exts.extensionsWrite()
+ case map[int32]Extension:
+ m = exts
+ default:
+ return errors.New("proto: not an extension map")
+ }
+
+ ms := new(messageSet)
+ if err := Unmarshal(buf, ms); err != nil {
+ return err
+ }
+ for _, item := range ms.Item {
+ id := *item.TypeId
+ msg := item.Message
+
+ // Restore wire type and field number varint, plus length varint.
+ // Be careful to preserve duplicate items.
+ b := EncodeVarint(uint64(id)<<3 | WireBytes)
+ if ext, ok := m[id]; ok {
+ // Existing data; rip off the tag and length varint
+ // so we join the new data correctly.
+ // We can assume that ext.enc is set because we are unmarshaling.
+ o := ext.enc[len(b):] // skip wire type and field number
+ _, n := DecodeVarint(o) // calculate length of length varint
+ o = o[n:] // skip length varint
+ msg = append(o, msg...) // join old data and new data
+ }
+ b = append(b, EncodeVarint(uint64(len(msg)))...)
+ b = append(b, msg...)
+
+ m[id] = Extension{enc: b}
+ }
+ return nil
+}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
new file mode 100644
index 0000000..94fa919
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,360 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+// +build purego appengine js
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+ "reflect"
+ "sync"
+)
+
+const unsafeAllowed = false
+
+// A field identifies a field in a struct, accessible from a pointer.
+// In this implementation, a field is identified by the sequence of field indices
+// passed to reflect's FieldByIndex.
+type field []int
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+ return f.Index
+}
+
+// invalidField is an invalid field identifier.
+var invalidField = field(nil)
+
+// zeroField is a noop when calling pointer.offset.
+var zeroField = field([]int{})
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool { return f != nil }
+
+// The pointer type is for the table-driven decoder.
+// The implementation here uses a reflect.Value of pointer type to
+// create a generic pointer. In pointer_unsafe.go we use unsafe
+// instead of reflect to implement the same (but faster) interface.
+type pointer struct {
+ v reflect.Value
+}
+
+// toPointer converts an interface of pointer type to a pointer
+// that points to the same target.
+func toPointer(i *Message) pointer {
+ return pointer{v: reflect.ValueOf(*i)}
+}
+
+// toAddrPointer converts an interface to a pointer that points to
+// the interface data.
+func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
+ v := reflect.ValueOf(*i)
+ u := reflect.New(v.Type())
+ u.Elem().Set(v)
+ if deref {
+ u = u.Elem()
+ }
+ return pointer{v: u}
+}
+
+// valToPointer converts v to a pointer. v must be of pointer type.
+func valToPointer(v reflect.Value) pointer {
+ return pointer{v: v}
+}
+
+// offset converts from a pointer to a structure to a pointer to
+// one of its fields.
+func (p pointer) offset(f field) pointer {
+ return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
+}
+
+func (p pointer) isNil() bool {
+ return p.v.IsNil()
+}
+
+// grow updates the slice s in place to make it one element longer.
+// s must be addressable.
+// Returns the (addressable) new element.
+func grow(s reflect.Value) reflect.Value {
+ n, m := s.Len(), s.Cap()
+ if n < m {
+ s.SetLen(n + 1)
+ } else {
+ s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
+ }
+ return s.Index(n)
+}
+
+func (p pointer) toInt64() *int64 {
+ return p.v.Interface().(*int64)
+}
+func (p pointer) toInt64Ptr() **int64 {
+ return p.v.Interface().(**int64)
+}
+func (p pointer) toInt64Slice() *[]int64 {
+ return p.v.Interface().(*[]int64)
+}
+
+var int32ptr = reflect.TypeOf((*int32)(nil))
+
+func (p pointer) toInt32() *int32 {
+ return p.v.Convert(int32ptr).Interface().(*int32)
+}
+
+// The toInt32Ptr/Slice methods don't work because of enums.
+// Instead, we must use set/get methods for the int32ptr/slice case.
+/*
+ func (p pointer) toInt32Ptr() **int32 {
+ return p.v.Interface().(**int32)
+}
+ func (p pointer) toInt32Slice() *[]int32 {
+ return p.v.Interface().(*[]int32)
+}
+*/
+func (p pointer) getInt32Ptr() *int32 {
+ if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+ // raw int32 type
+ return p.v.Elem().Interface().(*int32)
+ }
+ // an enum
+ return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
+}
+func (p pointer) setInt32Ptr(v int32) {
+ // Allocate value in a *int32. Possibly convert that to a *enum.
+ // Then assign it to a **int32 or **enum.
+ // Note: we can convert *int32 to *enum, but we can't convert
+ // **int32 to **enum!
+ p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
+}
+
+// getInt32Slice copies []int32 from p as a new slice.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) getInt32Slice() []int32 {
+ if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+ // raw int32 type
+ return p.v.Elem().Interface().([]int32)
+ }
+ // an enum
+ // Allocate a []int32, then assign []enum's values into it.
+ // Note: we can't convert []enum to []int32.
+ slice := p.v.Elem()
+ s := make([]int32, slice.Len())
+ for i := 0; i < slice.Len(); i++ {
+ s[i] = int32(slice.Index(i).Int())
+ }
+ return s
+}
+
+// setInt32Slice copies []int32 into p as a new slice.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) setInt32Slice(v []int32) {
+ if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+ // raw int32 type
+ p.v.Elem().Set(reflect.ValueOf(v))
+ return
+ }
+ // an enum
+ // Allocate a []enum, then assign []int32's values into it.
+ // Note: we can't convert []enum to []int32.
+ slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
+ for i, x := range v {
+ slice.Index(i).SetInt(int64(x))
+ }
+ p.v.Elem().Set(slice)
+}
+func (p pointer) appendInt32Slice(v int32) {
+ grow(p.v.Elem()).SetInt(int64(v))
+}
+
+func (p pointer) toUint64() *uint64 {
+ return p.v.Interface().(*uint64)
+}
+func (p pointer) toUint64Ptr() **uint64 {
+ return p.v.Interface().(**uint64)
+}
+func (p pointer) toUint64Slice() *[]uint64 {
+ return p.v.Interface().(*[]uint64)
+}
+func (p pointer) toUint32() *uint32 {
+ return p.v.Interface().(*uint32)
+}
+func (p pointer) toUint32Ptr() **uint32 {
+ return p.v.Interface().(**uint32)
+}
+func (p pointer) toUint32Slice() *[]uint32 {
+ return p.v.Interface().(*[]uint32)
+}
+func (p pointer) toBool() *bool {
+ return p.v.Interface().(*bool)
+}
+func (p pointer) toBoolPtr() **bool {
+ return p.v.Interface().(**bool)
+}
+func (p pointer) toBoolSlice() *[]bool {
+ return p.v.Interface().(*[]bool)
+}
+func (p pointer) toFloat64() *float64 {
+ return p.v.Interface().(*float64)
+}
+func (p pointer) toFloat64Ptr() **float64 {
+ return p.v.Interface().(**float64)
+}
+func (p pointer) toFloat64Slice() *[]float64 {
+ return p.v.Interface().(*[]float64)
+}
+func (p pointer) toFloat32() *float32 {
+ return p.v.Interface().(*float32)
+}
+func (p pointer) toFloat32Ptr() **float32 {
+ return p.v.Interface().(**float32)
+}
+func (p pointer) toFloat32Slice() *[]float32 {
+ return p.v.Interface().(*[]float32)
+}
+func (p pointer) toString() *string {
+ return p.v.Interface().(*string)
+}
+func (p pointer) toStringPtr() **string {
+ return p.v.Interface().(**string)
+}
+func (p pointer) toStringSlice() *[]string {
+ return p.v.Interface().(*[]string)
+}
+func (p pointer) toBytes() *[]byte {
+ return p.v.Interface().(*[]byte)
+}
+func (p pointer) toBytesSlice() *[][]byte {
+ return p.v.Interface().(*[][]byte)
+}
+func (p pointer) toExtensions() *XXX_InternalExtensions {
+ return p.v.Interface().(*XXX_InternalExtensions)
+}
+func (p pointer) toOldExtensions() *map[int32]Extension {
+ return p.v.Interface().(*map[int32]Extension)
+}
+func (p pointer) getPointer() pointer {
+ return pointer{v: p.v.Elem()}
+}
+func (p pointer) setPointer(q pointer) {
+ p.v.Elem().Set(q.v)
+}
+func (p pointer) appendPointer(q pointer) {
+ grow(p.v.Elem()).Set(q.v)
+}
+
+// getPointerSlice copies []*T from p as a new []pointer.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) getPointerSlice() []pointer {
+ if p.v.IsNil() {
+ return nil
+ }
+ n := p.v.Elem().Len()
+ s := make([]pointer, n)
+ for i := 0; i < n; i++ {
+ s[i] = pointer{v: p.v.Elem().Index(i)}
+ }
+ return s
+}
+
+// setPointerSlice copies []pointer into p as a new []*T.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) setPointerSlice(v []pointer) {
+ if v == nil {
+ p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
+ return
+ }
+ s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
+ for _, p := range v {
+ s = reflect.Append(s, p.v)
+ }
+ p.v.Elem().Set(s)
+}
+
+// getInterfacePointer returns a pointer that points to the
+// interface data of the interface pointed by p.
+func (p pointer) getInterfacePointer() pointer {
+ if p.v.Elem().IsNil() {
+ return pointer{v: p.v.Elem()}
+ }
+ return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
+}
+
+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
+ // TODO: check that p.v.Type().Elem() == t?
+ return p.v
+}
+
+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ return *p
+}
+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ *p = v
+}
+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ return *p
+}
+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ *p = v
+}
+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ return *p
+}
+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ *p = v
+}
+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ return *p
+}
+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
+ atomicLock.Lock()
+ defer atomicLock.Unlock()
+ *p = v
+}
+
+var atomicLock sync.Mutex
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
new file mode 100644
index 0000000..dbfffe0
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,313 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+// +build !purego,!appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+ "reflect"
+ "sync/atomic"
+ "unsafe"
+)
+
+const unsafeAllowed = true
+
+// A field identifies a field in a struct, accessible from a pointer.
+// In this implementation, a field is identified by its byte offset from the start of the struct.
+type field uintptr
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+ return field(f.Offset)
+}
+
+// invalidField is an invalid field identifier.
+const invalidField = ^field(0)
+
+// zeroField is a noop when calling pointer.offset.
+const zeroField = field(0)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool {
+ return f != invalidField
+}
+
+// The pointer type below is for the new table-driven encoder/decoder.
+// The implementation here uses unsafe.Pointer to create a generic pointer.
+// In pointer_reflect.go we use reflect instead of unsafe to implement
+// the same (but slower) interface.
+type pointer struct {
+ p unsafe.Pointer
+}
+
+// size of pointer
+var ptrSize = unsafe.Sizeof(uintptr(0))
+
+// toPointer converts an interface of pointer type to a pointer
+// that points to the same target.
+func toPointer(i *Message) pointer {
+ // Super-tricky - read pointer out of data word of interface value.
+ // Saves ~25ns over the equivalent:
+ // return valToPointer(reflect.ValueOf(*i))
+ return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+}
+
+// toAddrPointer converts an interface to a pointer that points to
+// the interface data.
+func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
+ // Super-tricky - read or get the address of data word of interface value.
+ if isptr {
+ // The interface is of pointer type, thus it is a direct interface.
+ // The data word is the pointer data itself. We take its address.
+ p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
+ } else {
+ // The interface is not of pointer type. The data word is the pointer
+ // to the data.
+ p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+ }
+ if deref {
+ p.p = *(*unsafe.Pointer)(p.p)
+ }
+ return p
+}
+
+// valToPointer converts v to a pointer. v must be of pointer type.
+func valToPointer(v reflect.Value) pointer {
+ return pointer{p: unsafe.Pointer(v.Pointer())}
+}
+
+// offset converts from a pointer to a structure to a pointer to
+// one of its fields.
+func (p pointer) offset(f field) pointer {
+ // For safety, we should panic if !f.IsValid, however calling panic causes
+ // this to no longer be inlineable, which is a serious performance cost.
+ /*
+ if !f.IsValid() {
+ panic("invalid field")
+ }
+ */
+ return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
+}
+
+func (p pointer) isNil() bool {
+ return p.p == nil
+}
+
+func (p pointer) toInt64() *int64 {
+ return (*int64)(p.p)
+}
+func (p pointer) toInt64Ptr() **int64 {
+ return (**int64)(p.p)
+}
+func (p pointer) toInt64Slice() *[]int64 {
+ return (*[]int64)(p.p)
+}
+func (p pointer) toInt32() *int32 {
+ return (*int32)(p.p)
+}
+
+// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
+/*
+ func (p pointer) toInt32Ptr() **int32 {
+ return (**int32)(p.p)
+ }
+ func (p pointer) toInt32Slice() *[]int32 {
+ return (*[]int32)(p.p)
+ }
+*/
+func (p pointer) getInt32Ptr() *int32 {
+ return *(**int32)(p.p)
+}
+func (p pointer) setInt32Ptr(v int32) {
+ *(**int32)(p.p) = &v
+}
+
+// getInt32Slice loads a []int32 from p.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) getInt32Slice() []int32 {
+ return *(*[]int32)(p.p)
+}
+
+// setInt32Slice stores a []int32 to p.
+// The value set is aliased with the input slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) setInt32Slice(v []int32) {
+ *(*[]int32)(p.p) = v
+}
+
+// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
+func (p pointer) appendInt32Slice(v int32) {
+ s := (*[]int32)(p.p)
+ *s = append(*s, v)
+}
+
+func (p pointer) toUint64() *uint64 {
+ return (*uint64)(p.p)
+}
+func (p pointer) toUint64Ptr() **uint64 {
+ return (**uint64)(p.p)
+}
+func (p pointer) toUint64Slice() *[]uint64 {
+ return (*[]uint64)(p.p)
+}
+func (p pointer) toUint32() *uint32 {
+ return (*uint32)(p.p)
+}
+func (p pointer) toUint32Ptr() **uint32 {
+ return (**uint32)(p.p)
+}
+func (p pointer) toUint32Slice() *[]uint32 {
+ return (*[]uint32)(p.p)
+}
+func (p pointer) toBool() *bool {
+ return (*bool)(p.p)
+}
+func (p pointer) toBoolPtr() **bool {
+ return (**bool)(p.p)
+}
+func (p pointer) toBoolSlice() *[]bool {
+ return (*[]bool)(p.p)
+}
+func (p pointer) toFloat64() *float64 {
+ return (*float64)(p.p)
+}
+func (p pointer) toFloat64Ptr() **float64 {
+ return (**float64)(p.p)
+}
+func (p pointer) toFloat64Slice() *[]float64 {
+ return (*[]float64)(p.p)
+}
+func (p pointer) toFloat32() *float32 {
+ return (*float32)(p.p)
+}
+func (p pointer) toFloat32Ptr() **float32 {
+ return (**float32)(p.p)
+}
+func (p pointer) toFloat32Slice() *[]float32 {
+ return (*[]float32)(p.p)
+}
+func (p pointer) toString() *string {
+ return (*string)(p.p)
+}
+func (p pointer) toStringPtr() **string {
+ return (**string)(p.p)
+}
+func (p pointer) toStringSlice() *[]string {
+ return (*[]string)(p.p)
+}
+func (p pointer) toBytes() *[]byte {
+ return (*[]byte)(p.p)
+}
+func (p pointer) toBytesSlice() *[][]byte {
+ return (*[][]byte)(p.p)
+}
+func (p pointer) toExtensions() *XXX_InternalExtensions {
+ return (*XXX_InternalExtensions)(p.p)
+}
+func (p pointer) toOldExtensions() *map[int32]Extension {
+ return (*map[int32]Extension)(p.p)
+}
+
+// getPointerSlice loads []*T from p as a []pointer.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) getPointerSlice() []pointer {
+ // Super-tricky - p should point to a []*T where T is a
+ // message type. We load it as []pointer.
+ return *(*[]pointer)(p.p)
+}
+
+// setPointerSlice stores []pointer into p as a []*T.
+// The value set is aliased with the input slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) setPointerSlice(v []pointer) {
+ // Super-tricky - p should point to a []*T where T is a
+ // message type. We store it as []pointer.
+ *(*[]pointer)(p.p) = v
+}
+
+// getPointer loads the pointer at p and returns it.
+func (p pointer) getPointer() pointer {
+ return pointer{p: *(*unsafe.Pointer)(p.p)}
+}
+
+// setPointer stores the pointer q at p.
+func (p pointer) setPointer(q pointer) {
+ *(*unsafe.Pointer)(p.p) = q.p
+}
+
+// append q to the slice pointed to by p.
+func (p pointer) appendPointer(q pointer) {
+ s := (*[]unsafe.Pointer)(p.p)
+ *s = append(*s, q.p)
+}
+
+// getInterfacePointer returns a pointer that points to the
+// interface data of the interface pointed by p.
+func (p pointer) getInterfacePointer() pointer {
+ // Super-tricky - read pointer out of data word of interface value.
+ return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
+}
+
+// asPointerTo returns a reflect.Value that is a pointer to an
+// object of type t stored at p.
+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
+ return reflect.NewAt(t, p.p)
+}
+
+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
+ return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
+ return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
+ return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
+ return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
index dcdc220..a4b8c0c 100644
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -1,104 +1,162 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package proto
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
import (
"fmt"
+ "log"
"reflect"
+ "sort"
"strconv"
"strings"
"sync"
-
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoimpl"
)
-// StructProperties represents protocol buffer type information for a
-// generated protobuf message in the open-struct API.
-//
-// Deprecated: Do not use.
+const debug bool = false
+
+// Constants that identify the encoding of a value on the wire.
+const (
+ WireVarint = 0
+ WireFixed64 = 1
+ WireBytes = 2
+ WireStartGroup = 3
+ WireEndGroup = 4
+ WireFixed32 = 5
+)
+
+// tagMap is an optimization over map[int]int for typical protocol buffer
+// use-cases. Encoded protocol buffers are often in tag order with small tag
+// numbers.
+type tagMap struct {
+ fastTags []int
+ slowTags map[int]int
+}
+
+// tagMapFastLimit is the upper bound on the tag number that will be stored in
+// the tagMap slice rather than its map.
+const tagMapFastLimit = 1024
+
+func (p *tagMap) get(t int) (int, bool) {
+ if t > 0 && t < tagMapFastLimit {
+ if t >= len(p.fastTags) {
+ return 0, false
+ }
+ fi := p.fastTags[t]
+ return fi, fi >= 0
+ }
+ fi, ok := p.slowTags[t]
+ return fi, ok
+}
+
+func (p *tagMap) put(t int, fi int) {
+ if t > 0 && t < tagMapFastLimit {
+ for len(p.fastTags) < t+1 {
+ p.fastTags = append(p.fastTags, -1)
+ }
+ p.fastTags[t] = fi
+ return
+ }
+ if p.slowTags == nil {
+ p.slowTags = make(map[int]int)
+ }
+ p.slowTags[t] = fi
+}
+
+// StructProperties represents properties for all the fields of a struct.
+// decoderTags and decoderOrigNames should only be used by the decoder.
type StructProperties struct {
- // Prop are the properties for each field.
- //
- // Fields belonging to a oneof are stored in OneofTypes instead, with a
- // single Properties representing the parent oneof held here.
- //
- // The order of Prop matches the order of fields in the Go struct.
- // Struct fields that are not related to protobufs have a "XXX_" prefix
- // in the Properties.Name and must be ignored by the user.
- Prop []*Properties
+ Prop []*Properties // properties for each field
+ reqCount int // required count
+ decoderTags tagMap // map from proto tag to struct field number
+ decoderOrigNames map[string]int // map from original name to struct field number
+ order []int // list of struct field numbers in tag order
// OneofTypes contains information about the oneof fields in this message.
- // It is keyed by the protobuf field name.
+ // It is keyed by the original name of a field.
OneofTypes map[string]*OneofProperties
}
-// Properties represents the type information for a protobuf message field.
-//
-// Deprecated: Do not use.
-type Properties struct {
- // Name is a placeholder name with little meaningful semantic value.
- // If the name has an "XXX_" prefix, the entire Properties must be ignored.
- Name string
- // OrigName is the protobuf field name or oneof name.
- OrigName string
- // JSONName is the JSON name for the protobuf field.
- JSONName string
- // Enum is a placeholder name for enums.
- // For historical reasons, this is neither the Go name for the enum,
- // nor the protobuf name for the enum.
- Enum string // Deprecated: Do not use.
- // Weak contains the full name of the weakly referenced message.
- Weak string
- // Wire is a string representation of the wire type.
- Wire string
- // WireType is the protobuf wire type for the field.
- WireType int
- // Tag is the protobuf field number.
- Tag int
- // Required reports whether this is a required field.
- Required bool
- // Optional reports whether this is a optional field.
- Optional bool
- // Repeated reports whether this is a repeated field.
- Repeated bool
- // Packed reports whether this is a packed repeated field of scalars.
- Packed bool
- // Proto3 reports whether this field operates under the proto3 syntax.
- Proto3 bool
- // Oneof reports whether this field belongs within a oneof.
- Oneof bool
-
- // Default is the default value in string form.
- Default string
- // HasDefault reports whether the field has a default value.
- HasDefault bool
-
- // MapKeyProp is the properties for the key field for a map field.
- MapKeyProp *Properties
- // MapValProp is the properties for the value field for a map field.
- MapValProp *Properties
+// OneofProperties represents information about a specific field in a oneof.
+type OneofProperties struct {
+ Type reflect.Type // pointer to generated struct type for this oneof field
+ Field int // struct field number of the containing oneof in the message
+ Prop *Properties
}
-// OneofProperties represents the type information for a protobuf oneof.
-//
-// Deprecated: Do not use.
-type OneofProperties struct {
- // Type is a pointer to the generated wrapper type for the field value.
- // This is nil for messages that are not in the open-struct API.
- Type reflect.Type
- // Field is the index into StructProperties.Prop for the containing oneof.
- Field int
- // Prop is the properties for the field.
- Prop *Properties
+// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
+// See encode.go, (*Buffer).enc_struct.
+
+func (sp *StructProperties) Len() int { return len(sp.order) }
+func (sp *StructProperties) Less(i, j int) bool {
+ return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
+}
+func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
+
+// Properties represents the protocol-specific behavior of a single struct field.
+type Properties struct {
+ Name string // name of the field, for error messages
+ OrigName string // original name before protocol compiler (always set)
+ JSONName string // name to use for JSON; determined by protoc
+ Wire string
+ WireType int
+ Tag int
+ Required bool
+ Optional bool
+ Repeated bool
+ Packed bool // relevant for repeated primitives only
+ Enum string // set for enum types only
+ proto3 bool // whether this is known to be a proto3 field
+ oneof bool // whether this is a oneof field
+
+ Default string // default value
+ HasDefault bool // whether an explicit default was provided
+
+ stype reflect.Type // set for struct types only
+ sprop *StructProperties // set for struct types only
+
+ mtype reflect.Type // set for map types only
+ MapKeyProp *Properties // set for map types only
+ MapValProp *Properties // set for map types only
}
// String formats the properties in the protobuf struct field tag style.
func (p *Properties) String() string {
s := p.Wire
- s += "," + strconv.Itoa(p.Tag)
+ s += ","
+ s += strconv.Itoa(p.Tag)
if p.Required {
s += ",req"
}
@@ -112,21 +170,18 @@
s += ",packed"
}
s += ",name=" + p.OrigName
- if p.JSONName != "" {
+ if p.JSONName != p.OrigName {
s += ",json=" + p.JSONName
}
+ if p.proto3 {
+ s += ",proto3"
+ }
+ if p.oneof {
+ s += ",oneof"
+ }
if len(p.Enum) > 0 {
s += ",enum=" + p.Enum
}
- if len(p.Weak) > 0 {
- s += ",weak=" + p.Weak
- }
- if p.Proto3 {
- s += ",proto3"
- }
- if p.Oneof {
- s += ",oneof"
- }
if p.HasDefault {
s += ",def=" + p.Default
}
@@ -134,173 +189,356 @@
}
// Parse populates p by parsing a string in the protobuf struct field tag style.
-func (p *Properties) Parse(tag string) {
- // For example: "bytes,49,opt,name=foo,def=hello!"
- for len(tag) > 0 {
- i := strings.IndexByte(tag, ',')
- if i < 0 {
- i = len(tag)
- }
- switch s := tag[:i]; {
- case strings.HasPrefix(s, "name="):
- p.OrigName = s[len("name="):]
- case strings.HasPrefix(s, "json="):
- p.JSONName = s[len("json="):]
- case strings.HasPrefix(s, "enum="):
- p.Enum = s[len("enum="):]
- case strings.HasPrefix(s, "weak="):
- p.Weak = s[len("weak="):]
- case strings.Trim(s, "0123456789") == "":
- n, _ := strconv.ParseUint(s, 10, 32)
- p.Tag = int(n)
- case s == "opt":
- p.Optional = true
- case s == "req":
+func (p *Properties) Parse(s string) {
+ // "bytes,49,opt,name=foo,def=hello!"
+ fields := strings.Split(s, ",") // breaks def=, but handled below.
+ if len(fields) < 2 {
+ log.Printf("proto: tag has too few fields: %q", s)
+ return
+ }
+
+ p.Wire = fields[0]
+ switch p.Wire {
+ case "varint":
+ p.WireType = WireVarint
+ case "fixed32":
+ p.WireType = WireFixed32
+ case "fixed64":
+ p.WireType = WireFixed64
+ case "zigzag32":
+ p.WireType = WireVarint
+ case "zigzag64":
+ p.WireType = WireVarint
+ case "bytes", "group":
+ p.WireType = WireBytes
+ // no numeric converter for non-numeric types
+ default:
+ log.Printf("proto: tag has unknown wire type: %q", s)
+ return
+ }
+
+ var err error
+ p.Tag, err = strconv.Atoi(fields[1])
+ if err != nil {
+ return
+ }
+
+outer:
+ for i := 2; i < len(fields); i++ {
+ f := fields[i]
+ switch {
+ case f == "req":
p.Required = true
- case s == "rep":
+ case f == "opt":
+ p.Optional = true
+ case f == "rep":
p.Repeated = true
- case s == "varint" || s == "zigzag32" || s == "zigzag64":
- p.Wire = s
- p.WireType = WireVarint
- case s == "fixed32":
- p.Wire = s
- p.WireType = WireFixed32
- case s == "fixed64":
- p.Wire = s
- p.WireType = WireFixed64
- case s == "bytes":
- p.Wire = s
- p.WireType = WireBytes
- case s == "group":
- p.Wire = s
- p.WireType = WireStartGroup
- case s == "packed":
+ case f == "packed":
p.Packed = true
- case s == "proto3":
- p.Proto3 = true
- case s == "oneof":
- p.Oneof = true
- case strings.HasPrefix(s, "def="):
- // The default tag is special in that everything afterwards is the
- // default regardless of the presence of commas.
+ case strings.HasPrefix(f, "name="):
+ p.OrigName = f[5:]
+ case strings.HasPrefix(f, "json="):
+ p.JSONName = f[5:]
+ case strings.HasPrefix(f, "enum="):
+ p.Enum = f[5:]
+ case f == "proto3":
+ p.proto3 = true
+ case f == "oneof":
+ p.oneof = true
+ case strings.HasPrefix(f, "def="):
p.HasDefault = true
- p.Default, i = tag[len("def="):], len(tag)
+ p.Default = f[4:] // rest of string
+ if i+1 < len(fields) {
+ // Commas aren't escaped, and def is always last.
+ p.Default += "," + strings.Join(fields[i+1:], ",")
+ break outer
+ }
}
- tag = strings.TrimPrefix(tag[i:], ",")
}
}
+var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
+
+// setFieldProps initializes the field properties for submessages and maps.
+func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
+ switch t1 := typ; t1.Kind() {
+ case reflect.Ptr:
+ if t1.Elem().Kind() == reflect.Struct {
+ p.stype = t1.Elem()
+ }
+
+ case reflect.Slice:
+ if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {
+ p.stype = t2.Elem()
+ }
+
+ case reflect.Map:
+ p.mtype = t1
+ p.MapKeyProp = &Properties{}
+ p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
+ p.MapValProp = &Properties{}
+ vtype := p.mtype.Elem()
+ if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
+ // The value type is not a message (*T) or bytes ([]byte),
+ // so we need encoders for the pointer to this type.
+ vtype = reflect.PtrTo(vtype)
+ }
+ p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
+ }
+
+ if p.stype != nil {
+ if lockGetProp {
+ p.sprop = GetProperties(p.stype)
+ } else {
+ p.sprop = getPropertiesLocked(p.stype)
+ }
+ }
+}
+
+var (
+ marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
+)
+
// Init populates the properties from a protocol buffer struct tag.
-//
-// Deprecated: Do not use.
func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
+ p.init(typ, name, tag, f, true)
+}
+
+func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
+ // "bytes,49,opt,def=hello!"
p.Name = name
p.OrigName = name
if tag == "" {
return
}
p.Parse(tag)
-
- if typ != nil && typ.Kind() == reflect.Map {
- p.MapKeyProp = new(Properties)
- p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil)
- p.MapValProp = new(Properties)
- p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil)
- }
+ p.setFieldProps(typ, f, lockGetProp)
}
-var propertiesCache sync.Map // map[reflect.Type]*StructProperties
+var (
+ propertiesMu sync.RWMutex
+ propertiesMap = make(map[reflect.Type]*StructProperties)
+)
-// GetProperties returns the list of properties for the type represented by t,
-// which must be a generated protocol buffer message in the open-struct API,
-// where protobuf message fields are represented by exported Go struct fields.
-//
-// Deprecated: Use protobuf reflection instead.
+// GetProperties returns the list of properties for the type represented by t.
+// t must represent a generated struct type of a protocol message.
func GetProperties(t reflect.Type) *StructProperties {
- if p, ok := propertiesCache.Load(t); ok {
- return p.(*StructProperties)
+ if t.Kind() != reflect.Struct {
+ panic("proto: type must have kind struct")
}
- p, _ := propertiesCache.LoadOrStore(t, newProperties(t))
- return p.(*StructProperties)
+
+ // Most calls to GetProperties in a long-running program will be
+ // retrieving details for types we have seen before.
+ propertiesMu.RLock()
+ sprop, ok := propertiesMap[t]
+ propertiesMu.RUnlock()
+ if ok {
+ return sprop
+ }
+
+ propertiesMu.Lock()
+ sprop = getPropertiesLocked(t)
+ propertiesMu.Unlock()
+ return sprop
}
-func newProperties(t reflect.Type) *StructProperties {
- if t.Kind() != reflect.Struct {
- panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
+type (
+ oneofFuncsIface interface {
+ XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+ }
+ oneofWrappersIface interface {
+ XXX_OneofWrappers() []interface{}
+ }
+)
+
+// getPropertiesLocked requires that propertiesMu is held.
+func getPropertiesLocked(t reflect.Type) *StructProperties {
+ if prop, ok := propertiesMap[t]; ok {
+ return prop
}
- var hasOneof bool
prop := new(StructProperties)
+ // in case of recursive protos, fill this in now.
+ propertiesMap[t] = prop
- // Construct a list of properties for each field in the struct.
+ // build properties
+ prop.Prop = make([]*Properties, t.NumField())
+ prop.order = make([]int, t.NumField())
+
for i := 0; i < t.NumField(); i++ {
- p := new(Properties)
f := t.Field(i)
- tagField := f.Tag.Get("protobuf")
- p.Init(f.Type, f.Name, tagField, &f)
+ p := new(Properties)
+ name := f.Name
+ p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
- tagOneof := f.Tag.Get("protobuf_oneof")
- if tagOneof != "" {
- hasOneof = true
- p.OrigName = tagOneof
+ oneof := f.Tag.Get("protobuf_oneof") // special case
+ if oneof != "" {
+ // Oneof fields don't use the traditional protobuf tag.
+ p.OrigName = oneof
}
-
- // Rename unrelated struct fields with the "XXX_" prefix since so much
- // user code simply checks for this to exclude special fields.
- if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") {
- p.Name = "XXX_" + p.Name
- p.OrigName = "XXX_" + p.OrigName
- } else if p.Weak != "" {
- p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field
+ prop.Prop[i] = p
+ prop.order[i] = i
+ if debug {
+ print(i, " ", f.Name, " ", t.String(), " ")
+ if p.Tag > 0 {
+ print(p.String())
+ }
+ print("\n")
}
-
- prop.Prop = append(prop.Prop, p)
}
- // Construct a mapping of oneof field names to properties.
- if hasOneof {
- var oneofWrappers []interface{}
- if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
- oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
- }
- if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
- oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
- }
- if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {
- if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok {
- oneofWrappers = m.ProtoMessageInfo().OneofWrappers
- }
- }
+ // Re-order prop.order.
+ sort.Sort(prop)
+ var oots []interface{}
+ switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+ case oneofFuncsIface:
+ _, _, _, oots = m.XXX_OneofFuncs()
+ case oneofWrappersIface:
+ oots = m.XXX_OneofWrappers()
+ }
+ if len(oots) > 0 {
+ // Interpret oneof metadata.
prop.OneofTypes = make(map[string]*OneofProperties)
- for _, wrapper := range oneofWrappers {
- p := &OneofProperties{
- Type: reflect.ValueOf(wrapper).Type(), // *T
+ for _, oot := range oots {
+ oop := &OneofProperties{
+ Type: reflect.ValueOf(oot).Type(), // *T
Prop: new(Properties),
}
- f := p.Type.Elem().Field(0)
- p.Prop.Name = f.Name
- p.Prop.Parse(f.Tag.Get("protobuf"))
-
- // Determine the struct field that contains this oneof.
- // Each wrapper is assignable to exactly one parent field.
- var foundOneof bool
- for i := 0; i < t.NumField() && !foundOneof; i++ {
- if p.Type.AssignableTo(t.Field(i).Type) {
- p.Field = i
- foundOneof = true
+ sft := oop.Type.Elem().Field(0)
+ oop.Prop.Name = sft.Name
+ oop.Prop.Parse(sft.Tag.Get("protobuf"))
+ // There will be exactly one interface field that
+ // this new value is assignable to.
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ if f.Type.Kind() != reflect.Interface {
+ continue
}
+ if !oop.Type.AssignableTo(f.Type) {
+ continue
+ }
+ oop.Field = i
+ break
}
- if !foundOneof {
- panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
- }
- prop.OneofTypes[p.Prop.OrigName] = p
+ prop.OneofTypes[oop.Prop.OrigName] = oop
}
}
+ // build required counts
+ // build tags
+ reqCount := 0
+ prop.decoderOrigNames = make(map[string]int)
+ for i, p := range prop.Prop {
+ if strings.HasPrefix(p.Name, "XXX_") {
+ // Internal fields should not appear in tags/origNames maps.
+ // They are handled specially when encoding and decoding.
+ continue
+ }
+ if p.Required {
+ reqCount++
+ }
+ prop.decoderTags.put(p.Tag, i)
+ prop.decoderOrigNames[p.OrigName] = i
+ }
+ prop.reqCount = reqCount
+
return prop
}
-func (sp *StructProperties) Len() int { return len(sp.Prop) }
-func (sp *StructProperties) Less(i, j int) bool { return false }
-func (sp *StructProperties) Swap(i, j int) { return }
+// A global registry of enum types.
+// The generated code will register the generated maps by calling RegisterEnum.
+
+var enumValueMaps = make(map[string]map[string]int32)
+
+// RegisterEnum is called from the generated code to install the enum descriptor
+// maps into the global table to aid parsing text format protocol buffers.
+func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
+ if _, ok := enumValueMaps[typeName]; ok {
+ panic("proto: duplicate enum registered: " + typeName)
+ }
+ enumValueMaps[typeName] = valueMap
+}
+
+// EnumValueMap returns the mapping from names to integers of the
+// enum type enumType, or a nil if not found.
+func EnumValueMap(enumType string) map[string]int32 {
+ return enumValueMaps[enumType]
+}
+
+// A registry of all linked message types.
+// The string is a fully-qualified proto name ("pkg.Message").
+var (
+ protoTypedNils = make(map[string]Message) // a map from proto names to typed nil pointers
+ protoMapTypes = make(map[string]reflect.Type) // a map from proto names to map types
+ revProtoTypes = make(map[reflect.Type]string)
+)
+
+// RegisterType is called from generated code and maps from the fully qualified
+// proto name to the type (pointer to struct) of the protocol buffer.
+func RegisterType(x Message, name string) {
+ if _, ok := protoTypedNils[name]; ok {
+ // TODO: Some day, make this a panic.
+ log.Printf("proto: duplicate proto type registered: %s", name)
+ return
+ }
+ t := reflect.TypeOf(x)
+ if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
+ // Generated code always calls RegisterType with nil x.
+ // This check is just for extra safety.
+ protoTypedNils[name] = x
+ } else {
+ protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
+ }
+ revProtoTypes[t] = name
+}
+
+// RegisterMapType is called from generated code and maps from the fully qualified
+// proto name to the native map type of the proto map definition.
+func RegisterMapType(x interface{}, name string) {
+ if reflect.TypeOf(x).Kind() != reflect.Map {
+ panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
+ }
+ if _, ok := protoMapTypes[name]; ok {
+ log.Printf("proto: duplicate proto type registered: %s", name)
+ return
+ }
+ t := reflect.TypeOf(x)
+ protoMapTypes[name] = t
+ revProtoTypes[t] = name
+}
+
+// MessageName returns the fully-qualified proto name for the given message type.
+func MessageName(x Message) string {
+ type xname interface {
+ XXX_MessageName() string
+ }
+ if m, ok := x.(xname); ok {
+ return m.XXX_MessageName()
+ }
+ return revProtoTypes[reflect.TypeOf(x)]
+}
+
+// MessageType returns the message type (pointer to struct) for a named message.
+// The type is not guaranteed to implement proto.Message if the name refers to a
+// map entry.
+func MessageType(name string) reflect.Type {
+ if t, ok := protoTypedNils[name]; ok {
+ return reflect.TypeOf(t)
+ }
+ return protoMapTypes[name]
+}
+
+// A registry of all linked proto files.
+var (
+ protoFiles = make(map[string][]byte) // file name => fileDescriptor
+)
+
+// RegisterFile is called from generated code and maps from the
+// full file name of a .proto file to its compressed FileDescriptorProto.
+func RegisterFile(filename string, fileDescriptor []byte) {
+ protoFiles[filename] = fileDescriptor
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
+func FileDescriptor(filename string) []byte { return protoFiles[filename] }
diff --git a/vendor/github.com/golang/protobuf/proto/proto.go b/vendor/github.com/golang/protobuf/proto/proto.go
deleted file mode 100644
index 5aee89c..0000000
--- a/vendor/github.com/golang/protobuf/proto/proto.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package proto provides functionality for handling protocol buffer messages.
-// In particular, it provides marshaling and unmarshaling between a protobuf
-// message and the binary wire format.
-//
-// See https://developers.google.com/protocol-buffers/docs/gotutorial for
-// more information.
-//
-// Deprecated: Use the "google.golang.org/protobuf/proto" package instead.
-package proto
-
-import (
- protoV2 "google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
- "google.golang.org/protobuf/runtime/protoimpl"
-)
-
-const (
- ProtoPackageIsVersion1 = true
- ProtoPackageIsVersion2 = true
- ProtoPackageIsVersion3 = true
- ProtoPackageIsVersion4 = true
-)
-
-// GeneratedEnum is any enum type generated by protoc-gen-go
-// which is a named int32 kind.
-// This type exists for documentation purposes.
-type GeneratedEnum interface{}
-
-// GeneratedMessage is any message type generated by protoc-gen-go
-// which is a pointer to a named struct kind.
-// This type exists for documentation purposes.
-type GeneratedMessage interface{}
-
-// Message is a protocol buffer message.
-//
-// This is the v1 version of the message interface and is marginally better
-// than an empty interface as it lacks any method to programatically interact
-// with the contents of the message.
-//
-// A v2 message is declared in "google.golang.org/protobuf/proto".Message and
-// exposes protobuf reflection as a first-class feature of the interface.
-//
-// To convert a v1 message to a v2 message, use the MessageV2 function.
-// To convert a v2 message to a v1 message, use the MessageV1 function.
-type Message = protoiface.MessageV1
-
-// MessageV1 converts either a v1 or v2 message to a v1 message.
-// It returns nil if m is nil.
-func MessageV1(m GeneratedMessage) protoiface.MessageV1 {
- return protoimpl.X.ProtoMessageV1Of(m)
-}
-
-// MessageV2 converts either a v1 or v2 message to a v2 message.
-// It returns nil if m is nil.
-func MessageV2(m GeneratedMessage) protoV2.Message {
- return protoimpl.X.ProtoMessageV2Of(m)
-}
-
-// MessageReflect returns a reflective view for a message.
-// It returns nil if m is nil.
-func MessageReflect(m Message) protoreflect.Message {
- return protoimpl.X.MessageOf(m)
-}
-
-// Marshaler is implemented by messages that can marshal themselves.
-// This interface is used by the following functions: Size, Marshal,
-// Buffer.Marshal, and Buffer.EncodeMessage.
-//
-// Deprecated: Do not implement.
-type Marshaler interface {
- // Marshal formats the encoded bytes of the message.
- // It should be deterministic and emit valid protobuf wire data.
- // The caller takes ownership of the returned buffer.
- Marshal() ([]byte, error)
-}
-
-// Unmarshaler is implemented by messages that can unmarshal themselves.
-// This interface is used by the following functions: Unmarshal, UnmarshalMerge,
-// Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup.
-//
-// Deprecated: Do not implement.
-type Unmarshaler interface {
- // Unmarshal parses the encoded bytes of the protobuf wire input.
- // The provided buffer is only valid for during method call.
- // It should not reset the receiver message.
- Unmarshal([]byte) error
-}
-
-// Merger is implemented by messages that can merge themselves.
-// This interface is used by the following functions: Clone and Merge.
-//
-// Deprecated: Do not implement.
-type Merger interface {
- // Merge merges the contents of src into the receiver message.
- // It clones all data structures in src such that it aliases no mutable
- // memory referenced by src.
- Merge(src Message)
-}
-
-// RequiredNotSetError is an error type returned when
-// marshaling or unmarshaling a message with missing required fields.
-type RequiredNotSetError struct {
- err error
-}
-
-func (e *RequiredNotSetError) Error() string {
- if e.err != nil {
- return e.err.Error()
- }
- return "proto: required field not set"
-}
-func (e *RequiredNotSetError) RequiredNotSet() bool {
- return true
-}
-
-func checkRequiredNotSet(m protoV2.Message) error {
- if err := protoV2.CheckInitialized(m); err != nil {
- return &RequiredNotSetError{err: err}
- }
- return nil
-}
-
-// Clone returns a deep copy of src.
-func Clone(src Message) Message {
- return MessageV1(protoV2.Clone(MessageV2(src)))
-}
-
-// Merge merges src into dst, which must be messages of the same type.
-//
-// Populated scalar fields in src are copied to dst, while populated
-// singular messages in src are merged into dst by recursively calling Merge.
-// The elements of every list field in src is appended to the corresponded
-// list fields in dst. The entries of every map field in src is copied into
-// the corresponding map field in dst, possibly replacing existing entries.
-// The unknown fields of src are appended to the unknown fields of dst.
-func Merge(dst, src Message) {
- protoV2.Merge(MessageV2(dst), MessageV2(src))
-}
-
-// Equal reports whether two messages are equal.
-// If two messages marshal to the same bytes under deterministic serialization,
-// then Equal is guaranteed to report true.
-//
-// Two messages are equal if they are the same protobuf message type,
-// have the same set of populated known and extension field values,
-// and the same set of unknown fields values.
-//
-// Scalar values are compared with the equivalent of the == operator in Go,
-// except bytes values which are compared using bytes.Equal and
-// floating point values which specially treat NaNs as equal.
-// Message values are compared by recursively calling Equal.
-// Lists are equal if each element value is also equal.
-// Maps are equal if they have the same set of keys, where the pair of values
-// for each key is also equal.
-func Equal(x, y Message) bool {
- return protoV2.Equal(MessageV2(x), MessageV2(y))
-}
-
-func isMessageSet(md protoreflect.MessageDescriptor) bool {
- ms, ok := md.(interface{ IsMessageSet() bool })
- return ok && ms.IsMessageSet()
-}
diff --git a/vendor/github.com/golang/protobuf/proto/registry.go b/vendor/github.com/golang/protobuf/proto/registry.go
deleted file mode 100644
index 1e7ff64..0000000
--- a/vendor/github.com/golang/protobuf/proto/registry.go
+++ /dev/null
@@ -1,323 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "bytes"
- "compress/gzip"
- "fmt"
- "io/ioutil"
- "reflect"
- "strings"
- "sync"
-
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
- "google.golang.org/protobuf/runtime/protoimpl"
-)
-
-// filePath is the path to the proto source file.
-type filePath = string // e.g., "google/protobuf/descriptor.proto"
-
-// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.
-type fileDescGZIP = []byte
-
-var fileCache sync.Map // map[filePath]fileDescGZIP
-
-// RegisterFile is called from generated code to register the compressed
-// FileDescriptorProto with the file path for a proto source file.
-//
-// Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead.
-func RegisterFile(s filePath, d fileDescGZIP) {
- // Decompress the descriptor.
- zr, err := gzip.NewReader(bytes.NewReader(d))
- if err != nil {
- panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
- }
- b, err := ioutil.ReadAll(zr)
- if err != nil {
- panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
- }
-
- // Construct a protoreflect.FileDescriptor from the raw descriptor.
- // Note that DescBuilder.Build automatically registers the constructed
- // file descriptor with the v2 registry.
- protoimpl.DescBuilder{RawDescriptor: b}.Build()
-
- // Locally cache the raw descriptor form for the file.
- fileCache.Store(s, d)
-}
-
-// FileDescriptor returns the compressed FileDescriptorProto given the file path
-// for a proto source file. It returns nil if not found.
-//
-// Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead.
-func FileDescriptor(s filePath) fileDescGZIP {
- if v, ok := fileCache.Load(s); ok {
- return v.(fileDescGZIP)
- }
-
- // Find the descriptor in the v2 registry.
- var b []byte
- if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil {
- if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok {
- b = fd.ProtoLegacyRawDesc()
- } else {
- // TODO: Use protodesc.ToFileDescriptorProto to construct
- // a descriptorpb.FileDescriptorProto and marshal it.
- // However, doing so causes the proto package to have a dependency
- // on descriptorpb, leading to cyclic dependency issues.
- }
- }
-
- // Locally cache the raw descriptor form for the file.
- if len(b) > 0 {
- v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b))
- return v.(fileDescGZIP)
- }
- return nil
-}
-
-// enumName is the name of an enum. For historical reasons, the enum name is
-// neither the full Go name nor the full protobuf name of the enum.
-// The name is the dot-separated combination of just the proto package that the
-// enum is declared within followed by the Go type name of the generated enum.
-type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"
-
-// enumsByName maps enum values by name to their numeric counterpart.
-type enumsByName = map[string]int32
-
-// enumsByNumber maps enum values by number to their name counterpart.
-type enumsByNumber = map[int32]string
-
-var enumCache sync.Map // map[enumName]enumsByName
-var numFilesCache sync.Map // map[protoreflect.FullName]int
-
-// RegisterEnum is called from the generated code to register the mapping of
-// enum value names to enum numbers for the enum identified by s.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead.
-func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) {
- if _, ok := enumCache.Load(s); ok {
- panic("proto: duplicate enum registered: " + s)
- }
- enumCache.Store(s, m)
-
- // This does not forward registration to the v2 registry since this API
- // lacks sufficient information to construct a complete v2 enum descriptor.
-}
-
-// EnumValueMap returns the mapping from enum value names to enum numbers for
-// the enum of the given name. It returns nil if not found.
-//
-// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.
-func EnumValueMap(s enumName) enumsByName {
- if v, ok := enumCache.Load(s); ok {
- return v.(enumsByName)
- }
-
- // Check whether the cache is stale. If the number of files in the current
- // package differs, then it means that some enums may have been recently
- // registered upstream that we do not know about.
- var protoPkg protoreflect.FullName
- if i := strings.LastIndexByte(s, '.'); i >= 0 {
- protoPkg = protoreflect.FullName(s[:i])
- }
- v, _ := numFilesCache.Load(protoPkg)
- numFiles, _ := v.(int)
- if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles {
- return nil // cache is up-to-date; was not found earlier
- }
-
- // Update the enum cache for all enums declared in the given proto package.
- numFiles = 0
- protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool {
- walkEnums(fd, func(ed protoreflect.EnumDescriptor) {
- name := protoimpl.X.LegacyEnumName(ed)
- if _, ok := enumCache.Load(name); !ok {
- m := make(enumsByName)
- evs := ed.Values()
- for i := evs.Len() - 1; i >= 0; i-- {
- ev := evs.Get(i)
- m[string(ev.Name())] = int32(ev.Number())
- }
- enumCache.LoadOrStore(name, m)
- }
- })
- numFiles++
- return true
- })
- numFilesCache.Store(protoPkg, numFiles)
-
- // Check cache again for enum map.
- if v, ok := enumCache.Load(s); ok {
- return v.(enumsByName)
- }
- return nil
-}
-
-// walkEnums recursively walks all enums declared in d.
-func walkEnums(d interface {
- Enums() protoreflect.EnumDescriptors
- Messages() protoreflect.MessageDescriptors
-}, f func(protoreflect.EnumDescriptor)) {
- eds := d.Enums()
- for i := eds.Len() - 1; i >= 0; i-- {
- f(eds.Get(i))
- }
- mds := d.Messages()
- for i := mds.Len() - 1; i >= 0; i-- {
- walkEnums(mds.Get(i), f)
- }
-}
-
-// messageName is the full name of protobuf message.
-type messageName = string
-
-var messageTypeCache sync.Map // map[messageName]reflect.Type
-
-// RegisterType is called from generated code to register the message Go type
-// for a message of the given name.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead.
-func RegisterType(m Message, s messageName) {
- mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s))
- if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil {
- panic(err)
- }
- messageTypeCache.Store(s, reflect.TypeOf(m))
-}
-
-// RegisterMapType is called from generated code to register the Go map type
-// for a protobuf message representing a map entry.
-//
-// Deprecated: Do not use.
-func RegisterMapType(m interface{}, s messageName) {
- t := reflect.TypeOf(m)
- if t.Kind() != reflect.Map {
- panic(fmt.Sprintf("invalid map kind: %v", t))
- }
- if _, ok := messageTypeCache.Load(s); ok {
- panic(fmt.Errorf("proto: duplicate proto message registered: %s", s))
- }
- messageTypeCache.Store(s, t)
-}
-
-// MessageType returns the message type for a named message.
-// It returns nil if not found.
-//
-// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.
-func MessageType(s messageName) reflect.Type {
- if v, ok := messageTypeCache.Load(s); ok {
- return v.(reflect.Type)
- }
-
- // Derive the message type from the v2 registry.
- var t reflect.Type
- if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil {
- t = messageGoType(mt)
- }
-
- // If we could not get a concrete type, it is possible that it is a
- // pseudo-message for a map entry.
- if t == nil {
- d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s))
- if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() {
- kt := goTypeForField(md.Fields().ByNumber(1))
- vt := goTypeForField(md.Fields().ByNumber(2))
- t = reflect.MapOf(kt, vt)
- }
- }
-
- // Locally cache the message type for the given name.
- if t != nil {
- v, _ := messageTypeCache.LoadOrStore(s, t)
- return v.(reflect.Type)
- }
- return nil
-}
-
-func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
- switch k := fd.Kind(); k {
- case protoreflect.EnumKind:
- if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil {
- return enumGoType(et)
- }
- return reflect.TypeOf(protoreflect.EnumNumber(0))
- case protoreflect.MessageKind, protoreflect.GroupKind:
- if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil {
- return messageGoType(mt)
- }
- return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
- default:
- return reflect.TypeOf(fd.Default().Interface())
- }
-}
-
-func enumGoType(et protoreflect.EnumType) reflect.Type {
- return reflect.TypeOf(et.New(0))
-}
-
-func messageGoType(mt protoreflect.MessageType) reflect.Type {
- return reflect.TypeOf(MessageV1(mt.Zero().Interface()))
-}
-
-// MessageName returns the full protobuf name for the given message type.
-//
-// Deprecated: Use protoreflect.MessageDescriptor.FullName instead.
-func MessageName(m Message) messageName {
- if m == nil {
- return ""
- }
- if m, ok := m.(interface{ XXX_MessageName() messageName }); ok {
- return m.XXX_MessageName()
- }
- return messageName(protoimpl.X.MessageDescriptorOf(m).FullName())
-}
-
-// RegisterExtension is called from the generated code to register
-// the extension descriptor.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead.
-func RegisterExtension(d *ExtensionDesc) {
- if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil {
- panic(err)
- }
-}
-
-type extensionsByNumber = map[int32]*ExtensionDesc
-
-var extensionCache sync.Map // map[messageName]extensionsByNumber
-
-// RegisteredExtensions returns a map of the registered extensions for the
-// provided protobuf message, indexed by the extension field number.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.
-func RegisteredExtensions(m Message) extensionsByNumber {
- // Check whether the cache is stale. If the number of extensions for
- // the given message differs, then it means that some extensions were
- // recently registered upstream that we do not know about.
- s := MessageName(m)
- v, _ := extensionCache.Load(s)
- xs, _ := v.(extensionsByNumber)
- if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) {
- return xs // cache is up-to-date
- }
-
- // Cache is stale, re-compute the extensions map.
- xs = make(extensionsByNumber)
- protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool {
- if xd, ok := xt.(*ExtensionDesc); ok {
- xs[int32(xt.TypeDescriptor().Number())] = xd
- } else {
- // TODO: This implies that the protoreflect.ExtensionType is a
- // custom type not generated by protoc-gen-go. We could try and
- // convert the type to an ExtensionDesc.
- }
- return true
- })
- extensionCache.Store(s, xs)
- return xs
-}
diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.go
new file mode 100644
index 0000000..5cb11fa
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go
@@ -0,0 +1,2776 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+import (
+ "errors"
+ "fmt"
+ "math"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "unicode/utf8"
+)
+
+// a sizer takes a pointer to a field and the size of its tag, computes the size of
+// the encoded data.
+type sizer func(pointer, int) int
+
+// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),
+// marshals the field to the end of the slice, returns the slice and error (if any).
+type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
+
+// marshalInfo is the information used for marshaling a message.
+type marshalInfo struct {
+ typ reflect.Type
+ fields []*marshalFieldInfo
+ unrecognized field // offset of XXX_unrecognized
+ extensions field // offset of XXX_InternalExtensions
+ v1extensions field // offset of XXX_extensions
+ sizecache field // offset of XXX_sizecache
+ initialized int32 // 0 -- only typ is set, 1 -- fully initialized
+ messageset bool // uses message set wire format
+ hasmarshaler bool // has custom marshaler
+ sync.RWMutex // protect extElems map, also for initialization
+ extElems map[int32]*marshalElemInfo // info of extension elements
+}
+
+// marshalFieldInfo is the information used for marshaling a field of a message.
+type marshalFieldInfo struct {
+ field field
+ wiretag uint64 // tag in wire format
+ tagsize int // size of tag in wire format
+ sizer sizer
+ marshaler marshaler
+ isPointer bool
+ required bool // field is required
+ name string // name of the field, for error reporting
+ oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
+}
+
+// marshalElemInfo is the information used for marshaling an extension or oneof element.
+type marshalElemInfo struct {
+ wiretag uint64 // tag in wire format
+ tagsize int // size of tag in wire format
+ sizer sizer
+ marshaler marshaler
+ isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
+ deref bool // dereference the pointer before operating on it; implies isptr
+}
+
+var (
+ marshalInfoMap = map[reflect.Type]*marshalInfo{}
+ marshalInfoLock sync.Mutex
+)
+
+// getMarshalInfo returns the information to marshal a given type of message.
+// The info it returns may not necessarily initialized.
+// t is the type of the message (NOT the pointer to it).
+func getMarshalInfo(t reflect.Type) *marshalInfo {
+ marshalInfoLock.Lock()
+ u, ok := marshalInfoMap[t]
+ if !ok {
+ u = &marshalInfo{typ: t}
+ marshalInfoMap[t] = u
+ }
+ marshalInfoLock.Unlock()
+ return u
+}
+
+// Size is the entry point from generated code,
+// and should be ONLY called by generated code.
+// It computes the size of encoded data of msg.
+// a is a pointer to a place to store cached marshal info.
+func (a *InternalMessageInfo) Size(msg Message) int {
+ u := getMessageMarshalInfo(msg, a)
+ ptr := toPointer(&msg)
+ if ptr.isNil() {
+ // We get here if msg is a typed nil ((*SomeMessage)(nil)),
+ // so it satisfies the interface, and msg == nil wouldn't
+ // catch it. We don't want crash in this case.
+ return 0
+ }
+ return u.size(ptr)
+}
+
+// Marshal is the entry point from generated code,
+// and should be ONLY called by generated code.
+// It marshals msg to the end of b.
+// a is a pointer to a place to store cached marshal info.
+func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
+ u := getMessageMarshalInfo(msg, a)
+ ptr := toPointer(&msg)
+ if ptr.isNil() {
+ // We get here if msg is a typed nil ((*SomeMessage)(nil)),
+ // so it satisfies the interface, and msg == nil wouldn't
+ // catch it. We don't want crash in this case.
+ return b, ErrNil
+ }
+ return u.marshal(b, ptr, deterministic)
+}
+
+func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
+ // u := a.marshal, but atomically.
+ // We use an atomic here to ensure memory consistency.
+ u := atomicLoadMarshalInfo(&a.marshal)
+ if u == nil {
+ // Get marshal information from type of message.
+ t := reflect.ValueOf(msg).Type()
+ if t.Kind() != reflect.Ptr {
+ panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
+ }
+ u = getMarshalInfo(t.Elem())
+ // Store it in the cache for later users.
+ // a.marshal = u, but atomically.
+ atomicStoreMarshalInfo(&a.marshal, u)
+ }
+ return u
+}
+
+// size is the main function to compute the size of the encoded data of a message.
+// ptr is the pointer to the message.
+func (u *marshalInfo) size(ptr pointer) int {
+ if atomic.LoadInt32(&u.initialized) == 0 {
+ u.computeMarshalInfo()
+ }
+
+ // If the message can marshal itself, let it do it, for compatibility.
+ // NOTE: This is not efficient.
+ if u.hasmarshaler {
+ m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
+ b, _ := m.Marshal()
+ return len(b)
+ }
+
+ n := 0
+ for _, f := range u.fields {
+ if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+ // nil pointer always marshals to nothing
+ continue
+ }
+ n += f.sizer(ptr.offset(f.field), f.tagsize)
+ }
+ if u.extensions.IsValid() {
+ e := ptr.offset(u.extensions).toExtensions()
+ if u.messageset {
+ n += u.sizeMessageSet(e)
+ } else {
+ n += u.sizeExtensions(e)
+ }
+ }
+ if u.v1extensions.IsValid() {
+ m := *ptr.offset(u.v1extensions).toOldExtensions()
+ n += u.sizeV1Extensions(m)
+ }
+ if u.unrecognized.IsValid() {
+ s := *ptr.offset(u.unrecognized).toBytes()
+ n += len(s)
+ }
+ // cache the result for use in marshal
+ if u.sizecache.IsValid() {
+ atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
+ }
+ return n
+}
+
+// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
+// fall back to compute the size.
+func (u *marshalInfo) cachedsize(ptr pointer) int {
+ if u.sizecache.IsValid() {
+ return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
+ }
+ return u.size(ptr)
+}
+
+// marshal is the main function to marshal a message. It takes a byte slice and appends
+// the encoded data to the end of the slice, returns the slice and error (if any).
+// ptr is the pointer to the message.
+// If deterministic is true, map is marshaled in deterministic order.
+func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
+ if atomic.LoadInt32(&u.initialized) == 0 {
+ u.computeMarshalInfo()
+ }
+
+ // If the message can marshal itself, let it do it, for compatibility.
+ // NOTE: This is not efficient.
+ if u.hasmarshaler {
+ m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
+ b1, err := m.Marshal()
+ b = append(b, b1...)
+ return b, err
+ }
+
+ var err, errLater error
+ // The old marshaler encodes extensions at beginning.
+ if u.extensions.IsValid() {
+ e := ptr.offset(u.extensions).toExtensions()
+ if u.messageset {
+ b, err = u.appendMessageSet(b, e, deterministic)
+ } else {
+ b, err = u.appendExtensions(b, e, deterministic)
+ }
+ if err != nil {
+ return b, err
+ }
+ }
+ if u.v1extensions.IsValid() {
+ m := *ptr.offset(u.v1extensions).toOldExtensions()
+ b, err = u.appendV1Extensions(b, m, deterministic)
+ if err != nil {
+ return b, err
+ }
+ }
+ for _, f := range u.fields {
+ if f.required {
+ if ptr.offset(f.field).getPointer().isNil() {
+ // Required field is not set.
+ // We record the error but keep going, to give a complete marshaling.
+ if errLater == nil {
+ errLater = &RequiredNotSetError{f.name}
+ }
+ continue
+ }
+ }
+ if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+ // nil pointer always marshals to nothing
+ continue
+ }
+ b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
+ if err != nil {
+ if err1, ok := err.(*RequiredNotSetError); ok {
+ // Required field in submessage is not set.
+ // We record the error but keep going, to give a complete marshaling.
+ if errLater == nil {
+ errLater = &RequiredNotSetError{f.name + "." + err1.field}
+ }
+ continue
+ }
+ if err == errRepeatedHasNil {
+ err = errors.New("proto: repeated field " + f.name + " has nil element")
+ }
+ if err == errInvalidUTF8 {
+ if errLater == nil {
+ fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
+ errLater = &invalidUTF8Error{fullName}
+ }
+ continue
+ }
+ return b, err
+ }
+ }
+ if u.unrecognized.IsValid() {
+ s := *ptr.offset(u.unrecognized).toBytes()
+ b = append(b, s...)
+ }
+ return b, errLater
+}
+
+// computeMarshalInfo initializes the marshal info.
+func (u *marshalInfo) computeMarshalInfo() {
+ u.Lock()
+ defer u.Unlock()
+ if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
+ return
+ }
+
+ t := u.typ
+ u.unrecognized = invalidField
+ u.extensions = invalidField
+ u.v1extensions = invalidField
+ u.sizecache = invalidField
+
+ // If the message can marshal itself, let it do it, for compatibility.
+ // NOTE: This is not efficient.
+ if reflect.PtrTo(t).Implements(marshalerType) {
+ u.hasmarshaler = true
+ atomic.StoreInt32(&u.initialized, 1)
+ return
+ }
+
+ // get oneof implementers
+ var oneofImplementers []interface{}
+ switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+ case oneofFuncsIface:
+ _, _, _, oneofImplementers = m.XXX_OneofFuncs()
+ case oneofWrappersIface:
+ oneofImplementers = m.XXX_OneofWrappers()
+ }
+
+ n := t.NumField()
+
+ // deal with XXX fields first
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ if !strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ switch f.Name {
+ case "XXX_sizecache":
+ u.sizecache = toField(&f)
+ case "XXX_unrecognized":
+ u.unrecognized = toField(&f)
+ case "XXX_InternalExtensions":
+ u.extensions = toField(&f)
+ u.messageset = f.Tag.Get("protobuf_messageset") == "1"
+ case "XXX_extensions":
+ u.v1extensions = toField(&f)
+ case "XXX_NoUnkeyedLiteral":
+ // nothing to do
+ default:
+ panic("unknown XXX field: " + f.Name)
+ }
+ n--
+ }
+
+ // normal fields
+ fields := make([]marshalFieldInfo, n) // batch allocation
+ u.fields = make([]*marshalFieldInfo, 0, n)
+ for i, j := 0, 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+ field := &fields[j]
+ j++
+ field.name = f.Name
+ u.fields = append(u.fields, field)
+ if f.Tag.Get("protobuf_oneof") != "" {
+ field.computeOneofFieldInfo(&f, oneofImplementers)
+ continue
+ }
+ if f.Tag.Get("protobuf") == "" {
+ // field has no tag (not in generated message), ignore it
+ u.fields = u.fields[:len(u.fields)-1]
+ j--
+ continue
+ }
+ field.computeMarshalFieldInfo(&f)
+ }
+
+ // fields are marshaled in tag order on the wire.
+ sort.Sort(byTag(u.fields))
+
+ atomic.StoreInt32(&u.initialized, 1)
+}
+
+// helper for sorting fields by tag
+type byTag []*marshalFieldInfo
+
+func (a byTag) Len() int { return len(a) }
+func (a byTag) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
+
+// getExtElemInfo returns the information to marshal an extension element.
+// The info it returns is initialized.
+func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
+ // get from cache first
+ u.RLock()
+ e, ok := u.extElems[desc.Field]
+ u.RUnlock()
+ if ok {
+ return e
+ }
+
+ t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
+ tags := strings.Split(desc.Tag, ",")
+ tag, err := strconv.Atoi(tags[1])
+ if err != nil {
+ panic("tag is not an integer")
+ }
+ wt := wiretype(tags[0])
+ if t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct {
+ t = t.Elem()
+ }
+ sizer, marshaler := typeMarshaler(t, tags, false, false)
+ var deref bool
+ if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+ t = reflect.PtrTo(t)
+ deref = true
+ }
+ e = &marshalElemInfo{
+ wiretag: uint64(tag)<<3 | wt,
+ tagsize: SizeVarint(uint64(tag) << 3),
+ sizer: sizer,
+ marshaler: marshaler,
+ isptr: t.Kind() == reflect.Ptr,
+ deref: deref,
+ }
+
+ // update cache
+ u.Lock()
+ if u.extElems == nil {
+ u.extElems = make(map[int32]*marshalElemInfo)
+ }
+ u.extElems[desc.Field] = e
+ u.Unlock()
+ return e
+}
+
+// computeMarshalFieldInfo fills up the information to marshal a field.
+func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
+ // parse protobuf tag of the field.
+ // tag has format of "bytes,49,opt,name=foo,def=hello!"
+ tags := strings.Split(f.Tag.Get("protobuf"), ",")
+ if tags[0] == "" {
+ return
+ }
+ tag, err := strconv.Atoi(tags[1])
+ if err != nil {
+ panic("tag is not an integer")
+ }
+ wt := wiretype(tags[0])
+ if tags[2] == "req" {
+ fi.required = true
+ }
+ fi.setTag(f, tag, wt)
+ fi.setMarshaler(f, tags)
+}
+
+func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
+ fi.field = toField(f)
+ fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
+ fi.isPointer = true
+ fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
+ fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
+
+ ityp := f.Type // interface type
+ for _, o := range oneofImplementers {
+ t := reflect.TypeOf(o)
+ if !t.Implements(ityp) {
+ continue
+ }
+ sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
+ tags := strings.Split(sf.Tag.Get("protobuf"), ",")
+ tag, err := strconv.Atoi(tags[1])
+ if err != nil {
+ panic("tag is not an integer")
+ }
+ wt := wiretype(tags[0])
+ sizer, marshaler := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
+ fi.oneofElems[t.Elem()] = &marshalElemInfo{
+ wiretag: uint64(tag)<<3 | wt,
+ tagsize: SizeVarint(uint64(tag) << 3),
+ sizer: sizer,
+ marshaler: marshaler,
+ }
+ }
+}
+
+// wiretype returns the wire encoding of the type.
+func wiretype(encoding string) uint64 {
+ switch encoding {
+ case "fixed32":
+ return WireFixed32
+ case "fixed64":
+ return WireFixed64
+ case "varint", "zigzag32", "zigzag64":
+ return WireVarint
+ case "bytes":
+ return WireBytes
+ case "group":
+ return WireStartGroup
+ }
+ panic("unknown wire type " + encoding)
+}
+
+// setTag fills up the tag (in wire format) and its size in the info of a field.
+func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
+ fi.field = toField(f)
+ fi.wiretag = uint64(tag)<<3 | wt
+ fi.tagsize = SizeVarint(uint64(tag) << 3)
+}
+
+// setMarshaler fills up the sizer and marshaler in the info of a field.
+func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
+ switch f.Type.Kind() {
+ case reflect.Map:
+ // map field
+ fi.isPointer = true
+ fi.sizer, fi.marshaler = makeMapMarshaler(f)
+ return
+ case reflect.Ptr, reflect.Slice:
+ fi.isPointer = true
+ }
+ fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
+}
+
+// typeMarshaler returns the sizer and marshaler of a given field.
+// t is the type of the field.
+// tags is the generated "protobuf" tag of the field.
+// If nozero is true, zero value is not marshaled to the wire.
+// If oneof is true, it is a oneof field.
+func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
+ encoding := tags[0]
+
+ pointer := false
+ slice := false
+ if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+ slice = true
+ t = t.Elem()
+ }
+ if t.Kind() == reflect.Ptr {
+ pointer = true
+ t = t.Elem()
+ }
+
+ packed := false
+ proto3 := false
+ validateUTF8 := true
+ for i := 2; i < len(tags); i++ {
+ if tags[i] == "packed" {
+ packed = true
+ }
+ if tags[i] == "proto3" {
+ proto3 = true
+ }
+ }
+ validateUTF8 = validateUTF8 && proto3
+
+ switch t.Kind() {
+ case reflect.Bool:
+ if pointer {
+ return sizeBoolPtr, appendBoolPtr
+ }
+ if slice {
+ if packed {
+ return sizeBoolPackedSlice, appendBoolPackedSlice
+ }
+ return sizeBoolSlice, appendBoolSlice
+ }
+ if nozero {
+ return sizeBoolValueNoZero, appendBoolValueNoZero
+ }
+ return sizeBoolValue, appendBoolValue
+ case reflect.Uint32:
+ switch encoding {
+ case "fixed32":
+ if pointer {
+ return sizeFixed32Ptr, appendFixed32Ptr
+ }
+ if slice {
+ if packed {
+ return sizeFixed32PackedSlice, appendFixed32PackedSlice
+ }
+ return sizeFixed32Slice, appendFixed32Slice
+ }
+ if nozero {
+ return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
+ }
+ return sizeFixed32Value, appendFixed32Value
+ case "varint":
+ if pointer {
+ return sizeVarint32Ptr, appendVarint32Ptr
+ }
+ if slice {
+ if packed {
+ return sizeVarint32PackedSlice, appendVarint32PackedSlice
+ }
+ return sizeVarint32Slice, appendVarint32Slice
+ }
+ if nozero {
+ return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
+ }
+ return sizeVarint32Value, appendVarint32Value
+ }
+ case reflect.Int32:
+ switch encoding {
+ case "fixed32":
+ if pointer {
+ return sizeFixedS32Ptr, appendFixedS32Ptr
+ }
+ if slice {
+ if packed {
+ return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
+ }
+ return sizeFixedS32Slice, appendFixedS32Slice
+ }
+ if nozero {
+ return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
+ }
+ return sizeFixedS32Value, appendFixedS32Value
+ case "varint":
+ if pointer {
+ return sizeVarintS32Ptr, appendVarintS32Ptr
+ }
+ if slice {
+ if packed {
+ return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
+ }
+ return sizeVarintS32Slice, appendVarintS32Slice
+ }
+ if nozero {
+ return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
+ }
+ return sizeVarintS32Value, appendVarintS32Value
+ case "zigzag32":
+ if pointer {
+ return sizeZigzag32Ptr, appendZigzag32Ptr
+ }
+ if slice {
+ if packed {
+ return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
+ }
+ return sizeZigzag32Slice, appendZigzag32Slice
+ }
+ if nozero {
+ return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
+ }
+ return sizeZigzag32Value, appendZigzag32Value
+ }
+ case reflect.Uint64:
+ switch encoding {
+ case "fixed64":
+ if pointer {
+ return sizeFixed64Ptr, appendFixed64Ptr
+ }
+ if slice {
+ if packed {
+ return sizeFixed64PackedSlice, appendFixed64PackedSlice
+ }
+ return sizeFixed64Slice, appendFixed64Slice
+ }
+ if nozero {
+ return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
+ }
+ return sizeFixed64Value, appendFixed64Value
+ case "varint":
+ if pointer {
+ return sizeVarint64Ptr, appendVarint64Ptr
+ }
+ if slice {
+ if packed {
+ return sizeVarint64PackedSlice, appendVarint64PackedSlice
+ }
+ return sizeVarint64Slice, appendVarint64Slice
+ }
+ if nozero {
+ return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
+ }
+ return sizeVarint64Value, appendVarint64Value
+ }
+ case reflect.Int64:
+ switch encoding {
+ case "fixed64":
+ if pointer {
+ return sizeFixedS64Ptr, appendFixedS64Ptr
+ }
+ if slice {
+ if packed {
+ return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
+ }
+ return sizeFixedS64Slice, appendFixedS64Slice
+ }
+ if nozero {
+ return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
+ }
+ return sizeFixedS64Value, appendFixedS64Value
+ case "varint":
+ if pointer {
+ return sizeVarintS64Ptr, appendVarintS64Ptr
+ }
+ if slice {
+ if packed {
+ return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
+ }
+ return sizeVarintS64Slice, appendVarintS64Slice
+ }
+ if nozero {
+ return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
+ }
+ return sizeVarintS64Value, appendVarintS64Value
+ case "zigzag64":
+ if pointer {
+ return sizeZigzag64Ptr, appendZigzag64Ptr
+ }
+ if slice {
+ if packed {
+ return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
+ }
+ return sizeZigzag64Slice, appendZigzag64Slice
+ }
+ if nozero {
+ return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
+ }
+ return sizeZigzag64Value, appendZigzag64Value
+ }
+ case reflect.Float32:
+ if pointer {
+ return sizeFloat32Ptr, appendFloat32Ptr
+ }
+ if slice {
+ if packed {
+ return sizeFloat32PackedSlice, appendFloat32PackedSlice
+ }
+ return sizeFloat32Slice, appendFloat32Slice
+ }
+ if nozero {
+ return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
+ }
+ return sizeFloat32Value, appendFloat32Value
+ case reflect.Float64:
+ if pointer {
+ return sizeFloat64Ptr, appendFloat64Ptr
+ }
+ if slice {
+ if packed {
+ return sizeFloat64PackedSlice, appendFloat64PackedSlice
+ }
+ return sizeFloat64Slice, appendFloat64Slice
+ }
+ if nozero {
+ return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
+ }
+ return sizeFloat64Value, appendFloat64Value
+ case reflect.String:
+ if validateUTF8 {
+ if pointer {
+ return sizeStringPtr, appendUTF8StringPtr
+ }
+ if slice {
+ return sizeStringSlice, appendUTF8StringSlice
+ }
+ if nozero {
+ return sizeStringValueNoZero, appendUTF8StringValueNoZero
+ }
+ return sizeStringValue, appendUTF8StringValue
+ }
+ if pointer {
+ return sizeStringPtr, appendStringPtr
+ }
+ if slice {
+ return sizeStringSlice, appendStringSlice
+ }
+ if nozero {
+ return sizeStringValueNoZero, appendStringValueNoZero
+ }
+ return sizeStringValue, appendStringValue
+ case reflect.Slice:
+ if slice {
+ return sizeBytesSlice, appendBytesSlice
+ }
+ if oneof {
+ // Oneof bytes field may also have "proto3" tag.
+ // We want to marshal it as a oneof field. Do this
+ // check before the proto3 check.
+ return sizeBytesOneof, appendBytesOneof
+ }
+ if proto3 {
+ return sizeBytes3, appendBytes3
+ }
+ return sizeBytes, appendBytes
+ case reflect.Struct:
+ switch encoding {
+ case "group":
+ if slice {
+ return makeGroupSliceMarshaler(getMarshalInfo(t))
+ }
+ return makeGroupMarshaler(getMarshalInfo(t))
+ case "bytes":
+ if slice {
+ return makeMessageSliceMarshaler(getMarshalInfo(t))
+ }
+ return makeMessageMarshaler(getMarshalInfo(t))
+ }
+ }
+ panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
+}
+
+// Below are functions to size/marshal a specific type of a field.
+// They are stored in the field's info, and called by function pointers.
+// They have type sizer or marshaler.
+
+func sizeFixed32Value(_ pointer, tagsize int) int {
+ return 4 + tagsize
+}
+func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toUint32()
+ if v == 0 {
+ return 0
+ }
+ return 4 + tagsize
+}
+func sizeFixed32Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toUint32Ptr()
+ if p == nil {
+ return 0
+ }
+ return 4 + tagsize
+}
+func sizeFixed32Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint32Slice()
+ return (4 + tagsize) * len(s)
+}
+func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint32Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFixedS32Value(_ pointer, tagsize int) int {
+ return 4 + tagsize
+}
+func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toInt32()
+ if v == 0 {
+ return 0
+ }
+ return 4 + tagsize
+}
+func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
+ p := ptr.getInt32Ptr()
+ if p == nil {
+ return 0
+ }
+ return 4 + tagsize
+}
+func sizeFixedS32Slice(ptr pointer, tagsize int) int {
+ s := ptr.getInt32Slice()
+ return (4 + tagsize) * len(s)
+}
+func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
+ s := ptr.getInt32Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFloat32Value(_ pointer, tagsize int) int {
+ return 4 + tagsize
+}
+func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
+ v := math.Float32bits(*ptr.toFloat32())
+ if v == 0 {
+ return 0
+ }
+ return 4 + tagsize
+}
+func sizeFloat32Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toFloat32Ptr()
+ if p == nil {
+ return 0
+ }
+ return 4 + tagsize
+}
+func sizeFloat32Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toFloat32Slice()
+ return (4 + tagsize) * len(s)
+}
+func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toFloat32Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFixed64Value(_ pointer, tagsize int) int {
+ return 8 + tagsize
+}
+func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toUint64()
+ if v == 0 {
+ return 0
+ }
+ return 8 + tagsize
+}
+func sizeFixed64Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toUint64Ptr()
+ if p == nil {
+ return 0
+ }
+ return 8 + tagsize
+}
+func sizeFixed64Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint64Slice()
+ return (8 + tagsize) * len(s)
+}
+func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint64Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeFixedS64Value(_ pointer, tagsize int) int {
+ return 8 + tagsize
+}
+func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toInt64()
+ if v == 0 {
+ return 0
+ }
+ return 8 + tagsize
+}
+func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toInt64Ptr()
+ if p == nil {
+ return 0
+ }
+ return 8 + tagsize
+}
+func sizeFixedS64Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toInt64Slice()
+ return (8 + tagsize) * len(s)
+}
+func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toInt64Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeFloat64Value(_ pointer, tagsize int) int {
+ return 8 + tagsize
+}
+func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
+ v := math.Float64bits(*ptr.toFloat64())
+ if v == 0 {
+ return 0
+ }
+ return 8 + tagsize
+}
+func sizeFloat64Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toFloat64Ptr()
+ if p == nil {
+ return 0
+ }
+ return 8 + tagsize
+}
+func sizeFloat64Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toFloat64Slice()
+ return (8 + tagsize) * len(s)
+}
+func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toFloat64Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeVarint32Value(ptr pointer, tagsize int) int {
+ v := *ptr.toUint32()
+ return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toUint32()
+ if v == 0 {
+ return 0
+ }
+ return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarint32Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toUint32Ptr()
+ if p == nil {
+ return 0
+ }
+ return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarint32Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint32Slice()
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v)) + tagsize
+ }
+ return n
+}
+func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint32Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v))
+ }
+ return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarintS32Value(ptr pointer, tagsize int) int {
+ v := *ptr.toInt32()
+ return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toInt32()
+ if v == 0 {
+ return 0
+ }
+ return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
+ p := ptr.getInt32Ptr()
+ if p == nil {
+ return 0
+ }
+ return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarintS32Slice(ptr pointer, tagsize int) int {
+ s := ptr.getInt32Slice()
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v)) + tagsize
+ }
+ return n
+}
+func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
+ s := ptr.getInt32Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v))
+ }
+ return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarint64Value(ptr pointer, tagsize int) int {
+ v := *ptr.toUint64()
+ return SizeVarint(v) + tagsize
+}
+func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toUint64()
+ if v == 0 {
+ return 0
+ }
+ return SizeVarint(v) + tagsize
+}
+func sizeVarint64Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toUint64Ptr()
+ if p == nil {
+ return 0
+ }
+ return SizeVarint(*p) + tagsize
+}
+func sizeVarint64Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint64Slice()
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(v) + tagsize
+ }
+ return n
+}
+func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toUint64Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(v)
+ }
+ return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarintS64Value(ptr pointer, tagsize int) int {
+ v := *ptr.toInt64()
+ return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toInt64()
+ if v == 0 {
+ return 0
+ }
+ return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toInt64Ptr()
+ if p == nil {
+ return 0
+ }
+ return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarintS64Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toInt64Slice()
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v)) + tagsize
+ }
+ return n
+}
+func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toInt64Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v))
+ }
+ return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeZigzag32Value(ptr pointer, tagsize int) int {
+ v := *ptr.toInt32()
+ return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toInt32()
+ if v == 0 {
+ return 0
+ }
+ return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
+ p := ptr.getInt32Ptr()
+ if p == nil {
+ return 0
+ }
+ v := *p
+ return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32Slice(ptr pointer, tagsize int) int {
+ s := ptr.getInt32Slice()
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+ }
+ return n
+}
+func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
+ s := ptr.getInt32Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+ }
+ return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeZigzag64Value(ptr pointer, tagsize int) int {
+ v := *ptr.toInt64()
+ return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toInt64()
+ if v == 0 {
+ return 0
+ }
+ return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
+ p := *ptr.toInt64Ptr()
+ if p == nil {
+ return 0
+ }
+ v := *p
+ return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64Slice(ptr pointer, tagsize int) int {
+ s := *ptr.toInt64Slice()
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+ }
+ return n
+}
+func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toInt64Slice()
+ if len(s) == 0 {
+ return 0
+ }
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
+ }
+ return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeBoolValue(_ pointer, tagsize int) int {
+ return 1 + tagsize
+}
+func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toBool()
+ if !v {
+ return 0
+ }
+ return 1 + tagsize
+}
+func sizeBoolPtr(ptr pointer, tagsize int) int {
+ p := *ptr.toBoolPtr()
+ if p == nil {
+ return 0
+ }
+ return 1 + tagsize
+}
+func sizeBoolSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toBoolSlice()
+ return (1 + tagsize) * len(s)
+}
+func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toBoolSlice()
+ if len(s) == 0 {
+ return 0
+ }
+ return len(s) + SizeVarint(uint64(len(s))) + tagsize
+}
+func sizeStringValue(ptr pointer, tagsize int) int {
+ v := *ptr.toString()
+ return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringValueNoZero(ptr pointer, tagsize int) int {
+ v := *ptr.toString()
+ if v == "" {
+ return 0
+ }
+ return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringPtr(ptr pointer, tagsize int) int {
+ p := *ptr.toStringPtr()
+ if p == nil {
+ return 0
+ }
+ v := *p
+ return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toStringSlice()
+ n := 0
+ for _, v := range s {
+ n += len(v) + SizeVarint(uint64(len(v))) + tagsize
+ }
+ return n
+}
+func sizeBytes(ptr pointer, tagsize int) int {
+ v := *ptr.toBytes()
+ if v == nil {
+ return 0
+ }
+ return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytes3(ptr pointer, tagsize int) int {
+ v := *ptr.toBytes()
+ if len(v) == 0 {
+ return 0
+ }
+ return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytesOneof(ptr pointer, tagsize int) int {
+ v := *ptr.toBytes()
+ return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytesSlice(ptr pointer, tagsize int) int {
+ s := *ptr.toBytesSlice()
+ n := 0
+ for _, v := range s {
+ n += len(v) + SizeVarint(uint64(len(v))) + tagsize
+ }
+ return n
+}
+
+// appendFixed32 appends an encoded fixed32 to b.
+func appendFixed32(b []byte, v uint32) []byte {
+ b = append(b,
+ byte(v),
+ byte(v>>8),
+ byte(v>>16),
+ byte(v>>24))
+ return b
+}
+
+// appendFixed64 appends an encoded fixed64 to b.
+func appendFixed64(b []byte, v uint64) []byte {
+ b = append(b,
+ byte(v),
+ byte(v>>8),
+ byte(v>>16),
+ byte(v>>24),
+ byte(v>>32),
+ byte(v>>40),
+ byte(v>>48),
+ byte(v>>56))
+ return b
+}
+
+// appendVarint appends an encoded varint to b.
+func appendVarint(b []byte, v uint64) []byte {
+ // TODO: make 1-byte (maybe 2-byte) case inline-able, once we
+ // have non-leaf inliner.
+ switch {
+ case v < 1<<7:
+ b = append(b, byte(v))
+ case v < 1<<14:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte(v>>7))
+ case v < 1<<21:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte(v>>14))
+ case v < 1<<28:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte(v>>21))
+ case v < 1<<35:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte((v>>21)&0x7f|0x80),
+ byte(v>>28))
+ case v < 1<<42:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte((v>>21)&0x7f|0x80),
+ byte((v>>28)&0x7f|0x80),
+ byte(v>>35))
+ case v < 1<<49:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte((v>>21)&0x7f|0x80),
+ byte((v>>28)&0x7f|0x80),
+ byte((v>>35)&0x7f|0x80),
+ byte(v>>42))
+ case v < 1<<56:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte((v>>21)&0x7f|0x80),
+ byte((v>>28)&0x7f|0x80),
+ byte((v>>35)&0x7f|0x80),
+ byte((v>>42)&0x7f|0x80),
+ byte(v>>49))
+ case v < 1<<63:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte((v>>21)&0x7f|0x80),
+ byte((v>>28)&0x7f|0x80),
+ byte((v>>35)&0x7f|0x80),
+ byte((v>>42)&0x7f|0x80),
+ byte((v>>49)&0x7f|0x80),
+ byte(v>>56))
+ default:
+ b = append(b,
+ byte(v&0x7f|0x80),
+ byte((v>>7)&0x7f|0x80),
+ byte((v>>14)&0x7f|0x80),
+ byte((v>>21)&0x7f|0x80),
+ byte((v>>28)&0x7f|0x80),
+ byte((v>>35)&0x7f|0x80),
+ byte((v>>42)&0x7f|0x80),
+ byte((v>>49)&0x7f|0x80),
+ byte((v>>56)&0x7f|0x80),
+ 1)
+ }
+ return b
+}
+
+func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint32()
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, v)
+ return b, nil
+}
+func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint32()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, v)
+ return b, nil
+}
+func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toUint32Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, *p)
+ return b, nil
+}
+func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint32Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, v)
+ }
+ return b, nil
+}
+func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint32Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(4*len(s)))
+ for _, v := range s {
+ b = appendFixed32(b, v)
+ }
+ return b, nil
+}
+func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt32()
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, uint32(v))
+ return b, nil
+}
+func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt32()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, uint32(v))
+ return b, nil
+}
+func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := ptr.getInt32Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, uint32(*p))
+ return b, nil
+}
+func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := ptr.getInt32Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, uint32(v))
+ }
+ return b, nil
+}
+func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := ptr.getInt32Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(4*len(s)))
+ for _, v := range s {
+ b = appendFixed32(b, uint32(v))
+ }
+ return b, nil
+}
+func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := math.Float32bits(*ptr.toFloat32())
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, v)
+ return b, nil
+}
+func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := math.Float32bits(*ptr.toFloat32())
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, v)
+ return b, nil
+}
+func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toFloat32Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, math.Float32bits(*p))
+ return b, nil
+}
+func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toFloat32Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendFixed32(b, math.Float32bits(v))
+ }
+ return b, nil
+}
+func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toFloat32Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(4*len(s)))
+ for _, v := range s {
+ b = appendFixed32(b, math.Float32bits(v))
+ }
+ return b, nil
+}
+func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint64()
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, v)
+ return b, nil
+}
+func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint64()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, v)
+ return b, nil
+}
+func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toUint64Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, *p)
+ return b, nil
+}
+func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint64Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, v)
+ }
+ return b, nil
+}
+func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint64Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(8*len(s)))
+ for _, v := range s {
+ b = appendFixed64(b, v)
+ }
+ return b, nil
+}
+func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt64()
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, uint64(v))
+ return b, nil
+}
+func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt64()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, uint64(v))
+ return b, nil
+}
+func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toInt64Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, uint64(*p))
+ return b, nil
+}
+func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toInt64Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, uint64(v))
+ }
+ return b, nil
+}
+func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toInt64Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(8*len(s)))
+ for _, v := range s {
+ b = appendFixed64(b, uint64(v))
+ }
+ return b, nil
+}
+func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := math.Float64bits(*ptr.toFloat64())
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, v)
+ return b, nil
+}
+func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := math.Float64bits(*ptr.toFloat64())
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, v)
+ return b, nil
+}
+func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toFloat64Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, math.Float64bits(*p))
+ return b, nil
+}
+func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toFloat64Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendFixed64(b, math.Float64bits(v))
+ }
+ return b, nil
+}
+func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toFloat64Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(8*len(s)))
+ for _, v := range s {
+ b = appendFixed64(b, math.Float64bits(v))
+ }
+ return b, nil
+}
+func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint32()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ return b, nil
+}
+func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint32()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ return b, nil
+}
+func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toUint32Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(*p))
+ return b, nil
+}
+func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint32Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ }
+ return b, nil
+}
+func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint32Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ // compute size
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v))
+ }
+ b = appendVarint(b, uint64(n))
+ for _, v := range s {
+ b = appendVarint(b, uint64(v))
+ }
+ return b, nil
+}
+func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt32()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ return b, nil
+}
+func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt32()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ return b, nil
+}
+func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := ptr.getInt32Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(*p))
+ return b, nil
+}
+func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := ptr.getInt32Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ }
+ return b, nil
+}
+func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := ptr.getInt32Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ // compute size
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v))
+ }
+ b = appendVarint(b, uint64(n))
+ for _, v := range s {
+ b = appendVarint(b, uint64(v))
+ }
+ return b, nil
+}
+func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint64()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, v)
+ return b, nil
+}
+func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toUint64()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, v)
+ return b, nil
+}
+func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toUint64Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, *p)
+ return b, nil
+}
+func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint64Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, v)
+ }
+ return b, nil
+}
+func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toUint64Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ // compute size
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(v)
+ }
+ b = appendVarint(b, uint64(n))
+ for _, v := range s {
+ b = appendVarint(b, v)
+ }
+ return b, nil
+}
+func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt64()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ return b, nil
+}
+func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt64()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ return b, nil
+}
+func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toInt64Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(*p))
+ return b, nil
+}
+func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toInt64Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v))
+ }
+ return b, nil
+}
+func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toInt64Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ // compute size
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v))
+ }
+ b = appendVarint(b, uint64(n))
+ for _, v := range s {
+ b = appendVarint(b, uint64(v))
+ }
+ return b, nil
+}
+func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt32()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+ return b, nil
+}
+func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt32()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+ return b, nil
+}
+func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := ptr.getInt32Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ v := *p
+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+ return b, nil
+}
+func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := ptr.getInt32Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+ }
+ return b, nil
+}
+func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := ptr.getInt32Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ // compute size
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+ }
+ b = appendVarint(b, uint64(n))
+ for _, v := range s {
+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+ }
+ return b, nil
+}
+func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt64()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+ return b, nil
+}
+func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toInt64()
+ if v == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+ return b, nil
+}
+func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toInt64Ptr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ v := *p
+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+ return b, nil
+}
+func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toInt64Slice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+ }
+ return b, nil
+}
+func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toInt64Slice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ // compute size
+ n := 0
+ for _, v := range s {
+ n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
+ }
+ b = appendVarint(b, uint64(n))
+ for _, v := range s {
+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+ }
+ return b, nil
+}
+func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toBool()
+ b = appendVarint(b, wiretag)
+ if v {
+ b = append(b, 1)
+ } else {
+ b = append(b, 0)
+ }
+ return b, nil
+}
+func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toBool()
+ if !v {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = append(b, 1)
+ return b, nil
+}
+
+func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toBoolPtr()
+ if p == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ if *p {
+ b = append(b, 1)
+ } else {
+ b = append(b, 0)
+ }
+ return b, nil
+}
+func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toBoolSlice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ if v {
+ b = append(b, 1)
+ } else {
+ b = append(b, 0)
+ }
+ }
+ return b, nil
+}
+func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toBoolSlice()
+ if len(s) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag&^7|WireBytes)
+ b = appendVarint(b, uint64(len(s)))
+ for _, v := range s {
+ if v {
+ b = append(b, 1)
+ } else {
+ b = append(b, 0)
+ }
+ }
+ return b, nil
+}
+func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toString()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ return b, nil
+}
+func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toString()
+ if v == "" {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ return b, nil
+}
+func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ p := *ptr.toStringPtr()
+ if p == nil {
+ return b, nil
+ }
+ v := *p
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ return b, nil
+}
+func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toStringSlice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ }
+ return b, nil
+}
+func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ var invalidUTF8 bool
+ v := *ptr.toString()
+ if !utf8.ValidString(v) {
+ invalidUTF8 = true
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ if invalidUTF8 {
+ return b, errInvalidUTF8
+ }
+ return b, nil
+}
+func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ var invalidUTF8 bool
+ v := *ptr.toString()
+ if v == "" {
+ return b, nil
+ }
+ if !utf8.ValidString(v) {
+ invalidUTF8 = true
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ if invalidUTF8 {
+ return b, errInvalidUTF8
+ }
+ return b, nil
+}
+func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ var invalidUTF8 bool
+ p := *ptr.toStringPtr()
+ if p == nil {
+ return b, nil
+ }
+ v := *p
+ if !utf8.ValidString(v) {
+ invalidUTF8 = true
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ if invalidUTF8 {
+ return b, errInvalidUTF8
+ }
+ return b, nil
+}
+func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ var invalidUTF8 bool
+ s := *ptr.toStringSlice()
+ for _, v := range s {
+ if !utf8.ValidString(v) {
+ invalidUTF8 = true
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ }
+ if invalidUTF8 {
+ return b, errInvalidUTF8
+ }
+ return b, nil
+}
+func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toBytes()
+ if v == nil {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ return b, nil
+}
+func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toBytes()
+ if len(v) == 0 {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ return b, nil
+}
+func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ v := *ptr.toBytes()
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ return b, nil
+}
+func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+ s := *ptr.toBytesSlice()
+ for _, v := range s {
+ b = appendVarint(b, wiretag)
+ b = appendVarint(b, uint64(len(v)))
+ b = append(b, v...)
+ }
+ return b, nil
+}
+
+// makeGroupMarshaler returns the sizer and marshaler for a group.
+// u is the marshal info of the underlying message.
+func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
+ return func(ptr pointer, tagsize int) int {
+ p := ptr.getPointer()
+ if p.isNil() {
+ return 0
+ }
+ return u.size(p) + 2*tagsize
+ },
+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+ p := ptr.getPointer()
+ if p.isNil() {
+ return b, nil
+ }
+ var err error
+ b = appendVarint(b, wiretag) // start group
+ b, err = u.marshal(b, p, deterministic)
+ b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
+ return b, err
+ }
+}
+
+// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
+// u is the marshal info of the underlying message.
+func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+ return func(ptr pointer, tagsize int) int {
+ s := ptr.getPointerSlice()
+ n := 0
+ for _, v := range s {
+ if v.isNil() {
+ continue
+ }
+ n += u.size(v) + 2*tagsize
+ }
+ return n
+ },
+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+ s := ptr.getPointerSlice()
+ var err error
+ var nerr nonFatal
+ for _, v := range s {
+ if v.isNil() {
+ return b, errRepeatedHasNil
+ }
+ b = appendVarint(b, wiretag) // start group
+ b, err = u.marshal(b, v, deterministic)
+ b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
+ if !nerr.Merge(err) {
+ if err == ErrNil {
+ err = errRepeatedHasNil
+ }
+ return b, err
+ }
+ }
+ return b, nerr.E
+ }
+}
+
+// makeMessageMarshaler returns the sizer and marshaler for a message field.
+// u is the marshal info of the message.
+func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
+ return func(ptr pointer, tagsize int) int {
+ p := ptr.getPointer()
+ if p.isNil() {
+ return 0
+ }
+ siz := u.size(p)
+ return siz + SizeVarint(uint64(siz)) + tagsize
+ },
+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+ p := ptr.getPointer()
+ if p.isNil() {
+ return b, nil
+ }
+ b = appendVarint(b, wiretag)
+ siz := u.cachedsize(p)
+ b = appendVarint(b, uint64(siz))
+ return u.marshal(b, p, deterministic)
+ }
+}
+
+// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
+// u is the marshal info of the message.
+func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+ return func(ptr pointer, tagsize int) int {
+ s := ptr.getPointerSlice()
+ n := 0
+ for _, v := range s {
+ if v.isNil() {
+ continue
+ }
+ siz := u.size(v)
+ n += siz + SizeVarint(uint64(siz)) + tagsize
+ }
+ return n
+ },
+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+ s := ptr.getPointerSlice()
+ var err error
+ var nerr nonFatal
+ for _, v := range s {
+ if v.isNil() {
+ return b, errRepeatedHasNil
+ }
+ b = appendVarint(b, wiretag)
+ siz := u.cachedsize(v)
+ b = appendVarint(b, uint64(siz))
+ b, err = u.marshal(b, v, deterministic)
+
+ if !nerr.Merge(err) {
+ if err == ErrNil {
+ err = errRepeatedHasNil
+ }
+ return b, err
+ }
+ }
+ return b, nerr.E
+ }
+}
+
+// makeMapMarshaler returns the sizer and marshaler for a map field.
+// f is the pointer to the reflect data structure of the field.
+func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
+ // figure out key and value type
+ t := f.Type
+ keyType := t.Key()
+ valType := t.Elem()
+ keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
+ valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
+ keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
+ valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
+ keyWireTag := 1<<3 | wiretype(keyTags[0])
+ valWireTag := 2<<3 | wiretype(valTags[0])
+
+ // We create an interface to get the addresses of the map key and value.
+ // If value is pointer-typed, the interface is a direct interface, the
+ // idata itself is the value. Otherwise, the idata is the pointer to the
+ // value.
+ // Key cannot be pointer-typed.
+ valIsPtr := valType.Kind() == reflect.Ptr
+
+ // If value is a message with nested maps, calling
+ // valSizer in marshal may be quadratic. We should use
+ // cached version in marshal (but not in size).
+ // If value is not message type, we don't have size cache,
+ // but it cannot be nested either. Just use valSizer.
+ valCachedSizer := valSizer
+ if valIsPtr && valType.Elem().Kind() == reflect.Struct {
+ u := getMarshalInfo(valType.Elem())
+ valCachedSizer = func(ptr pointer, tagsize int) int {
+ // Same as message sizer, but use cache.
+ p := ptr.getPointer()
+ if p.isNil() {
+ return 0
+ }
+ siz := u.cachedsize(p)
+ return siz + SizeVarint(uint64(siz)) + tagsize
+ }
+ }
+ return func(ptr pointer, tagsize int) int {
+ m := ptr.asPointerTo(t).Elem() // the map
+ n := 0
+ for _, k := range m.MapKeys() {
+ ki := k.Interface()
+ vi := m.MapIndex(k).Interface()
+ kaddr := toAddrPointer(&ki, false, false) // pointer to key
+ vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
+ siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
+ n += siz + SizeVarint(uint64(siz)) + tagsize
+ }
+ return n
+ },
+ func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
+ m := ptr.asPointerTo(t).Elem() // the map
+ var err error
+ keys := m.MapKeys()
+ if len(keys) > 1 && deterministic {
+ sort.Sort(mapKeys(keys))
+ }
+
+ var nerr nonFatal
+ for _, k := range keys {
+ ki := k.Interface()
+ vi := m.MapIndex(k).Interface()
+ kaddr := toAddrPointer(&ki, false, false) // pointer to key
+ vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
+ b = appendVarint(b, tag)
+ siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
+ b = appendVarint(b, uint64(siz))
+ b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
+ if !nerr.Merge(err) {
+ return b, err
+ }
+ b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
+ if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
+ return b, err
+ }
+ }
+ return b, nerr.E
+ }
+}
+
+// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
+// fi is the marshal info of the field.
+// f is the pointer to the reflect data structure of the field.
+func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
+ // Oneof field is an interface. We need to get the actual data type on the fly.
+ t := f.Type
+ return func(ptr pointer, _ int) int {
+ p := ptr.getInterfacePointer()
+ if p.isNil() {
+ return 0
+ }
+ v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
+ telem := v.Type()
+ e := fi.oneofElems[telem]
+ return e.sizer(p, e.tagsize)
+ },
+ func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
+ p := ptr.getInterfacePointer()
+ if p.isNil() {
+ return b, nil
+ }
+ v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
+ telem := v.Type()
+ if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
+ return b, errOneofHasNil
+ }
+ e := fi.oneofElems[telem]
+ return e.marshaler(b, p, e.wiretag, deterministic)
+ }
+}
+
+// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
+func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
+ m, mu := ext.extensionsRead()
+ if m == nil {
+ return 0
+ }
+ mu.Lock()
+
+ n := 0
+ for _, e := range m {
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ n += len(e.enc)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ n += ei.sizer(p, ei.tagsize)
+ }
+ mu.Unlock()
+ return n
+}
+
+// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
+func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
+ m, mu := ext.extensionsRead()
+ if m == nil {
+ return b, nil
+ }
+ mu.Lock()
+ defer mu.Unlock()
+
+ var err error
+ var nerr nonFatal
+
+ // Fast-path for common cases: zero or one extensions.
+ // Don't bother sorting the keys.
+ if len(m) <= 1 {
+ for _, e := range m {
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ b = append(b, e.enc...)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+ if !nerr.Merge(err) {
+ return b, err
+ }
+ }
+ return b, nerr.E
+ }
+
+ // Sort the keys to provide a deterministic encoding.
+ // Not sure this is required, but the old code does it.
+ keys := make([]int, 0, len(m))
+ for k := range m {
+ keys = append(keys, int(k))
+ }
+ sort.Ints(keys)
+
+ for _, k := range keys {
+ e := m[int32(k)]
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ b = append(b, e.enc...)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+ if !nerr.Merge(err) {
+ return b, err
+ }
+ }
+ return b, nerr.E
+}
+
+// message set format is:
+// message MessageSet {
+// repeated group Item = 1 {
+// required int32 type_id = 2;
+// required string message = 3;
+// };
+// }
+
+// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
+// in message set format (above).
+func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
+ m, mu := ext.extensionsRead()
+ if m == nil {
+ return 0
+ }
+ mu.Lock()
+
+ n := 0
+ for id, e := range m {
+ n += 2 // start group, end group. tag = 1 (size=1)
+ n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
+
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+ siz := len(msgWithLen)
+ n += siz + 1 // message, tag = 3 (size=1)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ n += ei.sizer(p, 1) // message, tag = 3 (size=1)
+ }
+ mu.Unlock()
+ return n
+}
+
+// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
+// to the end of byte slice b.
+func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
+ m, mu := ext.extensionsRead()
+ if m == nil {
+ return b, nil
+ }
+ mu.Lock()
+ defer mu.Unlock()
+
+ var err error
+ var nerr nonFatal
+
+ // Fast-path for common cases: zero or one extensions.
+ // Don't bother sorting the keys.
+ if len(m) <= 1 {
+ for id, e := range m {
+ b = append(b, 1<<3|WireStartGroup)
+ b = append(b, 2<<3|WireVarint)
+ b = appendVarint(b, uint64(id))
+
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+ b = append(b, 3<<3|WireBytes)
+ b = append(b, msgWithLen...)
+ b = append(b, 1<<3|WireEndGroup)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
+ if !nerr.Merge(err) {
+ return b, err
+ }
+ b = append(b, 1<<3|WireEndGroup)
+ }
+ return b, nerr.E
+ }
+
+ // Sort the keys to provide a deterministic encoding.
+ keys := make([]int, 0, len(m))
+ for k := range m {
+ keys = append(keys, int(k))
+ }
+ sort.Ints(keys)
+
+ for _, id := range keys {
+ e := m[int32(id)]
+ b = append(b, 1<<3|WireStartGroup)
+ b = append(b, 2<<3|WireVarint)
+ b = appendVarint(b, uint64(id))
+
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+ b = append(b, 3<<3|WireBytes)
+ b = append(b, msgWithLen...)
+ b = append(b, 1<<3|WireEndGroup)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
+ b = append(b, 1<<3|WireEndGroup)
+ if !nerr.Merge(err) {
+ return b, err
+ }
+ }
+ return b, nerr.E
+}
+
+// sizeV1Extensions computes the size of encoded data for a V1-API extension field.
+func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
+ if m == nil {
+ return 0
+ }
+
+ n := 0
+ for _, e := range m {
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ n += len(e.enc)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ n += ei.sizer(p, ei.tagsize)
+ }
+ return n
+}
+
+// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
+func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
+ if m == nil {
+ return b, nil
+ }
+
+ // Sort the keys to provide a deterministic encoding.
+ keys := make([]int, 0, len(m))
+ for k := range m {
+ keys = append(keys, int(k))
+ }
+ sort.Ints(keys)
+
+ var err error
+ var nerr nonFatal
+ for _, k := range keys {
+ e := m[int32(k)]
+ if e.value == nil || e.desc == nil {
+ // Extension is only in its encoded form.
+ b = append(b, e.enc...)
+ continue
+ }
+
+ // We don't skip extensions that have an encoded form set,
+ // because the extension value may have been mutated after
+ // the last time this function was called.
+
+ ei := u.getExtElemInfo(e.desc)
+ v := e.value
+ p := toAddrPointer(&v, ei.isptr, ei.deref)
+ b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+ if !nerr.Merge(err) {
+ return b, err
+ }
+ }
+ return b, nerr.E
+}
+
+// newMarshaler is the interface representing objects that can marshal themselves.
+//
+// This exists to support protoc-gen-go generated messages.
+// The proto package will stop type-asserting to this interface in the future.
+//
+// DO NOT DEPEND ON THIS.
+type newMarshaler interface {
+ XXX_Size() int
+ XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
+}
+
+// Size returns the encoded size of a protocol buffer message.
+// This is the main entry point.
+func Size(pb Message) int {
+ if m, ok := pb.(newMarshaler); ok {
+ return m.XXX_Size()
+ }
+ if m, ok := pb.(Marshaler); ok {
+ // If the message can marshal itself, let it do it, for compatibility.
+ // NOTE: This is not efficient.
+ b, _ := m.Marshal()
+ return len(b)
+ }
+ // in case somehow we didn't generate the wrapper
+ if pb == nil {
+ return 0
+ }
+ var info InternalMessageInfo
+ return info.Size(pb)
+}
+
+// Marshal takes a protocol buffer message
+// and encodes it into the wire format, returning the data.
+// This is the main entry point.
+func Marshal(pb Message) ([]byte, error) {
+ if m, ok := pb.(newMarshaler); ok {
+ siz := m.XXX_Size()
+ b := make([]byte, 0, siz)
+ return m.XXX_Marshal(b, false)
+ }
+ if m, ok := pb.(Marshaler); ok {
+ // If the message can marshal itself, let it do it, for compatibility.
+ // NOTE: This is not efficient.
+ return m.Marshal()
+ }
+ // in case somehow we didn't generate the wrapper
+ if pb == nil {
+ return nil, ErrNil
+ }
+ var info InternalMessageInfo
+ siz := info.Size(pb)
+ b := make([]byte, 0, siz)
+ return info.Marshal(b, pb, false)
+}
+
+// Marshal takes a protocol buffer message
+// and encodes it into the wire format, writing the result to the
+// Buffer.
+// This is an alternative entry point. It is not necessary to use
+// a Buffer for most applications.
+func (p *Buffer) Marshal(pb Message) error {
+ var err error
+ if m, ok := pb.(newMarshaler); ok {
+ siz := m.XXX_Size()
+ p.grow(siz) // make sure buf has enough capacity
+ p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
+ return err
+ }
+ if m, ok := pb.(Marshaler); ok {
+ // If the message can marshal itself, let it do it, for compatibility.
+ // NOTE: This is not efficient.
+ b, err := m.Marshal()
+ p.buf = append(p.buf, b...)
+ return err
+ }
+ // in case somehow we didn't generate the wrapper
+ if pb == nil {
+ return ErrNil
+ }
+ var info InternalMessageInfo
+ siz := info.Size(pb)
+ p.grow(siz) // make sure buf has enough capacity
+ p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
+ return err
+}
+
+// grow grows the buffer's capacity, if necessary, to guarantee space for
+// another n bytes. After grow(n), at least n bytes can be written to the
+// buffer without another allocation.
+func (p *Buffer) grow(n int) {
+ need := len(p.buf) + n
+ if need <= cap(p.buf) {
+ return
+ }
+ newCap := len(p.buf) * 2
+ if newCap < need {
+ newCap = need
+ }
+ p.buf = append(make([]byte, 0, newCap), p.buf...)
+}
diff --git a/vendor/github.com/golang/protobuf/proto/table_merge.go b/vendor/github.com/golang/protobuf/proto/table_merge.go
new file mode 100644
index 0000000..5525def
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/table_merge.go
@@ -0,0 +1,654 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+import (
+ "fmt"
+ "reflect"
+ "strings"
+ "sync"
+ "sync/atomic"
+)
+
+// Merge merges the src message into dst.
+// This assumes that dst and src of the same type and are non-nil.
+func (a *InternalMessageInfo) Merge(dst, src Message) {
+ mi := atomicLoadMergeInfo(&a.merge)
+ if mi == nil {
+ mi = getMergeInfo(reflect.TypeOf(dst).Elem())
+ atomicStoreMergeInfo(&a.merge, mi)
+ }
+ mi.merge(toPointer(&dst), toPointer(&src))
+}
+
+type mergeInfo struct {
+ typ reflect.Type
+
+ initialized int32 // 0: only typ is valid, 1: everything is valid
+ lock sync.Mutex
+
+ fields []mergeFieldInfo
+ unrecognized field // Offset of XXX_unrecognized
+}
+
+type mergeFieldInfo struct {
+ field field // Offset of field, guaranteed to be valid
+
+ // isPointer reports whether the value in the field is a pointer.
+ // This is true for the following situations:
+ // * Pointer to struct
+ // * Pointer to basic type (proto2 only)
+ // * Slice (first value in slice header is a pointer)
+ // * String (first value in string header is a pointer)
+ isPointer bool
+
+ // basicWidth reports the width of the field assuming that it is directly
+ // embedded in the struct (as is the case for basic types in proto3).
+ // The possible values are:
+ // 0: invalid
+ // 1: bool
+ // 4: int32, uint32, float32
+ // 8: int64, uint64, float64
+ basicWidth int
+
+ // Where dst and src are pointers to the types being merged.
+ merge func(dst, src pointer)
+}
+
+var (
+ mergeInfoMap = map[reflect.Type]*mergeInfo{}
+ mergeInfoLock sync.Mutex
+)
+
+func getMergeInfo(t reflect.Type) *mergeInfo {
+ mergeInfoLock.Lock()
+ defer mergeInfoLock.Unlock()
+ mi := mergeInfoMap[t]
+ if mi == nil {
+ mi = &mergeInfo{typ: t}
+ mergeInfoMap[t] = mi
+ }
+ return mi
+}
+
+// merge merges src into dst assuming they are both of type *mi.typ.
+func (mi *mergeInfo) merge(dst, src pointer) {
+ if dst.isNil() {
+ panic("proto: nil destination")
+ }
+ if src.isNil() {
+ return // Nothing to do.
+ }
+
+ if atomic.LoadInt32(&mi.initialized) == 0 {
+ mi.computeMergeInfo()
+ }
+
+ for _, fi := range mi.fields {
+ sfp := src.offset(fi.field)
+
+ // As an optimization, we can avoid the merge function call cost
+ // if we know for sure that the source will have no effect
+ // by checking if it is the zero value.
+ if unsafeAllowed {
+ if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
+ continue
+ }
+ if fi.basicWidth > 0 {
+ switch {
+ case fi.basicWidth == 1 && !*sfp.toBool():
+ continue
+ case fi.basicWidth == 4 && *sfp.toUint32() == 0:
+ continue
+ case fi.basicWidth == 8 && *sfp.toUint64() == 0:
+ continue
+ }
+ }
+ }
+
+ dfp := dst.offset(fi.field)
+ fi.merge(dfp, sfp)
+ }
+
+ // TODO: Make this faster?
+ out := dst.asPointerTo(mi.typ).Elem()
+ in := src.asPointerTo(mi.typ).Elem()
+ if emIn, err := extendable(in.Addr().Interface()); err == nil {
+ emOut, _ := extendable(out.Addr().Interface())
+ mIn, muIn := emIn.extensionsRead()
+ if mIn != nil {
+ mOut := emOut.extensionsWrite()
+ muIn.Lock()
+ mergeExtension(mOut, mIn)
+ muIn.Unlock()
+ }
+ }
+
+ if mi.unrecognized.IsValid() {
+ if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
+ *dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
+ }
+ }
+}
+
+func (mi *mergeInfo) computeMergeInfo() {
+ mi.lock.Lock()
+ defer mi.lock.Unlock()
+ if mi.initialized != 0 {
+ return
+ }
+ t := mi.typ
+ n := t.NumField()
+
+ props := GetProperties(t)
+ for i := 0; i < n; i++ {
+ f := t.Field(i)
+ if strings.HasPrefix(f.Name, "XXX_") {
+ continue
+ }
+
+ mfi := mergeFieldInfo{field: toField(&f)}
+ tf := f.Type
+
+ // As an optimization, we can avoid the merge function call cost
+ // if we know for sure that the source will have no effect
+ // by checking if it is the zero value.
+ if unsafeAllowed {
+ switch tf.Kind() {
+ case reflect.Ptr, reflect.Slice, reflect.String:
+ // As a special case, we assume slices and strings are pointers
+ // since we know that the first field in the SliceSlice or
+ // StringHeader is a data pointer.
+ mfi.isPointer = true
+ case reflect.Bool:
+ mfi.basicWidth = 1
+ case reflect.Int32, reflect.Uint32, reflect.Float32:
+ mfi.basicWidth = 4
+ case reflect.Int64, reflect.Uint64, reflect.Float64:
+ mfi.basicWidth = 8
+ }
+ }
+
+ // Unwrap tf to get at its most basic type.
+ var isPointer, isSlice bool
+ if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+ isSlice = true
+ tf = tf.Elem()
+ }
+ if tf.Kind() == reflect.Ptr {
+ isPointer = true
+ tf = tf.Elem()
+ }
+ if isPointer && isSlice && tf.Kind() != reflect.Struct {
+ panic("both pointer and slice for basic type in " + tf.Name())
+ }
+
+ switch tf.Kind() {
+ case reflect.Int32:
+ switch {
+ case isSlice: // E.g., []int32
+ mfi.merge = func(dst, src pointer) {
+ // NOTE: toInt32Slice is not defined (see pointer_reflect.go).
+ /*
+ sfsp := src.toInt32Slice()
+ if *sfsp != nil {
+ dfsp := dst.toInt32Slice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []int64{}
+ }
+ }
+ */
+ sfs := src.getInt32Slice()
+ if sfs != nil {
+ dfs := dst.getInt32Slice()
+ dfs = append(dfs, sfs...)
+ if dfs == nil {
+ dfs = []int32{}
+ }
+ dst.setInt32Slice(dfs)
+ }
+ }
+ case isPointer: // E.g., *int32
+ mfi.merge = func(dst, src pointer) {
+ // NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
+ /*
+ sfpp := src.toInt32Ptr()
+ if *sfpp != nil {
+ dfpp := dst.toInt32Ptr()
+ if *dfpp == nil {
+ *dfpp = Int32(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ */
+ sfp := src.getInt32Ptr()
+ if sfp != nil {
+ dfp := dst.getInt32Ptr()
+ if dfp == nil {
+ dst.setInt32Ptr(*sfp)
+ } else {
+ *dfp = *sfp
+ }
+ }
+ }
+ default: // E.g., int32
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toInt32(); v != 0 {
+ *dst.toInt32() = v
+ }
+ }
+ }
+ case reflect.Int64:
+ switch {
+ case isSlice: // E.g., []int64
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toInt64Slice()
+ if *sfsp != nil {
+ dfsp := dst.toInt64Slice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []int64{}
+ }
+ }
+ }
+ case isPointer: // E.g., *int64
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toInt64Ptr()
+ if *sfpp != nil {
+ dfpp := dst.toInt64Ptr()
+ if *dfpp == nil {
+ *dfpp = Int64(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., int64
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toInt64(); v != 0 {
+ *dst.toInt64() = v
+ }
+ }
+ }
+ case reflect.Uint32:
+ switch {
+ case isSlice: // E.g., []uint32
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toUint32Slice()
+ if *sfsp != nil {
+ dfsp := dst.toUint32Slice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []uint32{}
+ }
+ }
+ }
+ case isPointer: // E.g., *uint32
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toUint32Ptr()
+ if *sfpp != nil {
+ dfpp := dst.toUint32Ptr()
+ if *dfpp == nil {
+ *dfpp = Uint32(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., uint32
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toUint32(); v != 0 {
+ *dst.toUint32() = v
+ }
+ }
+ }
+ case reflect.Uint64:
+ switch {
+ case isSlice: // E.g., []uint64
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toUint64Slice()
+ if *sfsp != nil {
+ dfsp := dst.toUint64Slice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []uint64{}
+ }
+ }
+ }
+ case isPointer: // E.g., *uint64
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toUint64Ptr()
+ if *sfpp != nil {
+ dfpp := dst.toUint64Ptr()
+ if *dfpp == nil {
+ *dfpp = Uint64(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., uint64
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toUint64(); v != 0 {
+ *dst.toUint64() = v
+ }
+ }
+ }
+ case reflect.Float32:
+ switch {
+ case isSlice: // E.g., []float32
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toFloat32Slice()
+ if *sfsp != nil {
+ dfsp := dst.toFloat32Slice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []float32{}
+ }
+ }
+ }
+ case isPointer: // E.g., *float32
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toFloat32Ptr()
+ if *sfpp != nil {
+ dfpp := dst.toFloat32Ptr()
+ if *dfpp == nil {
+ *dfpp = Float32(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., float32
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toFloat32(); v != 0 {
+ *dst.toFloat32() = v
+ }
+ }
+ }
+ case reflect.Float64:
+ switch {
+ case isSlice: // E.g., []float64
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toFloat64Slice()
+ if *sfsp != nil {
+ dfsp := dst.toFloat64Slice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []float64{}
+ }
+ }
+ }
+ case isPointer: // E.g., *float64
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toFloat64Ptr()
+ if *sfpp != nil {
+ dfpp := dst.toFloat64Ptr()
+ if *dfpp == nil {
+ *dfpp = Float64(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., float64
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toFloat64(); v != 0 {
+ *dst.toFloat64() = v
+ }
+ }
+ }
+ case reflect.Bool:
+ switch {
+ case isSlice: // E.g., []bool
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toBoolSlice()
+ if *sfsp != nil {
+ dfsp := dst.toBoolSlice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []bool{}
+ }
+ }
+ }
+ case isPointer: // E.g., *bool
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toBoolPtr()
+ if *sfpp != nil {
+ dfpp := dst.toBoolPtr()
+ if *dfpp == nil {
+ *dfpp = Bool(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., bool
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toBool(); v {
+ *dst.toBool() = v
+ }
+ }
+ }
+ case reflect.String:
+ switch {
+ case isSlice: // E.g., []string
+ mfi.merge = func(dst, src pointer) {
+ sfsp := src.toStringSlice()
+ if *sfsp != nil {
+ dfsp := dst.toStringSlice()
+ *dfsp = append(*dfsp, *sfsp...)
+ if *dfsp == nil {
+ *dfsp = []string{}
+ }
+ }
+ }
+ case isPointer: // E.g., *string
+ mfi.merge = func(dst, src pointer) {
+ sfpp := src.toStringPtr()
+ if *sfpp != nil {
+ dfpp := dst.toStringPtr()
+ if *dfpp == nil {
+ *dfpp = String(**sfpp)
+ } else {
+ **dfpp = **sfpp
+ }
+ }
+ }
+ default: // E.g., string
+ mfi.merge = func(dst, src pointer) {
+ if v := *src.toString(); v != "" {
+ *dst.toString() = v
+ }
+ }
+ }
+ case reflect.Slice:
+ isProto3 := props.Prop[i].proto3
+ switch {
+ case isPointer:
+ panic("bad pointer in byte slice case in " + tf.Name())
+ case tf.Elem().Kind() != reflect.Uint8:
+ panic("bad element kind in byte slice case in " + tf.Name())
+ case isSlice: // E.g., [][]byte
+ mfi.merge = func(dst, src pointer) {
+ sbsp := src.toBytesSlice()
+ if *sbsp != nil {
+ dbsp := dst.toBytesSlice()
+ for _, sb := range *sbsp {
+ if sb == nil {
+ *dbsp = append(*dbsp, nil)
+ } else {
+ *dbsp = append(*dbsp, append([]byte{}, sb...))
+ }
+ }
+ if *dbsp == nil {
+ *dbsp = [][]byte{}
+ }
+ }
+ }
+ default: // E.g., []byte
+ mfi.merge = func(dst, src pointer) {
+ sbp := src.toBytes()
+ if *sbp != nil {
+ dbp := dst.toBytes()
+ if !isProto3 || len(*sbp) > 0 {
+ *dbp = append([]byte{}, *sbp...)
+ }
+ }
+ }
+ }
+ case reflect.Struct:
+ switch {
+ case !isPointer:
+ panic(fmt.Sprintf("message field %s without pointer", tf))
+ case isSlice: // E.g., []*pb.T
+ mi := getMergeInfo(tf)
+ mfi.merge = func(dst, src pointer) {
+ sps := src.getPointerSlice()
+ if sps != nil {
+ dps := dst.getPointerSlice()
+ for _, sp := range sps {
+ var dp pointer
+ if !sp.isNil() {
+ dp = valToPointer(reflect.New(tf))
+ mi.merge(dp, sp)
+ }
+ dps = append(dps, dp)
+ }
+ if dps == nil {
+ dps = []pointer{}
+ }
+ dst.setPointerSlice(dps)
+ }
+ }
+ default: // E.g., *pb.T
+ mi := getMergeInfo(tf)
+ mfi.merge = func(dst, src pointer) {
+ sp := src.getPointer()
+ if !sp.isNil() {
+ dp := dst.getPointer()
+ if dp.isNil() {
+ dp = valToPointer(reflect.New(tf))
+ dst.setPointer(dp)
+ }
+ mi.merge(dp, sp)
+ }
+ }
+ }
+ case reflect.Map:
+ switch {
+ case isPointer || isSlice:
+ panic("bad pointer or slice in map case in " + tf.Name())
+ default: // E.g., map[K]V
+ mfi.merge = func(dst, src pointer) {
+ sm := src.asPointerTo(tf).Elem()
+ if sm.Len() == 0 {
+ return
+ }
+ dm := dst.asPointerTo(tf).Elem()
+ if dm.IsNil() {
+ dm.Set(reflect.MakeMap(tf))
+ }
+
+ switch tf.Elem().Kind() {
+ case reflect.Ptr: // Proto struct (e.g., *T)
+ for _, key := range sm.MapKeys() {
+ val := sm.MapIndex(key)
+ val = reflect.ValueOf(Clone(val.Interface().(Message)))
+ dm.SetMapIndex(key, val)
+ }
+ case reflect.Slice: // E.g. Bytes type (e.g., []byte)
+ for _, key := range sm.MapKeys() {
+ val := sm.MapIndex(key)
+ val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+ dm.SetMapIndex(key, val)
+ }
+ default: // Basic type (e.g., string)
+ for _, key := range sm.MapKeys() {
+ val := sm.MapIndex(key)
+ dm.SetMapIndex(key, val)
+ }
+ }
+ }
+ }
+ case reflect.Interface:
+ // Must be oneof field.
+ switch {
+ case isPointer || isSlice:
+ panic("bad pointer or slice in interface case in " + tf.Name())
+ default: // E.g., interface{}
+ // TODO: Make this faster?
+ mfi.merge = func(dst, src pointer) {
+ su := src.asPointerTo(tf).Elem()
+ if !su.IsNil() {
+ du := dst.asPointerTo(tf).Elem()
+ typ := su.Elem().Type()
+ if du.IsNil() || du.Elem().Type() != typ {
+ du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
+ }
+ sv := su.Elem().Elem().Field(0)
+ if sv.Kind() == reflect.Ptr && sv.IsNil() {
+ return
+ }
+ dv := du.Elem().Elem().Field(0)
+ if dv.Kind() == reflect.Ptr && dv.IsNil() {
+ dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
+ }
+ switch sv.Type().Kind() {
+ case reflect.Ptr: // Proto struct (e.g., *T)
+ Merge(dv.Interface().(Message), sv.Interface().(Message))
+ case reflect.Slice: // E.g. Bytes type (e.g., []byte)
+ dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
+ default: // Basic type (e.g., string)
+ dv.Set(sv)
+ }
+ }
+ }
+ }
+ default:
+ panic(fmt.Sprintf("merger not found for type:%s", tf))
+ }
+ mi.fields = append(mi.fields, mfi)
+ }
+
+ mi.unrecognized = invalidField
+ if f, ok := t.FieldByName("XXX_unrecognized"); ok {
+ if f.Type != reflect.TypeOf([]byte{}) {
+ panic("expected XXX_unrecognized to be of type []byte")
+ }
+ mi.unrecognized = toField(&f)
+ }
+
+ atomic.StoreInt32(&mi.initialized, 1)
+}
diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
new file mode 100644
index 0000000..acee2fc
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
@@ -0,0 +1,2053 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "math"
+ "reflect"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "unicode/utf8"
+)
+
+// Unmarshal is the entry point from the generated .pb.go files.
+// This function is not intended to be used by non-generated code.
+// This function is not subject to any compatibility guarantee.
+// msg contains a pointer to a protocol buffer struct.
+// b is the data to be unmarshaled into the protocol buffer.
+// a is a pointer to a place to store cached unmarshal information.
+func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {
+ // Load the unmarshal information for this message type.
+ // The atomic load ensures memory consistency.
+ u := atomicLoadUnmarshalInfo(&a.unmarshal)
+ if u == nil {
+ // Slow path: find unmarshal info for msg, update a with it.
+ u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())
+ atomicStoreUnmarshalInfo(&a.unmarshal, u)
+ }
+ // Then do the unmarshaling.
+ err := u.unmarshal(toPointer(&msg), b)
+ return err
+}
+
+type unmarshalInfo struct {
+ typ reflect.Type // type of the protobuf struct
+
+ // 0 = only typ field is initialized
+ // 1 = completely initialized
+ initialized int32
+ lock sync.Mutex // prevents double initialization
+ dense []unmarshalFieldInfo // fields indexed by tag #
+ sparse map[uint64]unmarshalFieldInfo // fields indexed by tag #
+ reqFields []string // names of required fields
+ reqMask uint64 // 1<<len(reqFields)-1
+ unrecognized field // offset of []byte to put unrecognized data (or invalidField if we should throw it away)
+ extensions field // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist
+ oldExtensions field // offset of old-form extensions field (of type map[int]Extension)
+ extensionRanges []ExtensionRange // if non-nil, implies extensions field is valid
+ isMessageSet bool // if true, implies extensions field is valid
+}
+
+// An unmarshaler takes a stream of bytes and a pointer to a field of a message.
+// It decodes the field, stores it at f, and returns the unused bytes.
+// w is the wire encoding.
+// b is the data after the tag and wire encoding have been read.
+type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
+
+type unmarshalFieldInfo struct {
+ // location of the field in the proto message structure.
+ field field
+
+ // function to unmarshal the data for the field.
+ unmarshal unmarshaler
+
+ // if a required field, contains a single set bit at this field's index in the required field list.
+ reqMask uint64
+
+ name string // name of the field, for error reporting
+}
+
+var (
+ unmarshalInfoMap = map[reflect.Type]*unmarshalInfo{}
+ unmarshalInfoLock sync.Mutex
+)
+
+// getUnmarshalInfo returns the data structure which can be
+// subsequently used to unmarshal a message of the given type.
+// t is the type of the message (note: not pointer to message).
+func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {
+ // It would be correct to return a new unmarshalInfo
+ // unconditionally. We would end up allocating one
+ // per occurrence of that type as a message or submessage.
+ // We use a cache here just to reduce memory usage.
+ unmarshalInfoLock.Lock()
+ defer unmarshalInfoLock.Unlock()
+ u := unmarshalInfoMap[t]
+ if u == nil {
+ u = &unmarshalInfo{typ: t}
+ // Note: we just set the type here. The rest of the fields
+ // will be initialized on first use.
+ unmarshalInfoMap[t] = u
+ }
+ return u
+}
+
+// unmarshal does the main work of unmarshaling a message.
+// u provides type information used to unmarshal the message.
+// m is a pointer to a protocol buffer message.
+// b is a byte stream to unmarshal into m.
+// This is top routine used when recursively unmarshaling submessages.
+func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
+ if atomic.LoadInt32(&u.initialized) == 0 {
+ u.computeUnmarshalInfo()
+ }
+ if u.isMessageSet {
+ return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
+ }
+ var reqMask uint64 // bitmask of required fields we've seen.
+ var errLater error
+ for len(b) > 0 {
+ // Read tag and wire type.
+ // Special case 1 and 2 byte varints.
+ var x uint64
+ if b[0] < 128 {
+ x = uint64(b[0])
+ b = b[1:]
+ } else if len(b) >= 2 && b[1] < 128 {
+ x = uint64(b[0]&0x7f) + uint64(b[1])<<7
+ b = b[2:]
+ } else {
+ var n int
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ }
+ tag := x >> 3
+ wire := int(x) & 7
+
+ // Dispatch on the tag to one of the unmarshal* functions below.
+ var f unmarshalFieldInfo
+ if tag < uint64(len(u.dense)) {
+ f = u.dense[tag]
+ } else {
+ f = u.sparse[tag]
+ }
+ if fn := f.unmarshal; fn != nil {
+ var err error
+ b, err = fn(b, m.offset(f.field), wire)
+ if err == nil {
+ reqMask |= f.reqMask
+ continue
+ }
+ if r, ok := err.(*RequiredNotSetError); ok {
+ // Remember this error, but keep parsing. We need to produce
+ // a full parse even if a required field is missing.
+ if errLater == nil {
+ errLater = r
+ }
+ reqMask |= f.reqMask
+ continue
+ }
+ if err != errInternalBadWireType {
+ if err == errInvalidUTF8 {
+ if errLater == nil {
+ fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
+ errLater = &invalidUTF8Error{fullName}
+ }
+ continue
+ }
+ return err
+ }
+ // Fragments with bad wire type are treated as unknown fields.
+ }
+
+ // Unknown tag.
+ if !u.unrecognized.IsValid() {
+ // Don't keep unrecognized data; just skip it.
+ var err error
+ b, err = skipField(b, wire)
+ if err != nil {
+ return err
+ }
+ continue
+ }
+ // Keep unrecognized data around.
+ // maybe in extensions, maybe in the unrecognized field.
+ z := m.offset(u.unrecognized).toBytes()
+ var emap map[int32]Extension
+ var e Extension
+ for _, r := range u.extensionRanges {
+ if uint64(r.Start) <= tag && tag <= uint64(r.End) {
+ if u.extensions.IsValid() {
+ mp := m.offset(u.extensions).toExtensions()
+ emap = mp.extensionsWrite()
+ e = emap[int32(tag)]
+ z = &e.enc
+ break
+ }
+ if u.oldExtensions.IsValid() {
+ p := m.offset(u.oldExtensions).toOldExtensions()
+ emap = *p
+ if emap == nil {
+ emap = map[int32]Extension{}
+ *p = emap
+ }
+ e = emap[int32(tag)]
+ z = &e.enc
+ break
+ }
+ panic("no extensions field available")
+ }
+ }
+
+ // Use wire type to skip data.
+ var err error
+ b0 := b
+ b, err = skipField(b, wire)
+ if err != nil {
+ return err
+ }
+ *z = encodeVarint(*z, tag<<3|uint64(wire))
+ *z = append(*z, b0[:len(b0)-len(b)]...)
+
+ if emap != nil {
+ emap[int32(tag)] = e
+ }
+ }
+ if reqMask != u.reqMask && errLater == nil {
+ // A required field of this message is missing.
+ for _, n := range u.reqFields {
+ if reqMask&1 == 0 {
+ errLater = &RequiredNotSetError{n}
+ }
+ reqMask >>= 1
+ }
+ }
+ return errLater
+}
+
+// computeUnmarshalInfo fills in u with information for use
+// in unmarshaling protocol buffers of type u.typ.
+func (u *unmarshalInfo) computeUnmarshalInfo() {
+ u.lock.Lock()
+ defer u.lock.Unlock()
+ if u.initialized != 0 {
+ return
+ }
+ t := u.typ
+ n := t.NumField()
+
+ // Set up the "not found" value for the unrecognized byte buffer.
+ // This is the default for proto3.
+ u.unrecognized = invalidField
+ u.extensions = invalidField
+ u.oldExtensions = invalidField
+
+ // List of the generated type and offset for each oneof field.
+ type oneofField struct {
+ ityp reflect.Type // interface type of oneof field
+ field field // offset in containing message
+ }
+ var oneofFields []oneofField
+
+ for i := 0; i < n; i++ {
+ f := t.Field(i)
+ if f.Name == "XXX_unrecognized" {
+ // The byte slice used to hold unrecognized input is special.
+ if f.Type != reflect.TypeOf(([]byte)(nil)) {
+ panic("bad type for XXX_unrecognized field: " + f.Type.Name())
+ }
+ u.unrecognized = toField(&f)
+ continue
+ }
+ if f.Name == "XXX_InternalExtensions" {
+ // Ditto here.
+ if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {
+ panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())
+ }
+ u.extensions = toField(&f)
+ if f.Tag.Get("protobuf_messageset") == "1" {
+ u.isMessageSet = true
+ }
+ continue
+ }
+ if f.Name == "XXX_extensions" {
+ // An older form of the extensions field.
+ if f.Type != reflect.TypeOf((map[int32]Extension)(nil)) {
+ panic("bad type for XXX_extensions field: " + f.Type.Name())
+ }
+ u.oldExtensions = toField(&f)
+ continue
+ }
+ if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {
+ continue
+ }
+
+ oneof := f.Tag.Get("protobuf_oneof")
+ if oneof != "" {
+ oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})
+ // The rest of oneof processing happens below.
+ continue
+ }
+
+ tags := f.Tag.Get("protobuf")
+ tagArray := strings.Split(tags, ",")
+ if len(tagArray) < 2 {
+ panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)
+ }
+ tag, err := strconv.Atoi(tagArray[1])
+ if err != nil {
+ panic("protobuf tag field not an integer: " + tagArray[1])
+ }
+
+ name := ""
+ for _, tag := range tagArray[3:] {
+ if strings.HasPrefix(tag, "name=") {
+ name = tag[5:]
+ }
+ }
+
+ // Extract unmarshaling function from the field (its type and tags).
+ unmarshal := fieldUnmarshaler(&f)
+
+ // Required field?
+ var reqMask uint64
+ if tagArray[2] == "req" {
+ bit := len(u.reqFields)
+ u.reqFields = append(u.reqFields, name)
+ reqMask = uint64(1) << uint(bit)
+ // TODO: if we have more than 64 required fields, we end up
+ // not verifying that all required fields are present.
+ // Fix this, perhaps using a count of required fields?
+ }
+
+ // Store the info in the correct slot in the message.
+ u.setTag(tag, toField(&f), unmarshal, reqMask, name)
+ }
+
+ // Find any types associated with oneof fields.
+ var oneofImplementers []interface{}
+ switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+ case oneofFuncsIface:
+ _, _, _, oneofImplementers = m.XXX_OneofFuncs()
+ case oneofWrappersIface:
+ oneofImplementers = m.XXX_OneofWrappers()
+ }
+ for _, v := range oneofImplementers {
+ tptr := reflect.TypeOf(v) // *Msg_X
+ typ := tptr.Elem() // Msg_X
+
+ f := typ.Field(0) // oneof implementers have one field
+ baseUnmarshal := fieldUnmarshaler(&f)
+ tags := strings.Split(f.Tag.Get("protobuf"), ",")
+ fieldNum, err := strconv.Atoi(tags[1])
+ if err != nil {
+ panic("protobuf tag field not an integer: " + tags[1])
+ }
+ var name string
+ for _, tag := range tags {
+ if strings.HasPrefix(tag, "name=") {
+ name = strings.TrimPrefix(tag, "name=")
+ break
+ }
+ }
+
+ // Find the oneof field that this struct implements.
+ // Might take O(n^2) to process all of the oneofs, but who cares.
+ for _, of := range oneofFields {
+ if tptr.Implements(of.ityp) {
+ // We have found the corresponding interface for this struct.
+ // That lets us know where this struct should be stored
+ // when we encounter it during unmarshaling.
+ unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
+ u.setTag(fieldNum, of.field, unmarshal, 0, name)
+ }
+ }
+
+ }
+
+ // Get extension ranges, if any.
+ fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
+ if fn.IsValid() {
+ if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
+ panic("a message with extensions, but no extensions field in " + t.Name())
+ }
+ u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
+ }
+
+ // Explicitly disallow tag 0. This will ensure we flag an error
+ // when decoding a buffer of all zeros. Without this code, we
+ // would decode and skip an all-zero buffer of even length.
+ // [0 0] is [tag=0/wiretype=varint varint-encoded-0].
+ u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
+ return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
+ }, 0, "")
+
+ // Set mask for required field check.
+ u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
+
+ atomic.StoreInt32(&u.initialized, 1)
+}
+
+// setTag stores the unmarshal information for the given tag.
+// tag = tag # for field
+// field/unmarshal = unmarshal info for that field.
+// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
+// name = short name of the field.
+func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
+ i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
+ n := u.typ.NumField()
+ if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
+ for len(u.dense) <= tag {
+ u.dense = append(u.dense, unmarshalFieldInfo{})
+ }
+ u.dense[tag] = i
+ return
+ }
+ if u.sparse == nil {
+ u.sparse = map[uint64]unmarshalFieldInfo{}
+ }
+ u.sparse[uint64(tag)] = i
+}
+
+// fieldUnmarshaler returns an unmarshaler for the given field.
+func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
+ if f.Type.Kind() == reflect.Map {
+ return makeUnmarshalMap(f)
+ }
+ return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
+}
+
+// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
+func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
+ tagArray := strings.Split(tags, ",")
+ encoding := tagArray[0]
+ name := "unknown"
+ proto3 := false
+ validateUTF8 := true
+ for _, tag := range tagArray[3:] {
+ if strings.HasPrefix(tag, "name=") {
+ name = tag[5:]
+ }
+ if tag == "proto3" {
+ proto3 = true
+ }
+ }
+ validateUTF8 = validateUTF8 && proto3
+
+ // Figure out packaging (pointer, slice, or both)
+ slice := false
+ pointer := false
+ if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+ slice = true
+ t = t.Elem()
+ }
+ if t.Kind() == reflect.Ptr {
+ pointer = true
+ t = t.Elem()
+ }
+
+ // We'll never have both pointer and slice for basic types.
+ if pointer && slice && t.Kind() != reflect.Struct {
+ panic("both pointer and slice for basic type in " + t.Name())
+ }
+
+ switch t.Kind() {
+ case reflect.Bool:
+ if pointer {
+ return unmarshalBoolPtr
+ }
+ if slice {
+ return unmarshalBoolSlice
+ }
+ return unmarshalBoolValue
+ case reflect.Int32:
+ switch encoding {
+ case "fixed32":
+ if pointer {
+ return unmarshalFixedS32Ptr
+ }
+ if slice {
+ return unmarshalFixedS32Slice
+ }
+ return unmarshalFixedS32Value
+ case "varint":
+ // this could be int32 or enum
+ if pointer {
+ return unmarshalInt32Ptr
+ }
+ if slice {
+ return unmarshalInt32Slice
+ }
+ return unmarshalInt32Value
+ case "zigzag32":
+ if pointer {
+ return unmarshalSint32Ptr
+ }
+ if slice {
+ return unmarshalSint32Slice
+ }
+ return unmarshalSint32Value
+ }
+ case reflect.Int64:
+ switch encoding {
+ case "fixed64":
+ if pointer {
+ return unmarshalFixedS64Ptr
+ }
+ if slice {
+ return unmarshalFixedS64Slice
+ }
+ return unmarshalFixedS64Value
+ case "varint":
+ if pointer {
+ return unmarshalInt64Ptr
+ }
+ if slice {
+ return unmarshalInt64Slice
+ }
+ return unmarshalInt64Value
+ case "zigzag64":
+ if pointer {
+ return unmarshalSint64Ptr
+ }
+ if slice {
+ return unmarshalSint64Slice
+ }
+ return unmarshalSint64Value
+ }
+ case reflect.Uint32:
+ switch encoding {
+ case "fixed32":
+ if pointer {
+ return unmarshalFixed32Ptr
+ }
+ if slice {
+ return unmarshalFixed32Slice
+ }
+ return unmarshalFixed32Value
+ case "varint":
+ if pointer {
+ return unmarshalUint32Ptr
+ }
+ if slice {
+ return unmarshalUint32Slice
+ }
+ return unmarshalUint32Value
+ }
+ case reflect.Uint64:
+ switch encoding {
+ case "fixed64":
+ if pointer {
+ return unmarshalFixed64Ptr
+ }
+ if slice {
+ return unmarshalFixed64Slice
+ }
+ return unmarshalFixed64Value
+ case "varint":
+ if pointer {
+ return unmarshalUint64Ptr
+ }
+ if slice {
+ return unmarshalUint64Slice
+ }
+ return unmarshalUint64Value
+ }
+ case reflect.Float32:
+ if pointer {
+ return unmarshalFloat32Ptr
+ }
+ if slice {
+ return unmarshalFloat32Slice
+ }
+ return unmarshalFloat32Value
+ case reflect.Float64:
+ if pointer {
+ return unmarshalFloat64Ptr
+ }
+ if slice {
+ return unmarshalFloat64Slice
+ }
+ return unmarshalFloat64Value
+ case reflect.Map:
+ panic("map type in typeUnmarshaler in " + t.Name())
+ case reflect.Slice:
+ if pointer {
+ panic("bad pointer in slice case in " + t.Name())
+ }
+ if slice {
+ return unmarshalBytesSlice
+ }
+ return unmarshalBytesValue
+ case reflect.String:
+ if validateUTF8 {
+ if pointer {
+ return unmarshalUTF8StringPtr
+ }
+ if slice {
+ return unmarshalUTF8StringSlice
+ }
+ return unmarshalUTF8StringValue
+ }
+ if pointer {
+ return unmarshalStringPtr
+ }
+ if slice {
+ return unmarshalStringSlice
+ }
+ return unmarshalStringValue
+ case reflect.Struct:
+ // message or group field
+ if !pointer {
+ panic(fmt.Sprintf("message/group field %s:%s without pointer", t, encoding))
+ }
+ switch encoding {
+ case "bytes":
+ if slice {
+ return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
+ }
+ return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
+ case "group":
+ if slice {
+ return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
+ }
+ return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
+ }
+ }
+ panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
+}
+
+// Below are all the unmarshalers for individual fields of various types.
+
+func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x)
+ *f.toInt64() = v
+ return b, nil
+}
+
+func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x)
+ *f.toInt64Ptr() = &v
+ return b, nil
+}
+
+func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x)
+ s := f.toInt64Slice()
+ *s = append(*s, v)
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x)
+ s := f.toInt64Slice()
+ *s = append(*s, v)
+ return b, nil
+}
+
+func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x>>1) ^ int64(x)<<63>>63
+ *f.toInt64() = v
+ return b, nil
+}
+
+func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x>>1) ^ int64(x)<<63>>63
+ *f.toInt64Ptr() = &v
+ return b, nil
+}
+
+func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x>>1) ^ int64(x)<<63>>63
+ s := f.toInt64Slice()
+ *s = append(*s, v)
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int64(x>>1) ^ int64(x)<<63>>63
+ s := f.toInt64Slice()
+ *s = append(*s, v)
+ return b, nil
+}
+
+func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint64(x)
+ *f.toUint64() = v
+ return b, nil
+}
+
+func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint64(x)
+ *f.toUint64Ptr() = &v
+ return b, nil
+}
+
+func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint64(x)
+ s := f.toUint64Slice()
+ *s = append(*s, v)
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint64(x)
+ s := f.toUint64Slice()
+ *s = append(*s, v)
+ return b, nil
+}
+
+func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x)
+ *f.toInt32() = v
+ return b, nil
+}
+
+func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x)
+ f.setInt32Ptr(v)
+ return b, nil
+}
+
+func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x)
+ f.appendInt32Slice(v)
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x)
+ f.appendInt32Slice(v)
+ return b, nil
+}
+
+func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x>>1) ^ int32(x)<<31>>31
+ *f.toInt32() = v
+ return b, nil
+}
+
+func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x>>1) ^ int32(x)<<31>>31
+ f.setInt32Ptr(v)
+ return b, nil
+}
+
+func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x>>1) ^ int32(x)<<31>>31
+ f.appendInt32Slice(v)
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := int32(x>>1) ^ int32(x)<<31>>31
+ f.appendInt32Slice(v)
+ return b, nil
+}
+
+func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint32(x)
+ *f.toUint32() = v
+ return b, nil
+}
+
+func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint32(x)
+ *f.toUint32Ptr() = &v
+ return b, nil
+}
+
+func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint32(x)
+ s := f.toUint32Slice()
+ *s = append(*s, v)
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ v := uint32(x)
+ s := f.toUint32Slice()
+ *s = append(*s, v)
+ return b, nil
+}
+
+func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+ *f.toUint64() = v
+ return b[8:], nil
+}
+
+func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+ *f.toUint64Ptr() = &v
+ return b[8:], nil
+}
+
+func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+ s := f.toUint64Slice()
+ *s = append(*s, v)
+ b = b[8:]
+ }
+ return res, nil
+ }
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+ s := f.toUint64Slice()
+ *s = append(*s, v)
+ return b[8:], nil
+}
+
+func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+ *f.toInt64() = v
+ return b[8:], nil
+}
+
+func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+ *f.toInt64Ptr() = &v
+ return b[8:], nil
+}
+
+func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+ s := f.toInt64Slice()
+ *s = append(*s, v)
+ b = b[8:]
+ }
+ return res, nil
+ }
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+ s := f.toInt64Slice()
+ *s = append(*s, v)
+ return b[8:], nil
+}
+
+func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+ *f.toUint32() = v
+ return b[4:], nil
+}
+
+func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+ *f.toUint32Ptr() = &v
+ return b[4:], nil
+}
+
+func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+ s := f.toUint32Slice()
+ *s = append(*s, v)
+ b = b[4:]
+ }
+ return res, nil
+ }
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+ s := f.toUint32Slice()
+ *s = append(*s, v)
+ return b[4:], nil
+}
+
+func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+ *f.toInt32() = v
+ return b[4:], nil
+}
+
+func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+ f.setInt32Ptr(v)
+ return b[4:], nil
+}
+
+func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+ f.appendInt32Slice(v)
+ b = b[4:]
+ }
+ return res, nil
+ }
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+ f.appendInt32Slice(v)
+ return b[4:], nil
+}
+
+func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ // Note: any length varint is allowed, even though any sane
+ // encoder will use one byte.
+ // See https://github.com/golang/protobuf/issues/76
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ // TODO: check if x>1? Tests seem to indicate no.
+ v := x != 0
+ *f.toBool() = v
+ return b[n:], nil
+}
+
+func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := x != 0
+ *f.toBoolPtr() = &v
+ return b[n:], nil
+}
+
+func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ x, n = decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := x != 0
+ s := f.toBoolSlice()
+ *s = append(*s, v)
+ b = b[n:]
+ }
+ return res, nil
+ }
+ if w != WireVarint {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := x != 0
+ s := f.toBoolSlice()
+ *s = append(*s, v)
+ return b[n:], nil
+}
+
+func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+ *f.toFloat64() = v
+ return b[8:], nil
+}
+
+func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+ *f.toFloat64Ptr() = &v
+ return b[8:], nil
+}
+
+func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+ s := f.toFloat64Slice()
+ *s = append(*s, v)
+ b = b[8:]
+ }
+ return res, nil
+ }
+ if w != WireFixed64 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 8 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+ s := f.toFloat64Slice()
+ *s = append(*s, v)
+ return b[8:], nil
+}
+
+func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+ *f.toFloat32() = v
+ return b[4:], nil
+}
+
+func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+ *f.toFloat32Ptr() = &v
+ return b[4:], nil
+}
+
+func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
+ if w == WireBytes { // packed
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ res := b[x:]
+ b = b[:x]
+ for len(b) > 0 {
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+ s := f.toFloat32Slice()
+ *s = append(*s, v)
+ b = b[4:]
+ }
+ return res, nil
+ }
+ if w != WireFixed32 {
+ return b, errInternalBadWireType
+ }
+ if len(b) < 4 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+ s := f.toFloat32Slice()
+ *s = append(*s, v)
+ return b[4:], nil
+}
+
+func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := string(b[:x])
+ *f.toString() = v
+ return b[x:], nil
+}
+
+func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := string(b[:x])
+ *f.toStringPtr() = &v
+ return b[x:], nil
+}
+
+func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := string(b[:x])
+ s := f.toStringSlice()
+ *s = append(*s, v)
+ return b[x:], nil
+}
+
+func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := string(b[:x])
+ *f.toString() = v
+ if !utf8.ValidString(v) {
+ return b[x:], errInvalidUTF8
+ }
+ return b[x:], nil
+}
+
+func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := string(b[:x])
+ *f.toStringPtr() = &v
+ if !utf8.ValidString(v) {
+ return b[x:], errInvalidUTF8
+ }
+ return b[x:], nil
+}
+
+func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := string(b[:x])
+ s := f.toStringSlice()
+ *s = append(*s, v)
+ if !utf8.ValidString(v) {
+ return b[x:], errInvalidUTF8
+ }
+ return b[x:], nil
+}
+
+var emptyBuf [0]byte
+
+func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ // The use of append here is a trick which avoids the zeroing
+ // that would be required if we used a make/copy pair.
+ // We append to emptyBuf instead of nil because we want
+ // a non-nil result even when the length is 0.
+ v := append(emptyBuf[:], b[:x]...)
+ *f.toBytes() = v
+ return b[x:], nil
+}
+
+func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := append(emptyBuf[:], b[:x]...)
+ s := f.toBytesSlice()
+ *s = append(*s, v)
+ return b[x:], nil
+}
+
+func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
+ return func(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ // First read the message field to see if something is there.
+ // The semantics of multiple submessages are weird. Instead of
+ // the last one winning (as it is for all other fields), multiple
+ // submessages are merged.
+ v := f.getPointer()
+ if v.isNil() {
+ v = valToPointer(reflect.New(sub.typ))
+ f.setPointer(v)
+ }
+ err := sub.unmarshal(v, b[:x])
+ if err != nil {
+ if r, ok := err.(*RequiredNotSetError); ok {
+ r.field = name + "." + r.field
+ } else {
+ return nil, err
+ }
+ }
+ return b[x:], err
+ }
+}
+
+func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
+ return func(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireBytes {
+ return b, errInternalBadWireType
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := valToPointer(reflect.New(sub.typ))
+ err := sub.unmarshal(v, b[:x])
+ if err != nil {
+ if r, ok := err.(*RequiredNotSetError); ok {
+ r.field = name + "." + r.field
+ } else {
+ return nil, err
+ }
+ }
+ f.appendPointer(v)
+ return b[x:], err
+ }
+}
+
+func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
+ return func(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireStartGroup {
+ return b, errInternalBadWireType
+ }
+ x, y := findEndGroup(b)
+ if x < 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := f.getPointer()
+ if v.isNil() {
+ v = valToPointer(reflect.New(sub.typ))
+ f.setPointer(v)
+ }
+ err := sub.unmarshal(v, b[:x])
+ if err != nil {
+ if r, ok := err.(*RequiredNotSetError); ok {
+ r.field = name + "." + r.field
+ } else {
+ return nil, err
+ }
+ }
+ return b[y:], err
+ }
+}
+
+func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
+ return func(b []byte, f pointer, w int) ([]byte, error) {
+ if w != WireStartGroup {
+ return b, errInternalBadWireType
+ }
+ x, y := findEndGroup(b)
+ if x < 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ v := valToPointer(reflect.New(sub.typ))
+ err := sub.unmarshal(v, b[:x])
+ if err != nil {
+ if r, ok := err.(*RequiredNotSetError); ok {
+ r.field = name + "." + r.field
+ } else {
+ return nil, err
+ }
+ }
+ f.appendPointer(v)
+ return b[y:], err
+ }
+}
+
+func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
+ t := f.Type
+ kt := t.Key()
+ vt := t.Elem()
+ unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
+ unmarshalVal := typeUnmarshaler(vt, f.Tag.Get("protobuf_val"))
+ return func(b []byte, f pointer, w int) ([]byte, error) {
+ // The map entry is a submessage. Figure out how big it is.
+ if w != WireBytes {
+ return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
+ }
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ b = b[n:]
+ if x > uint64(len(b)) {
+ return nil, io.ErrUnexpectedEOF
+ }
+ r := b[x:] // unused data to return
+ b = b[:x] // data for map entry
+
+ // Note: we could use #keys * #values ~= 200 functions
+ // to do map decoding without reflection. Probably not worth it.
+ // Maps will be somewhat slow. Oh well.
+
+ // Read key and value from data.
+ var nerr nonFatal
+ k := reflect.New(kt)
+ v := reflect.New(vt)
+ for len(b) > 0 {
+ x, n := decodeVarint(b)
+ if n == 0 {
+ return nil, io.ErrUnexpectedEOF
+ }
+ wire := int(x) & 7
+ b = b[n:]
+
+ var err error
+ switch x >> 3 {
+ case 1:
+ b, err = unmarshalKey(b, valToPointer(k), wire)
+ case 2:
+ b, err = unmarshalVal(b, valToPointer(v), wire)
+ default:
+ err = errInternalBadWireType // skip unknown tag
+ }
+
+ if nerr.Merge(err) {
+ continue
+ }
+ if err != errInternalBadWireType {
+ return nil, err
+ }
+
+ // Skip past unknown fields.
+ b, err = skipField(b, wire)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ // Get map, allocate if needed.
+ m := f.asPointerTo(t).Elem() // an addressable map[K]T
+ if m.IsNil() {
+ m.Set(reflect.MakeMap(t))
+ }
+
+ // Insert into map.
+ m.SetMapIndex(k.Elem(), v.Elem())
+
+ return r, nerr.E
+ }
+}
+
+// makeUnmarshalOneof makes an unmarshaler for oneof fields.
+// for:
+// message Msg {
+// oneof F {
+// int64 X = 1;
+// float64 Y = 2;
+// }
+// }
+// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
+// ityp is the interface type of the oneof field (e.g. isMsg_F).
+// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
+// Note that this function will be called once for each case in the oneof.
+func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
+ sf := typ.Field(0)
+ field0 := toField(&sf)
+ return func(b []byte, f pointer, w int) ([]byte, error) {
+ // Allocate holder for value.
+ v := reflect.New(typ)
+
+ // Unmarshal data into holder.
+ // We unmarshal into the first field of the holder object.
+ var err error
+ var nerr nonFatal
+ b, err = unmarshal(b, valToPointer(v).offset(field0), w)
+ if !nerr.Merge(err) {
+ return nil, err
+ }
+
+ // Write pointer to holder into target field.
+ f.asPointerTo(ityp).Elem().Set(v)
+
+ return b, nerr.E
+ }
+}
+
+// Error used by decode internally.
+var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
+
+// skipField skips past a field of type wire and returns the remaining bytes.
+func skipField(b []byte, wire int) ([]byte, error) {
+ switch wire {
+ case WireVarint:
+ _, k := decodeVarint(b)
+ if k == 0 {
+ return b, io.ErrUnexpectedEOF
+ }
+ b = b[k:]
+ case WireFixed32:
+ if len(b) < 4 {
+ return b, io.ErrUnexpectedEOF
+ }
+ b = b[4:]
+ case WireFixed64:
+ if len(b) < 8 {
+ return b, io.ErrUnexpectedEOF
+ }
+ b = b[8:]
+ case WireBytes:
+ m, k := decodeVarint(b)
+ if k == 0 || uint64(len(b)-k) < m {
+ return b, io.ErrUnexpectedEOF
+ }
+ b = b[uint64(k)+m:]
+ case WireStartGroup:
+ _, i := findEndGroup(b)
+ if i == -1 {
+ return b, io.ErrUnexpectedEOF
+ }
+ b = b[i:]
+ default:
+ return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
+ }
+ return b, nil
+}
+
+// findEndGroup finds the index of the next EndGroup tag.
+// Groups may be nested, so the "next" EndGroup tag is the first
+// unpaired EndGroup.
+// findEndGroup returns the indexes of the start and end of the EndGroup tag.
+// Returns (-1,-1) if it can't find one.
+func findEndGroup(b []byte) (int, int) {
+ depth := 1
+ i := 0
+ for {
+ x, n := decodeVarint(b[i:])
+ if n == 0 {
+ return -1, -1
+ }
+ j := i
+ i += n
+ switch x & 7 {
+ case WireVarint:
+ _, k := decodeVarint(b[i:])
+ if k == 0 {
+ return -1, -1
+ }
+ i += k
+ case WireFixed32:
+ if len(b)-4 < i {
+ return -1, -1
+ }
+ i += 4
+ case WireFixed64:
+ if len(b)-8 < i {
+ return -1, -1
+ }
+ i += 8
+ case WireBytes:
+ m, k := decodeVarint(b[i:])
+ if k == 0 {
+ return -1, -1
+ }
+ i += k
+ if uint64(len(b)-i) < m {
+ return -1, -1
+ }
+ i += int(m)
+ case WireStartGroup:
+ depth++
+ case WireEndGroup:
+ depth--
+ if depth == 0 {
+ return j, i
+ }
+ default:
+ return -1, -1
+ }
+ }
+}
+
+// encodeVarint appends a varint-encoded integer to b and returns the result.
+func encodeVarint(b []byte, x uint64) []byte {
+ for x >= 1<<7 {
+ b = append(b, byte(x&0x7f|0x80))
+ x >>= 7
+ }
+ return append(b, byte(x))
+}
+
+// decodeVarint reads a varint-encoded integer from b.
+// Returns the decoded integer and the number of bytes read.
+// If there is an error, it returns 0,0.
+func decodeVarint(b []byte) (uint64, int) {
+ var x, y uint64
+ if len(b) == 0 {
+ goto bad
+ }
+ x = uint64(b[0])
+ if x < 0x80 {
+ return x, 1
+ }
+ x -= 0x80
+
+ if len(b) <= 1 {
+ goto bad
+ }
+ y = uint64(b[1])
+ x += y << 7
+ if y < 0x80 {
+ return x, 2
+ }
+ x -= 0x80 << 7
+
+ if len(b) <= 2 {
+ goto bad
+ }
+ y = uint64(b[2])
+ x += y << 14
+ if y < 0x80 {
+ return x, 3
+ }
+ x -= 0x80 << 14
+
+ if len(b) <= 3 {
+ goto bad
+ }
+ y = uint64(b[3])
+ x += y << 21
+ if y < 0x80 {
+ return x, 4
+ }
+ x -= 0x80 << 21
+
+ if len(b) <= 4 {
+ goto bad
+ }
+ y = uint64(b[4])
+ x += y << 28
+ if y < 0x80 {
+ return x, 5
+ }
+ x -= 0x80 << 28
+
+ if len(b) <= 5 {
+ goto bad
+ }
+ y = uint64(b[5])
+ x += y << 35
+ if y < 0x80 {
+ return x, 6
+ }
+ x -= 0x80 << 35
+
+ if len(b) <= 6 {
+ goto bad
+ }
+ y = uint64(b[6])
+ x += y << 42
+ if y < 0x80 {
+ return x, 7
+ }
+ x -= 0x80 << 42
+
+ if len(b) <= 7 {
+ goto bad
+ }
+ y = uint64(b[7])
+ x += y << 49
+ if y < 0x80 {
+ return x, 8
+ }
+ x -= 0x80 << 49
+
+ if len(b) <= 8 {
+ goto bad
+ }
+ y = uint64(b[8])
+ x += y << 56
+ if y < 0x80 {
+ return x, 9
+ }
+ x -= 0x80 << 56
+
+ if len(b) <= 9 {
+ goto bad
+ }
+ y = uint64(b[9])
+ x += y << 63
+ if y < 2 {
+ return x, 10
+ }
+
+bad:
+ return 0, 0
+}
diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go
new file mode 100644
index 0000000..1aaee72
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text.go
@@ -0,0 +1,843 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+// Functions for writing the text protocol buffer format.
+
+import (
+ "bufio"
+ "bytes"
+ "encoding"
+ "errors"
+ "fmt"
+ "io"
+ "log"
+ "math"
+ "reflect"
+ "sort"
+ "strings"
+)
+
+var (
+ newline = []byte("\n")
+ spaces = []byte(" ")
+ endBraceNewline = []byte("}\n")
+ backslashN = []byte{'\\', 'n'}
+ backslashR = []byte{'\\', 'r'}
+ backslashT = []byte{'\\', 't'}
+ backslashDQ = []byte{'\\', '"'}
+ backslashBS = []byte{'\\', '\\'}
+ posInf = []byte("inf")
+ negInf = []byte("-inf")
+ nan = []byte("nan")
+)
+
+type writer interface {
+ io.Writer
+ WriteByte(byte) error
+}
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+ ind int
+ complete bool // if the current position is a complete line
+ compact bool // whether to write out as a one-liner
+ w writer
+}
+
+func (w *textWriter) WriteString(s string) (n int, err error) {
+ if !strings.Contains(s, "\n") {
+ if !w.compact && w.complete {
+ w.writeIndent()
+ }
+ w.complete = false
+ return io.WriteString(w.w, s)
+ }
+ // WriteString is typically called without newlines, so this
+ // codepath and its copy are rare. We copy to avoid
+ // duplicating all of Write's logic here.
+ return w.Write([]byte(s))
+}
+
+func (w *textWriter) Write(p []byte) (n int, err error) {
+ newlines := bytes.Count(p, newline)
+ if newlines == 0 {
+ if !w.compact && w.complete {
+ w.writeIndent()
+ }
+ n, err = w.w.Write(p)
+ w.complete = false
+ return n, err
+ }
+
+ frags := bytes.SplitN(p, newline, newlines+1)
+ if w.compact {
+ for i, frag := range frags {
+ if i > 0 {
+ if err := w.w.WriteByte(' '); err != nil {
+ return n, err
+ }
+ n++
+ }
+ nn, err := w.w.Write(frag)
+ n += nn
+ if err != nil {
+ return n, err
+ }
+ }
+ return n, nil
+ }
+
+ for i, frag := range frags {
+ if w.complete {
+ w.writeIndent()
+ }
+ nn, err := w.w.Write(frag)
+ n += nn
+ if err != nil {
+ return n, err
+ }
+ if i+1 < len(frags) {
+ if err := w.w.WriteByte('\n'); err != nil {
+ return n, err
+ }
+ n++
+ }
+ }
+ w.complete = len(frags[len(frags)-1]) == 0
+ return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+ if w.compact && c == '\n' {
+ c = ' '
+ }
+ if !w.compact && w.complete {
+ w.writeIndent()
+ }
+ err := w.w.WriteByte(c)
+ w.complete = c == '\n'
+ return err
+}
+
+func (w *textWriter) indent() { w.ind++ }
+
+func (w *textWriter) unindent() {
+ if w.ind == 0 {
+ log.Print("proto: textWriter unindented too far")
+ return
+ }
+ w.ind--
+}
+
+func writeName(w *textWriter, props *Properties) error {
+ if _, err := w.WriteString(props.OrigName); err != nil {
+ return err
+ }
+ if props.Wire != "group" {
+ return w.WriteByte(':')
+ }
+ return nil
+}
+
+func requiresQuotes(u string) bool {
+ // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
+ for _, ch := range u {
+ switch {
+ case ch == '.' || ch == '/' || ch == '_':
+ continue
+ case '0' <= ch && ch <= '9':
+ continue
+ case 'A' <= ch && ch <= 'Z':
+ continue
+ case 'a' <= ch && ch <= 'z':
+ continue
+ default:
+ return true
+ }
+ }
+ return false
+}
+
+// isAny reports whether sv is a google.protobuf.Any message
+func isAny(sv reflect.Value) bool {
+ type wkt interface {
+ XXX_WellKnownType() string
+ }
+ t, ok := sv.Addr().Interface().(wkt)
+ return ok && t.XXX_WellKnownType() == "Any"
+}
+
+// writeProto3Any writes an expanded google.protobuf.Any message.
+//
+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
+// required messages are not linked in).
+//
+// It returns (true, error) when sv was written in expanded format or an error
+// was encountered.
+func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
+ turl := sv.FieldByName("TypeUrl")
+ val := sv.FieldByName("Value")
+ if !turl.IsValid() || !val.IsValid() {
+ return true, errors.New("proto: invalid google.protobuf.Any message")
+ }
+
+ b, ok := val.Interface().([]byte)
+ if !ok {
+ return true, errors.New("proto: invalid google.protobuf.Any message")
+ }
+
+ parts := strings.Split(turl.String(), "/")
+ mt := MessageType(parts[len(parts)-1])
+ if mt == nil {
+ return false, nil
+ }
+ m := reflect.New(mt.Elem())
+ if err := Unmarshal(b, m.Interface().(Message)); err != nil {
+ return false, nil
+ }
+ w.Write([]byte("["))
+ u := turl.String()
+ if requiresQuotes(u) {
+ writeString(w, u)
+ } else {
+ w.Write([]byte(u))
+ }
+ if w.compact {
+ w.Write([]byte("]:<"))
+ } else {
+ w.Write([]byte("]: <\n"))
+ w.ind++
+ }
+ if err := tm.writeStruct(w, m.Elem()); err != nil {
+ return true, err
+ }
+ if w.compact {
+ w.Write([]byte("> "))
+ } else {
+ w.ind--
+ w.Write([]byte(">\n"))
+ }
+ return true, nil
+}
+
+func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
+ if tm.ExpandAny && isAny(sv) {
+ if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
+ return err
+ }
+ }
+ st := sv.Type()
+ sprops := GetProperties(st)
+ for i := 0; i < sv.NumField(); i++ {
+ fv := sv.Field(i)
+ props := sprops.Prop[i]
+ name := st.Field(i).Name
+
+ if name == "XXX_NoUnkeyedLiteral" {
+ continue
+ }
+
+ if strings.HasPrefix(name, "XXX_") {
+ // There are two XXX_ fields:
+ // XXX_unrecognized []byte
+ // XXX_extensions map[int32]proto.Extension
+ // The first is handled here;
+ // the second is handled at the bottom of this function.
+ if name == "XXX_unrecognized" && !fv.IsNil() {
+ if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
+ return err
+ }
+ }
+ continue
+ }
+ if fv.Kind() == reflect.Ptr && fv.IsNil() {
+ // Field not filled in. This could be an optional field or
+ // a required field that wasn't filled in. Either way, there
+ // isn't anything we can show for it.
+ continue
+ }
+ if fv.Kind() == reflect.Slice && fv.IsNil() {
+ // Repeated field that is empty, or a bytes field that is unused.
+ continue
+ }
+
+ if props.Repeated && fv.Kind() == reflect.Slice {
+ // Repeated field.
+ for j := 0; j < fv.Len(); j++ {
+ if err := writeName(w, props); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ v := fv.Index(j)
+ if v.Kind() == reflect.Ptr && v.IsNil() {
+ // A nil message in a repeated field is not valid,
+ // but we can handle that more gracefully than panicking.
+ if _, err := w.Write([]byte("<nil>\n")); err != nil {
+ return err
+ }
+ continue
+ }
+ if err := tm.writeAny(w, v, props); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ continue
+ }
+ if fv.Kind() == reflect.Map {
+ // Map fields are rendered as a repeated struct with key/value fields.
+ keys := fv.MapKeys()
+ sort.Sort(mapKeys(keys))
+ for _, key := range keys {
+ val := fv.MapIndex(key)
+ if err := writeName(w, props); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ // open struct
+ if err := w.WriteByte('<'); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ w.indent()
+ // key
+ if _, err := w.WriteString("key:"); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ // nil values aren't legal, but we can avoid panicking because of them.
+ if val.Kind() != reflect.Ptr || !val.IsNil() {
+ // value
+ if _, err := w.WriteString("value:"); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if err := tm.writeAny(w, val, props.MapValProp); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ // close struct
+ w.unindent()
+ if err := w.WriteByte('>'); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ continue
+ }
+ if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
+ // empty bytes field
+ continue
+ }
+ if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+ // proto3 non-repeated scalar field; skip if zero value
+ if isProto3Zero(fv) {
+ continue
+ }
+ }
+
+ if fv.Kind() == reflect.Interface {
+ // Check if it is a oneof.
+ if st.Field(i).Tag.Get("protobuf_oneof") != "" {
+ // fv is nil, or holds a pointer to generated struct.
+ // That generated struct has exactly one field,
+ // which has a protobuf struct tag.
+ if fv.IsNil() {
+ continue
+ }
+ inner := fv.Elem().Elem() // interface -> *T -> T
+ tag := inner.Type().Field(0).Tag.Get("protobuf")
+ props = new(Properties) // Overwrite the outer props var, but not its pointee.
+ props.Parse(tag)
+ // Write the value in the oneof, not the oneof itself.
+ fv = inner.Field(0)
+
+ // Special case to cope with malformed messages gracefully:
+ // If the value in the oneof is a nil pointer, don't panic
+ // in writeAny.
+ if fv.Kind() == reflect.Ptr && fv.IsNil() {
+ // Use errors.New so writeAny won't render quotes.
+ msg := errors.New("/* nil */")
+ fv = reflect.ValueOf(&msg).Elem()
+ }
+ }
+ }
+
+ if err := writeName(w, props); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+
+ // Enums have a String method, so writeAny will work fine.
+ if err := tm.writeAny(w, fv, props); err != nil {
+ return err
+ }
+
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+
+ // Extensions (the XXX_extensions field).
+ pv := sv.Addr()
+ if _, err := extendable(pv.Interface()); err == nil {
+ if err := tm.writeExtensions(w, pv); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// writeAny writes an arbitrary field.
+func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
+ v = reflect.Indirect(v)
+
+ // Floats have special cases.
+ if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+ x := v.Float()
+ var b []byte
+ switch {
+ case math.IsInf(x, 1):
+ b = posInf
+ case math.IsInf(x, -1):
+ b = negInf
+ case math.IsNaN(x):
+ b = nan
+ }
+ if b != nil {
+ _, err := w.Write(b)
+ return err
+ }
+ // Other values are handled below.
+ }
+
+ // We don't attempt to serialise every possible value type; only those
+ // that can occur in protocol buffers.
+ switch v.Kind() {
+ case reflect.Slice:
+ // Should only be a []byte; repeated fields are handled in writeStruct.
+ if err := writeString(w, string(v.Bytes())); err != nil {
+ return err
+ }
+ case reflect.String:
+ if err := writeString(w, v.String()); err != nil {
+ return err
+ }
+ case reflect.Struct:
+ // Required/optional group/message.
+ var bra, ket byte = '<', '>'
+ if props != nil && props.Wire == "group" {
+ bra, ket = '{', '}'
+ }
+ if err := w.WriteByte(bra); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ w.indent()
+ if v.CanAddr() {
+ // Calling v.Interface on a struct causes the reflect package to
+ // copy the entire struct. This is racy with the new Marshaler
+ // since we atomically update the XXX_sizecache.
+ //
+ // Thus, we retrieve a pointer to the struct if possible to avoid
+ // a race since v.Interface on the pointer doesn't copy the struct.
+ //
+ // If v is not addressable, then we are not worried about a race
+ // since it implies that the binary Marshaler cannot possibly be
+ // mutating this value.
+ v = v.Addr()
+ }
+ if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
+ text, err := etm.MarshalText()
+ if err != nil {
+ return err
+ }
+ if _, err = w.Write(text); err != nil {
+ return err
+ }
+ } else {
+ if v.Kind() == reflect.Ptr {
+ v = v.Elem()
+ }
+ if err := tm.writeStruct(w, v); err != nil {
+ return err
+ }
+ }
+ w.unindent()
+ if err := w.WriteByte(ket); err != nil {
+ return err
+ }
+ default:
+ _, err := fmt.Fprint(w, v.Interface())
+ return err
+ }
+ return nil
+}
+
+// equivalent to C's isprint.
+func isprint(c byte) bool {
+ return c >= 0x20 && c < 0x7f
+}
+
+// writeString writes a string in the protocol buffer text format.
+// It is similar to strconv.Quote except we don't use Go escape sequences,
+// we treat the string as a byte sequence, and we use octal escapes.
+// These differences are to maintain interoperability with the other
+// languages' implementations of the text format.
+func writeString(w *textWriter, s string) error {
+ // use WriteByte here to get any needed indent
+ if err := w.WriteByte('"'); err != nil {
+ return err
+ }
+ // Loop over the bytes, not the runes.
+ for i := 0; i < len(s); i++ {
+ var err error
+ // Divergence from C++: we don't escape apostrophes.
+ // There's no need to escape them, and the C++ parser
+ // copes with a naked apostrophe.
+ switch c := s[i]; c {
+ case '\n':
+ _, err = w.w.Write(backslashN)
+ case '\r':
+ _, err = w.w.Write(backslashR)
+ case '\t':
+ _, err = w.w.Write(backslashT)
+ case '"':
+ _, err = w.w.Write(backslashDQ)
+ case '\\':
+ _, err = w.w.Write(backslashBS)
+ default:
+ if isprint(c) {
+ err = w.w.WriteByte(c)
+ } else {
+ _, err = fmt.Fprintf(w.w, "\\%03o", c)
+ }
+ }
+ if err != nil {
+ return err
+ }
+ }
+ return w.WriteByte('"')
+}
+
+func writeUnknownStruct(w *textWriter, data []byte) (err error) {
+ if !w.compact {
+ if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
+ return err
+ }
+ }
+ b := NewBuffer(data)
+ for b.index < len(b.buf) {
+ x, err := b.DecodeVarint()
+ if err != nil {
+ _, err := fmt.Fprintf(w, "/* %v */\n", err)
+ return err
+ }
+ wire, tag := x&7, x>>3
+ if wire == WireEndGroup {
+ w.unindent()
+ if _, err := w.Write(endBraceNewline); err != nil {
+ return err
+ }
+ continue
+ }
+ if _, err := fmt.Fprint(w, tag); err != nil {
+ return err
+ }
+ if wire != WireStartGroup {
+ if err := w.WriteByte(':'); err != nil {
+ return err
+ }
+ }
+ if !w.compact || wire == WireStartGroup {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ switch wire {
+ case WireBytes:
+ buf, e := b.DecodeRawBytes(false)
+ if e == nil {
+ _, err = fmt.Fprintf(w, "%q", buf)
+ } else {
+ _, err = fmt.Fprintf(w, "/* %v */", e)
+ }
+ case WireFixed32:
+ x, err = b.DecodeFixed32()
+ err = writeUnknownInt(w, x, err)
+ case WireFixed64:
+ x, err = b.DecodeFixed64()
+ err = writeUnknownInt(w, x, err)
+ case WireStartGroup:
+ err = w.WriteByte('{')
+ w.indent()
+ case WireVarint:
+ x, err = b.DecodeVarint()
+ err = writeUnknownInt(w, x, err)
+ default:
+ _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
+ }
+ if err != nil {
+ return err
+ }
+ if err = w.WriteByte('\n'); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func writeUnknownInt(w *textWriter, x uint64, err error) error {
+ if err == nil {
+ _, err = fmt.Fprint(w, x)
+ } else {
+ _, err = fmt.Fprintf(w, "/* %v */", err)
+ }
+ return err
+}
+
+type int32Slice []int32
+
+func (s int32Slice) Len() int { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// writeExtensions writes all the extensions in pv.
+// pv is assumed to be a pointer to a protocol message struct that is extendable.
+func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
+ emap := extensionMaps[pv.Type().Elem()]
+ ep, _ := extendable(pv.Interface())
+
+ // Order the extensions by ID.
+ // This isn't strictly necessary, but it will give us
+ // canonical output, which will also make testing easier.
+ m, mu := ep.extensionsRead()
+ if m == nil {
+ return nil
+ }
+ mu.Lock()
+ ids := make([]int32, 0, len(m))
+ for id := range m {
+ ids = append(ids, id)
+ }
+ sort.Sort(int32Slice(ids))
+ mu.Unlock()
+
+ for _, extNum := range ids {
+ ext := m[extNum]
+ var desc *ExtensionDesc
+ if emap != nil {
+ desc = emap[extNum]
+ }
+ if desc == nil {
+ // Unknown extension.
+ if err := writeUnknownStruct(w, ext.enc); err != nil {
+ return err
+ }
+ continue
+ }
+
+ pb, err := GetExtension(ep, desc)
+ if err != nil {
+ return fmt.Errorf("failed getting extension: %v", err)
+ }
+
+ // Repeated extensions will appear as a slice.
+ if !desc.repeated() {
+ if err := tm.writeExtension(w, desc.Name, pb); err != nil {
+ return err
+ }
+ } else {
+ v := reflect.ValueOf(pb)
+ for i := 0; i < v.Len(); i++ {
+ if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
+ return err
+ }
+ }
+ }
+ }
+ return nil
+}
+
+func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
+ if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
+ return err
+ }
+ if !w.compact {
+ if err := w.WriteByte(' '); err != nil {
+ return err
+ }
+ }
+ if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
+ return err
+ }
+ if err := w.WriteByte('\n'); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (w *textWriter) writeIndent() {
+ if !w.complete {
+ return
+ }
+ remain := w.ind * 2
+ for remain > 0 {
+ n := remain
+ if n > len(spaces) {
+ n = len(spaces)
+ }
+ w.w.Write(spaces[:n])
+ remain -= n
+ }
+ w.complete = false
+}
+
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+ Compact bool // use compact text format (one line).
+ ExpandAny bool // expand google.protobuf.Any messages of known types
+}
+
+// Marshal writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
+ val := reflect.ValueOf(pb)
+ if pb == nil || val.IsNil() {
+ w.Write([]byte("<nil>"))
+ return nil
+ }
+ var bw *bufio.Writer
+ ww, ok := w.(writer)
+ if !ok {
+ bw = bufio.NewWriter(w)
+ ww = bw
+ }
+ aw := &textWriter{
+ w: ww,
+ complete: true,
+ compact: tm.Compact,
+ }
+
+ if etm, ok := pb.(encoding.TextMarshaler); ok {
+ text, err := etm.MarshalText()
+ if err != nil {
+ return err
+ }
+ if _, err = aw.Write(text); err != nil {
+ return err
+ }
+ if bw != nil {
+ return bw.Flush()
+ }
+ return nil
+ }
+ // Dereference the received pointer so we don't have outer < and >.
+ v := reflect.Indirect(val)
+ if err := tm.writeStruct(aw, v); err != nil {
+ return err
+ }
+ if bw != nil {
+ return bw.Flush()
+ }
+ return nil
+}
+
+// Text is the same as Marshal, but returns the string directly.
+func (tm *TextMarshaler) Text(pb Message) string {
+ var buf bytes.Buffer
+ tm.Marshal(&buf, pb)
+ return buf.String()
+}
+
+var (
+ defaultTextMarshaler = TextMarshaler{}
+ compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// TODO: consider removing some of the Marshal functions below.
+
+// MarshalText writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
+
+// MarshalTextString is the same as MarshalText, but returns the string directly.
+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
+
+// CompactText writes a given protocol buffer in compact text format (one line).
+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
+
+// CompactTextString is the same as CompactText, but returns the string directly.
+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/golang/protobuf/proto/text_decode.go b/vendor/github.com/golang/protobuf/proto/text_decode.go
deleted file mode 100644
index 4a59310..0000000
--- a/vendor/github.com/golang/protobuf/proto/text_decode.go
+++ /dev/null
@@ -1,801 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "encoding"
- "errors"
- "fmt"
- "reflect"
- "strconv"
- "strings"
- "unicode/utf8"
-
- "google.golang.org/protobuf/encoding/prototext"
- protoV2 "google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const wrapTextUnmarshalV2 = false
-
-// ParseError is returned by UnmarshalText.
-type ParseError struct {
- Message string
-
- // Deprecated: Do not use.
- Line, Offset int
-}
-
-func (e *ParseError) Error() string {
- if wrapTextUnmarshalV2 {
- return e.Message
- }
- if e.Line == 1 {
- return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message)
- }
- return fmt.Sprintf("line %d: %v", e.Line, e.Message)
-}
-
-// UnmarshalText parses a proto text formatted string into m.
-func UnmarshalText(s string, m Message) error {
- if u, ok := m.(encoding.TextUnmarshaler); ok {
- return u.UnmarshalText([]byte(s))
- }
-
- m.Reset()
- mi := MessageV2(m)
-
- if wrapTextUnmarshalV2 {
- err := prototext.UnmarshalOptions{
- AllowPartial: true,
- }.Unmarshal([]byte(s), mi)
- if err != nil {
- return &ParseError{Message: err.Error()}
- }
- return checkRequiredNotSet(mi)
- } else {
- if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil {
- return err
- }
- return checkRequiredNotSet(mi)
- }
-}
-
-type textParser struct {
- s string // remaining input
- done bool // whether the parsing is finished (success or error)
- backed bool // whether back() was called
- offset, line int
- cur token
-}
-
-type token struct {
- value string
- err *ParseError
- line int // line number
- offset int // byte number from start of input, not start of line
- unquoted string // the unquoted version of value, if it was a quoted string
-}
-
-func newTextParser(s string) *textParser {
- p := new(textParser)
- p.s = s
- p.line = 1
- p.cur.line = 1
- return p
-}
-
-func (p *textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) {
- md := m.Descriptor()
- fds := md.Fields()
-
- // A struct is a sequence of "name: value", terminated by one of
- // '>' or '}', or the end of the input. A name may also be
- // "[extension]" or "[type/url]".
- //
- // The whole struct can also be an expanded Any message, like:
- // [type/url] < ... struct contents ... >
- seen := make(map[protoreflect.FieldNumber]bool)
- for {
- tok := p.next()
- if tok.err != nil {
- return tok.err
- }
- if tok.value == terminator {
- break
- }
- if tok.value == "[" {
- if err := p.unmarshalExtensionOrAny(m, seen); err != nil {
- return err
- }
- continue
- }
-
- // This is a normal, non-extension field.
- name := protoreflect.Name(tok.value)
- fd := fds.ByName(name)
- switch {
- case fd == nil:
- gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name))))
- if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name {
- fd = gd
- }
- case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name:
- fd = nil
- case fd.IsWeak() && fd.Message().IsPlaceholder():
- fd = nil
- }
- if fd == nil {
- typeName := string(md.FullName())
- if m, ok := m.Interface().(Message); ok {
- t := reflect.TypeOf(m)
- if t.Kind() == reflect.Ptr {
- typeName = t.Elem().String()
- }
- }
- return p.errorf("unknown field name %q in %v", name, typeName)
- }
- if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil {
- return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name())
- }
- if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] {
- return p.errorf("non-repeated field %q was repeated", fd.Name())
- }
- seen[fd.Number()] = true
-
- // Consume any colon.
- if err := p.checkForColon(fd); err != nil {
- return err
- }
-
- // Parse into the field.
- v := m.Get(fd)
- if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
- v = m.Mutable(fd)
- }
- if v, err = p.unmarshalValue(v, fd); err != nil {
- return err
- }
- m.Set(fd, v)
-
- if err := p.consumeOptionalSeparator(); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (p *textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error {
- name, err := p.consumeExtensionOrAnyName()
- if err != nil {
- return err
- }
-
- // If it contains a slash, it's an Any type URL.
- if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 {
- tok := p.next()
- if tok.err != nil {
- return tok.err
- }
- // consume an optional colon
- if tok.value == ":" {
- tok = p.next()
- if tok.err != nil {
- return tok.err
- }
- }
-
- var terminator string
- switch tok.value {
- case "<":
- terminator = ">"
- case "{":
- terminator = "}"
- default:
- return p.errorf("expected '{' or '<', found %q", tok.value)
- }
-
- mt, err := protoregistry.GlobalTypes.FindMessageByURL(name)
- if err != nil {
- return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):])
- }
- m2 := mt.New()
- if err := p.unmarshalMessage(m2, terminator); err != nil {
- return err
- }
- b, err := protoV2.Marshal(m2.Interface())
- if err != nil {
- return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err)
- }
-
- urlFD := m.Descriptor().Fields().ByName("type_url")
- valFD := m.Descriptor().Fields().ByName("value")
- if seen[urlFD.Number()] {
- return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name())
- }
- if seen[valFD.Number()] {
- return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name())
- }
- m.Set(urlFD, protoreflect.ValueOfString(name))
- m.Set(valFD, protoreflect.ValueOfBytes(b))
- seen[urlFD.Number()] = true
- seen[valFD.Number()] = true
- return nil
- }
-
- xname := protoreflect.FullName(name)
- xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
- if xt == nil && isMessageSet(m.Descriptor()) {
- xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
- }
- if xt == nil {
- return p.errorf("unrecognized extension %q", name)
- }
- fd := xt.TypeDescriptor()
- if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
- return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName())
- }
-
- if err := p.checkForColon(fd); err != nil {
- return err
- }
-
- v := m.Get(fd)
- if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
- v = m.Mutable(fd)
- }
- v, err = p.unmarshalValue(v, fd)
- if err != nil {
- return err
- }
- m.Set(fd, v)
- return p.consumeOptionalSeparator()
-}
-
-func (p *textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
- tok := p.next()
- if tok.err != nil {
- return v, tok.err
- }
- if tok.value == "" {
- return v, p.errorf("unexpected EOF")
- }
-
- switch {
- case fd.IsList():
- lv := v.List()
- var err error
- if tok.value == "[" {
- // Repeated field with list notation, like [1,2,3].
- for {
- vv := lv.NewElement()
- vv, err = p.unmarshalSingularValue(vv, fd)
- if err != nil {
- return v, err
- }
- lv.Append(vv)
-
- tok := p.next()
- if tok.err != nil {
- return v, tok.err
- }
- if tok.value == "]" {
- break
- }
- if tok.value != "," {
- return v, p.errorf("Expected ']' or ',' found %q", tok.value)
- }
- }
- return v, nil
- }
-
- // One value of the repeated field.
- p.back()
- vv := lv.NewElement()
- vv, err = p.unmarshalSingularValue(vv, fd)
- if err != nil {
- return v, err
- }
- lv.Append(vv)
- return v, nil
- case fd.IsMap():
- // The map entry should be this sequence of tokens:
- // < key : KEY value : VALUE >
- // However, implementations may omit key or value, and technically
- // we should support them in any order.
- var terminator string
- switch tok.value {
- case "<":
- terminator = ">"
- case "{":
- terminator = "}"
- default:
- return v, p.errorf("expected '{' or '<', found %q", tok.value)
- }
-
- keyFD := fd.MapKey()
- valFD := fd.MapValue()
-
- mv := v.Map()
- kv := keyFD.Default()
- vv := mv.NewValue()
- for {
- tok := p.next()
- if tok.err != nil {
- return v, tok.err
- }
- if tok.value == terminator {
- break
- }
- var err error
- switch tok.value {
- case "key":
- if err := p.consumeToken(":"); err != nil {
- return v, err
- }
- if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil {
- return v, err
- }
- if err := p.consumeOptionalSeparator(); err != nil {
- return v, err
- }
- case "value":
- if err := p.checkForColon(valFD); err != nil {
- return v, err
- }
- if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil {
- return v, err
- }
- if err := p.consumeOptionalSeparator(); err != nil {
- return v, err
- }
- default:
- p.back()
- return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
- }
- }
- mv.Set(kv.MapKey(), vv)
- return v, nil
- default:
- p.back()
- return p.unmarshalSingularValue(v, fd)
- }
-}
-
-func (p *textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
- tok := p.next()
- if tok.err != nil {
- return v, tok.err
- }
- if tok.value == "" {
- return v, p.errorf("unexpected EOF")
- }
-
- switch fd.Kind() {
- case protoreflect.BoolKind:
- switch tok.value {
- case "true", "1", "t", "True":
- return protoreflect.ValueOfBool(true), nil
- case "false", "0", "f", "False":
- return protoreflect.ValueOfBool(false), nil
- }
- case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
- if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
- return protoreflect.ValueOfInt32(int32(x)), nil
- }
-
- // The C++ parser accepts large positive hex numbers that uses
- // two's complement arithmetic to represent negative numbers.
- // This feature is here for backwards compatibility with C++.
- if strings.HasPrefix(tok.value, "0x") {
- if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
- return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil
- }
- }
- case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
- if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
- return protoreflect.ValueOfInt64(int64(x)), nil
- }
-
- // The C++ parser accepts large positive hex numbers that uses
- // two's complement arithmetic to represent negative numbers.
- // This feature is here for backwards compatibility with C++.
- if strings.HasPrefix(tok.value, "0x") {
- if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
- return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil
- }
- }
- case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
- if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
- return protoreflect.ValueOfUint32(uint32(x)), nil
- }
- case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
- if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
- return protoreflect.ValueOfUint64(uint64(x)), nil
- }
- case protoreflect.FloatKind:
- // Ignore 'f' for compatibility with output generated by C++,
- // but don't remove 'f' when the value is "-inf" or "inf".
- v := tok.value
- if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
- v = v[:len(v)-len("f")]
- }
- if x, err := strconv.ParseFloat(v, 32); err == nil {
- return protoreflect.ValueOfFloat32(float32(x)), nil
- }
- case protoreflect.DoubleKind:
- // Ignore 'f' for compatibility with output generated by C++,
- // but don't remove 'f' when the value is "-inf" or "inf".
- v := tok.value
- if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
- v = v[:len(v)-len("f")]
- }
- if x, err := strconv.ParseFloat(v, 64); err == nil {
- return protoreflect.ValueOfFloat64(float64(x)), nil
- }
- case protoreflect.StringKind:
- if isQuote(tok.value[0]) {
- return protoreflect.ValueOfString(tok.unquoted), nil
- }
- case protoreflect.BytesKind:
- if isQuote(tok.value[0]) {
- return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil
- }
- case protoreflect.EnumKind:
- if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
- return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil
- }
- vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value))
- if vd != nil {
- return protoreflect.ValueOfEnum(vd.Number()), nil
- }
- case protoreflect.MessageKind, protoreflect.GroupKind:
- var terminator string
- switch tok.value {
- case "{":
- terminator = "}"
- case "<":
- terminator = ">"
- default:
- return v, p.errorf("expected '{' or '<', found %q", tok.value)
- }
- err := p.unmarshalMessage(v.Message(), terminator)
- return v, err
- default:
- panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
- }
- return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value)
-}
-
-// Consume a ':' from the input stream (if the next token is a colon),
-// returning an error if a colon is needed but not present.
-func (p *textParser) checkForColon(fd protoreflect.FieldDescriptor) *ParseError {
- tok := p.next()
- if tok.err != nil {
- return tok.err
- }
- if tok.value != ":" {
- if fd.Message() == nil {
- return p.errorf("expected ':', found %q", tok.value)
- }
- p.back()
- }
- return nil
-}
-
-// consumeExtensionOrAnyName consumes an extension name or an Any type URL and
-// the following ']'. It returns the name or URL consumed.
-func (p *textParser) consumeExtensionOrAnyName() (string, error) {
- tok := p.next()
- if tok.err != nil {
- return "", tok.err
- }
-
- // If extension name or type url is quoted, it's a single token.
- if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
- name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
- if err != nil {
- return "", err
- }
- return name, p.consumeToken("]")
- }
-
- // Consume everything up to "]"
- var parts []string
- for tok.value != "]" {
- parts = append(parts, tok.value)
- tok = p.next()
- if tok.err != nil {
- return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
- }
- if p.done && tok.value != "]" {
- return "", p.errorf("unclosed type_url or extension name")
- }
- }
- return strings.Join(parts, ""), nil
-}
-
-// consumeOptionalSeparator consumes an optional semicolon or comma.
-// It is used in unmarshalMessage to provide backward compatibility.
-func (p *textParser) consumeOptionalSeparator() error {
- tok := p.next()
- if tok.err != nil {
- return tok.err
- }
- if tok.value != ";" && tok.value != "," {
- p.back()
- }
- return nil
-}
-
-func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
- pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
- p.cur.err = pe
- p.done = true
- return pe
-}
-
-func (p *textParser) skipWhitespace() {
- i := 0
- for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
- if p.s[i] == '#' {
- // comment; skip to end of line or input
- for i < len(p.s) && p.s[i] != '\n' {
- i++
- }
- if i == len(p.s) {
- break
- }
- }
- if p.s[i] == '\n' {
- p.line++
- }
- i++
- }
- p.offset += i
- p.s = p.s[i:len(p.s)]
- if len(p.s) == 0 {
- p.done = true
- }
-}
-
-func (p *textParser) advance() {
- // Skip whitespace
- p.skipWhitespace()
- if p.done {
- return
- }
-
- // Start of non-whitespace
- p.cur.err = nil
- p.cur.offset, p.cur.line = p.offset, p.line
- p.cur.unquoted = ""
- switch p.s[0] {
- case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
- // Single symbol
- p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
- case '"', '\'':
- // Quoted string
- i := 1
- for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
- if p.s[i] == '\\' && i+1 < len(p.s) {
- // skip escaped char
- i++
- }
- i++
- }
- if i >= len(p.s) || p.s[i] != p.s[0] {
- p.errorf("unmatched quote")
- return
- }
- unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
- if err != nil {
- p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
- return
- }
- p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
- p.cur.unquoted = unq
- default:
- i := 0
- for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
- i++
- }
- if i == 0 {
- p.errorf("unexpected byte %#x", p.s[0])
- return
- }
- p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
- }
- p.offset += len(p.cur.value)
-}
-
-// Back off the parser by one token. Can only be done between calls to next().
-// It makes the next advance() a no-op.
-func (p *textParser) back() { p.backed = true }
-
-// Advances the parser and returns the new current token.
-func (p *textParser) next() *token {
- if p.backed || p.done {
- p.backed = false
- return &p.cur
- }
- p.advance()
- if p.done {
- p.cur.value = ""
- } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
- // Look for multiple quoted strings separated by whitespace,
- // and concatenate them.
- cat := p.cur
- for {
- p.skipWhitespace()
- if p.done || !isQuote(p.s[0]) {
- break
- }
- p.advance()
- if p.cur.err != nil {
- return &p.cur
- }
- cat.value += " " + p.cur.value
- cat.unquoted += p.cur.unquoted
- }
- p.done = false // parser may have seen EOF, but we want to return cat
- p.cur = cat
- }
- return &p.cur
-}
-
-func (p *textParser) consumeToken(s string) error {
- tok := p.next()
- if tok.err != nil {
- return tok.err
- }
- if tok.value != s {
- p.back()
- return p.errorf("expected %q, found %q", s, tok.value)
- }
- return nil
-}
-
-var errBadUTF8 = errors.New("proto: bad UTF-8")
-
-func unquoteC(s string, quote rune) (string, error) {
- // This is based on C++'s tokenizer.cc.
- // Despite its name, this is *not* parsing C syntax.
- // For instance, "\0" is an invalid quoted string.
-
- // Avoid allocation in trivial cases.
- simple := true
- for _, r := range s {
- if r == '\\' || r == quote {
- simple = false
- break
- }
- }
- if simple {
- return s, nil
- }
-
- buf := make([]byte, 0, 3*len(s)/2)
- for len(s) > 0 {
- r, n := utf8.DecodeRuneInString(s)
- if r == utf8.RuneError && n == 1 {
- return "", errBadUTF8
- }
- s = s[n:]
- if r != '\\' {
- if r < utf8.RuneSelf {
- buf = append(buf, byte(r))
- } else {
- buf = append(buf, string(r)...)
- }
- continue
- }
-
- ch, tail, err := unescape(s)
- if err != nil {
- return "", err
- }
- buf = append(buf, ch...)
- s = tail
- }
- return string(buf), nil
-}
-
-func unescape(s string) (ch string, tail string, err error) {
- r, n := utf8.DecodeRuneInString(s)
- if r == utf8.RuneError && n == 1 {
- return "", "", errBadUTF8
- }
- s = s[n:]
- switch r {
- case 'a':
- return "\a", s, nil
- case 'b':
- return "\b", s, nil
- case 'f':
- return "\f", s, nil
- case 'n':
- return "\n", s, nil
- case 'r':
- return "\r", s, nil
- case 't':
- return "\t", s, nil
- case 'v':
- return "\v", s, nil
- case '?':
- return "?", s, nil // trigraph workaround
- case '\'', '"', '\\':
- return string(r), s, nil
- case '0', '1', '2', '3', '4', '5', '6', '7':
- if len(s) < 2 {
- return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
- }
- ss := string(r) + s[:2]
- s = s[2:]
- i, err := strconv.ParseUint(ss, 8, 8)
- if err != nil {
- return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
- }
- return string([]byte{byte(i)}), s, nil
- case 'x', 'X', 'u', 'U':
- var n int
- switch r {
- case 'x', 'X':
- n = 2
- case 'u':
- n = 4
- case 'U':
- n = 8
- }
- if len(s) < n {
- return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
- }
- ss := s[:n]
- s = s[n:]
- i, err := strconv.ParseUint(ss, 16, 64)
- if err != nil {
- return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
- }
- if r == 'x' || r == 'X' {
- return string([]byte{byte(i)}), s, nil
- }
- if i > utf8.MaxRune {
- return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
- }
- return string(i), s, nil
- }
- return "", "", fmt.Errorf(`unknown escape \%c`, r)
-}
-
-func isIdentOrNumberChar(c byte) bool {
- switch {
- case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
- return true
- case '0' <= c && c <= '9':
- return true
- }
- switch c {
- case '-', '+', '.', '_':
- return true
- }
- return false
-}
-
-func isWhitespace(c byte) bool {
- switch c {
- case ' ', '\t', '\n', '\r':
- return true
- }
- return false
-}
-
-func isQuote(c byte) bool {
- switch c {
- case '"', '\'':
- return true
- }
- return false
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text_encode.go b/vendor/github.com/golang/protobuf/proto/text_encode.go
deleted file mode 100644
index a31134e..0000000
--- a/vendor/github.com/golang/protobuf/proto/text_encode.go
+++ /dev/null
@@ -1,560 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "bytes"
- "encoding"
- "fmt"
- "io"
- "math"
- "sort"
- "strings"
-
- "google.golang.org/protobuf/encoding/prototext"
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const wrapTextMarshalV2 = false
-
-// TextMarshaler is a configurable text format marshaler.
-type TextMarshaler struct {
- Compact bool // use compact text format (one line)
- ExpandAny bool // expand google.protobuf.Any messages of known types
-}
-
-// Marshal writes the proto text format of m to w.
-func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error {
- b, err := tm.marshal(m)
- if len(b) > 0 {
- if _, err := w.Write(b); err != nil {
- return err
- }
- }
- return err
-}
-
-// Text returns a proto text formatted string of m.
-func (tm *TextMarshaler) Text(m Message) string {
- b, _ := tm.marshal(m)
- return string(b)
-}
-
-func (tm *TextMarshaler) marshal(m Message) ([]byte, error) {
- mr := MessageReflect(m)
- if mr == nil || !mr.IsValid() {
- return []byte("<nil>"), nil
- }
-
- if wrapTextMarshalV2 {
- if m, ok := m.(encoding.TextMarshaler); ok {
- return m.MarshalText()
- }
-
- opts := prototext.MarshalOptions{
- AllowPartial: true,
- EmitUnknown: true,
- }
- if !tm.Compact {
- opts.Indent = " "
- }
- if !tm.ExpandAny {
- opts.Resolver = (*protoregistry.Types)(nil)
- }
- return opts.Marshal(mr.Interface())
- } else {
- w := &textWriter{
- compact: tm.Compact,
- expandAny: tm.ExpandAny,
- complete: true,
- }
-
- if m, ok := m.(encoding.TextMarshaler); ok {
- b, err := m.MarshalText()
- if err != nil {
- return nil, err
- }
- w.Write(b)
- return w.buf, nil
- }
-
- err := w.writeMessage(mr)
- return w.buf, err
- }
-}
-
-var (
- defaultTextMarshaler = TextMarshaler{}
- compactTextMarshaler = TextMarshaler{Compact: true}
-)
-
-// MarshalText writes the proto text format of m to w.
-func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) }
-
-// MarshalTextString returns a proto text formatted string of m.
-func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) }
-
-// CompactText writes the compact proto text format of m to w.
-func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) }
-
-// CompactTextString returns a compact proto text formatted string of m.
-func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) }
-
-var (
- newline = []byte("\n")
- endBraceNewline = []byte("}\n")
- posInf = []byte("inf")
- negInf = []byte("-inf")
- nan = []byte("nan")
-)
-
-// textWriter is an io.Writer that tracks its indentation level.
-type textWriter struct {
- compact bool // same as TextMarshaler.Compact
- expandAny bool // same as TextMarshaler.ExpandAny
- complete bool // whether the current position is a complete line
- indent int // indentation level; never negative
- buf []byte
-}
-
-func (w *textWriter) Write(p []byte) (n int, _ error) {
- newlines := bytes.Count(p, newline)
- if newlines == 0 {
- if !w.compact && w.complete {
- w.writeIndent()
- }
- w.buf = append(w.buf, p...)
- w.complete = false
- return len(p), nil
- }
-
- frags := bytes.SplitN(p, newline, newlines+1)
- if w.compact {
- for i, frag := range frags {
- if i > 0 {
- w.buf = append(w.buf, ' ')
- n++
- }
- w.buf = append(w.buf, frag...)
- n += len(frag)
- }
- return n, nil
- }
-
- for i, frag := range frags {
- if w.complete {
- w.writeIndent()
- }
- w.buf = append(w.buf, frag...)
- n += len(frag)
- if i+1 < len(frags) {
- w.buf = append(w.buf, '\n')
- n++
- }
- }
- w.complete = len(frags[len(frags)-1]) == 0
- return n, nil
-}
-
-func (w *textWriter) WriteByte(c byte) error {
- if w.compact && c == '\n' {
- c = ' '
- }
- if !w.compact && w.complete {
- w.writeIndent()
- }
- w.buf = append(w.buf, c)
- w.complete = c == '\n'
- return nil
-}
-
-func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) {
- if !w.compact && w.complete {
- w.writeIndent()
- }
- w.complete = false
-
- if fd.Kind() != protoreflect.GroupKind {
- w.buf = append(w.buf, fd.Name()...)
- w.WriteByte(':')
- } else {
- // Use message type name for group field name.
- w.buf = append(w.buf, fd.Message().Name()...)
- }
-
- if !w.compact {
- w.WriteByte(' ')
- }
-}
-
-func requiresQuotes(u string) bool {
- // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
- for _, ch := range u {
- switch {
- case ch == '.' || ch == '/' || ch == '_':
- continue
- case '0' <= ch && ch <= '9':
- continue
- case 'A' <= ch && ch <= 'Z':
- continue
- case 'a' <= ch && ch <= 'z':
- continue
- default:
- return true
- }
- }
- return false
-}
-
-// writeProto3Any writes an expanded google.protobuf.Any message.
-//
-// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
-// required messages are not linked in).
-//
-// It returns (true, error) when sv was written in expanded format or an error
-// was encountered.
-func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) {
- md := m.Descriptor()
- fdURL := md.Fields().ByName("type_url")
- fdVal := md.Fields().ByName("value")
-
- url := m.Get(fdURL).String()
- mt, err := protoregistry.GlobalTypes.FindMessageByURL(url)
- if err != nil {
- return false, nil
- }
-
- b := m.Get(fdVal).Bytes()
- m2 := mt.New()
- if err := proto.Unmarshal(b, m2.Interface()); err != nil {
- return false, nil
- }
- w.Write([]byte("["))
- if requiresQuotes(url) {
- w.writeQuotedString(url)
- } else {
- w.Write([]byte(url))
- }
- if w.compact {
- w.Write([]byte("]:<"))
- } else {
- w.Write([]byte("]: <\n"))
- w.indent++
- }
- if err := w.writeMessage(m2); err != nil {
- return true, err
- }
- if w.compact {
- w.Write([]byte("> "))
- } else {
- w.indent--
- w.Write([]byte(">\n"))
- }
- return true, nil
-}
-
-func (w *textWriter) writeMessage(m protoreflect.Message) error {
- md := m.Descriptor()
- if w.expandAny && md.FullName() == "google.protobuf.Any" {
- if canExpand, err := w.writeProto3Any(m); canExpand {
- return err
- }
- }
-
- fds := md.Fields()
- for i := 0; i < fds.Len(); {
- fd := fds.Get(i)
- if od := fd.ContainingOneof(); od != nil {
- fd = m.WhichOneof(od)
- i += od.Fields().Len()
- } else {
- i++
- }
- if fd == nil || !m.Has(fd) {
- continue
- }
-
- switch {
- case fd.IsList():
- lv := m.Get(fd).List()
- for j := 0; j < lv.Len(); j++ {
- w.writeName(fd)
- v := lv.Get(j)
- if err := w.writeSingularValue(v, fd); err != nil {
- return err
- }
- w.WriteByte('\n')
- }
- case fd.IsMap():
- kfd := fd.MapKey()
- vfd := fd.MapValue()
- mv := m.Get(fd).Map()
-
- type entry struct{ key, val protoreflect.Value }
- var entries []entry
- mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
- entries = append(entries, entry{k.Value(), v})
- return true
- })
- sort.Slice(entries, func(i, j int) bool {
- switch kfd.Kind() {
- case protoreflect.BoolKind:
- return !entries[i].key.Bool() && entries[j].key.Bool()
- case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
- return entries[i].key.Int() < entries[j].key.Int()
- case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
- return entries[i].key.Uint() < entries[j].key.Uint()
- case protoreflect.StringKind:
- return entries[i].key.String() < entries[j].key.String()
- default:
- panic("invalid kind")
- }
- })
- for _, entry := range entries {
- w.writeName(fd)
- w.WriteByte('<')
- if !w.compact {
- w.WriteByte('\n')
- }
- w.indent++
- w.writeName(kfd)
- if err := w.writeSingularValue(entry.key, kfd); err != nil {
- return err
- }
- w.WriteByte('\n')
- w.writeName(vfd)
- if err := w.writeSingularValue(entry.val, vfd); err != nil {
- return err
- }
- w.WriteByte('\n')
- w.indent--
- w.WriteByte('>')
- w.WriteByte('\n')
- }
- default:
- w.writeName(fd)
- if err := w.writeSingularValue(m.Get(fd), fd); err != nil {
- return err
- }
- w.WriteByte('\n')
- }
- }
-
- if b := m.GetUnknown(); len(b) > 0 {
- w.writeUnknownFields(b)
- }
- return w.writeExtensions(m)
-}
-
-func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
- switch fd.Kind() {
- case protoreflect.FloatKind, protoreflect.DoubleKind:
- switch vf := v.Float(); {
- case math.IsInf(vf, +1):
- w.Write(posInf)
- case math.IsInf(vf, -1):
- w.Write(negInf)
- case math.IsNaN(vf):
- w.Write(nan)
- default:
- fmt.Fprint(w, v.Interface())
- }
- case protoreflect.StringKind:
- // NOTE: This does not validate UTF-8 for historical reasons.
- w.writeQuotedString(string(v.String()))
- case protoreflect.BytesKind:
- w.writeQuotedString(string(v.Bytes()))
- case protoreflect.MessageKind, protoreflect.GroupKind:
- var bra, ket byte = '<', '>'
- if fd.Kind() == protoreflect.GroupKind {
- bra, ket = '{', '}'
- }
- w.WriteByte(bra)
- if !w.compact {
- w.WriteByte('\n')
- }
- w.indent++
- m := v.Message()
- if m2, ok := m.Interface().(encoding.TextMarshaler); ok {
- b, err := m2.MarshalText()
- if err != nil {
- return err
- }
- w.Write(b)
- } else {
- w.writeMessage(m)
- }
- w.indent--
- w.WriteByte(ket)
- case protoreflect.EnumKind:
- if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil {
- fmt.Fprint(w, ev.Name())
- } else {
- fmt.Fprint(w, v.Enum())
- }
- default:
- fmt.Fprint(w, v.Interface())
- }
- return nil
-}
-
-// writeQuotedString writes a quoted string in the protocol buffer text format.
-func (w *textWriter) writeQuotedString(s string) {
- w.WriteByte('"')
- for i := 0; i < len(s); i++ {
- switch c := s[i]; c {
- case '\n':
- w.buf = append(w.buf, `\n`...)
- case '\r':
- w.buf = append(w.buf, `\r`...)
- case '\t':
- w.buf = append(w.buf, `\t`...)
- case '"':
- w.buf = append(w.buf, `\"`...)
- case '\\':
- w.buf = append(w.buf, `\\`...)
- default:
- if isPrint := c >= 0x20 && c < 0x7f; isPrint {
- w.buf = append(w.buf, c)
- } else {
- w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...)
- }
- }
- }
- w.WriteByte('"')
-}
-
-func (w *textWriter) writeUnknownFields(b []byte) {
- if !w.compact {
- fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b))
- }
-
- for len(b) > 0 {
- num, wtyp, n := protowire.ConsumeTag(b)
- if n < 0 {
- return
- }
- b = b[n:]
-
- if wtyp == protowire.EndGroupType {
- w.indent--
- w.Write(endBraceNewline)
- continue
- }
- fmt.Fprint(w, num)
- if wtyp != protowire.StartGroupType {
- w.WriteByte(':')
- }
- if !w.compact || wtyp == protowire.StartGroupType {
- w.WriteByte(' ')
- }
- switch wtyp {
- case protowire.VarintType:
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return
- }
- b = b[n:]
- fmt.Fprint(w, v)
- case protowire.Fixed32Type:
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return
- }
- b = b[n:]
- fmt.Fprint(w, v)
- case protowire.Fixed64Type:
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return
- }
- b = b[n:]
- fmt.Fprint(w, v)
- case protowire.BytesType:
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return
- }
- b = b[n:]
- fmt.Fprintf(w, "%q", v)
- case protowire.StartGroupType:
- w.WriteByte('{')
- w.indent++
- default:
- fmt.Fprintf(w, "/* unknown wire type %d */", wtyp)
- }
- w.WriteByte('\n')
- }
-}
-
-// writeExtensions writes all the extensions in m.
-func (w *textWriter) writeExtensions(m protoreflect.Message) error {
- md := m.Descriptor()
- if md.ExtensionRanges().Len() == 0 {
- return nil
- }
-
- type ext struct {
- desc protoreflect.FieldDescriptor
- val protoreflect.Value
- }
- var exts []ext
- m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- if fd.IsExtension() {
- exts = append(exts, ext{fd, v})
- }
- return true
- })
- sort.Slice(exts, func(i, j int) bool {
- return exts[i].desc.Number() < exts[j].desc.Number()
- })
-
- for _, ext := range exts {
- // For message set, use the name of the message as the extension name.
- name := string(ext.desc.FullName())
- if isMessageSet(ext.desc.ContainingMessage()) {
- name = strings.TrimSuffix(name, ".message_set_extension")
- }
-
- if !ext.desc.IsList() {
- if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil {
- return err
- }
- } else {
- lv := ext.val.List()
- for i := 0; i < lv.Len(); i++ {
- if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil {
- return err
- }
- }
- }
- }
- return nil
-}
-
-func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
- fmt.Fprintf(w, "[%s]:", name)
- if !w.compact {
- w.WriteByte(' ')
- }
- if err := w.writeSingularValue(v, fd); err != nil {
- return err
- }
- w.WriteByte('\n')
- return nil
-}
-
-func (w *textWriter) writeIndent() {
- if !w.complete {
- return
- }
- for i := 0; i < w.indent*2; i++ {
- w.buf = append(w.buf, ' ')
- }
- w.complete = false
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go
new file mode 100644
index 0000000..bb55a3a
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text_parser.go
@@ -0,0 +1,880 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
+
+package proto
+
+// Functions for parsing the Text protocol buffer format.
+// TODO: message sets.
+
+import (
+ "encoding"
+ "errors"
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+)
+
+// Error string emitted when deserializing Any and fields are already set
+const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
+
+type ParseError struct {
+ Message string
+ Line int // 1-based line number
+ Offset int // 0-based byte offset from start of input
+}
+
+func (p *ParseError) Error() string {
+ if p.Line == 1 {
+ // show offset only for first line
+ return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
+ }
+ return fmt.Sprintf("line %d: %v", p.Line, p.Message)
+}
+
+type token struct {
+ value string
+ err *ParseError
+ line int // line number
+ offset int // byte number from start of input, not start of line
+ unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func (t *token) String() string {
+ if t.err == nil {
+ return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
+ }
+ return fmt.Sprintf("parse error: %v", t.err)
+}
+
+type textParser struct {
+ s string // remaining input
+ done bool // whether the parsing is finished (success or error)
+ backed bool // whether back() was called
+ offset, line int
+ cur token
+}
+
+func newTextParser(s string) *textParser {
+ p := new(textParser)
+ p.s = s
+ p.line = 1
+ p.cur.line = 1
+ return p
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+ pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+ p.cur.err = pe
+ p.done = true
+ return pe
+}
+
+// Numbers and identifiers are matched by [-+._A-Za-z0-9]
+func isIdentOrNumberChar(c byte) bool {
+ switch {
+ case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+ return true
+ case '0' <= c && c <= '9':
+ return true
+ }
+ switch c {
+ case '-', '+', '.', '_':
+ return true
+ }
+ return false
+}
+
+func isWhitespace(c byte) bool {
+ switch c {
+ case ' ', '\t', '\n', '\r':
+ return true
+ }
+ return false
+}
+
+func isQuote(c byte) bool {
+ switch c {
+ case '"', '\'':
+ return true
+ }
+ return false
+}
+
+func (p *textParser) skipWhitespace() {
+ i := 0
+ for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+ if p.s[i] == '#' {
+ // comment; skip to end of line or input
+ for i < len(p.s) && p.s[i] != '\n' {
+ i++
+ }
+ if i == len(p.s) {
+ break
+ }
+ }
+ if p.s[i] == '\n' {
+ p.line++
+ }
+ i++
+ }
+ p.offset += i
+ p.s = p.s[i:len(p.s)]
+ if len(p.s) == 0 {
+ p.done = true
+ }
+}
+
+func (p *textParser) advance() {
+ // Skip whitespace
+ p.skipWhitespace()
+ if p.done {
+ return
+ }
+
+ // Start of non-whitespace
+ p.cur.err = nil
+ p.cur.offset, p.cur.line = p.offset, p.line
+ p.cur.unquoted = ""
+ switch p.s[0] {
+ case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
+ // Single symbol
+ p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+ case '"', '\'':
+ // Quoted string
+ i := 1
+ for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+ if p.s[i] == '\\' && i+1 < len(p.s) {
+ // skip escaped char
+ i++
+ }
+ i++
+ }
+ if i >= len(p.s) || p.s[i] != p.s[0] {
+ p.errorf("unmatched quote")
+ return
+ }
+ unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+ if err != nil {
+ p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
+ return
+ }
+ p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+ p.cur.unquoted = unq
+ default:
+ i := 0
+ for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+ i++
+ }
+ if i == 0 {
+ p.errorf("unexpected byte %#x", p.s[0])
+ return
+ }
+ p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+ }
+ p.offset += len(p.cur.value)
+}
+
+var (
+ errBadUTF8 = errors.New("proto: bad UTF-8")
+)
+
+func unquoteC(s string, quote rune) (string, error) {
+ // This is based on C++'s tokenizer.cc.
+ // Despite its name, this is *not* parsing C syntax.
+ // For instance, "\0" is an invalid quoted string.
+
+ // Avoid allocation in trivial cases.
+ simple := true
+ for _, r := range s {
+ if r == '\\' || r == quote {
+ simple = false
+ break
+ }
+ }
+ if simple {
+ return s, nil
+ }
+
+ buf := make([]byte, 0, 3*len(s)/2)
+ for len(s) > 0 {
+ r, n := utf8.DecodeRuneInString(s)
+ if r == utf8.RuneError && n == 1 {
+ return "", errBadUTF8
+ }
+ s = s[n:]
+ if r != '\\' {
+ if r < utf8.RuneSelf {
+ buf = append(buf, byte(r))
+ } else {
+ buf = append(buf, string(r)...)
+ }
+ continue
+ }
+
+ ch, tail, err := unescape(s)
+ if err != nil {
+ return "", err
+ }
+ buf = append(buf, ch...)
+ s = tail
+ }
+ return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+ r, n := utf8.DecodeRuneInString(s)
+ if r == utf8.RuneError && n == 1 {
+ return "", "", errBadUTF8
+ }
+ s = s[n:]
+ switch r {
+ case 'a':
+ return "\a", s, nil
+ case 'b':
+ return "\b", s, nil
+ case 'f':
+ return "\f", s, nil
+ case 'n':
+ return "\n", s, nil
+ case 'r':
+ return "\r", s, nil
+ case 't':
+ return "\t", s, nil
+ case 'v':
+ return "\v", s, nil
+ case '?':
+ return "?", s, nil // trigraph workaround
+ case '\'', '"', '\\':
+ return string(r), s, nil
+ case '0', '1', '2', '3', '4', '5', '6', '7':
+ if len(s) < 2 {
+ return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+ }
+ ss := string(r) + s[:2]
+ s = s[2:]
+ i, err := strconv.ParseUint(ss, 8, 8)
+ if err != nil {
+ return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
+ }
+ return string([]byte{byte(i)}), s, nil
+ case 'x', 'X', 'u', 'U':
+ var n int
+ switch r {
+ case 'x', 'X':
+ n = 2
+ case 'u':
+ n = 4
+ case 'U':
+ n = 8
+ }
+ if len(s) < n {
+ return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
+ }
+ ss := s[:n]
+ s = s[n:]
+ i, err := strconv.ParseUint(ss, 16, 64)
+ if err != nil {
+ return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
+ }
+ if r == 'x' || r == 'X' {
+ return string([]byte{byte(i)}), s, nil
+ }
+ if i > utf8.MaxRune {
+ return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
+ }
+ return string(i), s, nil
+ }
+ return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+ if p.backed || p.done {
+ p.backed = false
+ return &p.cur
+ }
+ p.advance()
+ if p.done {
+ p.cur.value = ""
+ } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
+ // Look for multiple quoted strings separated by whitespace,
+ // and concatenate them.
+ cat := p.cur
+ for {
+ p.skipWhitespace()
+ if p.done || !isQuote(p.s[0]) {
+ break
+ }
+ p.advance()
+ if p.cur.err != nil {
+ return &p.cur
+ }
+ cat.value += " " + p.cur.value
+ cat.unquoted += p.cur.unquoted
+ }
+ p.done = false // parser may have seen EOF, but we want to return cat
+ p.cur = cat
+ }
+ return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value != s {
+ p.back()
+ return p.errorf("expected %q, found %q", s, tok.value)
+ }
+ return nil
+}
+
+// Return a RequiredNotSetError indicating which required field was not set.
+func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
+ st := sv.Type()
+ sprops := GetProperties(st)
+ for i := 0; i < st.NumField(); i++ {
+ if !isNil(sv.Field(i)) {
+ continue
+ }
+
+ props := sprops.Prop[i]
+ if props.Required {
+ return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
+ }
+ }
+ return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
+}
+
+// Returns the index in the struct for the named field, as well as the parsed tag properties.
+func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
+ i, ok := sprops.decoderOrigNames[name]
+ if ok {
+ return i, sprops.Prop[i], true
+ }
+ return -1, nil, false
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value != ":" {
+ // Colon is optional when the field is a group or message.
+ needColon := true
+ switch props.Wire {
+ case "group":
+ needColon = false
+ case "bytes":
+ // A "bytes" field is either a message, a string, or a repeated field;
+ // those three become *T, *string and []T respectively, so we can check for
+ // this field being a pointer to a non-string.
+ if typ.Kind() == reflect.Ptr {
+ // *T or *string
+ if typ.Elem().Kind() == reflect.String {
+ break
+ }
+ } else if typ.Kind() == reflect.Slice {
+ // []T or []*T
+ if typ.Elem().Kind() != reflect.Ptr {
+ break
+ }
+ } else if typ.Kind() == reflect.String {
+ // The proto3 exception is for a string field,
+ // which requires a colon.
+ break
+ }
+ needColon = false
+ }
+ if needColon {
+ return p.errorf("expected ':', found %q", tok.value)
+ }
+ p.back()
+ }
+ return nil
+}
+
+func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
+ st := sv.Type()
+ sprops := GetProperties(st)
+ reqCount := sprops.reqCount
+ var reqFieldErr error
+ fieldSet := make(map[string]bool)
+ // A struct is a sequence of "name: value", terminated by one of
+ // '>' or '}', or the end of the input. A name may also be
+ // "[extension]" or "[type/url]".
+ //
+ // The whole struct can also be an expanded Any message, like:
+ // [type/url] < ... struct contents ... >
+ for {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == terminator {
+ break
+ }
+ if tok.value == "[" {
+ // Looks like an extension or an Any.
+ //
+ // TODO: Check whether we need to handle
+ // namespace rooted names (e.g. ".something.Foo").
+ extName, err := p.consumeExtName()
+ if err != nil {
+ return err
+ }
+
+ if s := strings.LastIndex(extName, "/"); s >= 0 {
+ // If it contains a slash, it's an Any type URL.
+ messageName := extName[s+1:]
+ mt := MessageType(messageName)
+ if mt == nil {
+ return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
+ }
+ tok = p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ // consume an optional colon
+ if tok.value == ":" {
+ tok = p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ }
+ var terminator string
+ switch tok.value {
+ case "<":
+ terminator = ">"
+ case "{":
+ terminator = "}"
+ default:
+ return p.errorf("expected '{' or '<', found %q", tok.value)
+ }
+ v := reflect.New(mt.Elem())
+ if pe := p.readStruct(v.Elem(), terminator); pe != nil {
+ return pe
+ }
+ b, err := Marshal(v.Interface().(Message))
+ if err != nil {
+ return p.errorf("failed to marshal message of type %q: %v", messageName, err)
+ }
+ if fieldSet["type_url"] {
+ return p.errorf(anyRepeatedlyUnpacked, "type_url")
+ }
+ if fieldSet["value"] {
+ return p.errorf(anyRepeatedlyUnpacked, "value")
+ }
+ sv.FieldByName("TypeUrl").SetString(extName)
+ sv.FieldByName("Value").SetBytes(b)
+ fieldSet["type_url"] = true
+ fieldSet["value"] = true
+ continue
+ }
+
+ var desc *ExtensionDesc
+ // This could be faster, but it's functional.
+ // TODO: Do something smarter than a linear scan.
+ for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
+ if d.Name == extName {
+ desc = d
+ break
+ }
+ }
+ if desc == nil {
+ return p.errorf("unrecognized extension %q", extName)
+ }
+
+ props := &Properties{}
+ props.Parse(desc.Tag)
+
+ typ := reflect.TypeOf(desc.ExtensionType)
+ if err := p.checkForColon(props, typ); err != nil {
+ return err
+ }
+
+ rep := desc.repeated()
+
+ // Read the extension structure, and set it in
+ // the value we're constructing.
+ var ext reflect.Value
+ if !rep {
+ ext = reflect.New(typ).Elem()
+ } else {
+ ext = reflect.New(typ.Elem()).Elem()
+ }
+ if err := p.readAny(ext, props); err != nil {
+ if _, ok := err.(*RequiredNotSetError); !ok {
+ return err
+ }
+ reqFieldErr = err
+ }
+ ep := sv.Addr().Interface().(Message)
+ if !rep {
+ SetExtension(ep, desc, ext.Interface())
+ } else {
+ old, err := GetExtension(ep, desc)
+ var sl reflect.Value
+ if err == nil {
+ sl = reflect.ValueOf(old) // existing slice
+ } else {
+ sl = reflect.MakeSlice(typ, 0, 1)
+ }
+ sl = reflect.Append(sl, ext)
+ SetExtension(ep, desc, sl.Interface())
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ continue
+ }
+
+ // This is a normal, non-extension field.
+ name := tok.value
+ var dst reflect.Value
+ fi, props, ok := structFieldByName(sprops, name)
+ if ok {
+ dst = sv.Field(fi)
+ } else if oop, ok := sprops.OneofTypes[name]; ok {
+ // It is a oneof.
+ props = oop.Prop
+ nv := reflect.New(oop.Type.Elem())
+ dst = nv.Elem().Field(0)
+ field := sv.Field(oop.Field)
+ if !field.IsNil() {
+ return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
+ }
+ field.Set(nv)
+ }
+ if !dst.IsValid() {
+ return p.errorf("unknown field name %q in %v", name, st)
+ }
+
+ if dst.Kind() == reflect.Map {
+ // Consume any colon.
+ if err := p.checkForColon(props, dst.Type()); err != nil {
+ return err
+ }
+
+ // Construct the map if it doesn't already exist.
+ if dst.IsNil() {
+ dst.Set(reflect.MakeMap(dst.Type()))
+ }
+ key := reflect.New(dst.Type().Key()).Elem()
+ val := reflect.New(dst.Type().Elem()).Elem()
+
+ // The map entry should be this sequence of tokens:
+ // < key : KEY value : VALUE >
+ // However, implementations may omit key or value, and technically
+ // we should support them in any order. See b/28924776 for a time
+ // this went wrong.
+
+ tok := p.next()
+ var terminator string
+ switch tok.value {
+ case "<":
+ terminator = ">"
+ case "{":
+ terminator = "}"
+ default:
+ return p.errorf("expected '{' or '<', found %q", tok.value)
+ }
+ for {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == terminator {
+ break
+ }
+ switch tok.value {
+ case "key":
+ if err := p.consumeToken(":"); err != nil {
+ return err
+ }
+ if err := p.readAny(key, props.MapKeyProp); err != nil {
+ return err
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ case "value":
+ if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
+ return err
+ }
+ if err := p.readAny(val, props.MapValProp); err != nil {
+ return err
+ }
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+ default:
+ p.back()
+ return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+ }
+ }
+
+ dst.SetMapIndex(key, val)
+ continue
+ }
+
+ // Check that it's not already set if it's not a repeated field.
+ if !props.Repeated && fieldSet[name] {
+ return p.errorf("non-repeated field %q was repeated", name)
+ }
+
+ if err := p.checkForColon(props, dst.Type()); err != nil {
+ return err
+ }
+
+ // Parse into the field.
+ fieldSet[name] = true
+ if err := p.readAny(dst, props); err != nil {
+ if _, ok := err.(*RequiredNotSetError); !ok {
+ return err
+ }
+ reqFieldErr = err
+ }
+ if props.Required {
+ reqCount--
+ }
+
+ if err := p.consumeOptionalSeparator(); err != nil {
+ return err
+ }
+
+ }
+
+ if reqCount > 0 {
+ return p.missingRequiredFieldError(sv)
+ }
+ return reqFieldErr
+}
+
+// consumeExtName consumes extension name or expanded Any type URL and the
+// following ']'. It returns the name or URL consumed.
+func (p *textParser) consumeExtName() (string, error) {
+ tok := p.next()
+ if tok.err != nil {
+ return "", tok.err
+ }
+
+ // If extension name or type url is quoted, it's a single token.
+ if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
+ name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
+ if err != nil {
+ return "", err
+ }
+ return name, p.consumeToken("]")
+ }
+
+ // Consume everything up to "]"
+ var parts []string
+ for tok.value != "]" {
+ parts = append(parts, tok.value)
+ tok = p.next()
+ if tok.err != nil {
+ return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
+ }
+ if p.done && tok.value != "]" {
+ return "", p.errorf("unclosed type_url or extension name")
+ }
+ }
+ return strings.Join(parts, ""), nil
+}
+
+// consumeOptionalSeparator consumes an optional semicolon or comma.
+// It is used in readStruct to provide backward compatibility.
+func (p *textParser) consumeOptionalSeparator() error {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value != ";" && tok.value != "," {
+ p.back()
+ }
+ return nil
+}
+
+func (p *textParser) readAny(v reflect.Value, props *Properties) error {
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == "" {
+ return p.errorf("unexpected EOF")
+ }
+
+ switch fv := v; fv.Kind() {
+ case reflect.Slice:
+ at := v.Type()
+ if at.Elem().Kind() == reflect.Uint8 {
+ // Special case for []byte
+ if tok.value[0] != '"' && tok.value[0] != '\'' {
+ // Deliberately written out here, as the error after
+ // this switch statement would write "invalid []byte: ...",
+ // which is not as user-friendly.
+ return p.errorf("invalid string: %v", tok.value)
+ }
+ bytes := []byte(tok.unquoted)
+ fv.Set(reflect.ValueOf(bytes))
+ return nil
+ }
+ // Repeated field.
+ if tok.value == "[" {
+ // Repeated field with list notation, like [1,2,3].
+ for {
+ fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+ err := p.readAny(fv.Index(fv.Len()-1), props)
+ if err != nil {
+ return err
+ }
+ tok := p.next()
+ if tok.err != nil {
+ return tok.err
+ }
+ if tok.value == "]" {
+ break
+ }
+ if tok.value != "," {
+ return p.errorf("Expected ']' or ',' found %q", tok.value)
+ }
+ }
+ return nil
+ }
+ // One value of the repeated field.
+ p.back()
+ fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+ return p.readAny(fv.Index(fv.Len()-1), props)
+ case reflect.Bool:
+ // true/1/t/True or false/f/0/False.
+ switch tok.value {
+ case "true", "1", "t", "True":
+ fv.SetBool(true)
+ return nil
+ case "false", "0", "f", "False":
+ fv.SetBool(false)
+ return nil
+ }
+ case reflect.Float32, reflect.Float64:
+ v := tok.value
+ // Ignore 'f' for compatibility with output generated by C++, but don't
+ // remove 'f' when the value is "-inf" or "inf".
+ if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
+ v = v[:len(v)-1]
+ }
+ if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
+ fv.SetFloat(f)
+ return nil
+ }
+ case reflect.Int32:
+ if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+ fv.SetInt(x)
+ return nil
+ }
+
+ if len(props.Enum) == 0 {
+ break
+ }
+ m, ok := enumValueMaps[props.Enum]
+ if !ok {
+ break
+ }
+ x, ok := m[tok.value]
+ if !ok {
+ break
+ }
+ fv.SetInt(int64(x))
+ return nil
+ case reflect.Int64:
+ if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+ fv.SetInt(x)
+ return nil
+ }
+
+ case reflect.Ptr:
+ // A basic field (indirected through pointer), or a repeated message/group
+ p.back()
+ fv.Set(reflect.New(fv.Type().Elem()))
+ return p.readAny(fv.Elem(), props)
+ case reflect.String:
+ if tok.value[0] == '"' || tok.value[0] == '\'' {
+ fv.SetString(tok.unquoted)
+ return nil
+ }
+ case reflect.Struct:
+ var terminator string
+ switch tok.value {
+ case "{":
+ terminator = "}"
+ case "<":
+ terminator = ">"
+ default:
+ return p.errorf("expected '{' or '<', found %q", tok.value)
+ }
+ // TODO: Handle nested messages which implement encoding.TextUnmarshaler.
+ return p.readStruct(fv, terminator)
+ case reflect.Uint32:
+ if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+ fv.SetUint(uint64(x))
+ return nil
+ }
+ case reflect.Uint64:
+ if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+ fv.SetUint(x)
+ return nil
+ }
+ }
+ return p.errorf("invalid %v: %v", v.Type(), tok.value)
+}
+
+// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
+// before starting to unmarshal, so any existing data in pb is always removed.
+// If a required field is not set and no other error occurs,
+// UnmarshalText returns *RequiredNotSetError.
+func UnmarshalText(s string, pb Message) error {
+ if um, ok := pb.(encoding.TextUnmarshaler); ok {
+ return um.UnmarshalText([]byte(s))
+ }
+ pb.Reset()
+ v := reflect.ValueOf(pb)
+ return newTextParser(s).readStruct(v.Elem(), "")
+}
diff --git a/vendor/github.com/golang/protobuf/proto/wire.go b/vendor/github.com/golang/protobuf/proto/wire.go
deleted file mode 100644
index d7c28da..0000000
--- a/vendor/github.com/golang/protobuf/proto/wire.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- protoV2 "google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Size returns the size in bytes of the wire-format encoding of m.
-func Size(m Message) int {
- if m == nil {
- return 0
- }
- mi := MessageV2(m)
- return protoV2.Size(mi)
-}
-
-// Marshal returns the wire-format encoding of m.
-func Marshal(m Message) ([]byte, error) {
- b, err := marshalAppend(nil, m, false)
- if b == nil {
- b = zeroBytes
- }
- return b, err
-}
-
-var zeroBytes = make([]byte, 0, 0)
-
-func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) {
- if m == nil {
- return nil, ErrNil
- }
- mi := MessageV2(m)
- nbuf, err := protoV2.MarshalOptions{
- Deterministic: deterministic,
- AllowPartial: true,
- }.MarshalAppend(buf, mi)
- if err != nil {
- return buf, err
- }
- if len(buf) == len(nbuf) {
- if !mi.ProtoReflect().IsValid() {
- return buf, ErrNil
- }
- }
- return nbuf, checkRequiredNotSet(mi)
-}
-
-// Unmarshal parses a wire-format message in b and places the decoded results in m.
-//
-// Unmarshal resets m before starting to unmarshal, so any existing data in m is always
-// removed. Use UnmarshalMerge to preserve and append to existing data.
-func Unmarshal(b []byte, m Message) error {
- m.Reset()
- return UnmarshalMerge(b, m)
-}
-
-// UnmarshalMerge parses a wire-format message in b and places the decoded results in m.
-func UnmarshalMerge(b []byte, m Message) error {
- mi := MessageV2(m)
- out, err := protoV2.UnmarshalOptions{
- AllowPartial: true,
- Merge: true,
- }.UnmarshalState(protoiface.UnmarshalInput{
- Buf: b,
- Message: mi.ProtoReflect(),
- })
- if err != nil {
- return err
- }
- if out.Flags&protoiface.UnmarshalInitialized > 0 {
- return nil
- }
- return checkRequiredNotSet(mi)
-}
diff --git a/vendor/github.com/golang/protobuf/proto/wrappers.go b/vendor/github.com/golang/protobuf/proto/wrappers.go
deleted file mode 100644
index 398e348..0000000
--- a/vendor/github.com/golang/protobuf/proto/wrappers.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-// Bool stores v in a new bool value and returns a pointer to it.
-func Bool(v bool) *bool { return &v }
-
-// Int stores v in a new int32 value and returns a pointer to it.
-//
-// Deprecated: Use Int32 instead.
-func Int(v int) *int32 { return Int32(int32(v)) }
-
-// Int32 stores v in a new int32 value and returns a pointer to it.
-func Int32(v int32) *int32 { return &v }
-
-// Int64 stores v in a new int64 value and returns a pointer to it.
-func Int64(v int64) *int64 { return &v }
-
-// Uint32 stores v in a new uint32 value and returns a pointer to it.
-func Uint32(v uint32) *uint32 { return &v }
-
-// Uint64 stores v in a new uint64 value and returns a pointer to it.
-func Uint64(v uint64) *uint64 { return &v }
-
-// Float32 stores v in a new float32 value and returns a pointer to it.
-func Float32(v float32) *float32 { return &v }
-
-// Float64 stores v in a new float64 value and returns a pointer to it.
-func Float64(v float64) *float64 { return &v }
-
-// String stores v in a new string value and returns a pointer to it.
-func String(v string) *string { return &v }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
index 63dc057..1ded05b 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
@@ -1,200 +1,2887 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
+// source: google/protobuf/descriptor.proto
package descriptor
import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- descriptorpb "google.golang.org/protobuf/types/descriptorpb"
- reflect "reflect"
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
)
-// Symbols defined in public import of google/protobuf/descriptor.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
-type FieldDescriptorProto_Type = descriptorpb.FieldDescriptorProto_Type
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-const FieldDescriptorProto_TYPE_DOUBLE = descriptorpb.FieldDescriptorProto_TYPE_DOUBLE
-const FieldDescriptorProto_TYPE_FLOAT = descriptorpb.FieldDescriptorProto_TYPE_FLOAT
-const FieldDescriptorProto_TYPE_INT64 = descriptorpb.FieldDescriptorProto_TYPE_INT64
-const FieldDescriptorProto_TYPE_UINT64 = descriptorpb.FieldDescriptorProto_TYPE_UINT64
-const FieldDescriptorProto_TYPE_INT32 = descriptorpb.FieldDescriptorProto_TYPE_INT32
-const FieldDescriptorProto_TYPE_FIXED64 = descriptorpb.FieldDescriptorProto_TYPE_FIXED64
-const FieldDescriptorProto_TYPE_FIXED32 = descriptorpb.FieldDescriptorProto_TYPE_FIXED32
-const FieldDescriptorProto_TYPE_BOOL = descriptorpb.FieldDescriptorProto_TYPE_BOOL
-const FieldDescriptorProto_TYPE_STRING = descriptorpb.FieldDescriptorProto_TYPE_STRING
-const FieldDescriptorProto_TYPE_GROUP = descriptorpb.FieldDescriptorProto_TYPE_GROUP
-const FieldDescriptorProto_TYPE_MESSAGE = descriptorpb.FieldDescriptorProto_TYPE_MESSAGE
-const FieldDescriptorProto_TYPE_BYTES = descriptorpb.FieldDescriptorProto_TYPE_BYTES
-const FieldDescriptorProto_TYPE_UINT32 = descriptorpb.FieldDescriptorProto_TYPE_UINT32
-const FieldDescriptorProto_TYPE_ENUM = descriptorpb.FieldDescriptorProto_TYPE_ENUM
-const FieldDescriptorProto_TYPE_SFIXED32 = descriptorpb.FieldDescriptorProto_TYPE_SFIXED32
-const FieldDescriptorProto_TYPE_SFIXED64 = descriptorpb.FieldDescriptorProto_TYPE_SFIXED64
-const FieldDescriptorProto_TYPE_SINT32 = descriptorpb.FieldDescriptorProto_TYPE_SINT32
-const FieldDescriptorProto_TYPE_SINT64 = descriptorpb.FieldDescriptorProto_TYPE_SINT64
+type FieldDescriptorProto_Type int32
-var FieldDescriptorProto_Type_name = descriptorpb.FieldDescriptorProto_Type_name
-var FieldDescriptorProto_Type_value = descriptorpb.FieldDescriptorProto_Type_value
+const (
+ // 0 is reserved for errors.
+ // Order is weird for historical reasons.
+ FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
+ FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
+ // negative values are likely.
+ FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3
+ FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
+ // negative values are likely.
+ FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5
+ FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
+ FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
+ FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8
+ FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9
+ // Tag-delimited aggregate.
+ // Group type is deprecated and not supported in proto3. However, Proto3
+ // implementations should still be able to parse the group wire format and
+ // treat group fields as unknown fields.
+ FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10
+ FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11
+ // New in version 2.
+ FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12
+ FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13
+ FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14
+ FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
+ FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
+ FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17
+ FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18
+)
-type FieldDescriptorProto_Label = descriptorpb.FieldDescriptorProto_Label
-
-const FieldDescriptorProto_LABEL_OPTIONAL = descriptorpb.FieldDescriptorProto_LABEL_OPTIONAL
-const FieldDescriptorProto_LABEL_REQUIRED = descriptorpb.FieldDescriptorProto_LABEL_REQUIRED
-const FieldDescriptorProto_LABEL_REPEATED = descriptorpb.FieldDescriptorProto_LABEL_REPEATED
-
-var FieldDescriptorProto_Label_name = descriptorpb.FieldDescriptorProto_Label_name
-var FieldDescriptorProto_Label_value = descriptorpb.FieldDescriptorProto_Label_value
-
-type FileOptions_OptimizeMode = descriptorpb.FileOptions_OptimizeMode
-
-const FileOptions_SPEED = descriptorpb.FileOptions_SPEED
-const FileOptions_CODE_SIZE = descriptorpb.FileOptions_CODE_SIZE
-const FileOptions_LITE_RUNTIME = descriptorpb.FileOptions_LITE_RUNTIME
-
-var FileOptions_OptimizeMode_name = descriptorpb.FileOptions_OptimizeMode_name
-var FileOptions_OptimizeMode_value = descriptorpb.FileOptions_OptimizeMode_value
-
-type FieldOptions_CType = descriptorpb.FieldOptions_CType
-
-const FieldOptions_STRING = descriptorpb.FieldOptions_STRING
-const FieldOptions_CORD = descriptorpb.FieldOptions_CORD
-const FieldOptions_STRING_PIECE = descriptorpb.FieldOptions_STRING_PIECE
-
-var FieldOptions_CType_name = descriptorpb.FieldOptions_CType_name
-var FieldOptions_CType_value = descriptorpb.FieldOptions_CType_value
-
-type FieldOptions_JSType = descriptorpb.FieldOptions_JSType
-
-const FieldOptions_JS_NORMAL = descriptorpb.FieldOptions_JS_NORMAL
-const FieldOptions_JS_STRING = descriptorpb.FieldOptions_JS_STRING
-const FieldOptions_JS_NUMBER = descriptorpb.FieldOptions_JS_NUMBER
-
-var FieldOptions_JSType_name = descriptorpb.FieldOptions_JSType_name
-var FieldOptions_JSType_value = descriptorpb.FieldOptions_JSType_value
-
-type MethodOptions_IdempotencyLevel = descriptorpb.MethodOptions_IdempotencyLevel
-
-const MethodOptions_IDEMPOTENCY_UNKNOWN = descriptorpb.MethodOptions_IDEMPOTENCY_UNKNOWN
-const MethodOptions_NO_SIDE_EFFECTS = descriptorpb.MethodOptions_NO_SIDE_EFFECTS
-const MethodOptions_IDEMPOTENT = descriptorpb.MethodOptions_IDEMPOTENT
-
-var MethodOptions_IdempotencyLevel_name = descriptorpb.MethodOptions_IdempotencyLevel_name
-var MethodOptions_IdempotencyLevel_value = descriptorpb.MethodOptions_IdempotencyLevel_value
-
-type FileDescriptorSet = descriptorpb.FileDescriptorSet
-type FileDescriptorProto = descriptorpb.FileDescriptorProto
-type DescriptorProto = descriptorpb.DescriptorProto
-type ExtensionRangeOptions = descriptorpb.ExtensionRangeOptions
-type FieldDescriptorProto = descriptorpb.FieldDescriptorProto
-type OneofDescriptorProto = descriptorpb.OneofDescriptorProto
-type EnumDescriptorProto = descriptorpb.EnumDescriptorProto
-type EnumValueDescriptorProto = descriptorpb.EnumValueDescriptorProto
-type ServiceDescriptorProto = descriptorpb.ServiceDescriptorProto
-type MethodDescriptorProto = descriptorpb.MethodDescriptorProto
-
-const Default_MethodDescriptorProto_ClientStreaming = descriptorpb.Default_MethodDescriptorProto_ClientStreaming
-const Default_MethodDescriptorProto_ServerStreaming = descriptorpb.Default_MethodDescriptorProto_ServerStreaming
-
-type FileOptions = descriptorpb.FileOptions
-
-const Default_FileOptions_JavaMultipleFiles = descriptorpb.Default_FileOptions_JavaMultipleFiles
-const Default_FileOptions_JavaStringCheckUtf8 = descriptorpb.Default_FileOptions_JavaStringCheckUtf8
-const Default_FileOptions_OptimizeFor = descriptorpb.Default_FileOptions_OptimizeFor
-const Default_FileOptions_CcGenericServices = descriptorpb.Default_FileOptions_CcGenericServices
-const Default_FileOptions_JavaGenericServices = descriptorpb.Default_FileOptions_JavaGenericServices
-const Default_FileOptions_PyGenericServices = descriptorpb.Default_FileOptions_PyGenericServices
-const Default_FileOptions_PhpGenericServices = descriptorpb.Default_FileOptions_PhpGenericServices
-const Default_FileOptions_Deprecated = descriptorpb.Default_FileOptions_Deprecated
-const Default_FileOptions_CcEnableArenas = descriptorpb.Default_FileOptions_CcEnableArenas
-
-type MessageOptions = descriptorpb.MessageOptions
-
-const Default_MessageOptions_MessageSetWireFormat = descriptorpb.Default_MessageOptions_MessageSetWireFormat
-const Default_MessageOptions_NoStandardDescriptorAccessor = descriptorpb.Default_MessageOptions_NoStandardDescriptorAccessor
-const Default_MessageOptions_Deprecated = descriptorpb.Default_MessageOptions_Deprecated
-
-type FieldOptions = descriptorpb.FieldOptions
-
-const Default_FieldOptions_Ctype = descriptorpb.Default_FieldOptions_Ctype
-const Default_FieldOptions_Jstype = descriptorpb.Default_FieldOptions_Jstype
-const Default_FieldOptions_Lazy = descriptorpb.Default_FieldOptions_Lazy
-const Default_FieldOptions_Deprecated = descriptorpb.Default_FieldOptions_Deprecated
-const Default_FieldOptions_Weak = descriptorpb.Default_FieldOptions_Weak
-
-type OneofOptions = descriptorpb.OneofOptions
-type EnumOptions = descriptorpb.EnumOptions
-
-const Default_EnumOptions_Deprecated = descriptorpb.Default_EnumOptions_Deprecated
-
-type EnumValueOptions = descriptorpb.EnumValueOptions
-
-const Default_EnumValueOptions_Deprecated = descriptorpb.Default_EnumValueOptions_Deprecated
-
-type ServiceOptions = descriptorpb.ServiceOptions
-
-const Default_ServiceOptions_Deprecated = descriptorpb.Default_ServiceOptions_Deprecated
-
-type MethodOptions = descriptorpb.MethodOptions
-
-const Default_MethodOptions_Deprecated = descriptorpb.Default_MethodOptions_Deprecated
-const Default_MethodOptions_IdempotencyLevel = descriptorpb.Default_MethodOptions_IdempotencyLevel
-
-type UninterpretedOption = descriptorpb.UninterpretedOption
-type SourceCodeInfo = descriptorpb.SourceCodeInfo
-type GeneratedCodeInfo = descriptorpb.GeneratedCodeInfo
-type DescriptorProto_ExtensionRange = descriptorpb.DescriptorProto_ExtensionRange
-type DescriptorProto_ReservedRange = descriptorpb.DescriptorProto_ReservedRange
-type EnumDescriptorProto_EnumReservedRange = descriptorpb.EnumDescriptorProto_EnumReservedRange
-type UninterpretedOption_NamePart = descriptorpb.UninterpretedOption_NamePart
-type SourceCodeInfo_Location = descriptorpb.SourceCodeInfo_Location
-type GeneratedCodeInfo_Annotation = descriptorpb.GeneratedCodeInfo_Annotation
-
-var File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc = []byte{
- 0x0a, 0x44, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
- 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f,
- 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72,
- 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
- 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
- 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x40, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68,
- 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72,
- 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
- 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3b,
- 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72,
- 0x6f, 0x74, 0x6f, 0x32,
+var FieldDescriptorProto_Type_name = map[int32]string{
+ 1: "TYPE_DOUBLE",
+ 2: "TYPE_FLOAT",
+ 3: "TYPE_INT64",
+ 4: "TYPE_UINT64",
+ 5: "TYPE_INT32",
+ 6: "TYPE_FIXED64",
+ 7: "TYPE_FIXED32",
+ 8: "TYPE_BOOL",
+ 9: "TYPE_STRING",
+ 10: "TYPE_GROUP",
+ 11: "TYPE_MESSAGE",
+ 12: "TYPE_BYTES",
+ 13: "TYPE_UINT32",
+ 14: "TYPE_ENUM",
+ 15: "TYPE_SFIXED32",
+ 16: "TYPE_SFIXED64",
+ 17: "TYPE_SINT32",
+ 18: "TYPE_SINT64",
}
-var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_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
+var FieldDescriptorProto_Type_value = map[string]int32{
+ "TYPE_DOUBLE": 1,
+ "TYPE_FLOAT": 2,
+ "TYPE_INT64": 3,
+ "TYPE_UINT64": 4,
+ "TYPE_INT32": 5,
+ "TYPE_FIXED64": 6,
+ "TYPE_FIXED32": 7,
+ "TYPE_BOOL": 8,
+ "TYPE_STRING": 9,
+ "TYPE_GROUP": 10,
+ "TYPE_MESSAGE": 11,
+ "TYPE_BYTES": 12,
+ "TYPE_UINT32": 13,
+ "TYPE_ENUM": 14,
+ "TYPE_SFIXED32": 15,
+ "TYPE_SFIXED64": 16,
+ "TYPE_SINT32": 17,
+ "TYPE_SINT64": 18,
}
-func init() { file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_init() }
-func file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_init() {
- if File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto != nil {
- return
+func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
+ p := new(FieldDescriptorProto_Type)
+ *p = x
+ return p
+}
+
+func (x FieldDescriptorProto_Type) String() string {
+ return proto.EnumName(FieldDescriptorProto_Type_name, int32(x))
+}
+
+func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type")
+ if err != nil {
+ return err
}
- type x struct{}
- out := protoimpl.TypeBuilder{
- File: protoimpl.DescBuilder{
- GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc,
- NumEnums: 0,
- NumMessages: 0,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes,
- DependencyIndexes: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs,
- }.Build()
- File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto = out.File
- file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc = nil
- file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = nil
- file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs = nil
+ *x = FieldDescriptorProto_Type(value)
+ return nil
+}
+
+func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{4, 0}
+}
+
+type FieldDescriptorProto_Label int32
+
+const (
+ // 0 is reserved for errors
+ FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
+ FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
+ FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
+)
+
+var FieldDescriptorProto_Label_name = map[int32]string{
+ 1: "LABEL_OPTIONAL",
+ 2: "LABEL_REQUIRED",
+ 3: "LABEL_REPEATED",
+}
+
+var FieldDescriptorProto_Label_value = map[string]int32{
+ "LABEL_OPTIONAL": 1,
+ "LABEL_REQUIRED": 2,
+ "LABEL_REPEATED": 3,
+}
+
+func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
+ p := new(FieldDescriptorProto_Label)
+ *p = x
+ return p
+}
+
+func (x FieldDescriptorProto_Label) String() string {
+ return proto.EnumName(FieldDescriptorProto_Label_name, int32(x))
+}
+
+func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label")
+ if err != nil {
+ return err
+ }
+ *x = FieldDescriptorProto_Label(value)
+ return nil
+}
+
+func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{4, 1}
+}
+
+// Generated classes can be optimized for speed or code size.
+type FileOptions_OptimizeMode int32
+
+const (
+ FileOptions_SPEED FileOptions_OptimizeMode = 1
+ // etc.
+ FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2
+ FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3
+)
+
+var FileOptions_OptimizeMode_name = map[int32]string{
+ 1: "SPEED",
+ 2: "CODE_SIZE",
+ 3: "LITE_RUNTIME",
+}
+
+var FileOptions_OptimizeMode_value = map[string]int32{
+ "SPEED": 1,
+ "CODE_SIZE": 2,
+ "LITE_RUNTIME": 3,
+}
+
+func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
+ p := new(FileOptions_OptimizeMode)
+ *p = x
+ return p
+}
+
+func (x FileOptions_OptimizeMode) String() string {
+ return proto.EnumName(FileOptions_OptimizeMode_name, int32(x))
+}
+
+func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode")
+ if err != nil {
+ return err
+ }
+ *x = FileOptions_OptimizeMode(value)
+ return nil
+}
+
+func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{10, 0}
+}
+
+type FieldOptions_CType int32
+
+const (
+ // Default mode.
+ FieldOptions_STRING FieldOptions_CType = 0
+ FieldOptions_CORD FieldOptions_CType = 1
+ FieldOptions_STRING_PIECE FieldOptions_CType = 2
+)
+
+var FieldOptions_CType_name = map[int32]string{
+ 0: "STRING",
+ 1: "CORD",
+ 2: "STRING_PIECE",
+}
+
+var FieldOptions_CType_value = map[string]int32{
+ "STRING": 0,
+ "CORD": 1,
+ "STRING_PIECE": 2,
+}
+
+func (x FieldOptions_CType) Enum() *FieldOptions_CType {
+ p := new(FieldOptions_CType)
+ *p = x
+ return p
+}
+
+func (x FieldOptions_CType) String() string {
+ return proto.EnumName(FieldOptions_CType_name, int32(x))
+}
+
+func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType")
+ if err != nil {
+ return err
+ }
+ *x = FieldOptions_CType(value)
+ return nil
+}
+
+func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{12, 0}
+}
+
+type FieldOptions_JSType int32
+
+const (
+ // Use the default type.
+ FieldOptions_JS_NORMAL FieldOptions_JSType = 0
+ // Use JavaScript strings.
+ FieldOptions_JS_STRING FieldOptions_JSType = 1
+ // Use JavaScript numbers.
+ FieldOptions_JS_NUMBER FieldOptions_JSType = 2
+)
+
+var FieldOptions_JSType_name = map[int32]string{
+ 0: "JS_NORMAL",
+ 1: "JS_STRING",
+ 2: "JS_NUMBER",
+}
+
+var FieldOptions_JSType_value = map[string]int32{
+ "JS_NORMAL": 0,
+ "JS_STRING": 1,
+ "JS_NUMBER": 2,
+}
+
+func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
+ p := new(FieldOptions_JSType)
+ *p = x
+ return p
+}
+
+func (x FieldOptions_JSType) String() string {
+ return proto.EnumName(FieldOptions_JSType_name, int32(x))
+}
+
+func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType")
+ if err != nil {
+ return err
+ }
+ *x = FieldOptions_JSType(value)
+ return nil
+}
+
+func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{12, 1}
+}
+
+// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+// or neither? HTTP based RPC implementation may choose GET verb for safe
+// methods, and PUT verb for idempotent methods instead of the default POST.
+type MethodOptions_IdempotencyLevel int32
+
+const (
+ MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
+ MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1
+ MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2
+)
+
+var MethodOptions_IdempotencyLevel_name = map[int32]string{
+ 0: "IDEMPOTENCY_UNKNOWN",
+ 1: "NO_SIDE_EFFECTS",
+ 2: "IDEMPOTENT",
+}
+
+var MethodOptions_IdempotencyLevel_value = map[string]int32{
+ "IDEMPOTENCY_UNKNOWN": 0,
+ "NO_SIDE_EFFECTS": 1,
+ "IDEMPOTENT": 2,
+}
+
+func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
+ p := new(MethodOptions_IdempotencyLevel)
+ *p = x
+ return p
+}
+
+func (x MethodOptions_IdempotencyLevel) String() string {
+ return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x))
+}
+
+func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel")
+ if err != nil {
+ return err
+ }
+ *x = MethodOptions_IdempotencyLevel(value)
+ return nil
+}
+
+func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{17, 0}
+}
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+type FileDescriptorSet struct {
+ File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} }
+func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorSet) ProtoMessage() {}
+func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{0}
+}
+
+func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b)
+}
+func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic)
+}
+func (m *FileDescriptorSet) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileDescriptorSet.Merge(m, src)
+}
+func (m *FileDescriptorSet) XXX_Size() int {
+ return xxx_messageInfo_FileDescriptorSet.Size(m)
+}
+func (m *FileDescriptorSet) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo
+
+func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto {
+ if m != nil {
+ return m.File
+ }
+ return nil
+}
+
+// Describes a complete .proto file.
+type FileDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"`
+ // Names of files imported by this file.
+ Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
+ // Indexes of the public imported files in the dependency list above.
+ PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
+ // Indexes of the weak imported files in the dependency list.
+ // For Google-internal migration only. Do not use.
+ WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
+ // All top-level definitions in this file.
+ MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
+ EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+ Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
+ Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
+ Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+ // This field contains optional information about the original source code.
+ // You may safely remove this entire field without harming runtime
+ // functionality of the descriptors -- the information is needed only by
+ // development tools.
+ SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
+ // The syntax of the proto file.
+ // The supported values are "proto2" and "proto3".
+ Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} }
+func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorProto) ProtoMessage() {}
+func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{1}
+}
+
+func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b)
+}
+func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *FileDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileDescriptorProto.Merge(m, src)
+}
+func (m *FileDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_FileDescriptorProto.Size(m)
+}
+func (m *FileDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo
+
+func (m *FileDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *FileDescriptorProto) GetPackage() string {
+ if m != nil && m.Package != nil {
+ return *m.Package
+ }
+ return ""
+}
+
+func (m *FileDescriptorProto) GetDependency() []string {
+ if m != nil {
+ return m.Dependency
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetPublicDependency() []int32 {
+ if m != nil {
+ return m.PublicDependency
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetWeakDependency() []int32 {
+ if m != nil {
+ return m.WeakDependency
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto {
+ if m != nil {
+ return m.MessageType
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
+ if m != nil {
+ return m.EnumType
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
+ if m != nil {
+ return m.Service
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
+ if m != nil {
+ return m.Extension
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetOptions() *FileOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
+ if m != nil {
+ return m.SourceCodeInfo
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetSyntax() string {
+ if m != nil && m.Syntax != nil {
+ return *m.Syntax
+ }
+ return ""
+}
+
+// Describes a message type.
+type DescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
+ Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
+ NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
+ EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+ ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
+ OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
+ Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
+ ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+ // Reserved field names, which may not be used by fields in the same message.
+ // A given name may only be reserved once.
+ ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DescriptorProto) Reset() { *m = DescriptorProto{} }
+func (m *DescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto) ProtoMessage() {}
+func (*DescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{2}
+}
+
+func (m *DescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_DescriptorProto.Unmarshal(m, b)
+}
+func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *DescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DescriptorProto.Merge(m, src)
+}
+func (m *DescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_DescriptorProto.Size(m)
+}
+func (m *DescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_DescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo
+
+func (m *DescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *DescriptorProto) GetField() []*FieldDescriptorProto {
+ if m != nil {
+ return m.Field
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto {
+ if m != nil {
+ return m.Extension
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetNestedType() []*DescriptorProto {
+ if m != nil {
+ return m.NestedType
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
+ if m != nil {
+ return m.EnumType
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
+ if m != nil {
+ return m.ExtensionRange
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
+ if m != nil {
+ return m.OneofDecl
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetOptions() *MessageOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
+ if m != nil {
+ return m.ReservedRange
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetReservedName() []string {
+ if m != nil {
+ return m.ReservedName
+ }
+ return nil
+}
+
+type DescriptorProto_ExtensionRange struct {
+ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+ Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} }
+func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
+func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{2, 0}
+}
+
+func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(m, src)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Size() int {
+ return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo
+
+func (m *DescriptorProto_ExtensionRange) GetStart() int32 {
+ if m != nil && m.Start != nil {
+ return *m.Start
+ }
+ return 0
+}
+
+func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Range of reserved tag numbers. Reserved tag numbers may not be used by
+// fields or extension ranges in the same message. Reserved ranges may
+// not overlap.
+type DescriptorProto_ReservedRange struct {
+ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} }
+func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto_ReservedRange) ProtoMessage() {}
+func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{2, 1}
+}
+
+func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DescriptorProto_ReservedRange.Merge(m, src)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Size() int {
+ return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m)
+}
+func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo
+
+func (m *DescriptorProto_ReservedRange) GetStart() int32 {
+ if m != nil && m.Start != nil {
+ return *m.Start
+ }
+ return 0
+}
+
+func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+type ExtensionRangeOptions struct {
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExtensionRangeOptions) Reset() { *m = ExtensionRangeOptions{} }
+func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) }
+func (*ExtensionRangeOptions) ProtoMessage() {}
+func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{3}
+}
+
+var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_ExtensionRangeOptions
+}
+
+func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b)
+}
+func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic)
+}
+func (m *ExtensionRangeOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExtensionRangeOptions.Merge(m, src)
+}
+func (m *ExtensionRangeOptions) XXX_Size() int {
+ return xxx_messageInfo_ExtensionRangeOptions.Size(m)
+}
+func (m *ExtensionRangeOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo
+
+func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+// Describes a field within a message.
+type FieldDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
+ Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
+ // If type_name is set, this need not be set. If both this and type_name
+ // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+ Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
+ // For message and enum types, this is the name of the type. If the name
+ // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
+ // rules are used to find the type (i.e. first the nested types within this
+ // message are searched, then within the parent, on up to the root
+ // namespace).
+ TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
+ // For extensions, this is the name of the type being extended. It is
+ // resolved in the same manner as type_name.
+ Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
+ // For numeric types, contains the original text representation of the value.
+ // For booleans, "true" or "false".
+ // For strings, contains the default text contents (not escaped in any way).
+ // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
+ // TODO(kenton): Base-64 encode?
+ DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
+ // If set, gives the index of a oneof in the containing type's oneof_decl
+ // list. This field is a member of that oneof.
+ OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
+ // JSON name of this field. The value is set by protocol compiler. If the
+ // user has set a "json_name" option on this field, that option's value
+ // will be used. Otherwise, it's deduced from the field's name by converting
+ // it to camelCase.
+ JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
+ Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} }
+func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*FieldDescriptorProto) ProtoMessage() {}
+func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{4}
+}
+
+func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b)
+}
+func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *FieldDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FieldDescriptorProto.Merge(m, src)
+}
+func (m *FieldDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_FieldDescriptorProto.Size(m)
+}
+func (m *FieldDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo
+
+func (m *FieldDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetNumber() int32 {
+ if m != nil && m.Number != nil {
+ return *m.Number
+ }
+ return 0
+}
+
+func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
+ if m != nil && m.Label != nil {
+ return *m.Label
+ }
+ return FieldDescriptorProto_LABEL_OPTIONAL
+}
+
+func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
+ if m != nil && m.Type != nil {
+ return *m.Type
+ }
+ return FieldDescriptorProto_TYPE_DOUBLE
+}
+
+func (m *FieldDescriptorProto) GetTypeName() string {
+ if m != nil && m.TypeName != nil {
+ return *m.TypeName
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetExtendee() string {
+ if m != nil && m.Extendee != nil {
+ return *m.Extendee
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetDefaultValue() string {
+ if m != nil && m.DefaultValue != nil {
+ return *m.DefaultValue
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetOneofIndex() int32 {
+ if m != nil && m.OneofIndex != nil {
+ return *m.OneofIndex
+ }
+ return 0
+}
+
+func (m *FieldDescriptorProto) GetJsonName() string {
+ if m != nil && m.JsonName != nil {
+ return *m.JsonName
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetOptions() *FieldOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes a oneof.
+type OneofDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} }
+func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*OneofDescriptorProto) ProtoMessage() {}
+func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{5}
+}
+
+func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b)
+}
+func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *OneofDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_OneofDescriptorProto.Merge(m, src)
+}
+func (m *OneofDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_OneofDescriptorProto.Size(m)
+}
+func (m *OneofDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo
+
+func (m *OneofDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *OneofDescriptorProto) GetOptions() *OneofOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes an enum type.
+type EnumDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
+ Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ // Range of reserved numeric values. Reserved numeric values may not be used
+ // by enum values in the same enum declaration. Reserved ranges may not
+ // overlap.
+ ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+ // Reserved enum value names, which may not be reused. A given name may only
+ // be reserved once.
+ ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} }
+func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*EnumDescriptorProto) ProtoMessage() {}
+func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{6}
+}
+
+func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b)
+}
+func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *EnumDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumDescriptorProto.Merge(m, src)
+}
+func (m *EnumDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_EnumDescriptorProto.Size(m)
+}
+func (m *EnumDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo
+
+func (m *EnumDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *EnumDescriptorProto) GetOptions() *EnumOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
+ if m != nil {
+ return m.ReservedRange
+ }
+ return nil
+}
+
+func (m *EnumDescriptorProto) GetReservedName() []string {
+ if m != nil {
+ return m.ReservedName
+ }
+ return nil
+}
+
+// Range of reserved numeric values. Reserved values may not be used by
+// entries in the same enum. Reserved ranges may not overlap.
+//
+// Note that this is distinct from DescriptorProto.ReservedRange in that it
+// is inclusive such that it can appropriately represent the entire int32
+// domain.
+type EnumDescriptorProto_EnumReservedRange struct {
+ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) Reset() { *m = EnumDescriptorProto_EnumReservedRange{} }
+func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) }
+func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
+func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{6, 0}
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(m, src)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int {
+ return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo
+
+func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
+ if m != nil && m.Start != nil {
+ return *m.Start
+ }
+ return 0
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+// Describes a value within an enum.
+type EnumValueDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
+ Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} }
+func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*EnumValueDescriptorProto) ProtoMessage() {}
+func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{7}
+}
+
+func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b)
+}
+func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *EnumValueDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumValueDescriptorProto.Merge(m, src)
+}
+func (m *EnumValueDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_EnumValueDescriptorProto.Size(m)
+}
+func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo
+
+func (m *EnumValueDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *EnumValueDescriptorProto) GetNumber() int32 {
+ if m != nil && m.Number != nil {
+ return *m.Number
+ }
+ return 0
+}
+
+func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes a service.
+type ServiceDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
+ Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} }
+func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*ServiceDescriptorProto) ProtoMessage() {}
+func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{8}
+}
+
+func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b)
+}
+func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *ServiceDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServiceDescriptorProto.Merge(m, src)
+}
+func (m *ServiceDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_ServiceDescriptorProto.Size(m)
+}
+func (m *ServiceDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo
+
+func (m *ServiceDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
+ if m != nil {
+ return m.Method
+ }
+ return nil
+}
+
+func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes a method of a service.
+type MethodDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ // Input and output type names. These are resolved in the same way as
+ // FieldDescriptorProto.type_name, but must refer to a message type.
+ InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
+ OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
+ Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
+ // Identifies if client streams multiple client messages
+ ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
+ // Identifies if server streams multiple server messages
+ ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} }
+func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*MethodDescriptorProto) ProtoMessage() {}
+func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{9}
+}
+
+func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b)
+}
+func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *MethodDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MethodDescriptorProto.Merge(m, src)
+}
+func (m *MethodDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_MethodDescriptorProto.Size(m)
+}
+func (m *MethodDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo
+
+const Default_MethodDescriptorProto_ClientStreaming bool = false
+const Default_MethodDescriptorProto_ServerStreaming bool = false
+
+func (m *MethodDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *MethodDescriptorProto) GetInputType() string {
+ if m != nil && m.InputType != nil {
+ return *m.InputType
+ }
+ return ""
+}
+
+func (m *MethodDescriptorProto) GetOutputType() string {
+ if m != nil && m.OutputType != nil {
+ return *m.OutputType
+ }
+ return ""
+}
+
+func (m *MethodDescriptorProto) GetOptions() *MethodOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *MethodDescriptorProto) GetClientStreaming() bool {
+ if m != nil && m.ClientStreaming != nil {
+ return *m.ClientStreaming
+ }
+ return Default_MethodDescriptorProto_ClientStreaming
+}
+
+func (m *MethodDescriptorProto) GetServerStreaming() bool {
+ if m != nil && m.ServerStreaming != nil {
+ return *m.ServerStreaming
+ }
+ return Default_MethodDescriptorProto_ServerStreaming
+}
+
+type FileOptions struct {
+ // Sets the Java package where classes generated from this .proto will be
+ // placed. By default, the proto package is used, but this is often
+ // inappropriate because proto packages do not normally start with backwards
+ // domain names.
+ JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
+ // If set, all the classes from the .proto file are wrapped in a single
+ // outer class with the given name. This applies to both Proto1
+ // (equivalent to the old "--one_java_file" option) and Proto2 (where
+ // a .proto always translates to a single class, but you may want to
+ // explicitly choose the class name).
+ JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
+ // If set true, then the Java code generator will generate a separate .java
+ // file for each top-level message, enum, and service defined in the .proto
+ // file. Thus, these types will *not* be nested inside the outer class
+ // named by java_outer_classname. However, the outer class will still be
+ // generated to contain the file's getDescriptor() method as well as any
+ // top-level extensions defined in the file.
+ JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
+ // This option does nothing.
+ JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use.
+ // If set true, then the Java2 code generator will generate code that
+ // throws an exception whenever an attempt is made to assign a non-UTF-8
+ // byte sequence to a string field.
+ // Message reflection will do the same.
+ // However, an extension field still accepts non-UTF-8 byte sequences.
+ // This option has no effect on when used with the lite runtime.
+ JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
+ OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
+ // Sets the Go package where structs generated from this .proto will be
+ // placed. If omitted, the Go package will be derived from the following:
+ // - The basename of the package import path, if provided.
+ // - Otherwise, the package statement in the .proto file, if present.
+ // - Otherwise, the basename of the .proto file, without extension.
+ GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
+ // Should generic services be generated in each language? "Generic" services
+ // are not specific to any particular RPC system. They are generated by the
+ // main code generators in each language (without additional plugins).
+ // Generic services were the only kind of service generation supported by
+ // early versions of google.protobuf.
+ //
+ // Generic services are now considered deprecated in favor of using plugins
+ // that generate code specific to your particular RPC system. Therefore,
+ // these default to false. Old code which depends on generic services should
+ // explicitly set them to true.
+ CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
+ JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
+ PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
+ PhpGenericServices *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
+ // Is this file deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for everything in the file, or it will be completely ignored; in the very
+ // least, this is a formalization for deprecating files.
+ Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // Enables the use of arenas for the proto messages in this file. This applies
+ // only to generated classes for C++.
+ CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"`
+ // Sets the objective c class prefix which is prepended to all objective c
+ // generated classes from this .proto. There is no default.
+ ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
+ // Namespace for generated classes; defaults to the package.
+ CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
+ // By default Swift generators will take the proto package and CamelCase it
+ // replacing '.' with underscore and use that to prefix the types/symbols
+ // defined. When this options is provided, they will use this value instead
+ // to prefix the types/symbols defined.
+ SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
+ // Sets the php class prefix which is prepended to all php generated classes
+ // from this .proto. Default is empty.
+ PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
+ // Use this option to change the namespace of php generated classes. Default
+ // is empty. When this option is empty, the package name will be used for
+ // determining the namespace.
+ PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
+ // Use this option to change the namespace of php generated metadata classes.
+ // Default is empty. When this option is empty, the proto file name will be used
+ // for determining the namespace.
+ PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
+ // Use this option to change the package of ruby generated classes. Default
+ // is empty. When this option is not set, the package name will be used for
+ // determining the ruby package.
+ RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
+ // The parser stores options it doesn't recognize here.
+ // See the documentation for the "Options" section above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileOptions) Reset() { *m = FileOptions{} }
+func (m *FileOptions) String() string { return proto.CompactTextString(m) }
+func (*FileOptions) ProtoMessage() {}
+func (*FileOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{10}
+}
+
+var extRange_FileOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_FileOptions
+}
+
+func (m *FileOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileOptions.Unmarshal(m, b)
+}
+func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic)
+}
+func (m *FileOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileOptions.Merge(m, src)
+}
+func (m *FileOptions) XXX_Size() int {
+ return xxx_messageInfo_FileOptions.Size(m)
+}
+func (m *FileOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileOptions proto.InternalMessageInfo
+
+const Default_FileOptions_JavaMultipleFiles bool = false
+const Default_FileOptions_JavaStringCheckUtf8 bool = false
+const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED
+const Default_FileOptions_CcGenericServices bool = false
+const Default_FileOptions_JavaGenericServices bool = false
+const Default_FileOptions_PyGenericServices bool = false
+const Default_FileOptions_PhpGenericServices bool = false
+const Default_FileOptions_Deprecated bool = false
+const Default_FileOptions_CcEnableArenas bool = false
+
+func (m *FileOptions) GetJavaPackage() string {
+ if m != nil && m.JavaPackage != nil {
+ return *m.JavaPackage
+ }
+ return ""
+}
+
+func (m *FileOptions) GetJavaOuterClassname() string {
+ if m != nil && m.JavaOuterClassname != nil {
+ return *m.JavaOuterClassname
+ }
+ return ""
+}
+
+func (m *FileOptions) GetJavaMultipleFiles() bool {
+ if m != nil && m.JavaMultipleFiles != nil {
+ return *m.JavaMultipleFiles
+ }
+ return Default_FileOptions_JavaMultipleFiles
+}
+
+// Deprecated: Do not use.
+func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool {
+ if m != nil && m.JavaGenerateEqualsAndHash != nil {
+ return *m.JavaGenerateEqualsAndHash
+ }
+ return false
+}
+
+func (m *FileOptions) GetJavaStringCheckUtf8() bool {
+ if m != nil && m.JavaStringCheckUtf8 != nil {
+ return *m.JavaStringCheckUtf8
+ }
+ return Default_FileOptions_JavaStringCheckUtf8
+}
+
+func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
+ if m != nil && m.OptimizeFor != nil {
+ return *m.OptimizeFor
+ }
+ return Default_FileOptions_OptimizeFor
+}
+
+func (m *FileOptions) GetGoPackage() string {
+ if m != nil && m.GoPackage != nil {
+ return *m.GoPackage
+ }
+ return ""
+}
+
+func (m *FileOptions) GetCcGenericServices() bool {
+ if m != nil && m.CcGenericServices != nil {
+ return *m.CcGenericServices
+ }
+ return Default_FileOptions_CcGenericServices
+}
+
+func (m *FileOptions) GetJavaGenericServices() bool {
+ if m != nil && m.JavaGenericServices != nil {
+ return *m.JavaGenericServices
+ }
+ return Default_FileOptions_JavaGenericServices
+}
+
+func (m *FileOptions) GetPyGenericServices() bool {
+ if m != nil && m.PyGenericServices != nil {
+ return *m.PyGenericServices
+ }
+ return Default_FileOptions_PyGenericServices
+}
+
+func (m *FileOptions) GetPhpGenericServices() bool {
+ if m != nil && m.PhpGenericServices != nil {
+ return *m.PhpGenericServices
+ }
+ return Default_FileOptions_PhpGenericServices
+}
+
+func (m *FileOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_FileOptions_Deprecated
+}
+
+func (m *FileOptions) GetCcEnableArenas() bool {
+ if m != nil && m.CcEnableArenas != nil {
+ return *m.CcEnableArenas
+ }
+ return Default_FileOptions_CcEnableArenas
+}
+
+func (m *FileOptions) GetObjcClassPrefix() string {
+ if m != nil && m.ObjcClassPrefix != nil {
+ return *m.ObjcClassPrefix
+ }
+ return ""
+}
+
+func (m *FileOptions) GetCsharpNamespace() string {
+ if m != nil && m.CsharpNamespace != nil {
+ return *m.CsharpNamespace
+ }
+ return ""
+}
+
+func (m *FileOptions) GetSwiftPrefix() string {
+ if m != nil && m.SwiftPrefix != nil {
+ return *m.SwiftPrefix
+ }
+ return ""
+}
+
+func (m *FileOptions) GetPhpClassPrefix() string {
+ if m != nil && m.PhpClassPrefix != nil {
+ return *m.PhpClassPrefix
+ }
+ return ""
+}
+
+func (m *FileOptions) GetPhpNamespace() string {
+ if m != nil && m.PhpNamespace != nil {
+ return *m.PhpNamespace
+ }
+ return ""
+}
+
+func (m *FileOptions) GetPhpMetadataNamespace() string {
+ if m != nil && m.PhpMetadataNamespace != nil {
+ return *m.PhpMetadataNamespace
+ }
+ return ""
+}
+
+func (m *FileOptions) GetRubyPackage() string {
+ if m != nil && m.RubyPackage != nil {
+ return *m.RubyPackage
+ }
+ return ""
+}
+
+func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type MessageOptions struct {
+ // Set true to use the old proto1 MessageSet wire format for extensions.
+ // This is provided for backwards-compatibility with the MessageSet wire
+ // format. You should not use this for any other reason: It's less
+ // efficient, has fewer features, and is more complicated.
+ //
+ // The message must be defined exactly as follows:
+ // message Foo {
+ // option message_set_wire_format = true;
+ // extensions 4 to max;
+ // }
+ // Note that the message cannot have any defined fields; MessageSets only
+ // have extensions.
+ //
+ // All extensions of your type must be singular messages; e.g. they cannot
+ // be int32s, enums, or repeated messages.
+ //
+ // Because this is an option, the above two restrictions are not enforced by
+ // the protocol compiler.
+ MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
+ // Disables the generation of the standard "descriptor()" accessor, which can
+ // conflict with a field of the same name. This is meant to make migration
+ // from proto1 easier; new code should avoid fields named "descriptor".
+ NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
+ // Is this message deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the message, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating messages.
+ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // Whether the message is an automatically generated map entry type for the
+ // maps field.
+ //
+ // For maps fields:
+ // map<KeyType, ValueType> map_field = 1;
+ // The parsed descriptor looks like:
+ // message MapFieldEntry {
+ // option map_entry = true;
+ // optional KeyType key = 1;
+ // optional ValueType value = 2;
+ // }
+ // repeated MapFieldEntry map_field = 1;
+ //
+ // Implementations may choose not to generate the map_entry=true message, but
+ // use a native map in the target language to hold the keys and values.
+ // The reflection APIs in such implementions still need to work as
+ // if the field is a repeated message field.
+ //
+ // NOTE: Do not set the option in .proto files. Always use the maps syntax
+ // instead. The option should only be implicitly set by the proto compiler
+ // parser.
+ MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MessageOptions) Reset() { *m = MessageOptions{} }
+func (m *MessageOptions) String() string { return proto.CompactTextString(m) }
+func (*MessageOptions) ProtoMessage() {}
+func (*MessageOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{11}
+}
+
+var extRange_MessageOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_MessageOptions
+}
+
+func (m *MessageOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MessageOptions.Unmarshal(m, b)
+}
+func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic)
+}
+func (m *MessageOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MessageOptions.Merge(m, src)
+}
+func (m *MessageOptions) XXX_Size() int {
+ return xxx_messageInfo_MessageOptions.Size(m)
+}
+func (m *MessageOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_MessageOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageOptions proto.InternalMessageInfo
+
+const Default_MessageOptions_MessageSetWireFormat bool = false
+const Default_MessageOptions_NoStandardDescriptorAccessor bool = false
+const Default_MessageOptions_Deprecated bool = false
+
+func (m *MessageOptions) GetMessageSetWireFormat() bool {
+ if m != nil && m.MessageSetWireFormat != nil {
+ return *m.MessageSetWireFormat
+ }
+ return Default_MessageOptions_MessageSetWireFormat
+}
+
+func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool {
+ if m != nil && m.NoStandardDescriptorAccessor != nil {
+ return *m.NoStandardDescriptorAccessor
+ }
+ return Default_MessageOptions_NoStandardDescriptorAccessor
+}
+
+func (m *MessageOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_MessageOptions_Deprecated
+}
+
+func (m *MessageOptions) GetMapEntry() bool {
+ if m != nil && m.MapEntry != nil {
+ return *m.MapEntry
+ }
+ return false
+}
+
+func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type FieldOptions struct {
+ // The ctype option instructs the C++ code generator to use a different
+ // representation of the field than it normally would. See the specific
+ // options below. This option is not yet implemented in the open source
+ // release -- sorry, we'll try to include it in a future version!
+ Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
+ // The packed option can be enabled for repeated primitive fields to enable
+ // a more efficient representation on the wire. Rather than repeatedly
+ // writing the tag and type for each element, the entire array is encoded as
+ // a single length-delimited blob. In proto3, only explicit setting it to
+ // false will avoid using packed encoding.
+ Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
+ // The jstype option determines the JavaScript type used for values of the
+ // field. The option is permitted only for 64 bit integral and fixed types
+ // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
+ // is represented as JavaScript string, which avoids loss of precision that
+ // can happen when a large value is converted to a floating point JavaScript.
+ // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+ // use the JavaScript "number" type. The behavior of the default option
+ // JS_NORMAL is implementation dependent.
+ //
+ // This option is an enum to permit additional types to be added, e.g.
+ // goog.math.Integer.
+ Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
+ // Should this field be parsed lazily? Lazy applies only to message-type
+ // fields. It means that when the outer message is initially parsed, the
+ // inner message's contents will not be parsed but instead stored in encoded
+ // form. The inner message will actually be parsed when it is first accessed.
+ //
+ // This is only a hint. Implementations are free to choose whether to use
+ // eager or lazy parsing regardless of the value of this option. However,
+ // setting this option true suggests that the protocol author believes that
+ // using lazy parsing on this field is worth the additional bookkeeping
+ // overhead typically needed to implement it.
+ //
+ // This option does not affect the public interface of any generated code;
+ // all method signatures remain the same. Furthermore, thread-safety of the
+ // interface is not affected by this option; const methods remain safe to
+ // call from multiple threads concurrently, while non-const methods continue
+ // to require exclusive access.
+ //
+ //
+ // Note that implementations may choose not to check required fields within
+ // a lazy sub-message. That is, calling IsInitialized() on the outer message
+ // may return true even if the inner message has missing required fields.
+ // This is necessary because otherwise the inner message would have to be
+ // parsed in order to perform the check, defeating the purpose of lazy
+ // parsing. An implementation which chooses not to check required fields
+ // must be consistent about it. That is, for any particular sub-message, the
+ // implementation must either *always* check its required fields, or *never*
+ // check its required fields, regardless of whether or not the message has
+ // been parsed.
+ Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
+ // Is this field deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for accessors, or it will be completely ignored; in the very least, this
+ // is a formalization for deprecating fields.
+ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // For Google-internal migration only. Do not use.
+ Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FieldOptions) Reset() { *m = FieldOptions{} }
+func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
+func (*FieldOptions) ProtoMessage() {}
+func (*FieldOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{12}
+}
+
+var extRange_FieldOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_FieldOptions
+}
+
+func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FieldOptions.Unmarshal(m, b)
+}
+func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
+}
+func (m *FieldOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FieldOptions.Merge(m, src)
+}
+func (m *FieldOptions) XXX_Size() int {
+ return xxx_messageInfo_FieldOptions.Size(m)
+}
+func (m *FieldOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_FieldOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
+
+const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING
+const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL
+const Default_FieldOptions_Lazy bool = false
+const Default_FieldOptions_Deprecated bool = false
+const Default_FieldOptions_Weak bool = false
+
+func (m *FieldOptions) GetCtype() FieldOptions_CType {
+ if m != nil && m.Ctype != nil {
+ return *m.Ctype
+ }
+ return Default_FieldOptions_Ctype
+}
+
+func (m *FieldOptions) GetPacked() bool {
+ if m != nil && m.Packed != nil {
+ return *m.Packed
+ }
+ return false
+}
+
+func (m *FieldOptions) GetJstype() FieldOptions_JSType {
+ if m != nil && m.Jstype != nil {
+ return *m.Jstype
+ }
+ return Default_FieldOptions_Jstype
+}
+
+func (m *FieldOptions) GetLazy() bool {
+ if m != nil && m.Lazy != nil {
+ return *m.Lazy
+ }
+ return Default_FieldOptions_Lazy
+}
+
+func (m *FieldOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_FieldOptions_Deprecated
+}
+
+func (m *FieldOptions) GetWeak() bool {
+ if m != nil && m.Weak != nil {
+ return *m.Weak
+ }
+ return Default_FieldOptions_Weak
+}
+
+func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type OneofOptions struct {
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *OneofOptions) Reset() { *m = OneofOptions{} }
+func (m *OneofOptions) String() string { return proto.CompactTextString(m) }
+func (*OneofOptions) ProtoMessage() {}
+func (*OneofOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{13}
+}
+
+var extRange_OneofOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_OneofOptions
+}
+
+func (m *OneofOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_OneofOptions.Unmarshal(m, b)
+}
+func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic)
+}
+func (m *OneofOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_OneofOptions.Merge(m, src)
+}
+func (m *OneofOptions) XXX_Size() int {
+ return xxx_messageInfo_OneofOptions.Size(m)
+}
+func (m *OneofOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_OneofOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OneofOptions proto.InternalMessageInfo
+
+func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type EnumOptions struct {
+ // Set this option to true to allow mapping different tag names to the same
+ // value.
+ AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
+ // Is this enum deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the enum, or it will be completely ignored; in the very least, this
+ // is a formalization for deprecating enums.
+ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumOptions) Reset() { *m = EnumOptions{} }
+func (m *EnumOptions) String() string { return proto.CompactTextString(m) }
+func (*EnumOptions) ProtoMessage() {}
+func (*EnumOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{14}
+}
+
+var extRange_EnumOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_EnumOptions
+}
+
+func (m *EnumOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumOptions.Unmarshal(m, b)
+}
+func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic)
+}
+func (m *EnumOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumOptions.Merge(m, src)
+}
+func (m *EnumOptions) XXX_Size() int {
+ return xxx_messageInfo_EnumOptions.Size(m)
+}
+func (m *EnumOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumOptions proto.InternalMessageInfo
+
+const Default_EnumOptions_Deprecated bool = false
+
+func (m *EnumOptions) GetAllowAlias() bool {
+ if m != nil && m.AllowAlias != nil {
+ return *m.AllowAlias
+ }
+ return false
+}
+
+func (m *EnumOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_EnumOptions_Deprecated
+}
+
+func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type EnumValueOptions struct {
+ // Is this enum value deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the enum value, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating enum values.
+ Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} }
+func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) }
+func (*EnumValueOptions) ProtoMessage() {}
+func (*EnumValueOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{15}
+}
+
+var extRange_EnumValueOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_EnumValueOptions
+}
+
+func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b)
+}
+func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic)
+}
+func (m *EnumValueOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumValueOptions.Merge(m, src)
+}
+func (m *EnumValueOptions) XXX_Size() int {
+ return xxx_messageInfo_EnumValueOptions.Size(m)
+}
+func (m *EnumValueOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumValueOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo
+
+const Default_EnumValueOptions_Deprecated bool = false
+
+func (m *EnumValueOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_EnumValueOptions_Deprecated
+}
+
+func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type ServiceOptions struct {
+ // Is this service deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the service, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating services.
+ Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServiceOptions) Reset() { *m = ServiceOptions{} }
+func (m *ServiceOptions) String() string { return proto.CompactTextString(m) }
+func (*ServiceOptions) ProtoMessage() {}
+func (*ServiceOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{16}
+}
+
+var extRange_ServiceOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_ServiceOptions
+}
+
+func (m *ServiceOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServiceOptions.Unmarshal(m, b)
+}
+func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic)
+}
+func (m *ServiceOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServiceOptions.Merge(m, src)
+}
+func (m *ServiceOptions) XXX_Size() int {
+ return xxx_messageInfo_ServiceOptions.Size(m)
+}
+func (m *ServiceOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServiceOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo
+
+const Default_ServiceOptions_Deprecated bool = false
+
+func (m *ServiceOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_ServiceOptions_Deprecated
+}
+
+func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type MethodOptions struct {
+ // Is this method deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the method, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating methods.
+ Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MethodOptions) Reset() { *m = MethodOptions{} }
+func (m *MethodOptions) String() string { return proto.CompactTextString(m) }
+func (*MethodOptions) ProtoMessage() {}
+func (*MethodOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{17}
+}
+
+var extRange_MethodOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_MethodOptions
+}
+
+func (m *MethodOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MethodOptions.Unmarshal(m, b)
+}
+func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic)
+}
+func (m *MethodOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MethodOptions.Merge(m, src)
+}
+func (m *MethodOptions) XXX_Size() int {
+ return xxx_messageInfo_MethodOptions.Size(m)
+}
+func (m *MethodOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_MethodOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MethodOptions proto.InternalMessageInfo
+
+const Default_MethodOptions_Deprecated bool = false
+const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
+
+func (m *MethodOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_MethodOptions_Deprecated
+}
+
+func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
+ if m != nil && m.IdempotencyLevel != nil {
+ return *m.IdempotencyLevel
+ }
+ return Default_MethodOptions_IdempotencyLevel
+}
+
+func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+type UninterpretedOption struct {
+ Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
+ // The value of the uninterpreted option, in whatever type the tokenizer
+ // identified it as during parsing. Exactly one of these should be set.
+ IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
+ PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
+ NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
+ DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
+ StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
+ AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} }
+func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) }
+func (*UninterpretedOption) ProtoMessage() {}
+func (*UninterpretedOption) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{18}
+}
+
+func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b)
+}
+func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic)
+}
+func (m *UninterpretedOption) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UninterpretedOption.Merge(m, src)
+}
+func (m *UninterpretedOption) XXX_Size() int {
+ return xxx_messageInfo_UninterpretedOption.Size(m)
+}
+func (m *UninterpretedOption) XXX_DiscardUnknown() {
+ xxx_messageInfo_UninterpretedOption.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo
+
+func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
+ if m != nil {
+ return m.Name
+ }
+ return nil
+}
+
+func (m *UninterpretedOption) GetIdentifierValue() string {
+ if m != nil && m.IdentifierValue != nil {
+ return *m.IdentifierValue
+ }
+ return ""
+}
+
+func (m *UninterpretedOption) GetPositiveIntValue() uint64 {
+ if m != nil && m.PositiveIntValue != nil {
+ return *m.PositiveIntValue
+ }
+ return 0
+}
+
+func (m *UninterpretedOption) GetNegativeIntValue() int64 {
+ if m != nil && m.NegativeIntValue != nil {
+ return *m.NegativeIntValue
+ }
+ return 0
+}
+
+func (m *UninterpretedOption) GetDoubleValue() float64 {
+ if m != nil && m.DoubleValue != nil {
+ return *m.DoubleValue
+ }
+ return 0
+}
+
+func (m *UninterpretedOption) GetStringValue() []byte {
+ if m != nil {
+ return m.StringValue
+ }
+ return nil
+}
+
+func (m *UninterpretedOption) GetAggregateValue() string {
+ if m != nil && m.AggregateValue != nil {
+ return *m.AggregateValue
+ }
+ return ""
+}
+
+// The name of the uninterpreted option. Each string represents a segment in
+// a dot-separated name. is_extension is true iff a segment represents an
+// extension (denoted with parentheses in options specs in .proto files).
+// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+// "foo.(bar.baz).qux".
+type UninterpretedOption_NamePart struct {
+ NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
+ IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} }
+func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
+func (*UninterpretedOption_NamePart) ProtoMessage() {}
+func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{18, 0}
+}
+
+func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b)
+}
+func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic)
+}
+func (m *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UninterpretedOption_NamePart.Merge(m, src)
+}
+func (m *UninterpretedOption_NamePart) XXX_Size() int {
+ return xxx_messageInfo_UninterpretedOption_NamePart.Size(m)
+}
+func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() {
+ xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo
+
+func (m *UninterpretedOption_NamePart) GetNamePart() string {
+ if m != nil && m.NamePart != nil {
+ return *m.NamePart
+ }
+ return ""
+}
+
+func (m *UninterpretedOption_NamePart) GetIsExtension() bool {
+ if m != nil && m.IsExtension != nil {
+ return *m.IsExtension
+ }
+ return false
+}
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+type SourceCodeInfo struct {
+ // A Location identifies a piece of source code in a .proto file which
+ // corresponds to a particular definition. This information is intended
+ // to be useful to IDEs, code indexers, documentation generators, and similar
+ // tools.
+ //
+ // For example, say we have a file like:
+ // message Foo {
+ // optional string foo = 1;
+ // }
+ // Let's look at just the field definition:
+ // optional string foo = 1;
+ // ^ ^^ ^^ ^ ^^^
+ // a bc de f ghi
+ // We have the following locations:
+ // span path represents
+ // [a,i) [ 4, 0, 2, 0 ] The whole field definition.
+ // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
+ // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
+ // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
+ // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
+ //
+ // Notes:
+ // - A location may refer to a repeated field itself (i.e. not to any
+ // particular index within it). This is used whenever a set of elements are
+ // logically enclosed in a single code segment. For example, an entire
+ // extend block (possibly containing multiple extension definitions) will
+ // have an outer location whose path refers to the "extensions" repeated
+ // field without an index.
+ // - Multiple locations may have the same path. This happens when a single
+ // logical declaration is spread out across multiple places. The most
+ // obvious example is the "extend" block again -- there may be multiple
+ // extend blocks in the same scope, each of which will have the same path.
+ // - A location's span is not always a subset of its parent's span. For
+ // example, the "extendee" of an extension declaration appears at the
+ // beginning of the "extend" block and is shared by all extensions within
+ // the block.
+ // - Just because a location's span is a subset of some other location's span
+ // does not mean that it is a descendent. For example, a "group" defines
+ // both a type and a field in a single declaration. Thus, the locations
+ // corresponding to the type and field and their components will overlap.
+ // - Code which tries to interpret locations should probably be designed to
+ // ignore those that it doesn't understand, as more types of locations could
+ // be recorded in the future.
+ Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} }
+func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) }
+func (*SourceCodeInfo) ProtoMessage() {}
+func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{19}
+}
+
+func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b)
+}
+func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic)
+}
+func (m *SourceCodeInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SourceCodeInfo.Merge(m, src)
+}
+func (m *SourceCodeInfo) XXX_Size() int {
+ return xxx_messageInfo_SourceCodeInfo.Size(m)
+}
+func (m *SourceCodeInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo
+
+func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
+ if m != nil {
+ return m.Location
+ }
+ return nil
+}
+
+type SourceCodeInfo_Location struct {
+ // Identifies which part of the FileDescriptorProto was defined at this
+ // location.
+ //
+ // Each element is a field number or an index. They form a path from
+ // the root FileDescriptorProto to the place where the definition. For
+ // example, this path:
+ // [ 4, 3, 2, 7, 1 ]
+ // refers to:
+ // file.message_type(3) // 4, 3
+ // .field(7) // 2, 7
+ // .name() // 1
+ // This is because FileDescriptorProto.message_type has field number 4:
+ // repeated DescriptorProto message_type = 4;
+ // and DescriptorProto.field has field number 2:
+ // repeated FieldDescriptorProto field = 2;
+ // and FieldDescriptorProto.name has field number 1:
+ // optional string name = 1;
+ //
+ // Thus, the above path gives the location of a field name. If we removed
+ // the last element:
+ // [ 4, 3, 2, 7 ]
+ // this path refers to the whole field declaration (from the beginning
+ // of the label to the terminating semicolon).
+ Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+ // Always has exactly three or four elements: start line, start column,
+ // end line (optional, otherwise assumed same as start line), end column.
+ // These are packed into a single field for efficiency. Note that line
+ // and column numbers are zero-based -- typically you will want to add
+ // 1 to each before displaying to a user.
+ Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
+ // If this SourceCodeInfo represents a complete declaration, these are any
+ // comments appearing before and after the declaration which appear to be
+ // attached to the declaration.
+ //
+ // A series of line comments appearing on consecutive lines, with no other
+ // tokens appearing on those lines, will be treated as a single comment.
+ //
+ // leading_detached_comments will keep paragraphs of comments that appear
+ // before (but not connected to) the current element. Each paragraph,
+ // separated by empty lines, will be one comment element in the repeated
+ // field.
+ //
+ // Only the comment content is provided; comment markers (e.g. //) are
+ // stripped out. For block comments, leading whitespace and an asterisk
+ // will be stripped from the beginning of each line other than the first.
+ // Newlines are included in the output.
+ //
+ // Examples:
+ //
+ // optional int32 foo = 1; // Comment attached to foo.
+ // // Comment attached to bar.
+ // optional int32 bar = 2;
+ //
+ // optional string baz = 3;
+ // // Comment attached to baz.
+ // // Another line attached to baz.
+ //
+ // // Comment attached to qux.
+ // //
+ // // Another line attached to qux.
+ // optional double qux = 4;
+ //
+ // // Detached comment for corge. This is not leading or trailing comments
+ // // to qux or corge because there are blank lines separating it from
+ // // both.
+ //
+ // // Detached comment for corge paragraph 2.
+ //
+ // optional string corge = 5;
+ // /* Block comment attached
+ // * to corge. Leading asterisks
+ // * will be removed. */
+ // /* Block comment attached to
+ // * grault. */
+ // optional int32 grault = 6;
+ //
+ // // ignored detached comments.
+ LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
+ TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
+ LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} }
+func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
+func (*SourceCodeInfo_Location) ProtoMessage() {}
+func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{19, 0}
+}
+
+func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b)
+}
+func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic)
+}
+func (m *SourceCodeInfo_Location) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SourceCodeInfo_Location.Merge(m, src)
+}
+func (m *SourceCodeInfo_Location) XXX_Size() int {
+ return xxx_messageInfo_SourceCodeInfo_Location.Size(m)
+}
+func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() {
+ xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo
+
+func (m *SourceCodeInfo_Location) GetPath() []int32 {
+ if m != nil {
+ return m.Path
+ }
+ return nil
+}
+
+func (m *SourceCodeInfo_Location) GetSpan() []int32 {
+ if m != nil {
+ return m.Span
+ }
+ return nil
+}
+
+func (m *SourceCodeInfo_Location) GetLeadingComments() string {
+ if m != nil && m.LeadingComments != nil {
+ return *m.LeadingComments
+ }
+ return ""
+}
+
+func (m *SourceCodeInfo_Location) GetTrailingComments() string {
+ if m != nil && m.TrailingComments != nil {
+ return *m.TrailingComments
+ }
+ return ""
+}
+
+func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
+ if m != nil {
+ return m.LeadingDetachedComments
+ }
+ return nil
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+type GeneratedCodeInfo struct {
+ // An Annotation connects some span of text in generated code to an element
+ // of its generating .proto file.
+ Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} }
+func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) }
+func (*GeneratedCodeInfo) ProtoMessage() {}
+func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{20}
+}
+
+func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b)
+}
+func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic)
+}
+func (m *GeneratedCodeInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GeneratedCodeInfo.Merge(m, src)
+}
+func (m *GeneratedCodeInfo) XXX_Size() int {
+ return xxx_messageInfo_GeneratedCodeInfo.Size(m)
+}
+func (m *GeneratedCodeInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo
+
+func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
+ if m != nil {
+ return m.Annotation
+ }
+ return nil
+}
+
+type GeneratedCodeInfo_Annotation struct {
+ // Identifies the element in the original source .proto file. This field
+ // is formatted the same as SourceCodeInfo.Location.path.
+ Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+ // Identifies the filesystem path to the original source .proto.
+ SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
+ // Identifies the starting offset in bytes in the generated code
+ // that relates to the identified object.
+ Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
+ // Identifies the ending offset in bytes in the generated code that
+ // relates to the identified offset. The end offset should be one past
+ // the last relevant byte (so the length of the text = end - begin).
+ End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} }
+func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
+func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
+func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e5baabe45344a177, []int{20, 0}
+}
+
+func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(m, src)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Size() int {
+ return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() {
+ xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo
+
+func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
+ if m != nil {
+ return m.Path
+ }
+ return nil
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string {
+ if m != nil && m.SourceFile != nil {
+ return *m.SourceFile
+ }
+ return ""
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 {
+ if m != nil && m.Begin != nil {
+ return *m.Begin
+ }
+ return 0
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value)
+ proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value)
+ proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value)
+ proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value)
+ proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value)
+ proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value)
+ proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
+ proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
+ proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
+ proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
+ proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
+ proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
+ proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
+ proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
+ proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
+ proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
+ proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
+ proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
+ proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
+ proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions")
+ proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions")
+ proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions")
+ proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions")
+ proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions")
+ proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
+ proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions")
+ proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions")
+ proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
+ proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
+ proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
+ proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
+ proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
+ proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
+}
+
+func init() { proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_e5baabe45344a177) }
+
+var fileDescriptor_e5baabe45344a177 = []byte{
+ // 2589 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdd, 0x8e, 0xdb, 0xc6,
+ 0x15, 0x0e, 0xf5, 0xb7, 0xd2, 0x91, 0x56, 0x3b, 0x3b, 0xbb, 0xb1, 0xe9, 0xcd, 0x8f, 0xd7, 0xca,
+ 0x8f, 0xd7, 0x4e, 0xac, 0x0d, 0x1c, 0xdb, 0x71, 0xd6, 0x45, 0x5a, 0xad, 0x44, 0x6f, 0xe4, 0xee,
+ 0x4a, 0x2a, 0xa5, 0x6d, 0x7e, 0x80, 0x82, 0x98, 0x25, 0x47, 0x12, 0x6d, 0x8a, 0x64, 0x48, 0xca,
+ 0xf6, 0x06, 0xbd, 0x30, 0xd0, 0xab, 0x5e, 0x15, 0xe8, 0x55, 0x51, 0x14, 0xbd, 0xe8, 0x4d, 0x80,
+ 0x3e, 0x40, 0x81, 0xde, 0xf5, 0x09, 0x0a, 0xe4, 0x0d, 0x8a, 0xb6, 0x40, 0xfb, 0x08, 0xbd, 0x2c,
+ 0x66, 0x86, 0xa4, 0x48, 0x49, 0x1b, 0x6f, 0x02, 0xc4, 0xb9, 0x92, 0xe6, 0x3b, 0xdf, 0x39, 0x73,
+ 0xe6, 0xcc, 0x99, 0x99, 0x33, 0x43, 0xd8, 0x1e, 0x39, 0xce, 0xc8, 0xa2, 0xbb, 0xae, 0xe7, 0x04,
+ 0xce, 0xc9, 0x74, 0xb8, 0x6b, 0x50, 0x5f, 0xf7, 0x4c, 0x37, 0x70, 0xbc, 0x3a, 0xc7, 0xf0, 0x9a,
+ 0x60, 0xd4, 0x23, 0x46, 0xed, 0x08, 0xd6, 0xef, 0x9b, 0x16, 0x6d, 0xc5, 0xc4, 0x3e, 0x0d, 0xf0,
+ 0x5d, 0xc8, 0x0d, 0x4d, 0x8b, 0xca, 0xd2, 0x76, 0x76, 0xa7, 0x7c, 0xf3, 0xcd, 0xfa, 0x9c, 0x52,
+ 0x3d, 0xad, 0xd1, 0x63, 0xb0, 0xca, 0x35, 0x6a, 0xff, 0xce, 0xc1, 0xc6, 0x12, 0x29, 0xc6, 0x90,
+ 0xb3, 0xc9, 0x84, 0x59, 0x94, 0x76, 0x4a, 0x2a, 0xff, 0x8f, 0x65, 0x58, 0x71, 0x89, 0xfe, 0x88,
+ 0x8c, 0xa8, 0x9c, 0xe1, 0x70, 0xd4, 0xc4, 0xaf, 0x03, 0x18, 0xd4, 0xa5, 0xb6, 0x41, 0x6d, 0xfd,
+ 0x54, 0xce, 0x6e, 0x67, 0x77, 0x4a, 0x6a, 0x02, 0xc1, 0xef, 0xc0, 0xba, 0x3b, 0x3d, 0xb1, 0x4c,
+ 0x5d, 0x4b, 0xd0, 0x60, 0x3b, 0xbb, 0x93, 0x57, 0x91, 0x10, 0xb4, 0x66, 0xe4, 0xab, 0xb0, 0xf6,
+ 0x84, 0x92, 0x47, 0x49, 0x6a, 0x99, 0x53, 0xab, 0x0c, 0x4e, 0x10, 0x9b, 0x50, 0x99, 0x50, 0xdf,
+ 0x27, 0x23, 0xaa, 0x05, 0xa7, 0x2e, 0x95, 0x73, 0x7c, 0xf4, 0xdb, 0x0b, 0xa3, 0x9f, 0x1f, 0x79,
+ 0x39, 0xd4, 0x1a, 0x9c, 0xba, 0x14, 0x37, 0xa0, 0x44, 0xed, 0xe9, 0x44, 0x58, 0xc8, 0x9f, 0x11,
+ 0x3f, 0xc5, 0x9e, 0x4e, 0xe6, 0xad, 0x14, 0x99, 0x5a, 0x68, 0x62, 0xc5, 0xa7, 0xde, 0x63, 0x53,
+ 0xa7, 0x72, 0x81, 0x1b, 0xb8, 0xba, 0x60, 0xa0, 0x2f, 0xe4, 0xf3, 0x36, 0x22, 0x3d, 0xdc, 0x84,
+ 0x12, 0x7d, 0x1a, 0x50, 0xdb, 0x37, 0x1d, 0x5b, 0x5e, 0xe1, 0x46, 0xde, 0x5a, 0x32, 0x8b, 0xd4,
+ 0x32, 0xe6, 0x4d, 0xcc, 0xf4, 0xf0, 0x1d, 0x58, 0x71, 0xdc, 0xc0, 0x74, 0x6c, 0x5f, 0x2e, 0x6e,
+ 0x4b, 0x3b, 0xe5, 0x9b, 0xaf, 0x2e, 0x4d, 0x84, 0xae, 0xe0, 0xa8, 0x11, 0x19, 0xb7, 0x01, 0xf9,
+ 0xce, 0xd4, 0xd3, 0xa9, 0xa6, 0x3b, 0x06, 0xd5, 0x4c, 0x7b, 0xe8, 0xc8, 0x25, 0x6e, 0xe0, 0xf2,
+ 0xe2, 0x40, 0x38, 0xb1, 0xe9, 0x18, 0xb4, 0x6d, 0x0f, 0x1d, 0xb5, 0xea, 0xa7, 0xda, 0xf8, 0x02,
+ 0x14, 0xfc, 0x53, 0x3b, 0x20, 0x4f, 0xe5, 0x0a, 0xcf, 0x90, 0xb0, 0x55, 0xfb, 0x6b, 0x01, 0xd6,
+ 0xce, 0x93, 0x62, 0xf7, 0x20, 0x3f, 0x64, 0xa3, 0x94, 0x33, 0xdf, 0x26, 0x06, 0x42, 0x27, 0x1d,
+ 0xc4, 0xc2, 0x77, 0x0c, 0x62, 0x03, 0xca, 0x36, 0xf5, 0x03, 0x6a, 0x88, 0x8c, 0xc8, 0x9e, 0x33,
+ 0xa7, 0x40, 0x28, 0x2d, 0xa6, 0x54, 0xee, 0x3b, 0xa5, 0xd4, 0xa7, 0xb0, 0x16, 0xbb, 0xa4, 0x79,
+ 0xc4, 0x1e, 0x45, 0xb9, 0xb9, 0xfb, 0x3c, 0x4f, 0xea, 0x4a, 0xa4, 0xa7, 0x32, 0x35, 0xb5, 0x4a,
+ 0x53, 0x6d, 0xdc, 0x02, 0x70, 0x6c, 0xea, 0x0c, 0x35, 0x83, 0xea, 0x96, 0x5c, 0x3c, 0x23, 0x4a,
+ 0x5d, 0x46, 0x59, 0x88, 0x92, 0x23, 0x50, 0xdd, 0xc2, 0x1f, 0xce, 0x52, 0x6d, 0xe5, 0x8c, 0x4c,
+ 0x39, 0x12, 0x8b, 0x6c, 0x21, 0xdb, 0x8e, 0xa1, 0xea, 0x51, 0x96, 0xf7, 0xd4, 0x08, 0x47, 0x56,
+ 0xe2, 0x4e, 0xd4, 0x9f, 0x3b, 0x32, 0x35, 0x54, 0x13, 0x03, 0x5b, 0xf5, 0x92, 0x4d, 0xfc, 0x06,
+ 0xc4, 0x80, 0xc6, 0xd3, 0x0a, 0xf8, 0x2e, 0x54, 0x89, 0xc0, 0x0e, 0x99, 0xd0, 0xad, 0x2f, 0xa1,
+ 0x9a, 0x0e, 0x0f, 0xde, 0x84, 0xbc, 0x1f, 0x10, 0x2f, 0xe0, 0x59, 0x98, 0x57, 0x45, 0x03, 0x23,
+ 0xc8, 0x52, 0xdb, 0xe0, 0xbb, 0x5c, 0x5e, 0x65, 0x7f, 0xf1, 0x4f, 0x66, 0x03, 0xce, 0xf2, 0x01,
+ 0xbf, 0xbd, 0x38, 0xa3, 0x29, 0xcb, 0xf3, 0xe3, 0xde, 0xfa, 0x00, 0x56, 0x53, 0x03, 0x38, 0x6f,
+ 0xd7, 0xb5, 0x5f, 0xc2, 0xcb, 0x4b, 0x4d, 0xe3, 0x4f, 0x61, 0x73, 0x6a, 0x9b, 0x76, 0x40, 0x3d,
+ 0xd7, 0xa3, 0x2c, 0x63, 0x45, 0x57, 0xf2, 0x7f, 0x56, 0xce, 0xc8, 0xb9, 0xe3, 0x24, 0x5b, 0x58,
+ 0x51, 0x37, 0xa6, 0x8b, 0xe0, 0xf5, 0x52, 0xf1, 0xbf, 0x2b, 0xe8, 0xd9, 0xb3, 0x67, 0xcf, 0x32,
+ 0xb5, 0xdf, 0x15, 0x60, 0x73, 0xd9, 0x9a, 0x59, 0xba, 0x7c, 0x2f, 0x40, 0xc1, 0x9e, 0x4e, 0x4e,
+ 0xa8, 0xc7, 0x83, 0x94, 0x57, 0xc3, 0x16, 0x6e, 0x40, 0xde, 0x22, 0x27, 0xd4, 0x92, 0x73, 0xdb,
+ 0xd2, 0x4e, 0xf5, 0xe6, 0x3b, 0xe7, 0x5a, 0x95, 0xf5, 0x43, 0xa6, 0xa2, 0x0a, 0x4d, 0xfc, 0x11,
+ 0xe4, 0xc2, 0x2d, 0x9a, 0x59, 0xb8, 0x7e, 0x3e, 0x0b, 0x6c, 0x2d, 0xa9, 0x5c, 0x0f, 0xbf, 0x02,
+ 0x25, 0xf6, 0x2b, 0x72, 0xa3, 0xc0, 0x7d, 0x2e, 0x32, 0x80, 0xe5, 0x05, 0xde, 0x82, 0x22, 0x5f,
+ 0x26, 0x06, 0x8d, 0x8e, 0xb6, 0xb8, 0xcd, 0x12, 0xcb, 0xa0, 0x43, 0x32, 0xb5, 0x02, 0xed, 0x31,
+ 0xb1, 0xa6, 0x94, 0x27, 0x7c, 0x49, 0xad, 0x84, 0xe0, 0xcf, 0x19, 0x86, 0x2f, 0x43, 0x59, 0xac,
+ 0x2a, 0xd3, 0x36, 0xe8, 0x53, 0xbe, 0x7b, 0xe6, 0x55, 0xb1, 0xd0, 0xda, 0x0c, 0x61, 0xdd, 0x3f,
+ 0xf4, 0x1d, 0x3b, 0x4a, 0x4d, 0xde, 0x05, 0x03, 0x78, 0xf7, 0x1f, 0xcc, 0x6f, 0xdc, 0xaf, 0x2d,
+ 0x1f, 0xde, 0x7c, 0x4e, 0xd5, 0xfe, 0x92, 0x81, 0x1c, 0xdf, 0x2f, 0xd6, 0xa0, 0x3c, 0xf8, 0xac,
+ 0xa7, 0x68, 0xad, 0xee, 0xf1, 0xfe, 0xa1, 0x82, 0x24, 0x5c, 0x05, 0xe0, 0xc0, 0xfd, 0xc3, 0x6e,
+ 0x63, 0x80, 0x32, 0x71, 0xbb, 0xdd, 0x19, 0xdc, 0xb9, 0x85, 0xb2, 0xb1, 0xc2, 0xb1, 0x00, 0x72,
+ 0x49, 0xc2, 0xfb, 0x37, 0x51, 0x1e, 0x23, 0xa8, 0x08, 0x03, 0xed, 0x4f, 0x95, 0xd6, 0x9d, 0x5b,
+ 0xa8, 0x90, 0x46, 0xde, 0xbf, 0x89, 0x56, 0xf0, 0x2a, 0x94, 0x38, 0xb2, 0xdf, 0xed, 0x1e, 0xa2,
+ 0x62, 0x6c, 0xb3, 0x3f, 0x50, 0xdb, 0x9d, 0x03, 0x54, 0x8a, 0x6d, 0x1e, 0xa8, 0xdd, 0xe3, 0x1e,
+ 0x82, 0xd8, 0xc2, 0x91, 0xd2, 0xef, 0x37, 0x0e, 0x14, 0x54, 0x8e, 0x19, 0xfb, 0x9f, 0x0d, 0x94,
+ 0x3e, 0xaa, 0xa4, 0xdc, 0x7a, 0xff, 0x26, 0x5a, 0x8d, 0xbb, 0x50, 0x3a, 0xc7, 0x47, 0xa8, 0x8a,
+ 0xd7, 0x61, 0x55, 0x74, 0x11, 0x39, 0xb1, 0x36, 0x07, 0xdd, 0xb9, 0x85, 0xd0, 0xcc, 0x11, 0x61,
+ 0x65, 0x3d, 0x05, 0xdc, 0xb9, 0x85, 0x70, 0xad, 0x09, 0x79, 0x9e, 0x5d, 0x18, 0x43, 0xf5, 0xb0,
+ 0xb1, 0xaf, 0x1c, 0x6a, 0xdd, 0xde, 0xa0, 0xdd, 0xed, 0x34, 0x0e, 0x91, 0x34, 0xc3, 0x54, 0xe5,
+ 0x67, 0xc7, 0x6d, 0x55, 0x69, 0xa1, 0x4c, 0x12, 0xeb, 0x29, 0x8d, 0x81, 0xd2, 0x42, 0xd9, 0x9a,
+ 0x0e, 0x9b, 0xcb, 0xf6, 0xc9, 0xa5, 0x2b, 0x23, 0x31, 0xc5, 0x99, 0x33, 0xa6, 0x98, 0xdb, 0x5a,
+ 0x98, 0xe2, 0x7f, 0x65, 0x60, 0x63, 0xc9, 0x59, 0xb1, 0xb4, 0x93, 0x1f, 0x43, 0x5e, 0xa4, 0xa8,
+ 0x38, 0x3d, 0xaf, 0x2d, 0x3d, 0x74, 0x78, 0xc2, 0x2e, 0x9c, 0xa0, 0x5c, 0x2f, 0x59, 0x41, 0x64,
+ 0xcf, 0xa8, 0x20, 0x98, 0x89, 0x85, 0x3d, 0xfd, 0x17, 0x0b, 0x7b, 0xba, 0x38, 0xf6, 0xee, 0x9c,
+ 0xe7, 0xd8, 0xe3, 0xd8, 0xb7, 0xdb, 0xdb, 0xf3, 0x4b, 0xf6, 0xf6, 0x7b, 0xb0, 0xbe, 0x60, 0xe8,
+ 0xdc, 0x7b, 0xec, 0xaf, 0x24, 0x90, 0xcf, 0x0a, 0xce, 0x73, 0x76, 0xba, 0x4c, 0x6a, 0xa7, 0xbb,
+ 0x37, 0x1f, 0xc1, 0x2b, 0x67, 0x4f, 0xc2, 0xc2, 0x5c, 0x7f, 0x25, 0xc1, 0x85, 0xe5, 0x95, 0xe2,
+ 0x52, 0x1f, 0x3e, 0x82, 0xc2, 0x84, 0x06, 0x63, 0x27, 0xaa, 0x96, 0xde, 0x5e, 0x72, 0x06, 0x33,
+ 0xf1, 0xfc, 0x64, 0x87, 0x5a, 0xc9, 0x43, 0x3c, 0x7b, 0x56, 0xb9, 0x27, 0xbc, 0x59, 0xf0, 0xf4,
+ 0xd7, 0x19, 0x78, 0x79, 0xa9, 0xf1, 0xa5, 0x8e, 0xbe, 0x06, 0x60, 0xda, 0xee, 0x34, 0x10, 0x15,
+ 0x91, 0xd8, 0x60, 0x4b, 0x1c, 0xe1, 0x9b, 0x17, 0xdb, 0x3c, 0xa7, 0x41, 0x2c, 0xcf, 0x72, 0x39,
+ 0x08, 0x88, 0x13, 0xee, 0xce, 0x1c, 0xcd, 0x71, 0x47, 0x5f, 0x3f, 0x63, 0xa4, 0x0b, 0x89, 0xf9,
+ 0x1e, 0x20, 0xdd, 0x32, 0xa9, 0x1d, 0x68, 0x7e, 0xe0, 0x51, 0x32, 0x31, 0xed, 0x11, 0x3f, 0x41,
+ 0x8a, 0x7b, 0xf9, 0x21, 0xb1, 0x7c, 0xaa, 0xae, 0x09, 0x71, 0x3f, 0x92, 0x32, 0x0d, 0x9e, 0x40,
+ 0x5e, 0x42, 0xa3, 0x90, 0xd2, 0x10, 0xe2, 0x58, 0xa3, 0xf6, 0xdb, 0x12, 0x94, 0x13, 0x75, 0x35,
+ 0xbe, 0x02, 0x95, 0x87, 0xe4, 0x31, 0xd1, 0xa2, 0xbb, 0x92, 0x88, 0x44, 0x99, 0x61, 0xbd, 0xf0,
+ 0xbe, 0xf4, 0x1e, 0x6c, 0x72, 0x8a, 0x33, 0x0d, 0xa8, 0xa7, 0xe9, 0x16, 0xf1, 0x7d, 0x1e, 0xb4,
+ 0x22, 0xa7, 0x62, 0x26, 0xeb, 0x32, 0x51, 0x33, 0x92, 0xe0, 0xdb, 0xb0, 0xc1, 0x35, 0x26, 0x53,
+ 0x2b, 0x30, 0x5d, 0x8b, 0x6a, 0xec, 0xf6, 0xe6, 0xf3, 0x93, 0x24, 0xf6, 0x6c, 0x9d, 0x31, 0x8e,
+ 0x42, 0x02, 0xf3, 0xc8, 0xc7, 0x2d, 0x78, 0x8d, 0xab, 0x8d, 0xa8, 0x4d, 0x3d, 0x12, 0x50, 0x8d,
+ 0x7e, 0x31, 0x25, 0x96, 0xaf, 0x11, 0xdb, 0xd0, 0xc6, 0xc4, 0x1f, 0xcb, 0x9b, 0xcc, 0xc0, 0x7e,
+ 0x46, 0x96, 0xd4, 0x4b, 0x8c, 0x78, 0x10, 0xf2, 0x14, 0x4e, 0x6b, 0xd8, 0xc6, 0xc7, 0xc4, 0x1f,
+ 0xe3, 0x3d, 0xb8, 0xc0, 0xad, 0xf8, 0x81, 0x67, 0xda, 0x23, 0x4d, 0x1f, 0x53, 0xfd, 0x91, 0x36,
+ 0x0d, 0x86, 0x77, 0xe5, 0x57, 0x92, 0xfd, 0x73, 0x0f, 0xfb, 0x9c, 0xd3, 0x64, 0x94, 0xe3, 0x60,
+ 0x78, 0x17, 0xf7, 0xa1, 0xc2, 0x26, 0x63, 0x62, 0x7e, 0x49, 0xb5, 0xa1, 0xe3, 0xf1, 0xa3, 0xb1,
+ 0xba, 0x64, 0x6b, 0x4a, 0x44, 0xb0, 0xde, 0x0d, 0x15, 0x8e, 0x1c, 0x83, 0xee, 0xe5, 0xfb, 0x3d,
+ 0x45, 0x69, 0xa9, 0xe5, 0xc8, 0xca, 0x7d, 0xc7, 0x63, 0x09, 0x35, 0x72, 0xe2, 0x00, 0x97, 0x45,
+ 0x42, 0x8d, 0x9c, 0x28, 0xbc, 0xb7, 0x61, 0x43, 0xd7, 0xc5, 0x98, 0x4d, 0x5d, 0x0b, 0xef, 0x58,
+ 0xbe, 0x8c, 0x52, 0xc1, 0xd2, 0xf5, 0x03, 0x41, 0x08, 0x73, 0xdc, 0xc7, 0x1f, 0xc2, 0xcb, 0xb3,
+ 0x60, 0x25, 0x15, 0xd7, 0x17, 0x46, 0x39, 0xaf, 0x7a, 0x1b, 0x36, 0xdc, 0xd3, 0x45, 0x45, 0x9c,
+ 0xea, 0xd1, 0x3d, 0x9d, 0x57, 0xfb, 0x00, 0x36, 0xdd, 0xb1, 0xbb, 0xa8, 0x77, 0x3d, 0xa9, 0x87,
+ 0xdd, 0xb1, 0x3b, 0xaf, 0xf8, 0x16, 0xbf, 0x70, 0x7b, 0x54, 0x27, 0x01, 0x35, 0xe4, 0x8b, 0x49,
+ 0x7a, 0x42, 0x80, 0x77, 0x01, 0xe9, 0xba, 0x46, 0x6d, 0x72, 0x62, 0x51, 0x8d, 0x78, 0xd4, 0x26,
+ 0xbe, 0x7c, 0x39, 0x49, 0xae, 0xea, 0xba, 0xc2, 0xa5, 0x0d, 0x2e, 0xc4, 0xd7, 0x61, 0xdd, 0x39,
+ 0x79, 0xa8, 0x8b, 0x94, 0xd4, 0x5c, 0x8f, 0x0e, 0xcd, 0xa7, 0xf2, 0x9b, 0x3c, 0xbe, 0x6b, 0x4c,
+ 0xc0, 0x13, 0xb2, 0xc7, 0x61, 0x7c, 0x0d, 0x90, 0xee, 0x8f, 0x89, 0xe7, 0xf2, 0x3d, 0xd9, 0x77,
+ 0x89, 0x4e, 0xe5, 0xb7, 0x04, 0x55, 0xe0, 0x9d, 0x08, 0x66, 0x4b, 0xc2, 0x7f, 0x62, 0x0e, 0x83,
+ 0xc8, 0xe2, 0x55, 0xb1, 0x24, 0x38, 0x16, 0x5a, 0xdb, 0x01, 0xc4, 0x42, 0x91, 0xea, 0x78, 0x87,
+ 0xd3, 0xaa, 0xee, 0xd8, 0x4d, 0xf6, 0xfb, 0x06, 0xac, 0x32, 0xe6, 0xac, 0xd3, 0x6b, 0xa2, 0x20,
+ 0x73, 0xc7, 0x89, 0x1e, 0x6f, 0xc1, 0x05, 0x46, 0x9a, 0xd0, 0x80, 0x18, 0x24, 0x20, 0x09, 0xf6,
+ 0xbb, 0x9c, 0xcd, 0xe2, 0x7e, 0x14, 0x0a, 0x53, 0x7e, 0x7a, 0xd3, 0x93, 0xd3, 0x38, 0xb3, 0x6e,
+ 0x08, 0x3f, 0x19, 0x16, 0xe5, 0xd6, 0xf7, 0x56, 0x74, 0xd7, 0xf6, 0xa0, 0x92, 0x4c, 0x7c, 0x5c,
+ 0x02, 0x91, 0xfa, 0x48, 0x62, 0x55, 0x50, 0xb3, 0xdb, 0x62, 0xf5, 0xcb, 0xe7, 0x0a, 0xca, 0xb0,
+ 0x3a, 0xea, 0xb0, 0x3d, 0x50, 0x34, 0xf5, 0xb8, 0x33, 0x68, 0x1f, 0x29, 0x28, 0x9b, 0x28, 0xd8,
+ 0x1f, 0xe4, 0x8a, 0x6f, 0xa3, 0xab, 0xb5, 0xaf, 0x33, 0x50, 0x4d, 0xdf, 0xc0, 0xf0, 0x8f, 0xe0,
+ 0x62, 0xf4, 0x5c, 0xe2, 0xd3, 0x40, 0x7b, 0x62, 0x7a, 0x7c, 0x45, 0x4e, 0x88, 0x38, 0x1d, 0xe3,
+ 0x9c, 0xd8, 0x0c, 0x59, 0x7d, 0x1a, 0x7c, 0x62, 0x7a, 0x6c, 0xbd, 0x4d, 0x48, 0x80, 0x0f, 0xe1,
+ 0xb2, 0xed, 0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0x7b, 0xa8, 0xd2, 0x88, 0xae, 0x53,
+ 0xdf, 0x77, 0xc4, 0x49, 0x18, 0x5b, 0x79, 0xd5, 0x76, 0xfa, 0x21, 0x79, 0x76, 0x44, 0x34, 0x42,
+ 0xea, 0x5c, 0xfe, 0x66, 0xcf, 0xca, 0xdf, 0x57, 0xa0, 0x34, 0x21, 0xae, 0x46, 0xed, 0xc0, 0x3b,
+ 0xe5, 0x75, 0x77, 0x51, 0x2d, 0x4e, 0x88, 0xab, 0xb0, 0xf6, 0x0b, 0xb9, 0xfe, 0x3c, 0xc8, 0x15,
+ 0x8b, 0xa8, 0xf4, 0x20, 0x57, 0x2c, 0x21, 0xa8, 0xfd, 0x33, 0x0b, 0x95, 0x64, 0x1d, 0xce, 0xae,
+ 0x35, 0x3a, 0x3f, 0xb2, 0x24, 0xbe, 0xa9, 0xbd, 0xf1, 0x8d, 0x55, 0x7b, 0xbd, 0xc9, 0xce, 0xb2,
+ 0xbd, 0x82, 0xa8, 0x8e, 0x55, 0xa1, 0xc9, 0xea, 0x08, 0x96, 0x6c, 0x54, 0x54, 0x23, 0x45, 0x35,
+ 0x6c, 0xe1, 0x03, 0x28, 0x3c, 0xf4, 0xb9, 0xed, 0x02, 0xb7, 0xfd, 0xe6, 0x37, 0xdb, 0x7e, 0xd0,
+ 0xe7, 0xc6, 0x4b, 0x0f, 0xfa, 0x5a, 0xa7, 0xab, 0x1e, 0x35, 0x0e, 0xd5, 0x50, 0x1d, 0x5f, 0x82,
+ 0x9c, 0x45, 0xbe, 0x3c, 0x4d, 0x9f, 0x7a, 0x1c, 0x3a, 0xef, 0x24, 0x5c, 0x82, 0xdc, 0x13, 0x4a,
+ 0x1e, 0xa5, 0xcf, 0x1a, 0x0e, 0x7d, 0x8f, 0x8b, 0x61, 0x17, 0xf2, 0x3c, 0x5e, 0x18, 0x20, 0x8c,
+ 0x18, 0x7a, 0x09, 0x17, 0x21, 0xd7, 0xec, 0xaa, 0x6c, 0x41, 0x20, 0xa8, 0x08, 0x54, 0xeb, 0xb5,
+ 0x95, 0xa6, 0x82, 0x32, 0xb5, 0xdb, 0x50, 0x10, 0x41, 0x60, 0x8b, 0x25, 0x0e, 0x03, 0x7a, 0x29,
+ 0x6c, 0x86, 0x36, 0xa4, 0x48, 0x7a, 0x7c, 0xb4, 0xaf, 0xa8, 0x28, 0x93, 0x9e, 0xea, 0x1c, 0xca,
+ 0xd7, 0x7c, 0xa8, 0x24, 0x0b, 0xf1, 0x17, 0x73, 0xc9, 0xfe, 0x9b, 0x04, 0xe5, 0x44, 0x61, 0xcd,
+ 0x2a, 0x22, 0x62, 0x59, 0xce, 0x13, 0x8d, 0x58, 0x26, 0xf1, 0xc3, 0xd4, 0x00, 0x0e, 0x35, 0x18,
+ 0x72, 0xde, 0xa9, 0x7b, 0x41, 0x4b, 0x24, 0x8f, 0x0a, 0xb5, 0x3f, 0x4a, 0x80, 0xe6, 0x2b, 0xdb,
+ 0x39, 0x37, 0xa5, 0x1f, 0xd2, 0xcd, 0xda, 0x1f, 0x24, 0xa8, 0xa6, 0xcb, 0xd9, 0x39, 0xf7, 0xae,
+ 0xfc, 0xa0, 0xee, 0xfd, 0x23, 0x03, 0xab, 0xa9, 0x22, 0xf6, 0xbc, 0xde, 0x7d, 0x01, 0xeb, 0xa6,
+ 0x41, 0x27, 0xae, 0x13, 0x50, 0x5b, 0x3f, 0xd5, 0x2c, 0xfa, 0x98, 0x5a, 0x72, 0x8d, 0x6f, 0x1a,
+ 0xbb, 0xdf, 0x5c, 0x26, 0xd7, 0xdb, 0x33, 0xbd, 0x43, 0xa6, 0xb6, 0xb7, 0xd1, 0x6e, 0x29, 0x47,
+ 0xbd, 0xee, 0x40, 0xe9, 0x34, 0x3f, 0xd3, 0x8e, 0x3b, 0x3f, 0xed, 0x74, 0x3f, 0xe9, 0xa8, 0xc8,
+ 0x9c, 0xa3, 0x7d, 0x8f, 0xcb, 0xbe, 0x07, 0x68, 0xde, 0x29, 0x7c, 0x11, 0x96, 0xb9, 0x85, 0x5e,
+ 0xc2, 0x1b, 0xb0, 0xd6, 0xe9, 0x6a, 0xfd, 0x76, 0x4b, 0xd1, 0x94, 0xfb, 0xf7, 0x95, 0xe6, 0xa0,
+ 0x2f, 0x1e, 0x3e, 0x62, 0xf6, 0x20, 0xb5, 0xc0, 0x6b, 0xbf, 0xcf, 0xc2, 0xc6, 0x12, 0x4f, 0x70,
+ 0x23, 0xbc, 0xb2, 0x88, 0x5b, 0xd4, 0x8d, 0xf3, 0x78, 0x5f, 0x67, 0x35, 0x43, 0x8f, 0x78, 0x41,
+ 0x78, 0xc3, 0xb9, 0x06, 0x2c, 0x4a, 0x76, 0x60, 0x0e, 0x4d, 0xea, 0x85, 0xef, 0x44, 0xe2, 0x1e,
+ 0xb3, 0x36, 0xc3, 0xc5, 0x53, 0xd1, 0xbb, 0x80, 0x5d, 0xc7, 0x37, 0x03, 0xf3, 0x31, 0xd5, 0x4c,
+ 0x3b, 0x7a, 0x54, 0x62, 0xf7, 0x9a, 0x9c, 0x8a, 0x22, 0x49, 0xdb, 0x0e, 0x62, 0xb6, 0x4d, 0x47,
+ 0x64, 0x8e, 0xcd, 0x36, 0xf3, 0xac, 0x8a, 0x22, 0x49, 0xcc, 0xbe, 0x02, 0x15, 0xc3, 0x99, 0xb2,
+ 0x62, 0x4f, 0xf0, 0xd8, 0xd9, 0x21, 0xa9, 0x65, 0x81, 0xc5, 0x94, 0xb0, 0x8c, 0x9f, 0xbd, 0x66,
+ 0x55, 0xd4, 0xb2, 0xc0, 0x04, 0xe5, 0x2a, 0xac, 0x91, 0xd1, 0xc8, 0x63, 0xc6, 0x23, 0x43, 0xe2,
+ 0x62, 0x52, 0x8d, 0x61, 0x4e, 0xdc, 0x7a, 0x00, 0xc5, 0x28, 0x0e, 0xec, 0xa8, 0x66, 0x91, 0xd0,
+ 0x5c, 0x71, 0xdb, 0xce, 0xec, 0x94, 0xd4, 0xa2, 0x1d, 0x09, 0xaf, 0x40, 0xc5, 0xf4, 0xb5, 0xd9,
+ 0xe3, 0x7c, 0x66, 0x3b, 0xb3, 0x53, 0x54, 0xcb, 0xa6, 0x1f, 0x3f, 0x6c, 0xd6, 0xbe, 0xca, 0x40,
+ 0x35, 0xfd, 0x71, 0x01, 0xb7, 0xa0, 0x68, 0x39, 0x3a, 0xe1, 0xa9, 0x25, 0xbe, 0x6c, 0xed, 0x3c,
+ 0xe7, 0x7b, 0x44, 0xfd, 0x30, 0xe4, 0xab, 0xb1, 0xe6, 0xd6, 0xdf, 0x25, 0x28, 0x46, 0x30, 0xbe,
+ 0x00, 0x39, 0x97, 0x04, 0x63, 0x6e, 0x2e, 0xbf, 0x9f, 0x41, 0x92, 0xca, 0xdb, 0x0c, 0xf7, 0x5d,
+ 0x62, 0xf3, 0x14, 0x08, 0x71, 0xd6, 0x66, 0xf3, 0x6a, 0x51, 0x62, 0xf0, 0x5b, 0x8f, 0x33, 0x99,
+ 0x50, 0x3b, 0xf0, 0xa3, 0x79, 0x0d, 0xf1, 0x66, 0x08, 0xe3, 0x77, 0x60, 0x3d, 0xf0, 0x88, 0x69,
+ 0xa5, 0xb8, 0x39, 0xce, 0x45, 0x91, 0x20, 0x26, 0xef, 0xc1, 0xa5, 0xc8, 0xae, 0x41, 0x03, 0xa2,
+ 0x8f, 0xa9, 0x31, 0x53, 0x2a, 0xf0, 0xd7, 0x8d, 0x8b, 0x21, 0xa1, 0x15, 0xca, 0x23, 0xdd, 0xda,
+ 0xd7, 0x12, 0xac, 0x47, 0xf7, 0x34, 0x23, 0x0e, 0xd6, 0x11, 0x00, 0xb1, 0x6d, 0x27, 0x48, 0x86,
+ 0x6b, 0x31, 0x95, 0x17, 0xf4, 0xea, 0x8d, 0x58, 0x49, 0x4d, 0x18, 0xd8, 0x9a, 0x00, 0xcc, 0x24,
+ 0x67, 0x86, 0xed, 0x32, 0x94, 0xc3, 0x2f, 0x47, 0xfc, 0xf3, 0xa3, 0xb8, 0xd9, 0x83, 0x80, 0xd8,
+ 0x85, 0x0e, 0x6f, 0x42, 0xfe, 0x84, 0x8e, 0x4c, 0x3b, 0x7c, 0x0f, 0x16, 0x8d, 0xe8, 0xfd, 0x25,
+ 0x17, 0xbf, 0xbf, 0xec, 0xff, 0x46, 0x82, 0x0d, 0xdd, 0x99, 0xcc, 0xfb, 0xbb, 0x8f, 0xe6, 0x9e,
+ 0x17, 0xfc, 0x8f, 0xa5, 0xcf, 0x3f, 0x1a, 0x99, 0xc1, 0x78, 0x7a, 0x52, 0xd7, 0x9d, 0xc9, 0xee,
+ 0xc8, 0xb1, 0x88, 0x3d, 0x9a, 0x7d, 0x3f, 0xe5, 0x7f, 0xf4, 0x1b, 0x23, 0x6a, 0xdf, 0x18, 0x39,
+ 0x89, 0xaf, 0xa9, 0xf7, 0x66, 0x7f, 0xff, 0x27, 0x49, 0x7f, 0xca, 0x64, 0x0f, 0x7a, 0xfb, 0x7f,
+ 0xce, 0x6c, 0x1d, 0x88, 0xee, 0x7a, 0x51, 0x78, 0x54, 0x3a, 0xb4, 0xa8, 0xce, 0x86, 0xfc, 0xff,
+ 0x00, 0x00, 0x00, 0xff, 0xff, 0x3e, 0xe8, 0xef, 0xc4, 0x9b, 0x1d, 0x00, 0x00,
}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
new file mode 100644
index 0000000..ed08fcb
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
@@ -0,0 +1,883 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+
+syntax = "proto2";
+
+package google.protobuf;
+option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DescriptorProtos";
+option csharp_namespace = "Google.Protobuf.Reflection";
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// descriptor.proto must be optimized for speed because reflection-based
+// algorithms don't work during bootstrapping.
+option optimize_for = SPEED;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+ repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+ optional string name = 1; // file name, relative to root of source tree
+ optional string package = 2; // e.g. "foo", "foo.bar", etc.
+
+ // Names of files imported by this file.
+ repeated string dependency = 3;
+ // Indexes of the public imported files in the dependency list above.
+ repeated int32 public_dependency = 10;
+ // Indexes of the weak imported files in the dependency list.
+ // For Google-internal migration only. Do not use.
+ repeated int32 weak_dependency = 11;
+
+ // All top-level definitions in this file.
+ repeated DescriptorProto message_type = 4;
+ repeated EnumDescriptorProto enum_type = 5;
+ repeated ServiceDescriptorProto service = 6;
+ repeated FieldDescriptorProto extension = 7;
+
+ optional FileOptions options = 8;
+
+ // This field contains optional information about the original source code.
+ // You may safely remove this entire field without harming runtime
+ // functionality of the descriptors -- the information is needed only by
+ // development tools.
+ optional SourceCodeInfo source_code_info = 9;
+
+ // The syntax of the proto file.
+ // The supported values are "proto2" and "proto3".
+ optional string syntax = 12;
+}
+
+// Describes a message type.
+message DescriptorProto {
+ optional string name = 1;
+
+ repeated FieldDescriptorProto field = 2;
+ repeated FieldDescriptorProto extension = 6;
+
+ repeated DescriptorProto nested_type = 3;
+ repeated EnumDescriptorProto enum_type = 4;
+
+ message ExtensionRange {
+ optional int32 start = 1;
+ optional int32 end = 2;
+
+ optional ExtensionRangeOptions options = 3;
+ }
+ repeated ExtensionRange extension_range = 5;
+
+ repeated OneofDescriptorProto oneof_decl = 8;
+
+ optional MessageOptions options = 7;
+
+ // Range of reserved tag numbers. Reserved tag numbers may not be used by
+ // fields or extension ranges in the same message. Reserved ranges may
+ // not overlap.
+ message ReservedRange {
+ optional int32 start = 1; // Inclusive.
+ optional int32 end = 2; // Exclusive.
+ }
+ repeated ReservedRange reserved_range = 9;
+ // Reserved field names, which may not be used by fields in the same message.
+ // A given name may only be reserved once.
+ repeated string reserved_name = 10;
+}
+
+message ExtensionRangeOptions {
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+ enum Type {
+ // 0 is reserved for errors.
+ // Order is weird for historical reasons.
+ TYPE_DOUBLE = 1;
+ TYPE_FLOAT = 2;
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
+ // negative values are likely.
+ TYPE_INT64 = 3;
+ TYPE_UINT64 = 4;
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
+ // negative values are likely.
+ TYPE_INT32 = 5;
+ TYPE_FIXED64 = 6;
+ TYPE_FIXED32 = 7;
+ TYPE_BOOL = 8;
+ TYPE_STRING = 9;
+ // Tag-delimited aggregate.
+ // Group type is deprecated and not supported in proto3. However, Proto3
+ // implementations should still be able to parse the group wire format and
+ // treat group fields as unknown fields.
+ TYPE_GROUP = 10;
+ TYPE_MESSAGE = 11; // Length-delimited aggregate.
+
+ // New in version 2.
+ TYPE_BYTES = 12;
+ TYPE_UINT32 = 13;
+ TYPE_ENUM = 14;
+ TYPE_SFIXED32 = 15;
+ TYPE_SFIXED64 = 16;
+ TYPE_SINT32 = 17; // Uses ZigZag encoding.
+ TYPE_SINT64 = 18; // Uses ZigZag encoding.
+ };
+
+ enum Label {
+ // 0 is reserved for errors
+ LABEL_OPTIONAL = 1;
+ LABEL_REQUIRED = 2;
+ LABEL_REPEATED = 3;
+ };
+
+ optional string name = 1;
+ optional int32 number = 3;
+ optional Label label = 4;
+
+ // If type_name is set, this need not be set. If both this and type_name
+ // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+ optional Type type = 5;
+
+ // For message and enum types, this is the name of the type. If the name
+ // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
+ // rules are used to find the type (i.e. first the nested types within this
+ // message are searched, then within the parent, on up to the root
+ // namespace).
+ optional string type_name = 6;
+
+ // For extensions, this is the name of the type being extended. It is
+ // resolved in the same manner as type_name.
+ optional string extendee = 2;
+
+ // For numeric types, contains the original text representation of the value.
+ // For booleans, "true" or "false".
+ // For strings, contains the default text contents (not escaped in any way).
+ // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
+ // TODO(kenton): Base-64 encode?
+ optional string default_value = 7;
+
+ // If set, gives the index of a oneof in the containing type's oneof_decl
+ // list. This field is a member of that oneof.
+ optional int32 oneof_index = 9;
+
+ // JSON name of this field. The value is set by protocol compiler. If the
+ // user has set a "json_name" option on this field, that option's value
+ // will be used. Otherwise, it's deduced from the field's name by converting
+ // it to camelCase.
+ optional string json_name = 10;
+
+ optional FieldOptions options = 8;
+}
+
+// Describes a oneof.
+message OneofDescriptorProto {
+ optional string name = 1;
+ optional OneofOptions options = 2;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+ optional string name = 1;
+
+ repeated EnumValueDescriptorProto value = 2;
+
+ optional EnumOptions options = 3;
+
+ // Range of reserved numeric values. Reserved values may not be used by
+ // entries in the same enum. Reserved ranges may not overlap.
+ //
+ // Note that this is distinct from DescriptorProto.ReservedRange in that it
+ // is inclusive such that it can appropriately represent the entire int32
+ // domain.
+ message EnumReservedRange {
+ optional int32 start = 1; // Inclusive.
+ optional int32 end = 2; // Inclusive.
+ }
+
+ // Range of reserved numeric values. Reserved numeric values may not be used
+ // by enum values in the same enum declaration. Reserved ranges may not
+ // overlap.
+ repeated EnumReservedRange reserved_range = 4;
+
+ // Reserved enum value names, which may not be reused. A given name may only
+ // be reserved once.
+ repeated string reserved_name = 5;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+ optional string name = 1;
+ optional int32 number = 2;
+
+ optional EnumValueOptions options = 3;
+}
+
+// Describes a service.
+message ServiceDescriptorProto {
+ optional string name = 1;
+ repeated MethodDescriptorProto method = 2;
+
+ optional ServiceOptions options = 3;
+}
+
+// Describes a method of a service.
+message MethodDescriptorProto {
+ optional string name = 1;
+
+ // Input and output type names. These are resolved in the same way as
+ // FieldDescriptorProto.type_name, but must refer to a message type.
+ optional string input_type = 2;
+ optional string output_type = 3;
+
+ optional MethodOptions options = 4;
+
+ // Identifies if client streams multiple client messages
+ optional bool client_streaming = 5 [default=false];
+ // Identifies if server streams multiple server messages
+ optional bool server_streaming = 6 [default=false];
+}
+
+
+// ===================================================================
+// Options
+
+// Each of the definitions above may have "options" attached. These are
+// just annotations which may cause code to be generated slightly differently
+// or may contain hints for code that manipulates protocol messages.
+//
+// Clients may define custom options as extensions of the *Options messages.
+// These extensions may not yet be known at parsing time, so the parser cannot
+// store the values in them. Instead it stores them in a field in the *Options
+// message called uninterpreted_option. This field must have the same name
+// across all *Options messages. We then use this field to populate the
+// extensions when we build a descriptor, at which point all protos have been
+// parsed and so all extensions are known.
+//
+// Extension numbers for custom options may be chosen as follows:
+// * For options which will only be used within a single application or
+// organization, or for experimental options, use field numbers 50000
+// through 99999. It is up to you to ensure that you do not use the
+// same number for multiple options.
+// * For options which will be published and used publicly by multiple
+// independent entities, e-mail protobuf-global-extension-registry@google.com
+// to reserve extension numbers. Simply provide your project name (e.g.
+// Objective-C plugin) and your project website (if available) -- there's no
+// need to explain how you intend to use them. Usually you only need one
+// extension number. You can declare multiple options with only one extension
+// number by putting them in a sub-message. See the Custom Options section of
+// the docs for examples:
+// https://developers.google.com/protocol-buffers/docs/proto#options
+// If this turns out to be popular, a web service will be set up
+// to automatically assign option numbers.
+
+
+message FileOptions {
+
+ // Sets the Java package where classes generated from this .proto will be
+ // placed. By default, the proto package is used, but this is often
+ // inappropriate because proto packages do not normally start with backwards
+ // domain names.
+ optional string java_package = 1;
+
+
+ // If set, all the classes from the .proto file are wrapped in a single
+ // outer class with the given name. This applies to both Proto1
+ // (equivalent to the old "--one_java_file" option) and Proto2 (where
+ // a .proto always translates to a single class, but you may want to
+ // explicitly choose the class name).
+ optional string java_outer_classname = 8;
+
+ // If set true, then the Java code generator will generate a separate .java
+ // file for each top-level message, enum, and service defined in the .proto
+ // file. Thus, these types will *not* be nested inside the outer class
+ // named by java_outer_classname. However, the outer class will still be
+ // generated to contain the file's getDescriptor() method as well as any
+ // top-level extensions defined in the file.
+ optional bool java_multiple_files = 10 [default=false];
+
+ // This option does nothing.
+ optional bool java_generate_equals_and_hash = 20 [deprecated=true];
+
+ // If set true, then the Java2 code generator will generate code that
+ // throws an exception whenever an attempt is made to assign a non-UTF-8
+ // byte sequence to a string field.
+ // Message reflection will do the same.
+ // However, an extension field still accepts non-UTF-8 byte sequences.
+ // This option has no effect on when used with the lite runtime.
+ optional bool java_string_check_utf8 = 27 [default=false];
+
+
+ // Generated classes can be optimized for speed or code size.
+ enum OptimizeMode {
+ SPEED = 1; // Generate complete code for parsing, serialization,
+ // etc.
+ CODE_SIZE = 2; // Use ReflectionOps to implement these methods.
+ LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
+ }
+ optional OptimizeMode optimize_for = 9 [default=SPEED];
+
+ // Sets the Go package where structs generated from this .proto will be
+ // placed. If omitted, the Go package will be derived from the following:
+ // - The basename of the package import path, if provided.
+ // - Otherwise, the package statement in the .proto file, if present.
+ // - Otherwise, the basename of the .proto file, without extension.
+ optional string go_package = 11;
+
+
+
+ // Should generic services be generated in each language? "Generic" services
+ // are not specific to any particular RPC system. They are generated by the
+ // main code generators in each language (without additional plugins).
+ // Generic services were the only kind of service generation supported by
+ // early versions of google.protobuf.
+ //
+ // Generic services are now considered deprecated in favor of using plugins
+ // that generate code specific to your particular RPC system. Therefore,
+ // these default to false. Old code which depends on generic services should
+ // explicitly set them to true.
+ optional bool cc_generic_services = 16 [default=false];
+ optional bool java_generic_services = 17 [default=false];
+ optional bool py_generic_services = 18 [default=false];
+ optional bool php_generic_services = 42 [default=false];
+
+ // Is this file deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for everything in the file, or it will be completely ignored; in the very
+ // least, this is a formalization for deprecating files.
+ optional bool deprecated = 23 [default=false];
+
+ // Enables the use of arenas for the proto messages in this file. This applies
+ // only to generated classes for C++.
+ optional bool cc_enable_arenas = 31 [default=false];
+
+
+ // Sets the objective c class prefix which is prepended to all objective c
+ // generated classes from this .proto. There is no default.
+ optional string objc_class_prefix = 36;
+
+ // Namespace for generated classes; defaults to the package.
+ optional string csharp_namespace = 37;
+
+ // By default Swift generators will take the proto package and CamelCase it
+ // replacing '.' with underscore and use that to prefix the types/symbols
+ // defined. When this options is provided, they will use this value instead
+ // to prefix the types/symbols defined.
+ optional string swift_prefix = 39;
+
+ // Sets the php class prefix which is prepended to all php generated classes
+ // from this .proto. Default is empty.
+ optional string php_class_prefix = 40;
+
+ // Use this option to change the namespace of php generated classes. Default
+ // is empty. When this option is empty, the package name will be used for
+ // determining the namespace.
+ optional string php_namespace = 41;
+
+
+ // Use this option to change the namespace of php generated metadata classes.
+ // Default is empty. When this option is empty, the proto file name will be used
+ // for determining the namespace.
+ optional string php_metadata_namespace = 44;
+
+ // Use this option to change the package of ruby generated classes. Default
+ // is empty. When this option is not set, the package name will be used for
+ // determining the ruby package.
+ optional string ruby_package = 45;
+
+ // The parser stores options it doesn't recognize here.
+ // See the documentation for the "Options" section above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message.
+ // See the documentation for the "Options" section above.
+ extensions 1000 to max;
+
+ reserved 38;
+}
+
+message MessageOptions {
+ // Set true to use the old proto1 MessageSet wire format for extensions.
+ // This is provided for backwards-compatibility with the MessageSet wire
+ // format. You should not use this for any other reason: It's less
+ // efficient, has fewer features, and is more complicated.
+ //
+ // The message must be defined exactly as follows:
+ // message Foo {
+ // option message_set_wire_format = true;
+ // extensions 4 to max;
+ // }
+ // Note that the message cannot have any defined fields; MessageSets only
+ // have extensions.
+ //
+ // All extensions of your type must be singular messages; e.g. they cannot
+ // be int32s, enums, or repeated messages.
+ //
+ // Because this is an option, the above two restrictions are not enforced by
+ // the protocol compiler.
+ optional bool message_set_wire_format = 1 [default=false];
+
+ // Disables the generation of the standard "descriptor()" accessor, which can
+ // conflict with a field of the same name. This is meant to make migration
+ // from proto1 easier; new code should avoid fields named "descriptor".
+ optional bool no_standard_descriptor_accessor = 2 [default=false];
+
+ // Is this message deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the message, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating messages.
+ optional bool deprecated = 3 [default=false];
+
+ // Whether the message is an automatically generated map entry type for the
+ // maps field.
+ //
+ // For maps fields:
+ // map<KeyType, ValueType> map_field = 1;
+ // The parsed descriptor looks like:
+ // message MapFieldEntry {
+ // option map_entry = true;
+ // optional KeyType key = 1;
+ // optional ValueType value = 2;
+ // }
+ // repeated MapFieldEntry map_field = 1;
+ //
+ // Implementations may choose not to generate the map_entry=true message, but
+ // use a native map in the target language to hold the keys and values.
+ // The reflection APIs in such implementions still need to work as
+ // if the field is a repeated message field.
+ //
+ // NOTE: Do not set the option in .proto files. Always use the maps syntax
+ // instead. The option should only be implicitly set by the proto compiler
+ // parser.
+ optional bool map_entry = 7;
+
+ reserved 8; // javalite_serializable
+ reserved 9; // javanano_as_lite
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+message FieldOptions {
+ // The ctype option instructs the C++ code generator to use a different
+ // representation of the field than it normally would. See the specific
+ // options below. This option is not yet implemented in the open source
+ // release -- sorry, we'll try to include it in a future version!
+ optional CType ctype = 1 [default = STRING];
+ enum CType {
+ // Default mode.
+ STRING = 0;
+
+ CORD = 1;
+
+ STRING_PIECE = 2;
+ }
+ // The packed option can be enabled for repeated primitive fields to enable
+ // a more efficient representation on the wire. Rather than repeatedly
+ // writing the tag and type for each element, the entire array is encoded as
+ // a single length-delimited blob. In proto3, only explicit setting it to
+ // false will avoid using packed encoding.
+ optional bool packed = 2;
+
+ // The jstype option determines the JavaScript type used for values of the
+ // field. The option is permitted only for 64 bit integral and fixed types
+ // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
+ // is represented as JavaScript string, which avoids loss of precision that
+ // can happen when a large value is converted to a floating point JavaScript.
+ // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+ // use the JavaScript "number" type. The behavior of the default option
+ // JS_NORMAL is implementation dependent.
+ //
+ // This option is an enum to permit additional types to be added, e.g.
+ // goog.math.Integer.
+ optional JSType jstype = 6 [default = JS_NORMAL];
+ enum JSType {
+ // Use the default type.
+ JS_NORMAL = 0;
+
+ // Use JavaScript strings.
+ JS_STRING = 1;
+
+ // Use JavaScript numbers.
+ JS_NUMBER = 2;
+ }
+
+ // Should this field be parsed lazily? Lazy applies only to message-type
+ // fields. It means that when the outer message is initially parsed, the
+ // inner message's contents will not be parsed but instead stored in encoded
+ // form. The inner message will actually be parsed when it is first accessed.
+ //
+ // This is only a hint. Implementations are free to choose whether to use
+ // eager or lazy parsing regardless of the value of this option. However,
+ // setting this option true suggests that the protocol author believes that
+ // using lazy parsing on this field is worth the additional bookkeeping
+ // overhead typically needed to implement it.
+ //
+ // This option does not affect the public interface of any generated code;
+ // all method signatures remain the same. Furthermore, thread-safety of the
+ // interface is not affected by this option; const methods remain safe to
+ // call from multiple threads concurrently, while non-const methods continue
+ // to require exclusive access.
+ //
+ //
+ // Note that implementations may choose not to check required fields within
+ // a lazy sub-message. That is, calling IsInitialized() on the outer message
+ // may return true even if the inner message has missing required fields.
+ // This is necessary because otherwise the inner message would have to be
+ // parsed in order to perform the check, defeating the purpose of lazy
+ // parsing. An implementation which chooses not to check required fields
+ // must be consistent about it. That is, for any particular sub-message, the
+ // implementation must either *always* check its required fields, or *never*
+ // check its required fields, regardless of whether or not the message has
+ // been parsed.
+ optional bool lazy = 5 [default=false];
+
+ // Is this field deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for accessors, or it will be completely ignored; in the very least, this
+ // is a formalization for deprecating fields.
+ optional bool deprecated = 3 [default=false];
+
+ // For Google-internal migration only. Do not use.
+ optional bool weak = 10 [default=false];
+
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+
+ reserved 4; // removed jtype
+}
+
+message OneofOptions {
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+message EnumOptions {
+
+ // Set this option to true to allow mapping different tag names to the same
+ // value.
+ optional bool allow_alias = 2;
+
+ // Is this enum deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the enum, or it will be completely ignored; in the very least, this
+ // is a formalization for deprecating enums.
+ optional bool deprecated = 3 [default=false];
+
+ reserved 5; // javanano_as_lite
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+message EnumValueOptions {
+ // Is this enum value deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the enum value, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating enum values.
+ optional bool deprecated = 1 [default=false];
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+message ServiceOptions {
+
+ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC
+ // framework. We apologize for hoarding these numbers to ourselves, but
+ // we were already using them long before we decided to release Protocol
+ // Buffers.
+
+ // Is this service deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the service, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating services.
+ optional bool deprecated = 33 [default=false];
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+message MethodOptions {
+
+ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC
+ // framework. We apologize for hoarding these numbers to ourselves, but
+ // we were already using them long before we decided to release Protocol
+ // Buffers.
+
+ // Is this method deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the method, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating methods.
+ optional bool deprecated = 33 [default=false];
+
+ // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+ // or neither? HTTP based RPC implementation may choose GET verb for safe
+ // methods, and PUT verb for idempotent methods instead of the default POST.
+ enum IdempotencyLevel {
+ IDEMPOTENCY_UNKNOWN = 0;
+ NO_SIDE_EFFECTS = 1; // implies idempotent
+ IDEMPOTENT = 2; // idempotent, but may have side effects
+ }
+ optional IdempotencyLevel idempotency_level =
+ 34 [default=IDEMPOTENCY_UNKNOWN];
+
+ // The parser stores options it doesn't recognize here. See above.
+ repeated UninterpretedOption uninterpreted_option = 999;
+
+ // Clients can define custom options in extensions of this message. See above.
+ extensions 1000 to max;
+}
+
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+message UninterpretedOption {
+ // The name of the uninterpreted option. Each string represents a segment in
+ // a dot-separated name. is_extension is true iff a segment represents an
+ // extension (denoted with parentheses in options specs in .proto files).
+ // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+ // "foo.(bar.baz).qux".
+ message NamePart {
+ required string name_part = 1;
+ required bool is_extension = 2;
+ }
+ repeated NamePart name = 2;
+
+ // The value of the uninterpreted option, in whatever type the tokenizer
+ // identified it as during parsing. Exactly one of these should be set.
+ optional string identifier_value = 3;
+ optional uint64 positive_int_value = 4;
+ optional int64 negative_int_value = 5;
+ optional double double_value = 6;
+ optional bytes string_value = 7;
+ optional string aggregate_value = 8;
+}
+
+// ===================================================================
+// Optional source code info
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+message SourceCodeInfo {
+ // A Location identifies a piece of source code in a .proto file which
+ // corresponds to a particular definition. This information is intended
+ // to be useful to IDEs, code indexers, documentation generators, and similar
+ // tools.
+ //
+ // For example, say we have a file like:
+ // message Foo {
+ // optional string foo = 1;
+ // }
+ // Let's look at just the field definition:
+ // optional string foo = 1;
+ // ^ ^^ ^^ ^ ^^^
+ // a bc de f ghi
+ // We have the following locations:
+ // span path represents
+ // [a,i) [ 4, 0, 2, 0 ] The whole field definition.
+ // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
+ // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
+ // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
+ // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
+ //
+ // Notes:
+ // - A location may refer to a repeated field itself (i.e. not to any
+ // particular index within it). This is used whenever a set of elements are
+ // logically enclosed in a single code segment. For example, an entire
+ // extend block (possibly containing multiple extension definitions) will
+ // have an outer location whose path refers to the "extensions" repeated
+ // field without an index.
+ // - Multiple locations may have the same path. This happens when a single
+ // logical declaration is spread out across multiple places. The most
+ // obvious example is the "extend" block again -- there may be multiple
+ // extend blocks in the same scope, each of which will have the same path.
+ // - A location's span is not always a subset of its parent's span. For
+ // example, the "extendee" of an extension declaration appears at the
+ // beginning of the "extend" block and is shared by all extensions within
+ // the block.
+ // - Just because a location's span is a subset of some other location's span
+ // does not mean that it is a descendent. For example, a "group" defines
+ // both a type and a field in a single declaration. Thus, the locations
+ // corresponding to the type and field and their components will overlap.
+ // - Code which tries to interpret locations should probably be designed to
+ // ignore those that it doesn't understand, as more types of locations could
+ // be recorded in the future.
+ repeated Location location = 1;
+ message Location {
+ // Identifies which part of the FileDescriptorProto was defined at this
+ // location.
+ //
+ // Each element is a field number or an index. They form a path from
+ // the root FileDescriptorProto to the place where the definition. For
+ // example, this path:
+ // [ 4, 3, 2, 7, 1 ]
+ // refers to:
+ // file.message_type(3) // 4, 3
+ // .field(7) // 2, 7
+ // .name() // 1
+ // This is because FileDescriptorProto.message_type has field number 4:
+ // repeated DescriptorProto message_type = 4;
+ // and DescriptorProto.field has field number 2:
+ // repeated FieldDescriptorProto field = 2;
+ // and FieldDescriptorProto.name has field number 1:
+ // optional string name = 1;
+ //
+ // Thus, the above path gives the location of a field name. If we removed
+ // the last element:
+ // [ 4, 3, 2, 7 ]
+ // this path refers to the whole field declaration (from the beginning
+ // of the label to the terminating semicolon).
+ repeated int32 path = 1 [packed=true];
+
+ // Always has exactly three or four elements: start line, start column,
+ // end line (optional, otherwise assumed same as start line), end column.
+ // These are packed into a single field for efficiency. Note that line
+ // and column numbers are zero-based -- typically you will want to add
+ // 1 to each before displaying to a user.
+ repeated int32 span = 2 [packed=true];
+
+ // If this SourceCodeInfo represents a complete declaration, these are any
+ // comments appearing before and after the declaration which appear to be
+ // attached to the declaration.
+ //
+ // A series of line comments appearing on consecutive lines, with no other
+ // tokens appearing on those lines, will be treated as a single comment.
+ //
+ // leading_detached_comments will keep paragraphs of comments that appear
+ // before (but not connected to) the current element. Each paragraph,
+ // separated by empty lines, will be one comment element in the repeated
+ // field.
+ //
+ // Only the comment content is provided; comment markers (e.g. //) are
+ // stripped out. For block comments, leading whitespace and an asterisk
+ // will be stripped from the beginning of each line other than the first.
+ // Newlines are included in the output.
+ //
+ // Examples:
+ //
+ // optional int32 foo = 1; // Comment attached to foo.
+ // // Comment attached to bar.
+ // optional int32 bar = 2;
+ //
+ // optional string baz = 3;
+ // // Comment attached to baz.
+ // // Another line attached to baz.
+ //
+ // // Comment attached to qux.
+ // //
+ // // Another line attached to qux.
+ // optional double qux = 4;
+ //
+ // // Detached comment for corge. This is not leading or trailing comments
+ // // to qux or corge because there are blank lines separating it from
+ // // both.
+ //
+ // // Detached comment for corge paragraph 2.
+ //
+ // optional string corge = 5;
+ // /* Block comment attached
+ // * to corge. Leading asterisks
+ // * will be removed. */
+ // /* Block comment attached to
+ // * grault. */
+ // optional int32 grault = 6;
+ //
+ // // ignored detached comments.
+ optional string leading_comments = 3;
+ optional string trailing_comments = 4;
+ repeated string leading_detached_comments = 6;
+ }
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+message GeneratedCodeInfo {
+ // An Annotation connects some span of text in generated code to an element
+ // of its generating .proto file.
+ repeated Annotation annotation = 1;
+ message Annotation {
+ // Identifies the element in the original source .proto file. This field
+ // is formatted the same as SourceCodeInfo.Location.path.
+ repeated int32 path = 1 [packed=true];
+
+ // Identifies the filesystem path to the original source .proto.
+ optional string source_file = 2;
+
+ // Identifies the starting offset in bytes in the generated code
+ // that relates to the identified object.
+ optional int32 begin = 3;
+
+ // Identifies the ending offset in bytes in the generated code that
+ // relates to the identified offset. The end offset should be one past
+ // the last relevant byte (so the length of the text = end - begin).
+ optional int32 end = 4;
+ }
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any.go b/vendor/github.com/golang/protobuf/ptypes/any.go
index e729dcf..70276e8 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any.go
@@ -1,165 +1,141 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package ptypes
+// This file implements functions to marshal proto.Message to/from
+// google.protobuf.Any message.
+
import (
"fmt"
+ "reflect"
"strings"
"github.com/golang/protobuf/proto"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-
- anypb "github.com/golang/protobuf/ptypes/any"
+ "github.com/golang/protobuf/ptypes/any"
)
-const urlPrefix = "type.googleapis.com/"
+const googleApis = "type.googleapis.com/"
-// AnyMessageName returns the message name contained in an anypb.Any message.
-// Most type assertions should use the Is function instead.
-func AnyMessageName(any *anypb.Any) (string, error) {
- name, err := anyMessageName(any)
- return string(name), err
-}
-func anyMessageName(any *anypb.Any) (protoreflect.FullName, error) {
+// AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
+//
+// Note that regular type assertions should be done using the Is
+// function. AnyMessageName is provided for less common use cases like filtering a
+// sequence of Any messages based on a set of allowed message type names.
+func AnyMessageName(any *any.Any) (string, error) {
if any == nil {
return "", fmt.Errorf("message is nil")
}
- name := protoreflect.FullName(any.TypeUrl)
- if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 {
- name = name[i+len("/"):]
- }
- if !name.IsValid() {
+ slash := strings.LastIndex(any.TypeUrl, "/")
+ if slash < 0 {
return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
}
- return name, nil
+ return any.TypeUrl[slash+1:], nil
}
-// MarshalAny marshals the given message m into an anypb.Any message.
-func MarshalAny(m proto.Message) (*anypb.Any, error) {
- switch dm := m.(type) {
- case DynamicAny:
- m = dm.Message
- case *DynamicAny:
- if dm == nil {
- return nil, proto.ErrNil
- }
- m = dm.Message
- }
- b, err := proto.Marshal(m)
+// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
+func MarshalAny(pb proto.Message) (*any.Any, error) {
+ value, err := proto.Marshal(pb)
if err != nil {
return nil, err
}
- return &anypb.Any{TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil
+ return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil
}
-// Empty returns a new message of the type specified in an anypb.Any message.
-// It returns protoregistry.NotFound if the corresponding message type could not
-// be resolved in the global registry.
-func Empty(any *anypb.Any) (proto.Message, error) {
- name, err := anyMessageName(any)
- if err != nil {
- return nil, err
- }
- mt, err := protoregistry.GlobalTypes.FindMessageByName(name)
- if err != nil {
- return nil, err
- }
- return proto.MessageV1(mt.New().Interface()), nil
-}
-
-// UnmarshalAny unmarshals the encoded value contained in the anypb.Any message
-// into the provided message m. It returns an error if the target message
-// does not match the type in the Any message or if an unmarshal error occurs.
+// DynamicAny is a value that can be passed to UnmarshalAny to automatically
+// allocate a proto.Message for the type specified in a google.protobuf.Any
+// message. The allocated message is stored in the embedded proto.Message.
//
-// The target message m may be a *DynamicAny message. If the underlying message
-// type could not be resolved, then this returns protoregistry.NotFound.
-func UnmarshalAny(any *anypb.Any, m proto.Message) error {
- if dm, ok := m.(*DynamicAny); ok {
- if dm.Message == nil {
+// Example:
+//
+// var x ptypes.DynamicAny
+// if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
+// fmt.Printf("unmarshaled message: %v", x.Message)
+type DynamicAny struct {
+ proto.Message
+}
+
+// Empty returns a new proto.Message of the type specified in a
+// google.protobuf.Any message. It returns an error if corresponding message
+// type isn't linked in.
+func Empty(any *any.Any) (proto.Message, error) {
+ aname, err := AnyMessageName(any)
+ if err != nil {
+ return nil, err
+ }
+
+ t := proto.MessageType(aname)
+ if t == nil {
+ return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
+ }
+ return reflect.New(t.Elem()).Interface().(proto.Message), nil
+}
+
+// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
+// message and places the decoded result in pb. It returns an error if type of
+// contents of Any message does not match type of pb message.
+//
+// pb can be a proto.Message, or a *DynamicAny.
+func UnmarshalAny(any *any.Any, pb proto.Message) error {
+ if d, ok := pb.(*DynamicAny); ok {
+ if d.Message == nil {
var err error
- dm.Message, err = Empty(any)
+ d.Message, err = Empty(any)
if err != nil {
return err
}
}
- m = dm.Message
+ return UnmarshalAny(any, d.Message)
}
- anyName, err := AnyMessageName(any)
+ aname, err := AnyMessageName(any)
if err != nil {
return err
}
- msgName := proto.MessageName(m)
- if anyName != msgName {
- return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName)
+
+ mname := proto.MessageName(pb)
+ if aname != mname {
+ return fmt.Errorf("mismatched message type: got %q want %q", aname, mname)
}
- return proto.Unmarshal(any.Value, m)
+ return proto.Unmarshal(any.Value, pb)
}
-// Is reports whether the Any message contains a message of the specified type.
-func Is(any *anypb.Any, m proto.Message) bool {
- if any == nil || m == nil {
+// Is returns true if any value contains a given message type.
+func Is(any *any.Any, pb proto.Message) bool {
+ // The following is equivalent to AnyMessageName(any) == proto.MessageName(pb),
+ // but it avoids scanning TypeUrl for the slash.
+ if any == nil {
return false
}
- name := proto.MessageName(m)
- if !strings.HasSuffix(any.TypeUrl, name) {
- return false
- }
- return len(any.TypeUrl) == len(name) || any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/'
-}
-
-// DynamicAny is a value that can be passed to UnmarshalAny to automatically
-// allocate a proto.Message for the type specified in an anypb.Any message.
-// The allocated message is stored in the embedded proto.Message.
-//
-// Example:
-// var x ptypes.DynamicAny
-// if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
-// fmt.Printf("unmarshaled message: %v", x.Message)
-type DynamicAny struct{ proto.Message }
-
-func (m DynamicAny) String() string {
- if m.Message == nil {
- return "<nil>"
- }
- return m.Message.String()
-}
-func (m DynamicAny) Reset() {
- if m.Message == nil {
- return
- }
- m.Message.Reset()
-}
-func (m DynamicAny) ProtoMessage() {
- return
-}
-func (m DynamicAny) ProtoReflect() protoreflect.Message {
- if m.Message == nil {
- return nil
- }
- return dynamicAny{proto.MessageReflect(m.Message)}
-}
-
-type dynamicAny struct{ protoreflect.Message }
-
-func (m dynamicAny) Type() protoreflect.MessageType {
- return dynamicAnyType{m.Message.Type()}
-}
-func (m dynamicAny) New() protoreflect.Message {
- return dynamicAnyType{m.Message.Type()}.New()
-}
-func (m dynamicAny) Interface() protoreflect.ProtoMessage {
- return DynamicAny{proto.MessageV1(m.Message.Interface())}
-}
-
-type dynamicAnyType struct{ protoreflect.MessageType }
-
-func (t dynamicAnyType) New() protoreflect.Message {
- return dynamicAny{t.MessageType.New()}
-}
-func (t dynamicAnyType) Zero() protoreflect.Message {
- return dynamicAny{t.MessageType.Zero()}
+ name := proto.MessageName(pb)
+ prefix := len(any.TypeUrl) - len(name)
+ return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name
}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
index 0ef27d3..78ee523 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
@@ -1,62 +1,200 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/any/any.proto
+// source: google/protobuf/any.proto
package any
import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- anypb "google.golang.org/protobuf/types/known/anypb"
- reflect "reflect"
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
)
-// Symbols defined in public import of google/protobuf/any.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
-type Any = anypb.Any
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-var File_github_com_golang_protobuf_ptypes_any_any_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = []byte{
- 0x0a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
- 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
- 0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
- 0x6f, 0x1a, 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, 0x42, 0x2b, 0x5a, 0x29,
- 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e,
- 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65,
- 0x73, 0x2f, 0x61, 0x6e, 0x79, 0x3b, 0x61, 0x6e, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f,
- 0x74, 0x6f, 0x33,
+// `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);
+// }
+//
+// 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 := ptypes.MarshalAny(foo)
+// ...
+// foo := &pb.Foo{}
+// if err := ptypes.UnmarshalAny(any, 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 {
+ // A URL/resource name that uniquely identifies the type of the serialized
+ // protocol buffer message. 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.
+ //
+ // 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"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-var file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_any_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 (m *Any) Reset() { *m = Any{} }
+func (m *Any) String() string { return proto.CompactTextString(m) }
+func (*Any) ProtoMessage() {}
+func (*Any) Descriptor() ([]byte, []int) {
+ return fileDescriptor_b53526c13ae22eb4, []int{0}
}
-func init() { file_github_com_golang_protobuf_ptypes_any_any_proto_init() }
-func file_github_com_golang_protobuf_ptypes_any_any_proto_init() {
- if File_github_com_golang_protobuf_ptypes_any_any_proto != nil {
- return
+func (*Any) XXX_WellKnownType() string { return "Any" }
+
+func (m *Any) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Any.Unmarshal(m, b)
+}
+func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Any.Marshal(b, m, deterministic)
+}
+func (m *Any) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Any.Merge(m, src)
+}
+func (m *Any) XXX_Size() int {
+ return xxx_messageInfo_Any.Size(m)
+}
+func (m *Any) XXX_DiscardUnknown() {
+ xxx_messageInfo_Any.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Any proto.InternalMessageInfo
+
+func (m *Any) GetTypeUrl() string {
+ if m != nil {
+ return m.TypeUrl
}
- type x struct{}
- out := protoimpl.TypeBuilder{
- File: protoimpl.DescBuilder{
- GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc,
- NumEnums: 0,
- NumMessages: 0,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes,
- DependencyIndexes: file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs,
- }.Build()
- File_github_com_golang_protobuf_ptypes_any_any_proto = out.File
- file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = nil
- file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = nil
- file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = nil
+ return ""
+}
+
+func (m *Any) GetValue() []byte {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*Any)(nil), "google.protobuf.Any")
+}
+
+func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_b53526c13ae22eb4) }
+
+var fileDescriptor_b53526c13ae22eb4 = []byte{
+ // 185 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
+ 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
+ 0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a,
+ 0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46,
+ 0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7,
+ 0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce,
+ 0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52,
+ 0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc,
+ 0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c,
+ 0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce,
+ 0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
+ 0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00,
}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.proto b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
new file mode 100644
index 0000000..4932942
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
@@ -0,0 +1,154 @@
+// 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.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/any";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// `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);
+// }
+//
+// 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 := ptypes.MarshalAny(foo)
+// ...
+// foo := &pb.Foo{}
+// if err := ptypes.UnmarshalAny(any, 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"
+// }
+//
+message Any {
+ // A URL/resource name that uniquely identifies the type of the serialized
+ // protocol buffer message. 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.
+ //
+ // Schemes other than `http`, `https` (or the empty scheme) might be
+ // used with implementation specific semantics.
+ //
+ string type_url = 1;
+
+ // Must be a valid serialized protocol buffer of the above specified type.
+ bytes value = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/doc.go b/vendor/github.com/golang/protobuf/ptypes/doc.go
index fb9edd5..c0d595d 100644
--- a/vendor/github.com/golang/protobuf/ptypes/doc.go
+++ b/vendor/github.com/golang/protobuf/ptypes/doc.go
@@ -1,6 +1,35 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
-// Package ptypes provides functionality for interacting with well-known types.
+/*
+Package ptypes contains code for interacting with well-known types.
+*/
package ptypes
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration.go b/vendor/github.com/golang/protobuf/ptypes/duration.go
index 6110ae8..26d1ca2 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration.go
@@ -1,72 +1,102 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package ptypes
+// This file implements conversions between google.protobuf.Duration
+// and time.Duration.
+
import (
"errors"
"fmt"
"time"
- durationpb "github.com/golang/protobuf/ptypes/duration"
+ durpb "github.com/golang/protobuf/ptypes/duration"
)
-// Range of google.protobuf.Duration as specified in duration.proto.
-// This is about 10,000 years in seconds.
const (
+ // Range of a durpb.Duration in seconds, as specified in
+ // google/protobuf/duration.proto. This is about 10,000 years in seconds.
maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
minSeconds = -maxSeconds
)
-// Duration converts a durationpb.Duration to a time.Duration.
-// Duration returns an error if dur is invalid or overflows a time.Duration.
-func Duration(dur *durationpb.Duration) (time.Duration, error) {
- if err := validateDuration(dur); err != nil {
+// validateDuration determines whether the durpb.Duration is valid according to the
+// definition in google/protobuf/duration.proto. A valid durpb.Duration
+// may still be too large to fit into a time.Duration (the range of durpb.Duration
+// is about 10,000 years, and the range of time.Duration is about 290).
+func validateDuration(d *durpb.Duration) error {
+ if d == nil {
+ return errors.New("duration: nil Duration")
+ }
+ if d.Seconds < minSeconds || d.Seconds > maxSeconds {
+ return fmt.Errorf("duration: %v: seconds out of range", d)
+ }
+ if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
+ return fmt.Errorf("duration: %v: nanos out of range", d)
+ }
+ // Seconds and Nanos must have the same sign, unless d.Nanos is zero.
+ if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
+ return fmt.Errorf("duration: %v: seconds and nanos have different signs", d)
+ }
+ return nil
+}
+
+// Duration converts a durpb.Duration to a time.Duration. Duration
+// returns an error if the durpb.Duration is invalid or is too large to be
+// represented in a time.Duration.
+func Duration(p *durpb.Duration) (time.Duration, error) {
+ if err := validateDuration(p); err != nil {
return 0, err
}
- d := time.Duration(dur.Seconds) * time.Second
- if int64(d/time.Second) != dur.Seconds {
- return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
+ d := time.Duration(p.Seconds) * time.Second
+ if int64(d/time.Second) != p.Seconds {
+ return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
}
- if dur.Nanos != 0 {
- d += time.Duration(dur.Nanos) * time.Nanosecond
- if (d < 0) != (dur.Nanos < 0) {
- return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
+ if p.Nanos != 0 {
+ d += time.Duration(p.Nanos) * time.Nanosecond
+ if (d < 0) != (p.Nanos < 0) {
+ return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
}
}
return d, nil
}
-// DurationProto converts a time.Duration to a durationpb.Duration.
-func DurationProto(d time.Duration) *durationpb.Duration {
+// DurationProto converts a time.Duration to a durpb.Duration.
+func DurationProto(d time.Duration) *durpb.Duration {
nanos := d.Nanoseconds()
secs := nanos / 1e9
nanos -= secs * 1e9
- return &durationpb.Duration{
- Seconds: int64(secs),
+ return &durpb.Duration{
+ Seconds: secs,
Nanos: int32(nanos),
}
}
-
-// validateDuration determines whether the durationpb.Duration is valid
-// according to the definition in google/protobuf/duration.proto.
-// A valid durpb.Duration may still be too large to fit into a time.Duration
-// Note that the range of durationpb.Duration is about 10,000 years,
-// while the range of time.Duration is about 290 years.
-func validateDuration(dur *durationpb.Duration) error {
- if dur == nil {
- return errors.New("duration: nil Duration")
- }
- if dur.Seconds < minSeconds || dur.Seconds > maxSeconds {
- return fmt.Errorf("duration: %v: seconds out of range", dur)
- }
- if dur.Nanos <= -1e9 || dur.Nanos >= 1e9 {
- return fmt.Errorf("duration: %v: nanos out of range", dur)
- }
- // Seconds and Nanos must have the same sign, unless d.Nanos is zero.
- if (dur.Seconds < 0 && dur.Nanos > 0) || (dur.Seconds > 0 && dur.Nanos < 0) {
- return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur)
- }
- return nil
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
index d0079ee..0d681ee 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
@@ -1,63 +1,161 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/duration/duration.proto
+// source: google/protobuf/duration.proto
package duration
import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- durationpb "google.golang.org/protobuf/types/known/durationpb"
- reflect "reflect"
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
)
-// Symbols defined in public import of google/protobuf/duration.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
-type Duration = durationpb.Duration
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-var File_github_com_golang_protobuf_ptypes_duration_duration_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = []byte{
- 0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
- 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
- 0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x64, 0x75, 0x72,
- 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x42, 0x35, 0x5a, 0x33, 0x67,
- 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
- 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
- 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
- 0x6f, 0x6e, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+// 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 (durations.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 {
+ // 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"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-var file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_duration_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 (m *Duration) Reset() { *m = Duration{} }
+func (m *Duration) String() string { return proto.CompactTextString(m) }
+func (*Duration) ProtoMessage() {}
+func (*Duration) Descriptor() ([]byte, []int) {
+ return fileDescriptor_23597b2ebd7ac6c5, []int{0}
}
-func init() { file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() }
-func file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() {
- if File_github_com_golang_protobuf_ptypes_duration_duration_proto != nil {
- return
+func (*Duration) XXX_WellKnownType() string { return "Duration" }
+
+func (m *Duration) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Duration.Unmarshal(m, b)
+}
+func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
+}
+func (m *Duration) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Duration.Merge(m, src)
+}
+func (m *Duration) XXX_Size() int {
+ return xxx_messageInfo_Duration.Size(m)
+}
+func (m *Duration) XXX_DiscardUnknown() {
+ xxx_messageInfo_Duration.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Duration proto.InternalMessageInfo
+
+func (m *Duration) GetSeconds() int64 {
+ if m != nil {
+ return m.Seconds
}
- type x struct{}
- out := protoimpl.TypeBuilder{
- File: protoimpl.DescBuilder{
- GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc,
- NumEnums: 0,
- NumMessages: 0,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes,
- DependencyIndexes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs,
- }.Build()
- File_github_com_golang_protobuf_ptypes_duration_duration_proto = out.File
- file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = nil
- file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = nil
- file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = nil
+ return 0
+}
+
+func (m *Duration) GetNanos() int32 {
+ if m != nil {
+ return m.Nanos
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
+}
+
+func init() { proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_23597b2ebd7ac6c5) }
+
+var fileDescriptor_23597b2ebd7ac6c5 = []byte{
+ // 190 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
+ 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
+ 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56,
+ 0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5,
+ 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e,
+ 0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c,
+ 0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56,
+ 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e,
+ 0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4,
+ 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78,
+ 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63,
+ 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00,
}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
new file mode 100644
index 0000000..975fce4
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
@@ -0,0 +1,117 @@
+// 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.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/duration";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DurationProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// 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 (durations.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".
+//
+//
+message Duration {
+
+ // 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
+ int64 seconds = 1;
+
+ // 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.
+ int32 nanos = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
index 16686a6..b4eb03e 100644
--- a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
@@ -1,62 +1,83 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/empty/empty.proto
+// source: google/protobuf/empty.proto
package empty
import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- emptypb "google.golang.org/protobuf/types/known/emptypb"
- reflect "reflect"
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
)
-// Symbols defined in public import of google/protobuf/empty.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
-type Empty = emptypb.Empty
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-var File_github_com_golang_protobuf_ptypes_empty_empty_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = []byte{
- 0x0a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
- 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
- 0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
- 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
- 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x3b, 0x65, 0x6d,
- 0x70, 0x74, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+// 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);
+// }
+//
+// The JSON representation for `Empty` is empty JSON object `{}`.
+type Empty struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-var file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_empty_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 (m *Empty) Reset() { *m = Empty{} }
+func (m *Empty) String() string { return proto.CompactTextString(m) }
+func (*Empty) ProtoMessage() {}
+func (*Empty) Descriptor() ([]byte, []int) {
+ return fileDescriptor_900544acb223d5b8, []int{0}
}
-func init() { file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() }
-func file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() {
- if File_github_com_golang_protobuf_ptypes_empty_empty_proto != nil {
- return
- }
- type x struct{}
- out := protoimpl.TypeBuilder{
- File: protoimpl.DescBuilder{
- GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc,
- NumEnums: 0,
- NumMessages: 0,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes,
- DependencyIndexes: file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs,
- }.Build()
- File_github_com_golang_protobuf_ptypes_empty_empty_proto = out.File
- file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = nil
- file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = nil
- file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = nil
+func (*Empty) XXX_WellKnownType() string { return "Empty" }
+
+func (m *Empty) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Empty.Unmarshal(m, b)
+}
+func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
+}
+func (m *Empty) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Empty.Merge(m, src)
+}
+func (m *Empty) XXX_Size() int {
+ return xxx_messageInfo_Empty.Size(m)
+}
+func (m *Empty) XXX_DiscardUnknown() {
+ xxx_messageInfo_Empty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Empty proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
+}
+
+func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) }
+
+var fileDescriptor_900544acb223d5b8 = []byte{
+ // 148 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
+ 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
+ 0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
+ 0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
+ 0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
+ 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
+ 0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
+ 0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
+ 0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
+ 0xb7, 0x00, 0x00, 0x00,
}
diff --git a/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto b/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
new file mode 100644
index 0000000..03cacd2
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
@@ -0,0 +1,52 @@
+// 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.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/empty";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "EmptyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// 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);
+// }
+//
+// The JSON representation for `Empty` is empty JSON object `{}`.
+message Empty {}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp.go b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
index 026d0d4..8da0df0 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
@@ -1,18 +1,46 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors. All rights reserved.
+// https://github.com/golang/protobuf
+//
+// 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.
package ptypes
+// This file implements operations on google.protobuf.Timestamp.
+
import (
"errors"
"fmt"
"time"
- timestamppb "github.com/golang/protobuf/ptypes/timestamp"
+ tspb "github.com/golang/protobuf/ptypes/timestamp"
)
-// Range of google.protobuf.Duration as specified in timestamp.proto.
const (
// Seconds field of the earliest valid Timestamp.
// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
@@ -22,71 +50,17 @@
maxValidSeconds = 253402300800
)
-// Timestamp converts a timestamppb.Timestamp to a time.Time.
-// It returns an error if the argument is invalid.
-//
-// Unlike most Go functions, if Timestamp returns an error, the first return
-// value is not the zero time.Time. Instead, it is the value obtained from the
-// time.Unix function when passed the contents of the Timestamp, in the UTC
-// locale. This may or may not be a meaningful time; many invalid Timestamps
-// do map to valid time.Times.
-//
-// A nil Timestamp returns an error. The first return value in that case is
-// undefined.
-func Timestamp(ts *timestamppb.Timestamp) (time.Time, error) {
- // Don't return the zero value on error, because corresponds to a valid
- // timestamp. Instead return whatever time.Unix gives us.
- var t time.Time
- if ts == nil {
- t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
- } else {
- t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
- }
- return t, validateTimestamp(ts)
-}
-
-// TimestampNow returns a google.protobuf.Timestamp for the current time.
-func TimestampNow() *timestamppb.Timestamp {
- ts, err := TimestampProto(time.Now())
- if err != nil {
- panic("ptypes: time.Now() out of Timestamp range")
- }
- return ts
-}
-
-// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
-// It returns an error if the resulting Timestamp is invalid.
-func TimestampProto(t time.Time) (*timestamppb.Timestamp, error) {
- ts := ×tamppb.Timestamp{
- Seconds: t.Unix(),
- Nanos: int32(t.Nanosecond()),
- }
- if err := validateTimestamp(ts); err != nil {
- return nil, err
- }
- return ts, nil
-}
-
-// TimestampString returns the RFC 3339 string for valid Timestamps.
-// For invalid Timestamps, it returns an error message in parentheses.
-func TimestampString(ts *timestamppb.Timestamp) string {
- t, err := Timestamp(ts)
- if err != nil {
- return fmt.Sprintf("(%v)", err)
- }
- return t.Format(time.RFC3339Nano)
-}
-
// validateTimestamp determines whether a Timestamp is valid.
-// A valid timestamp represents a time in the range [0001-01-01, 10000-01-01)
-// and has a Nanos field in the range [0, 1e9).
+// A valid timestamp represents a time in the range
+// [0001-01-01, 10000-01-01) and has a Nanos field
+// in the range [0, 1e9).
//
// If the Timestamp is valid, validateTimestamp returns nil.
-// Otherwise, it returns an error that describes the problem.
+// Otherwise, it returns an error that describes
+// the problem.
//
-// Every valid Timestamp can be represented by a time.Time,
-// but the converse is not true.
-func validateTimestamp(ts *timestamppb.Timestamp) error {
+// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
+func validateTimestamp(ts *tspb.Timestamp) error {
if ts == nil {
return errors.New("timestamp: nil Timestamp")
}
@@ -101,3 +75,58 @@
}
return nil
}
+
+// Timestamp converts a google.protobuf.Timestamp proto to a time.Time.
+// It returns an error if the argument is invalid.
+//
+// Unlike most Go functions, if Timestamp returns an error, the first return value
+// is not the zero time.Time. Instead, it is the value obtained from the
+// time.Unix function when passed the contents of the Timestamp, in the UTC
+// locale. This may or may not be a meaningful time; many invalid Timestamps
+// do map to valid time.Times.
+//
+// A nil Timestamp returns an error. The first return value in that case is
+// undefined.
+func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
+ // Don't return the zero value on error, because corresponds to a valid
+ // timestamp. Instead return whatever time.Unix gives us.
+ var t time.Time
+ if ts == nil {
+ t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
+ } else {
+ t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
+ }
+ return t, validateTimestamp(ts)
+}
+
+// TimestampNow returns a google.protobuf.Timestamp for the current time.
+func TimestampNow() *tspb.Timestamp {
+ ts, err := TimestampProto(time.Now())
+ if err != nil {
+ panic("ptypes: time.Now() out of Timestamp range")
+ }
+ return ts
+}
+
+// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
+// It returns an error if the resulting Timestamp is invalid.
+func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
+ ts := &tspb.Timestamp{
+ Seconds: t.Unix(),
+ Nanos: int32(t.Nanosecond()),
+ }
+ if err := validateTimestamp(ts); err != nil {
+ return nil, err
+ }
+ return ts, nil
+}
+
+// TimestampString returns the RFC 3339 string for valid Timestamps. For invalid
+// Timestamps, it returns an error message in parentheses.
+func TimestampString(ts *tspb.Timestamp) string {
+ t, err := Timestamp(ts)
+ if err != nil {
+ return fmt.Sprintf("(%v)", err)
+ }
+ return t.Format(time.RFC3339Nano)
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
index a76f807..31cd846 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@@ -1,64 +1,179 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+// source: google/protobuf/timestamp.proto
package timestamp
import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- timestamppb "google.golang.org/protobuf/types/known/timestamppb"
- reflect "reflect"
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
)
-// Symbols defined in public import of google/protobuf/timestamp.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
-type Timestamp = timestamppb.Timestamp
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-var File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{
- 0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
- 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
- 0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69,
- 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 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, 0x42, 0x37,
- 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
- 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
- 0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69,
- 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x33,
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. 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 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// # 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 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://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
+// ) to obtain a formatter capable of generating timestamps in this format.
+//
+//
+type Timestamp struct {
+ // 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"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_timestamp_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 (m *Timestamp) Reset() { *m = Timestamp{} }
+func (m *Timestamp) String() string { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage() {}
+func (*Timestamp) Descriptor() ([]byte, []int) {
+ return fileDescriptor_292007bbfe81227e, []int{0}
}
-func init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() }
-func file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() {
- if File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil {
- return
+func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" }
+
+func (m *Timestamp) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Timestamp.Unmarshal(m, b)
+}
+func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
+}
+func (m *Timestamp) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Timestamp.Merge(m, src)
+}
+func (m *Timestamp) XXX_Size() int {
+ return xxx_messageInfo_Timestamp.Size(m)
+}
+func (m *Timestamp) XXX_DiscardUnknown() {
+ xxx_messageInfo_Timestamp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Timestamp proto.InternalMessageInfo
+
+func (m *Timestamp) GetSeconds() int64 {
+ if m != nil {
+ return m.Seconds
}
- type x struct{}
- out := protoimpl.TypeBuilder{
- File: protoimpl.DescBuilder{
- GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
- RawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc,
- NumEnums: 0,
- NumMessages: 0,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,
- DependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,
- }.Build()
- File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File
- file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil
- file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil
- file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil
+ return 0
+}
+
+func (m *Timestamp) GetNanos() int32 {
+ if m != nil {
+ return m.Nanos
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
+}
+
+func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_292007bbfe81227e) }
+
+var fileDescriptor_292007bbfe81227e = []byte{
+ // 191 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
+ 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
+ 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
+ 0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
+ 0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
+ 0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
+ 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
+ 0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
+ 0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
+ 0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
+ 0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
+ 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
new file mode 100644
index 0000000..eafb3fa
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
@@ -0,0 +1,135 @@
+// 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.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/timestamp";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. 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 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// # 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 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://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
+// ) to obtain a formatter capable of generating timestamps in this format.
+//
+//
+message Timestamp {
+
+ // 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.
+ int64 seconds = 1;
+
+ // 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.
+ int32 nanos = 2;
+}
diff --git a/vendor/google.golang.org/protobuf/AUTHORS b/vendor/google.golang.org/protobuf/AUTHORS
deleted file mode 100644
index 2b00ddb..0000000
--- a/vendor/google.golang.org/protobuf/AUTHORS
+++ /dev/null
@@ -1,3 +0,0 @@
-# This source code refers to The Go Authors for copyright purposes.
-# The master list of authors is in the main Go distribution,
-# visible at https://tip.golang.org/AUTHORS.
diff --git a/vendor/google.golang.org/protobuf/CONTRIBUTORS b/vendor/google.golang.org/protobuf/CONTRIBUTORS
deleted file mode 100644
index 1fbd3e9..0000000
--- a/vendor/google.golang.org/protobuf/CONTRIBUTORS
+++ /dev/null
@@ -1,3 +0,0 @@
-# This source code was written by the Go contributors.
-# The master list of contributors is in the main Go distribution,
-# visible at https://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/google.golang.org/protobuf/LICENSE b/vendor/google.golang.org/protobuf/LICENSE
deleted file mode 100644
index 49ea0f9..0000000
--- a/vendor/google.golang.org/protobuf/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2018 The Go Authors. All rights reserved.
-
-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.
diff --git a/vendor/google.golang.org/protobuf/PATENTS b/vendor/google.golang.org/protobuf/PATENTS
deleted file mode 100644
index 7330990..0000000
--- a/vendor/google.golang.org/protobuf/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go. This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation. If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/decode.go b/vendor/google.golang.org/protobuf/encoding/prototext/decode.go
deleted file mode 100644
index 77dbe1b..0000000
--- a/vendor/google.golang.org/protobuf/encoding/prototext/decode.go
+++ /dev/null
@@ -1,789 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package prototext
-
-import (
- "fmt"
- "strings"
- "unicode/utf8"
-
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/encoding/text"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/fieldnum"
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/internal/set"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Unmarshal reads the given []byte into the given proto.Message.
-func Unmarshal(b []byte, m proto.Message) error {
- return UnmarshalOptions{}.Unmarshal(b, m)
-}
-
-// UnmarshalOptions is a configurable textproto format unmarshaler.
-type UnmarshalOptions struct {
- pragma.NoUnkeyedLiterals
-
- // AllowPartial accepts input for messages that will result in missing
- // required fields. If AllowPartial is false (the default), Unmarshal will
- // return error if there are any missing required fields.
- AllowPartial bool
-
- // DiscardUnknown specifies whether to ignore unknown fields when parsing.
- // An unknown field is any field whose field name or field number does not
- // resolve to any known or extension field in the message.
- // By default, unmarshal rejects unknown fields as an error.
- DiscardUnknown bool
-
- // Resolver is used for looking up types when unmarshaling
- // google.protobuf.Any messages or extension fields.
- // If nil, this defaults to using protoregistry.GlobalTypes.
- Resolver interface {
- protoregistry.MessageTypeResolver
- protoregistry.ExtensionTypeResolver
- }
-}
-
-// Unmarshal reads the given []byte and populates the given proto.Message using options in
-// UnmarshalOptions object.
-func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
- proto.Reset(m)
-
- if o.Resolver == nil {
- o.Resolver = protoregistry.GlobalTypes
- }
-
- dec := decoder{text.NewDecoder(b), o}
- if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
- return err
- }
- if o.AllowPartial {
- return nil
- }
- return proto.CheckInitialized(m)
-}
-
-type decoder struct {
- *text.Decoder
- opts UnmarshalOptions
-}
-
-// newError returns an error object with position info.
-func (d decoder) newError(pos int, f string, x ...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 text.Token) error {
- return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())
-}
-
-// syntaxError returns a syntax error for given position.
-func (d decoder) syntaxError(pos int, f string, x ...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 into the given protoreflect.Message.
-func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
- messageDesc := m.Descriptor()
- if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
- return errors.New("no support for proto1 MessageSets")
- }
-
- if messageDesc.FullName() == "google.protobuf.Any" {
- return d.unmarshalAny(m, checkDelims)
- }
-
- if checkDelims {
- tok, err := d.Read()
- if err != nil {
- return err
- }
-
- if tok.Kind() != text.MessageOpen {
- return d.unexpectedTokenError(tok)
- }
- }
-
- var seenNums set.Ints
- var seenOneofs set.Ints
- fieldDescs := messageDesc.Fields()
-
- for {
- // Read field name.
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch typ := tok.Kind(); typ {
- case text.Name:
- // Continue below.
- case text.EOF:
- if checkDelims {
- return text.ErrUnexpectedEOF
- }
- return nil
- default:
- if checkDelims && typ == text.MessageClose {
- return nil
- }
- return d.unexpectedTokenError(tok)
- }
-
- // Resolve the field descriptor.
- var name pref.Name
- var fd pref.FieldDescriptor
- var xt pref.ExtensionType
- var xtErr error
- var isFieldNumberName bool
-
- switch tok.NameKind() {
- case text.IdentName:
- name = pref.Name(tok.IdentName())
- fd = fieldDescs.ByName(name)
- if fd == nil {
- // The proto name of a group field is in all lowercase,
- // while the textproto field name is the group message name.
- gd := fieldDescs.ByName(pref.Name(strings.ToLower(string(name))))
- if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == name {
- fd = gd
- }
- } else if fd.Kind() == pref.GroupKind && fd.Message().Name() != name {
- fd = nil // reset since field name is actually the message name
- }
-
- case text.TypeName:
- // Handle extensions only. This code path is not for Any.
- xt, xtErr = d.findExtension(pref.FullName(tok.TypeName()))
-
- case text.FieldNumber:
- isFieldNumberName = true
- num := pref.FieldNumber(tok.FieldNumber())
- if !num.IsValid() {
- return d.newError(tok.Pos(), "invalid field number: %d", num)
- }
- fd = fieldDescs.ByNumber(num)
- if fd == nil {
- xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)
- }
- }
-
- if xt != nil {
- fd = xt.TypeDescriptor()
- if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
- return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
- }
- } else if xtErr != nil && xtErr != protoregistry.NotFound {
- return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)
- }
- if flags.ProtoLegacy {
- if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
- fd = nil // reset since the weak reference is not linked in
- }
- }
-
- // Handle unknown fields.
- if fd == nil {
- if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {
- d.skipValue()
- continue
- }
- return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())
- }
-
- // Handle fields identified by field number.
- if isFieldNumberName {
- // TODO: Add an option to permit parsing field numbers.
- //
- // This requires careful thought as the MarshalOptions.EmitUnknown
- // option allows formatting unknown fields as the field number and the
- // best-effort textual representation of the field value. In that case,
- // it may not be possible to unmarshal the value from a parser that does
- // have information about the unknown field.
- return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())
- }
-
- switch {
- case fd.IsList():
- kind := fd.Kind()
- if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
- return d.syntaxError(tok.Pos(), "missing field separator :")
- }
-
- list := m.Mutable(fd).List()
- if err := d.unmarshalList(fd, list); err != nil {
- return err
- }
-
- case fd.IsMap():
- mmap := m.Mutable(fd).Map()
- if err := d.unmarshalMap(fd, mmap); err != nil {
- return err
- }
-
- default:
- kind := fd.Kind()
- if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
- return d.syntaxError(tok.Pos(), "missing field separator :")
- }
-
- // If field is a oneof, check if it has already been set.
- if od := fd.ContainingOneof(); od != nil {
- idx := uint64(od.Index())
- if seenOneofs.Has(idx) {
- return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())
- }
- seenOneofs.Set(idx)
- }
-
- num := uint64(fd.Number())
- if seenNums.Has(num) {
- return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())
- }
-
- if err := d.unmarshalSingular(fd, m); err != nil {
- return err
- }
- seenNums.Set(num)
- }
- }
-
- return nil
-}
-
-// findExtension returns protoreflect.ExtensionType from the Resolver if found.
-func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
- xt, err := d.opts.Resolver.FindExtensionByName(xtName)
- if err == nil {
- return xt, nil
- }
- return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
-}
-
-// unmarshalSingular unmarshals a non-repeated field value specified by the
-// given FieldDescriptor.
-func (d decoder) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) error {
- var val pref.Value
- var err error
- switch fd.Kind() {
- case pref.MessageKind, pref.GroupKind:
- val = m.NewField(fd)
- err = d.unmarshalMessage(val.Message(), true)
- default:
- val, err = d.unmarshalScalar(fd)
- }
- if err == nil {
- m.Set(fd, val)
- }
- return err
-}
-
-// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
-// given FieldDescriptor.
-func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
- tok, err := d.Read()
- if err != nil {
- return pref.Value{}, err
- }
-
- if tok.Kind() != text.Scalar {
- return pref.Value{}, d.unexpectedTokenError(tok)
- }
-
- kind := fd.Kind()
- switch kind {
- case pref.BoolKind:
- if b, ok := tok.Bool(); ok {
- return pref.ValueOfBool(b), nil
- }
-
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
- if n, ok := tok.Int32(); ok {
- return pref.ValueOfInt32(n), nil
- }
-
- case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- if n, ok := tok.Int64(); ok {
- return pref.ValueOfInt64(n), nil
- }
-
- case pref.Uint32Kind, pref.Fixed32Kind:
- if n, ok := tok.Uint32(); ok {
- return pref.ValueOfUint32(n), nil
- }
-
- case pref.Uint64Kind, pref.Fixed64Kind:
- if n, ok := tok.Uint64(); ok {
- return pref.ValueOfUint64(n), nil
- }
-
- case pref.FloatKind:
- if n, ok := tok.Float32(); ok {
- return pref.ValueOfFloat32(n), nil
- }
-
- case pref.DoubleKind:
- if n, ok := tok.Float64(); ok {
- return pref.ValueOfFloat64(n), nil
- }
-
- case pref.StringKind:
- if s, ok := tok.String(); ok {
- if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
- return pref.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
- }
- return pref.ValueOfString(s), nil
- }
-
- case pref.BytesKind:
- if b, ok := tok.String(); ok {
- return pref.ValueOfBytes([]byte(b)), nil
- }
-
- case pref.EnumKind:
- if lit, ok := tok.Enum(); ok {
- // Lookup EnumNumber based on name.
- if enumVal := fd.Enum().Values().ByName(pref.Name(lit)); enumVal != nil {
- return pref.ValueOfEnum(enumVal.Number()), nil
- }
- }
- if num, ok := tok.Int32(); ok {
- return pref.ValueOfEnum(pref.EnumNumber(num)), nil
- }
-
- default:
- panic(fmt.Sprintf("invalid scalar kind %v", kind))
- }
-
- return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
-}
-
-// unmarshalList unmarshals into given protoreflect.List. A list value can
-// either be in [] syntax or simply just a single scalar/message value.
-func (d decoder) unmarshalList(fd pref.FieldDescriptor, list pref.List) error {
- tok, err := d.Peek()
- if err != nil {
- return err
- }
-
- switch fd.Kind() {
- case pref.MessageKind, pref.GroupKind:
- switch tok.Kind() {
- case text.ListOpen:
- d.Read()
- for {
- tok, err := d.Peek()
- if err != nil {
- return err
- }
-
- switch tok.Kind() {
- case text.ListClose:
- d.Read()
- return nil
- case text.MessageOpen:
- pval := list.NewElement()
- if err := d.unmarshalMessage(pval.Message(), true); err != nil {
- return err
- }
- list.Append(pval)
- default:
- return d.unexpectedTokenError(tok)
- }
- }
-
- case text.MessageOpen:
- pval := list.NewElement()
- if err := d.unmarshalMessage(pval.Message(), true); err != nil {
- return err
- }
- list.Append(pval)
- return nil
- }
-
- default:
- switch tok.Kind() {
- case text.ListOpen:
- d.Read()
- for {
- tok, err := d.Peek()
- if err != nil {
- return err
- }
-
- switch tok.Kind() {
- case text.ListClose:
- d.Read()
- return nil
- case text.Scalar:
- pval, err := d.unmarshalScalar(fd)
- if err != nil {
- return err
- }
- list.Append(pval)
- default:
- return d.unexpectedTokenError(tok)
- }
- }
-
- case text.Scalar:
- pval, err := d.unmarshalScalar(fd)
- if err != nil {
- return err
- }
- list.Append(pval)
- return nil
- }
- }
-
- return d.unexpectedTokenError(tok)
-}
-
-// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
-// textproto message containing {key: <kvalue>, value: <mvalue>}.
-func (d decoder) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error {
- // Determine ahead whether map entry is a scalar type or a message type in
- // order to call the appropriate unmarshalMapValue func inside
- // unmarshalMapEntry.
- var unmarshalMapValue func() (pref.Value, error)
- switch fd.MapValue().Kind() {
- case pref.MessageKind, pref.GroupKind:
- unmarshalMapValue = func() (pref.Value, error) {
- pval := mmap.NewValue()
- if err := d.unmarshalMessage(pval.Message(), true); err != nil {
- return pref.Value{}, err
- }
- return pval, nil
- }
- default:
- unmarshalMapValue = func() (pref.Value, error) {
- return d.unmarshalScalar(fd.MapValue())
- }
- }
-
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch tok.Kind() {
- case text.MessageOpen:
- return d.unmarshalMapEntry(fd, mmap, unmarshalMapValue)
-
- case text.ListOpen:
- for {
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch tok.Kind() {
- case text.ListClose:
- return nil
- case text.MessageOpen:
- if err := d.unmarshalMapEntry(fd, mmap, unmarshalMapValue); err != nil {
- return err
- }
- default:
- return d.unexpectedTokenError(tok)
- }
- }
-
- default:
- return d.unexpectedTokenError(tok)
- }
-}
-
-// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
-// textproto message containing {key: <kvalue>, value: <mvalue>}.
-func (d decoder) unmarshalMapEntry(fd pref.FieldDescriptor, mmap pref.Map, unmarshalMapValue func() (pref.Value, error)) error {
- var key pref.MapKey
- var pval pref.Value
-Loop:
- for {
- // Read field name.
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch tok.Kind() {
- case text.Name:
- if tok.NameKind() != text.IdentName {
- if !d.opts.DiscardUnknown {
- return d.newError(tok.Pos(), "unknown map entry field %q", tok.RawString())
- }
- d.skipValue()
- continue Loop
- }
- // Continue below.
- case text.MessageClose:
- break Loop
- default:
- return d.unexpectedTokenError(tok)
- }
-
- name := tok.IdentName()
- switch name {
- case "key":
- if !tok.HasSeparator() {
- return d.syntaxError(tok.Pos(), "missing field separator :")
- }
- if key.IsValid() {
- return d.newError(tok.Pos(), `map entry "key" cannot be repeated`)
- }
- val, err := d.unmarshalScalar(fd.MapKey())
- if err != nil {
- return err
- }
- key = val.MapKey()
-
- case "value":
- if kind := fd.MapValue().Kind(); (kind != pref.MessageKind) && (kind != pref.GroupKind) {
- if !tok.HasSeparator() {
- return d.syntaxError(tok.Pos(), "missing field separator :")
- }
- }
- if pval.IsValid() {
- return d.newError(tok.Pos(), `map entry "value" cannot be repeated`)
- }
- pval, err = unmarshalMapValue()
- if err != nil {
- return err
- }
-
- default:
- if !d.opts.DiscardUnknown {
- return d.newError(tok.Pos(), "unknown map entry field %q", name)
- }
- d.skipValue()
- }
- }
-
- if !key.IsValid() {
- key = fd.MapKey().Default().MapKey()
- }
- if !pval.IsValid() {
- switch fd.MapValue().Kind() {
- case pref.MessageKind, pref.GroupKind:
- // If value field is not set for message/group types, construct an
- // empty one as default.
- pval = mmap.NewValue()
- default:
- pval = fd.MapValue().Default()
- }
- }
- mmap.Set(key, pval)
- return nil
-}
-
-// unmarshalAny unmarshals an Any textproto. It can either be in expanded form
-// or non-expanded form.
-func (d decoder) unmarshalAny(m pref.Message, checkDelims bool) error {
- var typeURL string
- var bValue []byte
-
- // hasFields tracks which valid fields have been seen in the loop below in
- // order to flag an error if there are duplicates or conflicts. It may
- // contain the strings "type_url", "value" and "expanded". The literal
- // "expanded" is used to indicate that the expanded form has been
- // encountered already.
- hasFields := map[string]bool{}
-
- if checkDelims {
- tok, err := d.Read()
- if err != nil {
- return err
- }
-
- if tok.Kind() != text.MessageOpen {
- return d.unexpectedTokenError(tok)
- }
- }
-
-Loop:
- for {
- // Read field name. Can only have 3 possible field names, i.e. type_url,
- // value and type URL name inside [].
- tok, err := d.Read()
- if err != nil {
- return err
- }
- if typ := tok.Kind(); typ != text.Name {
- if checkDelims {
- if typ == text.MessageClose {
- break Loop
- }
- } else if typ == text.EOF {
- break Loop
- }
- return d.unexpectedTokenError(tok)
- }
-
- switch tok.NameKind() {
- case text.IdentName:
- // Both type_url and value fields require field separator :.
- if !tok.HasSeparator() {
- return d.syntaxError(tok.Pos(), "missing field separator :")
- }
-
- switch tok.IdentName() {
- case "type_url":
- if hasFields["type_url"] {
- return d.newError(tok.Pos(), "duplicate Any type_url field")
- }
- if hasFields["expanded"] {
- return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
- }
- tok, err := d.Read()
- if err != nil {
- return err
- }
- var ok bool
- typeURL, ok = tok.String()
- if !ok {
- return d.newError(tok.Pos(), "invalid Any type_url: %v", tok.RawString())
- }
- hasFields["type_url"] = true
-
- case "value":
- if hasFields["value"] {
- return d.newError(tok.Pos(), "duplicate Any value field")
- }
- if hasFields["expanded"] {
- return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
- }
- tok, err := d.Read()
- if err != nil {
- return err
- }
- s, ok := tok.String()
- if !ok {
- return d.newError(tok.Pos(), "invalid Any value: %v", tok.RawString())
- }
- bValue = []byte(s)
- hasFields["value"] = true
-
- default:
- if !d.opts.DiscardUnknown {
- return d.newError(tok.Pos(), "invalid field name %q in google.protobuf.Any message", tok.RawString())
- }
- }
-
- case text.TypeName:
- if hasFields["expanded"] {
- return d.newError(tok.Pos(), "cannot have more than one type")
- }
- if hasFields["type_url"] {
- return d.newError(tok.Pos(), "conflict with type_url field")
- }
- typeURL = tok.TypeName()
- var err error
- bValue, err = d.unmarshalExpandedAny(typeURL, tok.Pos())
- if err != nil {
- return err
- }
- hasFields["expanded"] = true
-
- default:
- if !d.opts.DiscardUnknown {
- return d.newError(tok.Pos(), "invalid field name %q in google.protobuf.Any message", tok.RawString())
- }
- }
- }
-
- fds := m.Descriptor().Fields()
- if len(typeURL) > 0 {
- m.Set(fds.ByNumber(fieldnum.Any_TypeUrl), pref.ValueOfString(typeURL))
- }
- if len(bValue) > 0 {
- m.Set(fds.ByNumber(fieldnum.Any_Value), pref.ValueOfBytes(bValue))
- }
- return nil
-}
-
-func (d decoder) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error) {
- mt, err := d.opts.Resolver.FindMessageByURL(typeURL)
- if err != nil {
- return nil, d.newError(pos, "unable to resolve message [%v]: %v", typeURL, err)
- }
- // Create new message for the embedded message type and unmarshal the value
- // field into it.
- m := mt.New()
- if err := d.unmarshalMessage(m, true); err != nil {
- return nil, err
- }
- // Serialize the embedded message and return the resulting bytes.
- b, err := proto.MarshalOptions{
- AllowPartial: true, // Never check required fields inside an Any.
- Deterministic: true,
- }.Marshal(m.Interface())
- if err != nil {
- return nil, d.newError(pos, "error in marshaling message into Any.value: %v", err)
- }
- return b, nil
-}
-
-// skipValue makes the decoder parse a field value in order to advance the read
-// to the next field. It relies on Read returning an error if the types are not
-// in valid sequence.
-func (d decoder) skipValue() error {
- tok, err := d.Read()
- if err != nil {
- return err
- }
- // Only need to continue reading for messages and lists.
- switch tok.Kind() {
- case text.MessageOpen:
- return d.skipMessageValue()
-
- case text.ListOpen:
- for {
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch tok.Kind() {
- case text.ListClose:
- return nil
- case text.MessageOpen:
- return d.skipMessageValue()
- default:
- // Skip items. This will not validate whether skipped values are
- // of the same type or not, same behavior as C++
- // TextFormat::Parser::AllowUnknownField(true) version 3.8.0.
- if err := d.skipValue(); err != nil {
- return err
- }
- }
- }
- }
- return nil
-}
-
-// skipMessageValue makes the decoder parse and skip over all fields in a
-// message. It assumes that the previous read type is MessageOpen.
-func (d decoder) skipMessageValue() error {
- for {
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch tok.Kind() {
- case text.MessageClose:
- return nil
- case text.Name:
- if err := d.skipValue(); err != nil {
- return err
- }
- }
- }
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/doc.go b/vendor/google.golang.org/protobuf/encoding/prototext/doc.go
deleted file mode 100644
index 162b4f9..0000000
--- a/vendor/google.golang.org/protobuf/encoding/prototext/doc.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package prototext marshals and unmarshals protocol buffer messages as the
-// textproto format.
-package prototext
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/encode.go b/vendor/google.golang.org/protobuf/encoding/prototext/encode.go
deleted file mode 100644
index dece229..0000000
--- a/vendor/google.golang.org/protobuf/encoding/prototext/encode.go
+++ /dev/null
@@ -1,426 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package prototext
-
-import (
- "fmt"
- "sort"
- "strconv"
- "unicode/utf8"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/encoding/text"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/fieldnum"
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/internal/mapsort"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/proto"
- pref "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 textproto 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 text format marshaler.
-type MarshalOptions struct {
- pragma.NoUnkeyedLiterals
-
- // Multiline specifies whether the marshaler should format the output in
- // indented-form with every textual element on a new line.
- // If Indent is an empty string, then an arbitrary indent is chosen.
- Multiline bool
-
- // Indent specifies the set of indentation characters to use in a multiline
- // formatted output such that every entry is preceded by Indent and
- // terminated by a newline. If non-empty, then Multiline is treated as true.
- // Indent can only be composed of space or tab characters.
- Indent string
-
- // EmitASCII specifies whether to format strings and bytes as ASCII only
- // as opposed to using UTF-8 encoding when possible.
- EmitASCII bool
-
- // allowInvalidUTF8 specifies whether to permit the encoding of strings
- // with invalid UTF-8. This is unexported as it is intended to only
- // be specified by the Format method.
- allowInvalidUTF8 bool
-
- // AllowPartial allows messages that have missing required fields to marshal
- // without returning an error. If AllowPartial is false (the default),
- // Marshal will return error if there are any missing required fields.
- AllowPartial bool
-
- // EmitUnknown specifies whether to emit unknown fields in the output.
- // If specified, the unmarshaler may be unable to parse the output.
- // The default is to exclude unknown fields.
- EmitUnknown bool
-
- // Resolver is used for looking up types when expanding google.protobuf.Any
- // messages. If nil, this defaults to using protoregistry.GlobalTypes.
- Resolver interface {
- protoregistry.ExtensionTypeResolver
- protoregistry.MessageTypeResolver
- }
-}
-
-// Format formats the message as a string.
-// This method is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. 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.allowInvalidUTF8 = true
- o.AllowPartial = true
- o.EmitUnknown = true
- b, _ := o.Marshal(m)
- return string(b)
-}
-
-// Marshal writes the given proto.Message in textproto format using options in
-// MarshalOptions object. Do not depend on the output being stable. It may
-// change over time across different versions of the program.
-func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
- var delims = [2]byte{'{', '}'}
-
- if o.Multiline && o.Indent == "" {
- o.Indent = defaultIndent
- }
- if o.Resolver == nil {
- o.Resolver = protoregistry.GlobalTypes
- }
-
- internalEnc, err := text.NewEncoder(o.Indent, delims, o.EmitASCII)
- if err != nil {
- return nil, err
- }
-
- // Treat nil message interface as an empty message,
- // in which case there is nothing to output.
- if m == nil {
- return []byte{}, nil
- }
-
- enc := encoder{internalEnc, o}
- err = enc.marshalMessage(m.ProtoReflect(), false)
- if err != nil {
- return nil, err
- }
- out := enc.Bytes()
- if len(o.Indent) > 0 && len(out) > 0 {
- out = append(out, '\n')
- }
- if o.AllowPartial {
- return out, nil
- }
- return out, proto.CheckInitialized(m)
-}
-
-type encoder struct {
- *text.Encoder
- opts MarshalOptions
-}
-
-// marshalMessage marshals the given protoreflect.Message.
-func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error {
- messageDesc := m.Descriptor()
- if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
- return errors.New("no support for proto1 MessageSets")
- }
-
- if inclDelims {
- e.StartMessage()
- defer e.EndMessage()
- }
-
- // Handle Any expansion.
- if messageDesc.FullName() == "google.protobuf.Any" {
- if e.marshalAny(m) {
- return nil
- }
- // If unable to expand, continue on to marshal Any as a regular message.
- }
-
- // Marshal known fields.
- fieldDescs := messageDesc.Fields()
- size := fieldDescs.Len()
- for i := 0; i < size; {
- fd := fieldDescs.Get(i)
- if od := fd.ContainingOneof(); od != nil {
- fd = m.WhichOneof(od)
- i += od.Fields().Len()
- } else {
- i++
- }
-
- if fd == nil || !m.Has(fd) {
- continue
- }
-
- name := fd.Name()
- // Use type name for group field name.
- if fd.Kind() == pref.GroupKind {
- name = fd.Message().Name()
- }
- val := m.Get(fd)
- if err := e.marshalField(string(name), val, fd); err != nil {
- return err
- }
- }
-
- // Marshal extensions.
- if err := e.marshalExtensions(m); err != nil {
- return err
- }
-
- // Marshal unknown fields.
- if e.opts.EmitUnknown {
- e.marshalUnknown(m.GetUnknown())
- }
-
- return nil
-}
-
-// marshalField marshals the given field with protoreflect.Value.
-func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescriptor) error {
- switch {
- case fd.IsList():
- return e.marshalList(name, val.List(), fd)
- case fd.IsMap():
- return e.marshalMap(name, val.Map(), fd)
- default:
- e.WriteName(name)
- return e.marshalSingular(val, fd)
- }
-}
-
-// marshalSingular marshals the given non-repeated field value. This includes
-// all scalar types, enums, messages, and groups.
-func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
- kind := fd.Kind()
- switch kind {
- case pref.BoolKind:
- e.WriteBool(val.Bool())
-
- case pref.StringKind:
- s := val.String()
- if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
- return errors.InvalidUTF8(string(fd.FullName()))
- }
- e.WriteString(s)
-
- case pref.Int32Kind, pref.Int64Kind,
- pref.Sint32Kind, pref.Sint64Kind,
- pref.Sfixed32Kind, pref.Sfixed64Kind:
- e.WriteInt(val.Int())
-
- case pref.Uint32Kind, pref.Uint64Kind,
- pref.Fixed32Kind, pref.Fixed64Kind:
- e.WriteUint(val.Uint())
-
- case pref.FloatKind:
- // Encoder.WriteFloat handles the special numbers NaN and infinites.
- e.WriteFloat(val.Float(), 32)
-
- case pref.DoubleKind:
- // Encoder.WriteFloat handles the special numbers NaN and infinites.
- e.WriteFloat(val.Float(), 64)
-
- case pref.BytesKind:
- e.WriteString(string(val.Bytes()))
-
- case pref.EnumKind:
- num := val.Enum()
- if desc := fd.Enum().Values().ByNumber(num); desc != nil {
- e.WriteLiteral(string(desc.Name()))
- } else {
- // Use numeric value if there is no enum description.
- e.WriteInt(int64(num))
- }
-
- case pref.MessageKind, pref.GroupKind:
- return e.marshalMessage(val.Message(), true)
-
- default:
- panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
- }
- return nil
-}
-
-// marshalList marshals the given protoreflect.List as multiple name-value fields.
-func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescriptor) error {
- size := list.Len()
- for i := 0; i < size; i++ {
- e.WriteName(name)
- if err := e.marshalSingular(list.Get(i), fd); err != nil {
- return err
- }
- }
- return nil
-}
-
-// marshalMap marshals the given protoreflect.Map as multiple name-value fields.
-func (e encoder) marshalMap(name string, mmap pref.Map, fd pref.FieldDescriptor) error {
- var err error
- mapsort.Range(mmap, fd.MapKey().Kind(), func(key pref.MapKey, val pref.Value) bool {
- e.WriteName(name)
- e.StartMessage()
- defer e.EndMessage()
-
- e.WriteName("key")
- err = e.marshalSingular(key.Value(), fd.MapKey())
- if err != nil {
- return false
- }
-
- e.WriteName("value")
- err = e.marshalSingular(val, fd.MapValue())
- if err != nil {
- return false
- }
- return true
- })
- return err
-}
-
-// marshalExtensions marshals extension fields.
-func (e encoder) marshalExtensions(m pref.Message) error {
- type entry struct {
- key string
- value pref.Value
- desc pref.FieldDescriptor
- }
-
- // Get a sorted list based on field key first.
- var entries []entry
- m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
- if !fd.IsExtension() {
- return true
- }
- // For MessageSet extensions, the name used is the parent message.
- name := fd.FullName()
- if messageset.IsMessageSetExtension(fd) {
- name = name.Parent()
- }
- entries = append(entries, entry{
- key: string(name),
- value: v,
- desc: fd,
- })
- return true
- })
- // Sort extensions lexicographically.
- sort.Slice(entries, func(i, j int) bool {
- return entries[i].key < entries[j].key
- })
-
- // Write out sorted list.
- for _, entry := range entries {
- // Extension field name is the proto field name enclosed in [].
- name := "[" + entry.key + "]"
- if err := e.marshalField(name, entry.value, entry.desc); err != nil {
- return err
- }
- }
- return nil
-}
-
-// marshalUnknown parses the given []byte and marshals fields out.
-// This function assumes proper encoding in the given []byte.
-func (e encoder) marshalUnknown(b []byte) {
- const dec = 10
- const hex = 16
- for len(b) > 0 {
- num, wtype, n := protowire.ConsumeTag(b)
- b = b[n:]
- e.WriteName(strconv.FormatInt(int64(num), dec))
-
- switch wtype {
- case protowire.VarintType:
- var v uint64
- v, n = protowire.ConsumeVarint(b)
- e.WriteUint(v)
- case protowire.Fixed32Type:
- var v uint32
- v, n = protowire.ConsumeFixed32(b)
- e.WriteLiteral("0x" + strconv.FormatUint(uint64(v), hex))
- case protowire.Fixed64Type:
- var v uint64
- v, n = protowire.ConsumeFixed64(b)
- e.WriteLiteral("0x" + strconv.FormatUint(v, hex))
- case protowire.BytesType:
- var v []byte
- v, n = protowire.ConsumeBytes(b)
- e.WriteString(string(v))
- case protowire.StartGroupType:
- e.StartMessage()
- var v []byte
- v, n = protowire.ConsumeGroup(num, b)
- e.marshalUnknown(v)
- e.EndMessage()
- default:
- panic(fmt.Sprintf("prototext: error parsing unknown field wire type: %v", wtype))
- }
-
- b = b[n:]
- }
-}
-
-// marshalAny marshals the given google.protobuf.Any message in expanded form.
-// It returns true if it was able to marshal, else false.
-func (e encoder) marshalAny(any pref.Message) bool {
- // Construct the embedded message.
- fds := any.Descriptor().Fields()
- fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
- typeURL := any.Get(fdType).String()
- mt, err := e.opts.Resolver.FindMessageByURL(typeURL)
- if err != nil {
- return false
- }
- m := mt.New().Interface()
-
- // Unmarshal bytes into embedded message.
- fdValue := fds.ByNumber(fieldnum.Any_Value)
- value := any.Get(fdValue)
- err = proto.UnmarshalOptions{
- AllowPartial: true,
- Resolver: e.opts.Resolver,
- }.Unmarshal(value.Bytes(), m)
- if err != nil {
- return false
- }
-
- // Get current encoder position. If marshaling fails, reset encoder output
- // back to this position.
- pos := e.Snapshot()
-
- // Field name is the proto field name enclosed in [].
- e.WriteName("[" + typeURL + "]")
- err = e.marshalMessage(m.ProtoReflect(), true)
- if err != nil {
- e.Reset(pos)
- return false
- }
- return true
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go b/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
deleted file mode 100644
index a427f8b..0000000
--- a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
+++ /dev/null
@@ -1,538 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protowire parses and formats the raw wire encoding.
-// See https://developers.google.com/protocol-buffers/docs/encoding.
-//
-// For marshaling and unmarshaling entire protobuf messages,
-// use the "google.golang.org/protobuf/proto" package instead.
-package protowire
-
-import (
- "io"
- "math"
- "math/bits"
-
- "google.golang.org/protobuf/internal/errors"
-)
-
-// Number represents the field number.
-type Number int32
-
-const (
- MinValidNumber Number = 1
- FirstReservedNumber Number = 19000
- LastReservedNumber Number = 19999
- MaxValidNumber Number = 1<<29 - 1
-)
-
-// IsValid reports whether the field number is semantically valid.
-//
-// Note that while numbers within the reserved range are semantically invalid,
-// they are syntactically valid in the wire format.
-// Implementations may treat records with reserved field numbers as unknown.
-func (n Number) IsValid() bool {
- return MinValidNumber <= n && n < FirstReservedNumber || LastReservedNumber < n && n <= MaxValidNumber
-}
-
-// Type represents the wire type.
-type Type int8
-
-const (
- VarintType Type = 0
- Fixed32Type Type = 5
- Fixed64Type Type = 1
- BytesType Type = 2
- StartGroupType Type = 3
- EndGroupType Type = 4
-)
-
-const (
- _ = -iota
- errCodeTruncated
- errCodeFieldNumber
- errCodeOverflow
- errCodeReserved
- errCodeEndGroup
-)
-
-var (
- errFieldNumber = errors.New("invalid field number")
- errOverflow = errors.New("variable length integer overflow")
- errReserved = errors.New("cannot parse reserved wire type")
- errEndGroup = errors.New("mismatching end group marker")
- errParse = errors.New("parse error")
-)
-
-// ParseError converts an error code into an error value.
-// This returns nil if n is a non-negative number.
-func ParseError(n int) error {
- if n >= 0 {
- return nil
- }
- switch n {
- case errCodeTruncated:
- return io.ErrUnexpectedEOF
- case errCodeFieldNumber:
- return errFieldNumber
- case errCodeOverflow:
- return errOverflow
- case errCodeReserved:
- return errReserved
- case errCodeEndGroup:
- return errEndGroup
- default:
- return errParse
- }
-}
-
-// ConsumeField parses an entire field record (both tag and value) and returns
-// the field number, the wire type, and the total length.
-// This returns a negative length upon an error (see ParseError).
-//
-// The total length includes the tag header and the end group marker (if the
-// field is a group).
-func ConsumeField(b []byte) (Number, Type, int) {
- num, typ, n := ConsumeTag(b)
- if n < 0 {
- return 0, 0, n // forward error code
- }
- m := ConsumeFieldValue(num, typ, b[n:])
- if m < 0 {
- return 0, 0, m // forward error code
- }
- return num, typ, n + m
-}
-
-// ConsumeFieldValue parses a field value and returns its length.
-// This assumes that the field Number and wire Type have already been parsed.
-// This returns a negative length upon an error (see ParseError).
-//
-// When parsing a group, the length includes the end group marker and
-// the end group is verified to match the starting field number.
-func ConsumeFieldValue(num Number, typ Type, b []byte) (n int) {
- switch typ {
- case VarintType:
- _, n = ConsumeVarint(b)
- return n
- case Fixed32Type:
- _, n = ConsumeFixed32(b)
- return n
- case Fixed64Type:
- _, n = ConsumeFixed64(b)
- return n
- case BytesType:
- _, n = ConsumeBytes(b)
- return n
- case StartGroupType:
- n0 := len(b)
- for {
- num2, typ2, n := ConsumeTag(b)
- if n < 0 {
- return n // forward error code
- }
- b = b[n:]
- if typ2 == EndGroupType {
- if num != num2 {
- return errCodeEndGroup
- }
- return n0 - len(b)
- }
-
- n = ConsumeFieldValue(num2, typ2, b)
- if n < 0 {
- return n // forward error code
- }
- b = b[n:]
- }
- case EndGroupType:
- return errCodeEndGroup
- default:
- return errCodeReserved
- }
-}
-
-// AppendTag encodes num and typ as a varint-encoded tag and appends it to b.
-func AppendTag(b []byte, num Number, typ Type) []byte {
- return AppendVarint(b, EncodeTag(num, typ))
-}
-
-// ConsumeTag parses b as a varint-encoded tag, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeTag(b []byte) (Number, Type, int) {
- v, n := ConsumeVarint(b)
- if n < 0 {
- return 0, 0, n // forward error code
- }
- num, typ := DecodeTag(v)
- if num < MinValidNumber {
- return 0, 0, errCodeFieldNumber
- }
- return num, typ, n
-}
-
-func SizeTag(num Number) int {
- return SizeVarint(EncodeTag(num, 0)) // wire type has no effect on size
-}
-
-// AppendVarint appends v to b as a varint-encoded uint64.
-func AppendVarint(b []byte, v uint64) []byte {
- switch {
- case v < 1<<7:
- b = append(b, byte(v))
- case v < 1<<14:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte(v>>7))
- case v < 1<<21:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte(v>>14))
- case v < 1<<28:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte(v>>21))
- case v < 1<<35:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte((v>>21)&0x7f|0x80),
- byte(v>>28))
- case v < 1<<42:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte((v>>21)&0x7f|0x80),
- byte((v>>28)&0x7f|0x80),
- byte(v>>35))
- case v < 1<<49:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte((v>>21)&0x7f|0x80),
- byte((v>>28)&0x7f|0x80),
- byte((v>>35)&0x7f|0x80),
- byte(v>>42))
- case v < 1<<56:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte((v>>21)&0x7f|0x80),
- byte((v>>28)&0x7f|0x80),
- byte((v>>35)&0x7f|0x80),
- byte((v>>42)&0x7f|0x80),
- byte(v>>49))
- case v < 1<<63:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte((v>>21)&0x7f|0x80),
- byte((v>>28)&0x7f|0x80),
- byte((v>>35)&0x7f|0x80),
- byte((v>>42)&0x7f|0x80),
- byte((v>>49)&0x7f|0x80),
- byte(v>>56))
- default:
- b = append(b,
- byte((v>>0)&0x7f|0x80),
- byte((v>>7)&0x7f|0x80),
- byte((v>>14)&0x7f|0x80),
- byte((v>>21)&0x7f|0x80),
- byte((v>>28)&0x7f|0x80),
- byte((v>>35)&0x7f|0x80),
- byte((v>>42)&0x7f|0x80),
- byte((v>>49)&0x7f|0x80),
- byte((v>>56)&0x7f|0x80),
- 1)
- }
- return b
-}
-
-// ConsumeVarint parses b as a varint-encoded uint64, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeVarint(b []byte) (v uint64, n int) {
- var y uint64
- if len(b) <= 0 {
- return 0, errCodeTruncated
- }
- v = uint64(b[0])
- if v < 0x80 {
- return v, 1
- }
- v -= 0x80
-
- if len(b) <= 1 {
- return 0, errCodeTruncated
- }
- y = uint64(b[1])
- v += y << 7
- if y < 0x80 {
- return v, 2
- }
- v -= 0x80 << 7
-
- if len(b) <= 2 {
- return 0, errCodeTruncated
- }
- y = uint64(b[2])
- v += y << 14
- if y < 0x80 {
- return v, 3
- }
- v -= 0x80 << 14
-
- if len(b) <= 3 {
- return 0, errCodeTruncated
- }
- y = uint64(b[3])
- v += y << 21
- if y < 0x80 {
- return v, 4
- }
- v -= 0x80 << 21
-
- if len(b) <= 4 {
- return 0, errCodeTruncated
- }
- y = uint64(b[4])
- v += y << 28
- if y < 0x80 {
- return v, 5
- }
- v -= 0x80 << 28
-
- if len(b) <= 5 {
- return 0, errCodeTruncated
- }
- y = uint64(b[5])
- v += y << 35
- if y < 0x80 {
- return v, 6
- }
- v -= 0x80 << 35
-
- if len(b) <= 6 {
- return 0, errCodeTruncated
- }
- y = uint64(b[6])
- v += y << 42
- if y < 0x80 {
- return v, 7
- }
- v -= 0x80 << 42
-
- if len(b) <= 7 {
- return 0, errCodeTruncated
- }
- y = uint64(b[7])
- v += y << 49
- if y < 0x80 {
- return v, 8
- }
- v -= 0x80 << 49
-
- if len(b) <= 8 {
- return 0, errCodeTruncated
- }
- y = uint64(b[8])
- v += y << 56
- if y < 0x80 {
- return v, 9
- }
- v -= 0x80 << 56
-
- if len(b) <= 9 {
- return 0, errCodeTruncated
- }
- y = uint64(b[9])
- v += y << 63
- if y < 2 {
- return v, 10
- }
- return 0, errCodeOverflow
-}
-
-// SizeVarint returns the encoded size of a varint.
-// The size is guaranteed to be within 1 and 10, inclusive.
-func SizeVarint(v uint64) int {
- // This computes 1 + (bits.Len64(v)-1)/7.
- // 9/64 is a good enough approximation of 1/7
- return int(9*uint32(bits.Len64(v))+64) / 64
-}
-
-// AppendFixed32 appends v to b as a little-endian uint32.
-func AppendFixed32(b []byte, v uint32) []byte {
- return append(b,
- byte(v>>0),
- byte(v>>8),
- byte(v>>16),
- byte(v>>24))
-}
-
-// ConsumeFixed32 parses b as a little-endian uint32, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeFixed32(b []byte) (v uint32, n int) {
- if len(b) < 4 {
- return 0, errCodeTruncated
- }
- v = uint32(b[0])<<0 | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
- return v, 4
-}
-
-// SizeFixed32 returns the encoded size of a fixed32; which is always 4.
-func SizeFixed32() int {
- return 4
-}
-
-// AppendFixed64 appends v to b as a little-endian uint64.
-func AppendFixed64(b []byte, v uint64) []byte {
- return append(b,
- byte(v>>0),
- byte(v>>8),
- byte(v>>16),
- byte(v>>24),
- byte(v>>32),
- byte(v>>40),
- byte(v>>48),
- byte(v>>56))
-}
-
-// ConsumeFixed64 parses b as a little-endian uint64, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeFixed64(b []byte) (v uint64, n int) {
- if len(b) < 8 {
- return 0, errCodeTruncated
- }
- v = uint64(b[0])<<0 | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
- return v, 8
-}
-
-// SizeFixed64 returns the encoded size of a fixed64; which is always 8.
-func SizeFixed64() int {
- return 8
-}
-
-// AppendBytes appends v to b as a length-prefixed bytes value.
-func AppendBytes(b []byte, v []byte) []byte {
- return append(AppendVarint(b, uint64(len(v))), v...)
-}
-
-// ConsumeBytes parses b as a length-prefixed bytes value, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeBytes(b []byte) (v []byte, n int) {
- m, n := ConsumeVarint(b)
- if n < 0 {
- return nil, n // forward error code
- }
- if m > uint64(len(b[n:])) {
- return nil, errCodeTruncated
- }
- return b[n:][:m], n + int(m)
-}
-
-// SizeBytes returns the encoded size of a length-prefixed bytes value,
-// given only the length.
-func SizeBytes(n int) int {
- return SizeVarint(uint64(n)) + n
-}
-
-// AppendString appends v to b as a length-prefixed bytes value.
-func AppendString(b []byte, v string) []byte {
- return append(AppendVarint(b, uint64(len(v))), v...)
-}
-
-// ConsumeString parses b as a length-prefixed bytes value, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeString(b []byte) (v string, n int) {
- bb, n := ConsumeBytes(b)
- return string(bb), n
-}
-
-// AppendGroup appends v to b as group value, with a trailing end group marker.
-// The value v must not contain the end marker.
-func AppendGroup(b []byte, num Number, v []byte) []byte {
- return AppendVarint(append(b, v...), EncodeTag(num, EndGroupType))
-}
-
-// ConsumeGroup parses b as a group value until the trailing end group marker,
-// and verifies that the end marker matches the provided num. The value v
-// does not contain the end marker, while the length does contain the end marker.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeGroup(num Number, b []byte) (v []byte, n int) {
- n = ConsumeFieldValue(num, StartGroupType, b)
- if n < 0 {
- return nil, n // forward error code
- }
- b = b[:n]
-
- // Truncate off end group marker, but need to handle denormalized varints.
- // Assuming end marker is never 0 (which is always the case since
- // EndGroupType is non-zero), we can truncate all trailing bytes where the
- // lower 7 bits are all zero (implying that the varint is denormalized).
- for len(b) > 0 && b[len(b)-1]&0x7f == 0 {
- b = b[:len(b)-1]
- }
- b = b[:len(b)-SizeTag(num)]
- return b, n
-}
-
-// SizeGroup returns the encoded size of a group, given only the length.
-func SizeGroup(num Number, n int) int {
- return n + SizeTag(num)
-}
-
-// DecodeTag decodes the field Number and wire Type from its unified form.
-// The Number is -1 if the decoded field number overflows int32.
-// Other than overflow, this does not check for field number validity.
-func DecodeTag(x uint64) (Number, Type) {
- // NOTE: MessageSet allows for larger field numbers than normal.
- if x>>3 > uint64(math.MaxInt32) {
- return -1, 0
- }
- return Number(x >> 3), Type(x & 7)
-}
-
-// EncodeTag encodes the field Number and wire Type into its unified form.
-func EncodeTag(num Number, typ Type) uint64 {
- return uint64(num)<<3 | uint64(typ&7)
-}
-
-// DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.
-// Input: {…, 5, 3, 1, 0, 2, 4, 6, …}
-// Output: {…, -3, -2, -1, 0, +1, +2, +3, …}
-func DecodeZigZag(x uint64) int64 {
- return int64(x>>1) ^ int64(x)<<63>>63
-}
-
-// EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.
-// Input: {…, -3, -2, -1, 0, +1, +2, +3, …}
-// Output: {…, 5, 3, 1, 0, 2, 4, 6, …}
-func EncodeZigZag(x int64) uint64 {
- return uint64(x<<1) ^ uint64(x>>63)
-}
-
-// DecodeBool decodes a uint64 as a bool.
-// Input: { 0, 1, 2, …}
-// Output: {false, true, true, …}
-func DecodeBool(x uint64) bool {
- return x != 0
-}
-
-// EncodeBool encodes a bool as a uint64.
-// Input: {false, true}
-// Output: { 0, 1}
-func EncodeBool(x bool) uint64 {
- if x {
- return 1
- }
- return 0
-}
diff --git a/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go b/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go
deleted file mode 100644
index e7af0fe..0000000
--- a/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go
+++ /dev/null
@@ -1,316 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package descfmt provides functionality to format descriptors.
-package descfmt
-
-import (
- "fmt"
- "io"
- "reflect"
- "strconv"
- "strings"
-
- "google.golang.org/protobuf/internal/detrand"
- "google.golang.org/protobuf/internal/pragma"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type list interface {
- Len() int
- pragma.DoNotImplement
-}
-
-func FormatList(s fmt.State, r rune, vs list) {
- io.WriteString(s, formatListOpt(vs, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
-}
-func formatListOpt(vs list, isRoot, allowMulti bool) string {
- start, end := "[", "]"
- if isRoot {
- var name string
- switch vs.(type) {
- case pref.Names:
- name = "Names"
- case pref.FieldNumbers:
- name = "FieldNumbers"
- case pref.FieldRanges:
- name = "FieldRanges"
- case pref.EnumRanges:
- name = "EnumRanges"
- case pref.FileImports:
- name = "FileImports"
- case pref.Descriptor:
- name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
- }
- start, end = name+"{", "}"
- }
-
- var ss []string
- switch vs := vs.(type) {
- case pref.Names:
- for i := 0; i < vs.Len(); i++ {
- ss = append(ss, fmt.Sprint(vs.Get(i)))
- }
- return start + joinStrings(ss, false) + end
- case pref.FieldNumbers:
- for i := 0; i < vs.Len(); i++ {
- ss = append(ss, fmt.Sprint(vs.Get(i)))
- }
- return start + joinStrings(ss, false) + end
- case pref.FieldRanges:
- for i := 0; i < vs.Len(); i++ {
- r := vs.Get(i)
- if r[0]+1 == r[1] {
- ss = append(ss, fmt.Sprintf("%d", r[0]))
- } else {
- ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive
- }
- }
- return start + joinStrings(ss, false) + end
- case pref.EnumRanges:
- for i := 0; i < vs.Len(); i++ {
- r := vs.Get(i)
- if r[0] == r[1] {
- ss = append(ss, fmt.Sprintf("%d", r[0]))
- } else {
- ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive
- }
- }
- return start + joinStrings(ss, false) + end
- case pref.FileImports:
- for i := 0; i < vs.Len(); i++ {
- var rs records
- rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak")
- ss = append(ss, "{"+rs.Join()+"}")
- }
- return start + joinStrings(ss, allowMulti) + end
- default:
- _, isEnumValue := vs.(pref.EnumValueDescriptors)
- for i := 0; i < vs.Len(); i++ {
- m := reflect.ValueOf(vs).MethodByName("Get")
- v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
- ss = append(ss, formatDescOpt(v.(pref.Descriptor), false, allowMulti && !isEnumValue))
- }
- return start + joinStrings(ss, allowMulti && isEnumValue) + end
- }
-}
-
-// descriptorAccessors is a list of accessors to print for each descriptor.
-//
-// Do not print all accessors since some contain redundant information,
-// while others are pointers that we do not want to follow since the descriptor
-// is actually a cyclic graph.
-//
-// Using a list allows us to print the accessors in a sensible order.
-var descriptorAccessors = map[reflect.Type][]string{
- reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem(): {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"},
- reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem(): {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"},
- reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem(): {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"},
- reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem(): {"Fields"}, // not directly used; must keep in sync with formatDescOpt
- reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem(): {"Values", "ReservedNames", "ReservedRanges"},
- reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"},
- reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem(): {"Methods"},
- reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem(): {"Input", "Output", "IsStreamingClient", "IsStreamingServer"},
-}
-
-func FormatDesc(s fmt.State, r rune, t pref.Descriptor) {
- io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
-}
-func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
- rv := reflect.ValueOf(t)
- rt := rv.MethodByName("ProtoType").Type().In(0)
-
- start, end := "{", "}"
- if isRoot {
- start = rt.Name() + "{"
- }
-
- _, isFile := t.(pref.FileDescriptor)
- rs := records{allowMulti: allowMulti}
- if t.IsPlaceholder() {
- if isFile {
- rs.Append(rv, "Path", "Package", "IsPlaceholder")
- } else {
- rs.Append(rv, "FullName", "IsPlaceholder")
- }
- } else {
- switch {
- case isFile:
- rs.Append(rv, "Syntax")
- case isRoot:
- rs.Append(rv, "Syntax", "FullName")
- default:
- rs.Append(rv, "Name")
- }
- switch t := t.(type) {
- case pref.FieldDescriptor:
- for _, s := range descriptorAccessors[rt] {
- switch s {
- case "MapKey":
- if k := t.MapKey(); k != nil {
- rs.recs = append(rs.recs, [2]string{"MapKey", k.Kind().String()})
- }
- case "MapValue":
- if v := t.MapValue(); v != nil {
- switch v.Kind() {
- case pref.EnumKind:
- rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())})
- case pref.MessageKind, pref.GroupKind:
- rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())})
- default:
- rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()})
- }
- }
- case "ContainingOneof":
- if od := t.ContainingOneof(); od != nil {
- rs.recs = append(rs.recs, [2]string{"Oneof", string(od.Name())})
- }
- case "ContainingMessage":
- if t.IsExtension() {
- rs.recs = append(rs.recs, [2]string{"Extendee", string(t.ContainingMessage().FullName())})
- }
- case "Message":
- if !t.IsMap() {
- rs.Append(rv, s)
- }
- default:
- rs.Append(rv, s)
- }
- }
- case pref.OneofDescriptor:
- var ss []string
- fs := t.Fields()
- for i := 0; i < fs.Len(); i++ {
- ss = append(ss, string(fs.Get(i).Name()))
- }
- if len(ss) > 0 {
- rs.recs = append(rs.recs, [2]string{"Fields", "[" + joinStrings(ss, false) + "]"})
- }
- default:
- rs.Append(rv, descriptorAccessors[rt]...)
- }
- if rv.MethodByName("GoType").IsValid() {
- rs.Append(rv, "GoType")
- }
- }
- return start + rs.Join() + end
-}
-
-type records struct {
- recs [][2]string
- allowMulti bool
-}
-
-func (rs *records) Append(v reflect.Value, accessors ...string) {
- for _, a := range accessors {
- var rv reflect.Value
- if m := v.MethodByName(a); m.IsValid() {
- rv = m.Call(nil)[0]
- }
- if v.Kind() == reflect.Struct && !rv.IsValid() {
- rv = v.FieldByName(a)
- }
- if !rv.IsValid() {
- panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
- }
- if _, ok := rv.Interface().(pref.Value); ok {
- rv = rv.MethodByName("Interface").Call(nil)[0]
- if !rv.IsNil() {
- rv = rv.Elem()
- }
- }
-
- // Ignore zero values.
- var isZero bool
- switch rv.Kind() {
- case reflect.Interface, reflect.Slice:
- isZero = rv.IsNil()
- case reflect.Bool:
- isZero = rv.Bool() == false
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- isZero = rv.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
- isZero = rv.Uint() == 0
- case reflect.String:
- isZero = rv.String() == ""
- }
- if n, ok := rv.Interface().(list); ok {
- isZero = n.Len() == 0
- }
- if isZero {
- continue
- }
-
- // Format the value.
- var s string
- v := rv.Interface()
- switch v := v.(type) {
- case list:
- s = formatListOpt(v, false, rs.allowMulti)
- case pref.FieldDescriptor, pref.OneofDescriptor, pref.EnumValueDescriptor, pref.MethodDescriptor:
- s = string(v.(pref.Descriptor).Name())
- case pref.Descriptor:
- s = string(v.FullName())
- case string:
- s = strconv.Quote(v)
- case []byte:
- s = fmt.Sprintf("%q", v)
- default:
- s = fmt.Sprint(v)
- }
- rs.recs = append(rs.recs, [2]string{a, s})
- }
-}
-
-func (rs *records) Join() string {
- var ss []string
-
- // In single line mode, simply join all records with commas.
- if !rs.allowMulti {
- for _, r := range rs.recs {
- ss = append(ss, r[0]+formatColon(0)+r[1])
- }
- return joinStrings(ss, false)
- }
-
- // In allowMulti line mode, align single line records for more readable output.
- var maxLen int
- flush := func(i int) {
- for _, r := range rs.recs[len(ss):i] {
- ss = append(ss, r[0]+formatColon(maxLen-len(r[0]))+r[1])
- }
- maxLen = 0
- }
- for i, r := range rs.recs {
- if isMulti := strings.Contains(r[1], "\n"); isMulti {
- flush(i)
- ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t"))
- } else if maxLen < len(r[0]) {
- maxLen = len(r[0])
- }
- }
- flush(len(rs.recs))
- return joinStrings(ss, true)
-}
-
-func formatColon(padding int) string {
- // Deliberately introduce instability into the debug output to
- // discourage users from performing string comparisons.
- // This provides us flexibility to change the output in the future.
- if detrand.Bool() {
- return ":" + strings.Repeat(" ", 1+padding) // use non-breaking spaces (U+00a0)
- } else {
- return ":" + strings.Repeat(" ", 1+padding) // use regular spaces (U+0020)
- }
-}
-
-func joinStrings(ss []string, isMulti bool) string {
- if len(ss) == 0 {
- return ""
- }
- if isMulti {
- return "\n\t" + strings.Join(ss, "\n\t") + "\n"
- }
- return strings.Join(ss, ", ")
-}
diff --git a/vendor/google.golang.org/protobuf/internal/descopts/options.go b/vendor/google.golang.org/protobuf/internal/descopts/options.go
deleted file mode 100644
index 8401be8..0000000
--- a/vendor/google.golang.org/protobuf/internal/descopts/options.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package descopts contains the nil pointers to concrete descriptor options.
-//
-// This package exists as a form of reverse dependency injection so that certain
-// packages (e.g., internal/filedesc and internal/filetype can avoid a direct
-// dependency on the descriptor proto package).
-package descopts
-
-import pref "google.golang.org/protobuf/reflect/protoreflect"
-
-// These variables are set by the init function in descriptor.pb.go via logic
-// in internal/filetype. In other words, so long as the descriptor proto package
-// is linked in, these variables will be populated.
-//
-// Each variable is populated with a nil pointer to the options struct.
-var (
- File pref.ProtoMessage
- Enum pref.ProtoMessage
- EnumValue pref.ProtoMessage
- Message pref.ProtoMessage
- Field pref.ProtoMessage
- Oneof pref.ProtoMessage
- ExtensionRange pref.ProtoMessage
- Service pref.ProtoMessage
- Method pref.ProtoMessage
-)
diff --git a/vendor/google.golang.org/protobuf/internal/detrand/rand.go b/vendor/google.golang.org/protobuf/internal/detrand/rand.go
deleted file mode 100644
index a904dd1..0000000
--- a/vendor/google.golang.org/protobuf/internal/detrand/rand.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package detrand provides deterministically random functionality.
-//
-// The pseudo-randomness of these functions is seeded by the program binary
-// itself and guarantees that the output does not change within a program,
-// while ensuring that the output is unstable across different builds.
-package detrand
-
-import (
- "encoding/binary"
- "hash/fnv"
- "os"
-)
-
-// Disable disables detrand such that all functions returns the zero value.
-// This function is not concurrent-safe and must be called during program init.
-func Disable() {
- randSeed = 0
-}
-
-// Bool returns a deterministically random boolean.
-func Bool() bool {
- return randSeed%2 == 1
-}
-
-// randSeed is a best-effort at an approximate hash of the Go binary.
-var randSeed = binaryHash()
-
-func binaryHash() uint64 {
- // Open the Go binary.
- s, err := os.Executable()
- if err != nil {
- return 0
- }
- f, err := os.Open(s)
- if err != nil {
- return 0
- }
- defer f.Close()
-
- // Hash the size and several samples of the Go binary.
- const numSamples = 8
- var buf [64]byte
- h := fnv.New64()
- fi, err := f.Stat()
- if err != nil {
- return 0
- }
- binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
- h.Write(buf[:8])
- for i := int64(0); i < numSamples; i++ {
- if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
- return 0
- }
- h.Write(buf[:])
- }
- return h.Sum64()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go b/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go
deleted file mode 100644
index fdd9b13..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package defval marshals and unmarshals textual forms of default values.
-//
-// This package handles both the form historically used in Go struct field tags
-// and also the form used by google.protobuf.FieldDescriptorProto.default_value
-// since they differ in superficial ways.
-package defval
-
-import (
- "fmt"
- "math"
- "strconv"
-
- ptext "google.golang.org/protobuf/internal/encoding/text"
- errors "google.golang.org/protobuf/internal/errors"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Format is the serialization format used to represent the default value.
-type Format int
-
-const (
- _ Format = iota
-
- // Descriptor uses the serialization format that protoc uses with the
- // google.protobuf.FieldDescriptorProto.default_value field.
- Descriptor
-
- // GoTag uses the historical serialization format in Go struct field tags.
- GoTag
-)
-
-// Unmarshal deserializes the default string s according to the given kind k.
-// When k is an enum, a list of enum value descriptors must be provided.
-func Unmarshal(s string, k pref.Kind, evs pref.EnumValueDescriptors, f Format) (pref.Value, pref.EnumValueDescriptor, error) {
- switch k {
- case pref.BoolKind:
- if f == GoTag {
- switch s {
- case "1":
- return pref.ValueOfBool(true), nil, nil
- case "0":
- return pref.ValueOfBool(false), nil, nil
- }
- } else {
- switch s {
- case "true":
- return pref.ValueOfBool(true), nil, nil
- case "false":
- return pref.ValueOfBool(false), nil, nil
- }
- }
- case pref.EnumKind:
- if f == GoTag {
- // Go tags use the numeric form of the enum value.
- if n, err := strconv.ParseInt(s, 10, 32); err == nil {
- if ev := evs.ByNumber(pref.EnumNumber(n)); ev != nil {
- return pref.ValueOfEnum(ev.Number()), ev, nil
- }
- }
- } else {
- // Descriptor default_value use the enum identifier.
- ev := evs.ByName(pref.Name(s))
- if ev != nil {
- return pref.ValueOfEnum(ev.Number()), ev, nil
- }
- }
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
- if v, err := strconv.ParseInt(s, 10, 32); err == nil {
- return pref.ValueOfInt32(int32(v)), nil, nil
- }
- case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- if v, err := strconv.ParseInt(s, 10, 64); err == nil {
- return pref.ValueOfInt64(int64(v)), nil, nil
- }
- case pref.Uint32Kind, pref.Fixed32Kind:
- if v, err := strconv.ParseUint(s, 10, 32); err == nil {
- return pref.ValueOfUint32(uint32(v)), nil, nil
- }
- case pref.Uint64Kind, pref.Fixed64Kind:
- if v, err := strconv.ParseUint(s, 10, 64); err == nil {
- return pref.ValueOfUint64(uint64(v)), nil, nil
- }
- case pref.FloatKind, pref.DoubleKind:
- var v float64
- var err error
- switch s {
- case "-inf":
- v = math.Inf(-1)
- case "inf":
- v = math.Inf(+1)
- case "nan":
- v = math.NaN()
- default:
- v, err = strconv.ParseFloat(s, 64)
- }
- if err == nil {
- if k == pref.FloatKind {
- return pref.ValueOfFloat32(float32(v)), nil, nil
- } else {
- return pref.ValueOfFloat64(float64(v)), nil, nil
- }
- }
- case pref.StringKind:
- // String values are already unescaped and can be used as is.
- return pref.ValueOfString(s), nil, nil
- case pref.BytesKind:
- if b, ok := unmarshalBytes(s); ok {
- return pref.ValueOfBytes(b), nil, nil
- }
- }
- return pref.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
-}
-
-// Marshal serializes v as the default string according to the given kind k.
-// When specifying the Descriptor format for an enum kind, the associated
-// enum value descriptor must be provided.
-func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (string, error) {
- switch k {
- case pref.BoolKind:
- if f == GoTag {
- if v.Bool() {
- return "1", nil
- } else {
- return "0", nil
- }
- } else {
- if v.Bool() {
- return "true", nil
- } else {
- return "false", nil
- }
- }
- case pref.EnumKind:
- if f == GoTag {
- return strconv.FormatInt(int64(v.Enum()), 10), nil
- } else {
- return string(ev.Name()), nil
- }
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind, pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- return strconv.FormatInt(v.Int(), 10), nil
- case pref.Uint32Kind, pref.Fixed32Kind, pref.Uint64Kind, pref.Fixed64Kind:
- return strconv.FormatUint(v.Uint(), 10), nil
- case pref.FloatKind, pref.DoubleKind:
- f := v.Float()
- switch {
- case math.IsInf(f, -1):
- return "-inf", nil
- case math.IsInf(f, +1):
- return "inf", nil
- case math.IsNaN(f):
- return "nan", nil
- default:
- if k == pref.FloatKind {
- return strconv.FormatFloat(f, 'g', -1, 32), nil
- } else {
- return strconv.FormatFloat(f, 'g', -1, 64), nil
- }
- }
- case pref.StringKind:
- // String values are serialized as is without any escaping.
- return v.String(), nil
- case pref.BytesKind:
- if s, ok := marshalBytes(v.Bytes()); ok {
- return s, nil
- }
- }
- return "", errors.New("could not format value for %v: %v", k, v)
-}
-
-// unmarshalBytes deserializes bytes by applying C unescaping.
-func unmarshalBytes(s string) ([]byte, bool) {
- // Bytes values use the same escaping as the text format,
- // however they lack the surrounding double quotes.
- v, err := ptext.UnmarshalString(`"` + s + `"`)
- if err != nil {
- return nil, false
- }
- return []byte(v), true
-}
-
-// marshalBytes serializes bytes by using C escaping.
-// To match the exact output of protoc, this is identical to the
-// CEscape function in strutil.cc of the protoc source code.
-func marshalBytes(b []byte) (string, bool) {
- var s []byte
- for _, c := range b {
- switch c {
- case '\n':
- s = append(s, `\n`...)
- case '\r':
- s = append(s, `\r`...)
- case '\t':
- s = append(s, `\t`...)
- case '"':
- s = append(s, `\"`...)
- case '\'':
- s = append(s, `\'`...)
- case '\\':
- s = append(s, `\\`...)
- default:
- if printableASCII := c >= 0x20 && c <= 0x7e; printableASCII {
- s = append(s, c)
- } else {
- s = append(s, fmt.Sprintf(`\%03o`, c)...)
- }
- }
- }
- return string(s), true
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go b/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go
deleted file mode 100644
index b1eeea5..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package messageset encodes and decodes the obsolete MessageSet wire format.
-package messageset
-
-import (
- "math"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/errors"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// The MessageSet wire format is equivalent to a message defiend as follows,
-// where each Item defines an extension field with a field number of 'type_id'
-// and content of 'message'. MessageSet extensions must be non-repeated message
-// fields.
-//
-// message MessageSet {
-// repeated group Item = 1 {
-// required int32 type_id = 2;
-// required string message = 3;
-// }
-// }
-const (
- FieldItem = protowire.Number(1)
- FieldTypeID = protowire.Number(2)
- FieldMessage = protowire.Number(3)
-)
-
-// ExtensionName is the field name for extensions of MessageSet.
-//
-// A valid MessageSet extension must be of the form:
-// message MyMessage {
-// extend proto2.bridge.MessageSet {
-// optional MyMessage message_set_extension = 1234;
-// }
-// ...
-// }
-const ExtensionName = "message_set_extension"
-
-// IsMessageSet returns whether the message uses the MessageSet wire format.
-func IsMessageSet(md pref.MessageDescriptor) bool {
- xmd, ok := md.(interface{ IsMessageSet() bool })
- return ok && xmd.IsMessageSet()
-}
-
-// IsMessageSetExtension reports this field extends a MessageSet.
-func IsMessageSetExtension(fd pref.FieldDescriptor) bool {
- if fd.Name() != ExtensionName {
- return false
- }
- if fd.FullName().Parent() != fd.Message().FullName() {
- return false
- }
- return IsMessageSet(fd.ContainingMessage())
-}
-
-// FindMessageSetExtension locates a MessageSet extension field by name.
-// In text and JSON formats, the extension name used is the message itself.
-// The extension field name is derived by appending ExtensionName.
-func FindMessageSetExtension(r preg.ExtensionTypeResolver, s pref.FullName) (pref.ExtensionType, error) {
- name := s.Append(ExtensionName)
- xt, err := r.FindExtensionByName(name)
- if err != nil {
- if err == preg.NotFound {
- return nil, err
- }
- return nil, errors.Wrap(err, "%q", name)
- }
- if !IsMessageSetExtension(xt.TypeDescriptor()) {
- return nil, preg.NotFound
- }
- return xt, nil
-}
-
-// SizeField returns the size of a MessageSet item field containing an extension
-// with the given field number, not counting the contents of the message subfield.
-func SizeField(num protowire.Number) int {
- return 2*protowire.SizeTag(FieldItem) + protowire.SizeTag(FieldTypeID) + protowire.SizeVarint(uint64(num))
-}
-
-// Unmarshal parses a MessageSet.
-//
-// It calls fn with the type ID and value of each item in the MessageSet.
-// Unknown fields are discarded.
-//
-// If wantLen is true, the item values include the varint length prefix.
-// This is ugly, but simplifies the fast-path decoder in internal/impl.
-func Unmarshal(b []byte, wantLen bool, fn func(typeID protowire.Number, value []byte) error) error {
- for len(b) > 0 {
- num, wtyp, n := protowire.ConsumeTag(b)
- if n < 0 {
- return protowire.ParseError(n)
- }
- b = b[n:]
- if num != FieldItem || wtyp != protowire.StartGroupType {
- n := protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return protowire.ParseError(n)
- }
- b = b[n:]
- continue
- }
- typeID, value, n, err := ConsumeFieldValue(b, wantLen)
- if err != nil {
- return err
- }
- b = b[n:]
- if typeID == 0 {
- continue
- }
- if err := fn(typeID, value); err != nil {
- return err
- }
- }
- return nil
-}
-
-// ConsumeFieldValue parses b as a MessageSet item field value until and including
-// the trailing end group marker. It assumes the start group tag has already been parsed.
-// It returns the contents of the type_id and message subfields and the total
-// item length.
-//
-// If wantLen is true, the returned message value includes the length prefix.
-func ConsumeFieldValue(b []byte, wantLen bool) (typeid protowire.Number, message []byte, n int, err error) {
- ilen := len(b)
- for {
- num, wtyp, n := protowire.ConsumeTag(b)
- if n < 0 {
- return 0, nil, 0, protowire.ParseError(n)
- }
- b = b[n:]
- switch {
- case num == FieldItem && wtyp == protowire.EndGroupType:
- if wantLen && len(message) == 0 {
- // The message field was missing, which should never happen.
- // Be prepared for this case anyway.
- message = protowire.AppendVarint(message, 0)
- }
- return typeid, message, ilen - len(b), nil
- case num == FieldTypeID && wtyp == protowire.VarintType:
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, nil, 0, protowire.ParseError(n)
- }
- b = b[n:]
- if v < 1 || v > math.MaxInt32 {
- return 0, nil, 0, errors.New("invalid type_id in message set")
- }
- typeid = protowire.Number(v)
- case num == FieldMessage && wtyp == protowire.BytesType:
- m, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, nil, 0, protowire.ParseError(n)
- }
- if message == nil {
- if wantLen {
- message = b[:n:n]
- } else {
- message = m[:len(m):len(m)]
- }
- } else {
- // This case should never happen in practice, but handle it for
- // correctness: The MessageSet item contains multiple message
- // fields, which need to be merged.
- //
- // In the case where we're returning the length, this becomes
- // quite inefficient since we need to strip the length off
- // the existing data and reconstruct it with the combined length.
- if wantLen {
- _, nn := protowire.ConsumeVarint(message)
- m0 := message[nn:]
- message = nil
- message = protowire.AppendVarint(message, uint64(len(m0)+len(m)))
- message = append(message, m0...)
- message = append(message, m...)
- } else {
- message = append(message, m...)
- }
- }
- b = b[n:]
- default:
- // We have no place to put it, so we just ignore unknown fields.
- n := protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return 0, nil, 0, protowire.ParseError(n)
- }
- b = b[n:]
- }
- }
-}
-
-// AppendFieldStart appends the start of a MessageSet item field containing
-// an extension with the given number. The caller must add the message
-// subfield (including the tag).
-func AppendFieldStart(b []byte, num protowire.Number) []byte {
- b = protowire.AppendTag(b, FieldItem, protowire.StartGroupType)
- b = protowire.AppendTag(b, FieldTypeID, protowire.VarintType)
- b = protowire.AppendVarint(b, uint64(num))
- return b
-}
-
-// AppendFieldEnd appends the trailing end group marker for a MessageSet item field.
-func AppendFieldEnd(b []byte) []byte {
- return protowire.AppendTag(b, FieldItem, protowire.EndGroupType)
-}
-
-// SizeUnknown returns the size of an unknown fields section in MessageSet format.
-//
-// See AppendUnknown.
-func SizeUnknown(unknown []byte) (size int) {
- for len(unknown) > 0 {
- num, typ, n := protowire.ConsumeTag(unknown)
- if n < 0 || typ != protowire.BytesType {
- return 0
- }
- unknown = unknown[n:]
- _, n = protowire.ConsumeBytes(unknown)
- if n < 0 {
- return 0
- }
- unknown = unknown[n:]
- size += SizeField(num) + protowire.SizeTag(FieldMessage) + n
- }
- return size
-}
-
-// AppendUnknown appends unknown fields to b in MessageSet format.
-//
-// For historic reasons, unresolved items in a MessageSet are stored in a
-// message's unknown fields section in non-MessageSet format. That is, an
-// unknown item with typeID T and value V appears in the unknown fields as
-// a field with number T and value V.
-//
-// This function converts the unknown fields back into MessageSet form.
-func AppendUnknown(b, unknown []byte) ([]byte, error) {
- for len(unknown) > 0 {
- num, typ, n := protowire.ConsumeTag(unknown)
- if n < 0 || typ != protowire.BytesType {
- return nil, errors.New("invalid data in message set unknown fields")
- }
- unknown = unknown[n:]
- _, n = protowire.ConsumeBytes(unknown)
- if n < 0 {
- return nil, errors.New("invalid data in message set unknown fields")
- }
- b = AppendFieldStart(b, num)
- b = protowire.AppendTag(b, FieldMessage, protowire.BytesType)
- b = append(b, unknown[:n]...)
- b = AppendFieldEnd(b)
- unknown = unknown[n:]
- }
- return b, nil
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go
deleted file mode 100644
index 16c02d7..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package tag marshals and unmarshals the legacy struct tags as generated
-// by historical versions of protoc-gen-go.
-package tag
-
-import (
- "reflect"
- "strconv"
- "strings"
-
- defval "google.golang.org/protobuf/internal/encoding/defval"
- fdesc "google.golang.org/protobuf/internal/filedesc"
- "google.golang.org/protobuf/internal/strs"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var byteType = reflect.TypeOf(byte(0))
-
-// Unmarshal decodes the tag into a prototype.Field.
-//
-// The goType is needed to determine the original protoreflect.Kind since the
-// tag does not record sufficient information to determine that.
-// The type is the underlying field type (e.g., a repeated field may be
-// represented by []T, but the Go type passed in is just T).
-// A list of enum value descriptors must be provided for enum fields.
-// This does not populate the Enum or Message (except for weak message).
-//
-// This function is a best effort attempt; parsing errors are ignored.
-func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) pref.FieldDescriptor {
- f := new(fdesc.Field)
- f.L0.ParentFile = fdesc.SurrogateProto2
- for len(tag) > 0 {
- i := strings.IndexByte(tag, ',')
- if i < 0 {
- i = len(tag)
- }
- switch s := tag[:i]; {
- case strings.HasPrefix(s, "name="):
- f.L0.FullName = pref.FullName(s[len("name="):])
- case strings.Trim(s, "0123456789") == "":
- n, _ := strconv.ParseUint(s, 10, 32)
- f.L1.Number = pref.FieldNumber(n)
- case s == "opt":
- f.L1.Cardinality = pref.Optional
- case s == "req":
- f.L1.Cardinality = pref.Required
- case s == "rep":
- f.L1.Cardinality = pref.Repeated
- case s == "varint":
- switch goType.Kind() {
- case reflect.Bool:
- f.L1.Kind = pref.BoolKind
- case reflect.Int32:
- f.L1.Kind = pref.Int32Kind
- case reflect.Int64:
- f.L1.Kind = pref.Int64Kind
- case reflect.Uint32:
- f.L1.Kind = pref.Uint32Kind
- case reflect.Uint64:
- f.L1.Kind = pref.Uint64Kind
- }
- case s == "zigzag32":
- if goType.Kind() == reflect.Int32 {
- f.L1.Kind = pref.Sint32Kind
- }
- case s == "zigzag64":
- if goType.Kind() == reflect.Int64 {
- f.L1.Kind = pref.Sint64Kind
- }
- case s == "fixed32":
- switch goType.Kind() {
- case reflect.Int32:
- f.L1.Kind = pref.Sfixed32Kind
- case reflect.Uint32:
- f.L1.Kind = pref.Fixed32Kind
- case reflect.Float32:
- f.L1.Kind = pref.FloatKind
- }
- case s == "fixed64":
- switch goType.Kind() {
- case reflect.Int64:
- f.L1.Kind = pref.Sfixed64Kind
- case reflect.Uint64:
- f.L1.Kind = pref.Fixed64Kind
- case reflect.Float64:
- f.L1.Kind = pref.DoubleKind
- }
- case s == "bytes":
- switch {
- case goType.Kind() == reflect.String:
- f.L1.Kind = pref.StringKind
- case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
- f.L1.Kind = pref.BytesKind
- default:
- f.L1.Kind = pref.MessageKind
- }
- case s == "group":
- f.L1.Kind = pref.GroupKind
- case strings.HasPrefix(s, "enum="):
- f.L1.Kind = pref.EnumKind
- case strings.HasPrefix(s, "json="):
- jsonName := s[len("json="):]
- if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) {
- f.L1.JSONName.Init(jsonName)
- }
- case s == "packed":
- f.L1.HasPacked = true
- f.L1.IsPacked = true
- case strings.HasPrefix(s, "weak="):
- f.L1.IsWeak = true
- f.L1.Message = fdesc.PlaceholderMessage(pref.FullName(s[len("weak="):]))
- case strings.HasPrefix(s, "def="):
- // The default tag is special in that everything afterwards is the
- // default regardless of the presence of commas.
- s, i = tag[len("def="):], len(tag)
- v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag)
- f.L1.Default = fdesc.DefaultValue(v, ev)
- case s == "proto3":
- f.L0.ParentFile = fdesc.SurrogateProto3
- }
- tag = strings.TrimPrefix(tag[i:], ",")
- }
-
- // The generator uses the group message name instead of the field name.
- // We obtain the real field name by lowercasing the group name.
- if f.L1.Kind == pref.GroupKind {
- f.L0.FullName = pref.FullName(strings.ToLower(string(f.L0.FullName)))
- }
- return f
-}
-
-// Marshal encodes the protoreflect.FieldDescriptor as a tag.
-//
-// The enumName must be provided if the kind is an enum.
-// Historically, the formulation of the enum "name" was the proto package
-// dot-concatenated with the generated Go identifier for the enum type.
-// Depending on the context on how Marshal is called, there are different ways
-// through which that information is determined. As such it is the caller's
-// responsibility to provide a function to obtain that information.
-func Marshal(fd pref.FieldDescriptor, enumName string) string {
- var tag []string
- switch fd.Kind() {
- case pref.BoolKind, pref.EnumKind, pref.Int32Kind, pref.Uint32Kind, pref.Int64Kind, pref.Uint64Kind:
- tag = append(tag, "varint")
- case pref.Sint32Kind:
- tag = append(tag, "zigzag32")
- case pref.Sint64Kind:
- tag = append(tag, "zigzag64")
- case pref.Sfixed32Kind, pref.Fixed32Kind, pref.FloatKind:
- tag = append(tag, "fixed32")
- case pref.Sfixed64Kind, pref.Fixed64Kind, pref.DoubleKind:
- tag = append(tag, "fixed64")
- case pref.StringKind, pref.BytesKind, pref.MessageKind:
- tag = append(tag, "bytes")
- case pref.GroupKind:
- tag = append(tag, "group")
- }
- tag = append(tag, strconv.Itoa(int(fd.Number())))
- switch fd.Cardinality() {
- case pref.Optional:
- tag = append(tag, "opt")
- case pref.Required:
- tag = append(tag, "req")
- case pref.Repeated:
- tag = append(tag, "rep")
- }
- if fd.IsPacked() {
- tag = append(tag, "packed")
- }
- name := string(fd.Name())
- if fd.Kind() == pref.GroupKind {
- // The name of the FieldDescriptor for a group field is
- // lowercased. To find the original capitalization, we
- // look in the field's MessageType.
- name = string(fd.Message().Name())
- }
- tag = append(tag, "name="+name)
- if jsonName := fd.JSONName(); jsonName != "" && jsonName != name && !fd.IsExtension() {
- // NOTE: The jsonName != name condition is suspect, but it preserve
- // the exact same semantics from the previous generator.
- tag = append(tag, "json="+jsonName)
- }
- if fd.IsWeak() {
- tag = append(tag, "weak="+string(fd.Message().FullName()))
- }
- // The previous implementation does not tag extension fields as proto3,
- // even when the field is defined in a proto3 file. Match that behavior
- // for consistency.
- if fd.Syntax() == pref.Proto3 && !fd.IsExtension() {
- tag = append(tag, "proto3")
- }
- if fd.Kind() == pref.EnumKind && enumName != "" {
- tag = append(tag, "enum="+enumName)
- }
- if fd.ContainingOneof() != nil {
- tag = append(tag, "oneof")
- }
- // This must appear last in the tag, since commas in strings aren't escaped.
- if fd.HasDefault() {
- def, _ := defval.Marshal(fd.Default(), fd.DefaultEnumValue(), fd.Kind(), defval.GoTag)
- tag = append(tag, "def="+def)
- }
- return strings.Join(tag, ",")
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go
deleted file mode 100644
index eb10ea1..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go
+++ /dev/null
@@ -1,665 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
- "bytes"
- "fmt"
- "io"
- "regexp"
- "strconv"
- "unicode/utf8"
-
- "google.golang.org/protobuf/internal/errors"
-)
-
-// Decoder is a token-based textproto decoder.
-type Decoder struct {
- // lastCall is last method called, either readCall or peekCall.
- // Initial value is readCall.
- lastCall call
-
- // lastToken contains the last read token.
- lastToken Token
-
- // lastErr contains the last read error.
- lastErr error
-
- // openStack is a stack containing the byte characters for MessageOpen and
- // ListOpen kinds. The top of stack represents the message or the list that
- // the current token is nested in. An empty stack means the current token is
- // at the top level message. The characters '{' and '<' both represent the
- // MessageOpen kind.
- openStack []byte
-
- // orig is used in reporting line and column.
- orig []byte
- // in contains the unconsumed input.
- in []byte
-}
-
-// NewDecoder returns a Decoder to read the given []byte.
-func NewDecoder(b []byte) *Decoder {
- return &Decoder{orig: b, in: b}
-}
-
-// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
-var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
-
-// call specifies which Decoder method was invoked.
-type call uint8
-
-const (
- readCall call = iota
- peekCall
-)
-
-// Peek looks ahead and returns the next token and error without advancing a read.
-func (d *Decoder) Peek() (Token, error) {
- defer func() { d.lastCall = peekCall }()
- if d.lastCall == readCall {
- d.lastToken, d.lastErr = d.Read()
- }
- return d.lastToken, d.lastErr
-}
-
-// Read returns the next token.
-// It will return an error if there is no valid token.
-func (d *Decoder) Read() (Token, error) {
- defer func() { d.lastCall = readCall }()
- if d.lastCall == peekCall {
- return d.lastToken, d.lastErr
- }
-
- tok, err := d.parseNext(d.lastToken.kind)
- if err != nil {
- return Token{}, err
- }
-
- switch tok.kind {
- case comma, semicolon:
- tok, err = d.parseNext(tok.kind)
- if err != nil {
- return Token{}, err
- }
- }
- d.lastToken = tok
- return tok, nil
-}
-
-const (
- mismatchedFmt = "mismatched close character %q"
- unexpectedFmt = "unexpected character %q"
-)
-
-// parseNext parses the next Token based on given last kind.
-func (d *Decoder) parseNext(lastKind Kind) (Token, error) {
- // Trim leading spaces.
- d.consume(0)
- isEOF := false
- if len(d.in) == 0 {
- isEOF = true
- }
-
- switch lastKind {
- case EOF:
- return d.consumeToken(EOF, 0, 0), nil
-
- case bof:
- // Start of top level message. Next token can be EOF or Name.
- if isEOF {
- return d.consumeToken(EOF, 0, 0), nil
- }
- return d.parseFieldName()
-
- case Name:
- // Next token can be MessageOpen, ListOpen or Scalar.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case '{', '<':
- d.pushOpenStack(ch)
- return d.consumeToken(MessageOpen, 1, 0), nil
- case '[':
- d.pushOpenStack(ch)
- return d.consumeToken(ListOpen, 1, 0), nil
- default:
- return d.parseScalar()
- }
-
- case Scalar:
- openKind, closeCh := d.currentOpenKind()
- switch openKind {
- case bof:
- // Top level message.
- // Next token can be EOF, comma, semicolon or Name.
- if isEOF {
- return d.consumeToken(EOF, 0, 0), nil
- }
- switch d.in[0] {
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- case ';':
- return d.consumeToken(semicolon, 1, 0), nil
- default:
- return d.parseFieldName()
- }
-
- case MessageOpen:
- // Next token can be MessageClose, comma, semicolon or Name.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case closeCh:
- d.popOpenStack()
- return d.consumeToken(MessageClose, 1, 0), nil
- case otherCloseChar[closeCh]:
- return Token{}, d.newSyntaxError(mismatchedFmt, ch)
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- case ';':
- return d.consumeToken(semicolon, 1, 0), nil
- default:
- return d.parseFieldName()
- }
-
- case ListOpen:
- // Next token can be ListClose or comma.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case ']':
- d.popOpenStack()
- return d.consumeToken(ListClose, 1, 0), nil
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- default:
- return Token{}, d.newSyntaxError(unexpectedFmt, ch)
- }
- }
-
- case MessageOpen:
- // Next token can be MessageClose or Name.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- _, closeCh := d.currentOpenKind()
- switch ch := d.in[0]; ch {
- case closeCh:
- d.popOpenStack()
- return d.consumeToken(MessageClose, 1, 0), nil
- case otherCloseChar[closeCh]:
- return Token{}, d.newSyntaxError(mismatchedFmt, ch)
- default:
- return d.parseFieldName()
- }
-
- case MessageClose:
- openKind, closeCh := d.currentOpenKind()
- switch openKind {
- case bof:
- // Top level message.
- // Next token can be EOF, comma, semicolon or Name.
- if isEOF {
- return d.consumeToken(EOF, 0, 0), nil
- }
- switch ch := d.in[0]; ch {
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- case ';':
- return d.consumeToken(semicolon, 1, 0), nil
- default:
- return d.parseFieldName()
- }
-
- case MessageOpen:
- // Next token can be MessageClose, comma, semicolon or Name.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case closeCh:
- d.popOpenStack()
- return d.consumeToken(MessageClose, 1, 0), nil
- case otherCloseChar[closeCh]:
- return Token{}, d.newSyntaxError(mismatchedFmt, ch)
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- case ';':
- return d.consumeToken(semicolon, 1, 0), nil
- default:
- return d.parseFieldName()
- }
-
- case ListOpen:
- // Next token can be ListClose or comma
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case closeCh:
- d.popOpenStack()
- return d.consumeToken(ListClose, 1, 0), nil
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- default:
- return Token{}, d.newSyntaxError(unexpectedFmt, ch)
- }
- }
-
- case ListOpen:
- // Next token can be ListClose, MessageStart or Scalar.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case ']':
- d.popOpenStack()
- return d.consumeToken(ListClose, 1, 0), nil
- case '{', '<':
- d.pushOpenStack(ch)
- return d.consumeToken(MessageOpen, 1, 0), nil
- default:
- return d.parseScalar()
- }
-
- case ListClose:
- openKind, closeCh := d.currentOpenKind()
- switch openKind {
- case bof:
- // Top level message.
- // Next token can be EOF, comma, semicolon or Name.
- if isEOF {
- return d.consumeToken(EOF, 0, 0), nil
- }
- switch ch := d.in[0]; ch {
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- case ';':
- return d.consumeToken(semicolon, 1, 0), nil
- default:
- return d.parseFieldName()
- }
-
- case MessageOpen:
- // Next token can be MessageClose, comma, semicolon or Name.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case closeCh:
- d.popOpenStack()
- return d.consumeToken(MessageClose, 1, 0), nil
- case otherCloseChar[closeCh]:
- return Token{}, d.newSyntaxError(mismatchedFmt, ch)
- case ',':
- return d.consumeToken(comma, 1, 0), nil
- case ';':
- return d.consumeToken(semicolon, 1, 0), nil
- default:
- return d.parseFieldName()
- }
-
- default:
- // It is not possible to have this case. Let it panic below.
- }
-
- case comma, semicolon:
- openKind, closeCh := d.currentOpenKind()
- switch openKind {
- case bof:
- // Top level message. Next token can be EOF or Name.
- if isEOF {
- return d.consumeToken(EOF, 0, 0), nil
- }
- return d.parseFieldName()
-
- case MessageOpen:
- // Next token can be MessageClose or Name.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case closeCh:
- d.popOpenStack()
- return d.consumeToken(MessageClose, 1, 0), nil
- case otherCloseChar[closeCh]:
- return Token{}, d.newSyntaxError(mismatchedFmt, ch)
- default:
- return d.parseFieldName()
- }
-
- case ListOpen:
- if lastKind == semicolon {
- // It is not be possible to have this case as logic here
- // should not have produced a semicolon Token when inside a
- // list. Let it panic below.
- break
- }
- // Next token can be MessageOpen or Scalar.
- if isEOF {
- return Token{}, ErrUnexpectedEOF
- }
- switch ch := d.in[0]; ch {
- case '{', '<':
- d.pushOpenStack(ch)
- return d.consumeToken(MessageOpen, 1, 0), nil
- default:
- return d.parseScalar()
- }
- }
- }
-
- line, column := d.Position(len(d.orig) - len(d.in))
- panic(fmt.Sprintf("Decoder.parseNext: bug at handling line %d:%d with lastKind=%v", line, column, lastKind))
-}
-
-var otherCloseChar = map[byte]byte{
- '}': '>',
- '>': '}',
-}
-
-// currentOpenKind indicates whether current position is inside a message, list
-// or top-level message by returning MessageOpen, ListOpen or bof respectively.
-// If the returned kind is either a MessageOpen or ListOpen, it also returns the
-// corresponding closing character.
-func (d *Decoder) currentOpenKind() (Kind, byte) {
- if len(d.openStack) == 0 {
- return bof, 0
- }
- openCh := d.openStack[len(d.openStack)-1]
- switch openCh {
- case '{':
- return MessageOpen, '}'
- case '<':
- return MessageOpen, '>'
- case '[':
- return ListOpen, ']'
- }
- panic(fmt.Sprintf("Decoder: openStack contains invalid byte %s", string(openCh)))
-}
-
-func (d *Decoder) pushOpenStack(ch byte) {
- d.openStack = append(d.openStack, ch)
-}
-
-func (d *Decoder) popOpenStack() {
- d.openStack = d.openStack[:len(d.openStack)-1]
-}
-
-// parseFieldName parses field name and separator.
-func (d *Decoder) parseFieldName() (tok Token, err error) {
- defer func() {
- if err == nil && d.tryConsumeChar(':') {
- tok.attrs |= hasSeparator
- }
- }()
-
- // Extension or Any type URL.
- if d.in[0] == '[' {
- return d.parseTypeName()
- }
-
- // Identifier.
- if size := parseIdent(d.in, false); size > 0 {
- return d.consumeToken(Name, size, uint8(IdentName)), nil
- }
-
- // Field number. Identify if input is a valid number that is not negative
- // and is decimal integer within 32-bit range.
- if num := parseNumber(d.in); num.size > 0 {
- if !num.neg && num.kind == numDec {
- if _, err := strconv.ParseInt(string(d.in[:num.size]), 10, 32); err == nil {
- return d.consumeToken(Name, num.size, uint8(FieldNumber)), nil
- }
- }
- return Token{}, d.newSyntaxError("invalid field number: %s", d.in[:num.size])
- }
-
- return Token{}, d.newSyntaxError("invalid field name: %s", errRegexp.Find(d.in))
-}
-
-// parseTypeName parses Any type URL or extension field name. The name is
-// enclosed in [ and ] characters. The C++ parser does not handle many legal URL
-// strings. This implementation is more liberal and allows for the pattern
-// ^[-_a-zA-Z0-9]+([./][-_a-zA-Z0-9]+)*`). Whitespaces and comments are allowed
-// in between [ ], '.', '/' and the sub names.
-func (d *Decoder) parseTypeName() (Token, error) {
- startPos := len(d.orig) - len(d.in)
- // Use alias s to advance first in order to use d.in for error handling.
- // Caller already checks for [ as first character.
- s := consume(d.in[1:], 0)
- if len(s) == 0 {
- return Token{}, ErrUnexpectedEOF
- }
-
- var name []byte
- for len(s) > 0 && isTypeNameChar(s[0]) {
- name = append(name, s[0])
- s = s[1:]
- }
- s = consume(s, 0)
-
- var closed bool
- for len(s) > 0 && !closed {
- switch {
- case s[0] == ']':
- s = s[1:]
- closed = true
-
- case s[0] == '/', s[0] == '.':
- if len(name) > 0 && (name[len(name)-1] == '/' || name[len(name)-1] == '.') {
- return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
- d.orig[startPos:len(d.orig)-len(s)+1])
- }
- name = append(name, s[0])
- s = s[1:]
- s = consume(s, 0)
- for len(s) > 0 && isTypeNameChar(s[0]) {
- name = append(name, s[0])
- s = s[1:]
- }
- s = consume(s, 0)
-
- default:
- return Token{}, d.newSyntaxError(
- "invalid type URL/extension field name: %s", d.orig[startPos:len(d.orig)-len(s)+1])
- }
- }
-
- if !closed {
- return Token{}, ErrUnexpectedEOF
- }
-
- // First character cannot be '.'. Last character cannot be '.' or '/'.
- size := len(name)
- if size == 0 || name[0] == '.' || name[size-1] == '.' || name[size-1] == '/' {
- return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
- d.orig[startPos:len(d.orig)-len(s)])
- }
-
- d.in = s
- endPos := len(d.orig) - len(d.in)
- d.consume(0)
-
- return Token{
- kind: Name,
- attrs: uint8(TypeName),
- pos: startPos,
- raw: d.orig[startPos:endPos],
- str: string(name),
- }, nil
-}
-
-func isTypeNameChar(b byte) bool {
- return (b == '-' || b == '_' ||
- ('0' <= b && b <= '9') ||
- ('a' <= b && b <= 'z') ||
- ('A' <= b && b <= 'Z'))
-}
-
-func isWhiteSpace(b byte) bool {
- switch b {
- case ' ', '\n', '\r', '\t':
- return true
- default:
- return false
- }
-}
-
-// parseIdent parses an unquoted proto identifier and returns size.
-// If allowNeg is true, it allows '-' to be the first character in the
-// identifier. This is used when parsing literal values like -infinity, etc.
-// Regular expression matches an identifier: `^[_a-zA-Z][_a-zA-Z0-9]*`
-func parseIdent(input []byte, allowNeg bool) int {
- var size int
-
- s := input
- if len(s) == 0 {
- return 0
- }
-
- if allowNeg && s[0] == '-' {
- s = s[1:]
- size++
- if len(s) == 0 {
- return 0
- }
- }
-
- switch {
- case s[0] == '_',
- 'a' <= s[0] && s[0] <= 'z',
- 'A' <= s[0] && s[0] <= 'Z':
- s = s[1:]
- size++
- default:
- return 0
- }
-
- for len(s) > 0 && (s[0] == '_' ||
- 'a' <= s[0] && s[0] <= 'z' ||
- 'A' <= s[0] && s[0] <= 'Z' ||
- '0' <= s[0] && s[0] <= '9') {
- s = s[1:]
- size++
- }
-
- if len(s) > 0 && !isDelim(s[0]) {
- return 0
- }
-
- return size
-}
-
-// parseScalar parses for a string, literal or number value.
-func (d *Decoder) parseScalar() (Token, error) {
- if d.in[0] == '"' || d.in[0] == '\'' {
- return d.parseStringValue()
- }
-
- if tok, ok := d.parseLiteralValue(); ok {
- return tok, nil
- }
-
- if tok, ok := d.parseNumberValue(); ok {
- return tok, nil
- }
-
- return Token{}, d.newSyntaxError("invalid scalar value: %s", errRegexp.Find(d.in))
-}
-
-// parseLiteralValue parses a literal value. A literal value is used for
-// bools, special floats and enums. This function simply identifies that the
-// field value is a literal.
-func (d *Decoder) parseLiteralValue() (Token, bool) {
- size := parseIdent(d.in, true)
- if size == 0 {
- return Token{}, false
- }
- return d.consumeToken(Scalar, size, literalValue), true
-}
-
-// consumeToken constructs a Token for given Kind from d.in and consumes given
-// size-length from it.
-func (d *Decoder) consumeToken(kind Kind, size int, attrs uint8) Token {
- // Important to compute raw and pos before consuming.
- tok := Token{
- kind: kind,
- attrs: attrs,
- pos: len(d.orig) - len(d.in),
- raw: d.in[:size],
- }
- d.consume(size)
- return tok
-}
-
-// newSyntaxError returns a syntax error with line and column information for
-// current position.
-func (d *Decoder) newSyntaxError(f string, x ...interface{}) error {
- e := errors.New(f, x...)
- line, column := d.Position(len(d.orig) - len(d.in))
- return errors.New("syntax error (line %d:%d): %v", line, column, e)
-}
-
-// Position returns line and column number of given index of the original input.
-// It will panic if index is out of range.
-func (d *Decoder) Position(idx int) (line int, column int) {
- b := d.orig[:idx]
- line = bytes.Count(b, []byte("\n")) + 1
- if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
- b = b[i+1:]
- }
- column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
- return line, column
-}
-
-func (d *Decoder) tryConsumeChar(c byte) bool {
- if len(d.in) > 0 && d.in[0] == c {
- d.consume(1)
- return true
- }
- return false
-}
-
-// consume consumes n bytes of input and any subsequent whitespace or comments.
-func (d *Decoder) consume(n int) {
- d.in = consume(d.in, n)
- return
-}
-
-// consume consumes n bytes of input and any subsequent whitespace or comments.
-func consume(b []byte, n int) []byte {
- b = b[n:]
- for len(b) > 0 {
- switch b[0] {
- case ' ', '\n', '\r', '\t':
- b = b[1:]
- case '#':
- if i := bytes.IndexByte(b, '\n'); i >= 0 {
- b = b[i+len("\n"):]
- } else {
- b = nil
- }
- default:
- return b
- }
- }
- return b
-}
-
-// Any sequence that looks like a non-delimiter (for error reporting).
-var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9\/]+|.)`)
-
-// isDelim returns true if given byte is a delimiter character.
-func isDelim(c byte) bool {
- return !(c == '-' || c == '+' || c == '.' || c == '_' ||
- ('a' <= c && c <= 'z') ||
- ('A' <= c && c <= 'Z') ||
- ('0' <= c && c <= '9'))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go
deleted file mode 100644
index f2d90b7..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-// parseNumberValue parses a number from the input and returns a Token object.
-func (d *Decoder) parseNumberValue() (Token, bool) {
- in := d.in
- num := parseNumber(in)
- if num.size == 0 {
- return Token{}, false
- }
- numAttrs := num.kind
- if num.neg {
- numAttrs |= isNegative
- }
- strSize := num.size
- last := num.size - 1
- if num.kind == numFloat && (d.in[last] == 'f' || d.in[last] == 'F') {
- strSize = last
- }
- tok := Token{
- kind: Scalar,
- attrs: numberValue,
- pos: len(d.orig) - len(d.in),
- raw: d.in[:num.size],
- str: string(d.in[:strSize]),
- numAttrs: numAttrs,
- }
- d.consume(num.size)
- return tok, true
-}
-
-const (
- numDec uint8 = (1 << iota) / 2
- numHex
- numOct
- numFloat
-)
-
-// number is the result of parsing out a valid number from parseNumber. It
-// contains data for doing float or integer conversion via the strconv package
-// in conjunction with the input bytes.
-type number struct {
- kind uint8
- neg bool
- size int
-}
-
-// parseNumber constructs a number object from given input. It allows for the
-// following patterns:
-// integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*)
-// float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?)
-// It also returns the number of parsed bytes for the given number, 0 if it is
-// not a number.
-func parseNumber(input []byte) number {
- kind := numDec
- var size int
- var neg bool
-
- s := input
- if len(s) == 0 {
- return number{}
- }
-
- // Optional -
- if s[0] == '-' {
- neg = true
- s = s[1:]
- size++
- if len(s) == 0 {
- return number{}
- }
- }
-
- // C++ allows for whitespace and comments in between the negative sign and
- // the rest of the number. This logic currently does not but is consistent
- // with v1.
-
- switch {
- case s[0] == '0':
- if len(s) > 1 {
- switch {
- case s[1] == 'x' || s[1] == 'X':
- // Parse as hex number.
- kind = numHex
- n := 2
- s = s[2:]
- for len(s) > 0 && (('0' <= s[0] && s[0] <= '9') ||
- ('a' <= s[0] && s[0] <= 'f') ||
- ('A' <= s[0] && s[0] <= 'F')) {
- s = s[1:]
- n++
- }
- if n == 2 {
- return number{}
- }
- size += n
-
- case '0' <= s[1] && s[1] <= '7':
- // Parse as octal number.
- kind = numOct
- n := 2
- s = s[2:]
- for len(s) > 0 && '0' <= s[0] && s[0] <= '7' {
- s = s[1:]
- n++
- }
- size += n
- }
-
- if kind&(numHex|numOct) > 0 {
- if len(s) > 0 && !isDelim(s[0]) {
- return number{}
- }
- return number{kind: kind, neg: neg, size: size}
- }
- }
- s = s[1:]
- size++
-
- case '1' <= s[0] && s[0] <= '9':
- n := 1
- s = s[1:]
- for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
- s = s[1:]
- n++
- }
- size += n
-
- case s[0] == '.':
- // Set kind to numFloat to signify the intent to parse as float. And
- // that it needs to have other digits after '.'.
- kind = numFloat
-
- default:
- return number{}
- }
-
- // . followed by 0 or more digits.
- if len(s) > 0 && s[0] == '.' {
- n := 1
- s = s[1:]
- // If decimal point was before any digits, it should be followed by
- // other digits.
- if len(s) == 0 && kind == numFloat {
- return number{}
- }
- for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
- s = s[1:]
- n++
- }
- size += n
- kind = numFloat
- }
-
- // e or E followed by an optional - or + and 1 or more digits.
- if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
- kind = numFloat
- s = s[1:]
- n := 1
- if s[0] == '+' || s[0] == '-' {
- s = s[1:]
- n++
- if len(s) == 0 {
- return number{}
- }
- }
- for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
- s = s[1:]
- n++
- }
- size += n
- }
-
- // Optional suffix f or F for floats.
- if len(s) > 0 && (s[0] == 'f' || s[0] == 'F') {
- kind = numFloat
- s = s[1:]
- size++
- }
-
- // Check that next byte is a delimiter or it is at the end.
- if len(s) > 0 && !isDelim(s[0]) {
- return number{}
- }
-
- return number{kind: kind, neg: neg, size: size}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go
deleted file mode 100644
index d4d3490..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
- "bytes"
- "strconv"
- "strings"
- "unicode"
- "unicode/utf16"
- "unicode/utf8"
-
- "google.golang.org/protobuf/internal/strs"
-)
-
-// parseStringValue parses string field token.
-// This differs from parseString since the text format allows
-// multiple back-to-back string literals where they are semantically treated
-// as a single large string with all values concatenated.
-//
-// E.g., `"foo" "bar" "baz"` => "foobarbaz"
-func (d *Decoder) parseStringValue() (Token, error) {
- // Note that the ending quote is sufficient to unambiguously mark the end
- // of a string. Thus, the text grammar does not require intervening
- // whitespace or control characters in-between strings.
- // Thus, the following is valid:
- // `"foo"'bar'"baz"` => "foobarbaz"
- in0 := d.in
- var ss []string
- for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
- s, err := d.parseString()
- if err != nil {
- return Token{}, err
- }
- ss = append(ss, s)
- }
- // d.in already points to the end of the value at this point.
- return Token{
- kind: Scalar,
- attrs: stringValue,
- pos: len(d.orig) - len(in0),
- raw: in0[:len(in0)-len(d.in)],
- str: strings.Join(ss, ""),
- }, nil
-}
-
-// parseString parses a string value enclosed in " or '.
-func (d *Decoder) parseString() (string, error) {
- in := d.in
- if len(in) == 0 {
- return "", ErrUnexpectedEOF
- }
- quote := in[0]
- in = in[1:]
- i := indexNeedEscapeInBytes(in)
- in, out := in[i:], in[:i:i] // set cap to prevent mutations
- for len(in) > 0 {
- switch r, n := utf8.DecodeRune(in); {
- case r == utf8.RuneError && n == 1:
- return "", d.newSyntaxError("invalid UTF-8 detected")
- case r == 0 || r == '\n':
- return "", d.newSyntaxError("invalid character %q in string", r)
- case r == rune(quote):
- in = in[1:]
- d.consume(len(d.in) - len(in))
- return string(out), nil
- case r == '\\':
- if len(in) < 2 {
- return "", ErrUnexpectedEOF
- }
- switch r := in[1]; r {
- case '"', '\'', '\\', '?':
- in, out = in[2:], append(out, r)
- case 'a':
- in, out = in[2:], append(out, '\a')
- case 'b':
- in, out = in[2:], append(out, '\b')
- case 'n':
- in, out = in[2:], append(out, '\n')
- case 'r':
- in, out = in[2:], append(out, '\r')
- case 't':
- in, out = in[2:], append(out, '\t')
- case 'v':
- in, out = in[2:], append(out, '\v')
- case 'f':
- in, out = in[2:], append(out, '\f')
- case '0', '1', '2', '3', '4', '5', '6', '7':
- // One, two, or three octal characters.
- n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
- if n > 3 {
- n = 3
- }
- v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
- if err != nil {
- return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
- }
- in, out = in[1+n:], append(out, byte(v))
- case 'x':
- // One or two hexadecimal characters.
- n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
- if n > 2 {
- n = 2
- }
- v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
- if err != nil {
- return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
- }
- in, out = in[2+n:], append(out, byte(v))
- case 'u', 'U':
- // Four or eight hexadecimal characters
- n := 6
- if r == 'U' {
- n = 10
- }
- if len(in) < n {
- return "", ErrUnexpectedEOF
- }
- v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
- if utf8.MaxRune < v || err != nil {
- return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
- }
- in = in[n:]
-
- r := rune(v)
- if utf16.IsSurrogate(r) {
- if len(in) < 6 {
- return "", ErrUnexpectedEOF
- }
- v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
- r = utf16.DecodeRune(r, rune(v))
- if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
- return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
- }
- in = in[6:]
- }
- out = append(out, string(r)...)
- default:
- return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
- }
- default:
- i := indexNeedEscapeInBytes(in[n:])
- in, out = in[n+i:], append(out, in[:n+i]...)
- }
- }
- return "", ErrUnexpectedEOF
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
-
-// UnmarshalString returns an unescaped string given a textproto string value.
-// String value needs to contain single or double quotes. This is only used by
-// internal/encoding/defval package for unmarshaling bytes.
-func UnmarshalString(s string) (string, error) {
- d := NewDecoder([]byte(s))
- return d.parseString()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go
deleted file mode 100644
index 83d2b0d..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go
+++ /dev/null
@@ -1,373 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
- "bytes"
- "fmt"
- "math"
- "strconv"
- "strings"
-
- "google.golang.org/protobuf/internal/flags"
-)
-
-// Kind represents a token kind expressible in the textproto format.
-type Kind uint8
-
-// Kind values.
-const (
- Invalid Kind = iota
- EOF
- Name // Name indicates the field name.
- Scalar // Scalar are scalar values, e.g. "string", 47, ENUM_LITERAL, true.
- MessageOpen
- MessageClose
- ListOpen
- ListClose
-
- // comma and semi-colon are only for parsing in between values and should not be exposed.
- comma
- semicolon
-
- // bof indicates beginning of file, which is the default token
- // kind at the beginning of parsing.
- bof = Invalid
-)
-
-func (t Kind) String() string {
- switch t {
- case Invalid:
- return "<invalid>"
- case EOF:
- return "eof"
- case Scalar:
- return "scalar"
- case Name:
- return "name"
- case MessageOpen:
- return "{"
- case MessageClose:
- return "}"
- case ListOpen:
- return "["
- case ListClose:
- return "]"
- case comma:
- return ","
- case semicolon:
- return ";"
- default:
- return fmt.Sprintf("<invalid:%v>", uint8(t))
- }
-}
-
-// NameKind represents different types of field names.
-type NameKind uint8
-
-// NameKind values.
-const (
- IdentName NameKind = iota + 1
- TypeName
- FieldNumber
-)
-
-func (t NameKind) String() string {
- switch t {
- case IdentName:
- return "IdentName"
- case TypeName:
- return "TypeName"
- case FieldNumber:
- return "FieldNumber"
- default:
- return fmt.Sprintf("<invalid:%v>", uint8(t))
- }
-}
-
-// Bit mask in Token.attrs to indicate if a Name token is followed by the
-// separator char ':'. The field name separator char is optional for message
-// field or repeated message field, but required for all other types. Decoder
-// simply indicates whether a Name token is followed by separator or not. It is
-// up to the prototext package to validate.
-const hasSeparator = 1 << 7
-
-// Scalar value types.
-const (
- numberValue = iota + 1
- stringValue
- literalValue
-)
-
-// Bit mask in Token.numAttrs to indicate that the number is a negative.
-const isNegative = 1 << 7
-
-// Token provides a parsed token kind and value. Values are provided by the
-// different accessor methods.
-type Token struct {
- // Kind of the Token object.
- kind Kind
- // attrs contains metadata for the following Kinds:
- // Name: hasSeparator bit and one of NameKind.
- // Scalar: one of numberValue, stringValue, literalValue.
- attrs uint8
- // numAttrs contains metadata for numberValue:
- // - highest bit is whether negative or positive.
- // - lower bits indicate one of numDec, numHex, numOct, numFloat.
- numAttrs uint8
- // pos provides the position of the token in the original input.
- pos int
- // raw bytes of the serialized token.
- // This is a subslice into the original input.
- raw []byte
- // str contains parsed string for the following:
- // - stringValue of Scalar kind
- // - numberValue of Scalar kind
- // - TypeName of Name kind
- str string
-}
-
-// Kind returns the token kind.
-func (t Token) Kind() Kind {
- return t.kind
-}
-
-// RawString returns the read value in string.
-func (t Token) RawString() string {
- return string(t.raw)
-}
-
-// Pos returns the token position from the input.
-func (t Token) Pos() int {
- return t.pos
-}
-
-// NameKind returns IdentName, TypeName or FieldNumber.
-// It panics if type is not Name.
-func (t Token) NameKind() NameKind {
- if t.kind == Name {
- return NameKind(t.attrs &^ hasSeparator)
- }
- panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
-}
-
-// HasSeparator returns true if the field name is followed by the separator char
-// ':', else false. It panics if type is not Name.
-func (t Token) HasSeparator() bool {
- if t.kind == Name {
- return t.attrs&hasSeparator != 0
- }
- panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
-}
-
-// IdentName returns the value for IdentName type.
-func (t Token) IdentName() string {
- if t.kind == Name && t.attrs&uint8(IdentName) != 0 {
- return string(t.raw)
- }
- panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-}
-
-// TypeName returns the value for TypeName type.
-func (t Token) TypeName() string {
- if t.kind == Name && t.attrs&uint8(TypeName) != 0 {
- return t.str
- }
- panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-}
-
-// FieldNumber returns the value for FieldNumber type. It returns a
-// non-negative int32 value. Caller will still need to validate for the correct
-// field number range.
-func (t Token) FieldNumber() int32 {
- if t.kind != Name || t.attrs&uint8(FieldNumber) == 0 {
- panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
- }
- // Following should not return an error as it had already been called right
- // before this Token was constructed.
- num, _ := strconv.ParseInt(string(t.raw), 10, 32)
- return int32(num)
-}
-
-// String returns the string value for a Scalar type.
-func (t Token) String() (string, bool) {
- if t.kind != Scalar || t.attrs != stringValue {
- return "", false
- }
- return t.str, true
-}
-
-// Enum returns the literal value for a Scalar type for use as enum literals.
-func (t Token) Enum() (string, bool) {
- if t.kind != Scalar || t.attrs != literalValue || (len(t.raw) > 0 && t.raw[0] == '-') {
- return "", false
- }
- return string(t.raw), true
-}
-
-// Bool returns the bool value for a Scalar type.
-func (t Token) Bool() (bool, bool) {
- if t.kind != Scalar {
- return false, false
- }
- switch t.attrs {
- case literalValue:
- if b, ok := boolLits[string(t.raw)]; ok {
- return b, true
- }
- case numberValue:
- // Unsigned integer representation of 0 or 1 is permitted: 00, 0x0, 01,
- // 0x1, etc.
- n, err := strconv.ParseUint(t.str, 0, 64)
- if err == nil {
- switch n {
- case 0:
- return false, true
- case 1:
- return true, true
- }
- }
- }
- return false, false
-}
-
-// These exact boolean literals are the ones supported in C++.
-var boolLits = map[string]bool{
- "t": true,
- "true": true,
- "True": true,
- "f": false,
- "false": false,
- "False": false,
-}
-
-// Uint64 returns the uint64 value for a Scalar type.
-func (t Token) Uint64() (uint64, bool) {
- if t.kind != Scalar || t.attrs != numberValue ||
- t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
- return 0, false
- }
- n, err := strconv.ParseUint(t.str, 0, 64)
- if err != nil {
- return 0, false
- }
- return n, true
-}
-
-// Uint32 returns the uint32 value for a Scalar type.
-func (t Token) Uint32() (uint32, bool) {
- if t.kind != Scalar || t.attrs != numberValue ||
- t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
- return 0, false
- }
- n, err := strconv.ParseUint(t.str, 0, 32)
- if err != nil {
- return 0, false
- }
- return uint32(n), true
-}
-
-// Int64 returns the int64 value for a Scalar type.
-func (t Token) Int64() (int64, bool) {
- if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
- return 0, false
- }
- if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {
- return n, true
- }
- // C++ accepts large positive hex numbers as negative values.
- // This feature is here for proto1 backwards compatibility purposes.
- if flags.ProtoLegacy && (t.numAttrs == numHex) {
- if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {
- return int64(n), true
- }
- }
- return 0, false
-}
-
-// Int32 returns the int32 value for a Scalar type.
-func (t Token) Int32() (int32, bool) {
- if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
- return 0, false
- }
- if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {
- return int32(n), true
- }
- // C++ accepts large positive hex numbers as negative values.
- // This feature is here for proto1 backwards compatibility purposes.
- if flags.ProtoLegacy && (t.numAttrs == numHex) {
- if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {
- return int32(n), true
- }
- }
- return 0, false
-}
-
-// Float64 returns the float64 value for a Scalar type.
-func (t Token) Float64() (float64, bool) {
- if t.kind != Scalar {
- return 0, false
- }
- switch t.attrs {
- case literalValue:
- if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
- return f, true
- }
- case numberValue:
- n, err := strconv.ParseFloat(t.str, 64)
- if err == nil {
- return n, true
- }
- nerr := err.(*strconv.NumError)
- if nerr.Err == strconv.ErrRange {
- return n, true
- }
- }
- return 0, false
-}
-
-// Float32 returns the float32 value for a Scalar type.
-func (t Token) Float32() (float32, bool) {
- if t.kind != Scalar {
- return 0, false
- }
- switch t.attrs {
- case literalValue:
- if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
- return float32(f), true
- }
- case numberValue:
- n, err := strconv.ParseFloat(t.str, 64)
- if err == nil {
- // Overflows are treated as (-)infinity.
- return float32(n), true
- }
- nerr := err.(*strconv.NumError)
- if nerr.Err == strconv.ErrRange {
- return float32(n), true
- }
- }
- return 0, false
-}
-
-// These are the supported float literals which C++ permits case-insensitive
-// variants of these.
-var floatLits = map[string]float64{
- "nan": math.NaN(),
- "inf": math.Inf(1),
- "infinity": math.Inf(1),
- "-inf": math.Inf(-1),
- "-infinity": math.Inf(-1),
-}
-
-// TokenEquals returns true if given Tokens are equal, else false.
-func TokenEquals(x, y Token) bool {
- return x.kind == y.kind &&
- x.attrs == y.attrs &&
- x.numAttrs == y.numAttrs &&
- x.pos == y.pos &&
- bytes.Equal(x.raw, y.raw) &&
- x.str == y.str
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go b/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go
deleted file mode 100644
index 0ce8d6f..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package text implements the text format for protocol buffers.
-// This package has no semantic understanding for protocol buffers and is only
-// a parser and composer for the format.
-//
-// There is no formal specification for the protobuf text format, as such the
-// C++ implementation (see google::protobuf::TextFormat) is the reference
-// implementation of the text format.
-//
-// This package is neither a superset nor a subset of the C++ implementation.
-// This implementation permits a more liberal grammar in some cases to be
-// backwards compatible with the historical Go implementation.
-// Future parsings unique to Go should not be added.
-// Some grammars allowed by the C++ implementation are deliberately
-// not implemented here because they are considered a bug by the protobuf team
-// and should not be replicated.
-//
-// The Go implementation should implement a sufficient amount of the C++
-// grammar such that the default text serialization by C++ can be parsed by Go.
-// However, just because the C++ parser accepts some input does not mean that
-// the Go implementation should as well.
-//
-// The text format is almost a superset of JSON except:
-// * message keys are not quoted strings, but identifiers
-// * the top-level value must be a message without the delimiters
-package text
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go b/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go
deleted file mode 100644
index c4ba1c5..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go
+++ /dev/null
@@ -1,267 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
- "math"
- "math/bits"
- "strconv"
- "strings"
- "unicode/utf8"
-
- "google.golang.org/protobuf/internal/detrand"
- "google.golang.org/protobuf/internal/errors"
-)
-
-// encType represents an encoding type.
-type encType uint8
-
-const (
- _ encType = (1 << iota) / 2
- name
- scalar
- messageOpen
- messageClose
-)
-
-// Encoder provides methods to write out textproto constructs and values. The user is
-// responsible for producing valid sequences of constructs and values.
-type Encoder struct {
- encoderState
-
- indent string
- newline string // set to "\n" if len(indent) > 0
- delims [2]byte
- outputASCII bool
-}
-
-type encoderState struct {
- lastType encType
- indents []byte
- out []byte
-}
-
-// NewEncoder returns an Encoder.
-//
-// If indent is a non-empty string, it causes every entry in a List or Message
-// to be preceded by the indent and trailed by a newline.
-//
-// If delims is not the zero value, it controls the delimiter characters used
-// for messages (e.g., "{}" vs "<>").
-//
-// If outputASCII is true, strings will be serialized in such a way that
-// multi-byte UTF-8 sequences are escaped. This property ensures that the
-// overall output is ASCII (as opposed to UTF-8).
-func NewEncoder(indent string, delims [2]byte, outputASCII bool) (*Encoder, error) {
- e := &Encoder{}
- if len(indent) > 0 {
- if strings.Trim(indent, " \t") != "" {
- return nil, errors.New("indent may only be composed of space and tab characters")
- }
- e.indent = indent
- e.newline = "\n"
- }
- switch delims {
- case [2]byte{0, 0}:
- e.delims = [2]byte{'{', '}'}
- case [2]byte{'{', '}'}, [2]byte{'<', '>'}:
- e.delims = delims
- default:
- return nil, errors.New("delimiters may only be \"{}\" or \"<>\"")
- }
- e.outputASCII = outputASCII
-
- return e, nil
-}
-
-// Bytes returns the content of the written bytes.
-func (e *Encoder) Bytes() []byte {
- return e.out
-}
-
-// StartMessage writes out the '{' or '<' symbol.
-func (e *Encoder) StartMessage() {
- e.prepareNext(messageOpen)
- e.out = append(e.out, e.delims[0])
-}
-
-// EndMessage writes out the '}' or '>' symbol.
-func (e *Encoder) EndMessage() {
- e.prepareNext(messageClose)
- e.out = append(e.out, e.delims[1])
-}
-
-// WriteName writes out the field name and the separator ':'.
-func (e *Encoder) WriteName(s string) {
- e.prepareNext(name)
- e.out = append(e.out, s...)
- e.out = append(e.out, ':')
-}
-
-// WriteBool writes out the given boolean value.
-func (e *Encoder) WriteBool(b bool) {
- if b {
- e.WriteLiteral("true")
- } else {
- e.WriteLiteral("false")
- }
-}
-
-// WriteString writes out the given string value.
-func (e *Encoder) WriteString(s string) {
- e.prepareNext(scalar)
- e.out = appendString(e.out, s, e.outputASCII)
-}
-
-func appendString(out []byte, in string, outputASCII bool) []byte {
- out = append(out, '"')
- i := indexNeedEscapeInString(in)
- in, out = in[i:], append(out, in[:i]...)
- for len(in) > 0 {
- switch r, n := utf8.DecodeRuneInString(in); {
- case r == utf8.RuneError && n == 1:
- // We do not report invalid UTF-8 because strings in the text format
- // are used to represent both the proto string and bytes type.
- r = rune(in[0])
- fallthrough
- case r < ' ' || r == '"' || r == '\\':
- out = append(out, '\\')
- switch r {
- case '"', '\\':
- out = append(out, byte(r))
- case '\n':
- out = append(out, 'n')
- case '\r':
- out = append(out, 'r')
- case '\t':
- out = append(out, 't')
- default:
- out = append(out, 'x')
- out = append(out, "00"[1+(bits.Len32(uint32(r))-1)/4:]...)
- out = strconv.AppendUint(out, uint64(r), 16)
- }
- in = in[n:]
- case outputASCII && r >= utf8.RuneSelf:
- out = append(out, '\\')
- if r <= math.MaxUint16 {
- out = append(out, 'u')
- out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
- out = strconv.AppendUint(out, uint64(r), 16)
- } else {
- out = append(out, 'U')
- out = append(out, "00000000"[1+(bits.Len32(uint32(r))-1)/4:]...)
- out = strconv.AppendUint(out, uint64(r), 16)
- }
- in = in[n:]
- default:
- i := indexNeedEscapeInString(in[n:])
- in, out = in[n+i:], append(out, in[:n+i]...)
- }
- }
- out = append(out, '"')
- return out
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInString(s string) int {
- for i := 0; i < len(s); i++ {
- if c := s[i]; c < ' ' || c == '"' || c == '\'' || c == '\\' || c >= utf8.RuneSelf {
- return i
- }
- }
- return len(s)
-}
-
-// WriteFloat writes out the given float value for given bitSize.
-func (e *Encoder) WriteFloat(n float64, bitSize int) {
- e.prepareNext(scalar)
- e.out = appendFloat(e.out, n, bitSize)
-}
-
-func appendFloat(out []byte, n float64, bitSize int) []byte {
- switch {
- case math.IsNaN(n):
- return append(out, "nan"...)
- case math.IsInf(n, +1):
- return append(out, "inf"...)
- case math.IsInf(n, -1):
- return append(out, "-inf"...)
- default:
- return strconv.AppendFloat(out, n, 'g', -1, bitSize)
- }
-}
-
-// WriteInt writes out the given signed integer value.
-func (e *Encoder) WriteInt(n int64) {
- e.prepareNext(scalar)
- e.out = append(e.out, strconv.FormatInt(n, 10)...)
-}
-
-// WriteUint writes out the given unsigned integer value.
-func (e *Encoder) WriteUint(n uint64) {
- e.prepareNext(scalar)
- e.out = append(e.out, strconv.FormatUint(n, 10)...)
-}
-
-// WriteLiteral writes out the given string as a literal value without quotes.
-// This is used for writing enum literal strings.
-func (e *Encoder) WriteLiteral(s string) {
- e.prepareNext(scalar)
- e.out = append(e.out, s...)
-}
-
-// prepareNext adds possible space and indentation for the next value based
-// on last encType and indent option. It also updates e.lastType to next.
-func (e *Encoder) prepareNext(next encType) {
- defer func() {
- e.lastType = next
- }()
-
- // Single line.
- if len(e.indent) == 0 {
- // Add space after each field before the next one.
- if e.lastType&(scalar|messageClose) != 0 && next == name {
- e.out = append(e.out, ' ')
- // Add a random extra space to make output unstable.
- if detrand.Bool() {
- e.out = append(e.out, ' ')
- }
- }
- return
- }
-
- // Multi-line.
- switch {
- case e.lastType == name:
- e.out = append(e.out, ' ')
- // Add a random extra space after name: to make output unstable.
- if detrand.Bool() {
- e.out = append(e.out, ' ')
- }
-
- case e.lastType == messageOpen && next != messageClose:
- e.indents = append(e.indents, e.indent...)
- e.out = append(e.out, '\n')
- e.out = append(e.out, e.indents...)
-
- case e.lastType&(scalar|messageClose) != 0:
- if next == messageClose {
- e.indents = e.indents[:len(e.indents)-len(e.indent)]
- }
- e.out = append(e.out, '\n')
- e.out = append(e.out, e.indents...)
- }
-}
-
-// Snapshot returns the current snapshot for use in Reset.
-func (e *Encoder) Snapshot() encoderState {
- return e.encoderState
-}
-
-// Reset resets the Encoder to the given encoderState from a Snapshot.
-func (e *Encoder) Reset(es encoderState) {
- e.encoderState = es
-}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/errors.go b/vendor/google.golang.org/protobuf/internal/errors/errors.go
deleted file mode 100644
index 20c17b3..0000000
--- a/vendor/google.golang.org/protobuf/internal/errors/errors.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package errors implements functions to manipulate errors.
-package errors
-
-import (
- "errors"
- "fmt"
-
- "google.golang.org/protobuf/internal/detrand"
-)
-
-// Error is a sentinel matching all errors produced by this package.
-var Error = errors.New("protobuf error")
-
-// New formats a string according to the format specifier and arguments and
-// returns an error that has a "proto" prefix.
-func New(f string, x ...interface{}) error {
- return &prefixError{s: format(f, x...)}
-}
-
-type prefixError struct{ s string }
-
-var prefix = func() string {
- // Deliberately introduce instability into the error message string to
- // discourage users from performing error string comparisons.
- if detrand.Bool() {
- return "proto: " // use non-breaking spaces (U+00a0)
- } else {
- return "proto: " // use regular spaces (U+0020)
- }
-}()
-
-func (e *prefixError) Error() string {
- return prefix + e.s
-}
-
-func (e *prefixError) Unwrap() error {
- return Error
-}
-
-// Wrap returns an error that has a "proto" prefix, the formatted string described
-// by the format specifier and arguments, and a suffix of err. The error wraps err.
-func Wrap(err error, f string, x ...interface{}) error {
- return &wrapError{
- s: format(f, x...),
- err: err,
- }
-}
-
-type wrapError struct {
- s string
- err error
-}
-
-func (e *wrapError) Error() string {
- return format("%v%v: %v", prefix, e.s, e.err)
-}
-
-func (e *wrapError) Unwrap() error {
- return e.err
-}
-
-func (e *wrapError) Is(target error) bool {
- return target == Error
-}
-
-func format(f string, x ...interface{}) string {
- // avoid "proto: " prefix when chaining
- for i := 0; i < len(x); i++ {
- switch e := x[i].(type) {
- case *prefixError:
- x[i] = e.s
- case *wrapError:
- x[i] = format("%v: %v", e.s, e.err)
- }
- }
- return fmt.Sprintf(f, x...)
-}
-
-func InvalidUTF8(name string) error {
- return New("field %v contains invalid UTF-8", name)
-}
-
-func RequiredNotSet(name string) error {
- return New("required field %v not set", name)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/is_go112.go b/vendor/google.golang.org/protobuf/internal/errors/is_go112.go
deleted file mode 100644
index f90e909..0000000
--- a/vendor/google.golang.org/protobuf/internal/errors/is_go112.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.13
-
-package errors
-
-import "reflect"
-
-// Is is a copy of Go 1.13's errors.Is for use with older Go versions.
-func Is(err, target error) bool {
- if target == nil {
- return err == target
- }
-
- isComparable := reflect.TypeOf(target).Comparable()
- for {
- if isComparable && err == target {
- return true
- }
- if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
- return true
- }
- if err = unwrap(err); err == nil {
- return false
- }
- }
-}
-
-func unwrap(err error) error {
- u, ok := err.(interface {
- Unwrap() error
- })
- if !ok {
- return nil
- }
- return u.Unwrap()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/is_go113.go b/vendor/google.golang.org/protobuf/internal/errors/is_go113.go
deleted file mode 100644
index dc05f41..0000000
--- a/vendor/google.golang.org/protobuf/internal/errors/is_go113.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.13
-
-package errors
-
-import "errors"
-
-// Is is errors.Is.
-func Is(err, target error) bool { return errors.Is(err, target) }
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go
deleted file mode 100644
index 74c5fef..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Any.
-const (
- Any_TypeUrl = 1 // optional string
- Any_Value = 2 // optional bytes
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go
deleted file mode 100644
index 9a6b5f2..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Api.
-const (
- Api_Name = 1 // optional string
- Api_Methods = 2 // repeated google.protobuf.Method
- Api_Options = 3 // repeated google.protobuf.Option
- Api_Version = 4 // optional string
- Api_SourceContext = 5 // optional google.protobuf.SourceContext
- Api_Mixins = 6 // repeated google.protobuf.Mixin
- Api_Syntax = 7 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.Method.
-const (
- Method_Name = 1 // optional string
- Method_RequestTypeUrl = 2 // optional string
- Method_RequestStreaming = 3 // optional bool
- Method_ResponseTypeUrl = 4 // optional string
- Method_ResponseStreaming = 5 // optional bool
- Method_Options = 6 // repeated google.protobuf.Option
- Method_Syntax = 7 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.Mixin.
-const (
- Mixin_Name = 1 // optional string
- Mixin_Root = 2 // optional string
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go
deleted file mode 100644
index 6e37b59..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.FileDescriptorSet.
-const (
- FileDescriptorSet_File = 1 // repeated google.protobuf.FileDescriptorProto
-)
-
-// Field numbers for google.protobuf.FileDescriptorProto.
-const (
- FileDescriptorProto_Name = 1 // optional string
- FileDescriptorProto_Package = 2 // optional string
- FileDescriptorProto_Dependency = 3 // repeated string
- FileDescriptorProto_PublicDependency = 10 // repeated int32
- FileDescriptorProto_WeakDependency = 11 // repeated int32
- FileDescriptorProto_MessageType = 4 // repeated google.protobuf.DescriptorProto
- FileDescriptorProto_EnumType = 5 // repeated google.protobuf.EnumDescriptorProto
- FileDescriptorProto_Service = 6 // repeated google.protobuf.ServiceDescriptorProto
- FileDescriptorProto_Extension = 7 // repeated google.protobuf.FieldDescriptorProto
- FileDescriptorProto_Options = 8 // optional google.protobuf.FileOptions
- FileDescriptorProto_SourceCodeInfo = 9 // optional google.protobuf.SourceCodeInfo
- FileDescriptorProto_Syntax = 12 // optional string
-)
-
-// Field numbers for google.protobuf.DescriptorProto.
-const (
- DescriptorProto_Name = 1 // optional string
- DescriptorProto_Field = 2 // repeated google.protobuf.FieldDescriptorProto
- DescriptorProto_Extension = 6 // repeated google.protobuf.FieldDescriptorProto
- DescriptorProto_NestedType = 3 // repeated google.protobuf.DescriptorProto
- DescriptorProto_EnumType = 4 // repeated google.protobuf.EnumDescriptorProto
- DescriptorProto_ExtensionRange = 5 // repeated google.protobuf.DescriptorProto.ExtensionRange
- DescriptorProto_OneofDecl = 8 // repeated google.protobuf.OneofDescriptorProto
- DescriptorProto_Options = 7 // optional google.protobuf.MessageOptions
- DescriptorProto_ReservedRange = 9 // repeated google.protobuf.DescriptorProto.ReservedRange
- DescriptorProto_ReservedName = 10 // repeated string
-)
-
-// Field numbers for google.protobuf.DescriptorProto.ExtensionRange.
-const (
- DescriptorProto_ExtensionRange_Start = 1 // optional int32
- DescriptorProto_ExtensionRange_End = 2 // optional int32
- DescriptorProto_ExtensionRange_Options = 3 // optional google.protobuf.ExtensionRangeOptions
-)
-
-// Field numbers for google.protobuf.DescriptorProto.ReservedRange.
-const (
- DescriptorProto_ReservedRange_Start = 1 // optional int32
- DescriptorProto_ReservedRange_End = 2 // optional int32
-)
-
-// Field numbers for google.protobuf.ExtensionRangeOptions.
-const (
- ExtensionRangeOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.FieldDescriptorProto.
-const (
- FieldDescriptorProto_Name = 1 // optional string
- FieldDescriptorProto_Number = 3 // optional int32
- FieldDescriptorProto_Label = 4 // optional google.protobuf.FieldDescriptorProto.Label
- FieldDescriptorProto_Type = 5 // optional google.protobuf.FieldDescriptorProto.Type
- FieldDescriptorProto_TypeName = 6 // optional string
- FieldDescriptorProto_Extendee = 2 // optional string
- FieldDescriptorProto_DefaultValue = 7 // optional string
- FieldDescriptorProto_OneofIndex = 9 // optional int32
- FieldDescriptorProto_JsonName = 10 // optional string
- FieldDescriptorProto_Options = 8 // optional google.protobuf.FieldOptions
- FieldDescriptorProto_Proto3Optional = 17 // optional bool
-)
-
-// Field numbers for google.protobuf.OneofDescriptorProto.
-const (
- OneofDescriptorProto_Name = 1 // optional string
- OneofDescriptorProto_Options = 2 // optional google.protobuf.OneofOptions
-)
-
-// Field numbers for google.protobuf.EnumDescriptorProto.
-const (
- EnumDescriptorProto_Name = 1 // optional string
- EnumDescriptorProto_Value = 2 // repeated google.protobuf.EnumValueDescriptorProto
- EnumDescriptorProto_Options = 3 // optional google.protobuf.EnumOptions
- EnumDescriptorProto_ReservedRange = 4 // repeated google.protobuf.EnumDescriptorProto.EnumReservedRange
- EnumDescriptorProto_ReservedName = 5 // repeated string
-)
-
-// Field numbers for google.protobuf.EnumDescriptorProto.EnumReservedRange.
-const (
- EnumDescriptorProto_EnumReservedRange_Start = 1 // optional int32
- EnumDescriptorProto_EnumReservedRange_End = 2 // optional int32
-)
-
-// Field numbers for google.protobuf.EnumValueDescriptorProto.
-const (
- EnumValueDescriptorProto_Name = 1 // optional string
- EnumValueDescriptorProto_Number = 2 // optional int32
- EnumValueDescriptorProto_Options = 3 // optional google.protobuf.EnumValueOptions
-)
-
-// Field numbers for google.protobuf.ServiceDescriptorProto.
-const (
- ServiceDescriptorProto_Name = 1 // optional string
- ServiceDescriptorProto_Method = 2 // repeated google.protobuf.MethodDescriptorProto
- ServiceDescriptorProto_Options = 3 // optional google.protobuf.ServiceOptions
-)
-
-// Field numbers for google.protobuf.MethodDescriptorProto.
-const (
- MethodDescriptorProto_Name = 1 // optional string
- MethodDescriptorProto_InputType = 2 // optional string
- MethodDescriptorProto_OutputType = 3 // optional string
- MethodDescriptorProto_Options = 4 // optional google.protobuf.MethodOptions
- MethodDescriptorProto_ClientStreaming = 5 // optional bool
- MethodDescriptorProto_ServerStreaming = 6 // optional bool
-)
-
-// Field numbers for google.protobuf.FileOptions.
-const (
- FileOptions_JavaPackage = 1 // optional string
- FileOptions_JavaOuterClassname = 8 // optional string
- FileOptions_JavaMultipleFiles = 10 // optional bool
- FileOptions_JavaGenerateEqualsAndHash = 20 // optional bool
- FileOptions_JavaStringCheckUtf8 = 27 // optional bool
- FileOptions_OptimizeFor = 9 // optional google.protobuf.FileOptions.OptimizeMode
- FileOptions_GoPackage = 11 // optional string
- FileOptions_CcGenericServices = 16 // optional bool
- FileOptions_JavaGenericServices = 17 // optional bool
- FileOptions_PyGenericServices = 18 // optional bool
- FileOptions_PhpGenericServices = 42 // optional bool
- FileOptions_Deprecated = 23 // optional bool
- FileOptions_CcEnableArenas = 31 // optional bool
- FileOptions_ObjcClassPrefix = 36 // optional string
- FileOptions_CsharpNamespace = 37 // optional string
- FileOptions_SwiftPrefix = 39 // optional string
- FileOptions_PhpClassPrefix = 40 // optional string
- FileOptions_PhpNamespace = 41 // optional string
- FileOptions_PhpMetadataNamespace = 44 // optional string
- FileOptions_RubyPackage = 45 // optional string
- FileOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.MessageOptions.
-const (
- MessageOptions_MessageSetWireFormat = 1 // optional bool
- MessageOptions_NoStandardDescriptorAccessor = 2 // optional bool
- MessageOptions_Deprecated = 3 // optional bool
- MessageOptions_MapEntry = 7 // optional bool
- MessageOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.FieldOptions.
-const (
- FieldOptions_Ctype = 1 // optional google.protobuf.FieldOptions.CType
- FieldOptions_Packed = 2 // optional bool
- FieldOptions_Jstype = 6 // optional google.protobuf.FieldOptions.JSType
- FieldOptions_Lazy = 5 // optional bool
- FieldOptions_Deprecated = 3 // optional bool
- FieldOptions_Weak = 10 // optional bool
- FieldOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.OneofOptions.
-const (
- OneofOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.EnumOptions.
-const (
- EnumOptions_AllowAlias = 2 // optional bool
- EnumOptions_Deprecated = 3 // optional bool
- EnumOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.EnumValueOptions.
-const (
- EnumValueOptions_Deprecated = 1 // optional bool
- EnumValueOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.ServiceOptions.
-const (
- ServiceOptions_Deprecated = 33 // optional bool
- ServiceOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.MethodOptions.
-const (
- MethodOptions_Deprecated = 33 // optional bool
- MethodOptions_IdempotencyLevel = 34 // optional google.protobuf.MethodOptions.IdempotencyLevel
- MethodOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.UninterpretedOption.
-const (
- UninterpretedOption_Name = 2 // repeated google.protobuf.UninterpretedOption.NamePart
- UninterpretedOption_IdentifierValue = 3 // optional string
- UninterpretedOption_PositiveIntValue = 4 // optional uint64
- UninterpretedOption_NegativeIntValue = 5 // optional int64
- UninterpretedOption_DoubleValue = 6 // optional double
- UninterpretedOption_StringValue = 7 // optional bytes
- UninterpretedOption_AggregateValue = 8 // optional string
-)
-
-// Field numbers for google.protobuf.UninterpretedOption.NamePart.
-const (
- UninterpretedOption_NamePart_NamePart = 1 // required string
- UninterpretedOption_NamePart_IsExtension = 2 // required bool
-)
-
-// Field numbers for google.protobuf.SourceCodeInfo.
-const (
- SourceCodeInfo_Location = 1 // repeated google.protobuf.SourceCodeInfo.Location
-)
-
-// Field numbers for google.protobuf.SourceCodeInfo.Location.
-const (
- SourceCodeInfo_Location_Path = 1 // repeated int32
- SourceCodeInfo_Location_Span = 2 // repeated int32
- SourceCodeInfo_Location_LeadingComments = 3 // optional string
- SourceCodeInfo_Location_TrailingComments = 4 // optional string
- SourceCodeInfo_Location_LeadingDetachedComments = 6 // repeated string
-)
-
-// Field numbers for google.protobuf.GeneratedCodeInfo.
-const (
- GeneratedCodeInfo_Annotation = 1 // repeated google.protobuf.GeneratedCodeInfo.Annotation
-)
-
-// Field numbers for google.protobuf.GeneratedCodeInfo.Annotation.
-const (
- GeneratedCodeInfo_Annotation_Path = 1 // repeated int32
- GeneratedCodeInfo_Annotation_SourceFile = 2 // optional string
- GeneratedCodeInfo_Annotation_Begin = 3 // optional int32
- GeneratedCodeInfo_Annotation_End = 4 // optional int32
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go b/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go
deleted file mode 100644
index e597885..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package fieldnum contains constants for field numbers of fields in messages
-// declared in descriptor.proto and any of the well-known types.
-package fieldnum
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go
deleted file mode 100644
index 8816c73..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Duration.
-const (
- Duration_Seconds = 1 // optional int64
- Duration_Nanos = 2 // optional int32
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go
deleted file mode 100644
index b5130a6..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Empty.
-const ()
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go
deleted file mode 100644
index 7e3bfa2..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.FieldMask.
-const (
- FieldMask_Paths = 1 // repeated string
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go
deleted file mode 100644
index 241972b..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.SourceContext.
-const (
- SourceContext_FileName = 1 // optional string
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go
deleted file mode 100644
index c460aab..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Struct.
-const (
- Struct_Fields = 1 // repeated google.protobuf.Struct.FieldsEntry
-)
-
-// Field numbers for google.protobuf.Struct.FieldsEntry.
-const (
- Struct_FieldsEntry_Key = 1 // optional string
- Struct_FieldsEntry_Value = 2 // optional google.protobuf.Value
-)
-
-// Field numbers for google.protobuf.Value.
-const (
- Value_NullValue = 1 // optional google.protobuf.NullValue
- Value_NumberValue = 2 // optional double
- Value_StringValue = 3 // optional string
- Value_BoolValue = 4 // optional bool
- Value_StructValue = 5 // optional google.protobuf.Struct
- Value_ListValue = 6 // optional google.protobuf.ListValue
-)
-
-// Field numbers for google.protobuf.ListValue.
-const (
- ListValue_Values = 1 // repeated google.protobuf.Value
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go
deleted file mode 100644
index b4346fb..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Timestamp.
-const (
- Timestamp_Seconds = 1 // optional int64
- Timestamp_Nanos = 2 // optional int32
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go
deleted file mode 100644
index b392e95..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Type.
-const (
- Type_Name = 1 // optional string
- Type_Fields = 2 // repeated google.protobuf.Field
- Type_Oneofs = 3 // repeated string
- Type_Options = 4 // repeated google.protobuf.Option
- Type_SourceContext = 5 // optional google.protobuf.SourceContext
- Type_Syntax = 6 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.Field.
-const (
- Field_Kind = 1 // optional google.protobuf.Field.Kind
- Field_Cardinality = 2 // optional google.protobuf.Field.Cardinality
- Field_Number = 3 // optional int32
- Field_Name = 4 // optional string
- Field_TypeUrl = 6 // optional string
- Field_OneofIndex = 7 // optional int32
- Field_Packed = 8 // optional bool
- Field_Options = 9 // repeated google.protobuf.Option
- Field_JsonName = 10 // optional string
- Field_DefaultValue = 11 // optional string
-)
-
-// Field numbers for google.protobuf.Enum.
-const (
- Enum_Name = 1 // optional string
- Enum_Enumvalue = 2 // repeated google.protobuf.EnumValue
- Enum_Options = 3 // repeated google.protobuf.Option
- Enum_SourceContext = 4 // optional google.protobuf.SourceContext
- Enum_Syntax = 5 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.EnumValue.
-const (
- EnumValue_Name = 1 // optional string
- EnumValue_Number = 2 // optional int32
- EnumValue_Options = 3 // repeated google.protobuf.Option
-)
-
-// Field numbers for google.protobuf.Option.
-const (
- Option_Name = 1 // optional string
- Option_Value = 2 // optional google.protobuf.Any
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go
deleted file mode 100644
index 42f846a..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.DoubleValue.
-const (
- DoubleValue_Value = 1 // optional double
-)
-
-// Field numbers for google.protobuf.FloatValue.
-const (
- FloatValue_Value = 1 // optional float
-)
-
-// Field numbers for google.protobuf.Int64Value.
-const (
- Int64Value_Value = 1 // optional int64
-)
-
-// Field numbers for google.protobuf.UInt64Value.
-const (
- UInt64Value_Value = 1 // optional uint64
-)
-
-// Field numbers for google.protobuf.Int32Value.
-const (
- Int32Value_Value = 1 // optional int32
-)
-
-// Field numbers for google.protobuf.UInt32Value.
-const (
- UInt32Value_Value = 1 // optional uint32
-)
-
-// Field numbers for google.protobuf.BoolValue.
-const (
- BoolValue_Value = 1 // optional bool
-)
-
-// Field numbers for google.protobuf.StringValue.
-const (
- StringValue_Value = 1 // optional string
-)
-
-// Field numbers for google.protobuf.BytesValue.
-const (
- BytesValue_Value = 1 // optional bytes
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go b/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go
deleted file mode 100644
index 517c4e2..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package fieldsort defines an ordering of fields.
-//
-// The ordering defined by this package matches the historic behavior of the proto
-// package, placing extensions first and oneofs last.
-//
-// There is no guarantee about stability of the wire encoding, and users should not
-// depend on the order defined in this package as it is subject to change without
-// notice.
-package fieldsort
-
-import (
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Less returns true if field a comes before field j in ordered wire marshal output.
-func Less(a, b protoreflect.FieldDescriptor) bool {
- ea := a.IsExtension()
- eb := b.IsExtension()
- oa := a.ContainingOneof()
- ob := b.ContainingOneof()
- switch {
- case ea != eb:
- return ea
- case oa != nil && ob != nil:
- if oa == ob {
- return a.Number() < b.Number()
- }
- return oa.Index() < ob.Index()
- case oa != nil && !oa.IsSynthetic():
- return false
- case ob != nil && !ob.IsSynthetic():
- return true
- default:
- return a.Number() < b.Number()
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/build.go b/vendor/google.golang.org/protobuf/internal/filedesc/build.go
deleted file mode 100644
index 462d384..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/build.go
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package filedesc provides functionality for constructing descriptors.
-package filedesc
-
-import (
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/fieldnum"
- "google.golang.org/protobuf/reflect/protoreflect"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Builder construct a protoreflect.FileDescriptor from the raw descriptor.
-type Builder struct {
- // GoPackagePath is the Go package path that is invoking this builder.
- GoPackagePath string
-
- // RawDescriptor is the wire-encoded bytes of FileDescriptorProto
- // and must be populated.
- RawDescriptor []byte
-
- // NumEnums is the total number of enums declared in the file.
- NumEnums int32
- // NumMessages is the total number of messages declared in the file.
- // It includes the implicit message declarations for map entries.
- NumMessages int32
- // NumExtensions is the total number of extensions declared in the file.
- NumExtensions int32
- // NumServices is the total number of services declared in the file.
- NumServices int32
-
- // TypeResolver resolves extension field types for descriptor options.
- // If nil, it uses protoregistry.GlobalTypes.
- TypeResolver interface {
- preg.ExtensionTypeResolver
- }
-
- // FileRegistry is use to lookup file, enum, and message dependencies.
- // Once constructed, the file descriptor is registered here.
- // If nil, it uses protoregistry.GlobalFiles.
- FileRegistry interface {
- FindFileByPath(string) (protoreflect.FileDescriptor, error)
- FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
- RegisterFile(pref.FileDescriptor) error
- }
-}
-
-// resolverByIndex is an interface Builder.FileRegistry may implement.
-// If so, it permits looking up an enum or message dependency based on the
-// sub-list and element index into filetype.Builder.DependencyIndexes.
-type resolverByIndex interface {
- FindEnumByIndex(int32, int32, []Enum, []Message) pref.EnumDescriptor
- FindMessageByIndex(int32, int32, []Enum, []Message) pref.MessageDescriptor
-}
-
-// Indexes of each sub-list in filetype.Builder.DependencyIndexes.
-const (
- listFieldDeps int32 = iota
- listExtTargets
- listExtDeps
- listMethInDeps
- listMethOutDeps
-)
-
-// Out is the output of the Builder.
-type Out struct {
- File pref.FileDescriptor
-
- // Enums is all enum descriptors in "flattened ordering".
- Enums []Enum
- // Messages is all message descriptors in "flattened ordering".
- // It includes the implicit message declarations for map entries.
- Messages []Message
- // Extensions is all extension descriptors in "flattened ordering".
- Extensions []Extension
- // Service is all service descriptors in "flattened ordering".
- Services []Service
-}
-
-// Build constructs a FileDescriptor given the parameters set in Builder.
-// It assumes that the inputs are well-formed and panics if any inconsistencies
-// are encountered.
-//
-// If NumEnums+NumMessages+NumExtensions+NumServices is zero,
-// then Build automatically derives them from the raw descriptor.
-func (db Builder) Build() (out Out) {
- // Populate the counts if uninitialized.
- if db.NumEnums+db.NumMessages+db.NumExtensions+db.NumServices == 0 {
- db.unmarshalCounts(db.RawDescriptor, true)
- }
-
- // Initialize resolvers and registries if unpopulated.
- if db.TypeResolver == nil {
- db.TypeResolver = preg.GlobalTypes
- }
- if db.FileRegistry == nil {
- db.FileRegistry = preg.GlobalFiles
- }
-
- fd := newRawFile(db)
- out.File = fd
- out.Enums = fd.allEnums
- out.Messages = fd.allMessages
- out.Extensions = fd.allExtensions
- out.Services = fd.allServices
-
- if err := db.FileRegistry.RegisterFile(fd); err != nil {
- panic(err)
- }
- return out
-}
-
-// unmarshalCounts counts the number of enum, message, extension, and service
-// declarations in the raw message, which is either a FileDescriptorProto
-// or a MessageDescriptorProto depending on whether isFile is set.
-func (db *Builder) unmarshalCounts(b []byte, isFile bool) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- if isFile {
- switch num {
- case fieldnum.FileDescriptorProto_EnumType:
- db.NumEnums++
- case fieldnum.FileDescriptorProto_MessageType:
- db.unmarshalCounts(v, false)
- db.NumMessages++
- case fieldnum.FileDescriptorProto_Extension:
- db.NumExtensions++
- case fieldnum.FileDescriptorProto_Service:
- db.NumServices++
- }
- } else {
- switch num {
- case fieldnum.DescriptorProto_EnumType:
- db.NumEnums++
- case fieldnum.DescriptorProto_NestedType:
- db.unmarshalCounts(v, false)
- db.NumMessages++
- case fieldnum.DescriptorProto_Extension:
- db.NumExtensions++
- }
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
deleted file mode 100644
index 2540bef..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
+++ /dev/null
@@ -1,613 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
- "bytes"
- "fmt"
- "sync"
- "sync/atomic"
-
- "google.golang.org/protobuf/internal/descfmt"
- "google.golang.org/protobuf/internal/descopts"
- "google.golang.org/protobuf/internal/encoding/defval"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/internal/strs"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// The types in this file may have a suffix:
-// • L0: Contains fields common to all descriptors (except File) and
-// must be initialized up front.
-// • L1: Contains fields specific to a descriptor and
-// must be initialized up front.
-// • L2: Contains fields that are lazily initialized when constructing
-// from the raw file descriptor. When constructing as a literal, the L2
-// fields must be initialized up front.
-//
-// The types are exported so that packages like reflect/protodesc can
-// directly construct descriptors.
-
-type (
- File struct {
- fileRaw
- L1 FileL1
-
- once uint32 // atomically set if L2 is valid
- mu sync.Mutex // protects L2
- L2 *FileL2
- }
- FileL1 struct {
- Syntax pref.Syntax
- Path string
- Package pref.FullName
-
- Enums Enums
- Messages Messages
- Extensions Extensions
- Services Services
- }
- FileL2 struct {
- Options func() pref.ProtoMessage
- Imports FileImports
- Locations SourceLocations
- }
-)
-
-func (fd *File) ParentFile() pref.FileDescriptor { return fd }
-func (fd *File) Parent() pref.Descriptor { return nil }
-func (fd *File) Index() int { return 0 }
-func (fd *File) Syntax() pref.Syntax { return fd.L1.Syntax }
-func (fd *File) Name() pref.Name { return fd.L1.Package.Name() }
-func (fd *File) FullName() pref.FullName { return fd.L1.Package }
-func (fd *File) IsPlaceholder() bool { return false }
-func (fd *File) Options() pref.ProtoMessage {
- if f := fd.lazyInit().Options; f != nil {
- return f()
- }
- return descopts.File
-}
-func (fd *File) Path() string { return fd.L1.Path }
-func (fd *File) Package() pref.FullName { return fd.L1.Package }
-func (fd *File) Imports() pref.FileImports { return &fd.lazyInit().Imports }
-func (fd *File) Enums() pref.EnumDescriptors { return &fd.L1.Enums }
-func (fd *File) Messages() pref.MessageDescriptors { return &fd.L1.Messages }
-func (fd *File) Extensions() pref.ExtensionDescriptors { return &fd.L1.Extensions }
-func (fd *File) Services() pref.ServiceDescriptors { return &fd.L1.Services }
-func (fd *File) SourceLocations() pref.SourceLocations { return &fd.lazyInit().Locations }
-func (fd *File) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) }
-func (fd *File) ProtoType(pref.FileDescriptor) {}
-func (fd *File) ProtoInternal(pragma.DoNotImplement) {}
-
-func (fd *File) lazyInit() *FileL2 {
- if atomic.LoadUint32(&fd.once) == 0 {
- fd.lazyInitOnce()
- }
- return fd.L2
-}
-
-func (fd *File) lazyInitOnce() {
- fd.mu.Lock()
- if fd.L2 == nil {
- fd.lazyRawInit() // recursively initializes all L2 structures
- }
- atomic.StoreUint32(&fd.once, 1)
- fd.mu.Unlock()
-}
-
-// ProtoLegacyRawDesc is a pseudo-internal API for allowing the v1 code
-// to be able to retrieve the raw descriptor.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (fd *File) ProtoLegacyRawDesc() []byte {
- return fd.builder.RawDescriptor
-}
-
-// GoPackagePath is a pseudo-internal API for determining the Go package path
-// that this file descriptor is declared in.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (fd *File) GoPackagePath() string {
- return fd.builder.GoPackagePath
-}
-
-type (
- Enum struct {
- Base
- L1 EnumL1
- L2 *EnumL2 // protected by fileDesc.once
- }
- EnumL1 struct {
- eagerValues bool // controls whether EnumL2.Values is already populated
- }
- EnumL2 struct {
- Options func() pref.ProtoMessage
- Values EnumValues
- ReservedNames Names
- ReservedRanges EnumRanges
- }
-
- EnumValue struct {
- Base
- L1 EnumValueL1
- }
- EnumValueL1 struct {
- Options func() pref.ProtoMessage
- Number pref.EnumNumber
- }
-)
-
-func (ed *Enum) Options() pref.ProtoMessage {
- if f := ed.lazyInit().Options; f != nil {
- return f()
- }
- return descopts.Enum
-}
-func (ed *Enum) Values() pref.EnumValueDescriptors {
- if ed.L1.eagerValues {
- return &ed.L2.Values
- }
- return &ed.lazyInit().Values
-}
-func (ed *Enum) ReservedNames() pref.Names { return &ed.lazyInit().ReservedNames }
-func (ed *Enum) ReservedRanges() pref.EnumRanges { return &ed.lazyInit().ReservedRanges }
-func (ed *Enum) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) }
-func (ed *Enum) ProtoType(pref.EnumDescriptor) {}
-func (ed *Enum) lazyInit() *EnumL2 {
- ed.L0.ParentFile.lazyInit() // implicitly initializes L2
- return ed.L2
-}
-
-func (ed *EnumValue) Options() pref.ProtoMessage {
- if f := ed.L1.Options; f != nil {
- return f()
- }
- return descopts.EnumValue
-}
-func (ed *EnumValue) Number() pref.EnumNumber { return ed.L1.Number }
-func (ed *EnumValue) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) }
-func (ed *EnumValue) ProtoType(pref.EnumValueDescriptor) {}
-
-type (
- Message struct {
- Base
- L1 MessageL1
- L2 *MessageL2 // protected by fileDesc.once
- }
- MessageL1 struct {
- Enums Enums
- Messages Messages
- Extensions Extensions
- IsMapEntry bool // promoted from google.protobuf.MessageOptions
- IsMessageSet bool // promoted from google.protobuf.MessageOptions
- }
- MessageL2 struct {
- Options func() pref.ProtoMessage
- Fields Fields
- Oneofs Oneofs
- ReservedNames Names
- ReservedRanges FieldRanges
- RequiredNumbers FieldNumbers // must be consistent with Fields.Cardinality
- ExtensionRanges FieldRanges
- ExtensionRangeOptions []func() pref.ProtoMessage // must be same length as ExtensionRanges
- }
-
- Field struct {
- Base
- L1 FieldL1
- }
- FieldL1 struct {
- Options func() pref.ProtoMessage
- Number pref.FieldNumber
- Cardinality pref.Cardinality // must be consistent with Message.RequiredNumbers
- Kind pref.Kind
- JSONName jsonName
- IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
- IsWeak bool // promoted from google.protobuf.FieldOptions
- HasPacked bool // promoted from google.protobuf.FieldOptions
- IsPacked bool // promoted from google.protobuf.FieldOptions
- HasEnforceUTF8 bool // promoted from google.protobuf.FieldOptions
- EnforceUTF8 bool // promoted from google.protobuf.FieldOptions
- Default defaultValue
- ContainingOneof pref.OneofDescriptor // must be consistent with Message.Oneofs.Fields
- Enum pref.EnumDescriptor
- Message pref.MessageDescriptor
- }
-
- Oneof struct {
- Base
- L1 OneofL1
- }
- OneofL1 struct {
- Options func() pref.ProtoMessage
- Fields OneofFields // must be consistent with Message.Fields.ContainingOneof
- }
-)
-
-func (md *Message) Options() pref.ProtoMessage {
- if f := md.lazyInit().Options; f != nil {
- return f()
- }
- return descopts.Message
-}
-func (md *Message) IsMapEntry() bool { return md.L1.IsMapEntry }
-func (md *Message) Fields() pref.FieldDescriptors { return &md.lazyInit().Fields }
-func (md *Message) Oneofs() pref.OneofDescriptors { return &md.lazyInit().Oneofs }
-func (md *Message) ReservedNames() pref.Names { return &md.lazyInit().ReservedNames }
-func (md *Message) ReservedRanges() pref.FieldRanges { return &md.lazyInit().ReservedRanges }
-func (md *Message) RequiredNumbers() pref.FieldNumbers { return &md.lazyInit().RequiredNumbers }
-func (md *Message) ExtensionRanges() pref.FieldRanges { return &md.lazyInit().ExtensionRanges }
-func (md *Message) ExtensionRangeOptions(i int) pref.ProtoMessage {
- if f := md.lazyInit().ExtensionRangeOptions[i]; f != nil {
- return f()
- }
- return descopts.ExtensionRange
-}
-func (md *Message) Enums() pref.EnumDescriptors { return &md.L1.Enums }
-func (md *Message) Messages() pref.MessageDescriptors { return &md.L1.Messages }
-func (md *Message) Extensions() pref.ExtensionDescriptors { return &md.L1.Extensions }
-func (md *Message) ProtoType(pref.MessageDescriptor) {}
-func (md *Message) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) }
-func (md *Message) lazyInit() *MessageL2 {
- md.L0.ParentFile.lazyInit() // implicitly initializes L2
- return md.L2
-}
-
-// IsMessageSet is a pseudo-internal API for checking whether a message
-// should serialize in the proto1 message format.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (md *Message) IsMessageSet() bool {
- return md.L1.IsMessageSet
-}
-
-func (fd *Field) Options() pref.ProtoMessage {
- if f := fd.L1.Options; f != nil {
- return f()
- }
- return descopts.Field
-}
-func (fd *Field) Number() pref.FieldNumber { return fd.L1.Number }
-func (fd *Field) Cardinality() pref.Cardinality { return fd.L1.Cardinality }
-func (fd *Field) Kind() pref.Kind { return fd.L1.Kind }
-func (fd *Field) HasJSONName() bool { return fd.L1.JSONName.has }
-func (fd *Field) JSONName() string { return fd.L1.JSONName.get(fd) }
-func (fd *Field) HasPresence() bool {
- return fd.L1.Cardinality != pref.Repeated && (fd.L0.ParentFile.L1.Syntax == pref.Proto2 || fd.L1.Message != nil || fd.L1.ContainingOneof != nil)
-}
-func (fd *Field) HasOptionalKeyword() bool {
- return (fd.L0.ParentFile.L1.Syntax == pref.Proto2 && fd.L1.Cardinality == pref.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional
-}
-func (fd *Field) IsPacked() bool {
- if !fd.L1.HasPacked && fd.L0.ParentFile.L1.Syntax != pref.Proto2 && fd.L1.Cardinality == pref.Repeated {
- switch fd.L1.Kind {
- case pref.StringKind, pref.BytesKind, pref.MessageKind, pref.GroupKind:
- default:
- return true
- }
- }
- return fd.L1.IsPacked
-}
-func (fd *Field) IsExtension() bool { return false }
-func (fd *Field) IsWeak() bool { return fd.L1.IsWeak }
-func (fd *Field) IsList() bool { return fd.Cardinality() == pref.Repeated && !fd.IsMap() }
-func (fd *Field) IsMap() bool { return fd.Message() != nil && fd.Message().IsMapEntry() }
-func (fd *Field) MapKey() pref.FieldDescriptor {
- if !fd.IsMap() {
- return nil
- }
- return fd.Message().Fields().ByNumber(1)
-}
-func (fd *Field) MapValue() pref.FieldDescriptor {
- if !fd.IsMap() {
- return nil
- }
- return fd.Message().Fields().ByNumber(2)
-}
-func (fd *Field) HasDefault() bool { return fd.L1.Default.has }
-func (fd *Field) Default() pref.Value { return fd.L1.Default.get(fd) }
-func (fd *Field) DefaultEnumValue() pref.EnumValueDescriptor { return fd.L1.Default.enum }
-func (fd *Field) ContainingOneof() pref.OneofDescriptor { return fd.L1.ContainingOneof }
-func (fd *Field) ContainingMessage() pref.MessageDescriptor {
- return fd.L0.Parent.(pref.MessageDescriptor)
-}
-func (fd *Field) Enum() pref.EnumDescriptor {
- return fd.L1.Enum
-}
-func (fd *Field) Message() pref.MessageDescriptor {
- if fd.L1.IsWeak {
- if d, _ := protoregistry.GlobalFiles.FindDescriptorByName(fd.L1.Message.FullName()); d != nil {
- return d.(pref.MessageDescriptor)
- }
- }
- return fd.L1.Message
-}
-func (fd *Field) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) }
-func (fd *Field) ProtoType(pref.FieldDescriptor) {}
-
-// EnforceUTF8 is a pseudo-internal API to determine whether to enforce UTF-8
-// validation for the string field. This exists for Google-internal use only
-// since proto3 did not enforce UTF-8 validity prior to the open-source release.
-// If this method does not exist, the default is to enforce valid UTF-8.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (fd *Field) EnforceUTF8() bool {
- if fd.L1.HasEnforceUTF8 {
- return fd.L1.EnforceUTF8
- }
- return fd.L0.ParentFile.L1.Syntax == pref.Proto3
-}
-
-func (od *Oneof) IsSynthetic() bool {
- return od.L0.ParentFile.L1.Syntax == pref.Proto3 && len(od.L1.Fields.List) == 1 && od.L1.Fields.List[0].HasOptionalKeyword()
-}
-func (od *Oneof) Options() pref.ProtoMessage {
- if f := od.L1.Options; f != nil {
- return f()
- }
- return descopts.Oneof
-}
-func (od *Oneof) Fields() pref.FieldDescriptors { return &od.L1.Fields }
-func (od *Oneof) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, od) }
-func (od *Oneof) ProtoType(pref.OneofDescriptor) {}
-
-type (
- Extension struct {
- Base
- L1 ExtensionL1
- L2 *ExtensionL2 // protected by fileDesc.once
- }
- ExtensionL1 struct {
- Number pref.FieldNumber
- Extendee pref.MessageDescriptor
- Cardinality pref.Cardinality
- Kind pref.Kind
- }
- ExtensionL2 struct {
- Options func() pref.ProtoMessage
- JSONName jsonName
- IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
- IsPacked bool // promoted from google.protobuf.FieldOptions
- Default defaultValue
- Enum pref.EnumDescriptor
- Message pref.MessageDescriptor
- }
-)
-
-func (xd *Extension) Options() pref.ProtoMessage {
- if f := xd.lazyInit().Options; f != nil {
- return f()
- }
- return descopts.Field
-}
-func (xd *Extension) Number() pref.FieldNumber { return xd.L1.Number }
-func (xd *Extension) Cardinality() pref.Cardinality { return xd.L1.Cardinality }
-func (xd *Extension) Kind() pref.Kind { return xd.L1.Kind }
-func (xd *Extension) HasJSONName() bool { return xd.lazyInit().JSONName.has }
-func (xd *Extension) JSONName() string { return xd.lazyInit().JSONName.get(xd) }
-func (xd *Extension) HasPresence() bool { return xd.L1.Cardinality != pref.Repeated }
-func (xd *Extension) HasOptionalKeyword() bool {
- return (xd.L0.ParentFile.L1.Syntax == pref.Proto2 && xd.L1.Cardinality == pref.Optional) || xd.lazyInit().IsProto3Optional
-}
-func (xd *Extension) IsPacked() bool { return xd.lazyInit().IsPacked }
-func (xd *Extension) IsExtension() bool { return true }
-func (xd *Extension) IsWeak() bool { return false }
-func (xd *Extension) IsList() bool { return xd.Cardinality() == pref.Repeated }
-func (xd *Extension) IsMap() bool { return false }
-func (xd *Extension) MapKey() pref.FieldDescriptor { return nil }
-func (xd *Extension) MapValue() pref.FieldDescriptor { return nil }
-func (xd *Extension) HasDefault() bool { return xd.lazyInit().Default.has }
-func (xd *Extension) Default() pref.Value { return xd.lazyInit().Default.get(xd) }
-func (xd *Extension) DefaultEnumValue() pref.EnumValueDescriptor { return xd.lazyInit().Default.enum }
-func (xd *Extension) ContainingOneof() pref.OneofDescriptor { return nil }
-func (xd *Extension) ContainingMessage() pref.MessageDescriptor { return xd.L1.Extendee }
-func (xd *Extension) Enum() pref.EnumDescriptor { return xd.lazyInit().Enum }
-func (xd *Extension) Message() pref.MessageDescriptor { return xd.lazyInit().Message }
-func (xd *Extension) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, xd) }
-func (xd *Extension) ProtoType(pref.FieldDescriptor) {}
-func (xd *Extension) ProtoInternal(pragma.DoNotImplement) {}
-func (xd *Extension) lazyInit() *ExtensionL2 {
- xd.L0.ParentFile.lazyInit() // implicitly initializes L2
- return xd.L2
-}
-
-type (
- Service struct {
- Base
- L1 ServiceL1
- L2 *ServiceL2 // protected by fileDesc.once
- }
- ServiceL1 struct{}
- ServiceL2 struct {
- Options func() pref.ProtoMessage
- Methods Methods
- }
-
- Method struct {
- Base
- L1 MethodL1
- }
- MethodL1 struct {
- Options func() pref.ProtoMessage
- Input pref.MessageDescriptor
- Output pref.MessageDescriptor
- IsStreamingClient bool
- IsStreamingServer bool
- }
-)
-
-func (sd *Service) Options() pref.ProtoMessage {
- if f := sd.lazyInit().Options; f != nil {
- return f()
- }
- return descopts.Service
-}
-func (sd *Service) Methods() pref.MethodDescriptors { return &sd.lazyInit().Methods }
-func (sd *Service) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, sd) }
-func (sd *Service) ProtoType(pref.ServiceDescriptor) {}
-func (sd *Service) ProtoInternal(pragma.DoNotImplement) {}
-func (sd *Service) lazyInit() *ServiceL2 {
- sd.L0.ParentFile.lazyInit() // implicitly initializes L2
- return sd.L2
-}
-
-func (md *Method) Options() pref.ProtoMessage {
- if f := md.L1.Options; f != nil {
- return f()
- }
- return descopts.Method
-}
-func (md *Method) Input() pref.MessageDescriptor { return md.L1.Input }
-func (md *Method) Output() pref.MessageDescriptor { return md.L1.Output }
-func (md *Method) IsStreamingClient() bool { return md.L1.IsStreamingClient }
-func (md *Method) IsStreamingServer() bool { return md.L1.IsStreamingServer }
-func (md *Method) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) }
-func (md *Method) ProtoType(pref.MethodDescriptor) {}
-func (md *Method) ProtoInternal(pragma.DoNotImplement) {}
-
-// Surrogate files are can be used to create standalone descriptors
-// where the syntax is only information derived from the parent file.
-var (
- SurrogateProto2 = &File{L1: FileL1{Syntax: pref.Proto2}, L2: &FileL2{}}
- SurrogateProto3 = &File{L1: FileL1{Syntax: pref.Proto3}, L2: &FileL2{}}
-)
-
-type (
- Base struct {
- L0 BaseL0
- }
- BaseL0 struct {
- FullName pref.FullName // must be populated
- ParentFile *File // must be populated
- Parent pref.Descriptor
- Index int
- }
-)
-
-func (d *Base) Name() pref.Name { return d.L0.FullName.Name() }
-func (d *Base) FullName() pref.FullName { return d.L0.FullName }
-func (d *Base) ParentFile() pref.FileDescriptor {
- if d.L0.ParentFile == SurrogateProto2 || d.L0.ParentFile == SurrogateProto3 {
- return nil // surrogate files are not real parents
- }
- return d.L0.ParentFile
-}
-func (d *Base) Parent() pref.Descriptor { return d.L0.Parent }
-func (d *Base) Index() int { return d.L0.Index }
-func (d *Base) Syntax() pref.Syntax { return d.L0.ParentFile.Syntax() }
-func (d *Base) IsPlaceholder() bool { return false }
-func (d *Base) ProtoInternal(pragma.DoNotImplement) {}
-
-type jsonName struct {
- has bool
- once sync.Once
- name string
-}
-
-// Init initializes the name. It is exported for use by other internal packages.
-func (js *jsonName) Init(s string) {
- js.has = true
- js.name = s
-}
-
-func (js *jsonName) get(fd pref.FieldDescriptor) string {
- if !js.has {
- js.once.Do(func() {
- js.name = strs.JSONCamelCase(string(fd.Name()))
- })
- }
- return js.name
-}
-
-func DefaultValue(v pref.Value, ev pref.EnumValueDescriptor) defaultValue {
- dv := defaultValue{has: v.IsValid(), val: v, enum: ev}
- if b, ok := v.Interface().([]byte); ok {
- // Store a copy of the default bytes, so that we can detect
- // accidental mutations of the original value.
- dv.bytes = append([]byte(nil), b...)
- }
- return dv
-}
-
-func unmarshalDefault(b []byte, k pref.Kind, pf *File, ed pref.EnumDescriptor) defaultValue {
- var evs pref.EnumValueDescriptors
- if k == pref.EnumKind {
- // If the enum is declared within the same file, be careful not to
- // blindly call the Values method, lest we bind ourselves in a deadlock.
- if e, ok := ed.(*Enum); ok && e.L0.ParentFile == pf {
- evs = &e.L2.Values
- } else {
- evs = ed.Values()
- }
-
- // If we are unable to resolve the enum dependency, use a placeholder
- // enum value since we will not be able to parse the default value.
- if ed.IsPlaceholder() && pref.Name(b).IsValid() {
- v := pref.ValueOfEnum(0)
- ev := PlaceholderEnumValue(ed.FullName().Parent().Append(pref.Name(b)))
- return DefaultValue(v, ev)
- }
- }
-
- v, ev, err := defval.Unmarshal(string(b), k, evs, defval.Descriptor)
- if err != nil {
- panic(err)
- }
- return DefaultValue(v, ev)
-}
-
-type defaultValue struct {
- has bool
- val pref.Value
- enum pref.EnumValueDescriptor
- bytes []byte
-}
-
-func (dv *defaultValue) get(fd pref.FieldDescriptor) pref.Value {
- // Return the zero value as the default if unpopulated.
- if !dv.has {
- if fd.Cardinality() == pref.Repeated {
- return pref.Value{}
- }
- switch fd.Kind() {
- case pref.BoolKind:
- return pref.ValueOfBool(false)
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
- return pref.ValueOfInt32(0)
- case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- return pref.ValueOfInt64(0)
- case pref.Uint32Kind, pref.Fixed32Kind:
- return pref.ValueOfUint32(0)
- case pref.Uint64Kind, pref.Fixed64Kind:
- return pref.ValueOfUint64(0)
- case pref.FloatKind:
- return pref.ValueOfFloat32(0)
- case pref.DoubleKind:
- return pref.ValueOfFloat64(0)
- case pref.StringKind:
- return pref.ValueOfString("")
- case pref.BytesKind:
- return pref.ValueOfBytes(nil)
- case pref.EnumKind:
- if evs := fd.Enum().Values(); evs.Len() > 0 {
- return pref.ValueOfEnum(evs.Get(0).Number())
- }
- return pref.ValueOfEnum(0)
- }
- }
-
- if len(dv.bytes) > 0 && !bytes.Equal(dv.bytes, dv.val.Bytes()) {
- // TODO: Avoid panic if we're running with the race detector
- // and instead spawn a goroutine that periodically resets
- // this value back to the original to induce a race.
- panic(fmt.Sprintf("detected mutation on the default bytes for %v", fd.FullName()))
- }
- return dv.val
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
deleted file mode 100644
index c0cddf8..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
+++ /dev/null
@@ -1,471 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
- "sync"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/fieldnum"
- "google.golang.org/protobuf/internal/strs"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// fileRaw is a data struct used when initializing a file descriptor from
-// a raw FileDescriptorProto.
-type fileRaw struct {
- builder Builder
- allEnums []Enum
- allMessages []Message
- allExtensions []Extension
- allServices []Service
-}
-
-func newRawFile(db Builder) *File {
- fd := &File{fileRaw: fileRaw{builder: db}}
- fd.initDecls(db.NumEnums, db.NumMessages, db.NumExtensions, db.NumServices)
- fd.unmarshalSeed(db.RawDescriptor)
-
- // Extended message targets are eagerly resolved since registration
- // needs this information at program init time.
- for i := range fd.allExtensions {
- xd := &fd.allExtensions[i]
- xd.L1.Extendee = fd.resolveMessageDependency(xd.L1.Extendee, listExtTargets, int32(i))
- }
-
- fd.checkDecls()
- return fd
-}
-
-// initDecls pre-allocates slices for the exact number of enums, messages
-// (including map entries), extensions, and services declared in the proto file.
-// This is done to avoid regrowing the slice, which would change the address
-// for any previously seen declaration.
-//
-// The alloc methods "allocates" slices by pulling from the capacity.
-func (fd *File) initDecls(numEnums, numMessages, numExtensions, numServices int32) {
- fd.allEnums = make([]Enum, 0, numEnums)
- fd.allMessages = make([]Message, 0, numMessages)
- fd.allExtensions = make([]Extension, 0, numExtensions)
- fd.allServices = make([]Service, 0, numServices)
-}
-
-func (fd *File) allocEnums(n int) []Enum {
- total := len(fd.allEnums)
- es := fd.allEnums[total : total+n]
- fd.allEnums = fd.allEnums[:total+n]
- return es
-}
-func (fd *File) allocMessages(n int) []Message {
- total := len(fd.allMessages)
- ms := fd.allMessages[total : total+n]
- fd.allMessages = fd.allMessages[:total+n]
- return ms
-}
-func (fd *File) allocExtensions(n int) []Extension {
- total := len(fd.allExtensions)
- xs := fd.allExtensions[total : total+n]
- fd.allExtensions = fd.allExtensions[:total+n]
- return xs
-}
-func (fd *File) allocServices(n int) []Service {
- total := len(fd.allServices)
- xs := fd.allServices[total : total+n]
- fd.allServices = fd.allServices[:total+n]
- return xs
-}
-
-// checkDecls performs a sanity check that the expected number of expected
-// declarations matches the number that were found in the descriptor proto.
-func (fd *File) checkDecls() {
- switch {
- case len(fd.allEnums) != cap(fd.allEnums):
- case len(fd.allMessages) != cap(fd.allMessages):
- case len(fd.allExtensions) != cap(fd.allExtensions):
- case len(fd.allServices) != cap(fd.allServices):
- default:
- return
- }
- panic("mismatching cardinality")
-}
-
-func (fd *File) unmarshalSeed(b []byte) {
- sb := getBuilder()
- defer putBuilder(sb)
-
- var prevField pref.FieldNumber
- var numEnums, numMessages, numExtensions, numServices int
- var posEnums, posMessages, posExtensions, posServices int
- b0 := b
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.FileDescriptorProto_Syntax:
- switch string(v) {
- case "proto2":
- fd.L1.Syntax = pref.Proto2
- case "proto3":
- fd.L1.Syntax = pref.Proto3
- default:
- panic("invalid syntax")
- }
- case fieldnum.FileDescriptorProto_Name:
- fd.L1.Path = sb.MakeString(v)
- case fieldnum.FileDescriptorProto_Package:
- fd.L1.Package = pref.FullName(sb.MakeString(v))
- case fieldnum.FileDescriptorProto_EnumType:
- if prevField != fieldnum.FileDescriptorProto_EnumType {
- if numEnums > 0 {
- panic("non-contiguous repeated field")
- }
- posEnums = len(b0) - len(b) - n - m
- }
- numEnums++
- case fieldnum.FileDescriptorProto_MessageType:
- if prevField != fieldnum.FileDescriptorProto_MessageType {
- if numMessages > 0 {
- panic("non-contiguous repeated field")
- }
- posMessages = len(b0) - len(b) - n - m
- }
- numMessages++
- case fieldnum.FileDescriptorProto_Extension:
- if prevField != fieldnum.FileDescriptorProto_Extension {
- if numExtensions > 0 {
- panic("non-contiguous repeated field")
- }
- posExtensions = len(b0) - len(b) - n - m
- }
- numExtensions++
- case fieldnum.FileDescriptorProto_Service:
- if prevField != fieldnum.FileDescriptorProto_Service {
- if numServices > 0 {
- panic("non-contiguous repeated field")
- }
- posServices = len(b0) - len(b) - n - m
- }
- numServices++
- }
- prevField = num
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- prevField = -1 // ignore known field numbers of unknown wire type
- }
- }
-
- // If syntax is missing, it is assumed to be proto2.
- if fd.L1.Syntax == 0 {
- fd.L1.Syntax = pref.Proto2
- }
-
- // Must allocate all declarations before parsing each descriptor type
- // to ensure we handled all descriptors in "flattened ordering".
- if numEnums > 0 {
- fd.L1.Enums.List = fd.allocEnums(numEnums)
- }
- if numMessages > 0 {
- fd.L1.Messages.List = fd.allocMessages(numMessages)
- }
- if numExtensions > 0 {
- fd.L1.Extensions.List = fd.allocExtensions(numExtensions)
- }
- if numServices > 0 {
- fd.L1.Services.List = fd.allocServices(numServices)
- }
-
- if numEnums > 0 {
- b := b0[posEnums:]
- for i := range fd.L1.Enums.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- fd.L1.Enums.List[i].unmarshalSeed(v, sb, fd, fd, i)
- b = b[n+m:]
- }
- }
- if numMessages > 0 {
- b := b0[posMessages:]
- for i := range fd.L1.Messages.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- fd.L1.Messages.List[i].unmarshalSeed(v, sb, fd, fd, i)
- b = b[n+m:]
- }
- }
- if numExtensions > 0 {
- b := b0[posExtensions:]
- for i := range fd.L1.Extensions.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- fd.L1.Extensions.List[i].unmarshalSeed(v, sb, fd, fd, i)
- b = b[n+m:]
- }
- }
- if numServices > 0 {
- b := b0[posServices:]
- for i := range fd.L1.Services.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- fd.L1.Services.List[i].unmarshalSeed(v, sb, fd, fd, i)
- b = b[n+m:]
- }
- }
-}
-
-func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- ed.L0.ParentFile = pf
- ed.L0.Parent = pd
- ed.L0.Index = i
-
- var numValues int
- for b := b; len(b) > 0; {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.EnumDescriptorProto_Name:
- ed.L0.FullName = appendFullName(sb, pd.FullName(), v)
- case fieldnum.EnumDescriptorProto_Value:
- numValues++
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-
- // Only construct enum value descriptors for top-level enums since
- // they are needed for registration.
- if pd != pf {
- return
- }
- ed.L1.eagerValues = true
- ed.L2 = new(EnumL2)
- ed.L2.Values.List = make([]EnumValue, numValues)
- for i := 0; len(b) > 0; {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.EnumDescriptorProto_Value:
- ed.L2.Values.List[i].unmarshalFull(v, sb, pf, ed, i)
- i++
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-func (md *Message) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- md.L0.ParentFile = pf
- md.L0.Parent = pd
- md.L0.Index = i
-
- var prevField pref.FieldNumber
- var numEnums, numMessages, numExtensions int
- var posEnums, posMessages, posExtensions int
- b0 := b
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.DescriptorProto_Name:
- md.L0.FullName = appendFullName(sb, pd.FullName(), v)
- case fieldnum.DescriptorProto_EnumType:
- if prevField != fieldnum.DescriptorProto_EnumType {
- if numEnums > 0 {
- panic("non-contiguous repeated field")
- }
- posEnums = len(b0) - len(b) - n - m
- }
- numEnums++
- case fieldnum.DescriptorProto_NestedType:
- if prevField != fieldnum.DescriptorProto_NestedType {
- if numMessages > 0 {
- panic("non-contiguous repeated field")
- }
- posMessages = len(b0) - len(b) - n - m
- }
- numMessages++
- case fieldnum.DescriptorProto_Extension:
- if prevField != fieldnum.DescriptorProto_Extension {
- if numExtensions > 0 {
- panic("non-contiguous repeated field")
- }
- posExtensions = len(b0) - len(b) - n - m
- }
- numExtensions++
- case fieldnum.DescriptorProto_Options:
- md.unmarshalSeedOptions(v)
- }
- prevField = num
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- prevField = -1 // ignore known field numbers of unknown wire type
- }
- }
-
- // Must allocate all declarations before parsing each descriptor type
- // to ensure we handled all descriptors in "flattened ordering".
- if numEnums > 0 {
- md.L1.Enums.List = pf.allocEnums(numEnums)
- }
- if numMessages > 0 {
- md.L1.Messages.List = pf.allocMessages(numMessages)
- }
- if numExtensions > 0 {
- md.L1.Extensions.List = pf.allocExtensions(numExtensions)
- }
-
- if numEnums > 0 {
- b := b0[posEnums:]
- for i := range md.L1.Enums.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- md.L1.Enums.List[i].unmarshalSeed(v, sb, pf, md, i)
- b = b[n+m:]
- }
- }
- if numMessages > 0 {
- b := b0[posMessages:]
- for i := range md.L1.Messages.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- md.L1.Messages.List[i].unmarshalSeed(v, sb, pf, md, i)
- b = b[n+m:]
- }
- }
- if numExtensions > 0 {
- b := b0[posExtensions:]
- for i := range md.L1.Extensions.List {
- _, n := protowire.ConsumeVarint(b)
- v, m := protowire.ConsumeBytes(b[n:])
- md.L1.Extensions.List[i].unmarshalSeed(v, sb, pf, md, i)
- b = b[n+m:]
- }
- }
-}
-
-func (md *Message) unmarshalSeedOptions(b []byte) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.MessageOptions_MapEntry:
- md.L1.IsMapEntry = protowire.DecodeBool(v)
- case fieldnum.MessageOptions_MessageSetWireFormat:
- md.L1.IsMessageSet = protowire.DecodeBool(v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- xd.L0.ParentFile = pf
- xd.L0.Parent = pd
- xd.L0.Index = i
-
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldDescriptorProto_Number:
- xd.L1.Number = pref.FieldNumber(v)
- case fieldnum.FieldDescriptorProto_Label:
- xd.L1.Cardinality = pref.Cardinality(v)
- case fieldnum.FieldDescriptorProto_Type:
- xd.L1.Kind = pref.Kind(v)
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldDescriptorProto_Name:
- xd.L0.FullName = appendFullName(sb, pd.FullName(), v)
- case fieldnum.FieldDescriptorProto_Extendee:
- xd.L1.Extendee = PlaceholderMessage(makeFullName(sb, v))
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- sd.L0.ParentFile = pf
- sd.L0.Parent = pd
- sd.L0.Index = i
-
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.ServiceDescriptorProto_Name:
- sd.L0.FullName = appendFullName(sb, pd.FullName(), v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-var nameBuilderPool = sync.Pool{
- New: func() interface{} { return new(strs.Builder) },
-}
-
-func getBuilder() *strs.Builder {
- return nameBuilderPool.Get().(*strs.Builder)
-}
-func putBuilder(b *strs.Builder) {
- nameBuilderPool.Put(b)
-}
-
-// makeFullName converts b to a protoreflect.FullName,
-// where b must start with a leading dot.
-func makeFullName(sb *strs.Builder, b []byte) pref.FullName {
- if len(b) == 0 || b[0] != '.' {
- panic("name reference must be fully qualified")
- }
- return pref.FullName(sb.MakeString(b[1:]))
-}
-
-func appendFullName(sb *strs.Builder, prefix pref.FullName, suffix []byte) pref.FullName {
- return sb.AppendFullName(prefix, pref.Name(strs.UnsafeString(suffix)))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
deleted file mode 100644
index bc21594..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
+++ /dev/null
@@ -1,704 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
- "reflect"
- "sync"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/descopts"
- "google.golang.org/protobuf/internal/fieldnum"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func (fd *File) lazyRawInit() {
- fd.unmarshalFull(fd.builder.RawDescriptor)
- fd.resolveMessages()
- fd.resolveExtensions()
- fd.resolveServices()
-}
-
-func (file *File) resolveMessages() {
- var depIdx int32
- for i := range file.allMessages {
- md := &file.allMessages[i]
-
- // Resolve message field dependencies.
- for j := range md.L2.Fields.List {
- fd := &md.L2.Fields.List[j]
-
- // Weak fields are resolved upon actual use.
- if fd.L1.IsWeak {
- continue
- }
-
- // Resolve message field dependency.
- switch fd.L1.Kind {
- case pref.EnumKind:
- fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
- depIdx++
- case pref.MessageKind, pref.GroupKind:
- fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
- depIdx++
- }
-
- // Default is resolved here since it depends on Enum being resolved.
- if v := fd.L1.Default.val; v.IsValid() {
- fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)
- }
- }
- }
-}
-
-func (file *File) resolveExtensions() {
- var depIdx int32
- for i := range file.allExtensions {
- xd := &file.allExtensions[i]
-
- // Resolve extension field dependency.
- switch xd.L1.Kind {
- case pref.EnumKind:
- xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
- depIdx++
- case pref.MessageKind, pref.GroupKind:
- xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
- depIdx++
- }
-
- // Default is resolved here since it depends on Enum being resolved.
- if v := xd.L2.Default.val; v.IsValid() {
- xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)
- }
- }
-}
-
-func (file *File) resolveServices() {
- var depIdx int32
- for i := range file.allServices {
- sd := &file.allServices[i]
-
- // Resolve method dependencies.
- for j := range sd.L2.Methods.List {
- md := &sd.L2.Methods.List[j]
- md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)
- md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)
- depIdx++
- }
- }
-}
-
-func (file *File) resolveEnumDependency(ed pref.EnumDescriptor, i, j int32) pref.EnumDescriptor {
- r := file.builder.FileRegistry
- if r, ok := r.(resolverByIndex); ok {
- if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
- return ed2
- }
- }
- for i := range file.allEnums {
- if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {
- return ed2
- }
- }
- if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
- return d.(pref.EnumDescriptor)
- }
- return ed
-}
-
-func (file *File) resolveMessageDependency(md pref.MessageDescriptor, i, j int32) pref.MessageDescriptor {
- r := file.builder.FileRegistry
- if r, ok := r.(resolverByIndex); ok {
- if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
- return md2
- }
- }
- for i := range file.allMessages {
- if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {
- return md2
- }
- }
- if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
- return d.(pref.MessageDescriptor)
- }
- return md
-}
-
-func (fd *File) unmarshalFull(b []byte) {
- sb := getBuilder()
- defer putBuilder(sb)
-
- var enumIdx, messageIdx, extensionIdx, serviceIdx int
- var rawOptions []byte
- fd.L2 = new(FileL2)
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.FileDescriptorProto_PublicDependency:
- fd.L2.Imports[v].IsPublic = true
- case fieldnum.FileDescriptorProto_WeakDependency:
- fd.L2.Imports[v].IsWeak = true
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.FileDescriptorProto_Dependency:
- path := sb.MakeString(v)
- imp, _ := fd.builder.FileRegistry.FindFileByPath(path)
- if imp == nil {
- imp = PlaceholderFile(path)
- }
- fd.L2.Imports = append(fd.L2.Imports, pref.FileImport{FileDescriptor: imp})
- case fieldnum.FileDescriptorProto_EnumType:
- fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
- enumIdx++
- case fieldnum.FileDescriptorProto_MessageType:
- fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
- messageIdx++
- case fieldnum.FileDescriptorProto_Extension:
- fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
- extensionIdx++
- case fieldnum.FileDescriptorProto_Service:
- fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)
- serviceIdx++
- case fieldnum.FileDescriptorProto_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)
-}
-
-func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
- var rawValues [][]byte
- var rawOptions []byte
- if !ed.L1.eagerValues {
- ed.L2 = new(EnumL2)
- }
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.EnumDescriptorProto_Value:
- rawValues = append(rawValues, v)
- case fieldnum.EnumDescriptorProto_ReservedName:
- ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, pref.Name(sb.MakeString(v)))
- case fieldnum.EnumDescriptorProto_ReservedRange:
- ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
- case fieldnum.EnumDescriptorProto_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- if !ed.L1.eagerValues && len(rawValues) > 0 {
- ed.L2.Values.List = make([]EnumValue, len(rawValues))
- for i, b := range rawValues {
- ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)
- }
- }
- ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
-}
-
-func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.EnumDescriptorProto_EnumReservedRange_Start:
- r[0] = pref.EnumNumber(v)
- case fieldnum.EnumDescriptorProto_EnumReservedRange_End:
- r[1] = pref.EnumNumber(v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- return r
-}
-
-func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- vd.L0.ParentFile = pf
- vd.L0.Parent = pd
- vd.L0.Index = i
-
- var rawOptions []byte
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.EnumValueDescriptorProto_Number:
- vd.L1.Number = pref.EnumNumber(v)
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.EnumValueDescriptorProto_Name:
- // NOTE: Enum values are in the same scope as the enum parent.
- vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)
- case fieldnum.EnumValueDescriptorProto_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)
-}
-
-func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
- var rawFields, rawOneofs [][]byte
- var enumIdx, messageIdx, extensionIdx int
- var rawOptions []byte
- md.L2 = new(MessageL2)
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.DescriptorProto_Field:
- rawFields = append(rawFields, v)
- case fieldnum.DescriptorProto_OneofDecl:
- rawOneofs = append(rawOneofs, v)
- case fieldnum.DescriptorProto_ReservedName:
- md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, pref.Name(sb.MakeString(v)))
- case fieldnum.DescriptorProto_ReservedRange:
- md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
- case fieldnum.DescriptorProto_ExtensionRange:
- r, rawOptions := unmarshalMessageExtensionRange(v)
- opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)
- md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)
- md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)
- case fieldnum.DescriptorProto_EnumType:
- md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
- enumIdx++
- case fieldnum.DescriptorProto_NestedType:
- md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
- messageIdx++
- case fieldnum.DescriptorProto_Extension:
- md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
- extensionIdx++
- case fieldnum.DescriptorProto_Options:
- md.unmarshalOptions(v)
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- if len(rawFields) > 0 || len(rawOneofs) > 0 {
- md.L2.Fields.List = make([]Field, len(rawFields))
- md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))
- for i, b := range rawFields {
- fd := &md.L2.Fields.List[i]
- fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
- if fd.L1.Cardinality == pref.Required {
- md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
- }
- }
- for i, b := range rawOneofs {
- od := &md.L2.Oneofs.List[i]
- od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
- }
- }
- md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)
-}
-
-func (md *Message) unmarshalOptions(b []byte) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.MessageOptions_MapEntry:
- md.L1.IsMapEntry = protowire.DecodeBool(v)
- case fieldnum.MessageOptions_MessageSetWireFormat:
- md.L1.IsMessageSet = protowire.DecodeBool(v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.DescriptorProto_ReservedRange_Start:
- r[0] = pref.FieldNumber(v)
- case fieldnum.DescriptorProto_ReservedRange_End:
- r[1] = pref.FieldNumber(v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- return r
-}
-
-func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions []byte) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.DescriptorProto_ExtensionRange_Start:
- r[0] = pref.FieldNumber(v)
- case fieldnum.DescriptorProto_ExtensionRange_End:
- r[1] = pref.FieldNumber(v)
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.DescriptorProto_ExtensionRange_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- return r, rawOptions
-}
-
-func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- fd.L0.ParentFile = pf
- fd.L0.Parent = pd
- fd.L0.Index = i
-
- var rawTypeName []byte
- var rawOptions []byte
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldDescriptorProto_Number:
- fd.L1.Number = pref.FieldNumber(v)
- case fieldnum.FieldDescriptorProto_Label:
- fd.L1.Cardinality = pref.Cardinality(v)
- case fieldnum.FieldDescriptorProto_Type:
- fd.L1.Kind = pref.Kind(v)
- case fieldnum.FieldDescriptorProto_OneofIndex:
- // In Message.unmarshalFull, we allocate slices for both
- // the field and oneof descriptors before unmarshaling either
- // of them. This ensures pointers to slice elements are stable.
- od := &pd.(*Message).L2.Oneofs.List[v]
- od.L1.Fields.List = append(od.L1.Fields.List, fd)
- if fd.L1.ContainingOneof != nil {
- panic("oneof type already set")
- }
- fd.L1.ContainingOneof = od
- case fieldnum.FieldDescriptorProto_Proto3Optional:
- fd.L1.IsProto3Optional = protowire.DecodeBool(v)
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldDescriptorProto_Name:
- fd.L0.FullName = appendFullName(sb, pd.FullName(), v)
- case fieldnum.FieldDescriptorProto_JsonName:
- fd.L1.JSONName.Init(sb.MakeString(v))
- case fieldnum.FieldDescriptorProto_DefaultValue:
- fd.L1.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
- case fieldnum.FieldDescriptorProto_TypeName:
- rawTypeName = v
- case fieldnum.FieldDescriptorProto_Options:
- fd.unmarshalOptions(v)
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- if rawTypeName != nil {
- name := makeFullName(sb, rawTypeName)
- switch fd.L1.Kind {
- case pref.EnumKind:
- fd.L1.Enum = PlaceholderEnum(name)
- case pref.MessageKind, pref.GroupKind:
- fd.L1.Message = PlaceholderMessage(name)
- }
- }
- fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
-}
-
-func (fd *Field) unmarshalOptions(b []byte) {
- const FieldOptions_EnforceUTF8 = 13
-
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldOptions_Packed:
- fd.L1.HasPacked = true
- fd.L1.IsPacked = protowire.DecodeBool(v)
- case fieldnum.FieldOptions_Weak:
- fd.L1.IsWeak = protowire.DecodeBool(v)
- case FieldOptions_EnforceUTF8:
- fd.L1.HasEnforceUTF8 = true
- fd.L1.EnforceUTF8 = protowire.DecodeBool(v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- od.L0.ParentFile = pf
- od.L0.Parent = pd
- od.L0.Index = i
-
- var rawOptions []byte
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.OneofDescriptorProto_Name:
- od.L0.FullName = appendFullName(sb, pd.FullName(), v)
- case fieldnum.OneofDescriptorProto_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- od.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Oneof, rawOptions)
-}
-
-func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
- var rawTypeName []byte
- var rawOptions []byte
- xd.L2 = new(ExtensionL2)
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldDescriptorProto_Proto3Optional:
- xd.L2.IsProto3Optional = protowire.DecodeBool(v)
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldDescriptorProto_JsonName:
- xd.L2.JSONName.Init(sb.MakeString(v))
- case fieldnum.FieldDescriptorProto_DefaultValue:
- xd.L2.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
- case fieldnum.FieldDescriptorProto_TypeName:
- rawTypeName = v
- case fieldnum.FieldDescriptorProto_Options:
- xd.unmarshalOptions(v)
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- if rawTypeName != nil {
- name := makeFullName(sb, rawTypeName)
- switch xd.L1.Kind {
- case pref.EnumKind:
- xd.L2.Enum = PlaceholderEnum(name)
- case pref.MessageKind, pref.GroupKind:
- xd.L2.Message = PlaceholderMessage(name)
- }
- }
- xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
-}
-
-func (xd *Extension) unmarshalOptions(b []byte) {
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.FieldOptions_Packed:
- xd.L2.IsPacked = protowire.DecodeBool(v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
-}
-
-func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
- var rawMethods [][]byte
- var rawOptions []byte
- sd.L2 = new(ServiceL2)
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.ServiceDescriptorProto_Method:
- rawMethods = append(rawMethods, v)
- case fieldnum.ServiceDescriptorProto_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- if len(rawMethods) > 0 {
- sd.L2.Methods.List = make([]Method, len(rawMethods))
- for i, b := range rawMethods {
- sd.L2.Methods.List[i].unmarshalFull(b, sb, sd.L0.ParentFile, sd, i)
- }
- }
- sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
-}
-
-func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
- md.L0.ParentFile = pf
- md.L0.Parent = pd
- md.L0.Index = i
-
- var rawOptions []byte
- for len(b) > 0 {
- num, typ, n := protowire.ConsumeTag(b)
- b = b[n:]
- switch typ {
- case protowire.VarintType:
- v, m := protowire.ConsumeVarint(b)
- b = b[m:]
- switch num {
- case fieldnum.MethodDescriptorProto_ClientStreaming:
- md.L1.IsStreamingClient = protowire.DecodeBool(v)
- case fieldnum.MethodDescriptorProto_ServerStreaming:
- md.L1.IsStreamingServer = protowire.DecodeBool(v)
- }
- case protowire.BytesType:
- v, m := protowire.ConsumeBytes(b)
- b = b[m:]
- switch num {
- case fieldnum.MethodDescriptorProto_Name:
- md.L0.FullName = appendFullName(sb, pd.FullName(), v)
- case fieldnum.MethodDescriptorProto_InputType:
- md.L1.Input = PlaceholderMessage(makeFullName(sb, v))
- case fieldnum.MethodDescriptorProto_OutputType:
- md.L1.Output = PlaceholderMessage(makeFullName(sb, v))
- case fieldnum.MethodDescriptorProto_Options:
- rawOptions = appendOptions(rawOptions, v)
- }
- default:
- m := protowire.ConsumeFieldValue(num, typ, b)
- b = b[m:]
- }
- }
- md.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Method, rawOptions)
-}
-
-// appendOptions appends src to dst, where the returned slice is never nil.
-// This is necessary to distinguish between empty and unpopulated options.
-func appendOptions(dst, src []byte) []byte {
- if dst == nil {
- dst = []byte{}
- }
- return append(dst, src...)
-}
-
-// optionsUnmarshaler constructs a lazy unmarshal function for an options message.
-//
-// The type of message to unmarshal to is passed as a pointer since the
-// vars in descopts may not yet be populated at the time this function is called.
-func (db *Builder) optionsUnmarshaler(p *pref.ProtoMessage, b []byte) func() pref.ProtoMessage {
- if b == nil {
- return nil
- }
- var opts pref.ProtoMessage
- var once sync.Once
- return func() pref.ProtoMessage {
- once.Do(func() {
- if *p == nil {
- panic("Descriptor.Options called without importing the descriptor package")
- }
- opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(pref.ProtoMessage)
- if err := (proto.UnmarshalOptions{
- AllowPartial: true,
- Resolver: db.TypeResolver,
- }).Unmarshal(b, opts); err != nil {
- panic(err)
- }
- })
- return opts
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go
deleted file mode 100644
index 1b7089b..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go
+++ /dev/null
@@ -1,286 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
- "fmt"
- "math"
- "sort"
- "sync"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/descfmt"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/reflect/protoreflect"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type FileImports []pref.FileImport
-
-func (p *FileImports) Len() int { return len(*p) }
-func (p *FileImports) Get(i int) pref.FileImport { return (*p)[i] }
-func (p *FileImports) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
-func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}
-
-type Names struct {
- List []pref.Name
- once sync.Once
- has map[pref.Name]int // protected by once
-}
-
-func (p *Names) Len() int { return len(p.List) }
-func (p *Names) Get(i int) pref.Name { return p.List[i] }
-func (p *Names) Has(s pref.Name) bool { return p.lazyInit().has[s] > 0 }
-func (p *Names) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
-func (p *Names) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Names) lazyInit() *Names {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.has = make(map[pref.Name]int, len(p.List))
- for _, s := range p.List {
- p.has[s] = p.has[s] + 1
- }
- }
- })
- return p
-}
-
-// CheckValid reports any errors with the set of names with an error message
-// that completes the sentence: "ranges is invalid because it has ..."
-func (p *Names) CheckValid() error {
- for s, n := range p.lazyInit().has {
- switch {
- case n > 1:
- return errors.New("duplicate name: %q", s)
- case false && !s.IsValid():
- // NOTE: The C++ implementation does not validate the identifier.
- // See https://github.com/protocolbuffers/protobuf/issues/6335.
- return errors.New("invalid name: %q", s)
- }
- }
- return nil
-}
-
-type EnumRanges struct {
- List [][2]pref.EnumNumber // start inclusive; end inclusive
- once sync.Once
- sorted [][2]pref.EnumNumber // protected by once
-}
-
-func (p *EnumRanges) Len() int { return len(p.List) }
-func (p *EnumRanges) Get(i int) [2]pref.EnumNumber { return p.List[i] }
-func (p *EnumRanges) Has(n pref.EnumNumber) bool {
- for ls := p.lazyInit().sorted; len(ls) > 0; {
- i := len(ls) / 2
- switch r := enumRange(ls[i]); {
- case n < r.Start():
- ls = ls[:i] // search lower
- case n > r.End():
- ls = ls[i+1:] // search upper
- default:
- return true
- }
- }
- return false
-}
-func (p *EnumRanges) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
-func (p *EnumRanges) ProtoInternal(pragma.DoNotImplement) {}
-func (p *EnumRanges) lazyInit() *EnumRanges {
- p.once.Do(func() {
- p.sorted = append(p.sorted, p.List...)
- sort.Slice(p.sorted, func(i, j int) bool {
- return p.sorted[i][0] < p.sorted[j][0]
- })
- })
- return p
-}
-
-// CheckValid reports any errors with the set of names with an error message
-// that completes the sentence: "ranges is invalid because it has ..."
-func (p *EnumRanges) CheckValid() error {
- var rp enumRange
- for i, r := range p.lazyInit().sorted {
- r := enumRange(r)
- switch {
- case !(r.Start() <= r.End()):
- return errors.New("invalid range: %v", r)
- case !(rp.End() < r.Start()) && i > 0:
- return errors.New("overlapping ranges: %v with %v", rp, r)
- }
- rp = r
- }
- return nil
-}
-
-type enumRange [2]protoreflect.EnumNumber
-
-func (r enumRange) Start() protoreflect.EnumNumber { return r[0] } // inclusive
-func (r enumRange) End() protoreflect.EnumNumber { return r[1] } // inclusive
-func (r enumRange) String() string {
- if r.Start() == r.End() {
- return fmt.Sprintf("%d", r.Start())
- }
- return fmt.Sprintf("%d to %d", r.Start(), r.End())
-}
-
-type FieldRanges struct {
- List [][2]pref.FieldNumber // start inclusive; end exclusive
- once sync.Once
- sorted [][2]pref.FieldNumber // protected by once
-}
-
-func (p *FieldRanges) Len() int { return len(p.List) }
-func (p *FieldRanges) Get(i int) [2]pref.FieldNumber { return p.List[i] }
-func (p *FieldRanges) Has(n pref.FieldNumber) bool {
- for ls := p.lazyInit().sorted; len(ls) > 0; {
- i := len(ls) / 2
- switch r := fieldRange(ls[i]); {
- case n < r.Start():
- ls = ls[:i] // search lower
- case n > r.End():
- ls = ls[i+1:] // search upper
- default:
- return true
- }
- }
- return false
-}
-func (p *FieldRanges) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
-func (p *FieldRanges) ProtoInternal(pragma.DoNotImplement) {}
-func (p *FieldRanges) lazyInit() *FieldRanges {
- p.once.Do(func() {
- p.sorted = append(p.sorted, p.List...)
- sort.Slice(p.sorted, func(i, j int) bool {
- return p.sorted[i][0] < p.sorted[j][0]
- })
- })
- return p
-}
-
-// CheckValid reports any errors with the set of ranges with an error message
-// that completes the sentence: "ranges is invalid because it has ..."
-func (p *FieldRanges) CheckValid(isMessageSet bool) error {
- var rp fieldRange
- for i, r := range p.lazyInit().sorted {
- r := fieldRange(r)
- switch {
- case !isValidFieldNumber(r.Start(), isMessageSet):
- return errors.New("invalid field number: %d", r.Start())
- case !isValidFieldNumber(r.End(), isMessageSet):
- return errors.New("invalid field number: %d", r.End())
- case !(r.Start() <= r.End()):
- return errors.New("invalid range: %v", r)
- case !(rp.End() < r.Start()) && i > 0:
- return errors.New("overlapping ranges: %v with %v", rp, r)
- }
- rp = r
- }
- return nil
-}
-
-// isValidFieldNumber reports whether the field number is valid.
-// Unlike the FieldNumber.IsValid method, it allows ranges that cover the
-// reserved number range.
-func isValidFieldNumber(n protoreflect.FieldNumber, isMessageSet bool) bool {
- if isMessageSet {
- return protowire.MinValidNumber <= n && n <= math.MaxInt32
- }
- return protowire.MinValidNumber <= n && n <= protowire.MaxValidNumber
-}
-
-// CheckOverlap reports an error if p and q overlap.
-func (p *FieldRanges) CheckOverlap(q *FieldRanges) error {
- rps := p.lazyInit().sorted
- rqs := q.lazyInit().sorted
- for pi, qi := 0, 0; pi < len(rps) && qi < len(rqs); {
- rp := fieldRange(rps[pi])
- rq := fieldRange(rqs[qi])
- if !(rp.End() < rq.Start() || rq.End() < rp.Start()) {
- return errors.New("overlapping ranges: %v with %v", rp, rq)
- }
- if rp.Start() < rq.Start() {
- pi++
- } else {
- qi++
- }
- }
- return nil
-}
-
-type fieldRange [2]protoreflect.FieldNumber
-
-func (r fieldRange) Start() protoreflect.FieldNumber { return r[0] } // inclusive
-func (r fieldRange) End() protoreflect.FieldNumber { return r[1] - 1 } // inclusive
-func (r fieldRange) String() string {
- if r.Start() == r.End() {
- return fmt.Sprintf("%d", r.Start())
- }
- return fmt.Sprintf("%d to %d", r.Start(), r.End())
-}
-
-type FieldNumbers struct {
- List []pref.FieldNumber
- once sync.Once
- has map[pref.FieldNumber]struct{} // protected by once
-}
-
-func (p *FieldNumbers) Len() int { return len(p.List) }
-func (p *FieldNumbers) Get(i int) pref.FieldNumber { return p.List[i] }
-func (p *FieldNumbers) Has(n pref.FieldNumber) bool {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.has = make(map[pref.FieldNumber]struct{}, len(p.List))
- for _, n := range p.List {
- p.has[n] = struct{}{}
- }
- }
- })
- _, ok := p.has[n]
- return ok
-}
-func (p *FieldNumbers) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
-func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}
-
-type OneofFields struct {
- List []pref.FieldDescriptor
- once sync.Once
- byName map[pref.Name]pref.FieldDescriptor // protected by once
- byJSON map[string]pref.FieldDescriptor // protected by once
- byNum map[pref.FieldNumber]pref.FieldDescriptor // protected by once
-}
-
-func (p *OneofFields) Len() int { return len(p.List) }
-func (p *OneofFields) Get(i int) pref.FieldDescriptor { return p.List[i] }
-func (p *OneofFields) ByName(s pref.Name) pref.FieldDescriptor { return p.lazyInit().byName[s] }
-func (p *OneofFields) ByJSONName(s string) pref.FieldDescriptor { return p.lazyInit().byJSON[s] }
-func (p *OneofFields) ByNumber(n pref.FieldNumber) pref.FieldDescriptor { return p.lazyInit().byNum[n] }
-func (p *OneofFields) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
-func (p *OneofFields) ProtoInternal(pragma.DoNotImplement) {}
-
-func (p *OneofFields) lazyInit() *OneofFields {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[pref.Name]pref.FieldDescriptor, len(p.List))
- p.byJSON = make(map[string]pref.FieldDescriptor, len(p.List))
- p.byNum = make(map[pref.FieldNumber]pref.FieldDescriptor, len(p.List))
- for _, f := range p.List {
- // Field names and numbers are guaranteed to be unique.
- p.byName[f.Name()] = f
- p.byJSON[f.JSONName()] = f
- p.byNum[f.Number()] = f
- }
- }
- })
- return p
-}
-
-type SourceLocations struct {
- List []pref.SourceLocation
-}
-
-func (p *SourceLocations) Len() int { return len(p.List) }
-func (p *SourceLocations) Get(i int) pref.SourceLocation { return p.List[i] }
-func (p *SourceLocations) ProtoInternal(pragma.DoNotImplement) {}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go
deleted file mode 100644
index 6a8825e..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package filedesc
-
-import (
- "fmt"
- "sync"
-
- "google.golang.org/protobuf/internal/descfmt"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type Enums struct {
- List []Enum
- once sync.Once
- byName map[protoreflect.Name]*Enum // protected by once
-}
-
-func (p *Enums) Len() int {
- return len(p.List)
-}
-func (p *Enums) Get(i int) protoreflect.EnumDescriptor {
- return &p.List[i]
-}
-func (p *Enums) ByName(s protoreflect.Name) protoreflect.EnumDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Enums) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Enums) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Enums) lazyInit() *Enums {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Enum, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- }
- }
- })
- return p
-}
-
-type EnumValues struct {
- List []EnumValue
- once sync.Once
- byName map[protoreflect.Name]*EnumValue // protected by once
- byNum map[protoreflect.EnumNumber]*EnumValue // protected by once
-}
-
-func (p *EnumValues) Len() int {
- return len(p.List)
-}
-func (p *EnumValues) Get(i int) protoreflect.EnumValueDescriptor {
- return &p.List[i]
-}
-func (p *EnumValues) ByName(s protoreflect.Name) protoreflect.EnumValueDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *EnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
- if d := p.lazyInit().byNum[n]; d != nil {
- return d
- }
- return nil
-}
-func (p *EnumValues) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *EnumValues) ProtoInternal(pragma.DoNotImplement) {}
-func (p *EnumValues) lazyInit() *EnumValues {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*EnumValue, len(p.List))
- p.byNum = make(map[protoreflect.EnumNumber]*EnumValue, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- if _, ok := p.byNum[d.Number()]; !ok {
- p.byNum[d.Number()] = d
- }
- }
- }
- })
- return p
-}
-
-type Messages struct {
- List []Message
- once sync.Once
- byName map[protoreflect.Name]*Message // protected by once
-}
-
-func (p *Messages) Len() int {
- return len(p.List)
-}
-func (p *Messages) Get(i int) protoreflect.MessageDescriptor {
- return &p.List[i]
-}
-func (p *Messages) ByName(s protoreflect.Name) protoreflect.MessageDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Messages) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Messages) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Messages) lazyInit() *Messages {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Message, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- }
- }
- })
- return p
-}
-
-type Fields struct {
- List []Field
- once sync.Once
- byName map[protoreflect.Name]*Field // protected by once
- byJSON map[string]*Field // protected by once
- byNum map[protoreflect.FieldNumber]*Field // protected by once
-}
-
-func (p *Fields) Len() int {
- return len(p.List)
-}
-func (p *Fields) Get(i int) protoreflect.FieldDescriptor {
- return &p.List[i]
-}
-func (p *Fields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Fields) ByJSONName(s string) protoreflect.FieldDescriptor {
- if d := p.lazyInit().byJSON[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Fields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
- if d := p.lazyInit().byNum[n]; d != nil {
- return d
- }
- return nil
-}
-func (p *Fields) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Fields) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Fields) lazyInit() *Fields {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Field, len(p.List))
- p.byJSON = make(map[string]*Field, len(p.List))
- p.byNum = make(map[protoreflect.FieldNumber]*Field, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- if _, ok := p.byJSON[d.JSONName()]; !ok {
- p.byJSON[d.JSONName()] = d
- }
- if _, ok := p.byNum[d.Number()]; !ok {
- p.byNum[d.Number()] = d
- }
- }
- }
- })
- return p
-}
-
-type Oneofs struct {
- List []Oneof
- once sync.Once
- byName map[protoreflect.Name]*Oneof // protected by once
-}
-
-func (p *Oneofs) Len() int {
- return len(p.List)
-}
-func (p *Oneofs) Get(i int) protoreflect.OneofDescriptor {
- return &p.List[i]
-}
-func (p *Oneofs) ByName(s protoreflect.Name) protoreflect.OneofDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Oneofs) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Oneofs) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Oneofs) lazyInit() *Oneofs {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Oneof, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- }
- }
- })
- return p
-}
-
-type Extensions struct {
- List []Extension
- once sync.Once
- byName map[protoreflect.Name]*Extension // protected by once
-}
-
-func (p *Extensions) Len() int {
- return len(p.List)
-}
-func (p *Extensions) Get(i int) protoreflect.ExtensionDescriptor {
- return &p.List[i]
-}
-func (p *Extensions) ByName(s protoreflect.Name) protoreflect.ExtensionDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Extensions) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Extensions) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Extensions) lazyInit() *Extensions {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Extension, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- }
- }
- })
- return p
-}
-
-type Services struct {
- List []Service
- once sync.Once
- byName map[protoreflect.Name]*Service // protected by once
-}
-
-func (p *Services) Len() int {
- return len(p.List)
-}
-func (p *Services) Get(i int) protoreflect.ServiceDescriptor {
- return &p.List[i]
-}
-func (p *Services) ByName(s protoreflect.Name) protoreflect.ServiceDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Services) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Services) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Services) lazyInit() *Services {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Service, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- }
- }
- })
- return p
-}
-
-type Methods struct {
- List []Method
- once sync.Once
- byName map[protoreflect.Name]*Method // protected by once
-}
-
-func (p *Methods) Len() int {
- return len(p.List)
-}
-func (p *Methods) Get(i int) protoreflect.MethodDescriptor {
- return &p.List[i]
-}
-func (p *Methods) ByName(s protoreflect.Name) protoreflect.MethodDescriptor {
- if d := p.lazyInit().byName[s]; d != nil {
- return d
- }
- return nil
-}
-func (p *Methods) Format(s fmt.State, r rune) {
- descfmt.FormatList(s, r, p)
-}
-func (p *Methods) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Methods) lazyInit() *Methods {
- p.once.Do(func() {
- if len(p.List) > 0 {
- p.byName = make(map[protoreflect.Name]*Method, len(p.List))
- for i := range p.List {
- d := &p.List[i]
- if _, ok := p.byName[d.Name()]; !ok {
- p.byName[d.Name()] = d
- }
- }
- }
- })
- return p
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go b/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go
deleted file mode 100644
index dbf2c60..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
- "google.golang.org/protobuf/internal/descopts"
- "google.golang.org/protobuf/internal/pragma"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var (
- emptyNames = new(Names)
- emptyEnumRanges = new(EnumRanges)
- emptyFieldRanges = new(FieldRanges)
- emptyFieldNumbers = new(FieldNumbers)
- emptySourceLocations = new(SourceLocations)
-
- emptyFiles = new(FileImports)
- emptyMessages = new(Messages)
- emptyFields = new(Fields)
- emptyOneofs = new(Oneofs)
- emptyEnums = new(Enums)
- emptyEnumValues = new(EnumValues)
- emptyExtensions = new(Extensions)
- emptyServices = new(Services)
-)
-
-// PlaceholderFile is a placeholder, representing only the file path.
-type PlaceholderFile string
-
-func (f PlaceholderFile) ParentFile() pref.FileDescriptor { return f }
-func (f PlaceholderFile) Parent() pref.Descriptor { return nil }
-func (f PlaceholderFile) Index() int { return 0 }
-func (f PlaceholderFile) Syntax() pref.Syntax { return 0 }
-func (f PlaceholderFile) Name() pref.Name { return "" }
-func (f PlaceholderFile) FullName() pref.FullName { return "" }
-func (f PlaceholderFile) IsPlaceholder() bool { return true }
-func (f PlaceholderFile) Options() pref.ProtoMessage { return descopts.File }
-func (f PlaceholderFile) Path() string { return string(f) }
-func (f PlaceholderFile) Package() pref.FullName { return "" }
-func (f PlaceholderFile) Imports() pref.FileImports { return emptyFiles }
-func (f PlaceholderFile) Messages() pref.MessageDescriptors { return emptyMessages }
-func (f PlaceholderFile) Enums() pref.EnumDescriptors { return emptyEnums }
-func (f PlaceholderFile) Extensions() pref.ExtensionDescriptors { return emptyExtensions }
-func (f PlaceholderFile) Services() pref.ServiceDescriptors { return emptyServices }
-func (f PlaceholderFile) SourceLocations() pref.SourceLocations { return emptySourceLocations }
-func (f PlaceholderFile) ProtoType(pref.FileDescriptor) { return }
-func (f PlaceholderFile) ProtoInternal(pragma.DoNotImplement) { return }
-
-// PlaceholderEnum is a placeholder, representing only the full name.
-type PlaceholderEnum pref.FullName
-
-func (e PlaceholderEnum) ParentFile() pref.FileDescriptor { return nil }
-func (e PlaceholderEnum) Parent() pref.Descriptor { return nil }
-func (e PlaceholderEnum) Index() int { return 0 }
-func (e PlaceholderEnum) Syntax() pref.Syntax { return 0 }
-func (e PlaceholderEnum) Name() pref.Name { return pref.FullName(e).Name() }
-func (e PlaceholderEnum) FullName() pref.FullName { return pref.FullName(e) }
-func (e PlaceholderEnum) IsPlaceholder() bool { return true }
-func (e PlaceholderEnum) Options() pref.ProtoMessage { return descopts.Enum }
-func (e PlaceholderEnum) Values() pref.EnumValueDescriptors { return emptyEnumValues }
-func (e PlaceholderEnum) ReservedNames() pref.Names { return emptyNames }
-func (e PlaceholderEnum) ReservedRanges() pref.EnumRanges { return emptyEnumRanges }
-func (e PlaceholderEnum) ProtoType(pref.EnumDescriptor) { return }
-func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return }
-
-// PlaceholderEnumValue is a placeholder, representing only the full name.
-type PlaceholderEnumValue pref.FullName
-
-func (e PlaceholderEnumValue) ParentFile() pref.FileDescriptor { return nil }
-func (e PlaceholderEnumValue) Parent() pref.Descriptor { return nil }
-func (e PlaceholderEnumValue) Index() int { return 0 }
-func (e PlaceholderEnumValue) Syntax() pref.Syntax { return 0 }
-func (e PlaceholderEnumValue) Name() pref.Name { return pref.FullName(e).Name() }
-func (e PlaceholderEnumValue) FullName() pref.FullName { return pref.FullName(e) }
-func (e PlaceholderEnumValue) IsPlaceholder() bool { return true }
-func (e PlaceholderEnumValue) Options() pref.ProtoMessage { return descopts.EnumValue }
-func (e PlaceholderEnumValue) Number() pref.EnumNumber { return 0 }
-func (e PlaceholderEnumValue) ProtoType(pref.EnumValueDescriptor) { return }
-func (e PlaceholderEnumValue) ProtoInternal(pragma.DoNotImplement) { return }
-
-// PlaceholderMessage is a placeholder, representing only the full name.
-type PlaceholderMessage pref.FullName
-
-func (m PlaceholderMessage) ParentFile() pref.FileDescriptor { return nil }
-func (m PlaceholderMessage) Parent() pref.Descriptor { return nil }
-func (m PlaceholderMessage) Index() int { return 0 }
-func (m PlaceholderMessage) Syntax() pref.Syntax { return 0 }
-func (m PlaceholderMessage) Name() pref.Name { return pref.FullName(m).Name() }
-func (m PlaceholderMessage) FullName() pref.FullName { return pref.FullName(m) }
-func (m PlaceholderMessage) IsPlaceholder() bool { return true }
-func (m PlaceholderMessage) Options() pref.ProtoMessage { return descopts.Message }
-func (m PlaceholderMessage) IsMapEntry() bool { return false }
-func (m PlaceholderMessage) Fields() pref.FieldDescriptors { return emptyFields }
-func (m PlaceholderMessage) Oneofs() pref.OneofDescriptors { return emptyOneofs }
-func (m PlaceholderMessage) ReservedNames() pref.Names { return emptyNames }
-func (m PlaceholderMessage) ReservedRanges() pref.FieldRanges { return emptyFieldRanges }
-func (m PlaceholderMessage) RequiredNumbers() pref.FieldNumbers { return emptyFieldNumbers }
-func (m PlaceholderMessage) ExtensionRanges() pref.FieldRanges { return emptyFieldRanges }
-func (m PlaceholderMessage) ExtensionRangeOptions(int) pref.ProtoMessage { panic("index out of range") }
-func (m PlaceholderMessage) Messages() pref.MessageDescriptors { return emptyMessages }
-func (m PlaceholderMessage) Enums() pref.EnumDescriptors { return emptyEnums }
-func (m PlaceholderMessage) Extensions() pref.ExtensionDescriptors { return emptyExtensions }
-func (m PlaceholderMessage) ProtoType(pref.MessageDescriptor) { return }
-func (m PlaceholderMessage) ProtoInternal(pragma.DoNotImplement) { return }
diff --git a/vendor/google.golang.org/protobuf/internal/filetype/build.go b/vendor/google.golang.org/protobuf/internal/filetype/build.go
deleted file mode 100644
index 0a0dd35..0000000
--- a/vendor/google.golang.org/protobuf/internal/filetype/build.go
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package filetype provides functionality for wrapping descriptors
-// with Go type information.
-package filetype
-
-import (
- "reflect"
-
- "google.golang.org/protobuf/internal/descopts"
- fdesc "google.golang.org/protobuf/internal/filedesc"
- pimpl "google.golang.org/protobuf/internal/impl"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Builder constructs type descriptors from a raw file descriptor
-// and associated Go types for each enum and message declaration.
-//
-//
-// Flattened Ordering
-//
-// The protobuf type system represents declarations as a tree. Certain nodes in
-// the tree require us to either associate it with a concrete Go type or to
-// resolve a dependency, which is information that must be provided separately
-// since it cannot be derived from the file descriptor alone.
-//
-// However, representing a tree as Go literals is difficult to simply do in a
-// space and time efficient way. Thus, we store them as a flattened list of
-// objects where the serialization order from the tree-based form is important.
-//
-// The "flattened ordering" is defined as a tree traversal of all enum, message,
-// extension, and service declarations using the following algorithm:
-//
-// def VisitFileDecls(fd):
-// for e in fd.Enums: yield e
-// for m in fd.Messages: yield m
-// for x in fd.Extensions: yield x
-// for s in fd.Services: yield s
-// for m in fd.Messages: yield from VisitMessageDecls(m)
-//
-// def VisitMessageDecls(md):
-// for e in md.Enums: yield e
-// for m in md.Messages: yield m
-// for x in md.Extensions: yield x
-// for m in md.Messages: yield from VisitMessageDecls(m)
-//
-// The traversal starts at the root file descriptor and yields each direct
-// declaration within each node before traversing into sub-declarations
-// that children themselves may have.
-type Builder struct {
- // File is the underlying file descriptor builder.
- File fdesc.Builder
-
- // GoTypes is a unique set of the Go types for all declarations and
- // dependencies. Each type is represented as a zero value of the Go type.
- //
- // Declarations are Go types generated for enums and messages directly
- // declared (not publicly imported) in the proto source file.
- // Messages for map entries are accounted for, but represented by nil.
- // Enum declarations in "flattened ordering" come first, followed by
- // message declarations in "flattened ordering".
- //
- // Dependencies are Go types for enums or messages referenced by
- // message fields (excluding weak fields), for parent extended messages of
- // extension fields, for enums or messages referenced by extension fields,
- // and for input and output messages referenced by service methods.
- // Dependencies must come after declarations, but the ordering of
- // dependencies themselves is unspecified.
- GoTypes []interface{}
-
- // DependencyIndexes is an ordered list of indexes into GoTypes for the
- // dependencies of messages, extensions, or services.
- //
- // There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
- // 0. Message field dependencies: list of the enum or message type
- // referred to by every message field.
- // 1. Extension field targets: list of the extended parent message of
- // every extension.
- // 2. Extension field dependencies: list of the enum or message type
- // referred to by every extension field.
- // 3. Service method inputs: list of the input message type
- // referred to by every service method.
- // 4. Service method outputs: list of the output message type
- // referred to by every service method.
- //
- // The offset into DependencyIndexes for the start of each sub-list
- // is appended to the end in reverse order.
- DependencyIndexes []int32
-
- // EnumInfos is a list of enum infos in "flattened ordering".
- EnumInfos []pimpl.EnumInfo
-
- // MessageInfos is a list of message infos in "flattened ordering".
- // If provided, the GoType and PBType for each element is populated.
- //
- // Requirement: len(MessageInfos) == len(Build.Messages)
- MessageInfos []pimpl.MessageInfo
-
- // ExtensionInfos is a list of extension infos in "flattened ordering".
- // Each element is initialized and registered with the protoregistry package.
- //
- // Requirement: len(LegacyExtensions) == len(Build.Extensions)
- ExtensionInfos []pimpl.ExtensionInfo
-
- // TypeRegistry is the registry to register each type descriptor.
- // If nil, it uses protoregistry.GlobalTypes.
- TypeRegistry interface {
- RegisterMessage(pref.MessageType) error
- RegisterEnum(pref.EnumType) error
- RegisterExtension(pref.ExtensionType) error
- }
-}
-
-// Out is the output of the builder.
-type Out struct {
- File pref.FileDescriptor
-}
-
-func (tb Builder) Build() (out Out) {
- // Replace the resolver with one that resolves dependencies by index,
- // which is faster and more reliable than relying on the global registry.
- if tb.File.FileRegistry == nil {
- tb.File.FileRegistry = preg.GlobalFiles
- }
- tb.File.FileRegistry = &resolverByIndex{
- goTypes: tb.GoTypes,
- depIdxs: tb.DependencyIndexes,
- fileRegistry: tb.File.FileRegistry,
- }
-
- // Initialize registry if unpopulated.
- if tb.TypeRegistry == nil {
- tb.TypeRegistry = preg.GlobalTypes
- }
-
- fbOut := tb.File.Build()
- out.File = fbOut.File
-
- // Process enums.
- enumGoTypes := tb.GoTypes[:len(fbOut.Enums)]
- if len(tb.EnumInfos) != len(fbOut.Enums) {
- panic("mismatching enum lengths")
- }
- if len(fbOut.Enums) > 0 {
- for i := range fbOut.Enums {
- tb.EnumInfos[i] = pimpl.EnumInfo{
- GoReflectType: reflect.TypeOf(enumGoTypes[i]),
- Desc: &fbOut.Enums[i],
- }
- // Register enum types.
- if err := tb.TypeRegistry.RegisterEnum(&tb.EnumInfos[i]); err != nil {
- panic(err)
- }
- }
- }
-
- // Process messages.
- messageGoTypes := tb.GoTypes[len(fbOut.Enums):][:len(fbOut.Messages)]
- if len(tb.MessageInfos) != len(fbOut.Messages) {
- panic("mismatching message lengths")
- }
- if len(fbOut.Messages) > 0 {
- for i := range fbOut.Messages {
- if messageGoTypes[i] == nil {
- continue // skip map entry
- }
-
- tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
- tb.MessageInfos[i].Desc = &fbOut.Messages[i]
-
- // Register message types.
- if err := tb.TypeRegistry.RegisterMessage(&tb.MessageInfos[i]); err != nil {
- panic(err)
- }
- }
-
- // As a special-case for descriptor.proto,
- // locally register concrete message type for the options.
- if out.File.Path() == "google/protobuf/descriptor.proto" && out.File.Package() == "google.protobuf" {
- for i := range fbOut.Messages {
- switch fbOut.Messages[i].Name() {
- case "FileOptions":
- descopts.File = messageGoTypes[i].(pref.ProtoMessage)
- case "EnumOptions":
- descopts.Enum = messageGoTypes[i].(pref.ProtoMessage)
- case "EnumValueOptions":
- descopts.EnumValue = messageGoTypes[i].(pref.ProtoMessage)
- case "MessageOptions":
- descopts.Message = messageGoTypes[i].(pref.ProtoMessage)
- case "FieldOptions":
- descopts.Field = messageGoTypes[i].(pref.ProtoMessage)
- case "OneofOptions":
- descopts.Oneof = messageGoTypes[i].(pref.ProtoMessage)
- case "ExtensionRangeOptions":
- descopts.ExtensionRange = messageGoTypes[i].(pref.ProtoMessage)
- case "ServiceOptions":
- descopts.Service = messageGoTypes[i].(pref.ProtoMessage)
- case "MethodOptions":
- descopts.Method = messageGoTypes[i].(pref.ProtoMessage)
- }
- }
- }
- }
-
- // Process extensions.
- if len(tb.ExtensionInfos) != len(fbOut.Extensions) {
- panic("mismatching extension lengths")
- }
- var depIdx int32
- for i := range fbOut.Extensions {
- // For enum and message kinds, determine the referent Go type so
- // that we can construct their constructors.
- const listExtDeps = 2
- var goType reflect.Type
- switch fbOut.Extensions[i].L1.Kind {
- case pref.EnumKind:
- j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
- goType = reflect.TypeOf(tb.GoTypes[j])
- depIdx++
- case pref.MessageKind, pref.GroupKind:
- j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
- goType = reflect.TypeOf(tb.GoTypes[j])
- depIdx++
- default:
- goType = goTypeForPBKind[fbOut.Extensions[i].L1.Kind]
- }
- if fbOut.Extensions[i].IsList() {
- goType = reflect.SliceOf(goType)
- }
-
- pimpl.InitExtensionInfo(&tb.ExtensionInfos[i], &fbOut.Extensions[i], goType)
-
- // Register extension types.
- if err := tb.TypeRegistry.RegisterExtension(&tb.ExtensionInfos[i]); err != nil {
- panic(err)
- }
- }
-
- return out
-}
-
-var goTypeForPBKind = map[pref.Kind]reflect.Type{
- pref.BoolKind: reflect.TypeOf(bool(false)),
- pref.Int32Kind: reflect.TypeOf(int32(0)),
- pref.Sint32Kind: reflect.TypeOf(int32(0)),
- pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
- pref.Int64Kind: reflect.TypeOf(int64(0)),
- pref.Sint64Kind: reflect.TypeOf(int64(0)),
- pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
- pref.Uint32Kind: reflect.TypeOf(uint32(0)),
- pref.Fixed32Kind: reflect.TypeOf(uint32(0)),
- pref.Uint64Kind: reflect.TypeOf(uint64(0)),
- pref.Fixed64Kind: reflect.TypeOf(uint64(0)),
- pref.FloatKind: reflect.TypeOf(float32(0)),
- pref.DoubleKind: reflect.TypeOf(float64(0)),
- pref.StringKind: reflect.TypeOf(string("")),
- pref.BytesKind: reflect.TypeOf([]byte(nil)),
-}
-
-type depIdxs []int32
-
-// Get retrieves the jth element of the ith sub-list.
-func (x depIdxs) Get(i, j int32) int32 {
- return x[x[int32(len(x))-i-1]+j]
-}
-
-type (
- resolverByIndex struct {
- goTypes []interface{}
- depIdxs depIdxs
- fileRegistry
- }
- fileRegistry interface {
- FindFileByPath(string) (pref.FileDescriptor, error)
- FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
- RegisterFile(pref.FileDescriptor) error
- }
-)
-
-func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.EnumDescriptor {
- if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
- return &es[depIdx]
- } else {
- return pimpl.Export{}.EnumDescriptorOf(r.goTypes[depIdx])
- }
-}
-
-func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.MessageDescriptor {
- if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
- return &ms[depIdx-len(es)]
- } else {
- return pimpl.Export{}.MessageDescriptorOf(r.goTypes[depIdx])
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/flags/flags.go b/vendor/google.golang.org/protobuf/internal/flags/flags.go
deleted file mode 100644
index 58372dd..0000000
--- a/vendor/google.golang.org/protobuf/internal/flags/flags.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package flags provides a set of flags controlled by build tags.
-package flags
-
-// ProtoLegacy specifies whether to enable support for legacy functionality
-// such as MessageSets, weak fields, and various other obscure behavior
-// that is necessary to maintain backwards compatibility with proto1 or
-// the pre-release variants of proto2 and proto3.
-//
-// This is disabled by default unless built with the "protolegacy" tag.
-//
-// WARNING: The compatibility agreement covers nothing provided by this flag.
-// As such, functionality may suddenly be removed or changed at our discretion.
-const ProtoLegacy = protoLegacy
-
-// LazyUnmarshalExtensions specifies whether to lazily unmarshal extensions.
-//
-// Lazy extension unmarshaling validates the contents of message-valued
-// extension fields at unmarshal time, but defers creating the message
-// structure until the extension is first accessed.
-const LazyUnmarshalExtensions = ProtoLegacy
diff --git a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go
deleted file mode 100644
index a72995f..0000000
--- a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !protolegacy
-
-package flags
-
-const protoLegacy = false
diff --git a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go
deleted file mode 100644
index 772e2f0..0000000
--- a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build protolegacy
-
-package flags
-
-const protoLegacy = true
diff --git a/vendor/google.golang.org/protobuf/internal/genname/name.go b/vendor/google.golang.org/protobuf/internal/genname/name.go
deleted file mode 100644
index f45509f..0000000
--- a/vendor/google.golang.org/protobuf/internal/genname/name.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package genname contains constants for generated names.
-package genname
-
-const (
- State = "state"
-
- SizeCache = "sizeCache"
- SizeCacheA = "XXX_sizecache"
-
- WeakFields = "weakFields"
- WeakFieldsA = "XXX_weak"
-
- UnknownFields = "unknownFields"
- UnknownFieldsA = "XXX_unrecognized"
-
- ExtensionFields = "extensionFields"
- ExtensionFieldsA = "XXX_InternalExtensions"
- ExtensionFieldsB = "XXX_extensions"
-
- WeakFieldPrefix = "XXX_weak_"
-)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/api_export.go b/vendor/google.golang.org/protobuf/internal/impl/api_export.go
deleted file mode 100644
index 4d22c96..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/api_export.go
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "strconv"
-
- "google.golang.org/protobuf/encoding/prototext"
- "google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Export is a zero-length named type that exists only to export a set of
-// functions that we do not want to appear in godoc.
-type Export struct{}
-
-// enum is any enum type generated by protoc-gen-go
-// and must be a named int32 type.
-type enum = interface{}
-
-// EnumOf returns the protoreflect.Enum interface over e.
-// It returns nil if e is nil.
-func (Export) EnumOf(e enum) pref.Enum {
- switch e := e.(type) {
- case nil:
- return nil
- case pref.Enum:
- return e
- default:
- return legacyWrapEnum(reflect.ValueOf(e))
- }
-}
-
-// EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
-// It returns nil if e is nil.
-func (Export) EnumDescriptorOf(e enum) pref.EnumDescriptor {
- switch e := e.(type) {
- case nil:
- return nil
- case pref.Enum:
- return e.Descriptor()
- default:
- return LegacyLoadEnumDesc(reflect.TypeOf(e))
- }
-}
-
-// EnumTypeOf returns the protoreflect.EnumType for e.
-// It returns nil if e is nil.
-func (Export) EnumTypeOf(e enum) pref.EnumType {
- switch e := e.(type) {
- case nil:
- return nil
- case pref.Enum:
- return e.Type()
- default:
- return legacyLoadEnumType(reflect.TypeOf(e))
- }
-}
-
-// EnumStringOf returns the enum value as a string, either as the name if
-// the number is resolvable, or the number formatted as a string.
-func (Export) EnumStringOf(ed pref.EnumDescriptor, n pref.EnumNumber) string {
- ev := ed.Values().ByNumber(n)
- if ev != nil {
- return string(ev.Name())
- }
- return strconv.Itoa(int(n))
-}
-
-// message is any message type generated by protoc-gen-go
-// and must be a pointer to a named struct type.
-type message = interface{}
-
-// legacyMessageWrapper wraps a v2 message as a v1 message.
-type legacyMessageWrapper struct{ m pref.ProtoMessage }
-
-func (m legacyMessageWrapper) Reset() { proto.Reset(m.m) }
-func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) }
-func (m legacyMessageWrapper) ProtoMessage() {}
-
-// ProtoMessageV1Of converts either a v1 or v2 message to a v1 message.
-// It returns nil if m is nil.
-func (Export) ProtoMessageV1Of(m message) piface.MessageV1 {
- switch mv := m.(type) {
- case nil:
- return nil
- case piface.MessageV1:
- return mv
- case unwrapper:
- return Export{}.ProtoMessageV1Of(mv.protoUnwrap())
- case pref.ProtoMessage:
- return legacyMessageWrapper{mv}
- default:
- panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
- }
-}
-
-func (Export) protoMessageV2Of(m message) pref.ProtoMessage {
- switch mv := m.(type) {
- case nil:
- return nil
- case pref.ProtoMessage:
- return mv
- case legacyMessageWrapper:
- return mv.m
- case piface.MessageV1:
- return nil
- default:
- panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
- }
-}
-
-// ProtoMessageV2Of converts either a v1 or v2 message to a v2 message.
-// It returns nil if m is nil.
-func (Export) ProtoMessageV2Of(m message) pref.ProtoMessage {
- if m == nil {
- return nil
- }
- if mv := (Export{}).protoMessageV2Of(m); mv != nil {
- return mv
- }
- return legacyWrapMessage(reflect.ValueOf(m)).Interface()
-}
-
-// MessageOf returns the protoreflect.Message interface over m.
-// It returns nil if m is nil.
-func (Export) MessageOf(m message) pref.Message {
- if m == nil {
- return nil
- }
- if mv := (Export{}).protoMessageV2Of(m); mv != nil {
- return mv.ProtoReflect()
- }
- return legacyWrapMessage(reflect.ValueOf(m))
-}
-
-// MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
-// It returns nil if m is nil.
-func (Export) MessageDescriptorOf(m message) pref.MessageDescriptor {
- if m == nil {
- return nil
- }
- if mv := (Export{}).protoMessageV2Of(m); mv != nil {
- return mv.ProtoReflect().Descriptor()
- }
- return LegacyLoadMessageDesc(reflect.TypeOf(m))
-}
-
-// MessageTypeOf returns the protoreflect.MessageType for m.
-// It returns nil if m is nil.
-func (Export) MessageTypeOf(m message) pref.MessageType {
- if m == nil {
- return nil
- }
- if mv := (Export{}).protoMessageV2Of(m); mv != nil {
- return mv.ProtoReflect().Type()
- }
- return legacyLoadMessageInfo(reflect.TypeOf(m), "")
-}
-
-// MessageStringOf returns the message value as a string,
-// which is the message serialized in the protobuf text format.
-func (Export) MessageStringOf(m pref.ProtoMessage) string {
- return prototext.MarshalOptions{Multiline: false}.Format(m)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/checkinit.go b/vendor/google.golang.org/protobuf/internal/impl/checkinit.go
deleted file mode 100644
index b82341e..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/checkinit.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "sync"
-
- "google.golang.org/protobuf/internal/errors"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-func (mi *MessageInfo) checkInitialized(in piface.CheckInitializedInput) (piface.CheckInitializedOutput, error) {
- var p pointer
- if ms, ok := in.Message.(*messageState); ok {
- p = ms.pointer()
- } else {
- p = in.Message.(*messageReflectWrapper).pointer()
- }
- return piface.CheckInitializedOutput{}, mi.checkInitializedPointer(p)
-}
-
-func (mi *MessageInfo) checkInitializedPointer(p pointer) error {
- mi.init()
- if !mi.needsInitCheck {
- return nil
- }
- if p.IsNil() {
- for _, f := range mi.orderedCoderFields {
- if f.isRequired {
- return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
- }
- }
- return nil
- }
- if mi.extensionOffset.IsValid() {
- e := p.Apply(mi.extensionOffset).Extensions()
- if err := mi.isInitExtensions(e); err != nil {
- return err
- }
- }
- for _, f := range mi.orderedCoderFields {
- if !f.isRequired && f.funcs.isInit == nil {
- continue
- }
- fptr := p.Apply(f.offset)
- if f.isPointer && fptr.Elem().IsNil() {
- if f.isRequired {
- return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
- }
- continue
- }
- if f.funcs.isInit == nil {
- continue
- }
- if err := f.funcs.isInit(fptr, f); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (mi *MessageInfo) isInitExtensions(ext *map[int32]ExtensionField) error {
- if ext == nil {
- return nil
- }
- for _, x := range *ext {
- ei := getExtensionFieldInfo(x.Type())
- if ei.funcs.isInit == nil {
- continue
- }
- v := x.Value()
- if !v.IsValid() {
- continue
- }
- if err := ei.funcs.isInit(v); err != nil {
- return err
- }
- }
- return nil
-}
-
-var (
- needsInitCheckMu sync.Mutex
- needsInitCheckMap sync.Map
-)
-
-// needsInitCheck reports whether a message needs to be checked for partial initialization.
-//
-// It returns true if the message transitively includes any required or extension fields.
-func needsInitCheck(md pref.MessageDescriptor) bool {
- if v, ok := needsInitCheckMap.Load(md); ok {
- if has, ok := v.(bool); ok {
- return has
- }
- }
- needsInitCheckMu.Lock()
- defer needsInitCheckMu.Unlock()
- return needsInitCheckLocked(md)
-}
-
-func needsInitCheckLocked(md pref.MessageDescriptor) (has bool) {
- if v, ok := needsInitCheckMap.Load(md); ok {
- // If has is true, we've previously determined that this message
- // needs init checks.
- //
- // If has is false, we've previously determined that it can never
- // be uninitialized.
- //
- // If has is not a bool, we've just encountered a cycle in the
- // message graph. In this case, it is safe to return false: If
- // the message does have required fields, we'll detect them later
- // in the graph traversal.
- has, ok := v.(bool)
- return ok && has
- }
- needsInitCheckMap.Store(md, struct{}{}) // avoid cycles while descending into this message
- defer func() {
- needsInitCheckMap.Store(md, has)
- }()
- if md.RequiredNumbers().Len() > 0 {
- return true
- }
- if md.ExtensionRanges().Len() > 0 {
- return true
- }
- for i := 0; i < md.Fields().Len(); i++ {
- fd := md.Fields().Get(i)
- // Map keys are never messages, so just consider the map value.
- if fd.IsMap() {
- fd = fd.MapValue()
- }
- fmd := fd.Message()
- if fmd != nil && needsInitCheckLocked(fmd) {
- return true
- }
- }
- return false
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go b/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
deleted file mode 100644
index 08d3517..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "sync"
- "sync/atomic"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/errors"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type extensionFieldInfo struct {
- wiretag uint64
- tagsize int
- unmarshalNeedsValue bool
- funcs valueCoderFuncs
- validation validationInfo
-}
-
-var legacyExtensionFieldInfoCache sync.Map // map[protoreflect.ExtensionType]*extensionFieldInfo
-
-func getExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
- if xi, ok := xt.(*ExtensionInfo); ok {
- xi.lazyInit()
- return xi.info
- }
- return legacyLoadExtensionFieldInfo(xt)
-}
-
-// legacyLoadExtensionFieldInfo dynamically loads a *ExtensionInfo for xt.
-func legacyLoadExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
- if xi, ok := legacyExtensionFieldInfoCache.Load(xt); ok {
- return xi.(*extensionFieldInfo)
- }
- e := makeExtensionFieldInfo(xt.TypeDescriptor())
- if e, ok := legacyMessageTypeCache.LoadOrStore(xt, e); ok {
- return e.(*extensionFieldInfo)
- }
- return e
-}
-
-func makeExtensionFieldInfo(xd pref.ExtensionDescriptor) *extensionFieldInfo {
- var wiretag uint64
- if !xd.IsPacked() {
- wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
- } else {
- wiretag = protowire.EncodeTag(xd.Number(), protowire.BytesType)
- }
- e := &extensionFieldInfo{
- wiretag: wiretag,
- tagsize: protowire.SizeVarint(wiretag),
- funcs: encoderFuncsForValue(xd),
- }
- // Does the unmarshal function need a value passed to it?
- // This is true for composite types, where we pass in a message, list, or map to fill in,
- // and for enums, where we pass in a prototype value to specify the concrete enum type.
- switch xd.Kind() {
- case pref.MessageKind, pref.GroupKind, pref.EnumKind:
- e.unmarshalNeedsValue = true
- default:
- if xd.Cardinality() == pref.Repeated {
- e.unmarshalNeedsValue = true
- }
- }
- return e
-}
-
-type lazyExtensionValue struct {
- atomicOnce uint32 // atomically set if value is valid
- mu sync.Mutex
- xi *extensionFieldInfo
- value pref.Value
- b []byte
- fn func() pref.Value
-}
-
-type ExtensionField struct {
- typ pref.ExtensionType
-
- // value is either the value of GetValue,
- // or a *lazyExtensionValue that then returns the value of GetValue.
- value pref.Value
- lazy *lazyExtensionValue
-}
-
-func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
- if f.lazy == nil {
- f.lazy = &lazyExtensionValue{xi: xi}
- }
- f.typ = xt
- f.lazy.xi = xi
- f.lazy.b = protowire.AppendTag(f.lazy.b, num, wtyp)
- f.lazy.b = append(f.lazy.b, b...)
-}
-
-func (f *ExtensionField) canLazy(xt pref.ExtensionType) bool {
- if f.typ == nil {
- return true
- }
- if f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
- return true
- }
- return false
-}
-
-func (f *ExtensionField) lazyInit() {
- f.lazy.mu.Lock()
- defer f.lazy.mu.Unlock()
- if atomic.LoadUint32(&f.lazy.atomicOnce) == 1 {
- return
- }
- if f.lazy.xi != nil {
- b := f.lazy.b
- val := f.typ.New()
- for len(b) > 0 {
- var tag uint64
- if b[0] < 0x80 {
- tag = uint64(b[0])
- b = b[1:]
- } else if len(b) >= 2 && b[1] < 128 {
- tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
- b = b[2:]
- } else {
- var n int
- tag, n = protowire.ConsumeVarint(b)
- if n < 0 {
- panic(errors.New("bad tag in lazy extension decoding"))
- }
- b = b[n:]
- }
- num := protowire.Number(tag >> 3)
- wtyp := protowire.Type(tag & 7)
- var out unmarshalOutput
- var err error
- val, out, err = f.lazy.xi.funcs.unmarshal(b, val, num, wtyp, lazyUnmarshalOptions)
- if err != nil {
- panic(errors.New("decode failure in lazy extension decoding: %v", err))
- }
- b = b[out.n:]
- }
- f.lazy.value = val
- } else {
- f.lazy.value = f.lazy.fn()
- }
- f.lazy.xi = nil
- f.lazy.fn = nil
- f.lazy.b = nil
- atomic.StoreUint32(&f.lazy.atomicOnce, 1)
-}
-
-// Set sets the type and value of the extension field.
-// This must not be called concurrently.
-func (f *ExtensionField) Set(t pref.ExtensionType, v pref.Value) {
- f.typ = t
- f.value = v
- f.lazy = nil
-}
-
-// SetLazy sets the type and a value that is to be lazily evaluated upon first use.
-// This must not be called concurrently.
-func (f *ExtensionField) SetLazy(t pref.ExtensionType, fn func() pref.Value) {
- f.typ = t
- f.lazy = &lazyExtensionValue{fn: fn}
-}
-
-// Value returns the value of the extension field.
-// This may be called concurrently.
-func (f *ExtensionField) Value() pref.Value {
- if f.lazy != nil {
- if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
- f.lazyInit()
- }
- return f.lazy.value
- }
- return f.value
-}
-
-// Type returns the type of the extension field.
-// This may be called concurrently.
-func (f ExtensionField) Type() pref.ExtensionType {
- return f.typ
-}
-
-// IsSet returns whether the extension field is set.
-// This may be called concurrently.
-func (f ExtensionField) IsSet() bool {
- return f.typ != nil
-}
-
-// IsLazy reports whether a field is lazily encoded.
-// It is exported for testing.
-func IsLazy(m pref.Message, fd pref.FieldDescriptor) bool {
- var mi *MessageInfo
- var p pointer
- switch m := m.(type) {
- case *messageState:
- mi = m.messageInfo()
- p = m.pointer()
- case *messageReflectWrapper:
- mi = m.messageInfo()
- p = m.pointer()
- default:
- return false
- }
- xd, ok := fd.(pref.ExtensionTypeDescriptor)
- if !ok {
- return false
- }
- xt := xd.Type()
- ext := mi.extensionMap(p)
- if ext == nil {
- return false
- }
- f, ok := (*ext)[int32(fd.Number())]
- if !ok {
- return false
- }
- return f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go b/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
deleted file mode 100644
index c00744d..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
+++ /dev/null
@@ -1,828 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "sync"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type errInvalidUTF8 struct{}
-
-func (errInvalidUTF8) Error() string { return "string field contains invalid UTF-8" }
-func (errInvalidUTF8) InvalidUTF8() bool { return true }
-
-// initOneofFieldCoders initializes the fast-path functions for the fields in a oneof.
-//
-// For size, marshal, and isInit operations, functions are set only on the first field
-// in the oneof. The functions are called when the oneof is non-nil, and will dispatch
-// to the appropriate field-specific function as necessary.
-//
-// The unmarshal function is set on each field individually as usual.
-func (mi *MessageInfo) initOneofFieldCoders(od pref.OneofDescriptor, si structInfo) {
- fs := si.oneofsByName[od.Name()]
- ft := fs.Type
- oneofFields := make(map[reflect.Type]*coderFieldInfo)
- needIsInit := false
- fields := od.Fields()
- for i, lim := 0, fields.Len(); i < lim; i++ {
- fd := od.Fields().Get(i)
- num := fd.Number()
- // Make a copy of the original coderFieldInfo for use in unmarshaling.
- //
- // oneofFields[oneofType].funcs.marshal is the field-specific marshal function.
- //
- // mi.coderFields[num].marshal is set on only the first field in the oneof,
- // and dispatches to the field-specific marshaler in oneofFields.
- cf := *mi.coderFields[num]
- ot := si.oneofWrappersByNumber[num]
- cf.ft = ot.Field(0).Type
- cf.mi, cf.funcs = fieldCoder(fd, cf.ft)
- oneofFields[ot] = &cf
- if cf.funcs.isInit != nil {
- needIsInit = true
- }
- mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- var vw reflect.Value // pointer to wrapper type
- vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind
- if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
- vw = vi.Elem()
- } else {
- vw = reflect.New(ot)
- }
- out, err := cf.funcs.unmarshal(b, pointerOfValue(vw).Apply(zeroOffset), wtyp, &cf, opts)
- if err != nil {
- return out, err
- }
- vi.Set(vw)
- return out, nil
- }
- }
- getInfo := func(p pointer) (pointer, *coderFieldInfo) {
- v := p.AsValueOf(ft).Elem()
- if v.IsNil() {
- return pointer{}, nil
- }
- v = v.Elem() // interface -> *struct
- if v.IsNil() {
- return pointer{}, nil
- }
- return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
- }
- first := mi.coderFields[od.Fields().Get(0).Number()]
- first.funcs.size = func(p pointer, _ *coderFieldInfo, opts marshalOptions) int {
- p, info := getInfo(p)
- if info == nil || info.funcs.size == nil {
- return 0
- }
- return info.funcs.size(p, info, opts)
- }
- first.funcs.marshal = func(b []byte, p pointer, _ *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- p, info := getInfo(p)
- if info == nil || info.funcs.marshal == nil {
- return b, nil
- }
- return info.funcs.marshal(b, p, info, opts)
- }
- first.funcs.merge = func(dst, src pointer, _ *coderFieldInfo, opts mergeOptions) {
- srcp, srcinfo := getInfo(src)
- if srcinfo == nil || srcinfo.funcs.merge == nil {
- return
- }
- dstp, dstinfo := getInfo(dst)
- if dstinfo != srcinfo {
- dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))
- dstp = pointerOfValue(dst.AsValueOf(ft).Elem().Elem()).Apply(zeroOffset)
- }
- srcinfo.funcs.merge(dstp, srcp, srcinfo, opts)
- }
- if needIsInit {
- first.funcs.isInit = func(p pointer, _ *coderFieldInfo) error {
- p, info := getInfo(p)
- if info == nil || info.funcs.isInit == nil {
- return nil
- }
- return info.funcs.isInit(p, info)
- }
- }
-}
-
-func makeWeakMessageFieldCoder(fd pref.FieldDescriptor) pointerCoderFuncs {
- var once sync.Once
- var messageType pref.MessageType
- lazyInit := func() {
- once.Do(func() {
- messageName := fd.Message().FullName()
- messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
- })
- }
-
- return pointerCoderFuncs{
- size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- m, ok := p.WeakFields().get(f.num)
- if !ok {
- return 0
- }
- lazyInit()
- if messageType == nil {
- panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
- }
- return sizeMessage(m, f.tagsize, opts)
- },
- marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- m, ok := p.WeakFields().get(f.num)
- if !ok {
- return b, nil
- }
- lazyInit()
- if messageType == nil {
- panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
- }
- return appendMessage(b, m, f.wiretag, opts)
- },
- unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- fs := p.WeakFields()
- m, ok := fs.get(f.num)
- if !ok {
- lazyInit()
- if messageType == nil {
- return unmarshalOutput{}, errUnknown
- }
- m = messageType.New().Interface()
- fs.set(f.num, m)
- }
- return consumeMessage(b, m, wtyp, opts)
- },
- isInit: func(p pointer, f *coderFieldInfo) error {
- m, ok := p.WeakFields().get(f.num)
- if !ok {
- return nil
- }
- return proto.CheckInitialized(m)
- },
- merge: func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
- sm, ok := src.WeakFields().get(f.num)
- if !ok {
- return
- }
- dm, ok := dst.WeakFields().get(f.num)
- if !ok {
- lazyInit()
- if messageType == nil {
- panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
- }
- dm = messageType.New().Interface()
- dst.WeakFields().set(f.num, dm)
- }
- opts.Merge(dm, sm)
- },
- }
-}
-
-func makeMessageFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
- if mi := getMessageInfo(ft); mi != nil {
- funcs := pointerCoderFuncs{
- size: sizeMessageInfo,
- marshal: appendMessageInfo,
- unmarshal: consumeMessageInfo,
- merge: mergeMessage,
- }
- if needsInitCheck(mi.Desc) {
- funcs.isInit = isInitMessageInfo
- }
- return funcs
- } else {
- return pointerCoderFuncs{
- size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- m := asMessage(p.AsValueOf(ft).Elem())
- return sizeMessage(m, f.tagsize, opts)
- },
- marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- m := asMessage(p.AsValueOf(ft).Elem())
- return appendMessage(b, m, f.wiretag, opts)
- },
- unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- mp := p.AsValueOf(ft).Elem()
- if mp.IsNil() {
- mp.Set(reflect.New(ft.Elem()))
- }
- return consumeMessage(b, asMessage(mp), wtyp, opts)
- },
- isInit: func(p pointer, f *coderFieldInfo) error {
- m := asMessage(p.AsValueOf(ft).Elem())
- return proto.CheckInitialized(m)
- },
- merge: mergeMessage,
- }
- }
-}
-
-func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- return protowire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize
-}
-
-func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts)))
- return f.mi.marshalAppendPointer(b, p.Elem(), opts)
-}
-
-func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if p.Elem().IsNil() {
- p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
- }
- o, err := f.mi.unmarshalPointer(v, p.Elem(), 0, opts)
- if err != nil {
- return out, err
- }
- out.n = n
- out.initialized = o.initialized
- return out, nil
-}
-
-func isInitMessageInfo(p pointer, f *coderFieldInfo) error {
- return f.mi.checkInitializedPointer(p.Elem())
-}
-
-func sizeMessage(m proto.Message, tagsize int, _ marshalOptions) int {
- return protowire.SizeBytes(proto.Size(m)) + tagsize
-}
-
-func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(proto.Size(m)))
- return opts.Options().MarshalAppend(b, m)
-}
-
-func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
- Buf: v,
- Message: m.ProtoReflect(),
- })
- if err != nil {
- return out, err
- }
- out.n = n
- out.initialized = o.Flags&piface.UnmarshalInitialized != 0
- return out, nil
-}
-
-func sizeMessageValue(v pref.Value, tagsize int, opts marshalOptions) int {
- m := v.Message().Interface()
- return sizeMessage(m, tagsize, opts)
-}
-
-func appendMessageValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
- m := v.Message().Interface()
- return appendMessage(b, m, wiretag, opts)
-}
-
-func consumeMessageValue(b []byte, v pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
- m := v.Message().Interface()
- out, err := consumeMessage(b, m, wtyp, opts)
- return v, out, err
-}
-
-func isInitMessageValue(v pref.Value) error {
- m := v.Message().Interface()
- return proto.CheckInitialized(m)
-}
-
-var coderMessageValue = valueCoderFuncs{
- size: sizeMessageValue,
- marshal: appendMessageValue,
- unmarshal: consumeMessageValue,
- isInit: isInitMessageValue,
- merge: mergeMessageValue,
-}
-
-func sizeGroupValue(v pref.Value, tagsize int, opts marshalOptions) int {
- m := v.Message().Interface()
- return sizeGroup(m, tagsize, opts)
-}
-
-func appendGroupValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
- m := v.Message().Interface()
- return appendGroup(b, m, wiretag, opts)
-}
-
-func consumeGroupValue(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
- m := v.Message().Interface()
- out, err := consumeGroup(b, m, num, wtyp, opts)
- return v, out, err
-}
-
-var coderGroupValue = valueCoderFuncs{
- size: sizeGroupValue,
- marshal: appendGroupValue,
- unmarshal: consumeGroupValue,
- isInit: isInitMessageValue,
- merge: mergeMessageValue,
-}
-
-func makeGroupFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
- num := fd.Number()
- if mi := getMessageInfo(ft); mi != nil {
- funcs := pointerCoderFuncs{
- size: sizeGroupType,
- marshal: appendGroupType,
- unmarshal: consumeGroupType,
- merge: mergeMessage,
- }
- if needsInitCheck(mi.Desc) {
- funcs.isInit = isInitMessageInfo
- }
- return funcs
- } else {
- return pointerCoderFuncs{
- size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- m := asMessage(p.AsValueOf(ft).Elem())
- return sizeGroup(m, f.tagsize, opts)
- },
- marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- m := asMessage(p.AsValueOf(ft).Elem())
- return appendGroup(b, m, f.wiretag, opts)
- },
- unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- mp := p.AsValueOf(ft).Elem()
- if mp.IsNil() {
- mp.Set(reflect.New(ft.Elem()))
- }
- return consumeGroup(b, asMessage(mp), num, wtyp, opts)
- },
- isInit: func(p pointer, f *coderFieldInfo) error {
- m := asMessage(p.AsValueOf(ft).Elem())
- return proto.CheckInitialized(m)
- },
- merge: mergeMessage,
- }
- }
-}
-
-func sizeGroupType(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- return 2*f.tagsize + f.mi.sizePointer(p.Elem(), opts)
-}
-
-func appendGroupType(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, f.wiretag) // start group
- b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts)
- b = protowire.AppendVarint(b, f.wiretag+1) // end group
- return b, err
-}
-
-func consumeGroupType(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.StartGroupType {
- return out, errUnknown
- }
- if p.Elem().IsNil() {
- p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
- }
- return f.mi.unmarshalPointer(b, p.Elem(), f.num, opts)
-}
-
-func sizeGroup(m proto.Message, tagsize int, _ marshalOptions) int {
- return 2*tagsize + proto.Size(m)
-}
-
-func appendGroup(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag) // start group
- b, err := opts.Options().MarshalAppend(b, m)
- b = protowire.AppendVarint(b, wiretag+1) // end group
- return b, err
-}
-
-func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.StartGroupType {
- return out, errUnknown
- }
- b, n := protowire.ConsumeGroup(num, b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
- Buf: b,
- Message: m.ProtoReflect(),
- })
- if err != nil {
- return out, err
- }
- out.n = n
- out.initialized = o.Flags&piface.UnmarshalInitialized != 0
- return out, nil
-}
-
-func makeMessageSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
- if mi := getMessageInfo(ft); mi != nil {
- funcs := pointerCoderFuncs{
- size: sizeMessageSliceInfo,
- marshal: appendMessageSliceInfo,
- unmarshal: consumeMessageSliceInfo,
- merge: mergeMessageSlice,
- }
- if needsInitCheck(mi.Desc) {
- funcs.isInit = isInitMessageSliceInfo
- }
- return funcs
- }
- return pointerCoderFuncs{
- size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- return sizeMessageSlice(p, ft, f.tagsize, opts)
- },
- marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- return appendMessageSlice(b, p, f.wiretag, ft, opts)
- },
- unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- return consumeMessageSlice(b, p, ft, wtyp, opts)
- },
- isInit: func(p pointer, f *coderFieldInfo) error {
- return isInitMessageSlice(p, ft)
- },
- merge: mergeMessageSlice,
- }
-}
-
-func sizeMessageSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- s := p.PointerSlice()
- n := 0
- for _, v := range s {
- n += protowire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
- }
- return n
-}
-
-func appendMessageSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- s := p.PointerSlice()
- var err error
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- siz := f.mi.sizePointer(v, opts)
- b = protowire.AppendVarint(b, uint64(siz))
- b, err = f.mi.marshalAppendPointer(b, v, opts)
- if err != nil {
- return b, err
- }
- }
- return b, nil
-}
-
-func consumeMessageSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
- mp := pointerOfIface(m)
- o, err := f.mi.unmarshalPointer(v, mp, 0, opts)
- if err != nil {
- return out, err
- }
- p.AppendPointerSlice(mp)
- out.n = n
- out.initialized = o.initialized
- return out, nil
-}
-
-func isInitMessageSliceInfo(p pointer, f *coderFieldInfo) error {
- s := p.PointerSlice()
- for _, v := range s {
- if err := f.mi.checkInitializedPointer(v); err != nil {
- return err
- }
- }
- return nil
-}
-
-func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, _ marshalOptions) int {
- s := p.PointerSlice()
- n := 0
- for _, v := range s {
- m := asMessage(v.AsValueOf(goType.Elem()))
- n += protowire.SizeBytes(proto.Size(m)) + tagsize
- }
- return n
-}
-
-func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
- s := p.PointerSlice()
- var err error
- for _, v := range s {
- m := asMessage(v.AsValueOf(goType.Elem()))
- b = protowire.AppendVarint(b, wiretag)
- siz := proto.Size(m)
- b = protowire.AppendVarint(b, uint64(siz))
- b, err = opts.Options().MarshalAppend(b, m)
- if err != nil {
- return b, err
- }
- }
- return b, nil
-}
-
-func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- mp := reflect.New(goType.Elem())
- o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
- Buf: v,
- Message: asMessage(mp).ProtoReflect(),
- })
- if err != nil {
- return out, err
- }
- p.AppendPointerSlice(pointerOfValue(mp))
- out.n = n
- out.initialized = o.Flags&piface.UnmarshalInitialized != 0
- return out, nil
-}
-
-func isInitMessageSlice(p pointer, goType reflect.Type) error {
- s := p.PointerSlice()
- for _, v := range s {
- m := asMessage(v.AsValueOf(goType.Elem()))
- if err := proto.CheckInitialized(m); err != nil {
- return err
- }
- }
- return nil
-}
-
-// Slices of messages
-
-func sizeMessageSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int {
- list := listv.List()
- n := 0
- for i, llen := 0, list.Len(); i < llen; i++ {
- m := list.Get(i).Message().Interface()
- n += protowire.SizeBytes(proto.Size(m)) + tagsize
- }
- return n
-}
-
-func appendMessageSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
- list := listv.List()
- mopts := opts.Options()
- for i, llen := 0, list.Len(); i < llen; i++ {
- m := list.Get(i).Message().Interface()
- b = protowire.AppendVarint(b, wiretag)
- siz := proto.Size(m)
- b = protowire.AppendVarint(b, uint64(siz))
- var err error
- b, err = mopts.MarshalAppend(b, m)
- if err != nil {
- return b, err
- }
- }
- return b, nil
-}
-
-func consumeMessageSliceValue(b []byte, listv pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp != protowire.BytesType {
- return pref.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return pref.Value{}, out, protowire.ParseError(n)
- }
- m := list.NewElement()
- o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
- Buf: v,
- Message: m.Message(),
- })
- if err != nil {
- return pref.Value{}, out, err
- }
- list.Append(m)
- out.n = n
- out.initialized = o.Flags&piface.UnmarshalInitialized != 0
- return listv, out, nil
-}
-
-func isInitMessageSliceValue(listv pref.Value) error {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- m := list.Get(i).Message().Interface()
- if err := proto.CheckInitialized(m); err != nil {
- return err
- }
- }
- return nil
-}
-
-var coderMessageSliceValue = valueCoderFuncs{
- size: sizeMessageSliceValue,
- marshal: appendMessageSliceValue,
- unmarshal: consumeMessageSliceValue,
- isInit: isInitMessageSliceValue,
- merge: mergeMessageListValue,
-}
-
-func sizeGroupSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int {
- list := listv.List()
- n := 0
- for i, llen := 0, list.Len(); i < llen; i++ {
- m := list.Get(i).Message().Interface()
- n += 2*tagsize + proto.Size(m)
- }
- return n
-}
-
-func appendGroupSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
- list := listv.List()
- mopts := opts.Options()
- for i, llen := 0, list.Len(); i < llen; i++ {
- m := list.Get(i).Message().Interface()
- b = protowire.AppendVarint(b, wiretag) // start group
- var err error
- b, err = mopts.MarshalAppend(b, m)
- if err != nil {
- return b, err
- }
- b = protowire.AppendVarint(b, wiretag+1) // end group
- }
- return b, nil
-}
-
-func consumeGroupSliceValue(b []byte, listv pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp != protowire.StartGroupType {
- return pref.Value{}, out, errUnknown
- }
- b, n := protowire.ConsumeGroup(num, b)
- if n < 0 {
- return pref.Value{}, out, protowire.ParseError(n)
- }
- m := list.NewElement()
- o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
- Buf: b,
- Message: m.Message(),
- })
- if err != nil {
- return pref.Value{}, out, err
- }
- list.Append(m)
- out.n = n
- out.initialized = o.Flags&piface.UnmarshalInitialized != 0
- return listv, out, nil
-}
-
-var coderGroupSliceValue = valueCoderFuncs{
- size: sizeGroupSliceValue,
- marshal: appendGroupSliceValue,
- unmarshal: consumeGroupSliceValue,
- isInit: isInitMessageSliceValue,
- merge: mergeMessageListValue,
-}
-
-func makeGroupSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
- num := fd.Number()
- if mi := getMessageInfo(ft); mi != nil {
- funcs := pointerCoderFuncs{
- size: sizeGroupSliceInfo,
- marshal: appendGroupSliceInfo,
- unmarshal: consumeGroupSliceInfo,
- merge: mergeMessageSlice,
- }
- if needsInitCheck(mi.Desc) {
- funcs.isInit = isInitMessageSliceInfo
- }
- return funcs
- }
- return pointerCoderFuncs{
- size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- return sizeGroupSlice(p, ft, f.tagsize, opts)
- },
- marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- return appendGroupSlice(b, p, f.wiretag, ft, opts)
- },
- unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- return consumeGroupSlice(b, p, num, wtyp, ft, opts)
- },
- isInit: func(p pointer, f *coderFieldInfo) error {
- return isInitMessageSlice(p, ft)
- },
- merge: mergeMessageSlice,
- }
-}
-
-func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, _ marshalOptions) int {
- s := p.PointerSlice()
- n := 0
- for _, v := range s {
- m := asMessage(v.AsValueOf(messageType.Elem()))
- n += 2*tagsize + proto.Size(m)
- }
- return n
-}
-
-func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
- s := p.PointerSlice()
- var err error
- for _, v := range s {
- m := asMessage(v.AsValueOf(messageType.Elem()))
- b = protowire.AppendVarint(b, wiretag) // start group
- b, err = opts.Options().MarshalAppend(b, m)
- if err != nil {
- return b, err
- }
- b = protowire.AppendVarint(b, wiretag+1) // end group
- }
- return b, nil
-}
-
-func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.StartGroupType {
- return out, errUnknown
- }
- b, n := protowire.ConsumeGroup(num, b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- mp := reflect.New(goType.Elem())
- o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
- Buf: b,
- Message: asMessage(mp).ProtoReflect(),
- })
- if err != nil {
- return out, err
- }
- p.AppendPointerSlice(pointerOfValue(mp))
- out.n = n
- out.initialized = o.Flags&piface.UnmarshalInitialized != 0
- return out, nil
-}
-
-func sizeGroupSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- s := p.PointerSlice()
- n := 0
- for _, v := range s {
- n += 2*f.tagsize + f.mi.sizePointer(v, opts)
- }
- return n
-}
-
-func appendGroupSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- s := p.PointerSlice()
- var err error
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag) // start group
- b, err = f.mi.marshalAppendPointer(b, v, opts)
- if err != nil {
- return b, err
- }
- b = protowire.AppendVarint(b, f.wiretag+1) // end group
- }
- return b, nil
-}
-
-func consumeGroupSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- if wtyp != protowire.StartGroupType {
- return unmarshalOutput{}, errUnknown
- }
- m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
- mp := pointerOfIface(m)
- out, err := f.mi.unmarshalPointer(b, mp, f.num, opts)
- if err != nil {
- return out, err
- }
- p.AppendPointerSlice(mp)
- return out, nil
-}
-
-func asMessage(v reflect.Value) pref.ProtoMessage {
- if m, ok := v.Interface().(pref.ProtoMessage); ok {
- return m
- }
- return legacyWrapMessage(v).Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go b/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go
deleted file mode 100644
index ff198d0..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go
+++ /dev/null
@@ -1,5637 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package impl
-
-import (
- "math"
- "unicode/utf8"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// sizeBool returns the size of wire encoding a bool pointer as a Bool.
-func sizeBool(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Bool()
- return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-}
-
-// appendBool wire encodes a bool pointer as a Bool.
-func appendBool(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Bool()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v))
- return b, nil
-}
-
-// consumeBool wire decodes a bool pointer as a Bool.
-func consumeBool(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Bool() = protowire.DecodeBool(v)
- out.n = n
- return out, nil
-}
-
-var coderBool = pointerCoderFuncs{
- size: sizeBool,
- marshal: appendBool,
- unmarshal: consumeBool,
- merge: mergeBool,
-}
-
-// sizeBoolNoZero returns the size of wire encoding a bool pointer as a Bool.
-// The zero value is not encoded.
-func sizeBoolNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Bool()
- if v == false {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-}
-
-// appendBoolNoZero wire encodes a bool pointer as a Bool.
-// The zero value is not encoded.
-func appendBoolNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Bool()
- if v == false {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v))
- return b, nil
-}
-
-var coderBoolNoZero = pointerCoderFuncs{
- size: sizeBoolNoZero,
- marshal: appendBoolNoZero,
- unmarshal: consumeBool,
- merge: mergeBoolNoZero,
-}
-
-// sizeBoolPtr returns the size of wire encoding a *bool pointer as a Bool.
-// It panics if the pointer is nil.
-func sizeBoolPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.BoolPtr()
- return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-}
-
-// appendBoolPtr wire encodes a *bool pointer as a Bool.
-// It panics if the pointer is nil.
-func appendBoolPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.BoolPtr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v))
- return b, nil
-}
-
-// consumeBoolPtr wire decodes a *bool pointer as a Bool.
-func consumeBoolPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.BoolPtr()
- if *vp == nil {
- *vp = new(bool)
- }
- **vp = protowire.DecodeBool(v)
- out.n = n
- return out, nil
-}
-
-var coderBoolPtr = pointerCoderFuncs{
- size: sizeBoolPtr,
- marshal: appendBoolPtr,
- unmarshal: consumeBoolPtr,
- merge: mergeBoolPtr,
-}
-
-// sizeBoolSlice returns the size of wire encoding a []bool pointer as a repeated Bool.
-func sizeBoolSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.BoolSlice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
- }
- return size
-}
-
-// appendBoolSlice encodes a []bool pointer as a repeated Bool.
-func appendBoolSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.BoolSlice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v))
- }
- return b, nil
-}
-
-// consumeBoolSlice wire decodes a []bool pointer as a repeated Bool.
-func consumeBoolSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.BoolSlice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, protowire.DecodeBool(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, protowire.DecodeBool(v))
- out.n = n
- return out, nil
-}
-
-var coderBoolSlice = pointerCoderFuncs{
- size: sizeBoolSlice,
- marshal: appendBoolSlice,
- unmarshal: consumeBoolSlice,
- merge: mergeBoolSlice,
-}
-
-// sizeBoolPackedSlice returns the size of wire encoding a []bool pointer as a packed repeated Bool.
-func sizeBoolPackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.BoolSlice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(protowire.EncodeBool(v))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool.
-func appendBoolPackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.BoolSlice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(protowire.EncodeBool(v))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, protowire.EncodeBool(v))
- }
- return b, nil
-}
-
-var coderBoolPackedSlice = pointerCoderFuncs{
- size: sizeBoolPackedSlice,
- marshal: appendBoolPackedSlice,
- unmarshal: consumeBoolSlice,
- merge: mergeBoolSlice,
-}
-
-// sizeBoolValue returns the size of wire encoding a bool value as a Bool.
-func sizeBoolValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
-}
-
-// appendBoolValue encodes a bool value as a Bool.
-func appendBoolValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
- return b, nil
-}
-
-// consumeBoolValue decodes a bool value as a Bool.
-func consumeBoolValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfBool(protowire.DecodeBool(v)), out, nil
-}
-
-var coderBoolValue = valueCoderFuncs{
- size: sizeBoolValue,
- marshal: appendBoolValue,
- unmarshal: consumeBoolValue,
- merge: mergeScalarValue,
-}
-
-// sizeBoolSliceValue returns the size of wire encoding a []bool value as a repeated Bool.
-func sizeBoolSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
- }
- return size
-}
-
-// appendBoolSliceValue encodes a []bool value as a repeated Bool.
-func appendBoolSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
- }
- return b, nil
-}
-
-// consumeBoolSliceValue wire decodes a []bool value as a repeated Bool.
-func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderBoolSliceValue = valueCoderFuncs{
- size: sizeBoolSliceValue,
- marshal: appendBoolSliceValue,
- unmarshal: consumeBoolSliceValue,
- merge: mergeListValue,
-}
-
-// sizeBoolPackedSliceValue returns the size of wire encoding a []bool value as a packed repeated Bool.
-func sizeBoolPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendBoolPackedSliceValue encodes a []bool value as a packed repeated Bool.
-func appendBoolPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
- }
- return b, nil
-}
-
-var coderBoolPackedSliceValue = valueCoderFuncs{
- size: sizeBoolPackedSliceValue,
- marshal: appendBoolPackedSliceValue,
- unmarshal: consumeBoolSliceValue,
- merge: mergeListValue,
-}
-
-// sizeEnumValue returns the size of wire encoding a value as a Enum.
-func sizeEnumValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(uint64(v.Enum()))
-}
-
-// appendEnumValue encodes a value as a Enum.
-func appendEnumValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(v.Enum()))
- return b, nil
-}
-
-// consumeEnumValue decodes a value as a Enum.
-func consumeEnumValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), out, nil
-}
-
-var coderEnumValue = valueCoderFuncs{
- size: sizeEnumValue,
- marshal: appendEnumValue,
- unmarshal: consumeEnumValue,
- merge: mergeScalarValue,
-}
-
-// sizeEnumSliceValue returns the size of wire encoding a [] value as a repeated Enum.
-func sizeEnumSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(uint64(v.Enum()))
- }
- return size
-}
-
-// appendEnumSliceValue encodes a [] value as a repeated Enum.
-func appendEnumSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(v.Enum()))
- }
- return b, nil
-}
-
-// consumeEnumSliceValue wire decodes a [] value as a repeated Enum.
-func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderEnumSliceValue = valueCoderFuncs{
- size: sizeEnumSliceValue,
- marshal: appendEnumSliceValue,
- unmarshal: consumeEnumSliceValue,
- merge: mergeListValue,
-}
-
-// sizeEnumPackedSliceValue returns the size of wire encoding a [] value as a packed repeated Enum.
-func sizeEnumPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(v.Enum()))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendEnumPackedSliceValue encodes a [] value as a packed repeated Enum.
-func appendEnumPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(v.Enum()))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, uint64(v.Enum()))
- }
- return b, nil
-}
-
-var coderEnumPackedSliceValue = valueCoderFuncs{
- size: sizeEnumPackedSliceValue,
- marshal: appendEnumPackedSliceValue,
- unmarshal: consumeEnumSliceValue,
- merge: mergeListValue,
-}
-
-// sizeInt32 returns the size of wire encoding a int32 pointer as a Int32.
-func sizeInt32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int32()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt32 wire encodes a int32 pointer as a Int32.
-func appendInt32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int32()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-// consumeInt32 wire decodes a int32 pointer as a Int32.
-func consumeInt32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Int32() = int32(v)
- out.n = n
- return out, nil
-}
-
-var coderInt32 = pointerCoderFuncs{
- size: sizeInt32,
- marshal: appendInt32,
- unmarshal: consumeInt32,
- merge: mergeInt32,
-}
-
-// sizeInt32NoZero returns the size of wire encoding a int32 pointer as a Int32.
-// The zero value is not encoded.
-func sizeInt32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int32()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt32NoZero wire encodes a int32 pointer as a Int32.
-// The zero value is not encoded.
-func appendInt32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int32()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-var coderInt32NoZero = pointerCoderFuncs{
- size: sizeInt32NoZero,
- marshal: appendInt32NoZero,
- unmarshal: consumeInt32,
- merge: mergeInt32NoZero,
-}
-
-// sizeInt32Ptr returns the size of wire encoding a *int32 pointer as a Int32.
-// It panics if the pointer is nil.
-func sizeInt32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.Int32Ptr()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt32Ptr wire encodes a *int32 pointer as a Int32.
-// It panics if the pointer is nil.
-func appendInt32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Int32Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-// consumeInt32Ptr wire decodes a *int32 pointer as a Int32.
-func consumeInt32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Int32Ptr()
- if *vp == nil {
- *vp = new(int32)
- }
- **vp = int32(v)
- out.n = n
- return out, nil
-}
-
-var coderInt32Ptr = pointerCoderFuncs{
- size: sizeInt32Ptr,
- marshal: appendInt32Ptr,
- unmarshal: consumeInt32Ptr,
- merge: mergeInt32Ptr,
-}
-
-// sizeInt32Slice returns the size of wire encoding a []int32 pointer as a repeated Int32.
-func sizeInt32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int32Slice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(uint64(v))
- }
- return size
-}
-
-// appendInt32Slice encodes a []int32 pointer as a repeated Int32.
-func appendInt32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int32Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- }
- return b, nil
-}
-
-// consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32.
-func consumeInt32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Int32Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, int32(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, int32(v))
- out.n = n
- return out, nil
-}
-
-var coderInt32Slice = pointerCoderFuncs{
- size: sizeInt32Slice,
- marshal: appendInt32Slice,
- unmarshal: consumeInt32Slice,
- merge: mergeInt32Slice,
-}
-
-// sizeInt32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Int32.
-func sizeInt32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int32Slice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(uint64(v))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32.
-func appendInt32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int32Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(uint64(v))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, uint64(v))
- }
- return b, nil
-}
-
-var coderInt32PackedSlice = pointerCoderFuncs{
- size: sizeInt32PackedSlice,
- marshal: appendInt32PackedSlice,
- unmarshal: consumeInt32Slice,
- merge: mergeInt32Slice,
-}
-
-// sizeInt32Value returns the size of wire encoding a int32 value as a Int32.
-func sizeInt32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
-}
-
-// appendInt32Value encodes a int32 value as a Int32.
-func appendInt32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(int32(v.Int())))
- return b, nil
-}
-
-// consumeInt32Value decodes a int32 value as a Int32.
-func consumeInt32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfInt32(int32(v)), out, nil
-}
-
-var coderInt32Value = valueCoderFuncs{
- size: sizeInt32Value,
- marshal: appendInt32Value,
- unmarshal: consumeInt32Value,
- merge: mergeScalarValue,
-}
-
-// sizeInt32SliceValue returns the size of wire encoding a []int32 value as a repeated Int32.
-func sizeInt32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
- }
- return size
-}
-
-// appendInt32SliceValue encodes a []int32 value as a repeated Int32.
-func appendInt32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(int32(v.Int())))
- }
- return b, nil
-}
-
-// consumeInt32SliceValue wire decodes a []int32 value as a repeated Int32.
-func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderInt32SliceValue = valueCoderFuncs{
- size: sizeInt32SliceValue,
- marshal: appendInt32SliceValue,
- unmarshal: consumeInt32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeInt32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Int32.
-func sizeInt32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(int32(v.Int())))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt32PackedSliceValue encodes a []int32 value as a packed repeated Int32.
-func appendInt32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(int32(v.Int())))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, uint64(int32(v.Int())))
- }
- return b, nil
-}
-
-var coderInt32PackedSliceValue = valueCoderFuncs{
- size: sizeInt32PackedSliceValue,
- marshal: appendInt32PackedSliceValue,
- unmarshal: consumeInt32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32.
-func sizeSint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int32()
- return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-}
-
-// appendSint32 wire encodes a int32 pointer as a Sint32.
-func appendSint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int32()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
- return b, nil
-}
-
-// consumeSint32 wire decodes a int32 pointer as a Sint32.
-func consumeSint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Int32() = int32(protowire.DecodeZigZag(v & math.MaxUint32))
- out.n = n
- return out, nil
-}
-
-var coderSint32 = pointerCoderFuncs{
- size: sizeSint32,
- marshal: appendSint32,
- unmarshal: consumeSint32,
- merge: mergeInt32,
-}
-
-// sizeSint32NoZero returns the size of wire encoding a int32 pointer as a Sint32.
-// The zero value is not encoded.
-func sizeSint32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int32()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-}
-
-// appendSint32NoZero wire encodes a int32 pointer as a Sint32.
-// The zero value is not encoded.
-func appendSint32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int32()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
- return b, nil
-}
-
-var coderSint32NoZero = pointerCoderFuncs{
- size: sizeSint32NoZero,
- marshal: appendSint32NoZero,
- unmarshal: consumeSint32,
- merge: mergeInt32NoZero,
-}
-
-// sizeSint32Ptr returns the size of wire encoding a *int32 pointer as a Sint32.
-// It panics if the pointer is nil.
-func sizeSint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.Int32Ptr()
- return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-}
-
-// appendSint32Ptr wire encodes a *int32 pointer as a Sint32.
-// It panics if the pointer is nil.
-func appendSint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Int32Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
- return b, nil
-}
-
-// consumeSint32Ptr wire decodes a *int32 pointer as a Sint32.
-func consumeSint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Int32Ptr()
- if *vp == nil {
- *vp = new(int32)
- }
- **vp = int32(protowire.DecodeZigZag(v & math.MaxUint32))
- out.n = n
- return out, nil
-}
-
-var coderSint32Ptr = pointerCoderFuncs{
- size: sizeSint32Ptr,
- marshal: appendSint32Ptr,
- unmarshal: consumeSint32Ptr,
- merge: mergeInt32Ptr,
-}
-
-// sizeSint32Slice returns the size of wire encoding a []int32 pointer as a repeated Sint32.
-func sizeSint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int32Slice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
- }
- return size
-}
-
-// appendSint32Slice encodes a []int32 pointer as a repeated Sint32.
-func appendSint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int32Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
- }
- return b, nil
-}
-
-// consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32.
-func consumeSint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Int32Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
- out.n = n
- return out, nil
-}
-
-var coderSint32Slice = pointerCoderFuncs{
- size: sizeSint32Slice,
- marshal: appendSint32Slice,
- unmarshal: consumeSint32Slice,
- merge: mergeInt32Slice,
-}
-
-// sizeSint32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sint32.
-func sizeSint32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int32Slice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32.
-func appendSint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int32Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
- }
- return b, nil
-}
-
-var coderSint32PackedSlice = pointerCoderFuncs{
- size: sizeSint32PackedSlice,
- marshal: appendSint32PackedSlice,
- unmarshal: consumeSint32Slice,
- merge: mergeInt32Slice,
-}
-
-// sizeSint32Value returns the size of wire encoding a int32 value as a Sint32.
-func sizeSint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
-}
-
-// appendSint32Value encodes a int32 value as a Sint32.
-func appendSint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
- return b, nil
-}
-
-// consumeSint32Value decodes a int32 value as a Sint32.
-func consumeSint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), out, nil
-}
-
-var coderSint32Value = valueCoderFuncs{
- size: sizeSint32Value,
- marshal: appendSint32Value,
- unmarshal: consumeSint32Value,
- merge: mergeScalarValue,
-}
-
-// sizeSint32SliceValue returns the size of wire encoding a []int32 value as a repeated Sint32.
-func sizeSint32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
- }
- return size
-}
-
-// appendSint32SliceValue encodes a []int32 value as a repeated Sint32.
-func appendSint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
- }
- return b, nil
-}
-
-// consumeSint32SliceValue wire decodes a []int32 value as a repeated Sint32.
-func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
- out.n = n
- return listv, out, nil
-}
-
-var coderSint32SliceValue = valueCoderFuncs{
- size: sizeSint32SliceValue,
- marshal: appendSint32SliceValue,
- unmarshal: consumeSint32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSint32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sint32.
-func sizeSint32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint32PackedSliceValue encodes a []int32 value as a packed repeated Sint32.
-func appendSint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
- }
- return b, nil
-}
-
-var coderSint32PackedSliceValue = valueCoderFuncs{
- size: sizeSint32PackedSliceValue,
- marshal: appendSint32PackedSliceValue,
- unmarshal: consumeSint32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32.
-func sizeUint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Uint32()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendUint32 wire encodes a uint32 pointer as a Uint32.
-func appendUint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint32()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-// consumeUint32 wire decodes a uint32 pointer as a Uint32.
-func consumeUint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Uint32() = uint32(v)
- out.n = n
- return out, nil
-}
-
-var coderUint32 = pointerCoderFuncs{
- size: sizeUint32,
- marshal: appendUint32,
- unmarshal: consumeUint32,
- merge: mergeUint32,
-}
-
-// sizeUint32NoZero returns the size of wire encoding a uint32 pointer as a Uint32.
-// The zero value is not encoded.
-func sizeUint32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Uint32()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendUint32NoZero wire encodes a uint32 pointer as a Uint32.
-// The zero value is not encoded.
-func appendUint32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint32()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-var coderUint32NoZero = pointerCoderFuncs{
- size: sizeUint32NoZero,
- marshal: appendUint32NoZero,
- unmarshal: consumeUint32,
- merge: mergeUint32NoZero,
-}
-
-// sizeUint32Ptr returns the size of wire encoding a *uint32 pointer as a Uint32.
-// It panics if the pointer is nil.
-func sizeUint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.Uint32Ptr()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendUint32Ptr wire encodes a *uint32 pointer as a Uint32.
-// It panics if the pointer is nil.
-func appendUint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Uint32Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-// consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32.
-func consumeUint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Uint32Ptr()
- if *vp == nil {
- *vp = new(uint32)
- }
- **vp = uint32(v)
- out.n = n
- return out, nil
-}
-
-var coderUint32Ptr = pointerCoderFuncs{
- size: sizeUint32Ptr,
- marshal: appendUint32Ptr,
- unmarshal: consumeUint32Ptr,
- merge: mergeUint32Ptr,
-}
-
-// sizeUint32Slice returns the size of wire encoding a []uint32 pointer as a repeated Uint32.
-func sizeUint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint32Slice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(uint64(v))
- }
- return size
-}
-
-// appendUint32Slice encodes a []uint32 pointer as a repeated Uint32.
-func appendUint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint32Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- }
- return b, nil
-}
-
-// consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32.
-func consumeUint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Uint32Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, uint32(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, uint32(v))
- out.n = n
- return out, nil
-}
-
-var coderUint32Slice = pointerCoderFuncs{
- size: sizeUint32Slice,
- marshal: appendUint32Slice,
- unmarshal: consumeUint32Slice,
- merge: mergeUint32Slice,
-}
-
-// sizeUint32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Uint32.
-func sizeUint32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint32Slice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(uint64(v))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32.
-func appendUint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint32Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(uint64(v))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, uint64(v))
- }
- return b, nil
-}
-
-var coderUint32PackedSlice = pointerCoderFuncs{
- size: sizeUint32PackedSlice,
- marshal: appendUint32PackedSlice,
- unmarshal: consumeUint32Slice,
- merge: mergeUint32Slice,
-}
-
-// sizeUint32Value returns the size of wire encoding a uint32 value as a Uint32.
-func sizeUint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
-}
-
-// appendUint32Value encodes a uint32 value as a Uint32.
-func appendUint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
- return b, nil
-}
-
-// consumeUint32Value decodes a uint32 value as a Uint32.
-func consumeUint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfUint32(uint32(v)), out, nil
-}
-
-var coderUint32Value = valueCoderFuncs{
- size: sizeUint32Value,
- marshal: appendUint32Value,
- unmarshal: consumeUint32Value,
- merge: mergeScalarValue,
-}
-
-// sizeUint32SliceValue returns the size of wire encoding a []uint32 value as a repeated Uint32.
-func sizeUint32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
- }
- return size
-}
-
-// appendUint32SliceValue encodes a []uint32 value as a repeated Uint32.
-func appendUint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
- }
- return b, nil
-}
-
-// consumeUint32SliceValue wire decodes a []uint32 value as a repeated Uint32.
-func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderUint32SliceValue = valueCoderFuncs{
- size: sizeUint32SliceValue,
- marshal: appendUint32SliceValue,
- unmarshal: consumeUint32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeUint32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Uint32.
-func sizeUint32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(uint32(v.Uint())))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint32PackedSliceValue encodes a []uint32 value as a packed repeated Uint32.
-func appendUint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(uint32(v.Uint())))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
- }
- return b, nil
-}
-
-var coderUint32PackedSliceValue = valueCoderFuncs{
- size: sizeUint32PackedSliceValue,
- marshal: appendUint32PackedSliceValue,
- unmarshal: consumeUint32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeInt64 returns the size of wire encoding a int64 pointer as a Int64.
-func sizeInt64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int64()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt64 wire encodes a int64 pointer as a Int64.
-func appendInt64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int64()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-// consumeInt64 wire decodes a int64 pointer as a Int64.
-func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Int64() = int64(v)
- out.n = n
- return out, nil
-}
-
-var coderInt64 = pointerCoderFuncs{
- size: sizeInt64,
- marshal: appendInt64,
- unmarshal: consumeInt64,
- merge: mergeInt64,
-}
-
-// sizeInt64NoZero returns the size of wire encoding a int64 pointer as a Int64.
-// The zero value is not encoded.
-func sizeInt64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int64()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt64NoZero wire encodes a int64 pointer as a Int64.
-// The zero value is not encoded.
-func appendInt64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int64()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-var coderInt64NoZero = pointerCoderFuncs{
- size: sizeInt64NoZero,
- marshal: appendInt64NoZero,
- unmarshal: consumeInt64,
- merge: mergeInt64NoZero,
-}
-
-// sizeInt64Ptr returns the size of wire encoding a *int64 pointer as a Int64.
-// It panics if the pointer is nil.
-func sizeInt64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.Int64Ptr()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt64Ptr wire encodes a *int64 pointer as a Int64.
-// It panics if the pointer is nil.
-func appendInt64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Int64Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-// consumeInt64Ptr wire decodes a *int64 pointer as a Int64.
-func consumeInt64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Int64Ptr()
- if *vp == nil {
- *vp = new(int64)
- }
- **vp = int64(v)
- out.n = n
- return out, nil
-}
-
-var coderInt64Ptr = pointerCoderFuncs{
- size: sizeInt64Ptr,
- marshal: appendInt64Ptr,
- unmarshal: consumeInt64Ptr,
- merge: mergeInt64Ptr,
-}
-
-// sizeInt64Slice returns the size of wire encoding a []int64 pointer as a repeated Int64.
-func sizeInt64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int64Slice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(uint64(v))
- }
- return size
-}
-
-// appendInt64Slice encodes a []int64 pointer as a repeated Int64.
-func appendInt64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int64Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- }
- return b, nil
-}
-
-// consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64.
-func consumeInt64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Int64Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, int64(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, int64(v))
- out.n = n
- return out, nil
-}
-
-var coderInt64Slice = pointerCoderFuncs{
- size: sizeInt64Slice,
- marshal: appendInt64Slice,
- unmarshal: consumeInt64Slice,
- merge: mergeInt64Slice,
-}
-
-// sizeInt64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Int64.
-func sizeInt64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int64Slice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(uint64(v))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64.
-func appendInt64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int64Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(uint64(v))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, uint64(v))
- }
- return b, nil
-}
-
-var coderInt64PackedSlice = pointerCoderFuncs{
- size: sizeInt64PackedSlice,
- marshal: appendInt64PackedSlice,
- unmarshal: consumeInt64Slice,
- merge: mergeInt64Slice,
-}
-
-// sizeInt64Value returns the size of wire encoding a int64 value as a Int64.
-func sizeInt64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(uint64(v.Int()))
-}
-
-// appendInt64Value encodes a int64 value as a Int64.
-func appendInt64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(v.Int()))
- return b, nil
-}
-
-// consumeInt64Value decodes a int64 value as a Int64.
-func consumeInt64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfInt64(int64(v)), out, nil
-}
-
-var coderInt64Value = valueCoderFuncs{
- size: sizeInt64Value,
- marshal: appendInt64Value,
- unmarshal: consumeInt64Value,
- merge: mergeScalarValue,
-}
-
-// sizeInt64SliceValue returns the size of wire encoding a []int64 value as a repeated Int64.
-func sizeInt64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(uint64(v.Int()))
- }
- return size
-}
-
-// appendInt64SliceValue encodes a []int64 value as a repeated Int64.
-func appendInt64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, uint64(v.Int()))
- }
- return b, nil
-}
-
-// consumeInt64SliceValue wire decodes a []int64 value as a repeated Int64.
-func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderInt64SliceValue = valueCoderFuncs{
- size: sizeInt64SliceValue,
- marshal: appendInt64SliceValue,
- unmarshal: consumeInt64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeInt64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Int64.
-func sizeInt64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(v.Int()))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt64PackedSliceValue encodes a []int64 value as a packed repeated Int64.
-func appendInt64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(uint64(v.Int()))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, uint64(v.Int()))
- }
- return b, nil
-}
-
-var coderInt64PackedSliceValue = valueCoderFuncs{
- size: sizeInt64PackedSliceValue,
- marshal: appendInt64PackedSliceValue,
- unmarshal: consumeInt64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64.
-func sizeSint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int64()
- return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-}
-
-// appendSint64 wire encodes a int64 pointer as a Sint64.
-func appendSint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int64()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
- return b, nil
-}
-
-// consumeSint64 wire decodes a int64 pointer as a Sint64.
-func consumeSint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Int64() = protowire.DecodeZigZag(v)
- out.n = n
- return out, nil
-}
-
-var coderSint64 = pointerCoderFuncs{
- size: sizeSint64,
- marshal: appendSint64,
- unmarshal: consumeSint64,
- merge: mergeInt64,
-}
-
-// sizeSint64NoZero returns the size of wire encoding a int64 pointer as a Sint64.
-// The zero value is not encoded.
-func sizeSint64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int64()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-}
-
-// appendSint64NoZero wire encodes a int64 pointer as a Sint64.
-// The zero value is not encoded.
-func appendSint64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int64()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
- return b, nil
-}
-
-var coderSint64NoZero = pointerCoderFuncs{
- size: sizeSint64NoZero,
- marshal: appendSint64NoZero,
- unmarshal: consumeSint64,
- merge: mergeInt64NoZero,
-}
-
-// sizeSint64Ptr returns the size of wire encoding a *int64 pointer as a Sint64.
-// It panics if the pointer is nil.
-func sizeSint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.Int64Ptr()
- return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-}
-
-// appendSint64Ptr wire encodes a *int64 pointer as a Sint64.
-// It panics if the pointer is nil.
-func appendSint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Int64Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
- return b, nil
-}
-
-// consumeSint64Ptr wire decodes a *int64 pointer as a Sint64.
-func consumeSint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Int64Ptr()
- if *vp == nil {
- *vp = new(int64)
- }
- **vp = protowire.DecodeZigZag(v)
- out.n = n
- return out, nil
-}
-
-var coderSint64Ptr = pointerCoderFuncs{
- size: sizeSint64Ptr,
- marshal: appendSint64Ptr,
- unmarshal: consumeSint64Ptr,
- merge: mergeInt64Ptr,
-}
-
-// sizeSint64Slice returns the size of wire encoding a []int64 pointer as a repeated Sint64.
-func sizeSint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int64Slice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
- }
- return size
-}
-
-// appendSint64Slice encodes a []int64 pointer as a repeated Sint64.
-func appendSint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int64Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
- }
- return b, nil
-}
-
-// consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64.
-func consumeSint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Int64Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, protowire.DecodeZigZag(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, protowire.DecodeZigZag(v))
- out.n = n
- return out, nil
-}
-
-var coderSint64Slice = pointerCoderFuncs{
- size: sizeSint64Slice,
- marshal: appendSint64Slice,
- unmarshal: consumeSint64Slice,
- merge: mergeInt64Slice,
-}
-
-// sizeSint64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sint64.
-func sizeSint64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int64Slice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(protowire.EncodeZigZag(v))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64.
-func appendSint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int64Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(protowire.EncodeZigZag(v))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
- }
- return b, nil
-}
-
-var coderSint64PackedSlice = pointerCoderFuncs{
- size: sizeSint64PackedSlice,
- marshal: appendSint64PackedSlice,
- unmarshal: consumeSint64Slice,
- merge: mergeInt64Slice,
-}
-
-// sizeSint64Value returns the size of wire encoding a int64 value as a Sint64.
-func sizeSint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
-}
-
-// appendSint64Value encodes a int64 value as a Sint64.
-func appendSint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
- return b, nil
-}
-
-// consumeSint64Value decodes a int64 value as a Sint64.
-func consumeSint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), out, nil
-}
-
-var coderSint64Value = valueCoderFuncs{
- size: sizeSint64Value,
- marshal: appendSint64Value,
- unmarshal: consumeSint64Value,
- merge: mergeScalarValue,
-}
-
-// sizeSint64SliceValue returns the size of wire encoding a []int64 value as a repeated Sint64.
-func sizeSint64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
- }
- return size
-}
-
-// appendSint64SliceValue encodes a []int64 value as a repeated Sint64.
-func appendSint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
- }
- return b, nil
-}
-
-// consumeSint64SliceValue wire decodes a []int64 value as a repeated Sint64.
-func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderSint64SliceValue = valueCoderFuncs{
- size: sizeSint64SliceValue,
- marshal: appendSint64SliceValue,
- unmarshal: consumeSint64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSint64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sint64.
-func sizeSint64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint64PackedSliceValue encodes a []int64 value as a packed repeated Sint64.
-func appendSint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
- }
- return b, nil
-}
-
-var coderSint64PackedSliceValue = valueCoderFuncs{
- size: sizeSint64PackedSliceValue,
- marshal: appendSint64PackedSliceValue,
- unmarshal: consumeSint64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64.
-func sizeUint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Uint64()
- return f.tagsize + protowire.SizeVarint(v)
-}
-
-// appendUint64 wire encodes a uint64 pointer as a Uint64.
-func appendUint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint64()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, v)
- return b, nil
-}
-
-// consumeUint64 wire decodes a uint64 pointer as a Uint64.
-func consumeUint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Uint64() = v
- out.n = n
- return out, nil
-}
-
-var coderUint64 = pointerCoderFuncs{
- size: sizeUint64,
- marshal: appendUint64,
- unmarshal: consumeUint64,
- merge: mergeUint64,
-}
-
-// sizeUint64NoZero returns the size of wire encoding a uint64 pointer as a Uint64.
-// The zero value is not encoded.
-func sizeUint64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Uint64()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeVarint(v)
-}
-
-// appendUint64NoZero wire encodes a uint64 pointer as a Uint64.
-// The zero value is not encoded.
-func appendUint64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint64()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, v)
- return b, nil
-}
-
-var coderUint64NoZero = pointerCoderFuncs{
- size: sizeUint64NoZero,
- marshal: appendUint64NoZero,
- unmarshal: consumeUint64,
- merge: mergeUint64NoZero,
-}
-
-// sizeUint64Ptr returns the size of wire encoding a *uint64 pointer as a Uint64.
-// It panics if the pointer is nil.
-func sizeUint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.Uint64Ptr()
- return f.tagsize + protowire.SizeVarint(v)
-}
-
-// appendUint64Ptr wire encodes a *uint64 pointer as a Uint64.
-// It panics if the pointer is nil.
-func appendUint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Uint64Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, v)
- return b, nil
-}
-
-// consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64.
-func consumeUint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Uint64Ptr()
- if *vp == nil {
- *vp = new(uint64)
- }
- **vp = v
- out.n = n
- return out, nil
-}
-
-var coderUint64Ptr = pointerCoderFuncs{
- size: sizeUint64Ptr,
- marshal: appendUint64Ptr,
- unmarshal: consumeUint64Ptr,
- merge: mergeUint64Ptr,
-}
-
-// sizeUint64Slice returns the size of wire encoding a []uint64 pointer as a repeated Uint64.
-func sizeUint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint64Slice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeVarint(v)
- }
- return size
-}
-
-// appendUint64Slice encodes a []uint64 pointer as a repeated Uint64.
-func appendUint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint64Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, v)
- }
- return b, nil
-}
-
-// consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64.
-func consumeUint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Uint64Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, v)
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, v)
- out.n = n
- return out, nil
-}
-
-var coderUint64Slice = pointerCoderFuncs{
- size: sizeUint64Slice,
- marshal: appendUint64Slice,
- unmarshal: consumeUint64Slice,
- merge: mergeUint64Slice,
-}
-
-// sizeUint64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Uint64.
-func sizeUint64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint64Slice()
- if len(s) == 0 {
- return 0
- }
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(v)
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64.
-func appendUint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint64Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for _, v := range s {
- n += protowire.SizeVarint(v)
- }
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendVarint(b, v)
- }
- return b, nil
-}
-
-var coderUint64PackedSlice = pointerCoderFuncs{
- size: sizeUint64PackedSlice,
- marshal: appendUint64PackedSlice,
- unmarshal: consumeUint64Slice,
- merge: mergeUint64Slice,
-}
-
-// sizeUint64Value returns the size of wire encoding a uint64 value as a Uint64.
-func sizeUint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeVarint(v.Uint())
-}
-
-// appendUint64Value encodes a uint64 value as a Uint64.
-func appendUint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, v.Uint())
- return b, nil
-}
-
-// consumeUint64Value decodes a uint64 value as a Uint64.
-func consumeUint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfUint64(v), out, nil
-}
-
-var coderUint64Value = valueCoderFuncs{
- size: sizeUint64Value,
- marshal: appendUint64Value,
- unmarshal: consumeUint64Value,
- merge: mergeScalarValue,
-}
-
-// sizeUint64SliceValue returns the size of wire encoding a []uint64 value as a repeated Uint64.
-func sizeUint64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeVarint(v.Uint())
- }
- return size
-}
-
-// appendUint64SliceValue encodes a []uint64 value as a repeated Uint64.
-func appendUint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendVarint(b, v.Uint())
- }
- return b, nil
-}
-
-// consumeUint64SliceValue wire decodes a []uint64 value as a repeated Uint64.
-func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint64(v))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.VarintType {
- return protoreflect.Value{}, out, errUnknown
- }
- var v uint64
- var n int
- if len(b) >= 1 && b[0] < 0x80 {
- v = uint64(b[0])
- n = 1
- } else if len(b) >= 2 && b[1] < 128 {
- v = uint64(b[0]&0x7f) + uint64(b[1])<<7
- n = 2
- } else {
- v, n = protowire.ConsumeVarint(b)
- }
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint64(v))
- out.n = n
- return listv, out, nil
-}
-
-var coderUint64SliceValue = valueCoderFuncs{
- size: sizeUint64SliceValue,
- marshal: appendUint64SliceValue,
- unmarshal: consumeUint64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeUint64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Uint64.
-func sizeUint64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i, llen := 0, llen; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(v.Uint())
- }
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint64PackedSliceValue encodes a []uint64 value as a packed repeated Uint64.
-func appendUint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- n += protowire.SizeVarint(v.Uint())
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, v.Uint())
- }
- return b, nil
-}
-
-var coderUint64PackedSliceValue = valueCoderFuncs{
- size: sizeUint64PackedSliceValue,
- marshal: appendUint64PackedSliceValue,
- unmarshal: consumeUint64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32.
-func sizeSfixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32 wire encodes a int32 pointer as a Sfixed32.
-func appendSfixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int32()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, uint32(v))
- return b, nil
-}
-
-// consumeSfixed32 wire decodes a int32 pointer as a Sfixed32.
-func consumeSfixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Int32() = int32(v)
- out.n = n
- return out, nil
-}
-
-var coderSfixed32 = pointerCoderFuncs{
- size: sizeSfixed32,
- marshal: appendSfixed32,
- unmarshal: consumeSfixed32,
- merge: mergeInt32,
-}
-
-// sizeSfixed32NoZero returns the size of wire encoding a int32 pointer as a Sfixed32.
-// The zero value is not encoded.
-func sizeSfixed32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int32()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32.
-// The zero value is not encoded.
-func appendSfixed32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int32()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, uint32(v))
- return b, nil
-}
-
-var coderSfixed32NoZero = pointerCoderFuncs{
- size: sizeSfixed32NoZero,
- marshal: appendSfixed32NoZero,
- unmarshal: consumeSfixed32,
- merge: mergeInt32NoZero,
-}
-
-// sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32.
-// It panics if the pointer is nil.
-func sizeSfixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32.
-// It panics if the pointer is nil.
-func appendSfixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Int32Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, uint32(v))
- return b, nil
-}
-
-// consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32.
-func consumeSfixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Int32Ptr()
- if *vp == nil {
- *vp = new(int32)
- }
- **vp = int32(v)
- out.n = n
- return out, nil
-}
-
-var coderSfixed32Ptr = pointerCoderFuncs{
- size: sizeSfixed32Ptr,
- marshal: appendSfixed32Ptr,
- unmarshal: consumeSfixed32Ptr,
- merge: mergeInt32Ptr,
-}
-
-// sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32.
-func sizeSfixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int32Slice()
- size = len(s) * (f.tagsize + protowire.SizeFixed32())
- return size
-}
-
-// appendSfixed32Slice encodes a []int32 pointer as a repeated Sfixed32.
-func appendSfixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int32Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, uint32(v))
- }
- return b, nil
-}
-
-// consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32.
-func consumeSfixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Int32Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, int32(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, int32(v))
- out.n = n
- return out, nil
-}
-
-var coderSfixed32Slice = pointerCoderFuncs{
- size: sizeSfixed32Slice,
- marshal: appendSfixed32Slice,
- unmarshal: consumeSfixed32Slice,
- merge: mergeInt32Slice,
-}
-
-// sizeSfixed32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sfixed32.
-func sizeSfixed32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int32Slice()
- if len(s) == 0 {
- return 0
- }
- n := len(s) * protowire.SizeFixed32()
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32.
-func appendSfixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int32Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := len(s) * protowire.SizeFixed32()
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendFixed32(b, uint32(v))
- }
- return b, nil
-}
-
-var coderSfixed32PackedSlice = pointerCoderFuncs{
- size: sizeSfixed32PackedSlice,
- marshal: appendSfixed32PackedSlice,
- unmarshal: consumeSfixed32Slice,
- merge: mergeInt32Slice,
-}
-
-// sizeSfixed32Value returns the size of wire encoding a int32 value as a Sfixed32.
-func sizeSfixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32Value encodes a int32 value as a Sfixed32.
-func appendSfixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed32(b, uint32(v.Int()))
- return b, nil
-}
-
-// consumeSfixed32Value decodes a int32 value as a Sfixed32.
-func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfInt32(int32(v)), out, nil
-}
-
-var coderSfixed32Value = valueCoderFuncs{
- size: sizeSfixed32Value,
- marshal: appendSfixed32Value,
- unmarshal: consumeSfixed32Value,
- merge: mergeScalarValue,
-}
-
-// sizeSfixed32SliceValue returns the size of wire encoding a []int32 value as a repeated Sfixed32.
-func sizeSfixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- size = list.Len() * (tagsize + protowire.SizeFixed32())
- return size
-}
-
-// appendSfixed32SliceValue encodes a []int32 value as a repeated Sfixed32.
-func appendSfixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed32(b, uint32(v.Int()))
- }
- return b, nil
-}
-
-// consumeSfixed32SliceValue wire decodes a []int32 value as a repeated Sfixed32.
-func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.Fixed32Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderSfixed32SliceValue = valueCoderFuncs{
- size: sizeSfixed32SliceValue,
- marshal: appendSfixed32SliceValue,
- unmarshal: consumeSfixed32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSfixed32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sfixed32.
-func sizeSfixed32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := llen * protowire.SizeFixed32()
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed32PackedSliceValue encodes a []int32 value as a packed repeated Sfixed32.
-func appendSfixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := llen * protowire.SizeFixed32()
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendFixed32(b, uint32(v.Int()))
- }
- return b, nil
-}
-
-var coderSfixed32PackedSliceValue = valueCoderFuncs{
- size: sizeSfixed32PackedSliceValue,
- marshal: appendSfixed32PackedSliceValue,
- unmarshal: consumeSfixed32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32.
-func sizeFixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32 wire encodes a uint32 pointer as a Fixed32.
-func appendFixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint32()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, v)
- return b, nil
-}
-
-// consumeFixed32 wire decodes a uint32 pointer as a Fixed32.
-func consumeFixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Uint32() = v
- out.n = n
- return out, nil
-}
-
-var coderFixed32 = pointerCoderFuncs{
- size: sizeFixed32,
- marshal: appendFixed32,
- unmarshal: consumeFixed32,
- merge: mergeUint32,
-}
-
-// sizeFixed32NoZero returns the size of wire encoding a uint32 pointer as a Fixed32.
-// The zero value is not encoded.
-func sizeFixed32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Uint32()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32.
-// The zero value is not encoded.
-func appendFixed32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint32()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, v)
- return b, nil
-}
-
-var coderFixed32NoZero = pointerCoderFuncs{
- size: sizeFixed32NoZero,
- marshal: appendFixed32NoZero,
- unmarshal: consumeFixed32,
- merge: mergeUint32NoZero,
-}
-
-// sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32.
-// It panics if the pointer is nil.
-func sizeFixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32.
-// It panics if the pointer is nil.
-func appendFixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Uint32Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, v)
- return b, nil
-}
-
-// consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.
-func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Uint32Ptr()
- if *vp == nil {
- *vp = new(uint32)
- }
- **vp = v
- out.n = n
- return out, nil
-}
-
-var coderFixed32Ptr = pointerCoderFuncs{
- size: sizeFixed32Ptr,
- marshal: appendFixed32Ptr,
- unmarshal: consumeFixed32Ptr,
- merge: mergeUint32Ptr,
-}
-
-// sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32.
-func sizeFixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint32Slice()
- size = len(s) * (f.tagsize + protowire.SizeFixed32())
- return size
-}
-
-// appendFixed32Slice encodes a []uint32 pointer as a repeated Fixed32.
-func appendFixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint32Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, v)
- }
- return b, nil
-}
-
-// consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32.
-func consumeFixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Uint32Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, v)
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, v)
- out.n = n
- return out, nil
-}
-
-var coderFixed32Slice = pointerCoderFuncs{
- size: sizeFixed32Slice,
- marshal: appendFixed32Slice,
- unmarshal: consumeFixed32Slice,
- merge: mergeUint32Slice,
-}
-
-// sizeFixed32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Fixed32.
-func sizeFixed32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint32Slice()
- if len(s) == 0 {
- return 0
- }
- n := len(s) * protowire.SizeFixed32()
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32.
-func appendFixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint32Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := len(s) * protowire.SizeFixed32()
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendFixed32(b, v)
- }
- return b, nil
-}
-
-var coderFixed32PackedSlice = pointerCoderFuncs{
- size: sizeFixed32PackedSlice,
- marshal: appendFixed32PackedSlice,
- unmarshal: consumeFixed32Slice,
- merge: mergeUint32Slice,
-}
-
-// sizeFixed32Value returns the size of wire encoding a uint32 value as a Fixed32.
-func sizeFixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32Value encodes a uint32 value as a Fixed32.
-func appendFixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed32(b, uint32(v.Uint()))
- return b, nil
-}
-
-// consumeFixed32Value decodes a uint32 value as a Fixed32.
-func consumeFixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfUint32(uint32(v)), out, nil
-}
-
-var coderFixed32Value = valueCoderFuncs{
- size: sizeFixed32Value,
- marshal: appendFixed32Value,
- unmarshal: consumeFixed32Value,
- merge: mergeScalarValue,
-}
-
-// sizeFixed32SliceValue returns the size of wire encoding a []uint32 value as a repeated Fixed32.
-func sizeFixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- size = list.Len() * (tagsize + protowire.SizeFixed32())
- return size
-}
-
-// appendFixed32SliceValue encodes a []uint32 value as a repeated Fixed32.
-func appendFixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed32(b, uint32(v.Uint()))
- }
- return b, nil
-}
-
-// consumeFixed32SliceValue wire decodes a []uint32 value as a repeated Fixed32.
-func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.Fixed32Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderFixed32SliceValue = valueCoderFuncs{
- size: sizeFixed32SliceValue,
- marshal: appendFixed32SliceValue,
- unmarshal: consumeFixed32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeFixed32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Fixed32.
-func sizeFixed32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := llen * protowire.SizeFixed32()
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed32PackedSliceValue encodes a []uint32 value as a packed repeated Fixed32.
-func appendFixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := llen * protowire.SizeFixed32()
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendFixed32(b, uint32(v.Uint()))
- }
- return b, nil
-}
-
-var coderFixed32PackedSliceValue = valueCoderFuncs{
- size: sizeFixed32PackedSliceValue,
- marshal: appendFixed32PackedSliceValue,
- unmarshal: consumeFixed32SliceValue,
- merge: mergeListValue,
-}
-
-// sizeFloat returns the size of wire encoding a float32 pointer as a Float.
-func sizeFloat(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFloat wire encodes a float32 pointer as a Float.
-func appendFloat(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Float32()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, math.Float32bits(v))
- return b, nil
-}
-
-// consumeFloat wire decodes a float32 pointer as a Float.
-func consumeFloat(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Float32() = math.Float32frombits(v)
- out.n = n
- return out, nil
-}
-
-var coderFloat = pointerCoderFuncs{
- size: sizeFloat,
- marshal: appendFloat,
- unmarshal: consumeFloat,
- merge: mergeFloat32,
-}
-
-// sizeFloatNoZero returns the size of wire encoding a float32 pointer as a Float.
-// The zero value is not encoded.
-func sizeFloatNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Float32()
- if v == 0 && !math.Signbit(float64(v)) {
- return 0
- }
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFloatNoZero wire encodes a float32 pointer as a Float.
-// The zero value is not encoded.
-func appendFloatNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Float32()
- if v == 0 && !math.Signbit(float64(v)) {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, math.Float32bits(v))
- return b, nil
-}
-
-var coderFloatNoZero = pointerCoderFuncs{
- size: sizeFloatNoZero,
- marshal: appendFloatNoZero,
- unmarshal: consumeFloat,
- merge: mergeFloat32NoZero,
-}
-
-// sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float.
-// It panics if the pointer is nil.
-func sizeFloatPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFloatPtr wire encodes a *float32 pointer as a Float.
-// It panics if the pointer is nil.
-func appendFloatPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Float32Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, math.Float32bits(v))
- return b, nil
-}
-
-// consumeFloatPtr wire decodes a *float32 pointer as a Float.
-func consumeFloatPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Float32Ptr()
- if *vp == nil {
- *vp = new(float32)
- }
- **vp = math.Float32frombits(v)
- out.n = n
- return out, nil
-}
-
-var coderFloatPtr = pointerCoderFuncs{
- size: sizeFloatPtr,
- marshal: appendFloatPtr,
- unmarshal: consumeFloatPtr,
- merge: mergeFloat32Ptr,
-}
-
-// sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float.
-func sizeFloatSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Float32Slice()
- size = len(s) * (f.tagsize + protowire.SizeFixed32())
- return size
-}
-
-// appendFloatSlice encodes a []float32 pointer as a repeated Float.
-func appendFloatSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Float32Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed32(b, math.Float32bits(v))
- }
- return b, nil
-}
-
-// consumeFloatSlice wire decodes a []float32 pointer as a repeated Float.
-func consumeFloatSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Float32Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, math.Float32frombits(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.Fixed32Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, math.Float32frombits(v))
- out.n = n
- return out, nil
-}
-
-var coderFloatSlice = pointerCoderFuncs{
- size: sizeFloatSlice,
- marshal: appendFloatSlice,
- unmarshal: consumeFloatSlice,
- merge: mergeFloat32Slice,
-}
-
-// sizeFloatPackedSlice returns the size of wire encoding a []float32 pointer as a packed repeated Float.
-func sizeFloatPackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Float32Slice()
- if len(s) == 0 {
- return 0
- }
- n := len(s) * protowire.SizeFixed32()
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float.
-func appendFloatPackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Float32Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := len(s) * protowire.SizeFixed32()
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendFixed32(b, math.Float32bits(v))
- }
- return b, nil
-}
-
-var coderFloatPackedSlice = pointerCoderFuncs{
- size: sizeFloatPackedSlice,
- marshal: appendFloatPackedSlice,
- unmarshal: consumeFloatSlice,
- merge: mergeFloat32Slice,
-}
-
-// sizeFloatValue returns the size of wire encoding a float32 value as a Float.
-func sizeFloatValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeFixed32()
-}
-
-// appendFloatValue encodes a float32 value as a Float.
-func appendFloatValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
- return b, nil
-}
-
-// consumeFloatValue decodes a float32 value as a Float.
-func consumeFloatValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed32Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), out, nil
-}
-
-var coderFloatValue = valueCoderFuncs{
- size: sizeFloatValue,
- marshal: appendFloatValue,
- unmarshal: consumeFloatValue,
- merge: mergeScalarValue,
-}
-
-// sizeFloatSliceValue returns the size of wire encoding a []float32 value as a repeated Float.
-func sizeFloatSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- size = list.Len() * (tagsize + protowire.SizeFixed32())
- return size
-}
-
-// appendFloatSliceValue encodes a []float32 value as a repeated Float.
-func appendFloatSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
- }
- return b, nil
-}
-
-// consumeFloatSliceValue wire decodes a []float32 value as a repeated Float.
-func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.Fixed32Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
- out.n = n
- return listv, out, nil
-}
-
-var coderFloatSliceValue = valueCoderFuncs{
- size: sizeFloatSliceValue,
- marshal: appendFloatSliceValue,
- unmarshal: consumeFloatSliceValue,
- merge: mergeListValue,
-}
-
-// sizeFloatPackedSliceValue returns the size of wire encoding a []float32 value as a packed repeated Float.
-func sizeFloatPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := llen * protowire.SizeFixed32()
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendFloatPackedSliceValue encodes a []float32 value as a packed repeated Float.
-func appendFloatPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := llen * protowire.SizeFixed32()
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
- }
- return b, nil
-}
-
-var coderFloatPackedSliceValue = valueCoderFuncs{
- size: sizeFloatPackedSliceValue,
- marshal: appendFloatPackedSliceValue,
- unmarshal: consumeFloatSliceValue,
- merge: mergeListValue,
-}
-
-// sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64.
-func sizeSfixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64 wire encodes a int64 pointer as a Sfixed64.
-func appendSfixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int64()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, uint64(v))
- return b, nil
-}
-
-// consumeSfixed64 wire decodes a int64 pointer as a Sfixed64.
-func consumeSfixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Int64() = int64(v)
- out.n = n
- return out, nil
-}
-
-var coderSfixed64 = pointerCoderFuncs{
- size: sizeSfixed64,
- marshal: appendSfixed64,
- unmarshal: consumeSfixed64,
- merge: mergeInt64,
-}
-
-// sizeSfixed64NoZero returns the size of wire encoding a int64 pointer as a Sfixed64.
-// The zero value is not encoded.
-func sizeSfixed64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Int64()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64.
-// The zero value is not encoded.
-func appendSfixed64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Int64()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, uint64(v))
- return b, nil
-}
-
-var coderSfixed64NoZero = pointerCoderFuncs{
- size: sizeSfixed64NoZero,
- marshal: appendSfixed64NoZero,
- unmarshal: consumeSfixed64,
- merge: mergeInt64NoZero,
-}
-
-// sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64.
-// It panics if the pointer is nil.
-func sizeSfixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64.
-// It panics if the pointer is nil.
-func appendSfixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Int64Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, uint64(v))
- return b, nil
-}
-
-// consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64.
-func consumeSfixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Int64Ptr()
- if *vp == nil {
- *vp = new(int64)
- }
- **vp = int64(v)
- out.n = n
- return out, nil
-}
-
-var coderSfixed64Ptr = pointerCoderFuncs{
- size: sizeSfixed64Ptr,
- marshal: appendSfixed64Ptr,
- unmarshal: consumeSfixed64Ptr,
- merge: mergeInt64Ptr,
-}
-
-// sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64.
-func sizeSfixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int64Slice()
- size = len(s) * (f.tagsize + protowire.SizeFixed64())
- return size
-}
-
-// appendSfixed64Slice encodes a []int64 pointer as a repeated Sfixed64.
-func appendSfixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int64Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, uint64(v))
- }
- return b, nil
-}
-
-// consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64.
-func consumeSfixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Int64Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, int64(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, int64(v))
- out.n = n
- return out, nil
-}
-
-var coderSfixed64Slice = pointerCoderFuncs{
- size: sizeSfixed64Slice,
- marshal: appendSfixed64Slice,
- unmarshal: consumeSfixed64Slice,
- merge: mergeInt64Slice,
-}
-
-// sizeSfixed64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sfixed64.
-func sizeSfixed64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Int64Slice()
- if len(s) == 0 {
- return 0
- }
- n := len(s) * protowire.SizeFixed64()
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64.
-func appendSfixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Int64Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := len(s) * protowire.SizeFixed64()
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendFixed64(b, uint64(v))
- }
- return b, nil
-}
-
-var coderSfixed64PackedSlice = pointerCoderFuncs{
- size: sizeSfixed64PackedSlice,
- marshal: appendSfixed64PackedSlice,
- unmarshal: consumeSfixed64Slice,
- merge: mergeInt64Slice,
-}
-
-// sizeSfixed64Value returns the size of wire encoding a int64 value as a Sfixed64.
-func sizeSfixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64Value encodes a int64 value as a Sfixed64.
-func appendSfixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed64(b, uint64(v.Int()))
- return b, nil
-}
-
-// consumeSfixed64Value decodes a int64 value as a Sfixed64.
-func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfInt64(int64(v)), out, nil
-}
-
-var coderSfixed64Value = valueCoderFuncs{
- size: sizeSfixed64Value,
- marshal: appendSfixed64Value,
- unmarshal: consumeSfixed64Value,
- merge: mergeScalarValue,
-}
-
-// sizeSfixed64SliceValue returns the size of wire encoding a []int64 value as a repeated Sfixed64.
-func sizeSfixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- size = list.Len() * (tagsize + protowire.SizeFixed64())
- return size
-}
-
-// appendSfixed64SliceValue encodes a []int64 value as a repeated Sfixed64.
-func appendSfixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed64(b, uint64(v.Int()))
- }
- return b, nil
-}
-
-// consumeSfixed64SliceValue wire decodes a []int64 value as a repeated Sfixed64.
-func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.Fixed64Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderSfixed64SliceValue = valueCoderFuncs{
- size: sizeSfixed64SliceValue,
- marshal: appendSfixed64SliceValue,
- unmarshal: consumeSfixed64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeSfixed64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sfixed64.
-func sizeSfixed64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := llen * protowire.SizeFixed64()
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed64PackedSliceValue encodes a []int64 value as a packed repeated Sfixed64.
-func appendSfixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := llen * protowire.SizeFixed64()
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendFixed64(b, uint64(v.Int()))
- }
- return b, nil
-}
-
-var coderSfixed64PackedSliceValue = valueCoderFuncs{
- size: sizeSfixed64PackedSliceValue,
- marshal: appendSfixed64PackedSliceValue,
- unmarshal: consumeSfixed64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64.
-func sizeFixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64 wire encodes a uint64 pointer as a Fixed64.
-func appendFixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint64()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, v)
- return b, nil
-}
-
-// consumeFixed64 wire decodes a uint64 pointer as a Fixed64.
-func consumeFixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Uint64() = v
- out.n = n
- return out, nil
-}
-
-var coderFixed64 = pointerCoderFuncs{
- size: sizeFixed64,
- marshal: appendFixed64,
- unmarshal: consumeFixed64,
- merge: mergeUint64,
-}
-
-// sizeFixed64NoZero returns the size of wire encoding a uint64 pointer as a Fixed64.
-// The zero value is not encoded.
-func sizeFixed64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Uint64()
- if v == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64.
-// The zero value is not encoded.
-func appendFixed64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Uint64()
- if v == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, v)
- return b, nil
-}
-
-var coderFixed64NoZero = pointerCoderFuncs{
- size: sizeFixed64NoZero,
- marshal: appendFixed64NoZero,
- unmarshal: consumeFixed64,
- merge: mergeUint64NoZero,
-}
-
-// sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64.
-// It panics if the pointer is nil.
-func sizeFixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64.
-// It panics if the pointer is nil.
-func appendFixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Uint64Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, v)
- return b, nil
-}
-
-// consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64.
-func consumeFixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Uint64Ptr()
- if *vp == nil {
- *vp = new(uint64)
- }
- **vp = v
- out.n = n
- return out, nil
-}
-
-var coderFixed64Ptr = pointerCoderFuncs{
- size: sizeFixed64Ptr,
- marshal: appendFixed64Ptr,
- unmarshal: consumeFixed64Ptr,
- merge: mergeUint64Ptr,
-}
-
-// sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64.
-func sizeFixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint64Slice()
- size = len(s) * (f.tagsize + protowire.SizeFixed64())
- return size
-}
-
-// appendFixed64Slice encodes a []uint64 pointer as a repeated Fixed64.
-func appendFixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint64Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, v)
- }
- return b, nil
-}
-
-// consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64.
-func consumeFixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Uint64Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, v)
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, v)
- out.n = n
- return out, nil
-}
-
-var coderFixed64Slice = pointerCoderFuncs{
- size: sizeFixed64Slice,
- marshal: appendFixed64Slice,
- unmarshal: consumeFixed64Slice,
- merge: mergeUint64Slice,
-}
-
-// sizeFixed64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Fixed64.
-func sizeFixed64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Uint64Slice()
- if len(s) == 0 {
- return 0
- }
- n := len(s) * protowire.SizeFixed64()
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64.
-func appendFixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Uint64Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := len(s) * protowire.SizeFixed64()
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendFixed64(b, v)
- }
- return b, nil
-}
-
-var coderFixed64PackedSlice = pointerCoderFuncs{
- size: sizeFixed64PackedSlice,
- marshal: appendFixed64PackedSlice,
- unmarshal: consumeFixed64Slice,
- merge: mergeUint64Slice,
-}
-
-// sizeFixed64Value returns the size of wire encoding a uint64 value as a Fixed64.
-func sizeFixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64Value encodes a uint64 value as a Fixed64.
-func appendFixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed64(b, v.Uint())
- return b, nil
-}
-
-// consumeFixed64Value decodes a uint64 value as a Fixed64.
-func consumeFixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfUint64(v), out, nil
-}
-
-var coderFixed64Value = valueCoderFuncs{
- size: sizeFixed64Value,
- marshal: appendFixed64Value,
- unmarshal: consumeFixed64Value,
- merge: mergeScalarValue,
-}
-
-// sizeFixed64SliceValue returns the size of wire encoding a []uint64 value as a repeated Fixed64.
-func sizeFixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- size = list.Len() * (tagsize + protowire.SizeFixed64())
- return size
-}
-
-// appendFixed64SliceValue encodes a []uint64 value as a repeated Fixed64.
-func appendFixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed64(b, v.Uint())
- }
- return b, nil
-}
-
-// consumeFixed64SliceValue wire decodes a []uint64 value as a repeated Fixed64.
-func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint64(v))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.Fixed64Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint64(v))
- out.n = n
- return listv, out, nil
-}
-
-var coderFixed64SliceValue = valueCoderFuncs{
- size: sizeFixed64SliceValue,
- marshal: appendFixed64SliceValue,
- unmarshal: consumeFixed64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeFixed64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Fixed64.
-func sizeFixed64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := llen * protowire.SizeFixed64()
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed64PackedSliceValue encodes a []uint64 value as a packed repeated Fixed64.
-func appendFixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := llen * protowire.SizeFixed64()
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendFixed64(b, v.Uint())
- }
- return b, nil
-}
-
-var coderFixed64PackedSliceValue = valueCoderFuncs{
- size: sizeFixed64PackedSliceValue,
- marshal: appendFixed64PackedSliceValue,
- unmarshal: consumeFixed64SliceValue,
- merge: mergeListValue,
-}
-
-// sizeDouble returns the size of wire encoding a float64 pointer as a Double.
-func sizeDouble(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendDouble wire encodes a float64 pointer as a Double.
-func appendDouble(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Float64()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, math.Float64bits(v))
- return b, nil
-}
-
-// consumeDouble wire decodes a float64 pointer as a Double.
-func consumeDouble(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Float64() = math.Float64frombits(v)
- out.n = n
- return out, nil
-}
-
-var coderDouble = pointerCoderFuncs{
- size: sizeDouble,
- marshal: appendDouble,
- unmarshal: consumeDouble,
- merge: mergeFloat64,
-}
-
-// sizeDoubleNoZero returns the size of wire encoding a float64 pointer as a Double.
-// The zero value is not encoded.
-func sizeDoubleNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Float64()
- if v == 0 && !math.Signbit(float64(v)) {
- return 0
- }
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendDoubleNoZero wire encodes a float64 pointer as a Double.
-// The zero value is not encoded.
-func appendDoubleNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Float64()
- if v == 0 && !math.Signbit(float64(v)) {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, math.Float64bits(v))
- return b, nil
-}
-
-var coderDoubleNoZero = pointerCoderFuncs{
- size: sizeDoubleNoZero,
- marshal: appendDoubleNoZero,
- unmarshal: consumeDouble,
- merge: mergeFloat64NoZero,
-}
-
-// sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double.
-// It panics if the pointer is nil.
-func sizeDoublePtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendDoublePtr wire encodes a *float64 pointer as a Double.
-// It panics if the pointer is nil.
-func appendDoublePtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.Float64Ptr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, math.Float64bits(v))
- return b, nil
-}
-
-// consumeDoublePtr wire decodes a *float64 pointer as a Double.
-func consumeDoublePtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.Float64Ptr()
- if *vp == nil {
- *vp = new(float64)
- }
- **vp = math.Float64frombits(v)
- out.n = n
- return out, nil
-}
-
-var coderDoublePtr = pointerCoderFuncs{
- size: sizeDoublePtr,
- marshal: appendDoublePtr,
- unmarshal: consumeDoublePtr,
- merge: mergeFloat64Ptr,
-}
-
-// sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double.
-func sizeDoubleSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Float64Slice()
- size = len(s) * (f.tagsize + protowire.SizeFixed64())
- return size
-}
-
-// appendDoubleSlice encodes a []float64 pointer as a repeated Double.
-func appendDoubleSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Float64Slice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendFixed64(b, math.Float64bits(v))
- }
- return b, nil
-}
-
-// consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double.
-func consumeDoubleSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.Float64Slice()
- if wtyp == protowire.BytesType {
- s := *sp
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- s = append(s, math.Float64frombits(v))
- b = b[n:]
- }
- *sp = s
- out.n = n
- return out, nil
- }
- if wtyp != protowire.Fixed64Type {
- return out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, math.Float64frombits(v))
- out.n = n
- return out, nil
-}
-
-var coderDoubleSlice = pointerCoderFuncs{
- size: sizeDoubleSlice,
- marshal: appendDoubleSlice,
- unmarshal: consumeDoubleSlice,
- merge: mergeFloat64Slice,
-}
-
-// sizeDoublePackedSlice returns the size of wire encoding a []float64 pointer as a packed repeated Double.
-func sizeDoublePackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.Float64Slice()
- if len(s) == 0 {
- return 0
- }
- n := len(s) * protowire.SizeFixed64()
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double.
-func appendDoublePackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.Float64Slice()
- if len(s) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := len(s) * protowire.SizeFixed64()
- b = protowire.AppendVarint(b, uint64(n))
- for _, v := range s {
- b = protowire.AppendFixed64(b, math.Float64bits(v))
- }
- return b, nil
-}
-
-var coderDoublePackedSlice = pointerCoderFuncs{
- size: sizeDoublePackedSlice,
- marshal: appendDoublePackedSlice,
- unmarshal: consumeDoubleSlice,
- merge: mergeFloat64Slice,
-}
-
-// sizeDoubleValue returns the size of wire encoding a float64 value as a Double.
-func sizeDoubleValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeFixed64()
-}
-
-// appendDoubleValue encodes a float64 value as a Double.
-func appendDoubleValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
- return b, nil
-}
-
-// consumeDoubleValue decodes a float64 value as a Double.
-func consumeDoubleValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.Fixed64Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
-}
-
-var coderDoubleValue = valueCoderFuncs{
- size: sizeDoubleValue,
- marshal: appendDoubleValue,
- unmarshal: consumeDoubleValue,
- merge: mergeScalarValue,
-}
-
-// sizeDoubleSliceValue returns the size of wire encoding a []float64 value as a repeated Double.
-func sizeDoubleSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- size = list.Len() * (tagsize + protowire.SizeFixed64())
- return size
-}
-
-// appendDoubleSliceValue encodes a []float64 value as a repeated Double.
-func appendDoubleSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
- }
- return b, nil
-}
-
-// consumeDoubleSliceValue wire decodes a []float64 value as a repeated Double.
-func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
- b = b[n:]
- }
- out.n = n
- return listv, out, nil
- }
- if wtyp != protowire.Fixed64Type {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderDoubleSliceValue = valueCoderFuncs{
- size: sizeDoubleSliceValue,
- marshal: appendDoubleSliceValue,
- unmarshal: consumeDoubleSliceValue,
- merge: mergeListValue,
-}
-
-// sizeDoublePackedSliceValue returns the size of wire encoding a []float64 value as a packed repeated Double.
-func sizeDoublePackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return 0
- }
- n := llen * protowire.SizeFixed64()
- return tagsize + protowire.SizeBytes(n)
-}
-
-// appendDoublePackedSliceValue encodes a []float64 value as a packed repeated Double.
-func appendDoublePackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- llen := list.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, wiretag)
- n := llen * protowire.SizeFixed64()
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
- }
- return b, nil
-}
-
-var coderDoublePackedSliceValue = valueCoderFuncs{
- size: sizeDoublePackedSliceValue,
- marshal: appendDoublePackedSliceValue,
- unmarshal: consumeDoubleSliceValue,
- merge: mergeListValue,
-}
-
-// sizeString returns the size of wire encoding a string pointer as a String.
-func sizeString(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.String()
- return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendString wire encodes a string pointer as a String.
-func appendString(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.String()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- return b, nil
-}
-
-// consumeString wire decodes a string pointer as a String.
-func consumeString(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.String() = v
- out.n = n
- return out, nil
-}
-
-var coderString = pointerCoderFuncs{
- size: sizeString,
- marshal: appendString,
- unmarshal: consumeString,
- merge: mergeString,
-}
-
-// appendStringValidateUTF8 wire encodes a string pointer as a String.
-func appendStringValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.String()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- if !utf8.ValidString(v) {
- return b, errInvalidUTF8{}
- }
- return b, nil
-}
-
-// consumeStringValidateUTF8 wire decodes a string pointer as a String.
-func consumeStringValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !utf8.ValidString(v) {
- return out, errInvalidUTF8{}
- }
- *p.String() = v
- out.n = n
- return out, nil
-}
-
-var coderStringValidateUTF8 = pointerCoderFuncs{
- size: sizeString,
- marshal: appendStringValidateUTF8,
- unmarshal: consumeStringValidateUTF8,
- merge: mergeString,
-}
-
-// sizeStringNoZero returns the size of wire encoding a string pointer as a String.
-// The zero value is not encoded.
-func sizeStringNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.String()
- if len(v) == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendStringNoZero wire encodes a string pointer as a String.
-// The zero value is not encoded.
-func appendStringNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.String()
- if len(v) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- return b, nil
-}
-
-var coderStringNoZero = pointerCoderFuncs{
- size: sizeStringNoZero,
- marshal: appendStringNoZero,
- unmarshal: consumeString,
- merge: mergeStringNoZero,
-}
-
-// appendStringNoZeroValidateUTF8 wire encodes a string pointer as a String.
-// The zero value is not encoded.
-func appendStringNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.String()
- if len(v) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- if !utf8.ValidString(v) {
- return b, errInvalidUTF8{}
- }
- return b, nil
-}
-
-var coderStringNoZeroValidateUTF8 = pointerCoderFuncs{
- size: sizeStringNoZero,
- marshal: appendStringNoZeroValidateUTF8,
- unmarshal: consumeStringValidateUTF8,
- merge: mergeStringNoZero,
-}
-
-// sizeStringPtr returns the size of wire encoding a *string pointer as a String.
-// It panics if the pointer is nil.
-func sizeStringPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := **p.StringPtr()
- return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendStringPtr wire encodes a *string pointer as a String.
-// It panics if the pointer is nil.
-func appendStringPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.StringPtr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- return b, nil
-}
-
-// consumeStringPtr wire decodes a *string pointer as a String.
-func consumeStringPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- vp := p.StringPtr()
- if *vp == nil {
- *vp = new(string)
- }
- **vp = v
- out.n = n
- return out, nil
-}
-
-var coderStringPtr = pointerCoderFuncs{
- size: sizeStringPtr,
- marshal: appendStringPtr,
- unmarshal: consumeStringPtr,
- merge: mergeStringPtr,
-}
-
-// appendStringPtrValidateUTF8 wire encodes a *string pointer as a String.
-// It panics if the pointer is nil.
-func appendStringPtrValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := **p.StringPtr()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- if !utf8.ValidString(v) {
- return b, errInvalidUTF8{}
- }
- return b, nil
-}
-
-// consumeStringPtrValidateUTF8 wire decodes a *string pointer as a String.
-func consumeStringPtrValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !utf8.ValidString(v) {
- return out, errInvalidUTF8{}
- }
- vp := p.StringPtr()
- if *vp == nil {
- *vp = new(string)
- }
- **vp = v
- out.n = n
- return out, nil
-}
-
-var coderStringPtrValidateUTF8 = pointerCoderFuncs{
- size: sizeStringPtr,
- marshal: appendStringPtrValidateUTF8,
- unmarshal: consumeStringPtrValidateUTF8,
- merge: mergeStringPtr,
-}
-
-// sizeStringSlice returns the size of wire encoding a []string pointer as a repeated String.
-func sizeStringSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.StringSlice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeBytes(len(v))
- }
- return size
-}
-
-// appendStringSlice encodes a []string pointer as a repeated String.
-func appendStringSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.StringSlice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- }
- return b, nil
-}
-
-// consumeStringSlice wire decodes a []string pointer as a repeated String.
-func consumeStringSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.StringSlice()
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, v)
- out.n = n
- return out, nil
-}
-
-var coderStringSlice = pointerCoderFuncs{
- size: sizeStringSlice,
- marshal: appendStringSlice,
- unmarshal: consumeStringSlice,
- merge: mergeStringSlice,
-}
-
-// appendStringSliceValidateUTF8 encodes a []string pointer as a repeated String.
-func appendStringSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.StringSlice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendString(b, v)
- if !utf8.ValidString(v) {
- return b, errInvalidUTF8{}
- }
- }
- return b, nil
-}
-
-// consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String.
-func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.StringSlice()
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !utf8.ValidString(v) {
- return out, errInvalidUTF8{}
- }
- *sp = append(*sp, v)
- out.n = n
- return out, nil
-}
-
-var coderStringSliceValidateUTF8 = pointerCoderFuncs{
- size: sizeStringSlice,
- marshal: appendStringSliceValidateUTF8,
- unmarshal: consumeStringSliceValidateUTF8,
- merge: mergeStringSlice,
-}
-
-// sizeStringValue returns the size of wire encoding a string value as a String.
-func sizeStringValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeBytes(len(v.String()))
-}
-
-// appendStringValue encodes a string value as a String.
-func appendStringValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendString(b, v.String())
- return b, nil
-}
-
-// consumeStringValue decodes a string value as a String.
-func consumeStringValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfString(string(v)), out, nil
-}
-
-var coderStringValue = valueCoderFuncs{
- size: sizeStringValue,
- marshal: appendStringValue,
- unmarshal: consumeStringValue,
- merge: mergeScalarValue,
-}
-
-// appendStringValueValidateUTF8 encodes a string value as a String.
-func appendStringValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendString(b, v.String())
- if !utf8.ValidString(v.String()) {
- return b, errInvalidUTF8{}
- }
- return b, nil
-}
-
-// consumeStringValueValidateUTF8 decodes a string value as a String.
-func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- if !utf8.ValidString(v) {
- return protoreflect.Value{}, out, errInvalidUTF8{}
- }
- out.n = n
- return protoreflect.ValueOfString(string(v)), out, nil
-}
-
-var coderStringValueValidateUTF8 = valueCoderFuncs{
- size: sizeStringValue,
- marshal: appendStringValueValidateUTF8,
- unmarshal: consumeStringValueValidateUTF8,
- merge: mergeScalarValue,
-}
-
-// sizeStringSliceValue returns the size of wire encoding a []string value as a repeated String.
-func sizeStringSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeBytes(len(v.String()))
- }
- return size
-}
-
-// appendStringSliceValue encodes a []string value as a repeated String.
-func appendStringSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendString(b, v.String())
- }
- return b, nil
-}
-
-// consumeStringSliceValue wire decodes a []string value as a repeated String.
-func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp != protowire.BytesType {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeString(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfString(string(v)))
- out.n = n
- return listv, out, nil
-}
-
-var coderStringSliceValue = valueCoderFuncs{
- size: sizeStringSliceValue,
- marshal: appendStringSliceValue,
- unmarshal: consumeStringSliceValue,
- merge: mergeListValue,
-}
-
-// sizeBytes returns the size of wire encoding a []byte pointer as a Bytes.
-func sizeBytes(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Bytes()
- return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendBytes wire encodes a []byte pointer as a Bytes.
-func appendBytes(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Bytes()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendBytes(b, v)
- return b, nil
-}
-
-// consumeBytes wire decodes a []byte pointer as a Bytes.
-func consumeBytes(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Bytes() = append(emptyBuf[:], v...)
- out.n = n
- return out, nil
-}
-
-var coderBytes = pointerCoderFuncs{
- size: sizeBytes,
- marshal: appendBytes,
- unmarshal: consumeBytes,
- merge: mergeBytes,
-}
-
-// appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes.
-func appendBytesValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Bytes()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendBytes(b, v)
- if !utf8.Valid(v) {
- return b, errInvalidUTF8{}
- }
- return b, nil
-}
-
-// consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes.
-func consumeBytesValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !utf8.Valid(v) {
- return out, errInvalidUTF8{}
- }
- *p.Bytes() = append(emptyBuf[:], v...)
- out.n = n
- return out, nil
-}
-
-var coderBytesValidateUTF8 = pointerCoderFuncs{
- size: sizeBytes,
- marshal: appendBytesValidateUTF8,
- unmarshal: consumeBytesValidateUTF8,
- merge: mergeBytes,
-}
-
-// sizeBytesNoZero returns the size of wire encoding a []byte pointer as a Bytes.
-// The zero value is not encoded.
-func sizeBytesNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := *p.Bytes()
- if len(v) == 0 {
- return 0
- }
- return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendBytesNoZero wire encodes a []byte pointer as a Bytes.
-// The zero value is not encoded.
-func appendBytesNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Bytes()
- if len(v) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendBytes(b, v)
- return b, nil
-}
-
-// consumeBytesNoZero wire decodes a []byte pointer as a Bytes.
-// The zero value is not decoded.
-func consumeBytesNoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *p.Bytes() = append(([]byte)(nil), v...)
- out.n = n
- return out, nil
-}
-
-var coderBytesNoZero = pointerCoderFuncs{
- size: sizeBytesNoZero,
- marshal: appendBytesNoZero,
- unmarshal: consumeBytesNoZero,
- merge: mergeBytesNoZero,
-}
-
-// appendBytesNoZeroValidateUTF8 wire encodes a []byte pointer as a Bytes.
-// The zero value is not encoded.
-func appendBytesNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- v := *p.Bytes()
- if len(v) == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendBytes(b, v)
- if !utf8.Valid(v) {
- return b, errInvalidUTF8{}
- }
- return b, nil
-}
-
-// consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes.
-func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !utf8.Valid(v) {
- return out, errInvalidUTF8{}
- }
- *p.Bytes() = append(([]byte)(nil), v...)
- out.n = n
- return out, nil
-}
-
-var coderBytesNoZeroValidateUTF8 = pointerCoderFuncs{
- size: sizeBytesNoZero,
- marshal: appendBytesNoZeroValidateUTF8,
- unmarshal: consumeBytesNoZeroValidateUTF8,
- merge: mergeBytesNoZero,
-}
-
-// sizeBytesSlice returns the size of wire encoding a [][]byte pointer as a repeated Bytes.
-func sizeBytesSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- s := *p.BytesSlice()
- for _, v := range s {
- size += f.tagsize + protowire.SizeBytes(len(v))
- }
- return size
-}
-
-// appendBytesSlice encodes a [][]byte pointer as a repeated Bytes.
-func appendBytesSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.BytesSlice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendBytes(b, v)
- }
- return b, nil
-}
-
-// consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes.
-func consumeBytesSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.BytesSlice()
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- *sp = append(*sp, append(emptyBuf[:], v...))
- out.n = n
- return out, nil
-}
-
-var coderBytesSlice = pointerCoderFuncs{
- size: sizeBytesSlice,
- marshal: appendBytesSlice,
- unmarshal: consumeBytesSlice,
- merge: mergeBytesSlice,
-}
-
-// appendBytesSliceValidateUTF8 encodes a [][]byte pointer as a repeated Bytes.
-func appendBytesSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
- s := *p.BytesSlice()
- for _, v := range s {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendBytes(b, v)
- if !utf8.Valid(v) {
- return b, errInvalidUTF8{}
- }
- }
- return b, nil
-}
-
-// consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes.
-func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- sp := p.BytesSlice()
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !utf8.Valid(v) {
- return out, errInvalidUTF8{}
- }
- *sp = append(*sp, append(emptyBuf[:], v...))
- out.n = n
- return out, nil
-}
-
-var coderBytesSliceValidateUTF8 = pointerCoderFuncs{
- size: sizeBytesSlice,
- marshal: appendBytesSliceValidateUTF8,
- unmarshal: consumeBytesSliceValidateUTF8,
- merge: mergeBytesSlice,
-}
-
-// sizeBytesValue returns the size of wire encoding a []byte value as a Bytes.
-func sizeBytesValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
- return tagsize + protowire.SizeBytes(len(v.Bytes()))
-}
-
-// appendBytesValue encodes a []byte value as a Bytes.
-func appendBytesValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendBytes(b, v.Bytes())
- return b, nil
-}
-
-// consumeBytesValue decodes a []byte value as a Bytes.
-func consumeBytesValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- out.n = n
- return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), out, nil
-}
-
-var coderBytesValue = valueCoderFuncs{
- size: sizeBytesValue,
- marshal: appendBytesValue,
- unmarshal: consumeBytesValue,
- merge: mergeBytesValue,
-}
-
-// sizeBytesSliceValue returns the size of wire encoding a [][]byte value as a repeated Bytes.
-func sizeBytesSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- size += tagsize + protowire.SizeBytes(len(v.Bytes()))
- }
- return size
-}
-
-// appendBytesSliceValue encodes a [][]byte value as a repeated Bytes.
-func appendBytesSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
- list := listv.List()
- for i, llen := 0, list.Len(); i < llen; i++ {
- v := list.Get(i)
- b = protowire.AppendVarint(b, wiretag)
- b = protowire.AppendBytes(b, v.Bytes())
- }
- return b, nil
-}
-
-// consumeBytesSliceValue wire decodes a [][]byte value as a repeated Bytes.
-func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
- list := listv.List()
- if wtyp != protowire.BytesType {
- return protoreflect.Value{}, out, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return protoreflect.Value{}, out, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
- out.n = n
- return listv, out, nil
-}
-
-var coderBytesSliceValue = valueCoderFuncs{
- size: sizeBytesSliceValue,
- marshal: appendBytesSliceValue,
- unmarshal: consumeBytesSliceValue,
- merge: mergeBytesListValue,
-}
-
-// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
-var emptyBuf [0]byte
-
-var wireTypes = map[protoreflect.Kind]protowire.Type{
- protoreflect.BoolKind: protowire.VarintType,
- protoreflect.EnumKind: protowire.VarintType,
- protoreflect.Int32Kind: protowire.VarintType,
- protoreflect.Sint32Kind: protowire.VarintType,
- protoreflect.Uint32Kind: protowire.VarintType,
- protoreflect.Int64Kind: protowire.VarintType,
- protoreflect.Sint64Kind: protowire.VarintType,
- protoreflect.Uint64Kind: protowire.VarintType,
- protoreflect.Sfixed32Kind: protowire.Fixed32Type,
- protoreflect.Fixed32Kind: protowire.Fixed32Type,
- protoreflect.FloatKind: protowire.Fixed32Type,
- protoreflect.Sfixed64Kind: protowire.Fixed64Type,
- protoreflect.Fixed64Kind: protowire.Fixed64Type,
- protoreflect.DoubleKind: protowire.Fixed64Type,
- protoreflect.StringKind: protowire.BytesType,
- protoreflect.BytesKind: protowire.BytesType,
- protoreflect.MessageKind: protowire.BytesType,
- protoreflect.GroupKind: protowire.StartGroupType,
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map.go
deleted file mode 100644
index 35a67c2..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_map.go
+++ /dev/null
@@ -1,388 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "errors"
- "reflect"
- "sort"
-
- "google.golang.org/protobuf/encoding/protowire"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type mapInfo struct {
- goType reflect.Type
- keyWiretag uint64
- valWiretag uint64
- keyFuncs valueCoderFuncs
- valFuncs valueCoderFuncs
- keyZero pref.Value
- keyKind pref.Kind
- conv *mapConverter
-}
-
-func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
- // TODO: Consider generating specialized map coders.
- keyField := fd.MapKey()
- valField := fd.MapValue()
- keyWiretag := protowire.EncodeTag(1, wireTypes[keyField.Kind()])
- valWiretag := protowire.EncodeTag(2, wireTypes[valField.Kind()])
- keyFuncs := encoderFuncsForValue(keyField)
- valFuncs := encoderFuncsForValue(valField)
- conv := newMapConverter(ft, fd)
-
- mapi := &mapInfo{
- goType: ft,
- keyWiretag: keyWiretag,
- valWiretag: valWiretag,
- keyFuncs: keyFuncs,
- valFuncs: valFuncs,
- keyZero: keyField.Default(),
- keyKind: keyField.Kind(),
- conv: conv,
- }
- if valField.Kind() == pref.MessageKind {
- valueMessage = getMessageInfo(ft.Elem())
- }
-
- funcs = pointerCoderFuncs{
- size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
- return sizeMap(p.AsValueOf(ft).Elem(), mapi, f, opts)
- },
- marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- return appendMap(b, p.AsValueOf(ft).Elem(), mapi, f, opts)
- },
- unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
- mp := p.AsValueOf(ft)
- if mp.Elem().IsNil() {
- mp.Elem().Set(reflect.MakeMap(mapi.goType))
- }
- if f.mi == nil {
- return consumeMap(b, mp.Elem(), wtyp, mapi, f, opts)
- } else {
- return consumeMapOfMessage(b, mp.Elem(), wtyp, mapi, f, opts)
- }
- },
- }
- switch valField.Kind() {
- case pref.MessageKind:
- funcs.merge = mergeMapOfMessage
- case pref.BytesKind:
- funcs.merge = mergeMapOfBytes
- default:
- funcs.merge = mergeMap
- }
- if valFuncs.isInit != nil {
- funcs.isInit = func(p pointer, f *coderFieldInfo) error {
- return isInitMap(p.AsValueOf(ft).Elem(), mapi, f)
- }
- }
- return valueMessage, funcs
-}
-
-const (
- mapKeyTagSize = 1 // field 1, tag size 1.
- mapValTagSize = 1 // field 2, tag size 2.
-)
-
-func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
- if mapv.Len() == 0 {
- return 0
- }
- n := 0
- iter := mapRange(mapv)
- for iter.Next() {
- key := mapi.conv.keyConv.PBValueOf(iter.Key()).MapKey()
- keySize := mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
- var valSize int
- value := mapi.conv.valConv.PBValueOf(iter.Value())
- if f.mi == nil {
- valSize = mapi.valFuncs.size(value, mapValTagSize, opts)
- } else {
- p := pointerOfValue(iter.Value())
- valSize += mapValTagSize
- valSize += protowire.SizeBytes(f.mi.sizePointer(p, opts))
- }
- n += f.tagsize + protowire.SizeBytes(keySize+valSize)
- }
- return n
-}
-
-func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- var (
- key = mapi.keyZero
- val = mapi.conv.valConv.New()
- )
- for len(b) > 0 {
- num, wtyp, n := protowire.ConsumeTag(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if num > protowire.MaxValidNumber {
- return out, errors.New("invalid field number")
- }
- b = b[n:]
- err := errUnknown
- switch num {
- case 1:
- var v pref.Value
- var o unmarshalOutput
- v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
- if err != nil {
- break
- }
- key = v
- n = o.n
- case 2:
- var v pref.Value
- var o unmarshalOutput
- v, o, err = mapi.valFuncs.unmarshal(b, val, num, wtyp, opts)
- if err != nil {
- break
- }
- val = v
- n = o.n
- }
- if err == errUnknown {
- n = protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- } else if err != nil {
- return out, err
- }
- b = b[n:]
- }
- mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), mapi.conv.valConv.GoValueOf(val))
- out.n = n
- return out, nil
-}
-
-func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.BytesType {
- return out, errUnknown
- }
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- var (
- key = mapi.keyZero
- val = reflect.New(f.mi.GoReflectType.Elem())
- )
- for len(b) > 0 {
- num, wtyp, n := protowire.ConsumeTag(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if num > protowire.MaxValidNumber {
- return out, errors.New("invalid field number")
- }
- b = b[n:]
- err := errUnknown
- switch num {
- case 1:
- var v pref.Value
- var o unmarshalOutput
- v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
- if err != nil {
- break
- }
- key = v
- n = o.n
- case 2:
- if wtyp != protowire.BytesType {
- break
- }
- var v []byte
- v, n = protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- var o unmarshalOutput
- o, err = f.mi.unmarshalPointer(v, pointerOfValue(val), 0, opts)
- if o.initialized {
- // Consider this map item initialized so long as we see
- // an initialized value.
- out.initialized = true
- }
- }
- if err == errUnknown {
- n = protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- } else if err != nil {
- return out, err
- }
- b = b[n:]
- }
- mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), val)
- out.n = n
- return out, nil
-}
-
-func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- if f.mi == nil {
- key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
- val := mapi.conv.valConv.PBValueOf(valrv)
- size := 0
- size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
- size += mapi.valFuncs.size(val, mapValTagSize, opts)
- b = protowire.AppendVarint(b, uint64(size))
- b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
- if err != nil {
- return nil, err
- }
- return mapi.valFuncs.marshal(b, val, mapi.valWiretag, opts)
- } else {
- key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
- val := pointerOfValue(valrv)
- valSize := f.mi.sizePointer(val, opts)
- size := 0
- size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
- size += mapValTagSize + protowire.SizeBytes(valSize)
- b = protowire.AppendVarint(b, uint64(size))
- b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
- if err != nil {
- return nil, err
- }
- b = protowire.AppendVarint(b, mapi.valWiretag)
- b = protowire.AppendVarint(b, uint64(valSize))
- return f.mi.marshalAppendPointer(b, val, opts)
- }
-}
-
-func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- if mapv.Len() == 0 {
- return b, nil
- }
- if opts.Deterministic() {
- return appendMapDeterministic(b, mapv, mapi, f, opts)
- }
- iter := mapRange(mapv)
- for iter.Next() {
- var err error
- b = protowire.AppendVarint(b, f.wiretag)
- b, err = appendMapItem(b, iter.Key(), iter.Value(), mapi, f, opts)
- if err != nil {
- return b, err
- }
- }
- return b, nil
-}
-
-func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- keys := mapv.MapKeys()
- sort.Slice(keys, func(i, j int) bool {
- switch keys[i].Kind() {
- case reflect.Bool:
- return !keys[i].Bool() && keys[j].Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return keys[i].Int() < keys[j].Int()
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return keys[i].Uint() < keys[j].Uint()
- case reflect.Float32, reflect.Float64:
- return keys[i].Float() < keys[j].Float()
- case reflect.String:
- return keys[i].String() < keys[j].String()
- default:
- panic("invalid kind: " + keys[i].Kind().String())
- }
- })
- for _, key := range keys {
- var err error
- b = protowire.AppendVarint(b, f.wiretag)
- b, err = appendMapItem(b, key, mapv.MapIndex(key), mapi, f, opts)
- if err != nil {
- return b, err
- }
- }
- return b, nil
-}
-
-func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
- if mi := f.mi; mi != nil {
- mi.init()
- if !mi.needsInitCheck {
- return nil
- }
- iter := mapRange(mapv)
- for iter.Next() {
- val := pointerOfValue(iter.Value())
- if err := mi.checkInitializedPointer(val); err != nil {
- return err
- }
- }
- } else {
- iter := mapRange(mapv)
- for iter.Next() {
- val := mapi.conv.valConv.PBValueOf(iter.Value())
- if err := mapi.valFuncs.isInit(val); err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-func mergeMap(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
- dstm := dst.AsValueOf(f.ft).Elem()
- srcm := src.AsValueOf(f.ft).Elem()
- if srcm.Len() == 0 {
- return
- }
- if dstm.IsNil() {
- dstm.Set(reflect.MakeMap(f.ft))
- }
- iter := mapRange(srcm)
- for iter.Next() {
- dstm.SetMapIndex(iter.Key(), iter.Value())
- }
-}
-
-func mergeMapOfBytes(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
- dstm := dst.AsValueOf(f.ft).Elem()
- srcm := src.AsValueOf(f.ft).Elem()
- if srcm.Len() == 0 {
- return
- }
- if dstm.IsNil() {
- dstm.Set(reflect.MakeMap(f.ft))
- }
- iter := mapRange(srcm)
- for iter.Next() {
- dstm.SetMapIndex(iter.Key(), reflect.ValueOf(append(emptyBuf[:], iter.Value().Bytes()...)))
- }
-}
-
-func mergeMapOfMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
- dstm := dst.AsValueOf(f.ft).Elem()
- srcm := src.AsValueOf(f.ft).Elem()
- if srcm.Len() == 0 {
- return
- }
- if dstm.IsNil() {
- dstm.Set(reflect.MakeMap(f.ft))
- }
- iter := mapRange(srcm)
- for iter.Next() {
- val := reflect.New(f.ft.Elem().Elem())
- if f.mi != nil {
- f.mi.mergePointer(pointerOfValue(val), pointerOfValue(iter.Value()), opts)
- } else {
- opts.Merge(asMessage(val), asMessage(iter.Value()))
- }
- dstm.SetMapIndex(iter.Key(), val)
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go
deleted file mode 100644
index 2706bb6..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.12
-
-package impl
-
-import "reflect"
-
-type mapIter struct {
- v reflect.Value
- keys []reflect.Value
-}
-
-// mapRange provides a less-efficient equivalent to
-// the Go 1.12 reflect.Value.MapRange method.
-func mapRange(v reflect.Value) *mapIter {
- return &mapIter{v: v}
-}
-
-func (i *mapIter) Next() bool {
- if i.keys == nil {
- i.keys = i.v.MapKeys()
- } else {
- i.keys = i.keys[1:]
- }
- return len(i.keys) > 0
-}
-
-func (i *mapIter) Key() reflect.Value {
- return i.keys[0]
-}
-
-func (i *mapIter) Value() reflect.Value {
- return i.v.MapIndex(i.keys[0])
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go
deleted file mode 100644
index 1533ef6..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.12
-
-package impl
-
-import "reflect"
-
-func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go b/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
deleted file mode 100644
index 0e176d5..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "sort"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/fieldsort"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// coderMessageInfo contains per-message information used by the fast-path functions.
-// This is a different type from MessageInfo to keep MessageInfo as general-purpose as
-// possible.
-type coderMessageInfo struct {
- methods piface.Methods
-
- orderedCoderFields []*coderFieldInfo
- denseCoderFields []*coderFieldInfo
- coderFields map[protowire.Number]*coderFieldInfo
- sizecacheOffset offset
- unknownOffset offset
- extensionOffset offset
- needsInitCheck bool
- isMessageSet bool
- numRequiredFields uint8
-}
-
-type coderFieldInfo struct {
- funcs pointerCoderFuncs // fast-path per-field functions
- mi *MessageInfo // field's message
- ft reflect.Type
- validation validationInfo // information used by message validation
- num pref.FieldNumber // field number
- offset offset // struct field offset
- wiretag uint64 // field tag (number + wire type)
- tagsize int // size of the varint-encoded tag
- isPointer bool // true if IsNil may be called on the struct field
- isRequired bool // true if field is required
-}
-
-func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
- mi.sizecacheOffset = si.sizecacheOffset
- mi.unknownOffset = si.unknownOffset
- mi.extensionOffset = si.extensionOffset
-
- mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
- fields := mi.Desc.Fields()
- preallocFields := make([]coderFieldInfo, fields.Len())
- for i := 0; i < fields.Len(); i++ {
- fd := fields.Get(i)
-
- fs := si.fieldsByNumber[fd.Number()]
- isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
- if isOneof {
- fs = si.oneofsByName[fd.ContainingOneof().Name()]
- }
- ft := fs.Type
- var wiretag uint64
- if !fd.IsPacked() {
- wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
- } else {
- wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
- }
- var fieldOffset offset
- var funcs pointerCoderFuncs
- var childMessage *MessageInfo
- switch {
- case isOneof:
- fieldOffset = offsetOf(fs, mi.Exporter)
- case fd.IsWeak():
- fieldOffset = si.weakOffset
- funcs = makeWeakMessageFieldCoder(fd)
- default:
- fieldOffset = offsetOf(fs, mi.Exporter)
- childMessage, funcs = fieldCoder(fd, ft)
- }
- cf := &preallocFields[i]
- *cf = coderFieldInfo{
- num: fd.Number(),
- offset: fieldOffset,
- wiretag: wiretag,
- ft: ft,
- tagsize: protowire.SizeVarint(wiretag),
- funcs: funcs,
- mi: childMessage,
- validation: newFieldValidationInfo(mi, si, fd, ft),
- isPointer: fd.Cardinality() == pref.Repeated || fd.HasPresence(),
- isRequired: fd.Cardinality() == pref.Required,
- }
- mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
- mi.coderFields[cf.num] = cf
- }
- for i, oneofs := 0, mi.Desc.Oneofs(); i < oneofs.Len(); i++ {
- if od := oneofs.Get(i); !od.IsSynthetic() {
- mi.initOneofFieldCoders(od, si)
- }
- }
- if messageset.IsMessageSet(mi.Desc) {
- if !mi.extensionOffset.IsValid() {
- panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
- }
- if !mi.unknownOffset.IsValid() {
- panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
- }
- mi.isMessageSet = true
- }
- sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
- return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
- })
-
- var maxDense pref.FieldNumber
- for _, cf := range mi.orderedCoderFields {
- if cf.num >= 16 && cf.num >= 2*maxDense {
- break
- }
- maxDense = cf.num
- }
- mi.denseCoderFields = make([]*coderFieldInfo, maxDense+1)
- for _, cf := range mi.orderedCoderFields {
- if int(cf.num) >= len(mi.denseCoderFields) {
- break
- }
- mi.denseCoderFields[cf.num] = cf
- }
-
- // To preserve compatibility with historic wire output, marshal oneofs last.
- if mi.Desc.Oneofs().Len() > 0 {
- sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
- fi := fields.ByNumber(mi.orderedCoderFields[i].num)
- fj := fields.ByNumber(mi.orderedCoderFields[j].num)
- return fieldsort.Less(fi, fj)
- })
- }
-
- mi.needsInitCheck = needsInitCheck(mi.Desc)
- if mi.methods.Marshal == nil && mi.methods.Size == nil {
- mi.methods.Flags |= piface.SupportMarshalDeterministic
- mi.methods.Marshal = mi.marshal
- mi.methods.Size = mi.size
- }
- if mi.methods.Unmarshal == nil {
- mi.methods.Flags |= piface.SupportUnmarshalDiscardUnknown
- mi.methods.Unmarshal = mi.unmarshal
- }
- if mi.methods.CheckInitialized == nil {
- mi.methods.CheckInitialized = mi.checkInitialized
- }
- if mi.methods.Merge == nil {
- mi.methods.Merge = mi.merge
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go b/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go
deleted file mode 100644
index cfb68e1..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "sort"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/flags"
-)
-
-func sizeMessageSet(mi *MessageInfo, p pointer, opts marshalOptions) (size int) {
- if !flags.ProtoLegacy {
- return 0
- }
-
- ext := *p.Apply(mi.extensionOffset).Extensions()
- for _, x := range ext {
- xi := getExtensionFieldInfo(x.Type())
- if xi.funcs.size == nil {
- continue
- }
- num, _ := protowire.DecodeTag(xi.wiretag)
- size += messageset.SizeField(num)
- size += xi.funcs.size(x.Value(), protowire.SizeTag(messageset.FieldMessage), opts)
- }
-
- unknown := *p.Apply(mi.unknownOffset).Bytes()
- size += messageset.SizeUnknown(unknown)
-
- return size
-}
-
-func marshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts marshalOptions) ([]byte, error) {
- if !flags.ProtoLegacy {
- return b, errors.New("no support for message_set_wire_format")
- }
-
- ext := *p.Apply(mi.extensionOffset).Extensions()
- switch len(ext) {
- case 0:
- case 1:
- // Fast-path for one extension: Don't bother sorting the keys.
- for _, x := range ext {
- var err error
- b, err = marshalMessageSetField(mi, b, x, opts)
- if err != nil {
- return b, err
- }
- }
- default:
- // Sort the keys to provide a deterministic encoding.
- // Not sure this is required, but the old code does it.
- keys := make([]int, 0, len(ext))
- for k := range ext {
- keys = append(keys, int(k))
- }
- sort.Ints(keys)
- for _, k := range keys {
- var err error
- b, err = marshalMessageSetField(mi, b, ext[int32(k)], opts)
- if err != nil {
- return b, err
- }
- }
- }
-
- unknown := *p.Apply(mi.unknownOffset).Bytes()
- b, err := messageset.AppendUnknown(b, unknown)
- if err != nil {
- return b, err
- }
-
- return b, nil
-}
-
-func marshalMessageSetField(mi *MessageInfo, b []byte, x ExtensionField, opts marshalOptions) ([]byte, error) {
- xi := getExtensionFieldInfo(x.Type())
- num, _ := protowire.DecodeTag(xi.wiretag)
- b = messageset.AppendFieldStart(b, num)
- b, err := xi.funcs.marshal(b, x.Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), opts)
- if err != nil {
- return b, err
- }
- b = messageset.AppendFieldEnd(b)
- return b, nil
-}
-
-func unmarshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if !flags.ProtoLegacy {
- return out, errors.New("no support for message_set_wire_format")
- }
-
- ep := p.Apply(mi.extensionOffset).Extensions()
- if *ep == nil {
- *ep = make(map[int32]ExtensionField)
- }
- ext := *ep
- unknown := p.Apply(mi.unknownOffset).Bytes()
- initialized := true
- err = messageset.Unmarshal(b, true, func(num protowire.Number, v []byte) error {
- o, err := mi.unmarshalExtension(v, num, protowire.BytesType, ext, opts)
- if err == errUnknown {
- *unknown = protowire.AppendTag(*unknown, num, protowire.BytesType)
- *unknown = append(*unknown, v...)
- return nil
- }
- if !o.initialized {
- initialized = false
- }
- return err
- })
- out.n = len(b)
- out.initialized = initialized
- return out, err
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
deleted file mode 100644
index 86f7dc3..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package impl
-
-import (
- "reflect"
-
- "google.golang.org/protobuf/encoding/protowire"
-)
-
-func sizeEnum(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
- v := p.v.Elem().Int()
- return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-func appendEnum(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- v := p.v.Elem().Int()
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(v))
- return b, nil
-}
-
-func consumeEnum(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- p.v.Elem().SetInt(int64(v))
- out.n = n
- return out, nil
-}
-
-func mergeEnum(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- dst.v.Elem().Set(src.v.Elem())
-}
-
-var coderEnum = pointerCoderFuncs{
- size: sizeEnum,
- marshal: appendEnum,
- unmarshal: consumeEnum,
- merge: mergeEnum,
-}
-
-func sizeEnumNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- if p.v.Elem().Int() == 0 {
- return 0
- }
- return sizeEnum(p, f, opts)
-}
-
-func appendEnumNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- if p.v.Elem().Int() == 0 {
- return b, nil
- }
- return appendEnum(b, p, f, opts)
-}
-
-func mergeEnumNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- if src.v.Elem().Int() != 0 {
- dst.v.Elem().Set(src.v.Elem())
- }
-}
-
-var coderEnumNoZero = pointerCoderFuncs{
- size: sizeEnumNoZero,
- marshal: appendEnumNoZero,
- unmarshal: consumeEnum,
- merge: mergeEnumNoZero,
-}
-
-func sizeEnumPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- return sizeEnum(pointer{p.v.Elem()}, f, opts)
-}
-
-func appendEnumPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- return appendEnum(b, pointer{p.v.Elem()}, f, opts)
-}
-
-func consumeEnumPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- if p.v.Elem().IsNil() {
- p.v.Elem().Set(reflect.New(p.v.Elem().Type().Elem()))
- }
- return consumeEnum(b, pointer{p.v.Elem()}, wtyp, f, opts)
-}
-
-func mergeEnumPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- if !src.v.Elem().IsNil() {
- v := reflect.New(dst.v.Type().Elem().Elem())
- v.Elem().Set(src.v.Elem().Elem())
- dst.v.Elem().Set(v)
- }
-}
-
-var coderEnumPtr = pointerCoderFuncs{
- size: sizeEnumPtr,
- marshal: appendEnumPtr,
- unmarshal: consumeEnumPtr,
- merge: mergeEnumPtr,
-}
-
-func sizeEnumSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- s := p.v.Elem()
- for i, llen := 0, s.Len(); i < llen; i++ {
- size += protowire.SizeVarint(uint64(s.Index(i).Int())) + f.tagsize
- }
- return size
-}
-
-func appendEnumSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- s := p.v.Elem()
- for i, llen := 0, s.Len(); i < llen; i++ {
- b = protowire.AppendVarint(b, f.wiretag)
- b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
- }
- return b, nil
-}
-
-func consumeEnumSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
- s := p.v.Elem()
- if wtyp == protowire.BytesType {
- b, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- for len(b) > 0 {
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- rv := reflect.New(s.Type().Elem()).Elem()
- rv.SetInt(int64(v))
- s.Set(reflect.Append(s, rv))
- b = b[n:]
- }
- out.n = n
- return out, nil
- }
- if wtyp != protowire.VarintType {
- return out, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- rv := reflect.New(s.Type().Elem()).Elem()
- rv.SetInt(int64(v))
- s.Set(reflect.Append(s, rv))
- out.n = n
- return out, nil
-}
-
-func mergeEnumSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- dst.v.Elem().Set(reflect.AppendSlice(dst.v.Elem(), src.v.Elem()))
-}
-
-var coderEnumSlice = pointerCoderFuncs{
- size: sizeEnumSlice,
- marshal: appendEnumSlice,
- unmarshal: consumeEnumSlice,
- merge: mergeEnumSlice,
-}
-
-func sizeEnumPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
- s := p.v.Elem()
- llen := s.Len()
- if llen == 0 {
- return 0
- }
- n := 0
- for i := 0; i < llen; i++ {
- n += protowire.SizeVarint(uint64(s.Index(i).Int()))
- }
- return f.tagsize + protowire.SizeBytes(n)
-}
-
-func appendEnumPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
- s := p.v.Elem()
- llen := s.Len()
- if llen == 0 {
- return b, nil
- }
- b = protowire.AppendVarint(b, f.wiretag)
- n := 0
- for i := 0; i < llen; i++ {
- n += protowire.SizeVarint(uint64(s.Index(i).Int()))
- }
- b = protowire.AppendVarint(b, uint64(n))
- for i := 0; i < llen; i++ {
- b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
- }
- return b, nil
-}
-
-var coderEnumPackedSlice = pointerCoderFuncs{
- size: sizeEnumPackedSlice,
- marshal: appendEnumPackedSlice,
- unmarshal: consumeEnumSlice,
- merge: mergeEnumSlice,
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go b/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go
deleted file mode 100644
index e899712..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go
+++ /dev/null
@@ -1,557 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/strs"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// pointerCoderFuncs is a set of pointer encoding functions.
-type pointerCoderFuncs struct {
- mi *MessageInfo
- size func(p pointer, f *coderFieldInfo, opts marshalOptions) int
- marshal func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error)
- unmarshal func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
- isInit func(p pointer, f *coderFieldInfo) error
- merge func(dst, src pointer, f *coderFieldInfo, opts mergeOptions)
-}
-
-// valueCoderFuncs is a set of protoreflect.Value encoding functions.
-type valueCoderFuncs struct {
- size func(v pref.Value, tagsize int, opts marshalOptions) int
- marshal func(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
- unmarshal func(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error)
- isInit func(v pref.Value) error
- merge func(dst, src pref.Value, opts mergeOptions) pref.Value
-}
-
-// fieldCoder returns pointer functions for a field, used for operating on
-// struct fields.
-func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
- switch {
- case fd.IsMap():
- return encoderFuncsForMap(fd, ft)
- case fd.Cardinality() == pref.Repeated && !fd.IsPacked():
- // Repeated fields (not packed).
- if ft.Kind() != reflect.Slice {
- break
- }
- ft := ft.Elem()
- switch fd.Kind() {
- case pref.BoolKind:
- if ft.Kind() == reflect.Bool {
- return nil, coderBoolSlice
- }
- case pref.EnumKind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderEnumSlice
- }
- case pref.Int32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderInt32Slice
- }
- case pref.Sint32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSint32Slice
- }
- case pref.Uint32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderUint32Slice
- }
- case pref.Int64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderInt64Slice
- }
- case pref.Sint64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSint64Slice
- }
- case pref.Uint64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderUint64Slice
- }
- case pref.Sfixed32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSfixed32Slice
- }
- case pref.Fixed32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderFixed32Slice
- }
- case pref.FloatKind:
- if ft.Kind() == reflect.Float32 {
- return nil, coderFloatSlice
- }
- case pref.Sfixed64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSfixed64Slice
- }
- case pref.Fixed64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderFixed64Slice
- }
- case pref.DoubleKind:
- if ft.Kind() == reflect.Float64 {
- return nil, coderDoubleSlice
- }
- case pref.StringKind:
- if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
- return nil, coderStringSliceValidateUTF8
- }
- if ft.Kind() == reflect.String {
- return nil, coderStringSlice
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
- return nil, coderBytesSliceValidateUTF8
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
- return nil, coderBytesSlice
- }
- case pref.BytesKind:
- if ft.Kind() == reflect.String {
- return nil, coderStringSlice
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
- return nil, coderBytesSlice
- }
- case pref.MessageKind:
- return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft)
- case pref.GroupKind:
- return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft)
- }
- case fd.Cardinality() == pref.Repeated && fd.IsPacked():
- // Packed repeated fields.
- //
- // Only repeated fields of primitive numeric types
- // (Varint, Fixed32, or Fixed64 wire type) can be packed.
- if ft.Kind() != reflect.Slice {
- break
- }
- ft := ft.Elem()
- switch fd.Kind() {
- case pref.BoolKind:
- if ft.Kind() == reflect.Bool {
- return nil, coderBoolPackedSlice
- }
- case pref.EnumKind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderEnumPackedSlice
- }
- case pref.Int32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderInt32PackedSlice
- }
- case pref.Sint32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSint32PackedSlice
- }
- case pref.Uint32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderUint32PackedSlice
- }
- case pref.Int64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderInt64PackedSlice
- }
- case pref.Sint64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSint64PackedSlice
- }
- case pref.Uint64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderUint64PackedSlice
- }
- case pref.Sfixed32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSfixed32PackedSlice
- }
- case pref.Fixed32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderFixed32PackedSlice
- }
- case pref.FloatKind:
- if ft.Kind() == reflect.Float32 {
- return nil, coderFloatPackedSlice
- }
- case pref.Sfixed64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSfixed64PackedSlice
- }
- case pref.Fixed64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderFixed64PackedSlice
- }
- case pref.DoubleKind:
- if ft.Kind() == reflect.Float64 {
- return nil, coderDoublePackedSlice
- }
- }
- case fd.Kind() == pref.MessageKind:
- return getMessageInfo(ft), makeMessageFieldCoder(fd, ft)
- case fd.Kind() == pref.GroupKind:
- return getMessageInfo(ft), makeGroupFieldCoder(fd, ft)
- case fd.Syntax() == pref.Proto3 && fd.ContainingOneof() == nil:
- // Populated oneof fields always encode even if set to the zero value,
- // which normally are not encoded in proto3.
- switch fd.Kind() {
- case pref.BoolKind:
- if ft.Kind() == reflect.Bool {
- return nil, coderBoolNoZero
- }
- case pref.EnumKind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderEnumNoZero
- }
- case pref.Int32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderInt32NoZero
- }
- case pref.Sint32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSint32NoZero
- }
- case pref.Uint32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderUint32NoZero
- }
- case pref.Int64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderInt64NoZero
- }
- case pref.Sint64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSint64NoZero
- }
- case pref.Uint64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderUint64NoZero
- }
- case pref.Sfixed32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSfixed32NoZero
- }
- case pref.Fixed32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderFixed32NoZero
- }
- case pref.FloatKind:
- if ft.Kind() == reflect.Float32 {
- return nil, coderFloatNoZero
- }
- case pref.Sfixed64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSfixed64NoZero
- }
- case pref.Fixed64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderFixed64NoZero
- }
- case pref.DoubleKind:
- if ft.Kind() == reflect.Float64 {
- return nil, coderDoubleNoZero
- }
- case pref.StringKind:
- if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
- return nil, coderStringNoZeroValidateUTF8
- }
- if ft.Kind() == reflect.String {
- return nil, coderStringNoZero
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
- return nil, coderBytesNoZeroValidateUTF8
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
- return nil, coderBytesNoZero
- }
- case pref.BytesKind:
- if ft.Kind() == reflect.String {
- return nil, coderStringNoZero
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
- return nil, coderBytesNoZero
- }
- }
- case ft.Kind() == reflect.Ptr:
- ft := ft.Elem()
- switch fd.Kind() {
- case pref.BoolKind:
- if ft.Kind() == reflect.Bool {
- return nil, coderBoolPtr
- }
- case pref.EnumKind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderEnumPtr
- }
- case pref.Int32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderInt32Ptr
- }
- case pref.Sint32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSint32Ptr
- }
- case pref.Uint32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderUint32Ptr
- }
- case pref.Int64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderInt64Ptr
- }
- case pref.Sint64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSint64Ptr
- }
- case pref.Uint64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderUint64Ptr
- }
- case pref.Sfixed32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSfixed32Ptr
- }
- case pref.Fixed32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderFixed32Ptr
- }
- case pref.FloatKind:
- if ft.Kind() == reflect.Float32 {
- return nil, coderFloatPtr
- }
- case pref.Sfixed64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSfixed64Ptr
- }
- case pref.Fixed64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderFixed64Ptr
- }
- case pref.DoubleKind:
- if ft.Kind() == reflect.Float64 {
- return nil, coderDoublePtr
- }
- case pref.StringKind:
- if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
- return nil, coderStringPtrValidateUTF8
- }
- if ft.Kind() == reflect.String {
- return nil, coderStringPtr
- }
- case pref.BytesKind:
- if ft.Kind() == reflect.String {
- return nil, coderStringPtr
- }
- }
- default:
- switch fd.Kind() {
- case pref.BoolKind:
- if ft.Kind() == reflect.Bool {
- return nil, coderBool
- }
- case pref.EnumKind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderEnum
- }
- case pref.Int32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderInt32
- }
- case pref.Sint32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSint32
- }
- case pref.Uint32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderUint32
- }
- case pref.Int64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderInt64
- }
- case pref.Sint64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSint64
- }
- case pref.Uint64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderUint64
- }
- case pref.Sfixed32Kind:
- if ft.Kind() == reflect.Int32 {
- return nil, coderSfixed32
- }
- case pref.Fixed32Kind:
- if ft.Kind() == reflect.Uint32 {
- return nil, coderFixed32
- }
- case pref.FloatKind:
- if ft.Kind() == reflect.Float32 {
- return nil, coderFloat
- }
- case pref.Sfixed64Kind:
- if ft.Kind() == reflect.Int64 {
- return nil, coderSfixed64
- }
- case pref.Fixed64Kind:
- if ft.Kind() == reflect.Uint64 {
- return nil, coderFixed64
- }
- case pref.DoubleKind:
- if ft.Kind() == reflect.Float64 {
- return nil, coderDouble
- }
- case pref.StringKind:
- if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
- return nil, coderStringValidateUTF8
- }
- if ft.Kind() == reflect.String {
- return nil, coderString
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
- return nil, coderBytesValidateUTF8
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
- return nil, coderBytes
- }
- case pref.BytesKind:
- if ft.Kind() == reflect.String {
- return nil, coderString
- }
- if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
- return nil, coderBytes
- }
- }
- }
- panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft))
-}
-
-// encoderFuncsForValue returns value functions for a field, used for
-// extension values and map encoding.
-func encoderFuncsForValue(fd pref.FieldDescriptor) valueCoderFuncs {
- switch {
- case fd.Cardinality() == pref.Repeated && !fd.IsPacked():
- switch fd.Kind() {
- case pref.BoolKind:
- return coderBoolSliceValue
- case pref.EnumKind:
- return coderEnumSliceValue
- case pref.Int32Kind:
- return coderInt32SliceValue
- case pref.Sint32Kind:
- return coderSint32SliceValue
- case pref.Uint32Kind:
- return coderUint32SliceValue
- case pref.Int64Kind:
- return coderInt64SliceValue
- case pref.Sint64Kind:
- return coderSint64SliceValue
- case pref.Uint64Kind:
- return coderUint64SliceValue
- case pref.Sfixed32Kind:
- return coderSfixed32SliceValue
- case pref.Fixed32Kind:
- return coderFixed32SliceValue
- case pref.FloatKind:
- return coderFloatSliceValue
- case pref.Sfixed64Kind:
- return coderSfixed64SliceValue
- case pref.Fixed64Kind:
- return coderFixed64SliceValue
- case pref.DoubleKind:
- return coderDoubleSliceValue
- case pref.StringKind:
- // We don't have a UTF-8 validating coder for repeated string fields.
- // Value coders are used for extensions and maps.
- // Extensions are never proto3, and maps never contain lists.
- return coderStringSliceValue
- case pref.BytesKind:
- return coderBytesSliceValue
- case pref.MessageKind:
- return coderMessageSliceValue
- case pref.GroupKind:
- return coderGroupSliceValue
- }
- case fd.Cardinality() == pref.Repeated && fd.IsPacked():
- switch fd.Kind() {
- case pref.BoolKind:
- return coderBoolPackedSliceValue
- case pref.EnumKind:
- return coderEnumPackedSliceValue
- case pref.Int32Kind:
- return coderInt32PackedSliceValue
- case pref.Sint32Kind:
- return coderSint32PackedSliceValue
- case pref.Uint32Kind:
- return coderUint32PackedSliceValue
- case pref.Int64Kind:
- return coderInt64PackedSliceValue
- case pref.Sint64Kind:
- return coderSint64PackedSliceValue
- case pref.Uint64Kind:
- return coderUint64PackedSliceValue
- case pref.Sfixed32Kind:
- return coderSfixed32PackedSliceValue
- case pref.Fixed32Kind:
- return coderFixed32PackedSliceValue
- case pref.FloatKind:
- return coderFloatPackedSliceValue
- case pref.Sfixed64Kind:
- return coderSfixed64PackedSliceValue
- case pref.Fixed64Kind:
- return coderFixed64PackedSliceValue
- case pref.DoubleKind:
- return coderDoublePackedSliceValue
- }
- default:
- switch fd.Kind() {
- default:
- case pref.BoolKind:
- return coderBoolValue
- case pref.EnumKind:
- return coderEnumValue
- case pref.Int32Kind:
- return coderInt32Value
- case pref.Sint32Kind:
- return coderSint32Value
- case pref.Uint32Kind:
- return coderUint32Value
- case pref.Int64Kind:
- return coderInt64Value
- case pref.Sint64Kind:
- return coderSint64Value
- case pref.Uint64Kind:
- return coderUint64Value
- case pref.Sfixed32Kind:
- return coderSfixed32Value
- case pref.Fixed32Kind:
- return coderFixed32Value
- case pref.FloatKind:
- return coderFloatValue
- case pref.Sfixed64Kind:
- return coderSfixed64Value
- case pref.Fixed64Kind:
- return coderFixed64Value
- case pref.DoubleKind:
- return coderDoubleValue
- case pref.StringKind:
- if strs.EnforceUTF8(fd) {
- return coderStringValueValidateUTF8
- }
- return coderStringValue
- case pref.BytesKind:
- return coderBytesValue
- case pref.MessageKind:
- return coderMessageValue
- case pref.GroupKind:
- return coderGroupValue
- }
- }
- panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind()))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
deleted file mode 100644
index e118af1..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package impl
-
-// When using unsafe pointers, we can just treat enum values as int32s.
-
-var (
- coderEnumNoZero = coderInt32NoZero
- coderEnum = coderInt32
- coderEnumPtr = coderInt32Ptr
- coderEnumSlice = coderInt32Slice
- coderEnumPackedSlice = coderInt32PackedSlice
-)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert.go b/vendor/google.golang.org/protobuf/internal/impl/convert.go
deleted file mode 100644
index 36a90df..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/convert.go
+++ /dev/null
@@ -1,467 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// unwrapper unwraps the value to the underlying value.
-// This is implemented by List and Map.
-type unwrapper interface {
- protoUnwrap() interface{}
-}
-
-// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
-type Converter interface {
- // PBValueOf converts a reflect.Value to a protoreflect.Value.
- PBValueOf(reflect.Value) pref.Value
-
- // GoValueOf converts a protoreflect.Value to a reflect.Value.
- GoValueOf(pref.Value) reflect.Value
-
- // IsValidPB returns whether a protoreflect.Value is compatible with this type.
- IsValidPB(pref.Value) bool
-
- // IsValidGo returns whether a reflect.Value is compatible with this type.
- IsValidGo(reflect.Value) bool
-
- // New returns a new field value.
- // For scalars, it returns the default value of the field.
- // For composite types, it returns a new mutable value.
- New() pref.Value
-
- // Zero returns a new field value.
- // For scalars, it returns the default value of the field.
- // For composite types, it returns an immutable, empty value.
- Zero() pref.Value
-}
-
-// NewConverter matches a Go type with a protobuf field and returns a Converter
-// that converts between the two. Enums must be a named int32 kind that
-// implements protoreflect.Enum, and messages must be pointer to a named
-// struct type that implements protoreflect.ProtoMessage.
-//
-// This matcher deliberately supports a wider range of Go types than what
-// protoc-gen-go historically generated to be able to automatically wrap some
-// v1 messages generated by other forks of protoc-gen-go.
-func NewConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
- switch {
- case fd.IsList():
- return newListConverter(t, fd)
- case fd.IsMap():
- return newMapConverter(t, fd)
- default:
- return newSingularConverter(t, fd)
- }
- panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-}
-
-var (
- boolType = reflect.TypeOf(bool(false))
- int32Type = reflect.TypeOf(int32(0))
- int64Type = reflect.TypeOf(int64(0))
- uint32Type = reflect.TypeOf(uint32(0))
- uint64Type = reflect.TypeOf(uint64(0))
- float32Type = reflect.TypeOf(float32(0))
- float64Type = reflect.TypeOf(float64(0))
- stringType = reflect.TypeOf(string(""))
- bytesType = reflect.TypeOf([]byte(nil))
- byteType = reflect.TypeOf(byte(0))
-)
-
-var (
- boolZero = pref.ValueOfBool(false)
- int32Zero = pref.ValueOfInt32(0)
- int64Zero = pref.ValueOfInt64(0)
- uint32Zero = pref.ValueOfUint32(0)
- uint64Zero = pref.ValueOfUint64(0)
- float32Zero = pref.ValueOfFloat32(0)
- float64Zero = pref.ValueOfFloat64(0)
- stringZero = pref.ValueOfString("")
- bytesZero = pref.ValueOfBytes(nil)
-)
-
-func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
- defVal := func(fd pref.FieldDescriptor, zero pref.Value) pref.Value {
- if fd.Cardinality() == pref.Repeated {
- // Default isn't defined for repeated fields.
- return zero
- }
- return fd.Default()
- }
- switch fd.Kind() {
- case pref.BoolKind:
- if t.Kind() == reflect.Bool {
- return &boolConverter{t, defVal(fd, boolZero)}
- }
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
- if t.Kind() == reflect.Int32 {
- return &int32Converter{t, defVal(fd, int32Zero)}
- }
- case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- if t.Kind() == reflect.Int64 {
- return &int64Converter{t, defVal(fd, int64Zero)}
- }
- case pref.Uint32Kind, pref.Fixed32Kind:
- if t.Kind() == reflect.Uint32 {
- return &uint32Converter{t, defVal(fd, uint32Zero)}
- }
- case pref.Uint64Kind, pref.Fixed64Kind:
- if t.Kind() == reflect.Uint64 {
- return &uint64Converter{t, defVal(fd, uint64Zero)}
- }
- case pref.FloatKind:
- if t.Kind() == reflect.Float32 {
- return &float32Converter{t, defVal(fd, float32Zero)}
- }
- case pref.DoubleKind:
- if t.Kind() == reflect.Float64 {
- return &float64Converter{t, defVal(fd, float64Zero)}
- }
- case pref.StringKind:
- if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
- return &stringConverter{t, defVal(fd, stringZero)}
- }
- case pref.BytesKind:
- if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
- return &bytesConverter{t, defVal(fd, bytesZero)}
- }
- case pref.EnumKind:
- // Handle enums, which must be a named int32 type.
- if t.Kind() == reflect.Int32 {
- return newEnumConverter(t, fd)
- }
- case pref.MessageKind, pref.GroupKind:
- return newMessageConverter(t)
- }
- panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-}
-
-type boolConverter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *boolConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfBool(v.Bool())
-}
-func (c *boolConverter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(v.Bool()).Convert(c.goType)
-}
-func (c *boolConverter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(bool)
- return ok
-}
-func (c *boolConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *boolConverter) New() pref.Value { return c.def }
-func (c *boolConverter) Zero() pref.Value { return c.def }
-
-type int32Converter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *int32Converter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfInt32(int32(v.Int()))
-}
-func (c *int32Converter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
-}
-func (c *int32Converter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(int32)
- return ok
-}
-func (c *int32Converter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *int32Converter) New() pref.Value { return c.def }
-func (c *int32Converter) Zero() pref.Value { return c.def }
-
-type int64Converter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *int64Converter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfInt64(int64(v.Int()))
-}
-func (c *int64Converter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
-}
-func (c *int64Converter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(int64)
- return ok
-}
-func (c *int64Converter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *int64Converter) New() pref.Value { return c.def }
-func (c *int64Converter) Zero() pref.Value { return c.def }
-
-type uint32Converter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *uint32Converter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfUint32(uint32(v.Uint()))
-}
-func (c *uint32Converter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
-}
-func (c *uint32Converter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(uint32)
- return ok
-}
-func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *uint32Converter) New() pref.Value { return c.def }
-func (c *uint32Converter) Zero() pref.Value { return c.def }
-
-type uint64Converter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *uint64Converter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfUint64(uint64(v.Uint()))
-}
-func (c *uint64Converter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
-}
-func (c *uint64Converter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(uint64)
- return ok
-}
-func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *uint64Converter) New() pref.Value { return c.def }
-func (c *uint64Converter) Zero() pref.Value { return c.def }
-
-type float32Converter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *float32Converter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfFloat32(float32(v.Float()))
-}
-func (c *float32Converter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
-}
-func (c *float32Converter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(float32)
- return ok
-}
-func (c *float32Converter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *float32Converter) New() pref.Value { return c.def }
-func (c *float32Converter) Zero() pref.Value { return c.def }
-
-type float64Converter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *float64Converter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfFloat64(float64(v.Float()))
-}
-func (c *float64Converter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
-}
-func (c *float64Converter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(float64)
- return ok
-}
-func (c *float64Converter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *float64Converter) New() pref.Value { return c.def }
-func (c *float64Converter) Zero() pref.Value { return c.def }
-
-type stringConverter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *stringConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfString(v.Convert(stringType).String())
-}
-func (c *stringConverter) GoValueOf(v pref.Value) reflect.Value {
- // pref.Value.String never panics, so we go through an interface
- // conversion here to check the type.
- s := v.Interface().(string)
- if c.goType.Kind() == reflect.Slice && s == "" {
- return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
- }
- return reflect.ValueOf(s).Convert(c.goType)
-}
-func (c *stringConverter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(string)
- return ok
-}
-func (c *stringConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *stringConverter) New() pref.Value { return c.def }
-func (c *stringConverter) Zero() pref.Value { return c.def }
-
-type bytesConverter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func (c *bytesConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- if c.goType.Kind() == reflect.String && v.Len() == 0 {
- return pref.ValueOfBytes(nil) // ensure empty string is []byte(nil)
- }
- return pref.ValueOfBytes(v.Convert(bytesType).Bytes())
-}
-func (c *bytesConverter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(v.Bytes()).Convert(c.goType)
-}
-func (c *bytesConverter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().([]byte)
- return ok
-}
-func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-func (c *bytesConverter) New() pref.Value { return c.def }
-func (c *bytesConverter) Zero() pref.Value { return c.def }
-
-type enumConverter struct {
- goType reflect.Type
- def pref.Value
-}
-
-func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
- var def pref.Value
- if fd.Cardinality() == pref.Repeated {
- def = pref.ValueOfEnum(fd.Enum().Values().Get(0).Number())
- } else {
- def = fd.Default()
- }
- return &enumConverter{goType, def}
-}
-
-func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfEnum(pref.EnumNumber(v.Int()))
-}
-
-func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
- return reflect.ValueOf(v.Enum()).Convert(c.goType)
-}
-
-func (c *enumConverter) IsValidPB(v pref.Value) bool {
- _, ok := v.Interface().(pref.EnumNumber)
- return ok
-}
-
-func (c *enumConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *enumConverter) New() pref.Value {
- return c.def
-}
-
-func (c *enumConverter) Zero() pref.Value {
- return c.def
-}
-
-type messageConverter struct {
- goType reflect.Type
-}
-
-func newMessageConverter(goType reflect.Type) Converter {
- return &messageConverter{goType}
-}
-
-func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- if m, ok := v.Interface().(pref.ProtoMessage); ok {
- return pref.ValueOfMessage(m.ProtoReflect())
- }
- return pref.ValueOfMessage(legacyWrapMessage(v))
-}
-
-func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
- m := v.Message()
- var rv reflect.Value
- if u, ok := m.(unwrapper); ok {
- rv = reflect.ValueOf(u.protoUnwrap())
- } else {
- rv = reflect.ValueOf(m.Interface())
- }
- if rv.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
- }
- return rv
-}
-
-func (c *messageConverter) IsValidPB(v pref.Value) bool {
- m := v.Message()
- var rv reflect.Value
- if u, ok := m.(unwrapper); ok {
- rv = reflect.ValueOf(u.protoUnwrap())
- } else {
- rv = reflect.ValueOf(m.Interface())
- }
- return rv.Type() == c.goType
-}
-
-func (c *messageConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *messageConverter) New() pref.Value {
- return c.PBValueOf(reflect.New(c.goType.Elem()))
-}
-
-func (c *messageConverter) Zero() pref.Value {
- return c.PBValueOf(reflect.Zero(c.goType))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert_list.go b/vendor/google.golang.org/protobuf/internal/impl/convert_list.go
deleted file mode 100644
index 6fccab5..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/convert_list.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func newListConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
- switch {
- case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Slice:
- return &listPtrConverter{t, newSingularConverter(t.Elem().Elem(), fd)}
- case t.Kind() == reflect.Slice:
- return &listConverter{t, newSingularConverter(t.Elem(), fd)}
- }
- panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-}
-
-type listConverter struct {
- goType reflect.Type // []T
- c Converter
-}
-
-func (c *listConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- pv := reflect.New(c.goType)
- pv.Elem().Set(v)
- return pref.ValueOfList(&listReflect{pv, c.c})
-}
-
-func (c *listConverter) GoValueOf(v pref.Value) reflect.Value {
- rv := v.List().(*listReflect).v
- if rv.IsNil() {
- return reflect.Zero(c.goType)
- }
- return rv.Elem()
-}
-
-func (c *listConverter) IsValidPB(v pref.Value) bool {
- list, ok := v.Interface().(*listReflect)
- if !ok {
- return false
- }
- return list.v.Type().Elem() == c.goType
-}
-
-func (c *listConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *listConverter) New() pref.Value {
- return pref.ValueOfList(&listReflect{reflect.New(c.goType), c.c})
-}
-
-func (c *listConverter) Zero() pref.Value {
- return pref.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
-}
-
-type listPtrConverter struct {
- goType reflect.Type // *[]T
- c Converter
-}
-
-func (c *listPtrConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfList(&listReflect{v, c.c})
-}
-
-func (c *listPtrConverter) GoValueOf(v pref.Value) reflect.Value {
- return v.List().(*listReflect).v
-}
-
-func (c *listPtrConverter) IsValidPB(v pref.Value) bool {
- list, ok := v.Interface().(*listReflect)
- if !ok {
- return false
- }
- return list.v.Type() == c.goType
-}
-
-func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *listPtrConverter) New() pref.Value {
- return c.PBValueOf(reflect.New(c.goType.Elem()))
-}
-
-func (c *listPtrConverter) Zero() pref.Value {
- return c.PBValueOf(reflect.Zero(c.goType))
-}
-
-type listReflect struct {
- v reflect.Value // *[]T
- conv Converter
-}
-
-func (ls *listReflect) Len() int {
- if ls.v.IsNil() {
- return 0
- }
- return ls.v.Elem().Len()
-}
-func (ls *listReflect) Get(i int) pref.Value {
- return ls.conv.PBValueOf(ls.v.Elem().Index(i))
-}
-func (ls *listReflect) Set(i int, v pref.Value) {
- ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v))
-}
-func (ls *listReflect) Append(v pref.Value) {
- ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
-}
-func (ls *listReflect) AppendMutable() pref.Value {
- if _, ok := ls.conv.(*messageConverter); !ok {
- panic("invalid AppendMutable on list with non-message type")
- }
- v := ls.NewElement()
- ls.Append(v)
- return v
-}
-func (ls *listReflect) Truncate(i int) {
- ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
-}
-func (ls *listReflect) NewElement() pref.Value {
- return ls.conv.New()
-}
-func (ls *listReflect) IsValid() bool {
- return !ls.v.IsNil()
-}
-func (ls *listReflect) protoUnwrap() interface{} {
- return ls.v.Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert_map.go b/vendor/google.golang.org/protobuf/internal/impl/convert_map.go
deleted file mode 100644
index de06b25..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/convert_map.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type mapConverter struct {
- goType reflect.Type // map[K]V
- keyConv, valConv Converter
-}
-
-func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
- if t.Kind() != reflect.Map {
- panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
- }
- return &mapConverter{
- goType: t,
- keyConv: newSingularConverter(t.Key(), fd.MapKey()),
- valConv: newSingularConverter(t.Elem(), fd.MapValue()),
- }
-}
-
-func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
- if v.Type() != c.goType {
- panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
- }
- return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
-}
-
-func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
- return v.Map().(*mapReflect).v
-}
-
-func (c *mapConverter) IsValidPB(v pref.Value) bool {
- mapv, ok := v.Interface().(*mapReflect)
- if !ok {
- return false
- }
- return mapv.v.Type() == c.goType
-}
-
-func (c *mapConverter) IsValidGo(v reflect.Value) bool {
- return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *mapConverter) New() pref.Value {
- return c.PBValueOf(reflect.MakeMap(c.goType))
-}
-
-func (c *mapConverter) Zero() pref.Value {
- return c.PBValueOf(reflect.Zero(c.goType))
-}
-
-type mapReflect struct {
- v reflect.Value // map[K]V
- keyConv Converter
- valConv Converter
-}
-
-func (ms *mapReflect) Len() int {
- return ms.v.Len()
-}
-func (ms *mapReflect) Has(k pref.MapKey) bool {
- rk := ms.keyConv.GoValueOf(k.Value())
- rv := ms.v.MapIndex(rk)
- return rv.IsValid()
-}
-func (ms *mapReflect) Get(k pref.MapKey) pref.Value {
- rk := ms.keyConv.GoValueOf(k.Value())
- rv := ms.v.MapIndex(rk)
- if !rv.IsValid() {
- return pref.Value{}
- }
- return ms.valConv.PBValueOf(rv)
-}
-func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) {
- rk := ms.keyConv.GoValueOf(k.Value())
- rv := ms.valConv.GoValueOf(v)
- ms.v.SetMapIndex(rk, rv)
-}
-func (ms *mapReflect) Clear(k pref.MapKey) {
- rk := ms.keyConv.GoValueOf(k.Value())
- ms.v.SetMapIndex(rk, reflect.Value{})
-}
-func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
- if _, ok := ms.valConv.(*messageConverter); !ok {
- panic("invalid Mutable on map with non-message value type")
- }
- v := ms.Get(k)
- if !v.IsValid() {
- v = ms.NewValue()
- ms.Set(k, v)
- }
- return v
-}
-func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
- iter := mapRange(ms.v)
- for iter.Next() {
- k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
- v := ms.valConv.PBValueOf(iter.Value())
- if !f(k, v) {
- return
- }
- }
-}
-func (ms *mapReflect) NewValue() pref.Value {
- return ms.valConv.New()
-}
-func (ms *mapReflect) IsValid() bool {
- return !ms.v.IsNil()
-}
-func (ms *mapReflect) protoUnwrap() interface{} {
- return ms.v.Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/decode.go b/vendor/google.golang.org/protobuf/internal/impl/decode.go
deleted file mode 100644
index 85ba1d3..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/decode.go
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "math/bits"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
- "google.golang.org/protobuf/runtime/protoiface"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type unmarshalOptions struct {
- flags protoiface.UnmarshalInputFlags
- resolver interface {
- FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
- FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
- }
-}
-
-func (o unmarshalOptions) Options() proto.UnmarshalOptions {
- return proto.UnmarshalOptions{
- Merge: true,
- AllowPartial: true,
- DiscardUnknown: o.DiscardUnknown(),
- Resolver: o.resolver,
- }
-}
-
-func (o unmarshalOptions) DiscardUnknown() bool { return o.flags&piface.UnmarshalDiscardUnknown != 0 }
-
-func (o unmarshalOptions) IsDefault() bool {
- return o.flags == 0 && o.resolver == preg.GlobalTypes
-}
-
-var lazyUnmarshalOptions = unmarshalOptions{
- resolver: preg.GlobalTypes,
-}
-
-type unmarshalOutput struct {
- n int // number of bytes consumed
- initialized bool
-}
-
-// unmarshal is protoreflect.Methods.Unmarshal.
-func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
- var p pointer
- if ms, ok := in.Message.(*messageState); ok {
- p = ms.pointer()
- } else {
- p = in.Message.(*messageReflectWrapper).pointer()
- }
- out, err := mi.unmarshalPointer(in.Buf, p, 0, unmarshalOptions{
- flags: in.Flags,
- resolver: in.Resolver,
- })
- var flags piface.UnmarshalOutputFlags
- if out.initialized {
- flags |= piface.UnmarshalInitialized
- }
- return piface.UnmarshalOutput{
- Flags: flags,
- }, err
-}
-
-// errUnknown is returned during unmarshaling to indicate a parse error that
-// should result in a field being placed in the unknown fields section (for example,
-// when the wire type doesn't match) as opposed to the entire unmarshal operation
-// failing (for example, when a field extends past the available input).
-//
-// This is a sentinel error which should never be visible to the user.
-var errUnknown = errors.New("unknown")
-
-func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
- mi.init()
- if flags.ProtoLegacy && mi.isMessageSet {
- return unmarshalMessageSet(mi, b, p, opts)
- }
- initialized := true
- var requiredMask uint64
- var exts *map[int32]ExtensionField
- start := len(b)
- for len(b) > 0 {
- // Parse the tag (field number and wire type).
- var tag uint64
- if b[0] < 0x80 {
- tag = uint64(b[0])
- b = b[1:]
- } else if len(b) >= 2 && b[1] < 128 {
- tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
- b = b[2:]
- } else {
- var n int
- tag, n = protowire.ConsumeVarint(b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- b = b[n:]
- }
- var num protowire.Number
- if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
- return out, errors.New("invalid field number")
- } else {
- num = protowire.Number(n)
- }
- wtyp := protowire.Type(tag & 7)
-
- if wtyp == protowire.EndGroupType {
- if num != groupTag {
- return out, errors.New("mismatching end group marker")
- }
- groupTag = 0
- break
- }
-
- var f *coderFieldInfo
- if int(num) < len(mi.denseCoderFields) {
- f = mi.denseCoderFields[num]
- } else {
- f = mi.coderFields[num]
- }
- var n int
- err := errUnknown
- switch {
- case f != nil:
- if f.funcs.unmarshal == nil {
- break
- }
- var o unmarshalOutput
- o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
- n = o.n
- if err != nil {
- break
- }
- requiredMask |= f.validation.requiredBit
- if f.funcs.isInit != nil && !o.initialized {
- initialized = false
- }
- default:
- // Possible extension.
- if exts == nil && mi.extensionOffset.IsValid() {
- exts = p.Apply(mi.extensionOffset).Extensions()
- if *exts == nil {
- *exts = make(map[int32]ExtensionField)
- }
- }
- if exts == nil {
- break
- }
- var o unmarshalOutput
- o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
- if err != nil {
- break
- }
- n = o.n
- if !o.initialized {
- initialized = false
- }
- }
- if err != nil {
- if err != errUnknown {
- return out, err
- }
- n = protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return out, protowire.ParseError(n)
- }
- if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
- u := p.Apply(mi.unknownOffset).Bytes()
- *u = protowire.AppendTag(*u, num, wtyp)
- *u = append(*u, b[:n]...)
- }
- }
- b = b[n:]
- }
- if groupTag != 0 {
- return out, errors.New("missing end group marker")
- }
- if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
- initialized = false
- }
- if initialized {
- out.initialized = true
- }
- out.n = start - len(b)
- return out, nil
-}
-
-func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
- x := exts[int32(num)]
- xt := x.Type()
- if xt == nil {
- var err error
- xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
- if err != nil {
- if err == preg.NotFound {
- return out, errUnknown
- }
- return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)
- }
- }
- xi := getExtensionFieldInfo(xt)
- if xi.funcs.unmarshal == nil {
- return out, errUnknown
- }
- if flags.LazyUnmarshalExtensions {
- if opts.IsDefault() && x.canLazy(xt) {
- out, valid := skipExtension(b, xi, num, wtyp, opts)
- switch valid {
- case ValidationValid:
- if out.initialized {
- x.appendLazyBytes(xt, xi, num, wtyp, b[:out.n])
- exts[int32(num)] = x
- return out, nil
- }
- case ValidationInvalid:
- return out, errors.New("invalid wire format")
- case ValidationUnknown:
- }
- }
- }
- ival := x.Value()
- if !ival.IsValid() && xi.unmarshalNeedsValue {
- // Create a new message, list, or map value to fill in.
- // For enums, create a prototype value to let the unmarshal func know the
- // concrete type.
- ival = xt.New()
- }
- v, out, err := xi.funcs.unmarshal(b, ival, num, wtyp, opts)
- if err != nil {
- return out, err
- }
- if xi.funcs.isInit == nil {
- out.initialized = true
- }
- x.Set(xt, v)
- exts[int32(num)] = x
- return out, nil
-}
-
-func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
- if xi.validation.mi == nil {
- return out, ValidationUnknown
- }
- xi.validation.mi.init()
- switch xi.validation.typ {
- case validationTypeMessage:
- if wtyp != protowire.BytesType {
- return out, ValidationUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return out, ValidationUnknown
- }
- out, st := xi.validation.mi.validate(v, 0, opts)
- out.n = n
- return out, st
- case validationTypeGroup:
- if wtyp != protowire.StartGroupType {
- return out, ValidationUnknown
- }
- out, st := xi.validation.mi.validate(b, num, opts)
- return out, st
- default:
- return out, ValidationUnknown
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/encode.go b/vendor/google.golang.org/protobuf/internal/impl/encode.go
deleted file mode 100644
index 8c8a794..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/encode.go
+++ /dev/null
@@ -1,199 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "math"
- "sort"
- "sync/atomic"
-
- "google.golang.org/protobuf/internal/flags"
- proto "google.golang.org/protobuf/proto"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type marshalOptions struct {
- flags piface.MarshalInputFlags
-}
-
-func (o marshalOptions) Options() proto.MarshalOptions {
- return proto.MarshalOptions{
- AllowPartial: true,
- Deterministic: o.Deterministic(),
- UseCachedSize: o.UseCachedSize(),
- }
-}
-
-func (o marshalOptions) Deterministic() bool { return o.flags&piface.MarshalDeterministic != 0 }
-func (o marshalOptions) UseCachedSize() bool { return o.flags&piface.MarshalUseCachedSize != 0 }
-
-// size is protoreflect.Methods.Size.
-func (mi *MessageInfo) size(in piface.SizeInput) piface.SizeOutput {
- var p pointer
- if ms, ok := in.Message.(*messageState); ok {
- p = ms.pointer()
- } else {
- p = in.Message.(*messageReflectWrapper).pointer()
- }
- size := mi.sizePointer(p, marshalOptions{
- flags: in.Flags,
- })
- return piface.SizeOutput{Size: size}
-}
-
-func (mi *MessageInfo) sizePointer(p pointer, opts marshalOptions) (size int) {
- mi.init()
- if p.IsNil() {
- return 0
- }
- if opts.UseCachedSize() && mi.sizecacheOffset.IsValid() {
- if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size >= 0 {
- return int(size)
- }
- }
- return mi.sizePointerSlow(p, opts)
-}
-
-func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int) {
- if flags.ProtoLegacy && mi.isMessageSet {
- size = sizeMessageSet(mi, p, opts)
- if mi.sizecacheOffset.IsValid() {
- atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
- }
- return size
- }
- if mi.extensionOffset.IsValid() {
- e := p.Apply(mi.extensionOffset).Extensions()
- size += mi.sizeExtensions(e, opts)
- }
- for _, f := range mi.orderedCoderFields {
- if f.funcs.size == nil {
- continue
- }
- fptr := p.Apply(f.offset)
- if f.isPointer && fptr.Elem().IsNil() {
- continue
- }
- size += f.funcs.size(fptr, f, opts)
- }
- if mi.unknownOffset.IsValid() {
- u := *p.Apply(mi.unknownOffset).Bytes()
- size += len(u)
- }
- if mi.sizecacheOffset.IsValid() {
- if size > math.MaxInt32 {
- // The size is too large for the int32 sizecache field.
- // We will need to recompute the size when encoding;
- // unfortunately expensive, but better than invalid output.
- atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), -1)
- } else {
- atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
- }
- }
- return size
-}
-
-// marshal is protoreflect.Methods.Marshal.
-func (mi *MessageInfo) marshal(in piface.MarshalInput) (out piface.MarshalOutput, err error) {
- var p pointer
- if ms, ok := in.Message.(*messageState); ok {
- p = ms.pointer()
- } else {
- p = in.Message.(*messageReflectWrapper).pointer()
- }
- b, err := mi.marshalAppendPointer(in.Buf, p, marshalOptions{
- flags: in.Flags,
- })
- return piface.MarshalOutput{Buf: b}, err
-}
-
-func (mi *MessageInfo) marshalAppendPointer(b []byte, p pointer, opts marshalOptions) ([]byte, error) {
- mi.init()
- if p.IsNil() {
- return b, nil
- }
- if flags.ProtoLegacy && mi.isMessageSet {
- return marshalMessageSet(mi, b, p, opts)
- }
- var err error
- // The old marshaler encodes extensions at beginning.
- if mi.extensionOffset.IsValid() {
- e := p.Apply(mi.extensionOffset).Extensions()
- // TODO: Special handling for MessageSet?
- b, err = mi.appendExtensions(b, e, opts)
- if err != nil {
- return b, err
- }
- }
- for _, f := range mi.orderedCoderFields {
- if f.funcs.marshal == nil {
- continue
- }
- fptr := p.Apply(f.offset)
- if f.isPointer && fptr.Elem().IsNil() {
- continue
- }
- b, err = f.funcs.marshal(b, fptr, f, opts)
- if err != nil {
- return b, err
- }
- }
- if mi.unknownOffset.IsValid() && !mi.isMessageSet {
- u := *p.Apply(mi.unknownOffset).Bytes()
- b = append(b, u...)
- }
- return b, nil
-}
-
-func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marshalOptions) (n int) {
- if ext == nil {
- return 0
- }
- for _, x := range *ext {
- xi := getExtensionFieldInfo(x.Type())
- if xi.funcs.size == nil {
- continue
- }
- n += xi.funcs.size(x.Value(), xi.tagsize, opts)
- }
- return n
-}
-
-func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, opts marshalOptions) ([]byte, error) {
- if ext == nil {
- return b, nil
- }
-
- switch len(*ext) {
- case 0:
- return b, nil
- case 1:
- // Fast-path for one extension: Don't bother sorting the keys.
- var err error
- for _, x := range *ext {
- xi := getExtensionFieldInfo(x.Type())
- b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
- }
- return b, err
- default:
- // Sort the keys to provide a deterministic encoding.
- // Not sure this is required, but the old code does it.
- keys := make([]int, 0, len(*ext))
- for k := range *ext {
- keys = append(keys, int(k))
- }
- sort.Ints(keys)
- var err error
- for _, k := range keys {
- x := (*ext)[int32(k)]
- xi := getExtensionFieldInfo(x.Type())
- b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
- if err != nil {
- return b, err
- }
- }
- return b, nil
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/enum.go b/vendor/google.golang.org/protobuf/internal/impl/enum.go
deleted file mode 100644
index 8c1eab4..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/enum.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "reflect"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type EnumInfo struct {
- GoReflectType reflect.Type // int32 kind
- Desc pref.EnumDescriptor
-}
-
-func (t *EnumInfo) New(n pref.EnumNumber) pref.Enum {
- return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum)
-}
-func (t *EnumInfo) Descriptor() pref.EnumDescriptor { return t.Desc }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/extension.go b/vendor/google.golang.org/protobuf/internal/impl/extension.go
deleted file mode 100644
index e904fd9..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/extension.go
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "reflect"
- "sync"
- "sync/atomic"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// ExtensionInfo implements ExtensionType.
-//
-// This type contains a number of exported fields for legacy compatibility.
-// The only non-deprecated use of this type is through the methods of the
-// ExtensionType interface.
-type ExtensionInfo struct {
- // An ExtensionInfo may exist in several stages of initialization.
- //
- // extensionInfoUninitialized: Some or all of the legacy exported
- // fields may be set, but none of the unexported fields have been
- // initialized. This is the starting state for an ExtensionInfo
- // in legacy generated code.
- //
- // extensionInfoDescInit: The desc field is set, but other unexported fields
- // may not be initialized. Legacy exported fields may or may not be set.
- // This is the starting state for an ExtensionInfo in newly generated code.
- //
- // extensionInfoFullInit: The ExtensionInfo is fully initialized.
- // This state is only entered after lazy initialization is complete.
- init uint32
- mu sync.Mutex
-
- goType reflect.Type
- desc extensionTypeDescriptor
- conv Converter
- info *extensionFieldInfo // for fast-path method implementations
-
- // ExtendedType is a typed nil-pointer to the parent message type that
- // is being extended. It is possible for this to be unpopulated in v2
- // since the message may no longer implement the MessageV1 interface.
- //
- // Deprecated: Use the ExtendedType method instead.
- ExtendedType piface.MessageV1
-
- // ExtensionType is the zero value of the extension type.
- //
- // For historical reasons, reflect.TypeOf(ExtensionType) and the
- // type returned by InterfaceOf may not be identical.
- //
- // Deprecated: Use InterfaceOf(xt.Zero()) instead.
- ExtensionType interface{}
-
- // Field is the field number of the extension.
- //
- // Deprecated: Use the Descriptor().Number method instead.
- Field int32
-
- // Name is the fully qualified name of extension.
- //
- // Deprecated: Use the Descriptor().FullName method instead.
- Name string
-
- // Tag is the protobuf struct tag used in the v1 API.
- //
- // Deprecated: Do not use.
- Tag string
-
- // Filename is the proto filename in which the extension is defined.
- //
- // Deprecated: Use Descriptor().ParentFile().Path() instead.
- Filename string
-}
-
-// Stages of initialization: See the ExtensionInfo.init field.
-const (
- extensionInfoUninitialized = 0
- extensionInfoDescInit = 1
- extensionInfoFullInit = 2
-)
-
-func InitExtensionInfo(xi *ExtensionInfo, xd pref.ExtensionDescriptor, goType reflect.Type) {
- xi.goType = goType
- xi.desc = extensionTypeDescriptor{xd, xi}
- xi.init = extensionInfoDescInit
-}
-
-func (xi *ExtensionInfo) New() pref.Value {
- return xi.lazyInit().New()
-}
-func (xi *ExtensionInfo) Zero() pref.Value {
- return xi.lazyInit().Zero()
-}
-func (xi *ExtensionInfo) ValueOf(v interface{}) pref.Value {
- return xi.lazyInit().PBValueOf(reflect.ValueOf(v))
-}
-func (xi *ExtensionInfo) InterfaceOf(v pref.Value) interface{} {
- return xi.lazyInit().GoValueOf(v).Interface()
-}
-func (xi *ExtensionInfo) IsValidValue(v pref.Value) bool {
- return xi.lazyInit().IsValidPB(v)
-}
-func (xi *ExtensionInfo) IsValidInterface(v interface{}) bool {
- return xi.lazyInit().IsValidGo(reflect.ValueOf(v))
-}
-func (xi *ExtensionInfo) TypeDescriptor() pref.ExtensionTypeDescriptor {
- if atomic.LoadUint32(&xi.init) < extensionInfoDescInit {
- xi.lazyInitSlow()
- }
- return &xi.desc
-}
-
-func (xi *ExtensionInfo) lazyInit() Converter {
- if atomic.LoadUint32(&xi.init) < extensionInfoFullInit {
- xi.lazyInitSlow()
- }
- return xi.conv
-}
-
-func (xi *ExtensionInfo) lazyInitSlow() {
- xi.mu.Lock()
- defer xi.mu.Unlock()
-
- if xi.init == extensionInfoFullInit {
- return
- }
- defer atomic.StoreUint32(&xi.init, extensionInfoFullInit)
-
- if xi.desc.ExtensionDescriptor == nil {
- xi.initFromLegacy()
- }
- if !xi.desc.ExtensionDescriptor.IsPlaceholder() {
- if xi.ExtensionType == nil {
- xi.initToLegacy()
- }
- xi.conv = NewConverter(xi.goType, xi.desc.ExtensionDescriptor)
- xi.info = makeExtensionFieldInfo(xi.desc.ExtensionDescriptor)
- xi.info.validation = newValidationInfo(xi.desc.ExtensionDescriptor, xi.goType)
- }
-}
-
-type extensionTypeDescriptor struct {
- pref.ExtensionDescriptor
- xi *ExtensionInfo
-}
-
-func (xtd *extensionTypeDescriptor) Type() pref.ExtensionType {
- return xtd.xi
-}
-func (xtd *extensionTypeDescriptor) Descriptor() pref.ExtensionDescriptor {
- return xtd.ExtensionDescriptor
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go
deleted file mode 100644
index f7d7ffb..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go
+++ /dev/null
@@ -1,219 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "strings"
- "sync"
-
- "google.golang.org/protobuf/internal/filedesc"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/reflect/protoreflect"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// legacyEnumName returns the name of enums used in legacy code.
-// It is neither the protobuf full name nor the qualified Go name,
-// but rather an odd hybrid of both.
-func legacyEnumName(ed pref.EnumDescriptor) string {
- var protoPkg string
- enumName := string(ed.FullName())
- if fd := ed.ParentFile(); fd != nil {
- protoPkg = string(fd.Package())
- enumName = strings.TrimPrefix(enumName, protoPkg+".")
- }
- if protoPkg == "" {
- return strs.GoCamelCase(enumName)
- }
- return protoPkg + "." + strs.GoCamelCase(enumName)
-}
-
-// legacyWrapEnum wraps v as a protoreflect.Enum,
-// where v must be a int32 kind and not implement the v2 API already.
-func legacyWrapEnum(v reflect.Value) pref.Enum {
- et := legacyLoadEnumType(v.Type())
- return et.New(pref.EnumNumber(v.Int()))
-}
-
-var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
-
-// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
-// where t must be an int32 kind and not implement the v2 API already.
-func legacyLoadEnumType(t reflect.Type) pref.EnumType {
- // Fast-path: check if a EnumType is cached for this concrete type.
- if et, ok := legacyEnumTypeCache.Load(t); ok {
- return et.(pref.EnumType)
- }
-
- // Slow-path: derive enum descriptor and initialize EnumType.
- var et pref.EnumType
- ed := LegacyLoadEnumDesc(t)
- et = &legacyEnumType{
- desc: ed,
- goType: t,
- }
- if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
- return et.(pref.EnumType)
- }
- return et
-}
-
-type legacyEnumType struct {
- desc pref.EnumDescriptor
- goType reflect.Type
- m sync.Map // map[protoreflect.EnumNumber]proto.Enum
-}
-
-func (t *legacyEnumType) New(n pref.EnumNumber) pref.Enum {
- if e, ok := t.m.Load(n); ok {
- return e.(pref.Enum)
- }
- e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
- t.m.Store(n, e)
- return e
-}
-func (t *legacyEnumType) Descriptor() pref.EnumDescriptor {
- return t.desc
-}
-
-type legacyEnumWrapper struct {
- num pref.EnumNumber
- pbTyp pref.EnumType
- goTyp reflect.Type
-}
-
-func (e *legacyEnumWrapper) Descriptor() pref.EnumDescriptor {
- return e.pbTyp.Descriptor()
-}
-func (e *legacyEnumWrapper) Type() pref.EnumType {
- return e.pbTyp
-}
-func (e *legacyEnumWrapper) Number() pref.EnumNumber {
- return e.num
-}
-func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
- return e
-}
-func (e *legacyEnumWrapper) protoUnwrap() interface{} {
- v := reflect.New(e.goTyp).Elem()
- v.SetInt(int64(e.num))
- return v.Interface()
-}
-
-var (
- _ pref.Enum = (*legacyEnumWrapper)(nil)
- _ unwrapper = (*legacyEnumWrapper)(nil)
-)
-
-var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
-
-// LegacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
-// which must be an int32 kind and not implement the v2 API already.
-//
-// This is exported for testing purposes.
-func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
- // Fast-path: check if an EnumDescriptor is cached for this concrete type.
- if ed, ok := legacyEnumDescCache.Load(t); ok {
- return ed.(pref.EnumDescriptor)
- }
-
- // Slow-path: initialize EnumDescriptor from the raw descriptor.
- ev := reflect.Zero(t).Interface()
- if _, ok := ev.(pref.Enum); ok {
- panic(fmt.Sprintf("%v already implements proto.Enum", t))
- }
- edV1, ok := ev.(enumV1)
- if !ok {
- return aberrantLoadEnumDesc(t)
- }
- b, idxs := edV1.EnumDescriptor()
-
- var ed pref.EnumDescriptor
- if len(idxs) == 1 {
- ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
- } else {
- md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
- for _, i := range idxs[1 : len(idxs)-1] {
- md = md.Messages().Get(i)
- }
- ed = md.Enums().Get(idxs[len(idxs)-1])
- }
- if ed, ok := legacyEnumDescCache.LoadOrStore(t, ed); ok {
- return ed.(protoreflect.EnumDescriptor)
- }
- return ed
-}
-
-var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
-
-// aberrantLoadEnumDesc returns an EnumDescriptor derived from the Go type,
-// which must not implement protoreflect.Enum or enumV1.
-//
-// If the type does not implement enumV1, then there is no reliable
-// way to derive the original protobuf type information.
-// We are unable to use the global enum registry since it is
-// unfortunately keyed by the protobuf full name, which we also do not know.
-// Thus, this produces some bogus enum descriptor based on the Go type name.
-func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
- // Fast-path: check if an EnumDescriptor is cached for this concrete type.
- if ed, ok := aberrantEnumDescCache.Load(t); ok {
- return ed.(pref.EnumDescriptor)
- }
-
- // Slow-path: construct a bogus, but unique EnumDescriptor.
- ed := &filedesc.Enum{L2: new(filedesc.EnumL2)}
- ed.L0.FullName = AberrantDeriveFullName(t) // e.g., github_com.user.repo.MyEnum
- ed.L0.ParentFile = filedesc.SurrogateProto3
- ed.L2.Values.List = append(ed.L2.Values.List, filedesc.EnumValue{})
-
- // TODO: Use the presence of a UnmarshalJSON method to determine proto2?
-
- vd := &ed.L2.Values.List[0]
- vd.L0.FullName = ed.L0.FullName + "_UNKNOWN" // e.g., github_com.user.repo.MyEnum_UNKNOWN
- vd.L0.ParentFile = ed.L0.ParentFile
- vd.L0.Parent = ed
-
- // TODO: We could use the String method to obtain some enum value names by
- // starting at 0 and print the enum until it produces invalid identifiers.
- // An exhaustive query is clearly impractical, but can be best-effort.
-
- if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
- return ed.(pref.EnumDescriptor)
- }
- return ed
-}
-
-// AberrantDeriveFullName derives a fully qualified protobuf name for the given Go type
-// The provided name is not guaranteed to be stable nor universally unique.
-// It should be sufficiently unique within a program.
-//
-// This is exported for testing purposes.
-func AberrantDeriveFullName(t reflect.Type) pref.FullName {
- sanitize := func(r rune) rune {
- switch {
- case r == '/':
- return '.'
- case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
- return r
- default:
- return '_'
- }
- }
- prefix := strings.Map(sanitize, t.PkgPath())
- suffix := strings.Map(sanitize, t.Name())
- if suffix == "" {
- suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
- }
-
- ss := append(strings.Split(prefix, "."), suffix)
- for i, s := range ss {
- if s == "" || ('0' <= s[0] && s[0] <= '9') {
- ss[i] = "x" + s
- }
- }
- return pref.FullName(strings.Join(ss, "."))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go
deleted file mode 100644
index c3d741c..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "encoding/binary"
- "encoding/json"
- "hash/crc32"
- "math"
- "reflect"
-
- "google.golang.org/protobuf/internal/errors"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// These functions exist to support exported APIs in generated protobufs.
-// While these are deprecated, they cannot be removed for compatibility reasons.
-
-// LegacyEnumName returns the name of enums used in legacy code.
-func (Export) LegacyEnumName(ed pref.EnumDescriptor) string {
- return legacyEnumName(ed)
-}
-
-// LegacyMessageTypeOf returns the protoreflect.MessageType for m,
-// with name used as the message name if necessary.
-func (Export) LegacyMessageTypeOf(m piface.MessageV1, name pref.FullName) pref.MessageType {
- if mv := (Export{}).protoMessageV2Of(m); mv != nil {
- return mv.ProtoReflect().Type()
- }
- return legacyLoadMessageInfo(reflect.TypeOf(m), name)
-}
-
-// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
-// The input can either be a string representing the enum value by name,
-// or a number representing the enum number itself.
-func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumber, error) {
- if b[0] == '"' {
- var name pref.Name
- if err := json.Unmarshal(b, &name); err != nil {
- return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
- }
- ev := ed.Values().ByName(name)
- if ev == nil {
- return 0, errors.New("invalid value for enum %v: %s", ed.FullName(), name)
- }
- return ev.Number(), nil
- } else {
- var num pref.EnumNumber
- if err := json.Unmarshal(b, &num); err != nil {
- return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
- }
- return num, nil
- }
-}
-
-// CompressGZIP compresses the input as a GZIP-encoded file.
-// The current implementation does no compression.
-func (Export) CompressGZIP(in []byte) (out []byte) {
- // RFC 1952, section 2.3.1.
- var gzipHeader = [10]byte{0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}
-
- // RFC 1951, section 3.2.4.
- var blockHeader [5]byte
- const maxBlockSize = math.MaxUint16
- numBlocks := 1 + len(in)/maxBlockSize
-
- // RFC 1952, section 2.3.1.
- var gzipFooter [8]byte
- binary.LittleEndian.PutUint32(gzipFooter[0:4], crc32.ChecksumIEEE(in))
- binary.LittleEndian.PutUint32(gzipFooter[4:8], uint32(len(in)))
-
- // Encode the input without compression using raw DEFLATE blocks.
- out = make([]byte, 0, len(gzipHeader)+len(blockHeader)*numBlocks+len(in)+len(gzipFooter))
- out = append(out, gzipHeader[:]...)
- for blockHeader[0] == 0 {
- blockSize := maxBlockSize
- if blockSize > len(in) {
- blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
- blockSize = len(in)
- }
- binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize)^0x0000)
- binary.LittleEndian.PutUint16(blockHeader[3:5], uint16(blockSize)^0xffff)
- out = append(out, blockHeader[:]...)
- out = append(out, in[:blockSize]...)
- in = in[blockSize:]
- }
- out = append(out, gzipFooter[:]...)
- return out
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
deleted file mode 100644
index 61757ce..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "reflect"
-
- "google.golang.org/protobuf/internal/descopts"
- "google.golang.org/protobuf/internal/encoding/messageset"
- ptag "google.golang.org/protobuf/internal/encoding/tag"
- "google.golang.org/protobuf/internal/filedesc"
- "google.golang.org/protobuf/internal/pragma"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-func (xi *ExtensionInfo) initToLegacy() {
- xd := xi.desc
- var parent piface.MessageV1
- messageName := xd.ContainingMessage().FullName()
- if mt, _ := preg.GlobalTypes.FindMessageByName(messageName); mt != nil {
- // Create a new parent message and unwrap it if possible.
- mv := mt.New().Interface()
- t := reflect.TypeOf(mv)
- if mv, ok := mv.(unwrapper); ok {
- t = reflect.TypeOf(mv.protoUnwrap())
- }
-
- // Check whether the message implements the legacy v1 Message interface.
- mz := reflect.Zero(t).Interface()
- if mz, ok := mz.(piface.MessageV1); ok {
- parent = mz
- }
- }
-
- // Determine the v1 extension type, which is unfortunately not the same as
- // the v2 ExtensionType.GoType.
- extType := xi.goType
- switch extType.Kind() {
- case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
- extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields
- }
-
- // Reconstruct the legacy enum full name.
- var enumName string
- if xd.Kind() == pref.EnumKind {
- enumName = legacyEnumName(xd.Enum())
- }
-
- // Derive the proto file that the extension was declared within.
- var filename string
- if fd := xd.ParentFile(); fd != nil {
- filename = fd.Path()
- }
-
- // For MessageSet extensions, the name used is the parent message.
- name := xd.FullName()
- if messageset.IsMessageSetExtension(xd) {
- name = name.Parent()
- }
-
- xi.ExtendedType = parent
- xi.ExtensionType = reflect.Zero(extType).Interface()
- xi.Field = int32(xd.Number())
- xi.Name = string(name)
- xi.Tag = ptag.Marshal(xd, enumName)
- xi.Filename = filename
-}
-
-// initFromLegacy initializes an ExtensionInfo from
-// the contents of the deprecated exported fields of the type.
-func (xi *ExtensionInfo) initFromLegacy() {
- // The v1 API returns "type incomplete" descriptors where only the
- // field number is specified. In such a case, use a placeholder.
- if xi.ExtendedType == nil || xi.ExtensionType == nil {
- xd := placeholderExtension{
- name: pref.FullName(xi.Name),
- number: pref.FieldNumber(xi.Field),
- }
- xi.desc = extensionTypeDescriptor{xd, xi}
- return
- }
-
- // Resolve enum or message dependencies.
- var ed pref.EnumDescriptor
- var md pref.MessageDescriptor
- t := reflect.TypeOf(xi.ExtensionType)
- isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
- isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
- if isOptional || isRepeated {
- t = t.Elem()
- }
- switch v := reflect.Zero(t).Interface().(type) {
- case pref.Enum:
- ed = v.Descriptor()
- case enumV1:
- ed = LegacyLoadEnumDesc(t)
- case pref.ProtoMessage:
- md = v.ProtoReflect().Descriptor()
- case messageV1:
- md = LegacyLoadMessageDesc(t)
- }
-
- // Derive basic field information from the struct tag.
- var evs pref.EnumValueDescriptors
- if ed != nil {
- evs = ed.Values()
- }
- fd := ptag.Unmarshal(xi.Tag, t, evs).(*filedesc.Field)
-
- // Construct a v2 ExtensionType.
- xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)}
- xd.L0.ParentFile = filedesc.SurrogateProto2
- xd.L0.FullName = pref.FullName(xi.Name)
- xd.L1.Number = pref.FieldNumber(xi.Field)
- xd.L1.Cardinality = fd.L1.Cardinality
- xd.L1.Kind = fd.L1.Kind
- xd.L2.IsPacked = fd.L1.IsPacked
- xd.L2.Default = fd.L1.Default
- xd.L1.Extendee = Export{}.MessageDescriptorOf(xi.ExtendedType)
- xd.L2.Enum = ed
- xd.L2.Message = md
-
- // Derive real extension field name for MessageSets.
- if messageset.IsMessageSet(xd.L1.Extendee) && md.FullName() == xd.L0.FullName {
- xd.L0.FullName = xd.L0.FullName.Append(messageset.ExtensionName)
- }
-
- tt := reflect.TypeOf(xi.ExtensionType)
- if isOptional {
- tt = tt.Elem()
- }
- xi.goType = tt
- xi.desc = extensionTypeDescriptor{xd, xi}
-}
-
-type placeholderExtension struct {
- name pref.FullName
- number pref.FieldNumber
-}
-
-func (x placeholderExtension) ParentFile() pref.FileDescriptor { return nil }
-func (x placeholderExtension) Parent() pref.Descriptor { return nil }
-func (x placeholderExtension) Index() int { return 0 }
-func (x placeholderExtension) Syntax() pref.Syntax { return 0 }
-func (x placeholderExtension) Name() pref.Name { return x.name.Name() }
-func (x placeholderExtension) FullName() pref.FullName { return x.name }
-func (x placeholderExtension) IsPlaceholder() bool { return true }
-func (x placeholderExtension) Options() pref.ProtoMessage { return descopts.Field }
-func (x placeholderExtension) Number() pref.FieldNumber { return x.number }
-func (x placeholderExtension) Cardinality() pref.Cardinality { return 0 }
-func (x placeholderExtension) Kind() pref.Kind { return 0 }
-func (x placeholderExtension) HasJSONName() bool { return false }
-func (x placeholderExtension) JSONName() string { return "" }
-func (x placeholderExtension) HasPresence() bool { return false }
-func (x placeholderExtension) HasOptionalKeyword() bool { return false }
-func (x placeholderExtension) IsExtension() bool { return true }
-func (x placeholderExtension) IsWeak() bool { return false }
-func (x placeholderExtension) IsPacked() bool { return false }
-func (x placeholderExtension) IsList() bool { return false }
-func (x placeholderExtension) IsMap() bool { return false }
-func (x placeholderExtension) MapKey() pref.FieldDescriptor { return nil }
-func (x placeholderExtension) MapValue() pref.FieldDescriptor { return nil }
-func (x placeholderExtension) HasDefault() bool { return false }
-func (x placeholderExtension) Default() pref.Value { return pref.Value{} }
-func (x placeholderExtension) DefaultEnumValue() pref.EnumValueDescriptor { return nil }
-func (x placeholderExtension) ContainingOneof() pref.OneofDescriptor { return nil }
-func (x placeholderExtension) ContainingMessage() pref.MessageDescriptor { return nil }
-func (x placeholderExtension) Enum() pref.EnumDescriptor { return nil }
-func (x placeholderExtension) Message() pref.MessageDescriptor { return nil }
-func (x placeholderExtension) ProtoType(pref.FieldDescriptor) { return }
-func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement) { return }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go
deleted file mode 100644
index 9ab0910..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "bytes"
- "compress/gzip"
- "io/ioutil"
- "sync"
-
- "google.golang.org/protobuf/internal/filedesc"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Every enum and message type generated by protoc-gen-go since commit 2fc053c5
-// on February 25th, 2016 has had a method to get the raw descriptor.
-// Types that were not generated by protoc-gen-go or were generated prior
-// to that version are not supported.
-//
-// The []byte returned is the encoded form of a FileDescriptorProto message
-// compressed using GZIP. The []int is the path from the top-level file
-// to the specific message or enum declaration.
-type (
- enumV1 interface {
- EnumDescriptor() ([]byte, []int)
- }
- messageV1 interface {
- Descriptor() ([]byte, []int)
- }
-)
-
-var legacyFileDescCache sync.Map // map[*byte]protoreflect.FileDescriptor
-
-// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
-//
-// This assumes that b is immutable and that b does not refer to part of a
-// concatenated series of GZIP files (which would require shenanigans that
-// rely on the concatenation properties of both protobufs and GZIP).
-// File descriptors generated by protoc-gen-go do not rely on that property.
-func legacyLoadFileDesc(b []byte) protoreflect.FileDescriptor {
- // Fast-path: check whether we already have a cached file descriptor.
- if fd, ok := legacyFileDescCache.Load(&b[0]); ok {
- return fd.(protoreflect.FileDescriptor)
- }
-
- // Slow-path: decompress and unmarshal the file descriptor proto.
- zr, err := gzip.NewReader(bytes.NewReader(b))
- if err != nil {
- panic(err)
- }
- b2, err := ioutil.ReadAll(zr)
- if err != nil {
- panic(err)
- }
-
- fd := filedesc.Builder{
- RawDescriptor: b2,
- FileRegistry: resolverOnly{protoregistry.GlobalFiles}, // do not register back to global registry
- }.Build().File
- if fd, ok := legacyFileDescCache.LoadOrStore(&b[0], fd); ok {
- return fd.(protoreflect.FileDescriptor)
- }
- return fd
-}
-
-type resolverOnly struct {
- reg *protoregistry.Files
-}
-
-func (r resolverOnly) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
- return r.reg.FindFileByPath(path)
-}
-func (r resolverOnly) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
- return r.reg.FindDescriptorByName(name)
-}
-func (resolverOnly) RegisterFile(protoreflect.FileDescriptor) error {
- return nil
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go
deleted file mode 100644
index 06c68e1..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "strings"
- "sync"
-
- "google.golang.org/protobuf/internal/descopts"
- ptag "google.golang.org/protobuf/internal/encoding/tag"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/filedesc"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/reflect/protoreflect"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// legacyWrapMessage wraps v as a protoreflect.Message,
-// where v must be a *struct kind and not implement the v2 API already.
-func legacyWrapMessage(v reflect.Value) pref.Message {
- typ := v.Type()
- if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Struct {
- return aberrantMessage{v: v}
- }
- mt := legacyLoadMessageInfo(typ, "")
- return mt.MessageOf(v.Interface())
-}
-
-var legacyMessageTypeCache sync.Map // map[reflect.Type]*MessageInfo
-
-// legacyLoadMessageInfo dynamically loads a *MessageInfo for t,
-// where t must be a *struct kind and not implement the v2 API already.
-// The provided name is used if it cannot be determined from the message.
-func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
- // Fast-path: check if a MessageInfo is cached for this concrete type.
- if mt, ok := legacyMessageTypeCache.Load(t); ok {
- return mt.(*MessageInfo)
- }
-
- // Slow-path: derive message descriptor and initialize MessageInfo.
- mi := &MessageInfo{
- Desc: legacyLoadMessageDesc(t, name),
- GoReflectType: t,
- }
-
- v := reflect.Zero(t).Interface()
- if _, ok := v.(legacyMarshaler); ok {
- mi.methods.Marshal = legacyMarshal
-
- // We have no way to tell whether the type's Marshal method
- // supports deterministic serialization or not, but this
- // preserves the v1 implementation's behavior of always
- // calling Marshal methods when present.
- mi.methods.Flags |= piface.SupportMarshalDeterministic
- }
- if _, ok := v.(legacyUnmarshaler); ok {
- mi.methods.Unmarshal = legacyUnmarshal
- }
- if _, ok := v.(legacyMerger); ok {
- mi.methods.Merge = legacyMerge
- }
-
- if mi, ok := legacyMessageTypeCache.LoadOrStore(t, mi); ok {
- return mi.(*MessageInfo)
- }
- return mi
-}
-
-var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
-
-// LegacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
-// which must be a *struct kind and not implement the v2 API already.
-//
-// This is exported for testing purposes.
-func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
- return legacyLoadMessageDesc(t, "")
-}
-func legacyLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
- // Fast-path: check if a MessageDescriptor is cached for this concrete type.
- if mi, ok := legacyMessageDescCache.Load(t); ok {
- return mi.(pref.MessageDescriptor)
- }
-
- // Slow-path: initialize MessageDescriptor from the raw descriptor.
- mv := reflect.Zero(t).Interface()
- if _, ok := mv.(pref.ProtoMessage); ok {
- panic(fmt.Sprintf("%v already implements proto.Message", t))
- }
- mdV1, ok := mv.(messageV1)
- if !ok {
- return aberrantLoadMessageDesc(t, name)
- }
-
- // If this is a dynamic message type where there isn't a 1-1 mapping between
- // Go and protobuf types, calling the Descriptor method on the zero value of
- // the message type isn't likely to work. If it panics, swallow the panic and
- // continue as if the Descriptor method wasn't present.
- b, idxs := func() ([]byte, []int) {
- defer func() {
- recover()
- }()
- return mdV1.Descriptor()
- }()
- if b == nil {
- return aberrantLoadMessageDesc(t, name)
- }
-
- // If the Go type has no fields, then this might be a proto3 empty message
- // from before the size cache was added. If there are any fields, check to
- // see that at least one of them looks like something we generated.
- if nfield := t.Elem().NumField(); nfield > 0 {
- hasProtoField := false
- for i := 0; i < nfield; i++ {
- f := t.Elem().Field(i)
- if f.Tag.Get("protobuf") != "" || f.Tag.Get("protobuf_oneof") != "" || strings.HasPrefix(f.Name, "XXX_") {
- hasProtoField = true
- break
- }
- }
- if !hasProtoField {
- return aberrantLoadMessageDesc(t, name)
- }
- }
-
- md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
- for _, i := range idxs[1:] {
- md = md.Messages().Get(i)
- }
- if name != "" && md.FullName() != name {
- panic(fmt.Sprintf("mismatching message name: got %v, want %v", md.FullName(), name))
- }
- if md, ok := legacyMessageDescCache.LoadOrStore(t, md); ok {
- return md.(protoreflect.MessageDescriptor)
- }
- return md
-}
-
-var (
- aberrantMessageDescLock sync.Mutex
- aberrantMessageDescCache map[reflect.Type]protoreflect.MessageDescriptor
-)
-
-// aberrantLoadMessageDesc returns an MessageDescriptor derived from the Go type,
-// which must not implement protoreflect.ProtoMessage or messageV1.
-//
-// This is a best-effort derivation of the message descriptor using the protobuf
-// tags on the struct fields.
-func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
- aberrantMessageDescLock.Lock()
- defer aberrantMessageDescLock.Unlock()
- if aberrantMessageDescCache == nil {
- aberrantMessageDescCache = make(map[reflect.Type]protoreflect.MessageDescriptor)
- }
- return aberrantLoadMessageDescReentrant(t, name)
-}
-func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
- // Fast-path: check if an MessageDescriptor is cached for this concrete type.
- if md, ok := aberrantMessageDescCache[t]; ok {
- return md
- }
-
- // Slow-path: construct a descriptor from the Go struct type (best-effort).
- // Cache the MessageDescriptor early on so that we can resolve internal
- // cyclic references.
- md := &filedesc.Message{L2: new(filedesc.MessageL2)}
- md.L0.FullName = aberrantDeriveMessageName(t, name)
- md.L0.ParentFile = filedesc.SurrogateProto2
- aberrantMessageDescCache[t] = md
-
- if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
- return md
- }
-
- // Try to determine if the message is using proto3 by checking scalars.
- for i := 0; i < t.Elem().NumField(); i++ {
- f := t.Elem().Field(i)
- if tag := f.Tag.Get("protobuf"); tag != "" {
- switch f.Type.Kind() {
- case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
- md.L0.ParentFile = filedesc.SurrogateProto3
- }
- for _, s := range strings.Split(tag, ",") {
- if s == "proto3" {
- md.L0.ParentFile = filedesc.SurrogateProto3
- }
- }
- }
- }
-
- // Obtain a list of oneof wrapper types.
- var oneofWrappers []reflect.Type
- for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
- if fn, ok := t.MethodByName(method); ok {
- for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
- if vs, ok := v.Interface().([]interface{}); ok {
- for _, v := range vs {
- oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
- }
- }
- }
- }
- }
-
- // Obtain a list of the extension ranges.
- if fn, ok := t.MethodByName("ExtensionRangeArray"); ok {
- vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
- for i := 0; i < vs.Len(); i++ {
- v := vs.Index(i)
- md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]pref.FieldNumber{
- pref.FieldNumber(v.FieldByName("Start").Int()),
- pref.FieldNumber(v.FieldByName("End").Int() + 1),
- })
- md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil)
- }
- }
-
- // Derive the message fields by inspecting the struct fields.
- for i := 0; i < t.Elem().NumField(); i++ {
- f := t.Elem().Field(i)
- if tag := f.Tag.Get("protobuf"); tag != "" {
- tagKey := f.Tag.Get("protobuf_key")
- tagVal := f.Tag.Get("protobuf_val")
- aberrantAppendField(md, f.Type, tag, tagKey, tagVal)
- }
- if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
- n := len(md.L2.Oneofs.List)
- md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{})
- od := &md.L2.Oneofs.List[n]
- od.L0.FullName = md.FullName().Append(pref.Name(tag))
- od.L0.ParentFile = md.L0.ParentFile
- od.L0.Parent = md
- od.L0.Index = n
-
- for _, t := range oneofWrappers {
- if t.Implements(f.Type) {
- f := t.Elem().Field(0)
- if tag := f.Tag.Get("protobuf"); tag != "" {
- aberrantAppendField(md, f.Type, tag, "", "")
- fd := &md.L2.Fields.List[len(md.L2.Fields.List)-1]
- fd.L1.ContainingOneof = od
- od.L1.Fields.List = append(od.L1.Fields.List, fd)
- }
- }
- }
- }
- }
-
- return md
-}
-
-func aberrantDeriveMessageName(t reflect.Type, name pref.FullName) pref.FullName {
- if name.IsValid() {
- return name
- }
- func() {
- defer func() { recover() }() // swallow possible nil panics
- if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
- name = pref.FullName(m.XXX_MessageName())
- }
- }()
- if name.IsValid() {
- return name
- }
- if t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- return AberrantDeriveFullName(t)
-}
-
-func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
- t := goType
- isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
- isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
- if isOptional || isRepeated {
- t = t.Elem()
- }
- fd := ptag.Unmarshal(tag, t, placeholderEnumValues{}).(*filedesc.Field)
-
- // Append field descriptor to the message.
- n := len(md.L2.Fields.List)
- md.L2.Fields.List = append(md.L2.Fields.List, *fd)
- fd = &md.L2.Fields.List[n]
- fd.L0.FullName = md.FullName().Append(fd.Name())
- fd.L0.ParentFile = md.L0.ParentFile
- fd.L0.Parent = md
- fd.L0.Index = n
-
- if fd.L1.IsWeak || fd.L1.HasPacked {
- fd.L1.Options = func() pref.ProtoMessage {
- opts := descopts.Field.ProtoReflect().New()
- if fd.L1.IsWeak {
- opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true))
- }
- if fd.L1.HasPacked {
- opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.IsPacked))
- }
- return opts.Interface()
- }
- }
-
- // Populate Enum and Message.
- if fd.Enum() == nil && fd.Kind() == pref.EnumKind {
- switch v := reflect.Zero(t).Interface().(type) {
- case pref.Enum:
- fd.L1.Enum = v.Descriptor()
- default:
- fd.L1.Enum = LegacyLoadEnumDesc(t)
- }
- }
- if fd.Message() == nil && (fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind) {
- switch v := reflect.Zero(t).Interface().(type) {
- case pref.ProtoMessage:
- fd.L1.Message = v.ProtoReflect().Descriptor()
- case messageV1:
- fd.L1.Message = LegacyLoadMessageDesc(t)
- default:
- if t.Kind() == reflect.Map {
- n := len(md.L1.Messages.List)
- md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)})
- md2 := &md.L1.Messages.List[n]
- md2.L0.FullName = md.FullName().Append(pref.Name(strs.MapEntryName(string(fd.Name()))))
- md2.L0.ParentFile = md.L0.ParentFile
- md2.L0.Parent = md
- md2.L0.Index = n
-
- md2.L1.IsMapEntry = true
- md2.L2.Options = func() pref.ProtoMessage {
- opts := descopts.Message.ProtoReflect().New()
- opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
- return opts.Interface()
- }
-
- aberrantAppendField(md2, t.Key(), tagKey, "", "")
- aberrantAppendField(md2, t.Elem(), tagVal, "", "")
-
- fd.L1.Message = md2
- break
- }
- fd.L1.Message = aberrantLoadMessageDescReentrant(t, "")
- }
- }
-}
-
-type placeholderEnumValues struct {
- protoreflect.EnumValueDescriptors
-}
-
-func (placeholderEnumValues) ByNumber(n pref.EnumNumber) pref.EnumValueDescriptor {
- return filedesc.PlaceholderEnumValue(pref.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
-}
-
-// legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder.
-type legacyMarshaler interface {
- Marshal() ([]byte, error)
-}
-
-// legacyUnmarshaler is the proto.Unmarshaler interface superseded by protoiface.Methoder.
-type legacyUnmarshaler interface {
- Unmarshal([]byte) error
-}
-
-// legacyMerger is the proto.Merger interface superseded by protoiface.Methoder.
-type legacyMerger interface {
- Merge(protoiface.MessageV1)
-}
-
-var legacyProtoMethods = &piface.Methods{
- Marshal: legacyMarshal,
- Unmarshal: legacyUnmarshal,
- Merge: legacyMerge,
-
- // We have no way to tell whether the type's Marshal method
- // supports deterministic serialization or not, but this
- // preserves the v1 implementation's behavior of always
- // calling Marshal methods when present.
- Flags: piface.SupportMarshalDeterministic,
-}
-
-func legacyMarshal(in piface.MarshalInput) (piface.MarshalOutput, error) {
- v := in.Message.(unwrapper).protoUnwrap()
- marshaler, ok := v.(legacyMarshaler)
- if !ok {
- return piface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
- }
- out, err := marshaler.Marshal()
- if in.Buf != nil {
- out = append(in.Buf, out...)
- }
- return piface.MarshalOutput{
- Buf: out,
- }, err
-}
-
-func legacyUnmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
- v := in.Message.(unwrapper).protoUnwrap()
- unmarshaler, ok := v.(legacyUnmarshaler)
- if !ok {
- return piface.UnmarshalOutput{}, errors.New("%T does not implement Marshal", v)
- }
- return piface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
-}
-
-func legacyMerge(in piface.MergeInput) piface.MergeOutput {
- dstv := in.Destination.(unwrapper).protoUnwrap()
- merger, ok := dstv.(legacyMerger)
- if !ok {
- return piface.MergeOutput{}
- }
- merger.Merge(Export{}.ProtoMessageV1Of(in.Source))
- return piface.MergeOutput{Flags: piface.MergeComplete}
-}
-
-// aberrantMessageType implements MessageType for all types other than pointer-to-struct.
-type aberrantMessageType struct {
- t reflect.Type
-}
-
-func (mt aberrantMessageType) New() pref.Message {
- return aberrantMessage{reflect.Zero(mt.t)}
-}
-func (mt aberrantMessageType) Zero() pref.Message {
- return aberrantMessage{reflect.Zero(mt.t)}
-}
-func (mt aberrantMessageType) GoType() reflect.Type {
- return mt.t
-}
-func (mt aberrantMessageType) Descriptor() pref.MessageDescriptor {
- return LegacyLoadMessageDesc(mt.t)
-}
-
-// aberrantMessage implements Message for all types other than pointer-to-struct.
-//
-// When the underlying type implements legacyMarshaler or legacyUnmarshaler,
-// the aberrant Message can be marshaled or unmarshaled. Otherwise, there is
-// not much that can be done with values of this type.
-type aberrantMessage struct {
- v reflect.Value
-}
-
-func (m aberrantMessage) ProtoReflect() pref.Message {
- return m
-}
-
-func (m aberrantMessage) Descriptor() pref.MessageDescriptor {
- return LegacyLoadMessageDesc(m.v.Type())
-}
-func (m aberrantMessage) Type() pref.MessageType {
- return aberrantMessageType{m.v.Type()}
-}
-func (m aberrantMessage) New() pref.Message {
- return aberrantMessage{reflect.Zero(m.v.Type())}
-}
-func (m aberrantMessage) Interface() pref.ProtoMessage {
- return m
-}
-func (m aberrantMessage) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
-}
-func (m aberrantMessage) Has(pref.FieldDescriptor) bool {
- panic("invalid field descriptor")
-}
-func (m aberrantMessage) Clear(pref.FieldDescriptor) {
- panic("invalid field descriptor")
-}
-func (m aberrantMessage) Get(pref.FieldDescriptor) pref.Value {
- panic("invalid field descriptor")
-}
-func (m aberrantMessage) Set(pref.FieldDescriptor, pref.Value) {
- panic("invalid field descriptor")
-}
-func (m aberrantMessage) Mutable(pref.FieldDescriptor) pref.Value {
- panic("invalid field descriptor")
-}
-func (m aberrantMessage) NewField(pref.FieldDescriptor) pref.Value {
- panic("invalid field descriptor")
-}
-func (m aberrantMessage) WhichOneof(pref.OneofDescriptor) pref.FieldDescriptor {
- panic("invalid oneof descriptor")
-}
-func (m aberrantMessage) GetUnknown() pref.RawFields {
- return nil
-}
-func (m aberrantMessage) SetUnknown(pref.RawFields) {
- // SetUnknown discards its input on messages which don't support unknown field storage.
-}
-func (m aberrantMessage) IsValid() bool {
- // An invalid message is a read-only, empty message. Since we don't know anything
- // about the alleged contents of this message, we can't say with confidence that
- // it is invalid in this sense. Therefore, report it as valid.
- return true
-}
-func (m aberrantMessage) ProtoMethods() *piface.Methods {
- return legacyProtoMethods
-}
-func (m aberrantMessage) protoUnwrap() interface{} {
- return m.v.Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/merge.go b/vendor/google.golang.org/protobuf/internal/impl/merge.go
deleted file mode 100644
index cdc4267..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/merge.go
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
-
- "google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type mergeOptions struct{}
-
-func (o mergeOptions) Merge(dst, src proto.Message) {
- proto.Merge(dst, src)
-}
-
-// merge is protoreflect.Methods.Merge.
-func (mi *MessageInfo) merge(in piface.MergeInput) piface.MergeOutput {
- dp, ok := mi.getPointer(in.Destination)
- if !ok {
- return piface.MergeOutput{}
- }
- sp, ok := mi.getPointer(in.Source)
- if !ok {
- return piface.MergeOutput{}
- }
- mi.mergePointer(dp, sp, mergeOptions{})
- return piface.MergeOutput{Flags: piface.MergeComplete}
-}
-
-func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
- mi.init()
- if dst.IsNil() {
- panic(fmt.Sprintf("invalid value: merging into nil message"))
- }
- if src.IsNil() {
- return
- }
- for _, f := range mi.orderedCoderFields {
- if f.funcs.merge == nil {
- continue
- }
- sfptr := src.Apply(f.offset)
- if f.isPointer && sfptr.Elem().IsNil() {
- continue
- }
- f.funcs.merge(dst.Apply(f.offset), sfptr, f, opts)
- }
- if mi.extensionOffset.IsValid() {
- sext := src.Apply(mi.extensionOffset).Extensions()
- dext := dst.Apply(mi.extensionOffset).Extensions()
- if *dext == nil {
- *dext = make(map[int32]ExtensionField)
- }
- for num, sx := range *sext {
- xt := sx.Type()
- xi := getExtensionFieldInfo(xt)
- if xi.funcs.merge == nil {
- continue
- }
- dx := (*dext)[num]
- var dv pref.Value
- if dx.Type() == sx.Type() {
- dv = dx.Value()
- }
- if !dv.IsValid() && xi.unmarshalNeedsValue {
- dv = xt.New()
- }
- dv = xi.funcs.merge(dv, sx.Value(), opts)
- dx.Set(sx.Type(), dv)
- (*dext)[num] = dx
- }
- }
- if mi.unknownOffset.IsValid() {
- du := dst.Apply(mi.unknownOffset).Bytes()
- su := src.Apply(mi.unknownOffset).Bytes()
- if len(*su) > 0 {
- *du = append(*du, *su...)
- }
- }
-}
-
-func mergeScalarValue(dst, src pref.Value, opts mergeOptions) pref.Value {
- return src
-}
-
-func mergeBytesValue(dst, src pref.Value, opts mergeOptions) pref.Value {
- return pref.ValueOfBytes(append(emptyBuf[:], src.Bytes()...))
-}
-
-func mergeListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
- dstl := dst.List()
- srcl := src.List()
- for i, llen := 0, srcl.Len(); i < llen; i++ {
- dstl.Append(srcl.Get(i))
- }
- return dst
-}
-
-func mergeBytesListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
- dstl := dst.List()
- srcl := src.List()
- for i, llen := 0, srcl.Len(); i < llen; i++ {
- sb := srcl.Get(i).Bytes()
- db := append(emptyBuf[:], sb...)
- dstl.Append(pref.ValueOfBytes(db))
- }
- return dst
-}
-
-func mergeMessageListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
- dstl := dst.List()
- srcl := src.List()
- for i, llen := 0, srcl.Len(); i < llen; i++ {
- sm := srcl.Get(i).Message()
- dm := proto.Clone(sm.Interface()).ProtoReflect()
- dstl.Append(pref.ValueOfMessage(dm))
- }
- return dst
-}
-
-func mergeMessageValue(dst, src pref.Value, opts mergeOptions) pref.Value {
- opts.Merge(dst.Message().Interface(), src.Message().Interface())
- return dst
-}
-
-func mergeMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
- if f.mi != nil {
- if dst.Elem().IsNil() {
- dst.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
- }
- f.mi.mergePointer(dst.Elem(), src.Elem(), opts)
- } else {
- dm := dst.AsValueOf(f.ft).Elem()
- sm := src.AsValueOf(f.ft).Elem()
- if dm.IsNil() {
- dm.Set(reflect.New(f.ft.Elem()))
- }
- opts.Merge(asMessage(dm), asMessage(sm))
- }
-}
-
-func mergeMessageSlice(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
- for _, sp := range src.PointerSlice() {
- dm := reflect.New(f.ft.Elem().Elem())
- if f.mi != nil {
- f.mi.mergePointer(pointerOfValue(dm), sp, opts)
- } else {
- opts.Merge(asMessage(dm), asMessage(sp.AsValueOf(f.ft.Elem().Elem())))
- }
- dst.AppendPointerSlice(pointerOfValue(dm))
- }
-}
-
-func mergeBytes(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Bytes() = append(emptyBuf[:], *src.Bytes()...)
-}
-
-func mergeBytesNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Bytes()
- if len(v) > 0 {
- *dst.Bytes() = append(emptyBuf[:], v...)
- }
-}
-
-func mergeBytesSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.BytesSlice()
- for _, v := range *src.BytesSlice() {
- *ds = append(*ds, append(emptyBuf[:], v...))
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go b/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go
deleted file mode 100644
index 8816c27..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package impl
-
-import ()
-
-func mergeBool(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Bool() = *src.Bool()
-}
-
-func mergeBoolNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Bool()
- if v != false {
- *dst.Bool() = v
- }
-}
-
-func mergeBoolPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.BoolPtr()
- if p != nil {
- v := *p
- *dst.BoolPtr() = &v
- }
-}
-
-func mergeBoolSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.BoolSlice()
- ss := src.BoolSlice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeInt32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Int32() = *src.Int32()
-}
-
-func mergeInt32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Int32()
- if v != 0 {
- *dst.Int32() = v
- }
-}
-
-func mergeInt32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.Int32Ptr()
- if p != nil {
- v := *p
- *dst.Int32Ptr() = &v
- }
-}
-
-func mergeInt32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.Int32Slice()
- ss := src.Int32Slice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeUint32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Uint32() = *src.Uint32()
-}
-
-func mergeUint32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Uint32()
- if v != 0 {
- *dst.Uint32() = v
- }
-}
-
-func mergeUint32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.Uint32Ptr()
- if p != nil {
- v := *p
- *dst.Uint32Ptr() = &v
- }
-}
-
-func mergeUint32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.Uint32Slice()
- ss := src.Uint32Slice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeInt64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Int64() = *src.Int64()
-}
-
-func mergeInt64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Int64()
- if v != 0 {
- *dst.Int64() = v
- }
-}
-
-func mergeInt64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.Int64Ptr()
- if p != nil {
- v := *p
- *dst.Int64Ptr() = &v
- }
-}
-
-func mergeInt64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.Int64Slice()
- ss := src.Int64Slice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeUint64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Uint64() = *src.Uint64()
-}
-
-func mergeUint64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Uint64()
- if v != 0 {
- *dst.Uint64() = v
- }
-}
-
-func mergeUint64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.Uint64Ptr()
- if p != nil {
- v := *p
- *dst.Uint64Ptr() = &v
- }
-}
-
-func mergeUint64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.Uint64Slice()
- ss := src.Uint64Slice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeFloat32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Float32() = *src.Float32()
-}
-
-func mergeFloat32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Float32()
- if v != 0 {
- *dst.Float32() = v
- }
-}
-
-func mergeFloat32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.Float32Ptr()
- if p != nil {
- v := *p
- *dst.Float32Ptr() = &v
- }
-}
-
-func mergeFloat32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.Float32Slice()
- ss := src.Float32Slice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeFloat64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.Float64() = *src.Float64()
-}
-
-func mergeFloat64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.Float64()
- if v != 0 {
- *dst.Float64() = v
- }
-}
-
-func mergeFloat64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.Float64Ptr()
- if p != nil {
- v := *p
- *dst.Float64Ptr() = &v
- }
-}
-
-func mergeFloat64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.Float64Slice()
- ss := src.Float64Slice()
- *ds = append(*ds, *ss...)
-}
-
-func mergeString(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- *dst.String() = *src.String()
-}
-
-func mergeStringNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- v := *src.String()
- if v != "" {
- *dst.String() = v
- }
-}
-
-func mergeStringPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- p := *src.StringPtr()
- if p != nil {
- v := *p
- *dst.StringPtr() = &v
- }
-}
-
-func mergeStringSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
- ds := dst.StringSlice()
- ss := src.StringSlice()
- *ds = append(*ds, *ss...)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message.go b/vendor/google.golang.org/protobuf/internal/impl/message.go
deleted file mode 100644
index 7dd994b..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "strconv"
- "strings"
- "sync"
- "sync/atomic"
-
- "google.golang.org/protobuf/internal/genname"
- "google.golang.org/protobuf/reflect/protoreflect"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// MessageInfo provides protobuf related functionality for a given Go type
-// that represents a message. A given instance of MessageInfo is tied to
-// exactly one Go type, which must be a pointer to a struct type.
-//
-// The exported fields must be populated before any methods are called
-// and cannot be mutated after set.
-type MessageInfo struct {
- // GoReflectType is the underlying message Go type and must be populated.
- GoReflectType reflect.Type // pointer to struct
-
- // Desc is the underlying message descriptor type and must be populated.
- Desc pref.MessageDescriptor
-
- // Exporter must be provided in a purego environment in order to provide
- // access to unexported fields.
- Exporter exporter
-
- // OneofWrappers is list of pointers to oneof wrapper struct types.
- OneofWrappers []interface{}
-
- initMu sync.Mutex // protects all unexported fields
- initDone uint32
-
- reflectMessageInfo // for reflection implementation
- coderMessageInfo // for fast-path method implementations
-}
-
-// exporter is a function that returns a reference to the ith field of v,
-// where v is a pointer to a struct. It returns nil if it does not support
-// exporting the requested field (e.g., already exported).
-type exporter func(v interface{}, i int) interface{}
-
-// getMessageInfo returns the MessageInfo for any message type that
-// is generated by our implementation of protoc-gen-go (for v2 and on).
-// If it is unable to obtain a MessageInfo, it returns nil.
-func getMessageInfo(mt reflect.Type) *MessageInfo {
- m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
- if !ok {
- return nil
- }
- mr, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *MessageInfo })
- if !ok {
- return nil
- }
- return mr.ProtoMessageInfo()
-}
-
-func (mi *MessageInfo) init() {
- // This function is called in the hot path. Inline the sync.Once logic,
- // since allocating a closure for Once.Do is expensive.
- // Keep init small to ensure that it can be inlined.
- if atomic.LoadUint32(&mi.initDone) == 0 {
- mi.initOnce()
- }
-}
-
-func (mi *MessageInfo) initOnce() {
- mi.initMu.Lock()
- defer mi.initMu.Unlock()
- if mi.initDone == 1 {
- return
- }
-
- t := mi.GoReflectType
- if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
- panic(fmt.Sprintf("got %v, want *struct kind", t))
- }
- t = t.Elem()
-
- si := mi.makeStructInfo(t)
- mi.makeReflectFuncs(t, si)
- mi.makeCoderMethods(t, si)
-
- atomic.StoreUint32(&mi.initDone, 1)
-}
-
-// getPointer returns the pointer for a message, which should be of
-// the type of the MessageInfo. If the message is of a different type,
-// it returns ok==false.
-func (mi *MessageInfo) getPointer(m pref.Message) (p pointer, ok bool) {
- switch m := m.(type) {
- case *messageState:
- return m.pointer(), m.messageInfo() == mi
- case *messageReflectWrapper:
- return m.pointer(), m.messageInfo() == mi
- }
- return pointer{}, false
-}
-
-type (
- SizeCache = int32
- WeakFields = map[int32]protoreflect.ProtoMessage
- UnknownFields = []byte
- ExtensionFields = map[int32]ExtensionField
-)
-
-var (
- sizecacheType = reflect.TypeOf(SizeCache(0))
- weakFieldsType = reflect.TypeOf(WeakFields(nil))
- unknownFieldsType = reflect.TypeOf(UnknownFields(nil))
- extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
-)
-
-type structInfo struct {
- sizecacheOffset offset
- weakOffset offset
- unknownOffset offset
- extensionOffset offset
-
- fieldsByNumber map[pref.FieldNumber]reflect.StructField
- oneofsByName map[pref.Name]reflect.StructField
- oneofWrappersByType map[reflect.Type]pref.FieldNumber
- oneofWrappersByNumber map[pref.FieldNumber]reflect.Type
-}
-
-func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
- si := structInfo{
- sizecacheOffset: invalidOffset,
- weakOffset: invalidOffset,
- unknownOffset: invalidOffset,
- extensionOffset: invalidOffset,
-
- fieldsByNumber: map[pref.FieldNumber]reflect.StructField{},
- oneofsByName: map[pref.Name]reflect.StructField{},
- oneofWrappersByType: map[reflect.Type]pref.FieldNumber{},
- oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
- }
-
-fieldLoop:
- for i := 0; i < t.NumField(); i++ {
- switch f := t.Field(i); f.Name {
- case genname.SizeCache, genname.SizeCacheA:
- if f.Type == sizecacheType {
- si.sizecacheOffset = offsetOf(f, mi.Exporter)
- }
- case genname.WeakFields, genname.WeakFieldsA:
- if f.Type == weakFieldsType {
- si.weakOffset = offsetOf(f, mi.Exporter)
- }
- case genname.UnknownFields, genname.UnknownFieldsA:
- if f.Type == unknownFieldsType {
- si.unknownOffset = offsetOf(f, mi.Exporter)
- }
- case genname.ExtensionFields, genname.ExtensionFieldsA, genname.ExtensionFieldsB:
- if f.Type == extensionFieldsType {
- si.extensionOffset = offsetOf(f, mi.Exporter)
- }
- default:
- for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
- if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
- n, _ := strconv.ParseUint(s, 10, 64)
- si.fieldsByNumber[pref.FieldNumber(n)] = f
- continue fieldLoop
- }
- }
- if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
- si.oneofsByName[pref.Name(s)] = f
- continue fieldLoop
- }
- }
- }
-
- // Derive a mapping of oneof wrappers to fields.
- oneofWrappers := mi.OneofWrappers
- for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
- if fn, ok := reflect.PtrTo(t).MethodByName(method); ok {
- for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
- if vs, ok := v.Interface().([]interface{}); ok {
- oneofWrappers = vs
- }
- }
- }
- }
- for _, v := range oneofWrappers {
- tf := reflect.TypeOf(v).Elem()
- f := tf.Field(0)
- for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
- if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
- n, _ := strconv.ParseUint(s, 10, 64)
- si.oneofWrappersByType[tf] = pref.FieldNumber(n)
- si.oneofWrappersByNumber[pref.FieldNumber(n)] = tf
- break
- }
- }
- }
-
- return si
-}
-
-func (mi *MessageInfo) New() protoreflect.Message {
- return mi.MessageOf(reflect.New(mi.GoReflectType.Elem()).Interface())
-}
-func (mi *MessageInfo) Zero() protoreflect.Message {
- return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
-}
-func (mi *MessageInfo) Descriptor() protoreflect.MessageDescriptor { return mi.Desc }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go
deleted file mode 100644
index 0f4b8db..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go
+++ /dev/null
@@ -1,364 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "reflect"
-
- "google.golang.org/protobuf/internal/pragma"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type reflectMessageInfo struct {
- fields map[pref.FieldNumber]*fieldInfo
- oneofs map[pref.Name]*oneofInfo
-
- // denseFields is a subset of fields where:
- // 0 < fieldDesc.Number() < len(denseFields)
- // It provides faster access to the fieldInfo, but may be incomplete.
- denseFields []*fieldInfo
-
- // rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.
- rangeInfos []interface{} // either *fieldInfo or *oneofInfo
-
- getUnknown func(pointer) pref.RawFields
- setUnknown func(pointer, pref.RawFields)
- extensionMap func(pointer) *extensionMap
-
- nilMessage atomicNilMessage
-}
-
-// makeReflectFuncs generates the set of functions to support reflection.
-func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
- mi.makeKnownFieldsFunc(si)
- mi.makeUnknownFieldsFunc(t, si)
- mi.makeExtensionFieldsFunc(t, si)
-}
-
-// makeKnownFieldsFunc generates functions for operations that can be performed
-// on each protobuf message field. It takes in a reflect.Type representing the
-// Go struct and matches message fields with struct fields.
-//
-// This code assumes that the struct is well-formed and panics if there are
-// any discrepancies.
-func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
- mi.fields = map[pref.FieldNumber]*fieldInfo{}
- md := mi.Desc
- fds := md.Fields()
- for i := 0; i < fds.Len(); i++ {
- fd := fds.Get(i)
- fs := si.fieldsByNumber[fd.Number()]
- var fi fieldInfo
- switch {
- case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
- fi = fieldInfoForOneof(fd, si.oneofsByName[fd.ContainingOneof().Name()], mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
- case fd.IsMap():
- fi = fieldInfoForMap(fd, fs, mi.Exporter)
- case fd.IsList():
- fi = fieldInfoForList(fd, fs, mi.Exporter)
- case fd.IsWeak():
- fi = fieldInfoForWeakMessage(fd, si.weakOffset)
- case fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind:
- fi = fieldInfoForMessage(fd, fs, mi.Exporter)
- default:
- fi = fieldInfoForScalar(fd, fs, mi.Exporter)
- }
- mi.fields[fd.Number()] = &fi
- }
-
- mi.oneofs = map[pref.Name]*oneofInfo{}
- for i := 0; i < md.Oneofs().Len(); i++ {
- od := md.Oneofs().Get(i)
- mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)
- }
-
- mi.denseFields = make([]*fieldInfo, fds.Len()*2)
- for i := 0; i < fds.Len(); i++ {
- if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {
- mi.denseFields[fd.Number()] = mi.fields[fd.Number()]
- }
- }
-
- for i := 0; i < fds.Len(); {
- fd := fds.Get(i)
- if od := fd.ContainingOneof(); od != nil && !od.IsSynthetic() {
- mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])
- i += od.Fields().Len()
- } else {
- mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])
- i++
- }
- }
-}
-
-func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
- mi.getUnknown = func(pointer) pref.RawFields { return nil }
- mi.setUnknown = func(pointer, pref.RawFields) { return }
- if si.unknownOffset.IsValid() {
- mi.getUnknown = func(p pointer) pref.RawFields {
- if p.IsNil() {
- return nil
- }
- rv := p.Apply(si.unknownOffset).AsValueOf(unknownFieldsType)
- return pref.RawFields(*rv.Interface().(*[]byte))
- }
- mi.setUnknown = func(p pointer, b pref.RawFields) {
- if p.IsNil() {
- panic("invalid SetUnknown on nil Message")
- }
- rv := p.Apply(si.unknownOffset).AsValueOf(unknownFieldsType)
- *rv.Interface().(*[]byte) = []byte(b)
- }
- } else {
- mi.getUnknown = func(pointer) pref.RawFields {
- return nil
- }
- mi.setUnknown = func(p pointer, _ pref.RawFields) {
- if p.IsNil() {
- panic("invalid SetUnknown on nil Message")
- }
- }
- }
-}
-
-func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
- if si.extensionOffset.IsValid() {
- mi.extensionMap = func(p pointer) *extensionMap {
- if p.IsNil() {
- return (*extensionMap)(nil)
- }
- v := p.Apply(si.extensionOffset).AsValueOf(extensionFieldsType)
- return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
- }
- } else {
- mi.extensionMap = func(pointer) *extensionMap {
- return (*extensionMap)(nil)
- }
- }
-}
-
-type extensionMap map[int32]ExtensionField
-
-func (m *extensionMap) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
- if m != nil {
- for _, x := range *m {
- xd := x.Type().TypeDescriptor()
- v := x.Value()
- if xd.IsList() && v.List().Len() == 0 {
- continue
- }
- if !f(xd, v) {
- return
- }
- }
- }
-}
-func (m *extensionMap) Has(xt pref.ExtensionType) (ok bool) {
- if m == nil {
- return false
- }
- xd := xt.TypeDescriptor()
- x, ok := (*m)[int32(xd.Number())]
- if !ok {
- return false
- }
- switch {
- case xd.IsList():
- return x.Value().List().Len() > 0
- case xd.IsMap():
- return x.Value().Map().Len() > 0
- case xd.Message() != nil:
- return x.Value().Message().IsValid()
- }
- return true
-}
-func (m *extensionMap) Clear(xt pref.ExtensionType) {
- delete(*m, int32(xt.TypeDescriptor().Number()))
-}
-func (m *extensionMap) Get(xt pref.ExtensionType) pref.Value {
- xd := xt.TypeDescriptor()
- if m != nil {
- if x, ok := (*m)[int32(xd.Number())]; ok {
- return x.Value()
- }
- }
- return xt.Zero()
-}
-func (m *extensionMap) Set(xt pref.ExtensionType, v pref.Value) {
- xd := xt.TypeDescriptor()
- isValid := true
- switch {
- case !xt.IsValidValue(v):
- isValid = false
- case xd.IsList():
- isValid = v.List().IsValid()
- case xd.IsMap():
- isValid = v.Map().IsValid()
- case xd.Message() != nil:
- isValid = v.Message().IsValid()
- }
- if !isValid {
- panic(fmt.Sprintf("%v: assigning invalid value", xt.TypeDescriptor().FullName()))
- }
-
- if *m == nil {
- *m = make(map[int32]ExtensionField)
- }
- var x ExtensionField
- x.Set(xt, v)
- (*m)[int32(xd.Number())] = x
-}
-func (m *extensionMap) Mutable(xt pref.ExtensionType) pref.Value {
- xd := xt.TypeDescriptor()
- if xd.Kind() != pref.MessageKind && xd.Kind() != pref.GroupKind && !xd.IsList() && !xd.IsMap() {
- panic("invalid Mutable on field with non-composite type")
- }
- if x, ok := (*m)[int32(xd.Number())]; ok {
- return x.Value()
- }
- v := xt.New()
- m.Set(xt, v)
- return v
-}
-
-// MessageState is a data structure that is nested as the first field in a
-// concrete message. It provides a way to implement the ProtoReflect method
-// in an allocation-free way without needing to have a shadow Go type generated
-// for every message type. This technique only works using unsafe.
-//
-//
-// Example generated code:
-//
-// type M struct {
-// state protoimpl.MessageState
-//
-// Field1 int32
-// Field2 string
-// Field3 *BarMessage
-// ...
-// }
-//
-// func (m *M) ProtoReflect() protoreflect.Message {
-// mi := &file_fizz_buzz_proto_msgInfos[5]
-// if protoimpl.UnsafeEnabled && m != nil {
-// ms := protoimpl.X.MessageStateOf(Pointer(m))
-// if ms.LoadMessageInfo() == nil {
-// ms.StoreMessageInfo(mi)
-// }
-// return ms
-// }
-// return mi.MessageOf(m)
-// }
-//
-// The MessageState type holds a *MessageInfo, which must be atomically set to
-// the message info associated with a given message instance.
-// By unsafely converting a *M into a *MessageState, the MessageState object
-// has access to all the information needed to implement protobuf reflection.
-// It has access to the message info as its first field, and a pointer to the
-// MessageState is identical to a pointer to the concrete message value.
-//
-//
-// Requirements:
-// • The type M must implement protoreflect.ProtoMessage.
-// • The address of m must not be nil.
-// • The address of m and the address of m.state must be equal,
-// even though they are different Go types.
-type MessageState struct {
- pragma.NoUnkeyedLiterals
- pragma.DoNotCompare
- pragma.DoNotCopy
-
- atomicMessageInfo *MessageInfo
-}
-
-type messageState MessageState
-
-var (
- _ pref.Message = (*messageState)(nil)
- _ unwrapper = (*messageState)(nil)
-)
-
-// messageDataType is a tuple of a pointer to the message data and
-// a pointer to the message type. It is a generalized way of providing a
-// reflective view over a message instance. The disadvantage of this approach
-// is the need to allocate this tuple of 16B.
-type messageDataType struct {
- p pointer
- mi *MessageInfo
-}
-
-type (
- messageReflectWrapper messageDataType
- messageIfaceWrapper messageDataType
-)
-
-var (
- _ pref.Message = (*messageReflectWrapper)(nil)
- _ unwrapper = (*messageReflectWrapper)(nil)
- _ pref.ProtoMessage = (*messageIfaceWrapper)(nil)
- _ unwrapper = (*messageIfaceWrapper)(nil)
-)
-
-// MessageOf returns a reflective view over a message. The input must be a
-// pointer to a named Go struct. If the provided type has a ProtoReflect method,
-// it must be implemented by calling this method.
-func (mi *MessageInfo) MessageOf(m interface{}) pref.Message {
- // TODO: Switch the input to be an opaque Pointer.
- if reflect.TypeOf(m) != mi.GoReflectType {
- panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
- }
- p := pointerOfIface(m)
- if p.IsNil() {
- return mi.nilMessage.Init(mi)
- }
- return &messageReflectWrapper{p, mi}
-}
-
-func (m *messageReflectWrapper) pointer() pointer { return m.p }
-func (m *messageReflectWrapper) messageInfo() *MessageInfo { return m.mi }
-
-func (m *messageIfaceWrapper) ProtoReflect() pref.Message {
- return (*messageReflectWrapper)(m)
-}
-func (m *messageIfaceWrapper) protoUnwrap() interface{} {
- return m.p.AsIfaceOf(m.mi.GoReflectType.Elem())
-}
-
-// checkField verifies that the provided field descriptor is valid.
-// Exactly one of the returned values is populated.
-func (mi *MessageInfo) checkField(fd pref.FieldDescriptor) (*fieldInfo, pref.ExtensionType) {
- var fi *fieldInfo
- if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) {
- fi = mi.denseFields[n]
- } else {
- fi = mi.fields[n]
- }
- if fi != nil {
- if fi.fieldDesc != fd {
- if got, want := fd.FullName(), fi.fieldDesc.FullName(); got != want {
- panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
- }
- panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
- }
- return fi, nil
- }
-
- if fd.IsExtension() {
- if got, want := fd.ContainingMessage().FullName(), mi.Desc.FullName(); got != want {
- // TODO: Should this be exact containing message descriptor match?
- panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
- }
- if !mi.Desc.ExtensionRanges().Has(fd.Number()) {
- panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
- }
- xtd, ok := fd.(pref.ExtensionTypeDescriptor)
- if !ok {
- panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
- }
- return nil, xtd.Type()
- }
- panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go
deleted file mode 100644
index 23124a8..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go
+++ /dev/null
@@ -1,466 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "math"
- "reflect"
- "sync"
-
- "google.golang.org/protobuf/internal/flags"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-type fieldInfo struct {
- fieldDesc pref.FieldDescriptor
-
- // These fields are used for protobuf reflection support.
- has func(pointer) bool
- clear func(pointer)
- get func(pointer) pref.Value
- set func(pointer, pref.Value)
- mutable func(pointer) pref.Value
- newMessage func() pref.Message
- newField func() pref.Value
-}
-
-func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
- ft := fs.Type
- if ft.Kind() != reflect.Interface {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
- }
- if ot.Kind() != reflect.Struct {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
- }
- if !reflect.PtrTo(ot).Implements(ft) {
- panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
- }
- conv := NewConverter(ot.Field(0).Type, fd)
- isMessage := fd.Message() != nil
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- // NOTE: The logic below intentionally assumes that oneof fields are
- // well-formatted. That is, the oneof interface never contains a
- // typed nil pointer to one of the wrapper structs.
-
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- return false
- }
- return true
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot {
- // NOTE: We intentionally don't check for rv.Elem().IsNil()
- // so that (*OneofWrapperType)(nil) gets cleared to nil.
- return
- }
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- return conv.Zero()
- }
- rv = rv.Elem().Elem().Field(0)
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- rv.Set(reflect.New(ot))
- }
- rv = rv.Elem().Elem().Field(0)
- rv.Set(conv.GoValueOf(v))
- },
- mutable: func(p pointer) pref.Value {
- if !isMessage {
- panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- rv.Set(reflect.New(ot))
- }
- rv = rv.Elem().Elem().Field(0)
- if rv.IsNil() {
- rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message())))
- }
- return conv.PBValueOf(rv)
- },
- newMessage: func() pref.Message {
- return conv.New().Message()
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- if ft.Kind() != reflect.Map {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
- }
- conv := NewConverter(ft, fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return rv.Len() > 0
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.Len() == 0 {
- return conv.Zero()
- }
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- pv := conv.GoValueOf(v)
- if pv.IsNil() {
- panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
- }
- rv.Set(pv)
- },
- mutable: func(p pointer) pref.Value {
- v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if v.IsNil() {
- v.Set(reflect.MakeMap(fs.Type))
- }
- return conv.PBValueOf(v)
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- if ft.Kind() != reflect.Slice {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
- }
- conv := NewConverter(reflect.PtrTo(ft), fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return rv.Len() > 0
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
- if rv.Elem().Len() == 0 {
- return conv.Zero()
- }
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- pv := conv.GoValueOf(v)
- if pv.IsNil() {
- panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
- }
- rv.Set(pv.Elem())
- },
- mutable: func(p pointer) pref.Value {
- v := p.Apply(fieldOffset).AsValueOf(fs.Type)
- return conv.PBValueOf(v)
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-var (
- nilBytes = reflect.ValueOf([]byte(nil))
- emptyBytes = reflect.ValueOf([]byte{})
-)
-
-func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- nullable := fd.HasPresence()
- isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
- if nullable {
- if ft.Kind() != reflect.Ptr && ft.Kind() != reflect.Slice {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want pointer", fd.FullName(), ft))
- }
- if ft.Kind() == reflect.Ptr {
- ft = ft.Elem()
- }
- }
- conv := NewConverter(ft, fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if nullable {
- return !rv.IsNil()
- }
- switch rv.Kind() {
- case reflect.Bool:
- return rv.Bool()
- case reflect.Int32, reflect.Int64:
- return rv.Int() != 0
- case reflect.Uint32, reflect.Uint64:
- return rv.Uint() != 0
- case reflect.Float32, reflect.Float64:
- return rv.Float() != 0 || math.Signbit(rv.Float())
- case reflect.String, reflect.Slice:
- return rv.Len() > 0
- default:
- panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
- }
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if nullable {
- if rv.IsNil() {
- return conv.Zero()
- }
- if rv.Kind() == reflect.Ptr {
- rv = rv.Elem()
- }
- }
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if nullable && rv.Kind() == reflect.Ptr {
- if rv.IsNil() {
- rv.Set(reflect.New(ft))
- }
- rv = rv.Elem()
- }
- rv.Set(conv.GoValueOf(v))
- if isBytes && rv.Len() == 0 {
- if nullable {
- rv.Set(emptyBytes) // preserve presence
- } else {
- rv.Set(nilBytes) // do not preserve presence
- }
- }
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldInfo {
- if !flags.ProtoLegacy {
- panic("no support for proto1 weak fields")
- }
-
- var once sync.Once
- var messageType pref.MessageType
- lazyInit := func() {
- once.Do(func() {
- messageName := fd.Message().FullName()
- messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
- if messageType == nil {
- panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))
- }
- })
- }
-
- num := fd.Number()
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- _, ok := p.Apply(weakOffset).WeakFields().get(num)
- return ok
- },
- clear: func(p pointer) {
- p.Apply(weakOffset).WeakFields().clear(num)
- },
- get: func(p pointer) pref.Value {
- lazyInit()
- if p.IsNil() {
- return pref.ValueOfMessage(messageType.Zero())
- }
- m, ok := p.Apply(weakOffset).WeakFields().get(num)
- if !ok {
- return pref.ValueOfMessage(messageType.Zero())
- }
- return pref.ValueOfMessage(m.ProtoReflect())
- },
- set: func(p pointer, v pref.Value) {
- lazyInit()
- m := v.Message()
- if m.Descriptor() != messageType.Descriptor() {
- if got, want := m.Descriptor().FullName(), messageType.Descriptor().FullName(); got != want {
- panic(fmt.Sprintf("field %v has mismatching message descriptor: got %v, want %v", fd.FullName(), got, want))
- }
- panic(fmt.Sprintf("field %v has mismatching message descriptor: %v", fd.FullName(), m.Descriptor().FullName()))
- }
- p.Apply(weakOffset).WeakFields().set(num, m.Interface())
- },
- mutable: func(p pointer) pref.Value {
- lazyInit()
- fs := p.Apply(weakOffset).WeakFields()
- m, ok := fs.get(num)
- if !ok {
- m = messageType.New().Interface()
- fs.set(num, m)
- }
- return pref.ValueOfMessage(m.ProtoReflect())
- },
- newMessage: func() pref.Message {
- lazyInit()
- return messageType.New()
- },
- newField: func() pref.Value {
- lazyInit()
- return pref.ValueOfMessage(messageType.New())
- },
- }
-}
-
-func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- conv := NewConverter(ft, fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return !rv.IsNil()
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(conv.GoValueOf(v))
- if rv.IsNil() {
- panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
- }
- },
- mutable: func(p pointer) pref.Value {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() {
- rv.Set(conv.GoValueOf(conv.New()))
- }
- return conv.PBValueOf(rv)
- },
- newMessage: func() pref.Message {
- return conv.New().Message()
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-type oneofInfo struct {
- oneofDesc pref.OneofDescriptor
- which func(pointer) pref.FieldNumber
-}
-
-func makeOneofInfo(od pref.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
- oi := &oneofInfo{oneofDesc: od}
- if od.IsSynthetic() {
- fs := si.fieldsByNumber[od.Fields().Get(0).Number()]
- fieldOffset := offsetOf(fs, x)
- oi.which = func(p pointer) pref.FieldNumber {
- if p.IsNil() {
- return 0
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() { // valid on either *T or []byte
- return 0
- }
- return od.Fields().Get(0).Number()
- }
- } else {
- fs := si.oneofsByName[od.Name()]
- fieldOffset := offsetOf(fs, x)
- oi.which = func(p pointer) pref.FieldNumber {
- if p.IsNil() {
- return 0
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() {
- return 0
- }
- rv = rv.Elem()
- if rv.IsNil() {
- return 0
- }
- return si.oneofWrappersByType[rv.Type().Elem()]
- }
- }
- return oi
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go
deleted file mode 100644
index 741d6e5..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package impl
-
-import (
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-func (m *messageState) Descriptor() protoreflect.MessageDescriptor {
- return m.messageInfo().Desc
-}
-func (m *messageState) Type() protoreflect.MessageType {
- return m.messageInfo()
-}
-func (m *messageState) New() protoreflect.Message {
- return m.messageInfo().New()
-}
-func (m *messageState) Interface() protoreflect.ProtoMessage {
- return m.protoUnwrap().(protoreflect.ProtoMessage)
-}
-func (m *messageState) protoUnwrap() interface{} {
- return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
-}
-func (m *messageState) ProtoMethods() *protoiface.Methods {
- m.messageInfo().init()
- return &m.messageInfo().methods
-}
-
-// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
-// to be able to retrieve a v2 MessageInfo struct.
-//
-// WARNING: This method is exempt from the compatibility promise and
-// may be removed in the future without warning.
-func (m *messageState) ProtoMessageInfo() *MessageInfo {
- return m.messageInfo()
-}
-
-func (m *messageState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- m.messageInfo().init()
- for _, ri := range m.messageInfo().rangeInfos {
- switch ri := ri.(type) {
- case *fieldInfo:
- if ri.has(m.pointer()) {
- if !f(ri.fieldDesc, ri.get(m.pointer())) {
- return
- }
- }
- case *oneofInfo:
- if n := ri.which(m.pointer()); n > 0 {
- fi := m.messageInfo().fields[n]
- if !f(fi.fieldDesc, fi.get(m.pointer())) {
- return
- }
- }
- }
- }
- m.messageInfo().extensionMap(m.pointer()).Range(f)
-}
-func (m *messageState) Has(fd protoreflect.FieldDescriptor) bool {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.has(m.pointer())
- } else {
- return m.messageInfo().extensionMap(m.pointer()).Has(xt)
- }
-}
-func (m *messageState) Clear(fd protoreflect.FieldDescriptor) {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- fi.clear(m.pointer())
- } else {
- m.messageInfo().extensionMap(m.pointer()).Clear(xt)
- }
-}
-func (m *messageState) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.get(m.pointer())
- } else {
- return m.messageInfo().extensionMap(m.pointer()).Get(xt)
- }
-}
-func (m *messageState) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- fi.set(m.pointer(), v)
- } else {
- m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
- }
-}
-func (m *messageState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.mutable(m.pointer())
- } else {
- return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
- }
-}
-func (m *messageState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.newField()
- } else {
- return xt.New()
- }
-}
-func (m *messageState) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
- m.messageInfo().init()
- if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
- return od.Fields().ByNumber(oi.which(m.pointer()))
- }
- panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
-}
-func (m *messageState) GetUnknown() protoreflect.RawFields {
- m.messageInfo().init()
- return m.messageInfo().getUnknown(m.pointer())
-}
-func (m *messageState) SetUnknown(b protoreflect.RawFields) {
- m.messageInfo().init()
- m.messageInfo().setUnknown(m.pointer(), b)
-}
-func (m *messageState) IsValid() bool {
- return !m.pointer().IsNil()
-}
-
-func (m *messageReflectWrapper) Descriptor() protoreflect.MessageDescriptor {
- return m.messageInfo().Desc
-}
-func (m *messageReflectWrapper) Type() protoreflect.MessageType {
- return m.messageInfo()
-}
-func (m *messageReflectWrapper) New() protoreflect.Message {
- return m.messageInfo().New()
-}
-func (m *messageReflectWrapper) Interface() protoreflect.ProtoMessage {
- if m, ok := m.protoUnwrap().(protoreflect.ProtoMessage); ok {
- return m
- }
- return (*messageIfaceWrapper)(m)
-}
-func (m *messageReflectWrapper) protoUnwrap() interface{} {
- return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
-}
-func (m *messageReflectWrapper) ProtoMethods() *protoiface.Methods {
- m.messageInfo().init()
- return &m.messageInfo().methods
-}
-
-// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
-// to be able to retrieve a v2 MessageInfo struct.
-//
-// WARNING: This method is exempt from the compatibility promise and
-// may be removed in the future without warning.
-func (m *messageReflectWrapper) ProtoMessageInfo() *MessageInfo {
- return m.messageInfo()
-}
-
-func (m *messageReflectWrapper) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- m.messageInfo().init()
- for _, ri := range m.messageInfo().rangeInfos {
- switch ri := ri.(type) {
- case *fieldInfo:
- if ri.has(m.pointer()) {
- if !f(ri.fieldDesc, ri.get(m.pointer())) {
- return
- }
- }
- case *oneofInfo:
- if n := ri.which(m.pointer()); n > 0 {
- fi := m.messageInfo().fields[n]
- if !f(fi.fieldDesc, fi.get(m.pointer())) {
- return
- }
- }
- }
- }
- m.messageInfo().extensionMap(m.pointer()).Range(f)
-}
-func (m *messageReflectWrapper) Has(fd protoreflect.FieldDescriptor) bool {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.has(m.pointer())
- } else {
- return m.messageInfo().extensionMap(m.pointer()).Has(xt)
- }
-}
-func (m *messageReflectWrapper) Clear(fd protoreflect.FieldDescriptor) {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- fi.clear(m.pointer())
- } else {
- m.messageInfo().extensionMap(m.pointer()).Clear(xt)
- }
-}
-func (m *messageReflectWrapper) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.get(m.pointer())
- } else {
- return m.messageInfo().extensionMap(m.pointer()).Get(xt)
- }
-}
-func (m *messageReflectWrapper) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- fi.set(m.pointer(), v)
- } else {
- m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
- }
-}
-func (m *messageReflectWrapper) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.mutable(m.pointer())
- } else {
- return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
- }
-}
-func (m *messageReflectWrapper) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
- m.messageInfo().init()
- if fi, xt := m.messageInfo().checkField(fd); fi != nil {
- return fi.newField()
- } else {
- return xt.New()
- }
-}
-func (m *messageReflectWrapper) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
- m.messageInfo().init()
- if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
- return od.Fields().ByNumber(oi.which(m.pointer()))
- }
- panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
-}
-func (m *messageReflectWrapper) GetUnknown() protoreflect.RawFields {
- m.messageInfo().init()
- return m.messageInfo().getUnknown(m.pointer())
-}
-func (m *messageReflectWrapper) SetUnknown(b protoreflect.RawFields) {
- m.messageInfo().init()
- m.messageInfo().setUnknown(m.pointer(), b)
-}
-func (m *messageReflectWrapper) IsValid() bool {
- return !m.pointer().IsNil()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
deleted file mode 100644
index 67b4ede..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package impl
-
-import (
- "fmt"
- "reflect"
- "sync"
-)
-
-const UnsafeEnabled = false
-
-// Pointer is an opaque pointer type.
-type Pointer interface{}
-
-// offset represents the offset to a struct field, accessible from a pointer.
-// The offset is the field index into a struct.
-type offset struct {
- index int
- export exporter
-}
-
-// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField, x exporter) offset {
- if len(f.Index) != 1 {
- panic("embedded structs are not supported")
- }
- if f.PkgPath == "" {
- return offset{index: f.Index[0]} // field is already exported
- }
- if x == nil {
- panic("exporter must be provided for unexported field")
- }
- return offset{index: f.Index[0], export: x}
-}
-
-// IsValid reports whether the offset is valid.
-func (f offset) IsValid() bool { return f.index >= 0 }
-
-// invalidOffset is an invalid field offset.
-var invalidOffset = offset{index: -1}
-
-// zeroOffset is a noop when calling pointer.Apply.
-var zeroOffset = offset{index: 0}
-
-// pointer is an abstract representation of a pointer to a struct or field.
-type pointer struct{ v reflect.Value }
-
-// pointerOf returns p as a pointer.
-func pointerOf(p Pointer) pointer {
- return pointerOfIface(p)
-}
-
-// pointerOfValue returns v as a pointer.
-func pointerOfValue(v reflect.Value) pointer {
- return pointer{v: v}
-}
-
-// pointerOfIface returns the pointer portion of an interface.
-func pointerOfIface(v interface{}) pointer {
- return pointer{v: reflect.ValueOf(v)}
-}
-
-// IsNil reports whether the pointer is nil.
-func (p pointer) IsNil() bool {
- return p.v.IsNil()
-}
-
-// Apply adds an offset to the pointer to derive a new pointer
-// to a specified field. The current pointer must be pointing at a struct.
-func (p pointer) Apply(f offset) pointer {
- if f.export != nil {
- if v := reflect.ValueOf(f.export(p.v.Interface(), f.index)); v.IsValid() {
- return pointer{v: v}
- }
- }
- return pointer{v: p.v.Elem().Field(f.index).Addr()}
-}
-
-// AsValueOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
-func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
- if got := p.v.Type().Elem(); got != t {
- panic(fmt.Sprintf("invalid type: got %v, want %v", got, t))
- }
- return p.v
-}
-
-// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to p.AsValueOf(t).Interface()
-func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
- return p.AsValueOf(t).Interface()
-}
-
-func (p pointer) Bool() *bool { return p.v.Interface().(*bool) }
-func (p pointer) BoolPtr() **bool { return p.v.Interface().(**bool) }
-func (p pointer) BoolSlice() *[]bool { return p.v.Interface().(*[]bool) }
-func (p pointer) Int32() *int32 { return p.v.Interface().(*int32) }
-func (p pointer) Int32Ptr() **int32 { return p.v.Interface().(**int32) }
-func (p pointer) Int32Slice() *[]int32 { return p.v.Interface().(*[]int32) }
-func (p pointer) Int64() *int64 { return p.v.Interface().(*int64) }
-func (p pointer) Int64Ptr() **int64 { return p.v.Interface().(**int64) }
-func (p pointer) Int64Slice() *[]int64 { return p.v.Interface().(*[]int64) }
-func (p pointer) Uint32() *uint32 { return p.v.Interface().(*uint32) }
-func (p pointer) Uint32Ptr() **uint32 { return p.v.Interface().(**uint32) }
-func (p pointer) Uint32Slice() *[]uint32 { return p.v.Interface().(*[]uint32) }
-func (p pointer) Uint64() *uint64 { return p.v.Interface().(*uint64) }
-func (p pointer) Uint64Ptr() **uint64 { return p.v.Interface().(**uint64) }
-func (p pointer) Uint64Slice() *[]uint64 { return p.v.Interface().(*[]uint64) }
-func (p pointer) Float32() *float32 { return p.v.Interface().(*float32) }
-func (p pointer) Float32Ptr() **float32 { return p.v.Interface().(**float32) }
-func (p pointer) Float32Slice() *[]float32 { return p.v.Interface().(*[]float32) }
-func (p pointer) Float64() *float64 { return p.v.Interface().(*float64) }
-func (p pointer) Float64Ptr() **float64 { return p.v.Interface().(**float64) }
-func (p pointer) Float64Slice() *[]float64 { return p.v.Interface().(*[]float64) }
-func (p pointer) String() *string { return p.v.Interface().(*string) }
-func (p pointer) StringPtr() **string { return p.v.Interface().(**string) }
-func (p pointer) StringSlice() *[]string { return p.v.Interface().(*[]string) }
-func (p pointer) Bytes() *[]byte { return p.v.Interface().(*[]byte) }
-func (p pointer) BytesSlice() *[][]byte { return p.v.Interface().(*[][]byte) }
-func (p pointer) WeakFields() *weakFields { return (*weakFields)(p.v.Interface().(*WeakFields)) }
-func (p pointer) Extensions() *map[int32]ExtensionField {
- return p.v.Interface().(*map[int32]ExtensionField)
-}
-
-func (p pointer) Elem() pointer {
- return pointer{v: p.v.Elem()}
-}
-
-// PointerSlice copies []*T from p as a new []pointer.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) PointerSlice() []pointer {
- // TODO: reconsider this
- if p.v.IsNil() {
- return nil
- }
- n := p.v.Elem().Len()
- s := make([]pointer, n)
- for i := 0; i < n; i++ {
- s[i] = pointer{v: p.v.Elem().Index(i)}
- }
- return s
-}
-
-// AppendPointerSlice appends v to p, which must be a []*T.
-func (p pointer) AppendPointerSlice(v pointer) {
- sp := p.v.Elem()
- sp.Set(reflect.Append(sp, v.v))
-}
-
-// SetPointer sets *p to v.
-func (p pointer) SetPointer(v pointer) {
- p.v.Elem().Set(v.v)
-}
-
-func (Export) MessageStateOf(p Pointer) *messageState { panic("not supported") }
-func (ms *messageState) pointer() pointer { panic("not supported") }
-func (ms *messageState) messageInfo() *MessageInfo { panic("not supported") }
-func (ms *messageState) LoadMessageInfo() *MessageInfo { panic("not supported") }
-func (ms *messageState) StoreMessageInfo(mi *MessageInfo) { panic("not supported") }
-
-type atomicNilMessage struct {
- once sync.Once
- m messageReflectWrapper
-}
-
-func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
- m.once.Do(func() {
- m.m.p = pointerOfIface(reflect.Zero(mi.GoReflectType).Interface())
- m.m.mi = mi
- })
- return &m.m
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
deleted file mode 100644
index 088aa85..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package impl
-
-import (
- "reflect"
- "sync/atomic"
- "unsafe"
-)
-
-const UnsafeEnabled = true
-
-// Pointer is an opaque pointer type.
-type Pointer unsafe.Pointer
-
-// offset represents the offset to a struct field, accessible from a pointer.
-// The offset is the byte offset to the field from the start of the struct.
-type offset uintptr
-
-// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField, x exporter) offset {
- return offset(f.Offset)
-}
-
-// IsValid reports whether the offset is valid.
-func (f offset) IsValid() bool { return f != invalidOffset }
-
-// invalidOffset is an invalid field offset.
-var invalidOffset = ^offset(0)
-
-// zeroOffset is a noop when calling pointer.Apply.
-var zeroOffset = offset(0)
-
-// pointer is a pointer to a message struct or field.
-type pointer struct{ p unsafe.Pointer }
-
-// pointerOf returns p as a pointer.
-func pointerOf(p Pointer) pointer {
- return pointer{p: unsafe.Pointer(p)}
-}
-
-// pointerOfValue returns v as a pointer.
-func pointerOfValue(v reflect.Value) pointer {
- return pointer{p: unsafe.Pointer(v.Pointer())}
-}
-
-// pointerOfIface returns the pointer portion of an interface.
-func pointerOfIface(v interface{}) pointer {
- type ifaceHeader struct {
- Type unsafe.Pointer
- Data unsafe.Pointer
- }
- return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
-}
-
-// IsNil reports whether the pointer is nil.
-func (p pointer) IsNil() bool {
- return p.p == nil
-}
-
-// Apply adds an offset to the pointer to derive a new pointer
-// to a specified field. The pointer must be valid and pointing at a struct.
-func (p pointer) Apply(f offset) pointer {
- if p.IsNil() {
- panic("invalid nil pointer")
- }
- return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
-}
-
-// AsValueOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
-func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
- return reflect.NewAt(t, p.p)
-}
-
-// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to p.AsValueOf(t).Interface()
-func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
- // TODO: Use tricky unsafe magic to directly create ifaceHeader.
- return p.AsValueOf(t).Interface()
-}
-
-func (p pointer) Bool() *bool { return (*bool)(p.p) }
-func (p pointer) BoolPtr() **bool { return (**bool)(p.p) }
-func (p pointer) BoolSlice() *[]bool { return (*[]bool)(p.p) }
-func (p pointer) Int32() *int32 { return (*int32)(p.p) }
-func (p pointer) Int32Ptr() **int32 { return (**int32)(p.p) }
-func (p pointer) Int32Slice() *[]int32 { return (*[]int32)(p.p) }
-func (p pointer) Int64() *int64 { return (*int64)(p.p) }
-func (p pointer) Int64Ptr() **int64 { return (**int64)(p.p) }
-func (p pointer) Int64Slice() *[]int64 { return (*[]int64)(p.p) }
-func (p pointer) Uint32() *uint32 { return (*uint32)(p.p) }
-func (p pointer) Uint32Ptr() **uint32 { return (**uint32)(p.p) }
-func (p pointer) Uint32Slice() *[]uint32 { return (*[]uint32)(p.p) }
-func (p pointer) Uint64() *uint64 { return (*uint64)(p.p) }
-func (p pointer) Uint64Ptr() **uint64 { return (**uint64)(p.p) }
-func (p pointer) Uint64Slice() *[]uint64 { return (*[]uint64)(p.p) }
-func (p pointer) Float32() *float32 { return (*float32)(p.p) }
-func (p pointer) Float32Ptr() **float32 { return (**float32)(p.p) }
-func (p pointer) Float32Slice() *[]float32 { return (*[]float32)(p.p) }
-func (p pointer) Float64() *float64 { return (*float64)(p.p) }
-func (p pointer) Float64Ptr() **float64 { return (**float64)(p.p) }
-func (p pointer) Float64Slice() *[]float64 { return (*[]float64)(p.p) }
-func (p pointer) String() *string { return (*string)(p.p) }
-func (p pointer) StringPtr() **string { return (**string)(p.p) }
-func (p pointer) StringSlice() *[]string { return (*[]string)(p.p) }
-func (p pointer) Bytes() *[]byte { return (*[]byte)(p.p) }
-func (p pointer) BytesSlice() *[][]byte { return (*[][]byte)(p.p) }
-func (p pointer) WeakFields() *weakFields { return (*weakFields)(p.p) }
-func (p pointer) Extensions() *map[int32]ExtensionField { return (*map[int32]ExtensionField)(p.p) }
-
-func (p pointer) Elem() pointer {
- return pointer{p: *(*unsafe.Pointer)(p.p)}
-}
-
-// PointerSlice loads []*T from p as a []pointer.
-// The value returned is aliased with the original slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) PointerSlice() []pointer {
- // Super-tricky - p should point to a []*T where T is a
- // message type. We load it as []pointer.
- return *(*[]pointer)(p.p)
-}
-
-// AppendPointerSlice appends v to p, which must be a []*T.
-func (p pointer) AppendPointerSlice(v pointer) {
- *(*[]pointer)(p.p) = append(*(*[]pointer)(p.p), v)
-}
-
-// SetPointer sets *p to v.
-func (p pointer) SetPointer(v pointer) {
- *(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
-}
-
-// Static check that MessageState does not exceed the size of a pointer.
-const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
-
-func (Export) MessageStateOf(p Pointer) *messageState {
- // Super-tricky - see documentation on MessageState.
- return (*messageState)(unsafe.Pointer(p))
-}
-func (ms *messageState) pointer() pointer {
- // Super-tricky - see documentation on MessageState.
- return pointer{p: unsafe.Pointer(ms)}
-}
-func (ms *messageState) messageInfo() *MessageInfo {
- mi := ms.LoadMessageInfo()
- if mi == nil {
- panic("invalid nil message info; this suggests memory corruption due to a race or shallow copy on the message struct")
- }
- return mi
-}
-func (ms *messageState) LoadMessageInfo() *MessageInfo {
- return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
-}
-func (ms *messageState) StoreMessageInfo(mi *MessageInfo) {
- atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
-}
-
-type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
-
-func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
- if p := atomic.LoadPointer(&m.p); p != nil {
- return (*messageReflectWrapper)(p)
- }
- w := &messageReflectWrapper{mi: mi}
- atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
- return (*messageReflectWrapper)(atomic.LoadPointer(&m.p))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/validate.go b/vendor/google.golang.org/protobuf/internal/impl/validate.go
deleted file mode 100644
index 57de9cc..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/validate.go
+++ /dev/null
@@ -1,575 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
- "math"
- "math/bits"
- "reflect"
- "unicode/utf8"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/internal/strs"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
- piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// ValidationStatus is the result of validating the wire-format encoding of a message.
-type ValidationStatus int
-
-const (
- // ValidationUnknown indicates that unmarshaling the message might succeed or fail.
- // The validator was unable to render a judgement.
- //
- // The only causes of this status are an aberrant message type appearing somewhere
- // in the message or a failure in the extension resolver.
- ValidationUnknown ValidationStatus = iota + 1
-
- // ValidationInvalid indicates that unmarshaling the message will fail.
- ValidationInvalid
-
- // ValidationValid indicates that unmarshaling the message will succeed.
- ValidationValid
-)
-
-func (v ValidationStatus) String() string {
- switch v {
- case ValidationUnknown:
- return "ValidationUnknown"
- case ValidationInvalid:
- return "ValidationInvalid"
- case ValidationValid:
- return "ValidationValid"
- default:
- return fmt.Sprintf("ValidationStatus(%d)", int(v))
- }
-}
-
-// Validate determines whether the contents of the buffer are a valid wire encoding
-// of the message type.
-//
-// This function is exposed for testing.
-func Validate(mt pref.MessageType, in piface.UnmarshalInput) (out piface.UnmarshalOutput, _ ValidationStatus) {
- mi, ok := mt.(*MessageInfo)
- if !ok {
- return out, ValidationUnknown
- }
- if in.Resolver == nil {
- in.Resolver = preg.GlobalTypes
- }
- o, st := mi.validate(in.Buf, 0, unmarshalOptions{
- flags: in.Flags,
- resolver: in.Resolver,
- })
- if o.initialized {
- out.Flags |= piface.UnmarshalInitialized
- }
- return out, st
-}
-
-type validationInfo struct {
- mi *MessageInfo
- typ validationType
- keyType, valType validationType
-
- // For non-required fields, requiredBit is 0.
- //
- // For required fields, requiredBit's nth bit is set, where n is a
- // unique index in the range [0, MessageInfo.numRequiredFields).
- //
- // If there are more than 64 required fields, requiredBit is 0.
- requiredBit uint64
-}
-
-type validationType uint8
-
-const (
- validationTypeOther validationType = iota
- validationTypeMessage
- validationTypeGroup
- validationTypeMap
- validationTypeRepeatedVarint
- validationTypeRepeatedFixed32
- validationTypeRepeatedFixed64
- validationTypeVarint
- validationTypeFixed32
- validationTypeFixed64
- validationTypeBytes
- validationTypeUTF8String
- validationTypeMessageSetItem
-)
-
-func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
- var vi validationInfo
- switch {
- case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
- switch fd.Kind() {
- case pref.MessageKind:
- vi.typ = validationTypeMessage
- if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
- vi.mi = getMessageInfo(ot.Field(0).Type)
- }
- case pref.GroupKind:
- vi.typ = validationTypeGroup
- if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
- vi.mi = getMessageInfo(ot.Field(0).Type)
- }
- case pref.StringKind:
- if strs.EnforceUTF8(fd) {
- vi.typ = validationTypeUTF8String
- }
- }
- default:
- vi = newValidationInfo(fd, ft)
- }
- if fd.Cardinality() == pref.Required {
- // Avoid overflow. The required field check is done with a 64-bit mask, with
- // any message containing more than 64 required fields always reported as
- // potentially uninitialized, so it is not important to get a precise count
- // of the required fields past 64.
- if mi.numRequiredFields < math.MaxUint8 {
- mi.numRequiredFields++
- vi.requiredBit = 1 << (mi.numRequiredFields - 1)
- }
- }
- return vi
-}
-
-func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
- var vi validationInfo
- switch {
- case fd.IsList():
- switch fd.Kind() {
- case pref.MessageKind:
- vi.typ = validationTypeMessage
- if ft.Kind() == reflect.Slice {
- vi.mi = getMessageInfo(ft.Elem())
- }
- case pref.GroupKind:
- vi.typ = validationTypeGroup
- if ft.Kind() == reflect.Slice {
- vi.mi = getMessageInfo(ft.Elem())
- }
- case pref.StringKind:
- vi.typ = validationTypeBytes
- if strs.EnforceUTF8(fd) {
- vi.typ = validationTypeUTF8String
- }
- default:
- switch wireTypes[fd.Kind()] {
- case protowire.VarintType:
- vi.typ = validationTypeRepeatedVarint
- case protowire.Fixed32Type:
- vi.typ = validationTypeRepeatedFixed32
- case protowire.Fixed64Type:
- vi.typ = validationTypeRepeatedFixed64
- }
- }
- case fd.IsMap():
- vi.typ = validationTypeMap
- switch fd.MapKey().Kind() {
- case pref.StringKind:
- if strs.EnforceUTF8(fd) {
- vi.keyType = validationTypeUTF8String
- }
- }
- switch fd.MapValue().Kind() {
- case pref.MessageKind:
- vi.valType = validationTypeMessage
- if ft.Kind() == reflect.Map {
- vi.mi = getMessageInfo(ft.Elem())
- }
- case pref.StringKind:
- if strs.EnforceUTF8(fd) {
- vi.valType = validationTypeUTF8String
- }
- }
- default:
- switch fd.Kind() {
- case pref.MessageKind:
- vi.typ = validationTypeMessage
- if !fd.IsWeak() {
- vi.mi = getMessageInfo(ft)
- }
- case pref.GroupKind:
- vi.typ = validationTypeGroup
- vi.mi = getMessageInfo(ft)
- case pref.StringKind:
- vi.typ = validationTypeBytes
- if strs.EnforceUTF8(fd) {
- vi.typ = validationTypeUTF8String
- }
- default:
- switch wireTypes[fd.Kind()] {
- case protowire.VarintType:
- vi.typ = validationTypeVarint
- case protowire.Fixed32Type:
- vi.typ = validationTypeFixed32
- case protowire.Fixed64Type:
- vi.typ = validationTypeFixed64
- case protowire.BytesType:
- vi.typ = validationTypeBytes
- }
- }
- }
- return vi
-}
-
-func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
- mi.init()
- type validationState struct {
- typ validationType
- keyType, valType validationType
- endGroup protowire.Number
- mi *MessageInfo
- tail []byte
- requiredMask uint64
- }
-
- // Pre-allocate some slots to avoid repeated slice reallocation.
- states := make([]validationState, 0, 16)
- states = append(states, validationState{
- typ: validationTypeMessage,
- mi: mi,
- })
- if groupTag > 0 {
- states[0].typ = validationTypeGroup
- states[0].endGroup = groupTag
- }
- initialized := true
- start := len(b)
-State:
- for len(states) > 0 {
- st := &states[len(states)-1]
- for len(b) > 0 {
- // Parse the tag (field number and wire type).
- var tag uint64
- if b[0] < 0x80 {
- tag = uint64(b[0])
- b = b[1:]
- } else if len(b) >= 2 && b[1] < 128 {
- tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
- b = b[2:]
- } else {
- var n int
- tag, n = protowire.ConsumeVarint(b)
- if n < 0 {
- return out, ValidationInvalid
- }
- b = b[n:]
- }
- var num protowire.Number
- if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
- return out, ValidationInvalid
- } else {
- num = protowire.Number(n)
- }
- wtyp := protowire.Type(tag & 7)
-
- if wtyp == protowire.EndGroupType {
- if st.endGroup == num {
- goto PopState
- }
- return out, ValidationInvalid
- }
- var vi validationInfo
- switch {
- case st.typ == validationTypeMap:
- switch num {
- case 1:
- vi.typ = st.keyType
- case 2:
- vi.typ = st.valType
- vi.mi = st.mi
- vi.requiredBit = 1
- }
- case flags.ProtoLegacy && st.mi.isMessageSet:
- switch num {
- case messageset.FieldItem:
- vi.typ = validationTypeMessageSetItem
- }
- default:
- var f *coderFieldInfo
- if int(num) < len(st.mi.denseCoderFields) {
- f = st.mi.denseCoderFields[num]
- } else {
- f = st.mi.coderFields[num]
- }
- if f != nil {
- vi = f.validation
- if vi.typ == validationTypeMessage && vi.mi == nil {
- // Probable weak field.
- //
- // TODO: Consider storing the results of this lookup somewhere
- // rather than recomputing it on every validation.
- fd := st.mi.Desc.Fields().ByNumber(num)
- if fd == nil || !fd.IsWeak() {
- break
- }
- messageName := fd.Message().FullName()
- messageType, err := preg.GlobalTypes.FindMessageByName(messageName)
- switch err {
- case nil:
- vi.mi, _ = messageType.(*MessageInfo)
- case preg.NotFound:
- vi.typ = validationTypeBytes
- default:
- return out, ValidationUnknown
- }
- }
- break
- }
- // Possible extension field.
- //
- // TODO: We should return ValidationUnknown when:
- // 1. The resolver is not frozen. (More extensions may be added to it.)
- // 2. The resolver returns preg.NotFound.
- // In this case, a type added to the resolver in the future could cause
- // unmarshaling to begin failing. Supporting this requires some way to
- // determine if the resolver is frozen.
- xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
- if err != nil && err != preg.NotFound {
- return out, ValidationUnknown
- }
- if err == nil {
- vi = getExtensionFieldInfo(xt).validation
- }
- }
- if vi.requiredBit != 0 {
- // Check that the field has a compatible wire type.
- // We only need to consider non-repeated field types,
- // since repeated fields (and maps) can never be required.
- ok := false
- switch vi.typ {
- case validationTypeVarint:
- ok = wtyp == protowire.VarintType
- case validationTypeFixed32:
- ok = wtyp == protowire.Fixed32Type
- case validationTypeFixed64:
- ok = wtyp == protowire.Fixed64Type
- case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
- ok = wtyp == protowire.BytesType
- case validationTypeGroup:
- ok = wtyp == protowire.StartGroupType
- }
- if ok {
- st.requiredMask |= vi.requiredBit
- }
- }
-
- switch wtyp {
- case protowire.VarintType:
- if len(b) >= 10 {
- switch {
- case b[0] < 0x80:
- b = b[1:]
- case b[1] < 0x80:
- b = b[2:]
- case b[2] < 0x80:
- b = b[3:]
- case b[3] < 0x80:
- b = b[4:]
- case b[4] < 0x80:
- b = b[5:]
- case b[5] < 0x80:
- b = b[6:]
- case b[6] < 0x80:
- b = b[7:]
- case b[7] < 0x80:
- b = b[8:]
- case b[8] < 0x80:
- b = b[9:]
- case b[9] < 0x80 && b[9] < 2:
- b = b[10:]
- default:
- return out, ValidationInvalid
- }
- } else {
- switch {
- case len(b) > 0 && b[0] < 0x80:
- b = b[1:]
- case len(b) > 1 && b[1] < 0x80:
- b = b[2:]
- case len(b) > 2 && b[2] < 0x80:
- b = b[3:]
- case len(b) > 3 && b[3] < 0x80:
- b = b[4:]
- case len(b) > 4 && b[4] < 0x80:
- b = b[5:]
- case len(b) > 5 && b[5] < 0x80:
- b = b[6:]
- case len(b) > 6 && b[6] < 0x80:
- b = b[7:]
- case len(b) > 7 && b[7] < 0x80:
- b = b[8:]
- case len(b) > 8 && b[8] < 0x80:
- b = b[9:]
- case len(b) > 9 && b[9] < 2:
- b = b[10:]
- default:
- return out, ValidationInvalid
- }
- }
- continue State
- case protowire.BytesType:
- var size uint64
- if len(b) >= 1 && b[0] < 0x80 {
- size = uint64(b[0])
- b = b[1:]
- } else if len(b) >= 2 && b[1] < 128 {
- size = uint64(b[0]&0x7f) + uint64(b[1])<<7
- b = b[2:]
- } else {
- var n int
- size, n = protowire.ConsumeVarint(b)
- if n < 0 {
- return out, ValidationInvalid
- }
- b = b[n:]
- }
- if size > uint64(len(b)) {
- return out, ValidationInvalid
- }
- v := b[:size]
- b = b[size:]
- switch vi.typ {
- case validationTypeMessage:
- if vi.mi == nil {
- return out, ValidationUnknown
- }
- vi.mi.init()
- fallthrough
- case validationTypeMap:
- if vi.mi != nil {
- vi.mi.init()
- }
- states = append(states, validationState{
- typ: vi.typ,
- keyType: vi.keyType,
- valType: vi.valType,
- mi: vi.mi,
- tail: b,
- })
- b = v
- continue State
- case validationTypeRepeatedVarint:
- // Packed field.
- for len(v) > 0 {
- _, n := protowire.ConsumeVarint(v)
- if n < 0 {
- return out, ValidationInvalid
- }
- v = v[n:]
- }
- case validationTypeRepeatedFixed32:
- // Packed field.
- if len(v)%4 != 0 {
- return out, ValidationInvalid
- }
- case validationTypeRepeatedFixed64:
- // Packed field.
- if len(v)%8 != 0 {
- return out, ValidationInvalid
- }
- case validationTypeUTF8String:
- if !utf8.Valid(v) {
- return out, ValidationInvalid
- }
- }
- case protowire.Fixed32Type:
- if len(b) < 4 {
- return out, ValidationInvalid
- }
- b = b[4:]
- case protowire.Fixed64Type:
- if len(b) < 8 {
- return out, ValidationInvalid
- }
- b = b[8:]
- case protowire.StartGroupType:
- switch {
- case vi.typ == validationTypeGroup:
- if vi.mi == nil {
- return out, ValidationUnknown
- }
- vi.mi.init()
- states = append(states, validationState{
- typ: validationTypeGroup,
- mi: vi.mi,
- endGroup: num,
- })
- continue State
- case flags.ProtoLegacy && vi.typ == validationTypeMessageSetItem:
- typeid, v, n, err := messageset.ConsumeFieldValue(b, false)
- if err != nil {
- return out, ValidationInvalid
- }
- xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
- switch {
- case err == preg.NotFound:
- b = b[n:]
- case err != nil:
- return out, ValidationUnknown
- default:
- xvi := getExtensionFieldInfo(xt).validation
- if xvi.mi != nil {
- xvi.mi.init()
- }
- states = append(states, validationState{
- typ: xvi.typ,
- mi: xvi.mi,
- tail: b[n:],
- })
- b = v
- continue State
- }
- default:
- n := protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return out, ValidationInvalid
- }
- b = b[n:]
- }
- default:
- return out, ValidationInvalid
- }
- }
- if st.endGroup != 0 {
- return out, ValidationInvalid
- }
- if len(b) != 0 {
- return out, ValidationInvalid
- }
- b = st.tail
- PopState:
- numRequiredFields := 0
- switch st.typ {
- case validationTypeMessage, validationTypeGroup:
- numRequiredFields = int(st.mi.numRequiredFields)
- case validationTypeMap:
- // If this is a map field with a message value that contains
- // required fields, require that the value be present.
- if st.mi != nil && st.mi.numRequiredFields > 0 {
- numRequiredFields = 1
- }
- }
- // If there are more than 64 required fields, this check will
- // always fail and we will report that the message is potentially
- // uninitialized.
- if numRequiredFields > 0 && bits.OnesCount64(st.requiredMask) != numRequiredFields {
- initialized = false
- }
- states = states[:len(states)-1]
- }
- out.n = start - len(b)
- if initialized {
- out.initialized = true
- }
- return out, ValidationValid
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/weak.go b/vendor/google.golang.org/protobuf/internal/impl/weak.go
deleted file mode 100644
index 009cbef..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/weak.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
- "fmt"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// weakFields adds methods to the exported WeakFields type for internal use.
-//
-// The exported type is an alias to an unnamed type, so methods can't be
-// defined directly on it.
-type weakFields WeakFields
-
-func (w weakFields) get(num pref.FieldNumber) (pref.ProtoMessage, bool) {
- m, ok := w[int32(num)]
- return m, ok
-}
-
-func (w *weakFields) set(num pref.FieldNumber, m pref.ProtoMessage) {
- if *w == nil {
- *w = make(weakFields)
- }
- (*w)[int32(num)] = m
-}
-
-func (w *weakFields) clear(num pref.FieldNumber) {
- delete(*w, int32(num))
-}
-
-func (Export) HasWeak(w WeakFields, num pref.FieldNumber) bool {
- _, ok := w[int32(num)]
- return ok
-}
-
-func (Export) ClearWeak(w *WeakFields, num pref.FieldNumber) {
- delete(*w, int32(num))
-}
-
-func (Export) GetWeak(w WeakFields, num pref.FieldNumber, name pref.FullName) pref.ProtoMessage {
- if m, ok := w[int32(num)]; ok {
- return m
- }
- mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
- if mt == nil {
- panic(fmt.Sprintf("message %v for weak field is not linked in", name))
- }
- return mt.Zero().Interface()
-}
-
-func (Export) SetWeak(w *WeakFields, num pref.FieldNumber, name pref.FullName, m pref.ProtoMessage) {
- if m != nil {
- mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
- if mt == nil {
- panic(fmt.Sprintf("message %v for weak field is not linked in", name))
- }
- if mt != m.ProtoReflect().Type() {
- panic(fmt.Sprintf("invalid message type for weak field: got %T, want %T", m, mt.Zero().Interface()))
- }
- }
- if m == nil || !m.ProtoReflect().IsValid() {
- delete(*w, int32(num))
- return
- }
- if *w == nil {
- *w = make(weakFields)
- }
- (*w)[int32(num)] = m
-}
diff --git a/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go b/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go
deleted file mode 100644
index a3de1cf..0000000
--- a/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package mapsort provides sorted access to maps.
-package mapsort
-
-import (
- "sort"
-
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Range iterates over every map entry in sorted key order,
-// calling f for each key and value encountered.
-func Range(mapv protoreflect.Map, keyKind protoreflect.Kind, f func(protoreflect.MapKey, protoreflect.Value) bool) {
- var keys []protoreflect.MapKey
- mapv.Range(func(key protoreflect.MapKey, _ protoreflect.Value) bool {
- keys = append(keys, key)
- return true
- })
- sort.Slice(keys, func(i, j int) bool {
- switch keyKind {
- case protoreflect.BoolKind:
- return !keys[i].Bool() && keys[j].Bool()
- case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind,
- protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
- return keys[i].Int() < keys[j].Int()
- case protoreflect.Uint32Kind, protoreflect.Fixed32Kind,
- protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
- return keys[i].Uint() < keys[j].Uint()
- case protoreflect.StringKind:
- return keys[i].String() < keys[j].String()
- default:
- panic("invalid kind: " + keyKind.String())
- }
- })
- for _, key := range keys {
- if !f(key, mapv.Get(key)) {
- break
- }
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/pragma/pragma.go b/vendor/google.golang.org/protobuf/internal/pragma/pragma.go
deleted file mode 100644
index 49dc4fc..0000000
--- a/vendor/google.golang.org/protobuf/internal/pragma/pragma.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package pragma provides types that can be embedded into a struct to
-// statically enforce or prevent certain language properties.
-package pragma
-
-import "sync"
-
-// NoUnkeyedLiterals can be embedded in a struct to prevent unkeyed literals.
-type NoUnkeyedLiterals struct{}
-
-// DoNotImplement can be embedded in an interface to prevent trivial
-// implementations of the interface.
-//
-// This is useful to prevent unauthorized implementations of an interface
-// so that it can be extended in the future for any protobuf language changes.
-type DoNotImplement interface{ ProtoInternal(DoNotImplement) }
-
-// DoNotCompare can be embedded in a struct to prevent comparability.
-type DoNotCompare [0]func()
-
-// DoNotCopy can be embedded in a struct to help prevent shallow copies.
-// This does not rely on a Go language feature, but rather a special case
-// within the vet checker.
-//
-// See https://golang.org/issues/8005.
-type DoNotCopy [0]sync.Mutex
diff --git a/vendor/google.golang.org/protobuf/internal/set/ints.go b/vendor/google.golang.org/protobuf/internal/set/ints.go
deleted file mode 100644
index d3d7f89..0000000
--- a/vendor/google.golang.org/protobuf/internal/set/ints.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package set provides simple set data structures for uint64s.
-package set
-
-import "math/bits"
-
-// int64s represents a set of integers within the range of 0..63.
-type int64s uint64
-
-func (bs *int64s) Len() int {
- return bits.OnesCount64(uint64(*bs))
-}
-func (bs *int64s) Has(n uint64) bool {
- return uint64(*bs)&(uint64(1)<<n) > 0
-}
-func (bs *int64s) Set(n uint64) {
- *(*uint64)(bs) |= uint64(1) << n
-}
-func (bs *int64s) Clear(n uint64) {
- *(*uint64)(bs) &^= uint64(1) << n
-}
-
-// Ints represents a set of integers within the range of 0..math.MaxUint64.
-type Ints struct {
- lo int64s
- hi map[uint64]struct{}
-}
-
-func (bs *Ints) Len() int {
- return bs.lo.Len() + len(bs.hi)
-}
-func (bs *Ints) Has(n uint64) bool {
- if n < 64 {
- return bs.lo.Has(n)
- }
- _, ok := bs.hi[n]
- return ok
-}
-func (bs *Ints) Set(n uint64) {
- if n < 64 {
- bs.lo.Set(n)
- return
- }
- if bs.hi == nil {
- bs.hi = make(map[uint64]struct{})
- }
- bs.hi[n] = struct{}{}
-}
-func (bs *Ints) Clear(n uint64) {
- if n < 64 {
- bs.lo.Clear(n)
- return
- }
- delete(bs.hi, n)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings.go b/vendor/google.golang.org/protobuf/internal/strs/strings.go
deleted file mode 100644
index 0b74e76..0000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings.go
+++ /dev/null
@@ -1,196 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package strs provides string manipulation functionality specific to protobuf.
-package strs
-
-import (
- "go/token"
- "strings"
- "unicode"
- "unicode/utf8"
-
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// EnforceUTF8 reports whether to enforce strict UTF-8 validation.
-func EnforceUTF8(fd protoreflect.FieldDescriptor) bool {
- if flags.ProtoLegacy {
- if fd, ok := fd.(interface{ EnforceUTF8() bool }); ok {
- return fd.EnforceUTF8()
- }
- }
- return fd.Syntax() == protoreflect.Proto3
-}
-
-// GoCamelCase camel-cases a protobuf name for use as a Go identifier.
-//
-// If there is an interior underscore followed by a lower case letter,
-// drop the underscore and convert the letter to upper case.
-func GoCamelCase(s string) string {
- // Invariant: if the next letter is lower case, it must be converted
- // to upper case.
- // That is, we process a word at a time, where words are marked by _ or
- // upper case letter. Digits are treated as words.
- var b []byte
- for i := 0; i < len(s); i++ {
- c := s[i]
- switch {
- case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
- // Skip over '.' in ".{{lowercase}}".
- case c == '.':
- b = append(b, '_') // convert '.' to '_'
- case c == '_' && (i == 0 || s[i-1] == '.'):
- // Convert initial '_' to ensure we start with a capital letter.
- // Do the same for '_' after '.' to match historic behavior.
- b = append(b, 'X') // convert '_' to 'X'
- case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
- // Skip over '_' in "_{{lowercase}}".
- case isASCIIDigit(c):
- b = append(b, c)
- default:
- // Assume we have a letter now - if not, it's a bogus identifier.
- // The next word is a sequence of characters that must start upper case.
- if isASCIILower(c) {
- c -= 'a' - 'A' // convert lowercase to uppercase
- }
- b = append(b, c)
-
- // Accept lower case sequence that follows.
- for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
- b = append(b, s[i+1])
- }
- }
- }
- return string(b)
-}
-
-// GoSanitized converts a string to a valid Go identifier.
-func GoSanitized(s string) string {
- // Sanitize the input to the set of valid characters,
- // which must be '_' or be in the Unicode L or N categories.
- s = strings.Map(func(r rune) rune {
- if unicode.IsLetter(r) || unicode.IsDigit(r) {
- return r
- }
- return '_'
- }, s)
-
- // Prepend '_' in the event of a Go keyword conflict or if
- // the identifier is invalid (does not start in the Unicode L category).
- r, _ := utf8.DecodeRuneInString(s)
- if token.Lookup(s).IsKeyword() || !unicode.IsLetter(r) {
- return "_" + s
- }
- return s
-}
-
-// JSONCamelCase converts a snake_case identifier to a camelCase identifier,
-// according to the protobuf JSON specification.
-func JSONCamelCase(s string) string {
- var b []byte
- var wasUnderscore bool
- for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
- c := s[i]
- if c != '_' {
- if wasUnderscore && isASCIILower(c) {
- c -= 'a' - 'A' // convert to uppercase
- }
- b = append(b, c)
- }
- wasUnderscore = c == '_'
- }
- return string(b)
-}
-
-// JSONSnakeCase converts a camelCase identifier to a snake_case identifier,
-// according to the protobuf JSON specification.
-func JSONSnakeCase(s string) string {
- var b []byte
- for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
- c := s[i]
- if isASCIIUpper(c) {
- b = append(b, '_')
- c += 'a' - 'A' // convert to lowercase
- }
- b = append(b, c)
- }
- return string(b)
-}
-
-// MapEntryName derives the name of the map entry message given the field name.
-// See protoc v3.8.0: src/google/protobuf/descriptor.cc:254-276,6057
-func MapEntryName(s string) string {
- var b []byte
- upperNext := true
- for _, c := range s {
- switch {
- case c == '_':
- upperNext = true
- case upperNext:
- b = append(b, byte(unicode.ToUpper(c)))
- upperNext = false
- default:
- b = append(b, byte(c))
- }
- }
- b = append(b, "Entry"...)
- return string(b)
-}
-
-// EnumValueName derives the camel-cased enum value name.
-// See protoc v3.8.0: src/google/protobuf/descriptor.cc:297-313
-func EnumValueName(s string) string {
- var b []byte
- upperNext := true
- for _, c := range s {
- switch {
- case c == '_':
- upperNext = true
- case upperNext:
- b = append(b, byte(unicode.ToUpper(c)))
- upperNext = false
- default:
- b = append(b, byte(unicode.ToLower(c)))
- upperNext = false
- }
- }
- return string(b)
-}
-
-// TrimEnumPrefix trims the enum name prefix from an enum value name,
-// where the prefix is all lowercase without underscores.
-// See protoc v3.8.0: src/google/protobuf/descriptor.cc:330-375
-func TrimEnumPrefix(s, prefix string) string {
- s0 := s // original input
- for len(s) > 0 && len(prefix) > 0 {
- if s[0] == '_' {
- s = s[1:]
- continue
- }
- if unicode.ToLower(rune(s[0])) != rune(prefix[0]) {
- return s0 // no prefix match
- }
- s, prefix = s[1:], prefix[1:]
- }
- if len(prefix) > 0 {
- return s0 // no prefix match
- }
- s = strings.TrimLeft(s, "_")
- if len(s) == 0 {
- return s0 // avoid returning empty string
- }
- return s
-}
-
-func isASCIILower(c byte) bool {
- return 'a' <= c && c <= 'z'
-}
-func isASCIIUpper(c byte) bool {
- return 'A' <= c && c <= 'Z'
-}
-func isASCIIDigit(c byte) bool {
- return '0' <= c && c <= '9'
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go b/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
deleted file mode 100644
index 85e074c..0000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package strs
-
-import pref "google.golang.org/protobuf/reflect/protoreflect"
-
-func UnsafeString(b []byte) string {
- return string(b)
-}
-
-func UnsafeBytes(s string) []byte {
- return []byte(s)
-}
-
-type Builder struct{}
-
-func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
- return prefix.Append(name)
-}
-
-func (*Builder) MakeString(b []byte) string {
- return string(b)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go
deleted file mode 100644
index 2160c70..0000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package strs
-
-import (
- "unsafe"
-
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type (
- stringHeader struct {
- Data unsafe.Pointer
- Len int
- }
- sliceHeader struct {
- Data unsafe.Pointer
- Len int
- Cap int
- }
-)
-
-// UnsafeString returns an unsafe string reference of b.
-// The caller must treat the input slice as immutable.
-//
-// WARNING: Use carefully. The returned result must not leak to the end user
-// unless the input slice is provably immutable.
-func UnsafeString(b []byte) (s string) {
- src := (*sliceHeader)(unsafe.Pointer(&b))
- dst := (*stringHeader)(unsafe.Pointer(&s))
- dst.Data = src.Data
- dst.Len = src.Len
- return s
-}
-
-// UnsafeBytes returns an unsafe bytes slice reference of s.
-// The caller must treat returned slice as immutable.
-//
-// WARNING: Use carefully. The returned result must not leak to the end user.
-func UnsafeBytes(s string) (b []byte) {
- src := (*stringHeader)(unsafe.Pointer(&s))
- dst := (*sliceHeader)(unsafe.Pointer(&b))
- dst.Data = src.Data
- dst.Len = src.Len
- dst.Cap = src.Len
- return b
-}
-
-// Builder builds a set of strings with shared lifetime.
-// This differs from strings.Builder, which is for building a single string.
-type Builder struct {
- buf []byte
-}
-
-// AppendFullName is equivalent to protoreflect.FullName.Append,
-// but optimized for large batches where each name has a shared lifetime.
-func (sb *Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
- n := len(prefix) + len(".") + len(name)
- if len(prefix) == 0 {
- n -= len(".")
- }
- sb.grow(n)
- sb.buf = append(sb.buf, prefix...)
- sb.buf = append(sb.buf, '.')
- sb.buf = append(sb.buf, name...)
- return pref.FullName(sb.last(n))
-}
-
-// MakeString is equivalent to string(b), but optimized for large batches
-// with a shared lifetime.
-func (sb *Builder) MakeString(b []byte) string {
- sb.grow(len(b))
- sb.buf = append(sb.buf, b...)
- return sb.last(len(b))
-}
-
-func (sb *Builder) grow(n int) {
- if cap(sb.buf)-len(sb.buf) >= n {
- return
- }
-
- // Unlike strings.Builder, we do not need to copy over the contents
- // of the old buffer since our builder provides no API for
- // retrieving previously created strings.
- sb.buf = make([]byte, 2*(cap(sb.buf)+n))
-}
-
-func (sb *Builder) last(n int) string {
- return UnsafeString(sb.buf[len(sb.buf)-n:])
-}
diff --git a/vendor/google.golang.org/protobuf/internal/version/version.go b/vendor/google.golang.org/protobuf/internal/version/version.go
deleted file mode 100644
index 4088e59..0000000
--- a/vendor/google.golang.org/protobuf/internal/version/version.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package version records versioning information about this module.
-package version
-
-import (
- "fmt"
- "strings"
-)
-
-// These constants determine the current version of this module.
-//
-//
-// For our release process, we enforce the following rules:
-// * Tagged releases use a tag that is identical to String.
-// * Tagged releases never reference a commit where the String
-// contains "devel".
-// * The set of all commits in this repository where String
-// does not contain "devel" must have a unique String.
-//
-//
-// Steps for tagging a new release:
-// 1. Create a new CL.
-//
-// 2. Update Minor, Patch, and/or PreRelease as necessary.
-// PreRelease must not contain the string "devel".
-//
-// 3. Since the last released minor version, have there been any changes to
-// generator that relies on new functionality in the runtime?
-// If yes, then increment RequiredGenerated.
-//
-// 4. Since the last released minor version, have there been any changes to
-// the runtime that removes support for old .pb.go source code?
-// If yes, then increment SupportMinimum.
-//
-// 5. Send out the CL for review and submit it.
-// Note that the next CL in step 8 must be submitted after this CL
-// without any other CLs in-between.
-//
-// 6. Tag a new version, where the tag is is the current String.
-//
-// 7. Write release notes for all notable changes
-// between this release and the last release.
-//
-// 8. Create a new CL.
-//
-// 9. Update PreRelease to include the string "devel".
-// For example: "" -> "devel" or "rc.1" -> "rc.1.devel"
-//
-// 10. Send out the CL for review and submit it.
-const (
- Major = 1
- Minor = 23
- Patch = 0
- PreRelease = ""
-)
-
-// String formats the version string for this module in semver format.
-//
-// Examples:
-// v1.20.1
-// v1.21.0-rc.1
-func String() string {
- v := fmt.Sprintf("v%d.%d.%d", Major, Minor, Patch)
- if PreRelease != "" {
- v += "-" + PreRelease
-
- // TODO: Add metadata about the commit or build hash.
- // See https://golang.org/issue/29814
- // See https://golang.org/issue/33533
- var metadata string
- if strings.Contains(PreRelease, "devel") && metadata != "" {
- v += "+" + metadata
- }
- }
- return v
-}
diff --git a/vendor/google.golang.org/protobuf/proto/checkinit.go b/vendor/google.golang.org/protobuf/proto/checkinit.go
deleted file mode 100644
index 3e9a6a2..0000000
--- a/vendor/google.golang.org/protobuf/proto/checkinit.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// CheckInitialized returns an error if any required fields in m are not set.
-func CheckInitialized(m Message) error {
- // Treat a nil message interface as an "untyped" empty message,
- // which we assume to have no required fields.
- if m == nil {
- return nil
- }
-
- return checkInitialized(m.ProtoReflect())
-}
-
-// CheckInitialized returns an error if any required fields in m are not set.
-func checkInitialized(m protoreflect.Message) error {
- if methods := protoMethods(m); methods != nil && methods.CheckInitialized != nil {
- _, err := methods.CheckInitialized(protoiface.CheckInitializedInput{
- Message: m,
- })
- return err
- }
- return checkInitializedSlow(m)
-}
-
-func checkInitializedSlow(m protoreflect.Message) error {
- md := m.Descriptor()
- fds := md.Fields()
- for i, nums := 0, md.RequiredNumbers(); i < nums.Len(); i++ {
- fd := fds.ByNumber(nums.Get(i))
- if !m.Has(fd) {
- return errors.RequiredNotSet(string(fd.FullName()))
- }
- }
- var err error
- m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- switch {
- case fd.IsList():
- if fd.Message() == nil {
- return true
- }
- for i, list := 0, v.List(); i < list.Len() && err == nil; i++ {
- err = checkInitialized(list.Get(i).Message())
- }
- case fd.IsMap():
- if fd.MapValue().Message() == nil {
- return true
- }
- v.Map().Range(func(key protoreflect.MapKey, v protoreflect.Value) bool {
- err = checkInitialized(v.Message())
- return err == nil
- })
- default:
- if fd.Message() == nil {
- return true
- }
- err = checkInitialized(v.Message())
- }
- return err == nil
- })
- return err
-}
diff --git a/vendor/google.golang.org/protobuf/proto/decode.go b/vendor/google.golang.org/protobuf/proto/decode.go
deleted file mode 100644
index 1282147..0000000
--- a/vendor/google.golang.org/protobuf/proto/decode.go
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// UnmarshalOptions configures the unmarshaler.
-//
-// Example usage:
-// err := UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, m)
-type UnmarshalOptions struct {
- pragma.NoUnkeyedLiterals
-
- // Merge merges the input into the destination message.
- // The default behavior is to always reset the message before unmarshaling,
- // unless Merge is specified.
- Merge bool
-
- // AllowPartial accepts input for messages that will result in missing
- // required fields. If AllowPartial is false (the default), Unmarshal will
- // return an error if there are any missing required fields.
- AllowPartial bool
-
- // If DiscardUnknown is set, unknown fields are ignored.
- DiscardUnknown bool
-
- // Resolver is used for looking up types when unmarshaling extension fields.
- // If nil, this defaults to using protoregistry.GlobalTypes.
- Resolver interface {
- FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
- FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
- }
-}
-
-// Unmarshal parses the wire-format message in b and places the result in m.
-func Unmarshal(b []byte, m Message) error {
- _, err := UnmarshalOptions{}.unmarshal(b, m.ProtoReflect())
- return err
-}
-
-// Unmarshal parses the wire-format message in b and places the result in m.
-func (o UnmarshalOptions) Unmarshal(b []byte, m Message) error {
- _, err := o.unmarshal(b, m.ProtoReflect())
- return err
-}
-
-// UnmarshalState parses a wire-format message and places the result in m.
-//
-// This method permits fine-grained control over the unmarshaler.
-// Most users should use Unmarshal instead.
-func (o UnmarshalOptions) UnmarshalState(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
- return o.unmarshal(in.Buf, in.Message)
-}
-
-func (o UnmarshalOptions) unmarshal(b []byte, m protoreflect.Message) (out protoiface.UnmarshalOutput, err error) {
- if o.Resolver == nil {
- o.Resolver = protoregistry.GlobalTypes
- }
- if !o.Merge {
- Reset(m.Interface()) // TODO
- }
- allowPartial := o.AllowPartial
- o.Merge = true
- o.AllowPartial = true
- methods := protoMethods(m)
- if methods != nil && methods.Unmarshal != nil &&
- !(o.DiscardUnknown && methods.Flags&protoiface.SupportUnmarshalDiscardUnknown == 0) {
- in := protoiface.UnmarshalInput{
- Message: m,
- Buf: b,
- Resolver: o.Resolver,
- }
- if o.DiscardUnknown {
- in.Flags |= protoiface.UnmarshalDiscardUnknown
- }
- out, err = methods.Unmarshal(in)
- } else {
- err = o.unmarshalMessageSlow(b, m)
- }
- if err != nil {
- return out, err
- }
- if allowPartial || (out.Flags&protoiface.UnmarshalInitialized != 0) {
- return out, nil
- }
- return out, checkInitialized(m)
-}
-
-func (o UnmarshalOptions) unmarshalMessage(b []byte, m protoreflect.Message) error {
- _, err := o.unmarshal(b, m)
- return err
-}
-
-func (o UnmarshalOptions) unmarshalMessageSlow(b []byte, m protoreflect.Message) error {
- md := m.Descriptor()
- if messageset.IsMessageSet(md) {
- return unmarshalMessageSet(b, m, o)
- }
- fields := md.Fields()
- for len(b) > 0 {
- // Parse the tag (field number and wire type).
- num, wtyp, tagLen := protowire.ConsumeTag(b)
- if tagLen < 0 {
- return protowire.ParseError(tagLen)
- }
- if num > protowire.MaxValidNumber {
- return errors.New("invalid field number")
- }
-
- // Find the field descriptor for this field number.
- fd := fields.ByNumber(num)
- if fd == nil && md.ExtensionRanges().Has(num) {
- extType, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
- if err != nil && err != protoregistry.NotFound {
- return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
- }
- if extType != nil {
- fd = extType.TypeDescriptor()
- }
- }
- var err error
- if fd == nil {
- err = errUnknown
- } else if flags.ProtoLegacy {
- if fd.IsWeak() && fd.Message().IsPlaceholder() {
- err = errUnknown // weak referent is not linked in
- }
- }
-
- // Parse the field value.
- var valLen int
- switch {
- case err != nil:
- case fd.IsList():
- valLen, err = o.unmarshalList(b[tagLen:], wtyp, m.Mutable(fd).List(), fd)
- case fd.IsMap():
- valLen, err = o.unmarshalMap(b[tagLen:], wtyp, m.Mutable(fd).Map(), fd)
- default:
- valLen, err = o.unmarshalSingular(b[tagLen:], wtyp, m, fd)
- }
- if err != nil {
- if err != errUnknown {
- return err
- }
- valLen = protowire.ConsumeFieldValue(num, wtyp, b[tagLen:])
- if valLen < 0 {
- return protowire.ParseError(valLen)
- }
- if !o.DiscardUnknown {
- m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...))
- }
- }
- b = b[tagLen+valLen:]
- }
- return nil
-}
-
-func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp protowire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) {
- v, n, err := o.unmarshalScalar(b, wtyp, fd)
- if err != nil {
- return 0, err
- }
- switch fd.Kind() {
- case protoreflect.GroupKind, protoreflect.MessageKind:
- m2 := m.Mutable(fd).Message()
- if err := o.unmarshalMessage(v.Bytes(), m2); err != nil {
- return n, err
- }
- default:
- // Non-message scalars replace the previous value.
- m.Set(fd, v)
- }
- return n, nil
-}
-
-func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp protowire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) {
- if wtyp != protowire.BytesType {
- return 0, errUnknown
- }
- b, n = protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- var (
- keyField = fd.MapKey()
- valField = fd.MapValue()
- key protoreflect.Value
- val protoreflect.Value
- haveKey bool
- haveVal bool
- )
- switch valField.Kind() {
- case protoreflect.GroupKind, protoreflect.MessageKind:
- val = mapv.NewValue()
- }
- // Map entries are represented as a two-element message with fields
- // containing the key and value.
- for len(b) > 0 {
- num, wtyp, n := protowire.ConsumeTag(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- if num > protowire.MaxValidNumber {
- return 0, errors.New("invalid field number")
- }
- b = b[n:]
- err = errUnknown
- switch num {
- case 1:
- key, n, err = o.unmarshalScalar(b, wtyp, keyField)
- if err != nil {
- break
- }
- haveKey = true
- case 2:
- var v protoreflect.Value
- v, n, err = o.unmarshalScalar(b, wtyp, valField)
- if err != nil {
- break
- }
- switch valField.Kind() {
- case protoreflect.GroupKind, protoreflect.MessageKind:
- if err := o.unmarshalMessage(v.Bytes(), val.Message()); err != nil {
- return 0, err
- }
- default:
- val = v
- }
- haveVal = true
- }
- if err == errUnknown {
- n = protowire.ConsumeFieldValue(num, wtyp, b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- } else if err != nil {
- return 0, err
- }
- b = b[n:]
- }
- // Every map entry should have entries for key and value, but this is not strictly required.
- if !haveKey {
- key = keyField.Default()
- }
- if !haveVal {
- switch valField.Kind() {
- case protoreflect.GroupKind, protoreflect.MessageKind:
- default:
- val = valField.Default()
- }
- }
- mapv.Set(key.MapKey(), val)
- return n, nil
-}
-
-// errUnknown is used internally to indicate fields which should be added
-// to the unknown field set of a message. It is never returned from an exported
-// function.
-var errUnknown = errors.New("BUG: internal error (unknown)")
diff --git a/vendor/google.golang.org/protobuf/proto/decode_gen.go b/vendor/google.golang.org/protobuf/proto/decode_gen.go
deleted file mode 100644
index d6dc904..0000000
--- a/vendor/google.golang.org/protobuf/proto/decode_gen.go
+++ /dev/null
@@ -1,603 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
- "math"
- "unicode/utf8"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// unmarshalScalar decodes a value of the given kind.
-//
-// Message values are decoded into a []byte which aliases the input data.
-func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
- switch fd.Kind() {
- case protoreflect.BoolKind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
- case protoreflect.EnumKind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
- case protoreflect.Int32Kind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfInt32(int32(v)), n, nil
- case protoreflect.Sint32Kind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
- case protoreflect.Uint32Kind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfUint32(uint32(v)), n, nil
- case protoreflect.Int64Kind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfInt64(int64(v)), n, nil
- case protoreflect.Sint64Kind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
- case protoreflect.Uint64Kind:
- if wtyp != protowire.VarintType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfUint64(v), n, nil
- case protoreflect.Sfixed32Kind:
- if wtyp != protowire.Fixed32Type {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfInt32(int32(v)), n, nil
- case protoreflect.Fixed32Kind:
- if wtyp != protowire.Fixed32Type {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfUint32(uint32(v)), n, nil
- case protoreflect.FloatKind:
- if wtyp != protowire.Fixed32Type {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
- case protoreflect.Sfixed64Kind:
- if wtyp != protowire.Fixed64Type {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfInt64(int64(v)), n, nil
- case protoreflect.Fixed64Kind:
- if wtyp != protowire.Fixed64Type {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfUint64(v), n, nil
- case protoreflect.DoubleKind:
- if wtyp != protowire.Fixed64Type {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
- case protoreflect.StringKind:
- if wtyp != protowire.BytesType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
- return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
- }
- return protoreflect.ValueOfString(string(v)), n, nil
- case protoreflect.BytesKind:
- if wtyp != protowire.BytesType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
- case protoreflect.MessageKind:
- if wtyp != protowire.BytesType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfBytes(v), n, nil
- case protoreflect.GroupKind:
- if wtyp != protowire.StartGroupType {
- return val, 0, errUnknown
- }
- v, n := protowire.ConsumeGroup(fd.Number(), b)
- if n < 0 {
- return val, 0, protowire.ParseError(n)
- }
- return protoreflect.ValueOfBytes(v), n, nil
- default:
- return val, 0, errUnknown
- }
-}
-
-func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
- switch fd.Kind() {
- case protoreflect.BoolKind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
- return n, nil
- case protoreflect.EnumKind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
- return n, nil
- case protoreflect.Int32Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- return n, nil
- case protoreflect.Sint32Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
- return n, nil
- case protoreflect.Uint32Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- return n, nil
- case protoreflect.Int64Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- return n, nil
- case protoreflect.Sint64Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
- return n, nil
- case protoreflect.Uint64Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeVarint(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfUint64(v))
- }
- return n, nil
- }
- if wtyp != protowire.VarintType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeVarint(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint64(v))
- return n, nil
- case protoreflect.Sfixed32Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeFixed32(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- }
- return n, nil
- }
- if wtyp != protowire.Fixed32Type {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt32(int32(v)))
- return n, nil
- case protoreflect.Fixed32Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeFixed32(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- }
- return n, nil
- }
- if wtyp != protowire.Fixed32Type {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint32(uint32(v)))
- return n, nil
- case protoreflect.FloatKind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeFixed32(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
- }
- return n, nil
- }
- if wtyp != protowire.Fixed32Type {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeFixed32(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
- return n, nil
- case protoreflect.Sfixed64Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeFixed64(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- }
- return n, nil
- }
- if wtyp != protowire.Fixed64Type {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfInt64(int64(v)))
- return n, nil
- case protoreflect.Fixed64Kind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeFixed64(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfUint64(v))
- }
- return n, nil
- }
- if wtyp != protowire.Fixed64Type {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfUint64(v))
- return n, nil
- case protoreflect.DoubleKind:
- if wtyp == protowire.BytesType {
- buf, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- for len(buf) > 0 {
- v, n := protowire.ConsumeFixed64(buf)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- buf = buf[n:]
- list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
- }
- return n, nil
- }
- if wtyp != protowire.Fixed64Type {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeFixed64(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
- return n, nil
- case protoreflect.StringKind:
- if wtyp != protowire.BytesType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
- return 0, errors.InvalidUTF8(string(fd.FullName()))
- }
- list.Append(protoreflect.ValueOfString(string(v)))
- return n, nil
- case protoreflect.BytesKind:
- if wtyp != protowire.BytesType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
- return n, nil
- case protoreflect.MessageKind:
- if wtyp != protowire.BytesType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeBytes(b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- m := list.NewElement()
- if err := o.unmarshalMessage(v, m.Message()); err != nil {
- return 0, err
- }
- list.Append(m)
- return n, nil
- case protoreflect.GroupKind:
- if wtyp != protowire.StartGroupType {
- return 0, errUnknown
- }
- v, n := protowire.ConsumeGroup(fd.Number(), b)
- if n < 0 {
- return 0, protowire.ParseError(n)
- }
- m := list.NewElement()
- if err := o.unmarshalMessage(v, m.Message()); err != nil {
- return 0, err
- }
- list.Append(m)
- return n, nil
- default:
- return 0, errUnknown
- }
-}
-
-// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
-var emptyBuf [0]byte
diff --git a/vendor/google.golang.org/protobuf/proto/doc.go b/vendor/google.golang.org/protobuf/proto/doc.go
deleted file mode 100644
index c52d8c4..0000000
--- a/vendor/google.golang.org/protobuf/proto/doc.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package proto provides functions operating on protocol buffer messages.
-//
-// For documentation on protocol buffers in general, see:
-//
-// https://developers.google.com/protocol-buffers
-//
-// For a tutorial on using protocol buffers with Go, see:
-//
-// https://developers.google.com/protocol-buffers/docs/gotutorial
-//
-// For a guide to generated Go protocol buffer code, see:
-//
-// https://developers.google.com/protocol-buffers/docs/reference/go-generated
-//
-//
-// Binary serialization
-//
-// This package contains functions to convert to and from the wire format,
-// an efficient binary serialization of protocol buffers.
-//
-// • Size reports the size of a message in the wire format.
-//
-// • Marshal converts a message to the wire format.
-// The MarshalOptions type provides more control over wire marshaling.
-//
-// • Unmarshal converts a message from the wire format.
-// The UnmarshalOptions type provides more control over wire unmarshaling.
-//
-//
-// Basic message operations
-//
-// • Clone makes a deep copy of a message.
-//
-// • Merge merges the content of a message into another.
-//
-// • Equal compares two messages. For more control over comparisons
-// and detailed reporting of differences, see package
-// "google.golang.org/protobuf/testing/protocmp".
-//
-// • Reset clears the content of a message.
-//
-// • CheckInitialized reports whether all required fields in a message are set.
-//
-//
-// Optional scalar constructors
-//
-// The API for some generated messages represents optional scalar fields
-// as pointers to a value. For example, an optional string field has the
-// Go type *string.
-//
-// • Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, and String
-// take a value and return a pointer to a new instance of it,
-// to simplify construction of optional field values.
-//
-// Generated enum types usually have an Enum method which performs the
-// same operation.
-//
-// Optional scalar fields are only supported in proto2.
-//
-//
-// Extension accessors
-//
-// • HasExtension, GetExtension, SetExtension, and ClearExtension
-// access extension field values in a protocol buffer message.
-//
-// Extension fields are only supported in proto2.
-//
-//
-// Related packages
-//
-// • Package "google.golang.org/protobuf/encoding/protojson" converts messages to
-// and from JSON.
-//
-// • Package "google.golang.org/protobuf/encoding/prototext" converts messages to
-// and from the text format.
-//
-// • Package "google.golang.org/protobuf/reflect/protoreflect" provides a
-// reflection interface for protocol buffer data types.
-//
-// • Package "google.golang.org/protobuf/testing/protocmp" provides features
-// to compare protocol buffer messages with the "github.com/google/go-cmp/cmp"
-// package.
-//
-// • Package "google.golang.org/protobuf/types/dynamicpb" provides a dynamic
-// message type, suitable for working with messages where the protocol buffer
-// type is only known at runtime.
-//
-// This module contains additional packages for more specialized use cases.
-// Consult the individual package documentation for details.
-package proto
diff --git a/vendor/google.golang.org/protobuf/proto/encode.go b/vendor/google.golang.org/protobuf/proto/encode.go
deleted file mode 100644
index 456bfda..0000000
--- a/vendor/google.golang.org/protobuf/proto/encode.go
+++ /dev/null
@@ -1,343 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "sort"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/fieldsort"
- "google.golang.org/protobuf/internal/mapsort"
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// MarshalOptions configures the marshaler.
-//
-// Example usage:
-// b, err := MarshalOptions{Deterministic: true}.Marshal(m)
-type MarshalOptions struct {
- pragma.NoUnkeyedLiterals
-
- // AllowPartial allows messages that have missing required fields to marshal
- // without returning an error. If AllowPartial is false (the default),
- // Marshal will return an error if there are any missing required fields.
- AllowPartial bool
-
- // Deterministic controls whether the same message will always be
- // serialized to the same bytes within the same binary.
- //
- // Setting this option guarantees that repeated serialization of
- // the same message will return the same bytes, and that different
- // processes of the same binary (which may be executing on different
- // machines) will serialize equal messages to the same bytes.
- // It has no effect on the resulting size of the encoded message compared
- // to a non-deterministic marshal.
- //
- // Note that the deterministic serialization is NOT canonical across
- // languages. It is not guaranteed to remain stable over time. It is
- // unstable across different builds with schema changes due to unknown
- // fields. Users who need canonical serialization (e.g., persistent
- // storage in a canonical form, fingerprinting, etc.) must define
- // their own canonicalization specification and implement their own
- // serializer rather than relying on this API.
- //
- // If deterministic serialization is requested, map entries will be
- // sorted by keys in lexographical order. This is an implementation
- // detail and subject to change.
- Deterministic bool
-
- // UseCachedSize indicates that the result of a previous Size call
- // may be reused.
- //
- // Setting this option asserts that:
- //
- // 1. Size has previously been called on this message with identical
- // options (except for UseCachedSize itself).
- //
- // 2. The message and all its submessages have not changed in any
- // way since the Size call.
- //
- // If either of these invariants is violated,
- // the results are undefined and may include panics or corrupted output.
- //
- // Implementations MAY take this option into account to provide
- // better performance, but there is no guarantee that they will do so.
- // There is absolutely no guarantee that Size followed by Marshal with
- // UseCachedSize set will perform equivalently to Marshal alone.
- UseCachedSize bool
-}
-
-// Marshal returns the wire-format encoding of m.
-func Marshal(m Message) ([]byte, error) {
- // Treat nil message interface as an empty message; nothing to output.
- if m == nil {
- return nil, nil
- }
-
- out, err := MarshalOptions{}.marshal(nil, m.ProtoReflect())
- if len(out.Buf) == 0 && err == nil {
- out.Buf = emptyBytesForMessage(m)
- }
- return out.Buf, err
-}
-
-// Marshal returns the wire-format encoding of m.
-func (o MarshalOptions) Marshal(m Message) ([]byte, error) {
- // Treat nil message interface as an empty message; nothing to output.
- if m == nil {
- return nil, nil
- }
-
- out, err := o.marshal(nil, m.ProtoReflect())
- if len(out.Buf) == 0 && err == nil {
- out.Buf = emptyBytesForMessage(m)
- }
- return out.Buf, err
-}
-
-// emptyBytesForMessage returns a nil buffer if and only if m is invalid,
-// otherwise it returns a non-nil empty buffer.
-//
-// This is to assist the edge-case where user-code does the following:
-// m1.OptionalBytes, _ = proto.Marshal(m2)
-// where they expect the proto2 "optional_bytes" field to be populated
-// if any only if m2 is a valid message.
-func emptyBytesForMessage(m Message) []byte {
- if m == nil || !m.ProtoReflect().IsValid() {
- return nil
- }
- return emptyBuf[:]
-}
-
-// MarshalAppend appends the wire-format encoding of m to b,
-// returning the result.
-func (o MarshalOptions) MarshalAppend(b []byte, m Message) ([]byte, error) {
- // Treat nil message interface as an empty message; nothing to append.
- if m == nil {
- return b, nil
- }
-
- out, err := o.marshal(b, m.ProtoReflect())
- return out.Buf, err
-}
-
-// MarshalState returns the wire-format encoding of a message.
-//
-// This method permits fine-grained control over the marshaler.
-// Most users should use Marshal instead.
-func (o MarshalOptions) MarshalState(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
- return o.marshal(in.Buf, in.Message)
-}
-
-func (o MarshalOptions) marshal(b []byte, m protoreflect.Message) (out protoiface.MarshalOutput, err error) {
- allowPartial := o.AllowPartial
- o.AllowPartial = true
- if methods := protoMethods(m); methods != nil && methods.Marshal != nil &&
- !(o.Deterministic && methods.Flags&protoiface.SupportMarshalDeterministic == 0) {
- in := protoiface.MarshalInput{
- Message: m,
- Buf: b,
- }
- if o.Deterministic {
- in.Flags |= protoiface.MarshalDeterministic
- }
- if o.UseCachedSize {
- in.Flags |= protoiface.MarshalUseCachedSize
- }
- if methods.Size != nil {
- sout := methods.Size(protoiface.SizeInput{
- Message: m,
- Flags: in.Flags,
- })
- if cap(b) < len(b)+sout.Size {
- in.Buf = make([]byte, len(b), growcap(cap(b), len(b)+sout.Size))
- copy(in.Buf, b)
- }
- in.Flags |= protoiface.MarshalUseCachedSize
- }
- out, err = methods.Marshal(in)
- } else {
- out.Buf, err = o.marshalMessageSlow(b, m)
- }
- if err != nil {
- return out, err
- }
- if allowPartial {
- return out, nil
- }
- return out, checkInitialized(m)
-}
-
-func (o MarshalOptions) marshalMessage(b []byte, m protoreflect.Message) ([]byte, error) {
- out, err := o.marshal(b, m)
- return out.Buf, err
-}
-
-// growcap scales up the capacity of a slice.
-//
-// Given a slice with a current capacity of oldcap and a desired
-// capacity of wantcap, growcap returns a new capacity >= wantcap.
-//
-// The algorithm is mostly identical to the one used by append as of Go 1.14.
-func growcap(oldcap, wantcap int) (newcap int) {
- if wantcap > oldcap*2 {
- newcap = wantcap
- } else if oldcap < 1024 {
- // The Go 1.14 runtime takes this case when len(s) < 1024,
- // not when cap(s) < 1024. The difference doesn't seem
- // significant here.
- newcap = oldcap * 2
- } else {
- newcap = oldcap
- for 0 < newcap && newcap < wantcap {
- newcap += newcap / 4
- }
- if newcap <= 0 {
- newcap = wantcap
- }
- }
- return newcap
-}
-
-func (o MarshalOptions) marshalMessageSlow(b []byte, m protoreflect.Message) ([]byte, error) {
- if messageset.IsMessageSet(m.Descriptor()) {
- return marshalMessageSet(b, m, o)
- }
- // There are many choices for what order we visit fields in. The default one here
- // is chosen for reasonable efficiency and simplicity given the protoreflect API.
- // It is not deterministic, since Message.Range does not return fields in any
- // defined order.
- //
- // When using deterministic serialization, we sort the known fields.
- var err error
- o.rangeFields(m, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- b, err = o.marshalField(b, fd, v)
- return err == nil
- })
- if err != nil {
- return b, err
- }
- b = append(b, m.GetUnknown()...)
- return b, nil
-}
-
-// rangeFields visits fields in a defined order when deterministic serialization is enabled.
-func (o MarshalOptions) rangeFields(m protoreflect.Message, f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
- if !o.Deterministic {
- m.Range(f)
- return
- }
- var fds []protoreflect.FieldDescriptor
- m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
- fds = append(fds, fd)
- return true
- })
- sort.Slice(fds, func(a, b int) bool {
- return fieldsort.Less(fds[a], fds[b])
- })
- for _, fd := range fds {
- if !f(fd, m.Get(fd)) {
- break
- }
- }
-}
-
-func (o MarshalOptions) marshalField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) {
- switch {
- case fd.IsList():
- return o.marshalList(b, fd, value.List())
- case fd.IsMap():
- return o.marshalMap(b, fd, value.Map())
- default:
- b = protowire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
- return o.marshalSingular(b, fd, value)
- }
-}
-
-func (o MarshalOptions) marshalList(b []byte, fd protoreflect.FieldDescriptor, list protoreflect.List) ([]byte, error) {
- if fd.IsPacked() && list.Len() > 0 {
- b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
- b, pos := appendSpeculativeLength(b)
- for i, llen := 0, list.Len(); i < llen; i++ {
- var err error
- b, err = o.marshalSingular(b, fd, list.Get(i))
- if err != nil {
- return b, err
- }
- }
- b = finishSpeculativeLength(b, pos)
- return b, nil
- }
-
- kind := fd.Kind()
- for i, llen := 0, list.Len(); i < llen; i++ {
- var err error
- b = protowire.AppendTag(b, fd.Number(), wireTypes[kind])
- b, err = o.marshalSingular(b, fd, list.Get(i))
- if err != nil {
- return b, err
- }
- }
- return b, nil
-}
-
-func (o MarshalOptions) marshalMap(b []byte, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) ([]byte, error) {
- keyf := fd.MapKey()
- valf := fd.MapValue()
- var err error
- o.rangeMap(mapv, keyf.Kind(), func(key protoreflect.MapKey, value protoreflect.Value) bool {
- b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
- var pos int
- b, pos = appendSpeculativeLength(b)
-
- b, err = o.marshalField(b, keyf, key.Value())
- if err != nil {
- return false
- }
- b, err = o.marshalField(b, valf, value)
- if err != nil {
- return false
- }
- b = finishSpeculativeLength(b, pos)
- return true
- })
- return b, err
-}
-
-func (o MarshalOptions) rangeMap(mapv protoreflect.Map, kind protoreflect.Kind, f func(protoreflect.MapKey, protoreflect.Value) bool) {
- if !o.Deterministic {
- mapv.Range(f)
- return
- }
- mapsort.Range(mapv, kind, f)
-}
-
-// When encoding length-prefixed fields, we speculatively set aside some number of bytes
-// for the length, encode the data, and then encode the length (shifting the data if necessary
-// to make room).
-const speculativeLength = 1
-
-func appendSpeculativeLength(b []byte) ([]byte, int) {
- pos := len(b)
- b = append(b, "\x00\x00\x00\x00"[:speculativeLength]...)
- return b, pos
-}
-
-func finishSpeculativeLength(b []byte, pos int) []byte {
- mlen := len(b) - pos - speculativeLength
- msiz := protowire.SizeVarint(uint64(mlen))
- if msiz != speculativeLength {
- for i := 0; i < msiz-speculativeLength; i++ {
- b = append(b, 0)
- }
- copy(b[pos+msiz:], b[pos+speculativeLength:])
- b = b[:pos+msiz+mlen]
- }
- protowire.AppendVarint(b[:pos], uint64(mlen))
- return b
-}
diff --git a/vendor/google.golang.org/protobuf/proto/encode_gen.go b/vendor/google.golang.org/protobuf/proto/encode_gen.go
deleted file mode 100644
index 185dacf..0000000
--- a/vendor/google.golang.org/protobuf/proto/encode_gen.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
- "math"
- "unicode/utf8"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/strs"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var wireTypes = map[protoreflect.Kind]protowire.Type{
- protoreflect.BoolKind: protowire.VarintType,
- protoreflect.EnumKind: protowire.VarintType,
- protoreflect.Int32Kind: protowire.VarintType,
- protoreflect.Sint32Kind: protowire.VarintType,
- protoreflect.Uint32Kind: protowire.VarintType,
- protoreflect.Int64Kind: protowire.VarintType,
- protoreflect.Sint64Kind: protowire.VarintType,
- protoreflect.Uint64Kind: protowire.VarintType,
- protoreflect.Sfixed32Kind: protowire.Fixed32Type,
- protoreflect.Fixed32Kind: protowire.Fixed32Type,
- protoreflect.FloatKind: protowire.Fixed32Type,
- protoreflect.Sfixed64Kind: protowire.Fixed64Type,
- protoreflect.Fixed64Kind: protowire.Fixed64Type,
- protoreflect.DoubleKind: protowire.Fixed64Type,
- protoreflect.StringKind: protowire.BytesType,
- protoreflect.BytesKind: protowire.BytesType,
- protoreflect.MessageKind: protowire.BytesType,
- protoreflect.GroupKind: protowire.StartGroupType,
-}
-
-func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
- switch fd.Kind() {
- case protoreflect.BoolKind:
- b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
- case protoreflect.EnumKind:
- b = protowire.AppendVarint(b, uint64(v.Enum()))
- case protoreflect.Int32Kind:
- b = protowire.AppendVarint(b, uint64(int32(v.Int())))
- case protoreflect.Sint32Kind:
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
- case protoreflect.Uint32Kind:
- b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
- case protoreflect.Int64Kind:
- b = protowire.AppendVarint(b, uint64(v.Int()))
- case protoreflect.Sint64Kind:
- b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
- case protoreflect.Uint64Kind:
- b = protowire.AppendVarint(b, v.Uint())
- case protoreflect.Sfixed32Kind:
- b = protowire.AppendFixed32(b, uint32(v.Int()))
- case protoreflect.Fixed32Kind:
- b = protowire.AppendFixed32(b, uint32(v.Uint()))
- case protoreflect.FloatKind:
- b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
- case protoreflect.Sfixed64Kind:
- b = protowire.AppendFixed64(b, uint64(v.Int()))
- case protoreflect.Fixed64Kind:
- b = protowire.AppendFixed64(b, v.Uint())
- case protoreflect.DoubleKind:
- b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
- case protoreflect.StringKind:
- if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
- return b, errors.InvalidUTF8(string(fd.FullName()))
- }
- b = protowire.AppendString(b, v.String())
- case protoreflect.BytesKind:
- b = protowire.AppendBytes(b, v.Bytes())
- case protoreflect.MessageKind:
- var pos int
- var err error
- b, pos = appendSpeculativeLength(b)
- b, err = o.marshalMessage(b, v.Message())
- if err != nil {
- return b, err
- }
- b = finishSpeculativeLength(b, pos)
- case protoreflect.GroupKind:
- var err error
- b, err = o.marshalMessage(b, v.Message())
- if err != nil {
- return b, err
- }
- b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
- default:
- return b, errors.New("invalid kind %v", fd.Kind())
- }
- return b, nil
-}
diff --git a/vendor/google.golang.org/protobuf/proto/equal.go b/vendor/google.golang.org/protobuf/proto/equal.go
deleted file mode 100644
index 10902bd..0000000
--- a/vendor/google.golang.org/protobuf/proto/equal.go
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "bytes"
- "math"
- "reflect"
-
- "google.golang.org/protobuf/encoding/protowire"
- pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Equal reports whether two messages are equal.
-// If two messages marshal to the same bytes under deterministic serialization,
-// then Equal is guaranteed to report true.
-//
-// Two messages are equal if they belong to the same message descriptor,
-// have the same set of populated known and extension field values,
-// and the same set of unknown fields values. If either of the top-level
-// messages are invalid, then Equal reports true only if both are invalid.
-//
-// Scalar values are compared with the equivalent of the == operator in Go,
-// except bytes values which are compared using bytes.Equal and
-// floating point values which specially treat NaNs as equal.
-// Message values are compared by recursively calling Equal.
-// Lists are equal if each element value is also equal.
-// Maps are equal if they have the same set of keys, where the pair of values
-// for each key is also equal.
-func Equal(x, y Message) bool {
- if x == nil || y == nil {
- return x == nil && y == nil
- }
- mx := x.ProtoReflect()
- my := y.ProtoReflect()
- if mx.IsValid() != my.IsValid() {
- return false
- }
- return equalMessage(mx, my)
-}
-
-// equalMessage compares two messages.
-func equalMessage(mx, my pref.Message) bool {
- if mx.Descriptor() != my.Descriptor() {
- return false
- }
-
- nx := 0
- equal := true
- mx.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
- nx++
- vy := my.Get(fd)
- equal = my.Has(fd) && equalField(fd, vx, vy)
- return equal
- })
- if !equal {
- return false
- }
- ny := 0
- my.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
- ny++
- return true
- })
- if nx != ny {
- return false
- }
-
- return equalUnknown(mx.GetUnknown(), my.GetUnknown())
-}
-
-// equalField compares two fields.
-func equalField(fd pref.FieldDescriptor, x, y pref.Value) bool {
- switch {
- case fd.IsList():
- return equalList(fd, x.List(), y.List())
- case fd.IsMap():
- return equalMap(fd, x.Map(), y.Map())
- default:
- return equalValue(fd, x, y)
- }
-}
-
-// equalMap compares two maps.
-func equalMap(fd pref.FieldDescriptor, x, y pref.Map) bool {
- if x.Len() != y.Len() {
- return false
- }
- equal := true
- x.Range(func(k pref.MapKey, vx pref.Value) bool {
- vy := y.Get(k)
- equal = y.Has(k) && equalValue(fd.MapValue(), vx, vy)
- return equal
- })
- return equal
-}
-
-// equalList compares two lists.
-func equalList(fd pref.FieldDescriptor, x, y pref.List) bool {
- if x.Len() != y.Len() {
- return false
- }
- for i := x.Len() - 1; i >= 0; i-- {
- if !equalValue(fd, x.Get(i), y.Get(i)) {
- return false
- }
- }
- return true
-}
-
-// equalValue compares two singular values.
-func equalValue(fd pref.FieldDescriptor, x, y pref.Value) bool {
- switch {
- case fd.Message() != nil:
- return equalMessage(x.Message(), y.Message())
- case fd.Kind() == pref.BytesKind:
- return bytes.Equal(x.Bytes(), y.Bytes())
- case fd.Kind() == pref.FloatKind, fd.Kind() == pref.DoubleKind:
- fx := x.Float()
- fy := y.Float()
- if math.IsNaN(fx) || math.IsNaN(fy) {
- return math.IsNaN(fx) && math.IsNaN(fy)
- }
- return fx == fy
- default:
- return x.Interface() == y.Interface()
- }
-}
-
-// equalUnknown compares unknown fields by direct comparison on the raw bytes
-// of each individual field number.
-func equalUnknown(x, y pref.RawFields) bool {
- if len(x) != len(y) {
- return false
- }
- if bytes.Equal([]byte(x), []byte(y)) {
- return true
- }
-
- mx := make(map[pref.FieldNumber]pref.RawFields)
- my := make(map[pref.FieldNumber]pref.RawFields)
- for len(x) > 0 {
- fnum, _, n := protowire.ConsumeField(x)
- mx[fnum] = append(mx[fnum], x[:n]...)
- x = x[n:]
- }
- for len(y) > 0 {
- fnum, _, n := protowire.ConsumeField(y)
- my[fnum] = append(my[fnum], y[:n]...)
- y = y[n:]
- }
- return reflect.DeepEqual(mx, my)
-}
diff --git a/vendor/google.golang.org/protobuf/proto/extension.go b/vendor/google.golang.org/protobuf/proto/extension.go
deleted file mode 100644
index 5f293cd..0000000
--- a/vendor/google.golang.org/protobuf/proto/extension.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// HasExtension reports whether an extension field is populated.
-// It returns false if m is invalid or if xt does not extend m.
-func HasExtension(m Message, xt protoreflect.ExtensionType) bool {
- // Treat nil message interface as an empty message; no populated fields.
- if m == nil {
- return false
- }
-
- // As a special-case, we reports invalid or mismatching descriptors
- // as always not being populated (since they aren't).
- if xt == nil || m.ProtoReflect().Descriptor() != xt.TypeDescriptor().ContainingMessage() {
- return false
- }
-
- return m.ProtoReflect().Has(xt.TypeDescriptor())
-}
-
-// ClearExtension clears an extension field such that subsequent
-// HasExtension calls return false.
-// It panics if m is invalid or if xt does not extend m.
-func ClearExtension(m Message, xt protoreflect.ExtensionType) {
- m.ProtoReflect().Clear(xt.TypeDescriptor())
-}
-
-// GetExtension retrieves the value for an extension field.
-// If the field is unpopulated, it returns the default value for
-// scalars and an immutable, empty value for lists or messages.
-// It panics if xt does not extend m.
-func GetExtension(m Message, xt protoreflect.ExtensionType) interface{} {
- // Treat nil message interface as an empty message; return the default.
- if m == nil {
- return xt.InterfaceOf(xt.Zero())
- }
-
- return xt.InterfaceOf(m.ProtoReflect().Get(xt.TypeDescriptor()))
-}
-
-// SetExtension stores the value of an extension field.
-// It panics if m is invalid, xt does not extend m, or if type of v
-// is invalid for the specified extension field.
-func SetExtension(m Message, xt protoreflect.ExtensionType, v interface{}) {
- xd := xt.TypeDescriptor()
- pv := xt.ValueOf(v)
-
- // Specially treat an invalid list, map, or message as clear.
- isValid := true
- switch {
- case xd.IsList():
- isValid = pv.List().IsValid()
- case xd.IsMap():
- isValid = pv.Map().IsValid()
- case xd.Message() != nil:
- isValid = pv.Message().IsValid()
- }
- if !isValid {
- m.ProtoReflect().Clear(xd)
- return
- }
-
- m.ProtoReflect().Set(xd, pv)
-}
-
-// RangeExtensions iterates over every populated extension field in m in an
-// undefined order, calling f for each extension type and value encountered.
-// It returns immediately if f returns false.
-// While iterating, mutating operations may only be performed
-// on the current extension field.
-func RangeExtensions(m Message, f func(protoreflect.ExtensionType, interface{}) bool) {
- // Treat nil message interface as an empty message; nothing to range over.
- if m == nil {
- return
- }
-
- m.ProtoReflect().Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- if fd.IsExtension() {
- xt := fd.(protoreflect.ExtensionTypeDescriptor).Type()
- vi := xt.InterfaceOf(v)
- return f(xt, vi)
- }
- return true
- })
-}
diff --git a/vendor/google.golang.org/protobuf/proto/merge.go b/vendor/google.golang.org/protobuf/proto/merge.go
deleted file mode 100644
index d761ab3..0000000
--- a/vendor/google.golang.org/protobuf/proto/merge.go
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "fmt"
-
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Merge merges src into dst, which must be a message with the same descriptor.
-//
-// Populated scalar fields in src are copied to dst, while populated
-// singular messages in src are merged into dst by recursively calling Merge.
-// The elements of every list field in src is appended to the corresponded
-// list fields in dst. The entries of every map field in src is copied into
-// the corresponding map field in dst, possibly replacing existing entries.
-// The unknown fields of src are appended to the unknown fields of dst.
-//
-// It is semantically equivalent to unmarshaling the encoded form of src
-// into dst with the UnmarshalOptions.Merge option specified.
-func Merge(dst, src Message) {
- // TODO: Should nil src be treated as semantically equivalent to a
- // untyped, read-only, empty message? What about a nil dst?
-
- dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
- if dstMsg.Descriptor() != srcMsg.Descriptor() {
- if got, want := dstMsg.Descriptor().FullName(), srcMsg.Descriptor().FullName(); got != want {
- panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
- }
- panic("descriptor mismatch")
- }
- mergeOptions{}.mergeMessage(dstMsg, srcMsg)
-}
-
-// Clone returns a deep copy of m.
-// If the top-level message is invalid, it returns an invalid message as well.
-func Clone(m Message) Message {
- // NOTE: Most usages of Clone assume the following properties:
- // t := reflect.TypeOf(m)
- // t == reflect.TypeOf(m.ProtoReflect().New().Interface())
- // t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
- //
- // Embedding protobuf messages breaks this since the parent type will have
- // a forwarded ProtoReflect method, but the Interface method will return
- // the underlying embedded message type.
- if m == nil {
- return nil
- }
- src := m.ProtoReflect()
- if !src.IsValid() {
- return src.Type().Zero().Interface()
- }
- dst := src.New()
- mergeOptions{}.mergeMessage(dst, src)
- return dst.Interface()
-}
-
-// mergeOptions provides a namespace for merge functions, and can be
-// exported in the future if we add user-visible merge options.
-type mergeOptions struct{}
-
-func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
- methods := protoMethods(dst)
- if methods != nil && methods.Merge != nil {
- in := protoiface.MergeInput{
- Destination: dst,
- Source: src,
- }
- out := methods.Merge(in)
- if out.Flags&protoiface.MergeComplete != 0 {
- return
- }
- }
-
- if !dst.IsValid() {
- panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
- }
-
- src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- switch {
- case fd.IsList():
- o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
- case fd.IsMap():
- o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
- case fd.Message() != nil:
- o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
- case fd.Kind() == protoreflect.BytesKind:
- dst.Set(fd, o.cloneBytes(v))
- default:
- dst.Set(fd, v)
- }
- return true
- })
-
- if len(src.GetUnknown()) > 0 {
- dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
- }
-}
-
-func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
- // Merge semantics appends to the end of the existing list.
- for i, n := 0, src.Len(); i < n; i++ {
- switch v := src.Get(i); {
- case fd.Message() != nil:
- dstv := dst.NewElement()
- o.mergeMessage(dstv.Message(), v.Message())
- dst.Append(dstv)
- case fd.Kind() == protoreflect.BytesKind:
- dst.Append(o.cloneBytes(v))
- default:
- dst.Append(v)
- }
- }
-}
-
-func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
- // Merge semantics replaces, rather than merges into existing entries.
- src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
- switch {
- case fd.Message() != nil:
- dstv := dst.NewValue()
- o.mergeMessage(dstv.Message(), v.Message())
- dst.Set(k, dstv)
- case fd.Kind() == protoreflect.BytesKind:
- dst.Set(k, o.cloneBytes(v))
- default:
- dst.Set(k, v)
- }
- return true
- })
-}
-
-func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
- return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
-}
diff --git a/vendor/google.golang.org/protobuf/proto/messageset.go b/vendor/google.golang.org/protobuf/proto/messageset.go
deleted file mode 100644
index b6b3de5..0000000
--- a/vendor/google.golang.org/protobuf/proto/messageset.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/internal/flags"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-func sizeMessageSet(m protoreflect.Message) (size int) {
- m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- size += messageset.SizeField(fd.Number())
- size += protowire.SizeTag(messageset.FieldMessage)
- size += protowire.SizeBytes(sizeMessage(v.Message()))
- return true
- })
- size += messageset.SizeUnknown(m.GetUnknown())
- return size
-}
-
-func marshalMessageSet(b []byte, m protoreflect.Message, o MarshalOptions) ([]byte, error) {
- if !flags.ProtoLegacy {
- return b, errors.New("no support for message_set_wire_format")
- }
- var err error
- o.rangeFields(m, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- b, err = marshalMessageSetField(b, fd, v, o)
- return err == nil
- })
- if err != nil {
- return b, err
- }
- return messageset.AppendUnknown(b, m.GetUnknown())
-}
-
-func marshalMessageSetField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value, o MarshalOptions) ([]byte, error) {
- b = messageset.AppendFieldStart(b, fd.Number())
- b = protowire.AppendTag(b, messageset.FieldMessage, protowire.BytesType)
- b = protowire.AppendVarint(b, uint64(o.Size(value.Message().Interface())))
- b, err := o.marshalMessage(b, value.Message())
- if err != nil {
- return b, err
- }
- b = messageset.AppendFieldEnd(b)
- return b, nil
-}
-
-func unmarshalMessageSet(b []byte, m protoreflect.Message, o UnmarshalOptions) error {
- if !flags.ProtoLegacy {
- return errors.New("no support for message_set_wire_format")
- }
- return messageset.Unmarshal(b, false, func(num protowire.Number, v []byte) error {
- err := unmarshalMessageSetField(m, num, v, o)
- if err == errUnknown {
- unknown := m.GetUnknown()
- unknown = protowire.AppendTag(unknown, num, protowire.BytesType)
- unknown = protowire.AppendBytes(unknown, v)
- m.SetUnknown(unknown)
- return nil
- }
- return err
- })
-}
-
-func unmarshalMessageSetField(m protoreflect.Message, num protowire.Number, v []byte, o UnmarshalOptions) error {
- md := m.Descriptor()
- if !md.ExtensionRanges().Has(num) {
- return errUnknown
- }
- xt, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
- if err == protoregistry.NotFound {
- return errUnknown
- }
- if err != nil {
- return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
- }
- xd := xt.TypeDescriptor()
- if err := o.unmarshalMessage(v, m.Mutable(xd).Message()); err != nil {
- return err
- }
- return nil
-}
diff --git a/vendor/google.golang.org/protobuf/proto/proto.go b/vendor/google.golang.org/protobuf/proto/proto.go
deleted file mode 100644
index ca14b09..0000000
--- a/vendor/google.golang.org/protobuf/proto/proto.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Message is the top-level interface that all messages must implement.
-// It provides access to a reflective view of a message.
-// Any implementation of this interface may be used with all functions in the
-// protobuf module that accept a Message, except where otherwise specified.
-//
-// This is the v2 interface definition for protobuf messages.
-// The v1 interface definition is "github.com/golang/protobuf/proto".Message.
-//
-// To convert a v1 message to a v2 message,
-// use "github.com/golang/protobuf/proto".MessageV2.
-// To convert a v2 message to a v1 message,
-// use "github.com/golang/protobuf/proto".MessageV1.
-type Message = protoreflect.ProtoMessage
-
-// Error matches all errors produced by packages in the protobuf module.
-//
-// That is, errors.Is(err, Error) reports whether an error is produced
-// by this module.
-var Error error
-
-func init() {
- Error = errors.Error
-}
diff --git a/vendor/google.golang.org/protobuf/proto/proto_methods.go b/vendor/google.golang.org/protobuf/proto/proto_methods.go
deleted file mode 100644
index d8dd604..0000000
--- a/vendor/google.golang.org/protobuf/proto/proto_methods.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The protoreflect build tag disables use of fast-path methods.
-// +build !protoreflect
-
-package proto
-
-import (
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-const hasProtoMethods = true
-
-func protoMethods(m protoreflect.Message) *protoiface.Methods {
- return m.ProtoMethods()
-}
diff --git a/vendor/google.golang.org/protobuf/proto/proto_reflect.go b/vendor/google.golang.org/protobuf/proto/proto_reflect.go
deleted file mode 100644
index b103d43..0000000
--- a/vendor/google.golang.org/protobuf/proto/proto_reflect.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The protoreflect build tag disables use of fast-path methods.
-// +build protoreflect
-
-package proto
-
-import (
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-const hasProtoMethods = false
-
-func protoMethods(m protoreflect.Message) *protoiface.Methods {
- return nil
-}
diff --git a/vendor/google.golang.org/protobuf/proto/reset.go b/vendor/google.golang.org/protobuf/proto/reset.go
deleted file mode 100644
index 3d7f894..0000000
--- a/vendor/google.golang.org/protobuf/proto/reset.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "fmt"
-
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Reset clears every field in the message.
-// The resulting message shares no observable memory with its previous state
-// other than the memory for the message itself.
-func Reset(m Message) {
- if mr, ok := m.(interface{ Reset() }); ok && hasProtoMethods {
- mr.Reset()
- return
- }
- resetMessage(m.ProtoReflect())
-}
-
-func resetMessage(m protoreflect.Message) {
- if !m.IsValid() {
- panic(fmt.Sprintf("cannot reset invalid %v message", m.Descriptor().FullName()))
- }
-
- // Clear all known fields.
- fds := m.Descriptor().Fields()
- for i := 0; i < fds.Len(); i++ {
- m.Clear(fds.Get(i))
- }
-
- // Clear extension fields.
- m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
- m.Clear(fd)
- return true
- })
-
- // Clear unknown fields.
- m.SetUnknown(nil)
-}
diff --git a/vendor/google.golang.org/protobuf/proto/size.go b/vendor/google.golang.org/protobuf/proto/size.go
deleted file mode 100644
index 11ba841..0000000
--- a/vendor/google.golang.org/protobuf/proto/size.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/encoding/messageset"
- "google.golang.org/protobuf/reflect/protoreflect"
- "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Size returns the size in bytes of the wire-format encoding of m.
-func Size(m Message) int {
- return MarshalOptions{}.Size(m)
-}
-
-// Size returns the size in bytes of the wire-format encoding of m.
-func (o MarshalOptions) Size(m Message) int {
- // Treat a nil message interface as an empty message; nothing to output.
- if m == nil {
- return 0
- }
-
- return sizeMessage(m.ProtoReflect())
-}
-
-func sizeMessage(m protoreflect.Message) (size int) {
- methods := protoMethods(m)
- if methods != nil && methods.Size != nil {
- out := methods.Size(protoiface.SizeInput{
- Message: m,
- })
- return out.Size
- }
- if methods != nil && methods.Marshal != nil {
- // This is not efficient, but we don't have any choice.
- // This case is mainly used for legacy types with a Marshal method.
- out, _ := methods.Marshal(protoiface.MarshalInput{
- Message: m,
- })
- return len(out.Buf)
- }
- return sizeMessageSlow(m)
-}
-
-func sizeMessageSlow(m protoreflect.Message) (size int) {
- if messageset.IsMessageSet(m.Descriptor()) {
- return sizeMessageSet(m)
- }
- m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
- size += sizeField(fd, v)
- return true
- })
- size += len(m.GetUnknown())
- return size
-}
-
-func sizeField(fd protoreflect.FieldDescriptor, value protoreflect.Value) (size int) {
- num := fd.Number()
- switch {
- case fd.IsList():
- return sizeList(num, fd, value.List())
- case fd.IsMap():
- return sizeMap(num, fd, value.Map())
- default:
- return protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), value)
- }
-}
-
-func sizeList(num protowire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
- if fd.IsPacked() && list.Len() > 0 {
- content := 0
- for i, llen := 0, list.Len(); i < llen; i++ {
- content += sizeSingular(num, fd.Kind(), list.Get(i))
- }
- return protowire.SizeTag(num) + protowire.SizeBytes(content)
- }
-
- for i, llen := 0, list.Len(); i < llen; i++ {
- size += protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), list.Get(i))
- }
- return size
-}
-
-func sizeMap(num protowire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
- mapv.Range(func(key protoreflect.MapKey, value protoreflect.Value) bool {
- size += protowire.SizeTag(num)
- size += protowire.SizeBytes(sizeField(fd.MapKey(), key.Value()) + sizeField(fd.MapValue(), value))
- return true
- })
- return size
-}
diff --git a/vendor/google.golang.org/protobuf/proto/size_gen.go b/vendor/google.golang.org/protobuf/proto/size_gen.go
deleted file mode 100644
index 1118460..0000000
--- a/vendor/google.golang.org/protobuf/proto/size_gen.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
- switch kind {
- case protoreflect.BoolKind:
- return protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
- case protoreflect.EnumKind:
- return protowire.SizeVarint(uint64(v.Enum()))
- case protoreflect.Int32Kind:
- return protowire.SizeVarint(uint64(int32(v.Int())))
- case protoreflect.Sint32Kind:
- return protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
- case protoreflect.Uint32Kind:
- return protowire.SizeVarint(uint64(uint32(v.Uint())))
- case protoreflect.Int64Kind:
- return protowire.SizeVarint(uint64(v.Int()))
- case protoreflect.Sint64Kind:
- return protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
- case protoreflect.Uint64Kind:
- return protowire.SizeVarint(v.Uint())
- case protoreflect.Sfixed32Kind:
- return protowire.SizeFixed32()
- case protoreflect.Fixed32Kind:
- return protowire.SizeFixed32()
- case protoreflect.FloatKind:
- return protowire.SizeFixed32()
- case protoreflect.Sfixed64Kind:
- return protowire.SizeFixed64()
- case protoreflect.Fixed64Kind:
- return protowire.SizeFixed64()
- case protoreflect.DoubleKind:
- return protowire.SizeFixed64()
- case protoreflect.StringKind:
- return protowire.SizeBytes(len(v.String()))
- case protoreflect.BytesKind:
- return protowire.SizeBytes(len(v.Bytes()))
- case protoreflect.MessageKind:
- return protowire.SizeBytes(sizeMessage(v.Message()))
- case protoreflect.GroupKind:
- return protowire.SizeGroup(num, sizeMessage(v.Message()))
- default:
- return 0
- }
-}
diff --git a/vendor/google.golang.org/protobuf/proto/wrappers.go b/vendor/google.golang.org/protobuf/proto/wrappers.go
deleted file mode 100644
index 653b12c..0000000
--- a/vendor/google.golang.org/protobuf/proto/wrappers.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-// Bool stores v in a new bool value and returns a pointer to it.
-func Bool(v bool) *bool { return &v }
-
-// Int32 stores v in a new int32 value and returns a pointer to it.
-func Int32(v int32) *int32 { return &v }
-
-// Int64 stores v in a new int64 value and returns a pointer to it.
-func Int64(v int64) *int64 { return &v }
-
-// Float32 stores v in a new float32 value and returns a pointer to it.
-func Float32(v float32) *float32 { return &v }
-
-// Float64 stores v in a new float64 value and returns a pointer to it.
-func Float64(v float64) *float64 { return &v }
-
-// Uint32 stores v in a new uint32 value and returns a pointer to it.
-func Uint32(v uint32) *uint32 { return &v }
-
-// Uint64 stores v in a new uint64 value and returns a pointer to it.
-func Uint64(v uint64) *uint64 { return &v }
-
-// String stores v in a new string value and returns a pointer to it.
-func String(v string) *string { return &v }
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
deleted file mode 100644
index 6be5d16..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-import (
- "google.golang.org/protobuf/internal/pragma"
-)
-
-// The following types are used by the fast-path Message.ProtoMethods method.
-//
-// To avoid polluting the public protoreflect API with types used only by
-// low-level implementations, the canonical definitions of these types are
-// in the runtime/protoiface package. The definitions here and in protoiface
-// must be kept in sync.
-type (
- methods = struct {
- pragma.NoUnkeyedLiterals
- Flags supportFlags
- Size func(sizeInput) sizeOutput
- Marshal func(marshalInput) (marshalOutput, error)
- Unmarshal func(unmarshalInput) (unmarshalOutput, error)
- Merge func(mergeInput) mergeOutput
- CheckInitialized func(checkInitializedInput) (checkInitializedOutput, error)
- }
- supportFlags = uint64
- sizeInput = struct {
- pragma.NoUnkeyedLiterals
- Message Message
- Flags uint8
- }
- sizeOutput = struct {
- pragma.NoUnkeyedLiterals
- Size int
- }
- marshalInput = struct {
- pragma.NoUnkeyedLiterals
- Message Message
- Buf []byte
- Flags uint8
- }
- marshalOutput = struct {
- pragma.NoUnkeyedLiterals
- Buf []byte
- }
- unmarshalInput = struct {
- pragma.NoUnkeyedLiterals
- Message Message
- Buf []byte
- Flags uint8
- Resolver interface {
- FindExtensionByName(field FullName) (ExtensionType, error)
- FindExtensionByNumber(message FullName, field FieldNumber) (ExtensionType, error)
- }
- }
- unmarshalOutput = struct {
- pragma.NoUnkeyedLiterals
- Flags uint8
- }
- mergeInput = struct {
- pragma.NoUnkeyedLiterals
- Source Message
- Destination Message
- }
- mergeOutput = struct {
- pragma.NoUnkeyedLiterals
- Flags uint8
- }
- checkInitializedInput = struct {
- pragma.NoUnkeyedLiterals
- Message Message
- }
- checkInitializedOutput = struct {
- pragma.NoUnkeyedLiterals
- }
-)
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go
deleted file mode 100644
index b669a4e..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go
+++ /dev/null
@@ -1,478 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoreflect provides interfaces to dynamically manipulate messages.
-//
-// This package includes type descriptors which describe the structure of types
-// defined in proto source files and value interfaces which provide the
-// ability to examine and manipulate the contents of messages.
-//
-//
-// Protocol Buffer Descriptors
-//
-// Protobuf descriptors (e.g., EnumDescriptor or MessageDescriptor)
-// are immutable objects that represent protobuf type information.
-// They are wrappers around the messages declared in descriptor.proto.
-// Protobuf descriptors alone lack any information regarding Go types.
-//
-// Enums and messages generated by this module implement Enum and ProtoMessage,
-// where the Descriptor and ProtoReflect.Descriptor accessors respectively
-// return the protobuf descriptor for the values.
-//
-// The protobuf descriptor interfaces are not meant to be implemented by
-// user code since they might need to be extended in the future to support
-// additions to the protobuf language.
-// The "google.golang.org/protobuf/reflect/protodesc" package converts between
-// google.protobuf.DescriptorProto messages and protobuf descriptors.
-//
-//
-// Go Type Descriptors
-//
-// A type descriptor (e.g., EnumType or MessageType) is a constructor for
-// a concrete Go type that represents the associated protobuf descriptor.
-// There is commonly a one-to-one relationship between protobuf descriptors and
-// Go type descriptors, but it can potentially be a one-to-many relationship.
-//
-// Enums and messages generated by this module implement Enum and ProtoMessage,
-// where the Type and ProtoReflect.Type accessors respectively
-// return the protobuf descriptor for the values.
-//
-// The "google.golang.org/protobuf/types/dynamicpb" package can be used to
-// create Go type descriptors from protobuf descriptors.
-//
-//
-// Value Interfaces
-//
-// The Enum and Message interfaces provide a reflective view over an
-// enum or message instance. For enums, it provides the ability to retrieve
-// the enum value number for any concrete enum type. For messages, it provides
-// the ability to access or manipulate fields of the message.
-//
-// To convert a proto.Message to a protoreflect.Message, use the
-// former's ProtoReflect method. Since the ProtoReflect method is new to the
-// v2 message interface, it may not be present on older message implementations.
-// The "github.com/golang/protobuf/proto".MessageReflect function can be used
-// to obtain a reflective view on older messages.
-//
-//
-// Relationships
-//
-// The following diagrams demonstrate the relationships between
-// various types declared in this package.
-//
-//
-// ┌───────────────────────────────────┐
-// V │
-// ┌────────────── New(n) ─────────────┐ │
-// │ │ │
-// │ ┌──── Descriptor() ──┐ │ ┌── Number() ──┐ │
-// │ │ V V │ V │
-// ╔════════════╗ ╔════════════════╗ ╔════════╗ ╔════════════╗
-// ║ EnumType ║ ║ EnumDescriptor ║ ║ Enum ║ ║ EnumNumber ║
-// ╚════════════╝ ╚════════════════╝ ╚════════╝ ╚════════════╝
-// Λ Λ │ │
-// │ └─── Descriptor() ──┘ │
-// │ │
-// └────────────────── Type() ───────┘
-//
-// • An EnumType describes a concrete Go enum type.
-// It has an EnumDescriptor and can construct an Enum instance.
-//
-// • An EnumDescriptor describes an abstract protobuf enum type.
-//
-// • An Enum is a concrete enum instance. Generated enums implement Enum.
-//
-//
-// ┌──────────────── New() ─────────────────┐
-// │ │
-// │ ┌─── Descriptor() ─────┐ │ ┌── Interface() ───┐
-// │ │ V V │ V
-// ╔═════════════╗ ╔═══════════════════╗ ╔═════════╗ ╔══════════════╗
-// ║ MessageType ║ ║ MessageDescriptor ║ ║ Message ║ ║ ProtoMessage ║
-// ╚═════════════╝ ╚═══════════════════╝ ╚═════════╝ ╚══════════════╝
-// Λ Λ │ │ Λ │
-// │ └──── Descriptor() ────┘ │ └─ ProtoReflect() ─┘
-// │ │
-// └─────────────────── Type() ─────────┘
-//
-// • A MessageType describes a concrete Go message type.
-// It has a MessageDescriptor and can construct a Message instance.
-//
-// • A MessageDescriptor describes an abstract protobuf message type.
-//
-// • A Message is a concrete message instance. Generated messages implement
-// ProtoMessage, which can convert to/from a Message.
-//
-//
-// ┌── TypeDescriptor() ──┐ ┌───── Descriptor() ─────┐
-// │ V │ V
-// ╔═══════════════╗ ╔═════════════════════════╗ ╔═════════════════════╗
-// ║ ExtensionType ║ ║ ExtensionTypeDescriptor ║ ║ ExtensionDescriptor ║
-// ╚═══════════════╝ ╚═════════════════════════╝ ╚═════════════════════╝
-// Λ │ │ Λ │ Λ
-// └─────── Type() ───────┘ │ └─── may implement ────┘ │
-// │ │
-// └────── implements ────────┘
-//
-// • An ExtensionType describes a concrete Go implementation of an extension.
-// It has an ExtensionTypeDescriptor and can convert to/from
-// abstract Values and Go values.
-//
-// • An ExtensionTypeDescriptor is an ExtensionDescriptor
-// which also has an ExtensionType.
-//
-// • An ExtensionDescriptor describes an abstract protobuf extension field and
-// may not always be an ExtensionTypeDescriptor.
-package protoreflect
-
-import (
- "fmt"
- "regexp"
- "strings"
-
- "google.golang.org/protobuf/encoding/protowire"
- "google.golang.org/protobuf/internal/pragma"
-)
-
-type doNotImplement pragma.DoNotImplement
-
-// ProtoMessage is the top-level interface that all proto messages implement.
-// This is declared in the protoreflect package to avoid a cyclic dependency;
-// use the proto.Message type instead, which aliases this type.
-type ProtoMessage interface{ ProtoReflect() Message }
-
-// Syntax is the language version of the proto file.
-type Syntax syntax
-
-type syntax int8 // keep exact type opaque as the int type may change
-
-const (
- Proto2 Syntax = 2
- Proto3 Syntax = 3
-)
-
-// IsValid reports whether the syntax is valid.
-func (s Syntax) IsValid() bool {
- switch s {
- case Proto2, Proto3:
- return true
- default:
- return false
- }
-}
-
-// String returns s as a proto source identifier (e.g., "proto2").
-func (s Syntax) String() string {
- switch s {
- case Proto2:
- return "proto2"
- case Proto3:
- return "proto3"
- default:
- return fmt.Sprintf("<unknown:%d>", s)
- }
-}
-
-// GoString returns s as a Go source identifier (e.g., "Proto2").
-func (s Syntax) GoString() string {
- switch s {
- case Proto2:
- return "Proto2"
- case Proto3:
- return "Proto3"
- default:
- return fmt.Sprintf("Syntax(%d)", s)
- }
-}
-
-// Cardinality determines whether a field is optional, required, or repeated.
-type Cardinality cardinality
-
-type cardinality int8 // keep exact type opaque as the int type may change
-
-// Constants as defined by the google.protobuf.Cardinality enumeration.
-const (
- Optional Cardinality = 1 // appears zero or one times
- Required Cardinality = 2 // appears exactly one time; invalid with Proto3
- Repeated Cardinality = 3 // appears zero or more times
-)
-
-// IsValid reports whether the cardinality is valid.
-func (c Cardinality) IsValid() bool {
- switch c {
- case Optional, Required, Repeated:
- return true
- default:
- return false
- }
-}
-
-// String returns c as a proto source identifier (e.g., "optional").
-func (c Cardinality) String() string {
- switch c {
- case Optional:
- return "optional"
- case Required:
- return "required"
- case Repeated:
- return "repeated"
- default:
- return fmt.Sprintf("<unknown:%d>", c)
- }
-}
-
-// GoString returns c as a Go source identifier (e.g., "Optional").
-func (c Cardinality) GoString() string {
- switch c {
- case Optional:
- return "Optional"
- case Required:
- return "Required"
- case Repeated:
- return "Repeated"
- default:
- return fmt.Sprintf("Cardinality(%d)", c)
- }
-}
-
-// Kind indicates the basic proto kind of a field.
-type Kind kind
-
-type kind int8 // keep exact type opaque as the int type may change
-
-// Constants as defined by the google.protobuf.Field.Kind enumeration.
-const (
- BoolKind Kind = 8
- EnumKind Kind = 14
- Int32Kind Kind = 5
- Sint32Kind Kind = 17
- Uint32Kind Kind = 13
- Int64Kind Kind = 3
- Sint64Kind Kind = 18
- Uint64Kind Kind = 4
- Sfixed32Kind Kind = 15
- Fixed32Kind Kind = 7
- FloatKind Kind = 2
- Sfixed64Kind Kind = 16
- Fixed64Kind Kind = 6
- DoubleKind Kind = 1
- StringKind Kind = 9
- BytesKind Kind = 12
- MessageKind Kind = 11
- GroupKind Kind = 10
-)
-
-// IsValid reports whether the kind is valid.
-func (k Kind) IsValid() bool {
- switch k {
- case BoolKind, EnumKind,
- Int32Kind, Sint32Kind, Uint32Kind,
- Int64Kind, Sint64Kind, Uint64Kind,
- Sfixed32Kind, Fixed32Kind, FloatKind,
- Sfixed64Kind, Fixed64Kind, DoubleKind,
- StringKind, BytesKind, MessageKind, GroupKind:
- return true
- default:
- return false
- }
-}
-
-// String returns k as a proto source identifier (e.g., "bool").
-func (k Kind) String() string {
- switch k {
- case BoolKind:
- return "bool"
- case EnumKind:
- return "enum"
- case Int32Kind:
- return "int32"
- case Sint32Kind:
- return "sint32"
- case Uint32Kind:
- return "uint32"
- case Int64Kind:
- return "int64"
- case Sint64Kind:
- return "sint64"
- case Uint64Kind:
- return "uint64"
- case Sfixed32Kind:
- return "sfixed32"
- case Fixed32Kind:
- return "fixed32"
- case FloatKind:
- return "float"
- case Sfixed64Kind:
- return "sfixed64"
- case Fixed64Kind:
- return "fixed64"
- case DoubleKind:
- return "double"
- case StringKind:
- return "string"
- case BytesKind:
- return "bytes"
- case MessageKind:
- return "message"
- case GroupKind:
- return "group"
- default:
- return fmt.Sprintf("<unknown:%d>", k)
- }
-}
-
-// GoString returns k as a Go source identifier (e.g., "BoolKind").
-func (k Kind) GoString() string {
- switch k {
- case BoolKind:
- return "BoolKind"
- case EnumKind:
- return "EnumKind"
- case Int32Kind:
- return "Int32Kind"
- case Sint32Kind:
- return "Sint32Kind"
- case Uint32Kind:
- return "Uint32Kind"
- case Int64Kind:
- return "Int64Kind"
- case Sint64Kind:
- return "Sint64Kind"
- case Uint64Kind:
- return "Uint64Kind"
- case Sfixed32Kind:
- return "Sfixed32Kind"
- case Fixed32Kind:
- return "Fixed32Kind"
- case FloatKind:
- return "FloatKind"
- case Sfixed64Kind:
- return "Sfixed64Kind"
- case Fixed64Kind:
- return "Fixed64Kind"
- case DoubleKind:
- return "DoubleKind"
- case StringKind:
- return "StringKind"
- case BytesKind:
- return "BytesKind"
- case MessageKind:
- return "MessageKind"
- case GroupKind:
- return "GroupKind"
- default:
- return fmt.Sprintf("Kind(%d)", k)
- }
-}
-
-// FieldNumber is the field number in a message.
-type FieldNumber = protowire.Number
-
-// FieldNumbers represent a list of field numbers.
-type FieldNumbers interface {
- // Len reports the number of fields in the list.
- Len() int
- // Get returns the ith field number. It panics if out of bounds.
- Get(i int) FieldNumber
- // Has reports whether n is within the list of fields.
- Has(n FieldNumber) bool
-
- doNotImplement
-}
-
-// FieldRanges represent a list of field number ranges.
-type FieldRanges interface {
- // Len reports the number of ranges in the list.
- Len() int
- // Get returns the ith range. It panics if out of bounds.
- Get(i int) [2]FieldNumber // start inclusive; end exclusive
- // Has reports whether n is within any of the ranges.
- Has(n FieldNumber) bool
-
- doNotImplement
-}
-
-// EnumNumber is the numeric value for an enum.
-type EnumNumber int32
-
-// EnumRanges represent a list of enum number ranges.
-type EnumRanges interface {
- // Len reports the number of ranges in the list.
- Len() int
- // Get returns the ith range. It panics if out of bounds.
- Get(i int) [2]EnumNumber // start inclusive; end inclusive
- // Has reports whether n is within any of the ranges.
- Has(n EnumNumber) bool
-
- doNotImplement
-}
-
-var (
- regexName = regexp.MustCompile(`^[_a-zA-Z][_a-zA-Z0-9]*$`)
- regexFullName = regexp.MustCompile(`^[_a-zA-Z][_a-zA-Z0-9]*(\.[_a-zA-Z][_a-zA-Z0-9]*)*$`)
-)
-
-// Name is the short name for a proto declaration. This is not the name
-// as used in Go source code, which might not be identical to the proto name.
-type Name string // e.g., "Kind"
-
-// IsValid reports whether n is a syntactically valid name.
-// An empty name is invalid.
-func (n Name) IsValid() bool {
- return regexName.MatchString(string(n))
-}
-
-// Names represent a list of names.
-type Names interface {
- // Len reports the number of names in the list.
- Len() int
- // Get returns the ith name. It panics if out of bounds.
- Get(i int) Name
- // Has reports whether s matches any names in the list.
- Has(s Name) bool
-
- doNotImplement
-}
-
-// FullName is a qualified name that uniquely identifies a proto declaration.
-// A qualified name is the concatenation of the proto package along with the
-// fully-declared name (i.e., name of parent preceding the name of the child),
-// with a '.' delimiter placed between each Name.
-//
-// This should not have any leading or trailing dots.
-type FullName string // e.g., "google.protobuf.Field.Kind"
-
-// IsValid reports whether n is a syntactically valid full name.
-// An empty full name is invalid.
-func (n FullName) IsValid() bool {
- return regexFullName.MatchString(string(n))
-}
-
-// Name returns the short name, which is the last identifier segment.
-// A single segment FullName is the Name itself.
-func (n FullName) Name() Name {
- if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
- return Name(n[i+1:])
- }
- return Name(n)
-}
-
-// Parent returns the full name with the trailing identifier removed.
-// A single segment FullName has no parent.
-func (n FullName) Parent() FullName {
- if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
- return n[:i]
- }
- return ""
-}
-
-// Append returns the qualified name appended with the provided short name.
-//
-// Invariant: n == n.Parent().Append(n.Name()) // assuming n is valid
-func (n FullName) Append(s Name) FullName {
- if n == "" {
- return FullName(s)
- }
- return n + "." + FullName(s)
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go
deleted file mode 100644
index 32ea3d9..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-// SourceLocations is a list of source locations.
-type SourceLocations interface {
- // Len reports the number of source locations in the proto file.
- Len() int
- // Get returns the ith SourceLocation. It panics if out of bounds.
- Get(int) SourceLocation
-
- doNotImplement
-
- // TODO: Add ByPath and ByDescriptor helper methods.
-}
-
-// SourceLocation describes a source location and
-// corresponds with the google.protobuf.SourceCodeInfo.Location message.
-type SourceLocation struct {
- // Path is the path to the declaration from the root file descriptor.
- // The contents of this slice must not be mutated.
- Path SourcePath
-
- // StartLine and StartColumn are the zero-indexed starting location
- // in the source file for the declaration.
- StartLine, StartColumn int
- // EndLine and EndColumn are the zero-indexed ending location
- // in the source file for the declaration.
- // In the descriptor.proto, the end line may be omitted if it is identical
- // to the start line. Here, it is always populated.
- EndLine, EndColumn int
-
- // LeadingDetachedComments are the leading detached comments
- // for the declaration. The contents of this slice must not be mutated.
- LeadingDetachedComments []string
- // LeadingComments is the leading attached comment for the declaration.
- LeadingComments string
- // TrailingComments is the trailing attached comment for the declaration.
- TrailingComments string
-}
-
-// SourcePath identifies part of a file descriptor for a source location.
-// The SourcePath is a sequence of either field numbers or indexes into
-// a repeated field that form a path starting from the root file descriptor.
-//
-// See google.protobuf.SourceCodeInfo.Location.path.
-type SourcePath []int32
-
-// TODO: Add SourcePath.String method to pretty-print the path. For example:
-// ".message_type[6].nested_type[15].field[3]"
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go
deleted file mode 100644
index 5be14a7..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go
+++ /dev/null
@@ -1,631 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-// Descriptor provides a set of accessors that are common to every descriptor.
-// Each descriptor type wraps the equivalent google.protobuf.XXXDescriptorProto,
-// but provides efficient lookup and immutability.
-//
-// Each descriptor is comparable. Equality implies that the two types are
-// exactly identical. However, it is possible for the same semantically
-// identical proto type to be represented by multiple type descriptors.
-//
-// For example, suppose we have t1 and t2 which are both MessageDescriptors.
-// If t1 == t2, then the types are definitely equal and all accessors return
-// the same information. However, if t1 != t2, then it is still possible that
-// they still represent the same proto type (e.g., t1.FullName == t2.FullName).
-// This can occur if a descriptor type is created dynamically, or multiple
-// versions of the same proto type are accidentally linked into the Go binary.
-type Descriptor interface {
- // ParentFile returns the parent file descriptor that this descriptor
- // is declared within. The parent file for the file descriptor is itself.
- //
- // Support for this functionality is optional and may return nil.
- ParentFile() FileDescriptor
-
- // Parent returns the parent containing this descriptor declaration.
- // The following shows the mapping from child type to possible parent types:
- //
- // ╔═════════════════════╤═══════════════════════════════════╗
- // ║ Child type │ Possible parent types ║
- // ╠═════════════════════╪═══════════════════════════════════╣
- // ║ FileDescriptor │ nil ║
- // ║ MessageDescriptor │ FileDescriptor, MessageDescriptor ║
- // ║ FieldDescriptor │ FileDescriptor, MessageDescriptor ║
- // ║ OneofDescriptor │ MessageDescriptor ║
- // ║ EnumDescriptor │ FileDescriptor, MessageDescriptor ║
- // ║ EnumValueDescriptor │ EnumDescriptor ║
- // ║ ServiceDescriptor │ FileDescriptor ║
- // ║ MethodDescriptor │ ServiceDescriptor ║
- // ╚═════════════════════╧═══════════════════════════════════╝
- //
- // Support for this functionality is optional and may return nil.
- Parent() Descriptor
-
- // Index returns the index of this descriptor within its parent.
- // It returns 0 if the descriptor does not have a parent or if the parent
- // is unknown.
- Index() int
-
- // Syntax is the protobuf syntax.
- Syntax() Syntax // e.g., Proto2 or Proto3
-
- // Name is the short name of the declaration (i.e., FullName.Name).
- Name() Name // e.g., "Any"
-
- // FullName is the fully-qualified name of the declaration.
- //
- // The FullName is a concatenation of the full name of the type that this
- // type is declared within and the declaration name. For example,
- // field "foo_field" in message "proto.package.MyMessage" is
- // uniquely identified as "proto.package.MyMessage.foo_field".
- // Enum values are an exception to the rule (see EnumValueDescriptor).
- FullName() FullName // e.g., "google.protobuf.Any"
-
- // IsPlaceholder reports whether type information is missing since a
- // dependency is not resolved, in which case only name information is known.
- //
- // Placeholder types may only be returned by the following accessors
- // as a result of unresolved dependencies or weak imports:
- //
- // ╔═══════════════════════════════════╤═════════════════════╗
- // ║ Accessor │ Descriptor ║
- // ╠═══════════════════════════════════╪═════════════════════╣
- // ║ FileImports.FileDescriptor │ FileDescriptor ║
- // ║ FieldDescriptor.Enum │ EnumDescriptor ║
- // ║ FieldDescriptor.Message │ MessageDescriptor ║
- // ║ FieldDescriptor.DefaultEnumValue │ EnumValueDescriptor ║
- // ║ FieldDescriptor.ContainingMessage │ MessageDescriptor ║
- // ║ MethodDescriptor.Input │ MessageDescriptor ║
- // ║ MethodDescriptor.Output │ MessageDescriptor ║
- // ╚═══════════════════════════════════╧═════════════════════╝
- //
- // If true, only Name and FullName are valid.
- // For FileDescriptor, the Path is also valid.
- IsPlaceholder() bool
-
- // Options returns the descriptor options. The caller must not modify
- // the returned value.
- //
- // To avoid a dependency cycle, this function returns a proto.Message value.
- // The proto message type returned for each descriptor type is as follows:
- // ╔═════════════════════╤══════════════════════════════════════════╗
- // ║ Go type │ Protobuf message type ║
- // ╠═════════════════════╪══════════════════════════════════════════╣
- // ║ FileDescriptor │ google.protobuf.FileOptions ║
- // ║ EnumDescriptor │ google.protobuf.EnumOptions ║
- // ║ EnumValueDescriptor │ google.protobuf.EnumValueOptions ║
- // ║ MessageDescriptor │ google.protobuf.MessageOptions ║
- // ║ FieldDescriptor │ google.protobuf.FieldOptions ║
- // ║ OneofDescriptor │ google.protobuf.OneofOptions ║
- // ║ ServiceDescriptor │ google.protobuf.ServiceOptions ║
- // ║ MethodDescriptor │ google.protobuf.MethodOptions ║
- // ╚═════════════════════╧══════════════════════════════════════════╝
- //
- // This method returns a typed nil-pointer if no options are present.
- // The caller must import the descriptorpb package to use this.
- Options() ProtoMessage
-
- doNotImplement
-}
-
-// FileDescriptor describes the types in a complete proto file and
-// corresponds with the google.protobuf.FileDescriptorProto message.
-//
-// Top-level declarations:
-// EnumDescriptor, MessageDescriptor, FieldDescriptor, and/or ServiceDescriptor.
-type FileDescriptor interface {
- Descriptor // Descriptor.FullName is identical to Package
-
- // Path returns the file name, relative to the source tree root.
- Path() string // e.g., "path/to/file.proto"
- // Package returns the protobuf package namespace.
- Package() FullName // e.g., "google.protobuf"
-
- // Imports is a list of imported proto files.
- Imports() FileImports
-
- // Enums is a list of the top-level enum declarations.
- Enums() EnumDescriptors
- // Messages is a list of the top-level message declarations.
- Messages() MessageDescriptors
- // Extensions is a list of the top-level extension declarations.
- Extensions() ExtensionDescriptors
- // Services is a list of the top-level service declarations.
- Services() ServiceDescriptors
-
- // SourceLocations is a list of source locations.
- SourceLocations() SourceLocations
-
- isFileDescriptor
-}
-type isFileDescriptor interface{ ProtoType(FileDescriptor) }
-
-// FileImports is a list of file imports.
-type FileImports interface {
- // Len reports the number of files imported by this proto file.
- Len() int
- // Get returns the ith FileImport. It panics if out of bounds.
- Get(i int) FileImport
-
- doNotImplement
-}
-
-// FileImport is the declaration for a proto file import.
-type FileImport struct {
- // FileDescriptor is the file type for the given import.
- // It is a placeholder descriptor if IsWeak is set or if a dependency has
- // not been regenerated to implement the new reflection APIs.
- FileDescriptor
-
- // IsPublic reports whether this is a public import, which causes this file
- // to alias declarations within the imported file. The intended use cases
- // for this feature is the ability to move proto files without breaking
- // existing dependencies.
- //
- // The current file and the imported file must be within proto package.
- IsPublic bool
-
- // IsWeak reports whether this is a weak import, which does not impose
- // a direct dependency on the target file.
- //
- // Weak imports are a legacy proto1 feature. Equivalent behavior is
- // achieved using proto2 extension fields or proto3 Any messages.
- IsWeak bool
-}
-
-// MessageDescriptor describes a message and
-// corresponds with the google.protobuf.DescriptorProto message.
-//
-// Nested declarations:
-// FieldDescriptor, OneofDescriptor, FieldDescriptor, EnumDescriptor,
-// and/or MessageDescriptor.
-type MessageDescriptor interface {
- Descriptor
-
- // IsMapEntry indicates that this is an auto-generated message type to
- // represent the entry type for a map field.
- //
- // Map entry messages have only two fields:
- // • a "key" field with a field number of 1
- // • a "value" field with a field number of 2
- // The key and value types are determined by these two fields.
- //
- // If IsMapEntry is true, it implies that FieldDescriptor.IsMap is true
- // for some field with this message type.
- IsMapEntry() bool
-
- // Fields is a list of nested field declarations.
- Fields() FieldDescriptors
- // Oneofs is a list of nested oneof declarations.
- Oneofs() OneofDescriptors
-
- // ReservedNames is a list of reserved field names.
- ReservedNames() Names
- // ReservedRanges is a list of reserved ranges of field numbers.
- ReservedRanges() FieldRanges
- // RequiredNumbers is a list of required field numbers.
- // In Proto3, it is always an empty list.
- RequiredNumbers() FieldNumbers
- // ExtensionRanges is the field ranges used for extension fields.
- // In Proto3, it is always an empty ranges.
- ExtensionRanges() FieldRanges
- // ExtensionRangeOptions returns the ith extension range options.
- //
- // To avoid a dependency cycle, this method returns a proto.Message value,
- // which always contains a google.protobuf.ExtensionRangeOptions message.
- // This method returns a typed nil-pointer if no options are present.
- // The caller must import the descriptorpb package to use this.
- ExtensionRangeOptions(i int) ProtoMessage
-
- // Enums is a list of nested enum declarations.
- Enums() EnumDescriptors
- // Messages is a list of nested message declarations.
- Messages() MessageDescriptors
- // Extensions is a list of nested extension declarations.
- Extensions() ExtensionDescriptors
-
- isMessageDescriptor
-}
-type isMessageDescriptor interface{ ProtoType(MessageDescriptor) }
-
-// MessageType encapsulates a MessageDescriptor with a concrete Go implementation.
-type MessageType interface {
- // New returns a newly allocated empty message.
- New() Message
-
- // Zero returns an empty, read-only message.
- Zero() Message
-
- // Descriptor returns the message descriptor.
- //
- // Invariant: t.Descriptor() == t.New().Descriptor()
- Descriptor() MessageDescriptor
-}
-
-// MessageDescriptors is a list of message declarations.
-type MessageDescriptors interface {
- // Len reports the number of messages.
- Len() int
- // Get returns the ith MessageDescriptor. It panics if out of bounds.
- Get(i int) MessageDescriptor
- // ByName returns the MessageDescriptor for a message named s.
- // It returns nil if not found.
- ByName(s Name) MessageDescriptor
-
- doNotImplement
-}
-
-// FieldDescriptor describes a field within a message and
-// corresponds with the google.protobuf.FieldDescriptorProto message.
-//
-// It is used for both normal fields defined within the parent message
-// (e.g., MessageDescriptor.Fields) and fields that extend some remote message
-// (e.g., FileDescriptor.Extensions or MessageDescriptor.Extensions).
-type FieldDescriptor interface {
- Descriptor
-
- // Number reports the unique number for this field.
- Number() FieldNumber
- // Cardinality reports the cardinality for this field.
- Cardinality() Cardinality
- // Kind reports the basic kind for this field.
- Kind() Kind
-
- // HasJSONName reports whether this field has an explicitly set JSON name.
- HasJSONName() bool
-
- // JSONName reports the name used for JSON serialization.
- // It is usually the camel-cased form of the field name.
- JSONName() string
-
- // HasPresence reports whether the field distinguishes between unpopulated
- // and default values.
- HasPresence() bool
-
- // IsExtension reports whether this is an extension field. If false,
- // then Parent and ContainingMessage refer to the same message.
- // Otherwise, ContainingMessage and Parent likely differ.
- IsExtension() bool
-
- // HasOptionalKeyword reports whether the "optional" keyword was explicitly
- // specified in the source .proto file.
- HasOptionalKeyword() bool
-
- // IsWeak reports whether this is a weak field, which does not impose a
- // direct dependency on the target type.
- // If true, then Message returns a placeholder type.
- IsWeak() bool
-
- // IsPacked reports whether repeated primitive numeric kinds should be
- // serialized using a packed encoding.
- // If true, then it implies Cardinality is Repeated.
- IsPacked() bool
-
- // IsList reports whether this field represents a list,
- // where the value type for the associated field is a List.
- // It is equivalent to checking whether Cardinality is Repeated and
- // that IsMap reports false.
- IsList() bool
-
- // IsMap reports whether this field represents a map,
- // where the value type for the associated field is a Map.
- // It is equivalent to checking whether Cardinality is Repeated,
- // that the Kind is MessageKind, and that Message.IsMapEntry reports true.
- IsMap() bool
-
- // MapKey returns the field descriptor for the key in the map entry.
- // It returns nil if IsMap reports false.
- MapKey() FieldDescriptor
-
- // MapValue returns the field descriptor for the value in the map entry.
- // It returns nil if IsMap reports false.
- MapValue() FieldDescriptor
-
- // HasDefault reports whether this field has a default value.
- HasDefault() bool
-
- // Default returns the default value for scalar fields.
- // For proto2, it is the default value as specified in the proto file,
- // or the zero value if unspecified.
- // For proto3, it is always the zero value of the scalar.
- // The Value type is determined by the Kind.
- Default() Value
-
- // DefaultEnumValue returns the enum value descriptor for the default value
- // of an enum field, and is nil for any other kind of field.
- DefaultEnumValue() EnumValueDescriptor
-
- // ContainingOneof is the containing oneof that this field belongs to,
- // and is nil if this field is not part of a oneof.
- ContainingOneof() OneofDescriptor
-
- // ContainingMessage is the containing message that this field belongs to.
- // For extension fields, this may not necessarily be the parent message
- // that the field is declared within.
- ContainingMessage() MessageDescriptor
-
- // Enum is the enum descriptor if Kind is EnumKind.
- // It returns nil for any other Kind.
- Enum() EnumDescriptor
-
- // Message is the message descriptor if Kind is
- // MessageKind or GroupKind. It returns nil for any other Kind.
- Message() MessageDescriptor
-
- isFieldDescriptor
-}
-type isFieldDescriptor interface{ ProtoType(FieldDescriptor) }
-
-// FieldDescriptors is a list of field declarations.
-type FieldDescriptors interface {
- // Len reports the number of fields.
- Len() int
- // Get returns the ith FieldDescriptor. It panics if out of bounds.
- Get(i int) FieldDescriptor
- // ByName returns the FieldDescriptor for a field named s.
- // It returns nil if not found.
- ByName(s Name) FieldDescriptor
- // ByJSONName returns the FieldDescriptor for a field with s as the JSON name.
- // It returns nil if not found.
- ByJSONName(s string) FieldDescriptor
- // ByNumber returns the FieldDescriptor for a field numbered n.
- // It returns nil if not found.
- ByNumber(n FieldNumber) FieldDescriptor
-
- doNotImplement
-}
-
-// OneofDescriptor describes a oneof field set within a given message and
-// corresponds with the google.protobuf.OneofDescriptorProto message.
-type OneofDescriptor interface {
- Descriptor
-
- // IsSynthetic reports whether this is a synthetic oneof created to support
- // proto3 optional semantics. If true, Fields contains exactly one field
- // with HasOptionalKeyword specified.
- IsSynthetic() bool
-
- // Fields is a list of fields belonging to this oneof.
- Fields() FieldDescriptors
-
- isOneofDescriptor
-}
-type isOneofDescriptor interface{ ProtoType(OneofDescriptor) }
-
-// OneofDescriptors is a list of oneof declarations.
-type OneofDescriptors interface {
- // Len reports the number of oneof fields.
- Len() int
- // Get returns the ith OneofDescriptor. It panics if out of bounds.
- Get(i int) OneofDescriptor
- // ByName returns the OneofDescriptor for a oneof named s.
- // It returns nil if not found.
- ByName(s Name) OneofDescriptor
-
- doNotImplement
-}
-
-// ExtensionDescriptor is an alias of FieldDescriptor for documentation.
-type ExtensionDescriptor = FieldDescriptor
-
-// ExtensionTypeDescriptor is an ExtensionDescriptor with an associated ExtensionType.
-type ExtensionTypeDescriptor interface {
- ExtensionDescriptor
-
- // Type returns the associated ExtensionType.
- Type() ExtensionType
-
- // Descriptor returns the plain ExtensionDescriptor without the
- // associated ExtensionType.
- Descriptor() ExtensionDescriptor
-}
-
-// ExtensionDescriptors is a list of field declarations.
-type ExtensionDescriptors interface {
- // Len reports the number of fields.
- Len() int
- // Get returns the ith ExtensionDescriptor. It panics if out of bounds.
- Get(i int) ExtensionDescriptor
- // ByName returns the ExtensionDescriptor for a field named s.
- // It returns nil if not found.
- ByName(s Name) ExtensionDescriptor
-
- doNotImplement
-}
-
-// ExtensionType encapsulates an ExtensionDescriptor with a concrete
-// Go implementation. The nested field descriptor must be for a extension field.
-//
-// While a normal field is a member of the parent message that it is declared
-// within (see Descriptor.Parent), an extension field is a member of some other
-// target message (see ExtensionDescriptor.Extendee) and may have no
-// relationship with the parent. However, the full name of an extension field is
-// relative to the parent that it is declared within.
-//
-// For example:
-// syntax = "proto2";
-// package example;
-// message FooMessage {
-// extensions 100 to max;
-// }
-// message BarMessage {
-// extends FooMessage { optional BarMessage bar_field = 100; }
-// }
-//
-// Field "bar_field" is an extension of FooMessage, but its full name is
-// "example.BarMessage.bar_field" instead of "example.FooMessage.bar_field".
-type ExtensionType interface {
- // New returns a new value for the field.
- // For scalars, this returns the default value in native Go form.
- New() Value
-
- // Zero returns a new value for the field.
- // For scalars, this returns the default value in native Go form.
- // For composite types, this returns an empty, read-only message, list, or map.
- Zero() Value
-
- // TypeDescriptor returns the extension type descriptor.
- TypeDescriptor() ExtensionTypeDescriptor
-
- // ValueOf wraps the input and returns it as a Value.
- // ValueOf panics if the input value is invalid or not the appropriate type.
- //
- // ValueOf is more extensive than protoreflect.ValueOf for a given field's
- // value as it has more type information available.
- ValueOf(interface{}) Value
-
- // InterfaceOf completely unwraps the Value to the underlying Go type.
- // InterfaceOf panics if the input is nil or does not represent the
- // appropriate underlying Go type. For composite types, it panics if the
- // value is not mutable.
- //
- // InterfaceOf is able to unwrap the Value further than Value.Interface
- // as it has more type information available.
- InterfaceOf(Value) interface{}
-
- // IsValidValue reports whether the Value is valid to assign to the field.
- IsValidValue(Value) bool
-
- // IsValidInterface reports whether the input is valid to assign to the field.
- IsValidInterface(interface{}) bool
-}
-
-// EnumDescriptor describes an enum and
-// corresponds with the google.protobuf.EnumDescriptorProto message.
-//
-// Nested declarations:
-// EnumValueDescriptor.
-type EnumDescriptor interface {
- Descriptor
-
- // Values is a list of nested enum value declarations.
- Values() EnumValueDescriptors
-
- // ReservedNames is a list of reserved enum names.
- ReservedNames() Names
- // ReservedRanges is a list of reserved ranges of enum numbers.
- ReservedRanges() EnumRanges
-
- isEnumDescriptor
-}
-type isEnumDescriptor interface{ ProtoType(EnumDescriptor) }
-
-// EnumType encapsulates an EnumDescriptor with a concrete Go implementation.
-type EnumType interface {
- // New returns an instance of this enum type with its value set to n.
- New(n EnumNumber) Enum
-
- // Descriptor returns the enum descriptor.
- //
- // Invariant: t.Descriptor() == t.New(0).Descriptor()
- Descriptor() EnumDescriptor
-}
-
-// EnumDescriptors is a list of enum declarations.
-type EnumDescriptors interface {
- // Len reports the number of enum types.
- Len() int
- // Get returns the ith EnumDescriptor. It panics if out of bounds.
- Get(i int) EnumDescriptor
- // ByName returns the EnumDescriptor for an enum named s.
- // It returns nil if not found.
- ByName(s Name) EnumDescriptor
-
- doNotImplement
-}
-
-// EnumValueDescriptor describes an enum value and
-// corresponds with the google.protobuf.EnumValueDescriptorProto message.
-//
-// All other proto declarations are in the namespace of the parent.
-// However, enum values do not follow this rule and are within the namespace
-// of the parent's parent (i.e., they are a sibling of the containing enum).
-// Thus, a value named "FOO_VALUE" declared within an enum uniquely identified
-// as "proto.package.MyEnum" has a full name of "proto.package.FOO_VALUE".
-type EnumValueDescriptor interface {
- Descriptor
-
- // Number returns the enum value as an integer.
- Number() EnumNumber
-
- isEnumValueDescriptor
-}
-type isEnumValueDescriptor interface{ ProtoType(EnumValueDescriptor) }
-
-// EnumValueDescriptors is a list of enum value declarations.
-type EnumValueDescriptors interface {
- // Len reports the number of enum values.
- Len() int
- // Get returns the ith EnumValueDescriptor. It panics if out of bounds.
- Get(i int) EnumValueDescriptor
- // ByName returns the EnumValueDescriptor for the enum value named s.
- // It returns nil if not found.
- ByName(s Name) EnumValueDescriptor
- // ByNumber returns the EnumValueDescriptor for the enum value numbered n.
- // If multiple have the same number, the first one defined is returned
- // It returns nil if not found.
- ByNumber(n EnumNumber) EnumValueDescriptor
-
- doNotImplement
-}
-
-// ServiceDescriptor describes a service and
-// corresponds with the google.protobuf.ServiceDescriptorProto message.
-//
-// Nested declarations: MethodDescriptor.
-type ServiceDescriptor interface {
- Descriptor
-
- // Methods is a list of nested message declarations.
- Methods() MethodDescriptors
-
- isServiceDescriptor
-}
-type isServiceDescriptor interface{ ProtoType(ServiceDescriptor) }
-
-// ServiceDescriptors is a list of service declarations.
-type ServiceDescriptors interface {
- // Len reports the number of services.
- Len() int
- // Get returns the ith ServiceDescriptor. It panics if out of bounds.
- Get(i int) ServiceDescriptor
- // ByName returns the ServiceDescriptor for a service named s.
- // It returns nil if not found.
- ByName(s Name) ServiceDescriptor
-
- doNotImplement
-}
-
-// MethodDescriptor describes a method and
-// corresponds with the google.protobuf.MethodDescriptorProto message.
-type MethodDescriptor interface {
- Descriptor
-
- // Input is the input message descriptor.
- Input() MessageDescriptor
- // Output is the output message descriptor.
- Output() MessageDescriptor
- // IsStreamingClient reports whether the client streams multiple messages.
- IsStreamingClient() bool
- // IsStreamingServer reports whether the server streams multiple messages.
- IsStreamingServer() bool
-
- isMethodDescriptor
-}
-type isMethodDescriptor interface{ ProtoType(MethodDescriptor) }
-
-// MethodDescriptors is a list of method declarations.
-type MethodDescriptors interface {
- // Len reports the number of methods.
- Len() int
- // Get returns the ith MethodDescriptor. It panics if out of bounds.
- Get(i int) MethodDescriptor
- // ByName returns the MethodDescriptor for a service method named s.
- // It returns nil if not found.
- ByName(s Name) MethodDescriptor
-
- doNotImplement
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go
deleted file mode 100644
index f319810..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-import "google.golang.org/protobuf/encoding/protowire"
-
-// Enum is a reflection interface for a concrete enum value,
-// which provides type information and a getter for the enum number.
-// Enum does not provide a mutable API since enums are commonly backed by
-// Go constants, which are not addressable.
-type Enum interface {
- // Descriptor returns enum descriptor, which contains only the protobuf
- // type information for the enum.
- Descriptor() EnumDescriptor
-
- // Type returns the enum type, which encapsulates both Go and protobuf
- // type information. If the Go type information is not needed,
- // it is recommended that the enum descriptor be used instead.
- Type() EnumType
-
- // Number returns the enum value as an integer.
- Number() EnumNumber
-}
-
-// Message is a reflective interface for a concrete message value,
-// encapsulating both type and value information for the message.
-//
-// Accessor/mutators for individual fields are keyed by FieldDescriptor.
-// For non-extension fields, the descriptor must exactly match the
-// field known by the parent message.
-// For extension fields, the descriptor must implement ExtensionTypeDescriptor,
-// extend the parent message (i.e., have the same message FullName), and
-// be within the parent's extension range.
-//
-// Each field Value can be a scalar or a composite type (Message, List, or Map).
-// See Value for the Go types associated with a FieldDescriptor.
-// Providing a Value that is invalid or of an incorrect type panics.
-type Message interface {
- // Descriptor returns message descriptor, which contains only the protobuf
- // type information for the message.
- Descriptor() MessageDescriptor
-
- // Type returns the message type, which encapsulates both Go and protobuf
- // type information. If the Go type information is not needed,
- // it is recommended that the message descriptor be used instead.
- Type() MessageType
-
- // New returns a newly allocated and mutable empty message.
- New() Message
-
- // Interface unwraps the message reflection interface and
- // returns the underlying ProtoMessage interface.
- Interface() ProtoMessage
-
- // Range iterates over every populated field in an undefined order,
- // calling f for each field descriptor and value encountered.
- // Range returns immediately if f returns false.
- // While iterating, mutating operations may only be performed
- // on the current field descriptor.
- Range(f func(FieldDescriptor, Value) bool)
-
- // Has reports whether a field is populated.
- //
- // Some fields have the property of nullability where it is possible to
- // distinguish between the default value of a field and whether the field
- // was explicitly populated with the default value. Singular message fields,
- // member fields of a oneof, and proto2 scalar fields are nullable. Such
- // fields are populated only if explicitly set.
- //
- // In other cases (aside from the nullable cases above),
- // a proto3 scalar field is populated if it contains a non-zero value, and
- // a repeated field is populated if it is non-empty.
- Has(FieldDescriptor) bool
-
- // Clear clears the field such that a subsequent Has call reports false.
- //
- // Clearing an extension field clears both the extension type and value
- // associated with the given field number.
- //
- // Clear is a mutating operation and unsafe for concurrent use.
- Clear(FieldDescriptor)
-
- // Get retrieves the value for a field.
- //
- // For unpopulated scalars, it returns the default value, where
- // the default value of a bytes scalar is guaranteed to be a copy.
- // For unpopulated composite types, it returns an empty, read-only view
- // of the value; to obtain a mutable reference, use Mutable.
- Get(FieldDescriptor) Value
-
- // Set stores the value for a field.
- //
- // For a field belonging to a oneof, it implicitly clears any other field
- // that may be currently set within the same oneof.
- // For extension fields, it implicitly stores the provided ExtensionType.
- // When setting a composite type, it is unspecified whether the stored value
- // aliases the source's memory in any way. If the composite value is an
- // empty, read-only value, then it panics.
- //
- // Set is a mutating operation and unsafe for concurrent use.
- Set(FieldDescriptor, Value)
-
- // Mutable returns a mutable reference to a composite type.
- //
- // If the field is unpopulated, it may allocate a composite value.
- // For a field belonging to a oneof, it implicitly clears any other field
- // that may be currently set within the same oneof.
- // For extension fields, it implicitly stores the provided ExtensionType
- // if not already stored.
- // It panics if the field does not contain a composite type.
- //
- // Mutable is a mutating operation and unsafe for concurrent use.
- Mutable(FieldDescriptor) Value
-
- // NewField returns a new value that is assignable to the field
- // for the given descriptor. For scalars, this returns the default value.
- // For lists, maps, and messages, this returns a new, empty, mutable value.
- NewField(FieldDescriptor) Value
-
- // WhichOneof reports which field within the oneof is populated,
- // returning nil if none are populated.
- // It panics if the oneof descriptor does not belong to this message.
- WhichOneof(OneofDescriptor) FieldDescriptor
-
- // GetUnknown retrieves the entire list of unknown fields.
- // The caller may only mutate the contents of the RawFields
- // if the mutated bytes are stored back into the message with SetUnknown.
- GetUnknown() RawFields
-
- // SetUnknown stores an entire list of unknown fields.
- // The raw fields must be syntactically valid according to the wire format.
- // An implementation may panic if this is not the case.
- // Once stored, the caller must not mutate the content of the RawFields.
- // An empty RawFields may be passed to clear the fields.
- //
- // SetUnknown is a mutating operation and unsafe for concurrent use.
- SetUnknown(RawFields)
-
- // IsValid reports whether the message is valid.
- //
- // An invalid message is an empty, read-only value.
- //
- // An invalid message often corresponds to a nil pointer of the concrete
- // message type, but the details are implementation dependent.
- // Validity is not part of the protobuf data model, and may not
- // be preserved in marshaling or other operations.
- IsValid() bool
-
- // ProtoMethods returns optional fast-path implementions of various operations.
- // This method may return nil.
- //
- // The returned methods type is identical to
- // "google.golang.org/protobuf/runtime/protoiface".Methods.
- // Consult the protoiface package documentation for details.
- ProtoMethods() *methods
-}
-
-// RawFields is the raw bytes for an ordered sequence of fields.
-// Each field contains both the tag (representing field number and wire type),
-// and also the wire data itself.
-type RawFields []byte
-
-// IsValid reports whether b is syntactically correct wire format.
-func (b RawFields) IsValid() bool {
- for len(b) > 0 {
- _, _, n := protowire.ConsumeField(b)
- if n < 0 {
- return false
- }
- b = b[n:]
- }
- return true
-}
-
-// List is a zero-indexed, ordered list.
-// The element Value type is determined by FieldDescriptor.Kind.
-// Providing a Value that is invalid or of an incorrect type panics.
-type List interface {
- // Len reports the number of entries in the List.
- // Get, Set, and Truncate panic with out of bound indexes.
- Len() int
-
- // Get retrieves the value at the given index.
- // It never returns an invalid value.
- Get(int) Value
-
- // Set stores a value for the given index.
- // When setting a composite type, it is unspecified whether the set
- // value aliases the source's memory in any way.
- //
- // Set is a mutating operation and unsafe for concurrent use.
- Set(int, Value)
-
- // Append appends the provided value to the end of the list.
- // When appending a composite type, it is unspecified whether the appended
- // value aliases the source's memory in any way.
- //
- // Append is a mutating operation and unsafe for concurrent use.
- Append(Value)
-
- // AppendMutable appends a new, empty, mutable message value to the end
- // of the list and returns it.
- // It panics if the list does not contain a message type.
- AppendMutable() Value
-
- // Truncate truncates the list to a smaller length.
- //
- // Truncate is a mutating operation and unsafe for concurrent use.
- Truncate(int)
-
- // NewElement returns a new value for a list element.
- // For enums, this returns the first enum value.
- // For other scalars, this returns the zero value.
- // For messages, this returns a new, empty, mutable value.
- NewElement() Value
-
- // IsValid reports whether the list is valid.
- //
- // An invalid list is an empty, read-only value.
- //
- // Validity is not part of the protobuf data model, and may not
- // be preserved in marshaling or other operations.
- IsValid() bool
-}
-
-// Map is an unordered, associative map.
-// The entry MapKey type is determined by FieldDescriptor.MapKey.Kind.
-// The entry Value type is determined by FieldDescriptor.MapValue.Kind.
-// Providing a MapKey or Value that is invalid or of an incorrect type panics.
-type Map interface {
- // Len reports the number of elements in the map.
- Len() int
-
- // Range iterates over every map entry in an undefined order,
- // calling f for each key and value encountered.
- // Range calls f Len times unless f returns false, which stops iteration.
- // While iterating, mutating operations may only be performed
- // on the current map key.
- Range(f func(MapKey, Value) bool)
-
- // Has reports whether an entry with the given key is in the map.
- Has(MapKey) bool
-
- // Clear clears the entry associated with they given key.
- // The operation does nothing if there is no entry associated with the key.
- //
- // Clear is a mutating operation and unsafe for concurrent use.
- Clear(MapKey)
-
- // Get retrieves the value for an entry with the given key.
- // It returns an invalid value for non-existent entries.
- Get(MapKey) Value
-
- // Set stores the value for an entry with the given key.
- // It panics when given a key or value that is invalid or the wrong type.
- // When setting a composite type, it is unspecified whether the set
- // value aliases the source's memory in any way.
- //
- // Set is a mutating operation and unsafe for concurrent use.
- Set(MapKey, Value)
-
- // Mutable retrieves a mutable reference to the entry for the given key.
- // If no entry exists for the key, it creates a new, empty, mutable value
- // and stores it as the entry for the key.
- // It panics if the map value is not a message.
- Mutable(MapKey) Value
-
- // NewValue returns a new value assignable as a map value.
- // For enums, this returns the first enum value.
- // For other scalars, this returns the zero value.
- // For messages, this returns a new, empty, mutable value.
- NewValue() Value
-
- // IsValid reports whether the map is valid.
- //
- // An invalid map is an empty, read-only value.
- //
- // An invalid message often corresponds to a nil Go map value,
- // but the details are implementation dependent.
- // Validity is not part of the protobuf data model, and may not
- // be preserved in marshaling or other operations.
- IsValid() bool
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
deleted file mode 100644
index 918e685..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package protoreflect
-
-import "google.golang.org/protobuf/internal/pragma"
-
-type valueType int
-
-const (
- nilType valueType = iota
- boolType
- int32Type
- int64Type
- uint32Type
- uint64Type
- float32Type
- float64Type
- stringType
- bytesType
- enumType
- ifaceType
-)
-
-// value is a union where only one type can be represented at a time.
-// This uses a distinct field for each type. This is type safe in Go, but
-// occupies more memory than necessary (72B).
-type value struct {
- pragma.DoNotCompare // 0B
-
- typ valueType // 8B
- num uint64 // 8B
- str string // 16B
- bin []byte // 24B
- iface interface{} // 16B
-}
-
-func valueOfString(v string) Value {
- return Value{typ: stringType, str: v}
-}
-func valueOfBytes(v []byte) Value {
- return Value{typ: bytesType, bin: v}
-}
-func valueOfIface(v interface{}) Value {
- return Value{typ: ifaceType, iface: v}
-}
-
-func (v Value) getString() string {
- return v.str
-}
-func (v Value) getBytes() []byte {
- return v.bin
-}
-func (v Value) getIface() interface{} {
- return v.iface
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go
deleted file mode 100644
index f334f71..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go
+++ /dev/null
@@ -1,409 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-import (
- "fmt"
- "math"
-)
-
-// Value is a union where only one Go type may be set at a time.
-// The Value is used to represent all possible values a field may take.
-// The following shows which Go type is used to represent each proto Kind:
-//
-// ╔════════════╤═════════════════════════════════════╗
-// ║ Go type │ Protobuf kind ║
-// ╠════════════╪═════════════════════════════════════╣
-// ║ bool │ BoolKind ║
-// ║ int32 │ Int32Kind, Sint32Kind, Sfixed32Kind ║
-// ║ int64 │ Int64Kind, Sint64Kind, Sfixed64Kind ║
-// ║ uint32 │ Uint32Kind, Fixed32Kind ║
-// ║ uint64 │ Uint64Kind, Fixed64Kind ║
-// ║ float32 │ FloatKind ║
-// ║ float64 │ DoubleKind ║
-// ║ string │ StringKind ║
-// ║ []byte │ BytesKind ║
-// ║ EnumNumber │ EnumKind ║
-// ║ Message │ MessageKind, GroupKind ║
-// ╚════════════╧═════════════════════════════════════╝
-//
-// Multiple protobuf Kinds may be represented by a single Go type if the type
-// can losslessly represent the information for the proto kind. For example,
-// Int64Kind, Sint64Kind, and Sfixed64Kind are all represented by int64,
-// but use different integer encoding methods.
-//
-// The List or Map types are used if the field cardinality is repeated.
-// A field is a List if FieldDescriptor.IsList reports true.
-// A field is a Map if FieldDescriptor.IsMap reports true.
-//
-// Converting to/from a Value and a concrete Go value panics on type mismatch.
-// For example, ValueOf("hello").Int() panics because this attempts to
-// retrieve an int64 from a string.
-type Value value
-
-// The protoreflect API uses a custom Value union type instead of interface{}
-// to keep the future open for performance optimizations. Using an interface{}
-// always incurs an allocation for primitives (e.g., int64) since it needs to
-// be boxed on the heap (as interfaces can only contain pointers natively).
-// Instead, we represent the Value union as a flat struct that internally keeps
-// track of which type is set. Using unsafe, the Value union can be reduced
-// down to 24B, which is identical in size to a slice.
-//
-// The latest compiler (Go1.11) currently suffers from some limitations:
-// • With inlining, the compiler should be able to statically prove that
-// only one of these switch cases are taken and inline one specific case.
-// See https://golang.org/issue/22310.
-
-// ValueOf returns a Value initialized with the concrete value stored in v.
-// This panics if the type does not match one of the allowed types in the
-// Value union.
-func ValueOf(v interface{}) Value {
- switch v := v.(type) {
- case nil:
- return Value{}
- case bool:
- return ValueOfBool(v)
- case int32:
- return ValueOfInt32(v)
- case int64:
- return ValueOfInt64(v)
- case uint32:
- return ValueOfUint32(v)
- case uint64:
- return ValueOfUint64(v)
- case float32:
- return ValueOfFloat32(v)
- case float64:
- return ValueOfFloat64(v)
- case string:
- return ValueOfString(v)
- case []byte:
- return ValueOfBytes(v)
- case EnumNumber:
- return ValueOfEnum(v)
- case Message, List, Map:
- return valueOfIface(v)
- default:
- panic(fmt.Sprintf("invalid type: %T", v))
- }
-}
-
-// ValueOfBool returns a new boolean value.
-func ValueOfBool(v bool) Value {
- if v {
- return Value{typ: boolType, num: 1}
- } else {
- return Value{typ: boolType, num: 0}
- }
-}
-
-// ValueOfInt32 returns a new int32 value.
-func ValueOfInt32(v int32) Value {
- return Value{typ: int32Type, num: uint64(v)}
-}
-
-// ValueOfInt64 returns a new int64 value.
-func ValueOfInt64(v int64) Value {
- return Value{typ: int64Type, num: uint64(v)}
-}
-
-// ValueOfUint32 returns a new uint32 value.
-func ValueOfUint32(v uint32) Value {
- return Value{typ: uint32Type, num: uint64(v)}
-}
-
-// ValueOfUint64 returns a new uint64 value.
-func ValueOfUint64(v uint64) Value {
- return Value{typ: uint64Type, num: v}
-}
-
-// ValueOfFloat32 returns a new float32 value.
-func ValueOfFloat32(v float32) Value {
- return Value{typ: float32Type, num: uint64(math.Float64bits(float64(v)))}
-}
-
-// ValueOfFloat64 returns a new float64 value.
-func ValueOfFloat64(v float64) Value {
- return Value{typ: float64Type, num: uint64(math.Float64bits(float64(v)))}
-}
-
-// ValueOfString returns a new string value.
-func ValueOfString(v string) Value {
- return valueOfString(v)
-}
-
-// ValueOfBytes returns a new bytes value.
-func ValueOfBytes(v []byte) Value {
- return valueOfBytes(v[:len(v):len(v)])
-}
-
-// ValueOfEnum returns a new enum value.
-func ValueOfEnum(v EnumNumber) Value {
- return Value{typ: enumType, num: uint64(v)}
-}
-
-// ValueOfMessage returns a new Message value.
-func ValueOfMessage(v Message) Value {
- return valueOfIface(v)
-}
-
-// ValueOfList returns a new List value.
-func ValueOfList(v List) Value {
- return valueOfIface(v)
-}
-
-// ValueOfMap returns a new Map value.
-func ValueOfMap(v Map) Value {
- return valueOfIface(v)
-}
-
-// IsValid reports whether v is populated with a value.
-func (v Value) IsValid() bool {
- return v.typ != nilType
-}
-
-// Interface returns v as an interface{}.
-//
-// Invariant: v == ValueOf(v).Interface()
-func (v Value) Interface() interface{} {
- switch v.typ {
- case nilType:
- return nil
- case boolType:
- return v.Bool()
- case int32Type:
- return int32(v.Int())
- case int64Type:
- return int64(v.Int())
- case uint32Type:
- return uint32(v.Uint())
- case uint64Type:
- return uint64(v.Uint())
- case float32Type:
- return float32(v.Float())
- case float64Type:
- return float64(v.Float())
- case stringType:
- return v.String()
- case bytesType:
- return v.Bytes()
- case enumType:
- return v.Enum()
- default:
- return v.getIface()
- }
-}
-
-func (v Value) typeName() string {
- switch v.typ {
- case nilType:
- return "nil"
- case boolType:
- return "bool"
- case int32Type:
- return "int32"
- case int64Type:
- return "int64"
- case uint32Type:
- return "uint32"
- case uint64Type:
- return "uint64"
- case float32Type:
- return "float32"
- case float64Type:
- return "float64"
- case stringType:
- return "string"
- case bytesType:
- return "bytes"
- case enumType:
- return "enum"
- default:
- switch v := v.getIface().(type) {
- case Message:
- return "message"
- case List:
- return "list"
- case Map:
- return "map"
- default:
- return fmt.Sprintf("<unknown: %T>", v)
- }
- }
-}
-
-func (v Value) panicMessage(what string) string {
- return fmt.Sprintf("type mismatch: cannot convert %v to %s", v.typeName(), what)
-}
-
-// Bool returns v as a bool and panics if the type is not a bool.
-func (v Value) Bool() bool {
- switch v.typ {
- case boolType:
- return v.num > 0
- default:
- panic(v.panicMessage("bool"))
- }
-}
-
-// Int returns v as a int64 and panics if the type is not a int32 or int64.
-func (v Value) Int() int64 {
- switch v.typ {
- case int32Type, int64Type:
- return int64(v.num)
- default:
- panic(v.panicMessage("int"))
- }
-}
-
-// Uint returns v as a uint64 and panics if the type is not a uint32 or uint64.
-func (v Value) Uint() uint64 {
- switch v.typ {
- case uint32Type, uint64Type:
- return uint64(v.num)
- default:
- panic(v.panicMessage("uint"))
- }
-}
-
-// Float returns v as a float64 and panics if the type is not a float32 or float64.
-func (v Value) Float() float64 {
- switch v.typ {
- case float32Type, float64Type:
- return math.Float64frombits(uint64(v.num))
- default:
- panic(v.panicMessage("float"))
- }
-}
-
-// String returns v as a string. Since this method implements fmt.Stringer,
-// this returns the formatted string value for any non-string type.
-func (v Value) String() string {
- switch v.typ {
- case stringType:
- return v.getString()
- default:
- return fmt.Sprint(v.Interface())
- }
-}
-
-// Bytes returns v as a []byte and panics if the type is not a []byte.
-func (v Value) Bytes() []byte {
- switch v.typ {
- case bytesType:
- return v.getBytes()
- default:
- panic(v.panicMessage("bytes"))
- }
-}
-
-// Enum returns v as a EnumNumber and panics if the type is not a EnumNumber.
-func (v Value) Enum() EnumNumber {
- switch v.typ {
- case enumType:
- return EnumNumber(v.num)
- default:
- panic(v.panicMessage("enum"))
- }
-}
-
-// Message returns v as a Message and panics if the type is not a Message.
-func (v Value) Message() Message {
- switch vi := v.getIface().(type) {
- case Message:
- return vi
- default:
- panic(v.panicMessage("message"))
- }
-}
-
-// List returns v as a List and panics if the type is not a List.
-func (v Value) List() List {
- switch vi := v.getIface().(type) {
- case List:
- return vi
- default:
- panic(v.panicMessage("list"))
- }
-}
-
-// Map returns v as a Map and panics if the type is not a Map.
-func (v Value) Map() Map {
- switch vi := v.getIface().(type) {
- case Map:
- return vi
- default:
- panic(v.panicMessage("map"))
- }
-}
-
-// MapKey returns v as a MapKey and panics for invalid MapKey types.
-func (v Value) MapKey() MapKey {
- switch v.typ {
- case boolType, int32Type, int64Type, uint32Type, uint64Type, stringType:
- return MapKey(v)
- default:
- panic(v.panicMessage("map key"))
- }
-}
-
-// MapKey is used to index maps, where the Go type of the MapKey must match
-// the specified key Kind (see MessageDescriptor.IsMapEntry).
-// The following shows what Go type is used to represent each proto Kind:
-//
-// ╔═════════╤═════════════════════════════════════╗
-// ║ Go type │ Protobuf kind ║
-// ╠═════════╪═════════════════════════════════════╣
-// ║ bool │ BoolKind ║
-// ║ int32 │ Int32Kind, Sint32Kind, Sfixed32Kind ║
-// ║ int64 │ Int64Kind, Sint64Kind, Sfixed64Kind ║
-// ║ uint32 │ Uint32Kind, Fixed32Kind ║
-// ║ uint64 │ Uint64Kind, Fixed64Kind ║
-// ║ string │ StringKind ║
-// ╚═════════╧═════════════════════════════════════╝
-//
-// A MapKey is constructed and accessed through a Value:
-// k := ValueOf("hash").MapKey() // convert string to MapKey
-// s := k.String() // convert MapKey to string
-//
-// The MapKey is a strict subset of valid types used in Value;
-// converting a Value to a MapKey with an invalid type panics.
-type MapKey value
-
-// IsValid reports whether k is populated with a value.
-func (k MapKey) IsValid() bool {
- return Value(k).IsValid()
-}
-
-// Interface returns k as an interface{}.
-func (k MapKey) Interface() interface{} {
- return Value(k).Interface()
-}
-
-// Bool returns k as a bool and panics if the type is not a bool.
-func (k MapKey) Bool() bool {
- return Value(k).Bool()
-}
-
-// Int returns k as a int64 and panics if the type is not a int32 or int64.
-func (k MapKey) Int() int64 {
- return Value(k).Int()
-}
-
-// Uint returns k as a uint64 and panics if the type is not a uint32 or uint64.
-func (k MapKey) Uint() uint64 {
- return Value(k).Uint()
-}
-
-// String returns k as a string. Since this method implements fmt.Stringer,
-// this returns the formatted string value for any non-string type.
-func (k MapKey) String() string {
- return Value(k).String()
-}
-
-// Value returns k as a Value.
-func (k MapKey) Value() Value {
- return Value(k)
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go
deleted file mode 100644
index c45debd..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package protoreflect
-
-import (
- "unsafe"
-
- "google.golang.org/protobuf/internal/pragma"
-)
-
-type (
- stringHeader struct {
- Data unsafe.Pointer
- Len int
- }
- sliceHeader struct {
- Data unsafe.Pointer
- Len int
- Cap int
- }
- ifaceHeader struct {
- Type unsafe.Pointer
- Data unsafe.Pointer
- }
-)
-
-var (
- nilType = typeOf(nil)
- boolType = typeOf(*new(bool))
- int32Type = typeOf(*new(int32))
- int64Type = typeOf(*new(int64))
- uint32Type = typeOf(*new(uint32))
- uint64Type = typeOf(*new(uint64))
- float32Type = typeOf(*new(float32))
- float64Type = typeOf(*new(float64))
- stringType = typeOf(*new(string))
- bytesType = typeOf(*new([]byte))
- enumType = typeOf(*new(EnumNumber))
-)
-
-// typeOf returns a pointer to the Go type information.
-// The pointer is comparable and equal if and only if the types are identical.
-func typeOf(t interface{}) unsafe.Pointer {
- return (*ifaceHeader)(unsafe.Pointer(&t)).Type
-}
-
-// value is a union where only one type can be represented at a time.
-// The struct is 24B large on 64-bit systems and requires the minimum storage
-// necessary to represent each possible type.
-//
-// The Go GC needs to be able to scan variables containing pointers.
-// As such, pointers and non-pointers cannot be intermixed.
-type value struct {
- pragma.DoNotCompare // 0B
-
- // typ stores the type of the value as a pointer to the Go type.
- typ unsafe.Pointer // 8B
-
- // ptr stores the data pointer for a String, Bytes, or interface value.
- ptr unsafe.Pointer // 8B
-
- // num stores a Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, or
- // Enum value as a raw uint64.
- //
- // It is also used to store the length of a String or Bytes value;
- // the capacity is ignored.
- num uint64 // 8B
-}
-
-func valueOfString(v string) Value {
- p := (*stringHeader)(unsafe.Pointer(&v))
- return Value{typ: stringType, ptr: p.Data, num: uint64(len(v))}
-}
-func valueOfBytes(v []byte) Value {
- p := (*sliceHeader)(unsafe.Pointer(&v))
- return Value{typ: bytesType, ptr: p.Data, num: uint64(len(v))}
-}
-func valueOfIface(v interface{}) Value {
- p := (*ifaceHeader)(unsafe.Pointer(&v))
- return Value{typ: p.Type, ptr: p.Data}
-}
-
-func (v Value) getString() (x string) {
- *(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
- return x
-}
-func (v Value) getBytes() (x []byte) {
- *(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
- return x
-}
-func (v Value) getIface() (x interface{}) {
- *(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
- return x
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go b/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go
deleted file mode 100644
index 43f16c6..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go
+++ /dev/null
@@ -1,768 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoregistry provides data structures to register and lookup
-// protobuf descriptor types.
-//
-// The Files registry contains file descriptors and provides the ability
-// to iterate over the files or lookup a specific descriptor within the files.
-// Files only contains protobuf descriptors and has no understanding of Go
-// type information that may be associated with each descriptor.
-//
-// The Types registry contains descriptor types for which there is a known
-// Go type associated with that descriptor. It provides the ability to iterate
-// over the registered types or lookup a type by name.
-package protoregistry
-
-import (
- "fmt"
- "log"
- "strings"
- "sync"
-
- "google.golang.org/protobuf/internal/errors"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// ignoreConflict reports whether to ignore a registration conflict
-// given the descriptor being registered and the error.
-// It is a variable so that the behavior is easily overridden in another file.
-var ignoreConflict = func(d protoreflect.Descriptor, err error) bool {
- log.Printf(""+
- "WARNING: %v\n"+
- "A future release will panic on registration conflicts. See:\n"+
- "https://developers.google.com/protocol-buffers/docs/reference/go/faq#namespace-conflict\n"+
- "\n", err)
- return true
-}
-
-var globalMutex sync.RWMutex
-
-// GlobalFiles is a global registry of file descriptors.
-var GlobalFiles *Files = new(Files)
-
-// GlobalTypes is the registry used by default for type lookups
-// unless a local registry is provided by the user.
-var GlobalTypes *Types = new(Types)
-
-// NotFound is a sentinel error value to indicate that the type was not found.
-//
-// Since registry lookup can happen in the critical performance path, resolvers
-// must return this exact error value, not an error wrapping it.
-var NotFound = errors.New("not found")
-
-// Files is a registry for looking up or iterating over files and the
-// descriptors contained within them.
-// The Find and Range methods are safe for concurrent use.
-type Files struct {
- // The map of descsByName contains:
- // EnumDescriptor
- // EnumValueDescriptor
- // MessageDescriptor
- // ExtensionDescriptor
- // ServiceDescriptor
- // *packageDescriptor
- //
- // Note that files are stored as a slice, since a package may contain
- // multiple files. Only top-level declarations are registered.
- // Note that enum values are in the top-level since that are in the same
- // scope as the parent enum.
- descsByName map[protoreflect.FullName]interface{}
- filesByPath map[string]protoreflect.FileDescriptor
-}
-
-type packageDescriptor struct {
- files []protoreflect.FileDescriptor
-}
-
-// RegisterFile registers the provided file descriptor.
-//
-// If any descriptor within the file conflicts with the descriptor of any
-// previously registered file (e.g., two enums with the same full name),
-// then the file is not registered and an error is returned.
-//
-// It is permitted for multiple files to have the same file path.
-func (r *Files) RegisterFile(file protoreflect.FileDescriptor) error {
- if r == GlobalFiles {
- globalMutex.Lock()
- defer globalMutex.Unlock()
- }
- if r.descsByName == nil {
- r.descsByName = map[protoreflect.FullName]interface{}{
- "": &packageDescriptor{},
- }
- r.filesByPath = make(map[string]protoreflect.FileDescriptor)
- }
- path := file.Path()
- if prev := r.filesByPath[path]; prev != nil {
- err := errors.New("file %q is already registered", file.Path())
- err = amendErrorWithCaller(err, prev, file)
- if r == GlobalFiles && ignoreConflict(file, err) {
- err = nil
- }
- return err
- }
-
- for name := file.Package(); name != ""; name = name.Parent() {
- switch prev := r.descsByName[name]; prev.(type) {
- case nil, *packageDescriptor:
- default:
- err := errors.New("file %q has a package name conflict over %v", file.Path(), name)
- err = amendErrorWithCaller(err, prev, file)
- if r == GlobalFiles && ignoreConflict(file, err) {
- err = nil
- }
- return err
- }
- }
- var err error
- var hasConflict bool
- rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
- if prev := r.descsByName[d.FullName()]; prev != nil {
- hasConflict = true
- err = errors.New("file %q has a name conflict over %v", file.Path(), d.FullName())
- err = amendErrorWithCaller(err, prev, file)
- if r == GlobalFiles && ignoreConflict(d, err) {
- err = nil
- }
- }
- })
- if hasConflict {
- return err
- }
-
- for name := file.Package(); name != ""; name = name.Parent() {
- if r.descsByName[name] == nil {
- r.descsByName[name] = &packageDescriptor{}
- }
- }
- p := r.descsByName[file.Package()].(*packageDescriptor)
- p.files = append(p.files, file)
- rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
- r.descsByName[d.FullName()] = d
- })
- r.filesByPath[path] = file
- return nil
-}
-
-// FindDescriptorByName looks up a descriptor by the full name.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Files) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
- if r == nil {
- return nil, NotFound
- }
- if r == GlobalFiles {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- prefix := name
- suffix := nameSuffix("")
- for prefix != "" {
- if d, ok := r.descsByName[prefix]; ok {
- switch d := d.(type) {
- case protoreflect.EnumDescriptor:
- if d.FullName() == name {
- return d, nil
- }
- case protoreflect.EnumValueDescriptor:
- if d.FullName() == name {
- return d, nil
- }
- case protoreflect.MessageDescriptor:
- if d.FullName() == name {
- return d, nil
- }
- if d := findDescriptorInMessage(d, suffix); d != nil && d.FullName() == name {
- return d, nil
- }
- case protoreflect.ExtensionDescriptor:
- if d.FullName() == name {
- return d, nil
- }
- case protoreflect.ServiceDescriptor:
- if d.FullName() == name {
- return d, nil
- }
- if d := d.Methods().ByName(suffix.Pop()); d != nil && d.FullName() == name {
- return d, nil
- }
- }
- return nil, NotFound
- }
- prefix = prefix.Parent()
- suffix = nameSuffix(name[len(prefix)+len("."):])
- }
- return nil, NotFound
-}
-
-func findDescriptorInMessage(md protoreflect.MessageDescriptor, suffix nameSuffix) protoreflect.Descriptor {
- name := suffix.Pop()
- if suffix == "" {
- if ed := md.Enums().ByName(name); ed != nil {
- return ed
- }
- for i := md.Enums().Len() - 1; i >= 0; i-- {
- if vd := md.Enums().Get(i).Values().ByName(name); vd != nil {
- return vd
- }
- }
- if xd := md.Extensions().ByName(name); xd != nil {
- return xd
- }
- if fd := md.Fields().ByName(name); fd != nil {
- return fd
- }
- if od := md.Oneofs().ByName(name); od != nil {
- return od
- }
- }
- if md := md.Messages().ByName(name); md != nil {
- if suffix == "" {
- return md
- }
- return findDescriptorInMessage(md, suffix)
- }
- return nil
-}
-
-type nameSuffix string
-
-func (s *nameSuffix) Pop() (name protoreflect.Name) {
- if i := strings.IndexByte(string(*s), '.'); i >= 0 {
- name, *s = protoreflect.Name((*s)[:i]), (*s)[i+1:]
- } else {
- name, *s = protoreflect.Name((*s)), ""
- }
- return name
-}
-
-// FindFileByPath looks up a file by the path.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Files) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
- if r == nil {
- return nil, NotFound
- }
- if r == GlobalFiles {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- if fd, ok := r.filesByPath[path]; ok {
- return fd, nil
- }
- return nil, NotFound
-}
-
-// NumFiles reports the number of registered files.
-func (r *Files) NumFiles() int {
- if r == nil {
- return 0
- }
- if r == GlobalFiles {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- return len(r.filesByPath)
-}
-
-// RangeFiles iterates over all registered files while f returns true.
-// The iteration order is undefined.
-func (r *Files) RangeFiles(f func(protoreflect.FileDescriptor) bool) {
- if r == nil {
- return
- }
- if r == GlobalFiles {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- for _, file := range r.filesByPath {
- if !f(file) {
- return
- }
- }
-}
-
-// NumFilesByPackage reports the number of registered files in a proto package.
-func (r *Files) NumFilesByPackage(name protoreflect.FullName) int {
- if r == nil {
- return 0
- }
- if r == GlobalFiles {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- p, ok := r.descsByName[name].(*packageDescriptor)
- if !ok {
- return 0
- }
- return len(p.files)
-}
-
-// RangeFilesByPackage iterates over all registered files in a given proto package
-// while f returns true. The iteration order is undefined.
-func (r *Files) RangeFilesByPackage(name protoreflect.FullName, f func(protoreflect.FileDescriptor) bool) {
- if r == nil {
- return
- }
- if r == GlobalFiles {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- p, ok := r.descsByName[name].(*packageDescriptor)
- if !ok {
- return
- }
- for _, file := range p.files {
- if !f(file) {
- return
- }
- }
-}
-
-// rangeTopLevelDescriptors iterates over all top-level descriptors in a file
-// which will be directly entered into the registry.
-func rangeTopLevelDescriptors(fd protoreflect.FileDescriptor, f func(protoreflect.Descriptor)) {
- eds := fd.Enums()
- for i := eds.Len() - 1; i >= 0; i-- {
- f(eds.Get(i))
- vds := eds.Get(i).Values()
- for i := vds.Len() - 1; i >= 0; i-- {
- f(vds.Get(i))
- }
- }
- mds := fd.Messages()
- for i := mds.Len() - 1; i >= 0; i-- {
- f(mds.Get(i))
- }
- xds := fd.Extensions()
- for i := xds.Len() - 1; i >= 0; i-- {
- f(xds.Get(i))
- }
- sds := fd.Services()
- for i := sds.Len() - 1; i >= 0; i-- {
- f(sds.Get(i))
- }
-}
-
-// MessageTypeResolver is an interface for looking up messages.
-//
-// A compliant implementation must deterministically return the same type
-// if no error is encountered.
-//
-// The Types type implements this interface.
-type MessageTypeResolver interface {
- // FindMessageByName looks up a message by its full name.
- // E.g., "google.protobuf.Any"
- //
- // This return (nil, NotFound) if not found.
- FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error)
-
- // FindMessageByURL looks up a message by a URL identifier.
- // See documentation on google.protobuf.Any.type_url for the URL format.
- //
- // This returns (nil, NotFound) if not found.
- FindMessageByURL(url string) (protoreflect.MessageType, error)
-}
-
-// ExtensionTypeResolver is an interface for looking up extensions.
-//
-// A compliant implementation must deterministically return the same type
-// if no error is encountered.
-//
-// The Types type implements this interface.
-type ExtensionTypeResolver interface {
- // FindExtensionByName looks up a extension field by the field's full name.
- // Note that this is the full name of the field as determined by
- // where the extension is declared and is unrelated to the full name of the
- // message being extended.
- //
- // This returns (nil, NotFound) if not found.
- FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
-
- // FindExtensionByNumber looks up a extension field by the field number
- // within some parent message, identified by full name.
- //
- // This returns (nil, NotFound) if not found.
- FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
-}
-
-var (
- _ MessageTypeResolver = (*Types)(nil)
- _ ExtensionTypeResolver = (*Types)(nil)
-)
-
-// Types is a registry for looking up or iterating over descriptor types.
-// The Find and Range methods are safe for concurrent use.
-type Types struct {
- typesByName typesByName
- extensionsByMessage extensionsByMessage
-
- numEnums int
- numMessages int
- numExtensions int
-}
-
-type (
- typesByName map[protoreflect.FullName]interface{}
- extensionsByMessage map[protoreflect.FullName]extensionsByNumber
- extensionsByNumber map[protoreflect.FieldNumber]protoreflect.ExtensionType
-)
-
-// RegisterMessage registers the provided message type.
-//
-// If a naming conflict occurs, the type is not registered and an error is returned.
-func (r *Types) RegisterMessage(mt protoreflect.MessageType) error {
- // Under rare circumstances getting the descriptor might recursively
- // examine the registry, so fetch it before locking.
- md := mt.Descriptor()
-
- if r == GlobalTypes {
- globalMutex.Lock()
- defer globalMutex.Unlock()
- }
-
- if err := r.register("message", md, mt); err != nil {
- return err
- }
- r.numMessages++
- return nil
-}
-
-// RegisterEnum registers the provided enum type.
-//
-// If a naming conflict occurs, the type is not registered and an error is returned.
-func (r *Types) RegisterEnum(et protoreflect.EnumType) error {
- // Under rare circumstances getting the descriptor might recursively
- // examine the registry, so fetch it before locking.
- ed := et.Descriptor()
-
- if r == GlobalTypes {
- globalMutex.Lock()
- defer globalMutex.Unlock()
- }
-
- if err := r.register("enum", ed, et); err != nil {
- return err
- }
- r.numEnums++
- return nil
-}
-
-// RegisterExtension registers the provided extension type.
-//
-// If a naming conflict occurs, the type is not registered and an error is returned.
-func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error {
- // Under rare circumstances getting the descriptor might recursively
- // examine the registry, so fetch it before locking.
- //
- // A known case where this can happen: Fetching the TypeDescriptor for a
- // legacy ExtensionDesc can consult the global registry.
- xd := xt.TypeDescriptor()
-
- if r == GlobalTypes {
- globalMutex.Lock()
- defer globalMutex.Unlock()
- }
-
- field := xd.Number()
- message := xd.ContainingMessage().FullName()
- if prev := r.extensionsByMessage[message][field]; prev != nil {
- err := errors.New("extension number %d is already registered on message %v", field, message)
- err = amendErrorWithCaller(err, prev, xt)
- if !(r == GlobalTypes && ignoreConflict(xd, err)) {
- return err
- }
- }
-
- if err := r.register("extension", xd, xt); err != nil {
- return err
- }
- if r.extensionsByMessage == nil {
- r.extensionsByMessage = make(extensionsByMessage)
- }
- if r.extensionsByMessage[message] == nil {
- r.extensionsByMessage[message] = make(extensionsByNumber)
- }
- r.extensionsByMessage[message][field] = xt
- r.numExtensions++
- return nil
-}
-
-func (r *Types) register(kind string, desc protoreflect.Descriptor, typ interface{}) error {
- name := desc.FullName()
- prev := r.typesByName[name]
- if prev != nil {
- err := errors.New("%v %v is already registered", kind, name)
- err = amendErrorWithCaller(err, prev, typ)
- if !(r == GlobalTypes && ignoreConflict(desc, err)) {
- return err
- }
- }
- if r.typesByName == nil {
- r.typesByName = make(typesByName)
- }
- r.typesByName[name] = typ
- return nil
-}
-
-// FindEnumByName looks up an enum by its full name.
-// E.g., "google.protobuf.Field.Kind".
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindEnumByName(enum protoreflect.FullName) (protoreflect.EnumType, error) {
- if r == nil {
- return nil, NotFound
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- if v := r.typesByName[enum]; v != nil {
- if et, _ := v.(protoreflect.EnumType); et != nil {
- return et, nil
- }
- return nil, errors.New("found wrong type: got %v, want enum", typeName(v))
- }
- return nil, NotFound
-}
-
-// FindMessageByName looks up a message by its full name.
-// E.g., "google.protobuf.Any"
-//
-// This return (nil, NotFound) if not found.
-func (r *Types) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
- // The full name by itself is a valid URL.
- return r.FindMessageByURL(string(message))
-}
-
-// FindMessageByURL looks up a message by a URL identifier.
-// See documentation on google.protobuf.Any.type_url for the URL format.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindMessageByURL(url string) (protoreflect.MessageType, error) {
- if r == nil {
- return nil, NotFound
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- message := protoreflect.FullName(url)
- if i := strings.LastIndexByte(url, '/'); i >= 0 {
- message = message[i+len("/"):]
- }
-
- if v := r.typesByName[message]; v != nil {
- if mt, _ := v.(protoreflect.MessageType); mt != nil {
- return mt, nil
- }
- return nil, errors.New("found wrong type: got %v, want message", typeName(v))
- }
- return nil, NotFound
-}
-
-// FindExtensionByName looks up a extension field by the field's full name.
-// Note that this is the full name of the field as determined by
-// where the extension is declared and is unrelated to the full name of the
-// message being extended.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
- if r == nil {
- return nil, NotFound
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- if v := r.typesByName[field]; v != nil {
- if xt, _ := v.(protoreflect.ExtensionType); xt != nil {
- return xt, nil
- }
- return nil, errors.New("found wrong type: got %v, want extension", typeName(v))
- }
- return nil, NotFound
-}
-
-// FindExtensionByNumber looks up a extension field by the field number
-// within some parent message, identified by full name.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
- if r == nil {
- return nil, NotFound
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- if xt, ok := r.extensionsByMessage[message][field]; ok {
- return xt, nil
- }
- return nil, NotFound
-}
-
-// NumEnums reports the number of registered enums.
-func (r *Types) NumEnums() int {
- if r == nil {
- return 0
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- return r.numEnums
-}
-
-// RangeEnums iterates over all registered enums while f returns true.
-// Iteration order is undefined.
-func (r *Types) RangeEnums(f func(protoreflect.EnumType) bool) {
- if r == nil {
- return
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- for _, typ := range r.typesByName {
- if et, ok := typ.(protoreflect.EnumType); ok {
- if !f(et) {
- return
- }
- }
- }
-}
-
-// NumMessages reports the number of registered messages.
-func (r *Types) NumMessages() int {
- if r == nil {
- return 0
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- return r.numMessages
-}
-
-// RangeMessages iterates over all registered messages while f returns true.
-// Iteration order is undefined.
-func (r *Types) RangeMessages(f func(protoreflect.MessageType) bool) {
- if r == nil {
- return
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- for _, typ := range r.typesByName {
- if mt, ok := typ.(protoreflect.MessageType); ok {
- if !f(mt) {
- return
- }
- }
- }
-}
-
-// NumExtensions reports the number of registered extensions.
-func (r *Types) NumExtensions() int {
- if r == nil {
- return 0
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- return r.numExtensions
-}
-
-// RangeExtensions iterates over all registered extensions while f returns true.
-// Iteration order is undefined.
-func (r *Types) RangeExtensions(f func(protoreflect.ExtensionType) bool) {
- if r == nil {
- return
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- for _, typ := range r.typesByName {
- if xt, ok := typ.(protoreflect.ExtensionType); ok {
- if !f(xt) {
- return
- }
- }
- }
-}
-
-// NumExtensionsByMessage reports the number of registered extensions for
-// a given message type.
-func (r *Types) NumExtensionsByMessage(message protoreflect.FullName) int {
- if r == nil {
- return 0
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- return len(r.extensionsByMessage[message])
-}
-
-// RangeExtensionsByMessage iterates over all registered extensions filtered
-// by a given message type while f returns true. Iteration order is undefined.
-func (r *Types) RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool) {
- if r == nil {
- return
- }
- if r == GlobalTypes {
- globalMutex.RLock()
- defer globalMutex.RUnlock()
- }
- for _, xt := range r.extensionsByMessage[message] {
- if !f(xt) {
- return
- }
- }
-}
-
-func typeName(t interface{}) string {
- switch t.(type) {
- case protoreflect.EnumType:
- return "enum"
- case protoreflect.MessageType:
- return "message"
- case protoreflect.ExtensionType:
- return "extension"
- default:
- return fmt.Sprintf("%T", t)
- }
-}
-
-func amendErrorWithCaller(err error, prev, curr interface{}) error {
- prevPkg := goPackage(prev)
- currPkg := goPackage(curr)
- if prevPkg == "" || currPkg == "" || prevPkg == currPkg {
- return err
- }
- return errors.New("%s\n\tpreviously from: %q\n\tcurrently from: %q", err, prevPkg, currPkg)
-}
-
-func goPackage(v interface{}) string {
- switch d := v.(type) {
- case protoreflect.EnumType:
- v = d.Descriptor()
- case protoreflect.MessageType:
- v = d.Descriptor()
- case protoreflect.ExtensionType:
- v = d.TypeDescriptor()
- }
- if d, ok := v.(protoreflect.Descriptor); ok {
- v = d.ParentFile()
- }
- if d, ok := v.(interface{ GoPackagePath() string }); ok {
- return d.GoPackagePath()
- }
- return ""
-}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go b/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go
deleted file mode 100644
index c587276..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoiface
-
-type MessageV1 interface {
- Reset()
- String() string
- ProtoMessage()
-}
-
-type ExtensionRangeV1 struct {
- Start, End int32 // both inclusive
-}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go b/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
deleted file mode 100644
index 32c04f6..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoiface contains types referenced or implemented by messages.
-//
-// WARNING: This package should only be imported by message implementations.
-// The functionality found in this package should be accessed through
-// higher-level abstractions provided by the proto package.
-package protoiface
-
-import (
- "google.golang.org/protobuf/internal/pragma"
- "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Methods is a set of optional fast-path implementations of various operations.
-type Methods = struct {
- pragma.NoUnkeyedLiterals
-
- // Flags indicate support for optional features.
- Flags SupportFlags
-
- // Size returns the size in bytes of the wire-format encoding of a message.
- // Marshal must be provided if a custom Size is provided.
- Size func(SizeInput) SizeOutput
-
- // Marshal formats a message in the wire-format encoding to the provided buffer.
- // Size should be provided if a custom Marshal is provided.
- // It must not return an error for a partial message.
- Marshal func(MarshalInput) (MarshalOutput, error)
-
- // Unmarshal parses the wire-format encoding and merges the result into a message.
- // It must not reset the target message or return an error for a partial message.
- Unmarshal func(UnmarshalInput) (UnmarshalOutput, error)
-
- // Merge merges the contents of a source message into a destination message.
- Merge func(MergeInput) MergeOutput
-
- // CheckInitialized returns an error if any required fields in the message are not set.
- CheckInitialized func(CheckInitializedInput) (CheckInitializedOutput, error)
-}
-
-// SupportFlags indicate support for optional features.
-type SupportFlags = uint64
-
-const (
- // SupportMarshalDeterministic reports whether MarshalOptions.Deterministic is supported.
- SupportMarshalDeterministic SupportFlags = 1 << iota
-
- // SupportUnmarshalDiscardUnknown reports whether UnmarshalOptions.DiscardUnknown is supported.
- SupportUnmarshalDiscardUnknown
-)
-
-// SizeInput is input to the Size method.
-type SizeInput = struct {
- pragma.NoUnkeyedLiterals
-
- Message protoreflect.Message
- Flags MarshalInputFlags
-}
-
-// SizeOutput is output from the Size method.
-type SizeOutput = struct {
- pragma.NoUnkeyedLiterals
-
- Size int
-}
-
-// MarshalInput is input to the Marshal method.
-type MarshalInput = struct {
- pragma.NoUnkeyedLiterals
-
- Message protoreflect.Message
- Buf []byte // output is appended to this buffer
- Flags MarshalInputFlags
-}
-
-// MarshalOutput is output from the Marshal method.
-type MarshalOutput = struct {
- pragma.NoUnkeyedLiterals
-
- Buf []byte // contains marshaled message
-}
-
-// MarshalInputFlags configure the marshaler.
-// Most flags correspond to fields in proto.MarshalOptions.
-type MarshalInputFlags = uint8
-
-const (
- MarshalDeterministic MarshalInputFlags = 1 << iota
- MarshalUseCachedSize
-)
-
-// UnmarshalInput is input to the Unmarshal method.
-type UnmarshalInput = struct {
- pragma.NoUnkeyedLiterals
-
- Message protoreflect.Message
- Buf []byte // input buffer
- Flags UnmarshalInputFlags
- Resolver interface {
- FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
- FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
- }
-}
-
-// UnmarshalOutput is output from the Unmarshal method.
-type UnmarshalOutput = struct {
- pragma.NoUnkeyedLiterals
-
- Flags UnmarshalOutputFlags
-}
-
-// UnmarshalInputFlags configure the unmarshaler.
-// Most flags correspond to fields in proto.UnmarshalOptions.
-type UnmarshalInputFlags = uint8
-
-const (
- UnmarshalDiscardUnknown UnmarshalInputFlags = 1 << iota
-)
-
-// UnmarshalOutputFlags are output from the Unmarshal method.
-type UnmarshalOutputFlags = uint8
-
-const (
- // UnmarshalInitialized may be set on return if all required fields are known to be set.
- // If unset, then it does not necessarily indicate that the message is uninitialized,
- // only that its status could not be confirmed.
- UnmarshalInitialized UnmarshalOutputFlags = 1 << iota
-)
-
-// MergeInput is input to the Merge method.
-type MergeInput = struct {
- pragma.NoUnkeyedLiterals
-
- Source protoreflect.Message
- Destination protoreflect.Message
-}
-
-// MergeOutput is output from the Merge method.
-type MergeOutput = struct {
- pragma.NoUnkeyedLiterals
-
- Flags MergeOutputFlags
-}
-
-// MergeOutputFlags are output from the Merge method.
-type MergeOutputFlags = uint8
-
-const (
- // MergeComplete reports whether the merge was performed.
- // If unset, the merger must have made no changes to the destination.
- MergeComplete MergeOutputFlags = 1 << iota
-)
-
-// CheckInitializedInput is input to the CheckInitialized method.
-type CheckInitializedInput = struct {
- pragma.NoUnkeyedLiterals
-
- Message protoreflect.Message
-}
-
-// CheckInitializedOutput is output from the CheckInitialized method.
-type CheckInitializedOutput = struct {
- pragma.NoUnkeyedLiterals
-}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go b/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go
deleted file mode 100644
index 4a1ab7f..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoimpl contains the default implementation for messages
-// generated by protoc-gen-go.
-//
-// WARNING: This package should only ever be imported by generated messages.
-// The compatibility agreement covers nothing except for functionality needed
-// to keep existing generated messages operational. Breakages that occur due
-// to unauthorized usages of this package are not the author's responsibility.
-package protoimpl
-
-import (
- "google.golang.org/protobuf/internal/filedesc"
- "google.golang.org/protobuf/internal/filetype"
- "google.golang.org/protobuf/internal/impl"
-)
-
-// UnsafeEnabled specifies whether package unsafe can be used.
-const UnsafeEnabled = impl.UnsafeEnabled
-
-type (
- // Types used by generated code in init functions.
- DescBuilder = filedesc.Builder
- TypeBuilder = filetype.Builder
-
- // Types used by generated code to implement EnumType, MessageType, and ExtensionType.
- EnumInfo = impl.EnumInfo
- MessageInfo = impl.MessageInfo
- ExtensionInfo = impl.ExtensionInfo
-
- // Types embedded in generated messages.
- MessageState = impl.MessageState
- SizeCache = impl.SizeCache
- WeakFields = impl.WeakFields
- UnknownFields = impl.UnknownFields
- ExtensionFields = impl.ExtensionFields
- ExtensionFieldV1 = impl.ExtensionField
-
- Pointer = impl.Pointer
-)
-
-var X impl.Export
diff --git a/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go b/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go
deleted file mode 100644
index ff094e1..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoimpl
-
-import (
- "google.golang.org/protobuf/internal/version"
-)
-
-const (
- // MaxVersion is the maximum supported version for generated .pb.go files.
- // It is always the current version of the module.
- MaxVersion = version.Minor
-
- // GenVersion is the runtime version required by generated .pb.go files.
- // This is incremented when generated code relies on new functionality
- // in the runtime.
- GenVersion = 20
-
- // MinVersion is the minimum supported version for generated .pb.go files.
- // This is incremented when the runtime drops support for old code.
- MinVersion = 0
-)
-
-// EnforceVersion is used by code generated by protoc-gen-go
-// to statically enforce minimum and maximum versions of this package.
-// A compilation failure implies either that:
-// * the runtime package is too old and needs to be updated OR
-// * the generated code is too old and needs to be regenerated.
-//
-// The runtime package can be upgraded by running:
-// go get google.golang.org/protobuf
-//
-// The generated code can be regenerated by running:
-// protoc --go_out=${PROTOC_GEN_GO_ARGS} ${PROTO_FILES}
-//
-// Example usage by generated code:
-// const (
-// // Verify that this generated code is sufficiently up-to-date.
-// _ = protoimpl.EnforceVersion(genVersion - protoimpl.MinVersion)
-// // Verify that runtime/protoimpl is sufficiently up-to-date.
-// _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - genVersion)
-// )
-//
-// The genVersion is the current minor version used to generated the code.
-// This compile-time check relies on negative integer overflow of a uint
-// being a compilation failure (guaranteed by the Go specification).
-type EnforceVersion uint
-
-// This enforces the following invariant:
-// MinVersion ≤ GenVersion ≤ MaxVersion
-const (
- _ = EnforceVersion(GenVersion - MinVersion)
- _ = EnforceVersion(MaxVersion - GenVersion)
-)
diff --git a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
deleted file mode 100644
index 8242378..0000000
--- a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
+++ /dev/null
@@ -1,4040 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc. All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-// Based on original Protocol Buffers design by
-// Sanjay Ghemawat, Jeff Dean, and others.
-//
-// The messages in this file describe the definitions found in .proto files.
-// A valid .proto file can be translated directly to a FileDescriptorProto
-// without any other information (e.g. without reading its imports).
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/descriptor.proto
-
-package descriptorpb
-
-import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoiface "google.golang.org/protobuf/runtime/protoiface"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- reflect "reflect"
- sync "sync"
-)
-
-type FieldDescriptorProto_Type int32
-
-const (
- // 0 is reserved for errors.
- // Order is weird for historical reasons.
- FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
- FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2
- // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
- // negative values are likely.
- FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3
- FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
- // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
- // negative values are likely.
- FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5
- FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
- FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
- FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8
- FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9
- // Tag-delimited aggregate.
- // Group type is deprecated and not supported in proto3. However, Proto3
- // implementations should still be able to parse the group wire format and
- // treat group fields as unknown fields.
- FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10
- FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 // Length-delimited aggregate.
- // New in version 2.
- FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12
- FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13
- FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14
- FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
- FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
- FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 // Uses ZigZag encoding.
- FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 // Uses ZigZag encoding.
-)
-
-// Enum value maps for FieldDescriptorProto_Type.
-var (
- FieldDescriptorProto_Type_name = map[int32]string{
- 1: "TYPE_DOUBLE",
- 2: "TYPE_FLOAT",
- 3: "TYPE_INT64",
- 4: "TYPE_UINT64",
- 5: "TYPE_INT32",
- 6: "TYPE_FIXED64",
- 7: "TYPE_FIXED32",
- 8: "TYPE_BOOL",
- 9: "TYPE_STRING",
- 10: "TYPE_GROUP",
- 11: "TYPE_MESSAGE",
- 12: "TYPE_BYTES",
- 13: "TYPE_UINT32",
- 14: "TYPE_ENUM",
- 15: "TYPE_SFIXED32",
- 16: "TYPE_SFIXED64",
- 17: "TYPE_SINT32",
- 18: "TYPE_SINT64",
- }
- FieldDescriptorProto_Type_value = map[string]int32{
- "TYPE_DOUBLE": 1,
- "TYPE_FLOAT": 2,
- "TYPE_INT64": 3,
- "TYPE_UINT64": 4,
- "TYPE_INT32": 5,
- "TYPE_FIXED64": 6,
- "TYPE_FIXED32": 7,
- "TYPE_BOOL": 8,
- "TYPE_STRING": 9,
- "TYPE_GROUP": 10,
- "TYPE_MESSAGE": 11,
- "TYPE_BYTES": 12,
- "TYPE_UINT32": 13,
- "TYPE_ENUM": 14,
- "TYPE_SFIXED32": 15,
- "TYPE_SFIXED64": 16,
- "TYPE_SINT32": 17,
- "TYPE_SINT64": 18,
- }
-)
-
-func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
- p := new(FieldDescriptorProto_Type)
- *p = x
- return p
-}
-
-func (x FieldDescriptorProto_Type) String() string {
- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldDescriptorProto_Type) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[0].Descriptor()
-}
-
-func (FieldDescriptorProto_Type) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[0]
-}
-
-func (x FieldDescriptorProto_Type) Number() protoreflect.EnumNumber {
- return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldDescriptorProto_Type) UnmarshalJSON(b []byte) error {
- num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
- if err != nil {
- return err
- }
- *x = FieldDescriptorProto_Type(num)
- return nil
-}
-
-// Deprecated: Use FieldDescriptorProto_Type.Descriptor instead.
-func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 0}
-}
-
-type FieldDescriptorProto_Label int32
-
-const (
- // 0 is reserved for errors
- FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
- FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
- FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
-)
-
-// Enum value maps for FieldDescriptorProto_Label.
-var (
- FieldDescriptorProto_Label_name = map[int32]string{
- 1: "LABEL_OPTIONAL",
- 2: "LABEL_REQUIRED",
- 3: "LABEL_REPEATED",
- }
- FieldDescriptorProto_Label_value = map[string]int32{
- "LABEL_OPTIONAL": 1,
- "LABEL_REQUIRED": 2,
- "LABEL_REPEATED": 3,
- }
-)
-
-func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
- p := new(FieldDescriptorProto_Label)
- *p = x
- return p
-}
-
-func (x FieldDescriptorProto_Label) String() string {
- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldDescriptorProto_Label) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor()
-}
-
-func (FieldDescriptorProto_Label) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[1]
-}
-
-func (x FieldDescriptorProto_Label) Number() protoreflect.EnumNumber {
- return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldDescriptorProto_Label) UnmarshalJSON(b []byte) error {
- num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
- if err != nil {
- return err
- }
- *x = FieldDescriptorProto_Label(num)
- return nil
-}
-
-// Deprecated: Use FieldDescriptorProto_Label.Descriptor instead.
-func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 1}
-}
-
-// Generated classes can be optimized for speed or code size.
-type FileOptions_OptimizeMode int32
-
-const (
- FileOptions_SPEED FileOptions_OptimizeMode = 1 // Generate complete code for parsing, serialization,
- // etc.
- FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 // Use ReflectionOps to implement these methods.
- FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 // Generate code using MessageLite and the lite runtime.
-)
-
-// Enum value maps for FileOptions_OptimizeMode.
-var (
- FileOptions_OptimizeMode_name = map[int32]string{
- 1: "SPEED",
- 2: "CODE_SIZE",
- 3: "LITE_RUNTIME",
- }
- FileOptions_OptimizeMode_value = map[string]int32{
- "SPEED": 1,
- "CODE_SIZE": 2,
- "LITE_RUNTIME": 3,
- }
-)
-
-func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
- p := new(FileOptions_OptimizeMode)
- *p = x
- return p
-}
-
-func (x FileOptions_OptimizeMode) String() string {
- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FileOptions_OptimizeMode) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor()
-}
-
-func (FileOptions_OptimizeMode) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[2]
-}
-
-func (x FileOptions_OptimizeMode) Number() protoreflect.EnumNumber {
- return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FileOptions_OptimizeMode) UnmarshalJSON(b []byte) error {
- num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
- if err != nil {
- return err
- }
- *x = FileOptions_OptimizeMode(num)
- return nil
-}
-
-// Deprecated: Use FileOptions_OptimizeMode.Descriptor instead.
-func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10, 0}
-}
-
-type FieldOptions_CType int32
-
-const (
- // Default mode.
- FieldOptions_STRING FieldOptions_CType = 0
- FieldOptions_CORD FieldOptions_CType = 1
- FieldOptions_STRING_PIECE FieldOptions_CType = 2
-)
-
-// Enum value maps for FieldOptions_CType.
-var (
- FieldOptions_CType_name = map[int32]string{
- 0: "STRING",
- 1: "CORD",
- 2: "STRING_PIECE",
- }
- FieldOptions_CType_value = map[string]int32{
- "STRING": 0,
- "CORD": 1,
- "STRING_PIECE": 2,
- }
-)
-
-func (x FieldOptions_CType) Enum() *FieldOptions_CType {
- p := new(FieldOptions_CType)
- *p = x
- return p
-}
-
-func (x FieldOptions_CType) String() string {
- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldOptions_CType) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor()
-}
-
-func (FieldOptions_CType) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[3]
-}
-
-func (x FieldOptions_CType) Number() protoreflect.EnumNumber {
- return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldOptions_CType) UnmarshalJSON(b []byte) error {
- num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
- if err != nil {
- return err
- }
- *x = FieldOptions_CType(num)
- return nil
-}
-
-// Deprecated: Use FieldOptions_CType.Descriptor instead.
-func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0}
-}
-
-type FieldOptions_JSType int32
-
-const (
- // Use the default type.
- FieldOptions_JS_NORMAL FieldOptions_JSType = 0
- // Use JavaScript strings.
- FieldOptions_JS_STRING FieldOptions_JSType = 1
- // Use JavaScript numbers.
- FieldOptions_JS_NUMBER FieldOptions_JSType = 2
-)
-
-// Enum value maps for FieldOptions_JSType.
-var (
- FieldOptions_JSType_name = map[int32]string{
- 0: "JS_NORMAL",
- 1: "JS_STRING",
- 2: "JS_NUMBER",
- }
- FieldOptions_JSType_value = map[string]int32{
- "JS_NORMAL": 0,
- "JS_STRING": 1,
- "JS_NUMBER": 2,
- }
-)
-
-func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
- p := new(FieldOptions_JSType)
- *p = x
- return p
-}
-
-func (x FieldOptions_JSType) String() string {
- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldOptions_JSType) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor()
-}
-
-func (FieldOptions_JSType) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[4]
-}
-
-func (x FieldOptions_JSType) Number() protoreflect.EnumNumber {
- return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldOptions_JSType) UnmarshalJSON(b []byte) error {
- num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
- if err != nil {
- return err
- }
- *x = FieldOptions_JSType(num)
- return nil
-}
-
-// Deprecated: Use FieldOptions_JSType.Descriptor instead.
-func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 1}
-}
-
-// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
-// or neither? HTTP based RPC implementation may choose GET verb for safe
-// methods, and PUT verb for idempotent methods instead of the default POST.
-type MethodOptions_IdempotencyLevel int32
-
-const (
- MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
- MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1 // implies idempotent
- MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2 // idempotent, but may have side effects
-)
-
-// Enum value maps for MethodOptions_IdempotencyLevel.
-var (
- MethodOptions_IdempotencyLevel_name = map[int32]string{
- 0: "IDEMPOTENCY_UNKNOWN",
- 1: "NO_SIDE_EFFECTS",
- 2: "IDEMPOTENT",
- }
- MethodOptions_IdempotencyLevel_value = map[string]int32{
- "IDEMPOTENCY_UNKNOWN": 0,
- "NO_SIDE_EFFECTS": 1,
- "IDEMPOTENT": 2,
- }
-)
-
-func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
- p := new(MethodOptions_IdempotencyLevel)
- *p = x
- return p
-}
-
-func (x MethodOptions_IdempotencyLevel) String() string {
- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (MethodOptions_IdempotencyLevel) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor()
-}
-
-func (MethodOptions_IdempotencyLevel) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[5]
-}
-
-func (x MethodOptions_IdempotencyLevel) Number() protoreflect.EnumNumber {
- return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(b []byte) error {
- num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
- if err != nil {
- return err
- }
- *x = MethodOptions_IdempotencyLevel(num)
- return nil
-}
-
-// Deprecated: Use MethodOptions_IdempotencyLevel.Descriptor instead.
-func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17, 0}
-}
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-type FileDescriptorSet struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
-}
-
-func (x *FileDescriptorSet) Reset() {
- *x = FileDescriptorSet{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *FileDescriptorSet) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FileDescriptorSet) ProtoMessage() {}
-
-func (x *FileDescriptorSet) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
- if 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 FileDescriptorSet.ProtoReflect.Descriptor instead.
-func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *FileDescriptorSet) GetFile() []*FileDescriptorProto {
- if x != nil {
- return x.File
- }
- return nil
-}
-
-// Describes a complete .proto file.
-type FileDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // file name, relative to root of source tree
- Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` // e.g. "foo", "foo.bar", etc.
- // Names of files imported by this file.
- Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
- // Indexes of the public imported files in the dependency list above.
- PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
- // Indexes of the weak imported files in the dependency list.
- // For Google-internal migration only. Do not use.
- WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
- // All top-level definitions in this file.
- MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
- EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
- Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
- Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
- Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
- // This field contains optional information about the original source code.
- // You may safely remove this entire field without harming runtime
- // functionality of the descriptors -- the information is needed only by
- // development tools.
- SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
- // The syntax of the proto file.
- // The supported values are "proto2" and "proto3".
- Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
-}
-
-func (x *FileDescriptorProto) Reset() {
- *x = FileDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *FileDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FileDescriptorProto) ProtoMessage() {}
-
-func (x *FileDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
- if 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 FileDescriptorProto.ProtoReflect.Descriptor instead.
-func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *FileDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *FileDescriptorProto) GetPackage() string {
- if x != nil && x.Package != nil {
- return *x.Package
- }
- return ""
-}
-
-func (x *FileDescriptorProto) GetDependency() []string {
- if x != nil {
- return x.Dependency
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetPublicDependency() []int32 {
- if x != nil {
- return x.PublicDependency
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetWeakDependency() []int32 {
- if x != nil {
- return x.WeakDependency
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetMessageType() []*DescriptorProto {
- if x != nil {
- return x.MessageType
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
- if x != nil {
- return x.EnumType
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
- if x != nil {
- return x.Service
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
- if x != nil {
- return x.Extension
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetOptions() *FileOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
- if x != nil {
- return x.SourceCodeInfo
- }
- return nil
-}
-
-func (x *FileDescriptorProto) GetSyntax() string {
- if x != nil && x.Syntax != nil {
- return *x.Syntax
- }
- return ""
-}
-
-// Describes a message type.
-type DescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
- Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
- NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
- EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
- ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
- OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
- Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
- ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
- // Reserved field names, which may not be used by fields in the same message.
- // A given name may only be reserved once.
- ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-}
-
-func (x *DescriptorProto) Reset() {
- *x = DescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *DescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DescriptorProto) ProtoMessage() {}
-
-func (x *DescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
- if 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 DescriptorProto.ProtoReflect.Descriptor instead.
-func (*DescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *DescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *DescriptorProto) GetField() []*FieldDescriptorProto {
- if x != nil {
- return x.Field
- }
- return nil
-}
-
-func (x *DescriptorProto) GetExtension() []*FieldDescriptorProto {
- if x != nil {
- return x.Extension
- }
- return nil
-}
-
-func (x *DescriptorProto) GetNestedType() []*DescriptorProto {
- if x != nil {
- return x.NestedType
- }
- return nil
-}
-
-func (x *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
- if x != nil {
- return x.EnumType
- }
- return nil
-}
-
-func (x *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
- if x != nil {
- return x.ExtensionRange
- }
- return nil
-}
-
-func (x *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
- if x != nil {
- return x.OneofDecl
- }
- return nil
-}
-
-func (x *DescriptorProto) GetOptions() *MessageOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-func (x *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
- if x != nil {
- return x.ReservedRange
- }
- return nil
-}
-
-func (x *DescriptorProto) GetReservedName() []string {
- if x != nil {
- return x.ReservedName
- }
- return nil
-}
-
-type ExtensionRangeOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-func (x *ExtensionRangeOptions) Reset() {
- *x = ExtensionRangeOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *ExtensionRangeOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ExtensionRangeOptions) ProtoMessage() {}
-
-func (x *ExtensionRangeOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
- if 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 ExtensionRangeOptions.ProtoReflect.Descriptor instead.
-func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3}
-}
-
-var extRange_ExtensionRangeOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*ExtensionRangeOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_ExtensionRangeOptions
-}
-
-func (x *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-// Describes a field within a message.
-type FieldDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
- Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
- // If type_name is set, this need not be set. If both this and type_name
- // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
- Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
- // For message and enum types, this is the name of the type. If the name
- // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
- // rules are used to find the type (i.e. first the nested types within this
- // message are searched, then within the parent, on up to the root
- // namespace).
- TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
- // For extensions, this is the name of the type being extended. It is
- // resolved in the same manner as type_name.
- Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
- // For numeric types, contains the original text representation of the value.
- // For booleans, "true" or "false".
- // For strings, contains the default text contents (not escaped in any way).
- // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
- // TODO(kenton): Base-64 encode?
- DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
- // If set, gives the index of a oneof in the containing type's oneof_decl
- // list. This field is a member of that oneof.
- OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
- // JSON name of this field. The value is set by protocol compiler. If the
- // user has set a "json_name" option on this field, that option's value
- // will be used. Otherwise, it's deduced from the field's name by converting
- // it to camelCase.
- JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
- Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
- // If true, this is a proto3 "optional". When a proto3 field is optional, it
- // tracks presence regardless of field type.
- //
- // When proto3_optional is true, this field must be belong to a oneof to
- // signal to old proto3 clients that presence is tracked for this field. This
- // oneof is known as a "synthetic" oneof, and this field must be its sole
- // member (each proto3 optional field gets its own synthetic oneof). Synthetic
- // oneofs exist in the descriptor only, and do not generate any API. Synthetic
- // oneofs must be ordered after all "real" oneofs.
- //
- // For message fields, proto3_optional doesn't create any semantic change,
- // since non-repeated message fields always track presence. However it still
- // indicates the semantic detail of whether the user wrote "optional" or not.
- // This can be useful for round-tripping the .proto file. For consistency we
- // give message fields a synthetic oneof also, even though it is not required
- // to track presence. This is especially important because the parser can't
- // tell if a field is a message or an enum, so it must always create a
- // synthetic oneof.
- //
- // Proto2 optional fields do not set this flag, because they already indicate
- // optional with `LABEL_OPTIONAL`.
- Proto3Optional *bool `protobuf:"varint,17,opt,name=proto3_optional,json=proto3Optional" json:"proto3_optional,omitempty"`
-}
-
-func (x *FieldDescriptorProto) Reset() {
- *x = FieldDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *FieldDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FieldDescriptorProto) ProtoMessage() {}
-
-func (x *FieldDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
- if 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 FieldDescriptorProto.ProtoReflect.Descriptor instead.
-func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *FieldDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *FieldDescriptorProto) GetNumber() int32 {
- if x != nil && x.Number != nil {
- return *x.Number
- }
- return 0
-}
-
-func (x *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
- if x != nil && x.Label != nil {
- return *x.Label
- }
- return FieldDescriptorProto_LABEL_OPTIONAL
-}
-
-func (x *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
- if x != nil && x.Type != nil {
- return *x.Type
- }
- return FieldDescriptorProto_TYPE_DOUBLE
-}
-
-func (x *FieldDescriptorProto) GetTypeName() string {
- if x != nil && x.TypeName != nil {
- return *x.TypeName
- }
- return ""
-}
-
-func (x *FieldDescriptorProto) GetExtendee() string {
- if x != nil && x.Extendee != nil {
- return *x.Extendee
- }
- return ""
-}
-
-func (x *FieldDescriptorProto) GetDefaultValue() string {
- if x != nil && x.DefaultValue != nil {
- return *x.DefaultValue
- }
- return ""
-}
-
-func (x *FieldDescriptorProto) GetOneofIndex() int32 {
- if x != nil && x.OneofIndex != nil {
- return *x.OneofIndex
- }
- return 0
-}
-
-func (x *FieldDescriptorProto) GetJsonName() string {
- if x != nil && x.JsonName != nil {
- return *x.JsonName
- }
- return ""
-}
-
-func (x *FieldDescriptorProto) GetOptions() *FieldOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-func (x *FieldDescriptorProto) GetProto3Optional() bool {
- if x != nil && x.Proto3Optional != nil {
- return *x.Proto3Optional
- }
- return false
-}
-
-// Describes a oneof.
-type OneofDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *OneofDescriptorProto) Reset() {
- *x = OneofDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *OneofDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*OneofDescriptorProto) ProtoMessage() {}
-
-func (x *OneofDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
- if 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 OneofDescriptorProto.ProtoReflect.Descriptor instead.
-func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *OneofDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *OneofDescriptorProto) GetOptions() *OneofOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-// Describes an enum type.
-type EnumDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
- Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
- // Range of reserved numeric values. Reserved numeric values may not be used
- // by enum values in the same enum declaration. Reserved ranges may not
- // overlap.
- ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
- // Reserved enum value names, which may not be reused. A given name may only
- // be reserved once.
- ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-}
-
-func (x *EnumDescriptorProto) Reset() {
- *x = EnumDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *EnumDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumDescriptorProto) ProtoMessage() {}
-
-func (x *EnumDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
- if 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 EnumDescriptorProto.ProtoReflect.Descriptor instead.
-func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *EnumDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
- if x != nil {
- return x.Value
- }
- return nil
-}
-
-func (x *EnumDescriptorProto) GetOptions() *EnumOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-func (x *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
- if x != nil {
- return x.ReservedRange
- }
- return nil
-}
-
-func (x *EnumDescriptorProto) GetReservedName() []string {
- if x != nil {
- return x.ReservedName
- }
- return nil
-}
-
-// Describes a value within an enum.
-type EnumValueDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
- Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *EnumValueDescriptorProto) Reset() {
- *x = EnumValueDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *EnumValueDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumValueDescriptorProto) ProtoMessage() {}
-
-func (x *EnumValueDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
- if 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 EnumValueDescriptorProto.ProtoReflect.Descriptor instead.
-func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{7}
-}
-
-func (x *EnumValueDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *EnumValueDescriptorProto) GetNumber() int32 {
- if x != nil && x.Number != nil {
- return *x.Number
- }
- return 0
-}
-
-func (x *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-// Describes a service.
-type ServiceDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
- Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *ServiceDescriptorProto) Reset() {
- *x = ServiceDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *ServiceDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ServiceDescriptorProto) ProtoMessage() {}
-
-func (x *ServiceDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
- if 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 ServiceDescriptorProto.ProtoReflect.Descriptor instead.
-func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{8}
-}
-
-func (x *ServiceDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
- if x != nil {
- return x.Method
- }
- return nil
-}
-
-func (x *ServiceDescriptorProto) GetOptions() *ServiceOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-// Describes a method of a service.
-type MethodDescriptorProto struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
- // Input and output type names. These are resolved in the same way as
- // FieldDescriptorProto.type_name, but must refer to a message type.
- InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
- OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
- Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
- // Identifies if client streams multiple client messages
- ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
- // Identifies if server streams multiple server messages
- ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
-}
-
-// Default values for MethodDescriptorProto fields.
-const (
- Default_MethodDescriptorProto_ClientStreaming = bool(false)
- Default_MethodDescriptorProto_ServerStreaming = bool(false)
-)
-
-func (x *MethodDescriptorProto) Reset() {
- *x = MethodDescriptorProto{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *MethodDescriptorProto) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MethodDescriptorProto) ProtoMessage() {}
-
-func (x *MethodDescriptorProto) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
- if 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 MethodDescriptorProto.ProtoReflect.Descriptor instead.
-func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{9}
-}
-
-func (x *MethodDescriptorProto) GetName() string {
- if x != nil && x.Name != nil {
- return *x.Name
- }
- return ""
-}
-
-func (x *MethodDescriptorProto) GetInputType() string {
- if x != nil && x.InputType != nil {
- return *x.InputType
- }
- return ""
-}
-
-func (x *MethodDescriptorProto) GetOutputType() string {
- if x != nil && x.OutputType != nil {
- return *x.OutputType
- }
- return ""
-}
-
-func (x *MethodDescriptorProto) GetOptions() *MethodOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-func (x *MethodDescriptorProto) GetClientStreaming() bool {
- if x != nil && x.ClientStreaming != nil {
- return *x.ClientStreaming
- }
- return Default_MethodDescriptorProto_ClientStreaming
-}
-
-func (x *MethodDescriptorProto) GetServerStreaming() bool {
- if x != nil && x.ServerStreaming != nil {
- return *x.ServerStreaming
- }
- return Default_MethodDescriptorProto_ServerStreaming
-}
-
-type FileOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // Sets the Java package where classes generated from this .proto will be
- // placed. By default, the proto package is used, but this is often
- // inappropriate because proto packages do not normally start with backwards
- // domain names.
- JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
- // If set, all the classes from the .proto file are wrapped in a single
- // outer class with the given name. This applies to both Proto1
- // (equivalent to the old "--one_java_file" option) and Proto2 (where
- // a .proto always translates to a single class, but you may want to
- // explicitly choose the class name).
- JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
- // If set true, then the Java code generator will generate a separate .java
- // file for each top-level message, enum, and service defined in the .proto
- // file. Thus, these types will *not* be nested inside the outer class
- // named by java_outer_classname. However, the outer class will still be
- // generated to contain the file's getDescriptor() method as well as any
- // top-level extensions defined in the file.
- JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
- // This option does nothing.
- //
- // Deprecated: Do not use.
- JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"`
- // If set true, then the Java2 code generator will generate code that
- // throws an exception whenever an attempt is made to assign a non-UTF-8
- // byte sequence to a string field.
- // Message reflection will do the same.
- // However, an extension field still accepts non-UTF-8 byte sequences.
- // This option has no effect on when used with the lite runtime.
- JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
- OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
- // Sets the Go package where structs generated from this .proto will be
- // placed. If omitted, the Go package will be derived from the following:
- // - The basename of the package import path, if provided.
- // - Otherwise, the package statement in the .proto file, if present.
- // - Otherwise, the basename of the .proto file, without extension.
- GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
- // Should generic services be generated in each language? "Generic" services
- // are not specific to any particular RPC system. They are generated by the
- // main code generators in each language (without additional plugins).
- // Generic services were the only kind of service generation supported by
- // early versions of google.protobuf.
- //
- // Generic services are now considered deprecated in favor of using plugins
- // that generate code specific to your particular RPC system. Therefore,
- // these default to false. Old code which depends on generic services should
- // explicitly set them to true.
- CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
- JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
- PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
- PhpGenericServices *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
- // Is this file deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for everything in the file, or it will be completely ignored; in the very
- // least, this is a formalization for deprecating files.
- Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- // Enables the use of arenas for the proto messages in this file. This applies
- // only to generated classes for C++.
- CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=1" json:"cc_enable_arenas,omitempty"`
- // Sets the objective c class prefix which is prepended to all objective c
- // generated classes from this .proto. There is no default.
- ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
- // Namespace for generated classes; defaults to the package.
- CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
- // By default Swift generators will take the proto package and CamelCase it
- // replacing '.' with underscore and use that to prefix the types/symbols
- // defined. When this options is provided, they will use this value instead
- // to prefix the types/symbols defined.
- SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
- // Sets the php class prefix which is prepended to all php generated classes
- // from this .proto. Default is empty.
- PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
- // Use this option to change the namespace of php generated classes. Default
- // is empty. When this option is empty, the package name will be used for
- // determining the namespace.
- PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
- // Use this option to change the namespace of php generated metadata classes.
- // Default is empty. When this option is empty, the proto file name will be
- // used for determining the namespace.
- PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
- // Use this option to change the package of ruby generated classes. Default
- // is empty. When this option is not set, the package name will be used for
- // determining the ruby package.
- RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
- // The parser stores options it doesn't recognize here.
- // See the documentation for the "Options" section above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for FileOptions fields.
-const (
- Default_FileOptions_JavaMultipleFiles = bool(false)
- Default_FileOptions_JavaStringCheckUtf8 = bool(false)
- Default_FileOptions_OptimizeFor = FileOptions_SPEED
- Default_FileOptions_CcGenericServices = bool(false)
- Default_FileOptions_JavaGenericServices = bool(false)
- Default_FileOptions_PyGenericServices = bool(false)
- Default_FileOptions_PhpGenericServices = bool(false)
- Default_FileOptions_Deprecated = bool(false)
- Default_FileOptions_CcEnableArenas = bool(true)
-)
-
-func (x *FileOptions) Reset() {
- *x = FileOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *FileOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FileOptions) ProtoMessage() {}
-
-func (x *FileOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
- if 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 FileOptions.ProtoReflect.Descriptor instead.
-func (*FileOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10}
-}
-
-var extRange_FileOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use FileOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*FileOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_FileOptions
-}
-
-func (x *FileOptions) GetJavaPackage() string {
- if x != nil && x.JavaPackage != nil {
- return *x.JavaPackage
- }
- return ""
-}
-
-func (x *FileOptions) GetJavaOuterClassname() string {
- if x != nil && x.JavaOuterClassname != nil {
- return *x.JavaOuterClassname
- }
- return ""
-}
-
-func (x *FileOptions) GetJavaMultipleFiles() bool {
- if x != nil && x.JavaMultipleFiles != nil {
- return *x.JavaMultipleFiles
- }
- return Default_FileOptions_JavaMultipleFiles
-}
-
-// Deprecated: Do not use.
-func (x *FileOptions) GetJavaGenerateEqualsAndHash() bool {
- if x != nil && x.JavaGenerateEqualsAndHash != nil {
- return *x.JavaGenerateEqualsAndHash
- }
- return false
-}
-
-func (x *FileOptions) GetJavaStringCheckUtf8() bool {
- if x != nil && x.JavaStringCheckUtf8 != nil {
- return *x.JavaStringCheckUtf8
- }
- return Default_FileOptions_JavaStringCheckUtf8
-}
-
-func (x *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
- if x != nil && x.OptimizeFor != nil {
- return *x.OptimizeFor
- }
- return Default_FileOptions_OptimizeFor
-}
-
-func (x *FileOptions) GetGoPackage() string {
- if x != nil && x.GoPackage != nil {
- return *x.GoPackage
- }
- return ""
-}
-
-func (x *FileOptions) GetCcGenericServices() bool {
- if x != nil && x.CcGenericServices != nil {
- return *x.CcGenericServices
- }
- return Default_FileOptions_CcGenericServices
-}
-
-func (x *FileOptions) GetJavaGenericServices() bool {
- if x != nil && x.JavaGenericServices != nil {
- return *x.JavaGenericServices
- }
- return Default_FileOptions_JavaGenericServices
-}
-
-func (x *FileOptions) GetPyGenericServices() bool {
- if x != nil && x.PyGenericServices != nil {
- return *x.PyGenericServices
- }
- return Default_FileOptions_PyGenericServices
-}
-
-func (x *FileOptions) GetPhpGenericServices() bool {
- if x != nil && x.PhpGenericServices != nil {
- return *x.PhpGenericServices
- }
- return Default_FileOptions_PhpGenericServices
-}
-
-func (x *FileOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_FileOptions_Deprecated
-}
-
-func (x *FileOptions) GetCcEnableArenas() bool {
- if x != nil && x.CcEnableArenas != nil {
- return *x.CcEnableArenas
- }
- return Default_FileOptions_CcEnableArenas
-}
-
-func (x *FileOptions) GetObjcClassPrefix() string {
- if x != nil && x.ObjcClassPrefix != nil {
- return *x.ObjcClassPrefix
- }
- return ""
-}
-
-func (x *FileOptions) GetCsharpNamespace() string {
- if x != nil && x.CsharpNamespace != nil {
- return *x.CsharpNamespace
- }
- return ""
-}
-
-func (x *FileOptions) GetSwiftPrefix() string {
- if x != nil && x.SwiftPrefix != nil {
- return *x.SwiftPrefix
- }
- return ""
-}
-
-func (x *FileOptions) GetPhpClassPrefix() string {
- if x != nil && x.PhpClassPrefix != nil {
- return *x.PhpClassPrefix
- }
- return ""
-}
-
-func (x *FileOptions) GetPhpNamespace() string {
- if x != nil && x.PhpNamespace != nil {
- return *x.PhpNamespace
- }
- return ""
-}
-
-func (x *FileOptions) GetPhpMetadataNamespace() string {
- if x != nil && x.PhpMetadataNamespace != nil {
- return *x.PhpMetadataNamespace
- }
- return ""
-}
-
-func (x *FileOptions) GetRubyPackage() string {
- if x != nil && x.RubyPackage != nil {
- return *x.RubyPackage
- }
- return ""
-}
-
-func (x *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type MessageOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // Set true to use the old proto1 MessageSet wire format for extensions.
- // This is provided for backwards-compatibility with the MessageSet wire
- // format. You should not use this for any other reason: It's less
- // efficient, has fewer features, and is more complicated.
- //
- // The message must be defined exactly as follows:
- // message Foo {
- // option message_set_wire_format = true;
- // extensions 4 to max;
- // }
- // Note that the message cannot have any defined fields; MessageSets only
- // have extensions.
- //
- // All extensions of your type must be singular messages; e.g. they cannot
- // be int32s, enums, or repeated messages.
- //
- // Because this is an option, the above two restrictions are not enforced by
- // the protocol compiler.
- MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
- // Disables the generation of the standard "descriptor()" accessor, which can
- // conflict with a field of the same name. This is meant to make migration
- // from proto1 easier; new code should avoid fields named "descriptor".
- NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
- // Is this message deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for the message, or it will be completely ignored; in the very least,
- // this is a formalization for deprecating messages.
- Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- // Whether the message is an automatically generated map entry type for the
- // maps field.
- //
- // For maps fields:
- // map<KeyType, ValueType> map_field = 1;
- // The parsed descriptor looks like:
- // message MapFieldEntry {
- // option map_entry = true;
- // optional KeyType key = 1;
- // optional ValueType value = 2;
- // }
- // repeated MapFieldEntry map_field = 1;
- //
- // Implementations may choose not to generate the map_entry=true message, but
- // use a native map in the target language to hold the keys and values.
- // The reflection APIs in such implementations still need to work as
- // if the field is a repeated message field.
- //
- // NOTE: Do not set the option in .proto files. Always use the maps syntax
- // instead. The option should only be implicitly set by the proto compiler
- // parser.
- MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for MessageOptions fields.
-const (
- Default_MessageOptions_MessageSetWireFormat = bool(false)
- Default_MessageOptions_NoStandardDescriptorAccessor = bool(false)
- Default_MessageOptions_Deprecated = bool(false)
-)
-
-func (x *MessageOptions) Reset() {
- *x = MessageOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *MessageOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MessageOptions) ProtoMessage() {}
-
-func (x *MessageOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
- if 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 MessageOptions.ProtoReflect.Descriptor instead.
-func (*MessageOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{11}
-}
-
-var extRange_MessageOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use MessageOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*MessageOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_MessageOptions
-}
-
-func (x *MessageOptions) GetMessageSetWireFormat() bool {
- if x != nil && x.MessageSetWireFormat != nil {
- return *x.MessageSetWireFormat
- }
- return Default_MessageOptions_MessageSetWireFormat
-}
-
-func (x *MessageOptions) GetNoStandardDescriptorAccessor() bool {
- if x != nil && x.NoStandardDescriptorAccessor != nil {
- return *x.NoStandardDescriptorAccessor
- }
- return Default_MessageOptions_NoStandardDescriptorAccessor
-}
-
-func (x *MessageOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_MessageOptions_Deprecated
-}
-
-func (x *MessageOptions) GetMapEntry() bool {
- if x != nil && x.MapEntry != nil {
- return *x.MapEntry
- }
- return false
-}
-
-func (x *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type FieldOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // The ctype option instructs the C++ code generator to use a different
- // representation of the field than it normally would. See the specific
- // options below. This option is not yet implemented in the open source
- // release -- sorry, we'll try to include it in a future version!
- Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
- // The packed option can be enabled for repeated primitive fields to enable
- // a more efficient representation on the wire. Rather than repeatedly
- // writing the tag and type for each element, the entire array is encoded as
- // a single length-delimited blob. In proto3, only explicit setting it to
- // false will avoid using packed encoding.
- Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
- // The jstype option determines the JavaScript type used for values of the
- // field. The option is permitted only for 64 bit integral and fixed types
- // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
- // is represented as JavaScript string, which avoids loss of precision that
- // can happen when a large value is converted to a floating point JavaScript.
- // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
- // use the JavaScript "number" type. The behavior of the default option
- // JS_NORMAL is implementation dependent.
- //
- // This option is an enum to permit additional types to be added, e.g.
- // goog.math.Integer.
- Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
- // Should this field be parsed lazily? Lazy applies only to message-type
- // fields. It means that when the outer message is initially parsed, the
- // inner message's contents will not be parsed but instead stored in encoded
- // form. The inner message will actually be parsed when it is first accessed.
- //
- // This is only a hint. Implementations are free to choose whether to use
- // eager or lazy parsing regardless of the value of this option. However,
- // setting this option true suggests that the protocol author believes that
- // using lazy parsing on this field is worth the additional bookkeeping
- // overhead typically needed to implement it.
- //
- // This option does not affect the public interface of any generated code;
- // all method signatures remain the same. Furthermore, thread-safety of the
- // interface is not affected by this option; const methods remain safe to
- // call from multiple threads concurrently, while non-const methods continue
- // to require exclusive access.
- //
- //
- // Note that implementations may choose not to check required fields within
- // a lazy sub-message. That is, calling IsInitialized() on the outer message
- // may return true even if the inner message has missing required fields.
- // This is necessary because otherwise the inner message would have to be
- // parsed in order to perform the check, defeating the purpose of lazy
- // parsing. An implementation which chooses not to check required fields
- // must be consistent about it. That is, for any particular sub-message, the
- // implementation must either *always* check its required fields, or *never*
- // check its required fields, regardless of whether or not the message has
- // been parsed.
- Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
- // Is this field deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for accessors, or it will be completely ignored; in the very least, this
- // is a formalization for deprecating fields.
- Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- // For Google-internal migration only. Do not use.
- Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for FieldOptions fields.
-const (
- Default_FieldOptions_Ctype = FieldOptions_STRING
- Default_FieldOptions_Jstype = FieldOptions_JS_NORMAL
- Default_FieldOptions_Lazy = bool(false)
- Default_FieldOptions_Deprecated = bool(false)
- Default_FieldOptions_Weak = bool(false)
-)
-
-func (x *FieldOptions) Reset() {
- *x = FieldOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *FieldOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FieldOptions) ProtoMessage() {}
-
-func (x *FieldOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
- if 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 FieldOptions.ProtoReflect.Descriptor instead.
-func (*FieldOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12}
-}
-
-var extRange_FieldOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use FieldOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*FieldOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_FieldOptions
-}
-
-func (x *FieldOptions) GetCtype() FieldOptions_CType {
- if x != nil && x.Ctype != nil {
- return *x.Ctype
- }
- return Default_FieldOptions_Ctype
-}
-
-func (x *FieldOptions) GetPacked() bool {
- if x != nil && x.Packed != nil {
- return *x.Packed
- }
- return false
-}
-
-func (x *FieldOptions) GetJstype() FieldOptions_JSType {
- if x != nil && x.Jstype != nil {
- return *x.Jstype
- }
- return Default_FieldOptions_Jstype
-}
-
-func (x *FieldOptions) GetLazy() bool {
- if x != nil && x.Lazy != nil {
- return *x.Lazy
- }
- return Default_FieldOptions_Lazy
-}
-
-func (x *FieldOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_FieldOptions_Deprecated
-}
-
-func (x *FieldOptions) GetWeak() bool {
- if x != nil && x.Weak != nil {
- return *x.Weak
- }
- return Default_FieldOptions_Weak
-}
-
-func (x *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type OneofOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-func (x *OneofOptions) Reset() {
- *x = OneofOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *OneofOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*OneofOptions) ProtoMessage() {}
-
-func (x *OneofOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
- if 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 OneofOptions.ProtoReflect.Descriptor instead.
-func (*OneofOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{13}
-}
-
-var extRange_OneofOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use OneofOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*OneofOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_OneofOptions
-}
-
-func (x *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type EnumOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // Set this option to true to allow mapping different tag names to the same
- // value.
- AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
- // Is this enum deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for the enum, or it will be completely ignored; in the very least, this
- // is a formalization for deprecating enums.
- Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for EnumOptions fields.
-const (
- Default_EnumOptions_Deprecated = bool(false)
-)
-
-func (x *EnumOptions) Reset() {
- *x = EnumOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *EnumOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumOptions) ProtoMessage() {}
-
-func (x *EnumOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
- if 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 EnumOptions.ProtoReflect.Descriptor instead.
-func (*EnumOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{14}
-}
-
-var extRange_EnumOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use EnumOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*EnumOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_EnumOptions
-}
-
-func (x *EnumOptions) GetAllowAlias() bool {
- if x != nil && x.AllowAlias != nil {
- return *x.AllowAlias
- }
- return false
-}
-
-func (x *EnumOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_EnumOptions_Deprecated
-}
-
-func (x *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type EnumValueOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // Is this enum value deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for the enum value, or it will be completely ignored; in the very least,
- // this is a formalization for deprecating enum values.
- Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for EnumValueOptions fields.
-const (
- Default_EnumValueOptions_Deprecated = bool(false)
-)
-
-func (x *EnumValueOptions) Reset() {
- *x = EnumValueOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *EnumValueOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumValueOptions) ProtoMessage() {}
-
-func (x *EnumValueOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
- if 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 EnumValueOptions.ProtoReflect.Descriptor instead.
-func (*EnumValueOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{15}
-}
-
-var extRange_EnumValueOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*EnumValueOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_EnumValueOptions
-}
-
-func (x *EnumValueOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_EnumValueOptions_Deprecated
-}
-
-func (x *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type ServiceOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // Is this service deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for the service, or it will be completely ignored; in the very least,
- // this is a formalization for deprecating services.
- Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for ServiceOptions fields.
-const (
- Default_ServiceOptions_Deprecated = bool(false)
-)
-
-func (x *ServiceOptions) Reset() {
- *x = ServiceOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *ServiceOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ServiceOptions) ProtoMessage() {}
-
-func (x *ServiceOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
- if 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 ServiceOptions.ProtoReflect.Descriptor instead.
-func (*ServiceOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{16}
-}
-
-var extRange_ServiceOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*ServiceOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_ServiceOptions
-}
-
-func (x *ServiceOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_ServiceOptions_Deprecated
-}
-
-func (x *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-type MethodOptions struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
- extensionFields protoimpl.ExtensionFields
-
- // Is this method deprecated?
- // Depending on the target platform, this can emit Deprecated annotations
- // for the method, or it will be completely ignored; in the very least,
- // this is a formalization for deprecating methods.
- Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
- IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
- // The parser stores options it doesn't recognize here. See above.
- UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for MethodOptions fields.
-const (
- Default_MethodOptions_Deprecated = bool(false)
- Default_MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
-)
-
-func (x *MethodOptions) Reset() {
- *x = MethodOptions{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *MethodOptions) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MethodOptions) ProtoMessage() {}
-
-func (x *MethodOptions) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
- if 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 MethodOptions.ProtoReflect.Descriptor instead.
-func (*MethodOptions) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17}
-}
-
-var extRange_MethodOptions = []protoiface.ExtensionRangeV1{
- {Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use MethodOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*MethodOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
- return extRange_MethodOptions
-}
-
-func (x *MethodOptions) GetDeprecated() bool {
- if x != nil && x.Deprecated != nil {
- return *x.Deprecated
- }
- return Default_MethodOptions_Deprecated
-}
-
-func (x *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
- if x != nil && x.IdempotencyLevel != nil {
- return *x.IdempotencyLevel
- }
- return Default_MethodOptions_IdempotencyLevel
-}
-
-func (x *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
- if x != nil {
- return x.UninterpretedOption
- }
- return nil
-}
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-type UninterpretedOption struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
- // The value of the uninterpreted option, in whatever type the tokenizer
- // identified it as during parsing. Exactly one of these should be set.
- IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
- PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
- NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
- DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
- StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
- AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
-}
-
-func (x *UninterpretedOption) Reset() {
- *x = UninterpretedOption{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *UninterpretedOption) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UninterpretedOption) ProtoMessage() {}
-
-func (x *UninterpretedOption) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
- if 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 UninterpretedOption.ProtoReflect.Descriptor instead.
-func (*UninterpretedOption) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18}
-}
-
-func (x *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
- if x != nil {
- return x.Name
- }
- return nil
-}
-
-func (x *UninterpretedOption) GetIdentifierValue() string {
- if x != nil && x.IdentifierValue != nil {
- return *x.IdentifierValue
- }
- return ""
-}
-
-func (x *UninterpretedOption) GetPositiveIntValue() uint64 {
- if x != nil && x.PositiveIntValue != nil {
- return *x.PositiveIntValue
- }
- return 0
-}
-
-func (x *UninterpretedOption) GetNegativeIntValue() int64 {
- if x != nil && x.NegativeIntValue != nil {
- return *x.NegativeIntValue
- }
- return 0
-}
-
-func (x *UninterpretedOption) GetDoubleValue() float64 {
- if x != nil && x.DoubleValue != nil {
- return *x.DoubleValue
- }
- return 0
-}
-
-func (x *UninterpretedOption) GetStringValue() []byte {
- if x != nil {
- return x.StringValue
- }
- return nil
-}
-
-func (x *UninterpretedOption) GetAggregateValue() string {
- if x != nil && x.AggregateValue != nil {
- return *x.AggregateValue
- }
- return ""
-}
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-type SourceCodeInfo struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- // A Location identifies a piece of source code in a .proto file which
- // corresponds to a particular definition. This information is intended
- // to be useful to IDEs, code indexers, documentation generators, and similar
- // tools.
- //
- // For example, say we have a file like:
- // message Foo {
- // optional string foo = 1;
- // }
- // Let's look at just the field definition:
- // optional string foo = 1;
- // ^ ^^ ^^ ^ ^^^
- // a bc de f ghi
- // We have the following locations:
- // span path represents
- // [a,i) [ 4, 0, 2, 0 ] The whole field definition.
- // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
- // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
- // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
- // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
- //
- // Notes:
- // - A location may refer to a repeated field itself (i.e. not to any
- // particular index within it). This is used whenever a set of elements are
- // logically enclosed in a single code segment. For example, an entire
- // extend block (possibly containing multiple extension definitions) will
- // have an outer location whose path refers to the "extensions" repeated
- // field without an index.
- // - Multiple locations may have the same path. This happens when a single
- // logical declaration is spread out across multiple places. The most
- // obvious example is the "extend" block again -- there may be multiple
- // extend blocks in the same scope, each of which will have the same path.
- // - A location's span is not always a subset of its parent's span. For
- // example, the "extendee" of an extension declaration appears at the
- // beginning of the "extend" block and is shared by all extensions within
- // the block.
- // - Just because a location's span is a subset of some other location's span
- // does not mean that it is a descendant. For example, a "group" defines
- // both a type and a field in a single declaration. Thus, the locations
- // corresponding to the type and field and their components will overlap.
- // - Code which tries to interpret locations should probably be designed to
- // ignore those that it doesn't understand, as more types of locations could
- // be recorded in the future.
- Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
-}
-
-func (x *SourceCodeInfo) Reset() {
- *x = SourceCodeInfo{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *SourceCodeInfo) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SourceCodeInfo) ProtoMessage() {}
-
-func (x *SourceCodeInfo) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
- 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 SourceCodeInfo.ProtoReflect.Descriptor instead.
-func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19}
-}
-
-func (x *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
- if x != nil {
- return x.Location
- }
- return nil
-}
-
-// Describes the relationship between generated code and its original source
-// file. A GeneratedCodeInfo message is associated with only one generated
-// source file, but may contain references to different source .proto files.
-type GeneratedCodeInfo struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- // An Annotation connects some span of text in generated code to an element
- // of its generating .proto file.
- Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
-}
-
-func (x *GeneratedCodeInfo) Reset() {
- *x = GeneratedCodeInfo{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *GeneratedCodeInfo) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GeneratedCodeInfo) ProtoMessage() {}
-
-func (x *GeneratedCodeInfo) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
- 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 GeneratedCodeInfo.ProtoReflect.Descriptor instead.
-func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20}
-}
-
-func (x *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
- if x != nil {
- return x.Annotation
- }
- return nil
-}
-
-type DescriptorProto_ExtensionRange struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
- End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Exclusive.
- Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *DescriptorProto_ExtensionRange) Reset() {
- *x = DescriptorProto_ExtensionRange{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *DescriptorProto_ExtensionRange) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
-
-func (x *DescriptorProto_ExtensionRange) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
- 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 DescriptorProto_ExtensionRange.ProtoReflect.Descriptor instead.
-func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 0}
-}
-
-func (x *DescriptorProto_ExtensionRange) GetStart() int32 {
- if x != nil && x.Start != nil {
- return *x.Start
- }
- return 0
-}
-
-func (x *DescriptorProto_ExtensionRange) GetEnd() int32 {
- if x != nil && x.End != nil {
- return *x.End
- }
- return 0
-}
-
-func (x *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
- if x != nil {
- return x.Options
- }
- return nil
-}
-
-// Range of reserved tag numbers. Reserved tag numbers may not be used by
-// fields or extension ranges in the same message. Reserved ranges may
-// not overlap.
-type DescriptorProto_ReservedRange struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
- End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Exclusive.
-}
-
-func (x *DescriptorProto_ReservedRange) Reset() {
- *x = DescriptorProto_ReservedRange{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *DescriptorProto_ReservedRange) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DescriptorProto_ReservedRange) ProtoMessage() {}
-
-func (x *DescriptorProto_ReservedRange) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
- 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 DescriptorProto_ReservedRange.ProtoReflect.Descriptor instead.
-func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 1}
-}
-
-func (x *DescriptorProto_ReservedRange) GetStart() int32 {
- if x != nil && x.Start != nil {
- return *x.Start
- }
- return 0
-}
-
-func (x *DescriptorProto_ReservedRange) GetEnd() int32 {
- if x != nil && x.End != nil {
- return *x.End
- }
- return 0
-}
-
-// Range of reserved numeric values. Reserved values may not be used by
-// entries in the same enum. Reserved ranges may not overlap.
-//
-// Note that this is distinct from DescriptorProto.ReservedRange in that it
-// is inclusive such that it can appropriately represent the entire int32
-// domain.
-type EnumDescriptorProto_EnumReservedRange struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
- End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Inclusive.
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) Reset() {
- *x = EnumDescriptorProto_EnumReservedRange{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
-
-func (x *EnumDescriptorProto_EnumReservedRange) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
- 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 EnumDescriptorProto_EnumReservedRange.ProtoReflect.Descriptor instead.
-func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6, 0}
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
- if x != nil && x.Start != nil {
- return *x.Start
- }
- return 0
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
- if x != nil && x.End != nil {
- return *x.End
- }
- return 0
-}
-
-// The name of the uninterpreted option. Each string represents a segment in
-// a dot-separated name. is_extension is true iff a segment represents an
-// extension (denoted with parentheses in options specs in .proto files).
-// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-// "foo.(bar.baz).qux".
-type UninterpretedOption_NamePart struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
- IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
-}
-
-func (x *UninterpretedOption_NamePart) Reset() {
- *x = UninterpretedOption_NamePart{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *UninterpretedOption_NamePart) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UninterpretedOption_NamePart) ProtoMessage() {}
-
-func (x *UninterpretedOption_NamePart) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
- 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 UninterpretedOption_NamePart.ProtoReflect.Descriptor instead.
-func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18, 0}
-}
-
-func (x *UninterpretedOption_NamePart) GetNamePart() string {
- if x != nil && x.NamePart != nil {
- return *x.NamePart
- }
- return ""
-}
-
-func (x *UninterpretedOption_NamePart) GetIsExtension() bool {
- if x != nil && x.IsExtension != nil {
- return *x.IsExtension
- }
- return false
-}
-
-type SourceCodeInfo_Location struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- // Identifies which part of the FileDescriptorProto was defined at this
- // location.
- //
- // Each element is a field number or an index. They form a path from
- // the root FileDescriptorProto to the place where the definition. For
- // example, this path:
- // [ 4, 3, 2, 7, 1 ]
- // refers to:
- // file.message_type(3) // 4, 3
- // .field(7) // 2, 7
- // .name() // 1
- // This is because FileDescriptorProto.message_type has field number 4:
- // repeated DescriptorProto message_type = 4;
- // and DescriptorProto.field has field number 2:
- // repeated FieldDescriptorProto field = 2;
- // and FieldDescriptorProto.name has field number 1:
- // optional string name = 1;
- //
- // Thus, the above path gives the location of a field name. If we removed
- // the last element:
- // [ 4, 3, 2, 7 ]
- // this path refers to the whole field declaration (from the beginning
- // of the label to the terminating semicolon).
- Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
- // Always has exactly three or four elements: start line, start column,
- // end line (optional, otherwise assumed same as start line), end column.
- // These are packed into a single field for efficiency. Note that line
- // and column numbers are zero-based -- typically you will want to add
- // 1 to each before displaying to a user.
- Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
- // If this SourceCodeInfo represents a complete declaration, these are any
- // comments appearing before and after the declaration which appear to be
- // attached to the declaration.
- //
- // A series of line comments appearing on consecutive lines, with no other
- // tokens appearing on those lines, will be treated as a single comment.
- //
- // leading_detached_comments will keep paragraphs of comments that appear
- // before (but not connected to) the current element. Each paragraph,
- // separated by empty lines, will be one comment element in the repeated
- // field.
- //
- // Only the comment content is provided; comment markers (e.g. //) are
- // stripped out. For block comments, leading whitespace and an asterisk
- // will be stripped from the beginning of each line other than the first.
- // Newlines are included in the output.
- //
- // Examples:
- //
- // optional int32 foo = 1; // Comment attached to foo.
- // // Comment attached to bar.
- // optional int32 bar = 2;
- //
- // optional string baz = 3;
- // // Comment attached to baz.
- // // Another line attached to baz.
- //
- // // Comment attached to qux.
- // //
- // // Another line attached to qux.
- // optional double qux = 4;
- //
- // // Detached comment for corge. This is not leading or trailing comments
- // // to qux or corge because there are blank lines separating it from
- // // both.
- //
- // // Detached comment for corge paragraph 2.
- //
- // optional string corge = 5;
- // /* Block comment attached
- // * to corge. Leading asterisks
- // * will be removed. */
- // /* Block comment attached to
- // * grault. */
- // optional int32 grault = 6;
- //
- // // ignored detached comments.
- LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
- TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
- LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
-}
-
-func (x *SourceCodeInfo_Location) Reset() {
- *x = SourceCodeInfo_Location{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *SourceCodeInfo_Location) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SourceCodeInfo_Location) ProtoMessage() {}
-
-func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
- 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 SourceCodeInfo_Location.ProtoReflect.Descriptor instead.
-func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0}
-}
-
-func (x *SourceCodeInfo_Location) GetPath() []int32 {
- if x != nil {
- return x.Path
- }
- return nil
-}
-
-func (x *SourceCodeInfo_Location) GetSpan() []int32 {
- if x != nil {
- return x.Span
- }
- return nil
-}
-
-func (x *SourceCodeInfo_Location) GetLeadingComments() string {
- if x != nil && x.LeadingComments != nil {
- return *x.LeadingComments
- }
- return ""
-}
-
-func (x *SourceCodeInfo_Location) GetTrailingComments() string {
- if x != nil && x.TrailingComments != nil {
- return *x.TrailingComments
- }
- return ""
-}
-
-func (x *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
- if x != nil {
- return x.LeadingDetachedComments
- }
- return nil
-}
-
-type GeneratedCodeInfo_Annotation struct {
- state protoimpl.MessageState
- sizeCache protoimpl.SizeCache
- unknownFields protoimpl.UnknownFields
-
- // Identifies the element in the original source .proto file. This field
- // is formatted the same as SourceCodeInfo.Location.path.
- Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
- // Identifies the filesystem path to the original source .proto.
- SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
- // Identifies the starting offset in bytes in the generated code
- // that relates to the identified object.
- Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
- // Identifies the ending offset in bytes in the generated code that
- // relates to the identified offset. The end offset should be one past
- // the last relevant byte (so the length of the text = end - begin).
- End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
-}
-
-func (x *GeneratedCodeInfo_Annotation) Reset() {
- *x = GeneratedCodeInfo_Annotation{}
- if protoimpl.UnsafeEnabled {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
- ms.StoreMessageInfo(mi)
- }
-}
-
-func (x *GeneratedCodeInfo_Annotation) String() string {
- return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
-
-func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
- 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 GeneratedCodeInfo_Annotation.ProtoReflect.Descriptor instead.
-func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
- return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20, 0}
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetPath() []int32 {
- if x != nil {
- return x.Path
- }
- return nil
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetSourceFile() string {
- if x != nil && x.SourceFile != nil {
- return *x.SourceFile
- }
- return ""
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetBegin() int32 {
- if x != nil && x.Begin != nil {
- return *x.Begin
- }
- return 0
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetEnd() int32 {
- if x != nil && x.End != nil {
- return *x.End
- }
- return 0
-}
-
-var File_google_protobuf_descriptor_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_descriptor_proto_rawDesc = []byte{
- 0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
- 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f,
- 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x62, 0x75, 0x66, 0x22, 0x4d, 0x0a, 0x11, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
- 0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65,
- 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73,
- 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x04, 0x66, 0x69,
- 0x6c, 0x65, 0x22, 0xe4, 0x04, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
- 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
- 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18,
- 0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65,
- 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65,
- 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x75, 0x62, 0x6c,
- 0x69, 0x63, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0a, 0x20,
- 0x03, 0x28, 0x05, 0x52, 0x10, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x44, 0x65, 0x70, 0x65, 0x6e,
- 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x64, 0x65,
- 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e,
- 0x77, 0x65, 0x61, 0x6b, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x43,
- 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04,
- 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
- 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
- 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
- 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65,
- 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73,
- 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x08, 0x65, 0x6e,
- 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
- 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, 0x65, 0x78, 0x74,
- 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46,
- 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
- 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36,
- 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
- 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
- 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f,
- 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
- 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
- 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
- 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
- 0x6f, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
- 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28,
- 0x09, 0x52, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x22, 0xb9, 0x06, 0x0a, 0x0f, 0x44, 0x65,
- 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a,
- 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
- 0x65, 0x12, 0x3b, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
- 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
- 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
- 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x43,
- 0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28,
- 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
- 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
- 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0b, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x79,
- 0x70, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72,
- 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0a, 0x6e, 0x65, 0x73, 0x74,
- 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74,
- 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
- 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52,
- 0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x58, 0x0a, 0x0f, 0x65, 0x78, 0x74,
- 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x05, 0x20, 0x03,
- 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
- 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
- 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
- 0x6e, 0x67, 0x65, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
- 0x6e, 0x67, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x64, 0x65, 0x63,
- 0x6c, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x44,
- 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09,
- 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, 0x63, 0x6c, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
- 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
- 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64,
- 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44,
- 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x52,
- 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x72, 0x65,
- 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72,
- 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x03,
- 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65,
- 0x1a, 0x7a, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e,
- 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
- 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18,
- 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x07, 0x6f, 0x70,
- 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f,
- 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x78,
- 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
- 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x37, 0x0a, 0x0d,
- 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a,
- 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74,
- 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
- 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0x7c, 0x0a, 0x15, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
- 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58,
- 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
- 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
- 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
- 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
- 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80,
- 0x80, 0x80, 0x02, 0x22, 0xc1, 0x06, 0x0a, 0x14, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73,
- 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04,
- 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
- 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
- 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65,
- 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44,
- 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x4c,
- 0x61, 0x62, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x3e, 0x0a, 0x04, 0x74,
- 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c,
- 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
- 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74,
- 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
- 0x74, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65,
- 0x6e, 0x64, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65,
- 0x6e, 0x64, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
- 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66,
- 0x61, 0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x6e, 0x65,
- 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
- 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x73,
- 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6a,
- 0x73, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
- 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64,
- 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
- 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
- 0x6e, 0x61, 0x6c, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x33, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x22, 0xb6, 0x02, 0x0a, 0x04, 0x54, 0x79,
- 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c,
- 0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x41,
- 0x54, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x36,
- 0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54,
- 0x36, 0x34, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54,
- 0x33, 0x32, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58,
- 0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46,
- 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45,
- 0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f,
- 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45,
- 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0a, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45,
- 0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x0b, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59,
- 0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x0c, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59,
- 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x0d, 0x12, 0x0d, 0x0a, 0x09, 0x54,
- 0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59,
- 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x0f, 0x12, 0x11, 0x0a,
- 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x10,
- 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10,
- 0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x36, 0x34,
- 0x10, 0x12, 0x22, 0x43, 0x0a, 0x05, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x4c,
- 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x10, 0x01, 0x12,
- 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45,
- 0x44, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x50,
- 0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x22, 0x63, 0x0a, 0x14, 0x4f, 0x6e, 0x65, 0x6f, 0x66,
- 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
- 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
- 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02,
- 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
- 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69,
- 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xe3, 0x02, 0x0a,
- 0x13, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
- 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
- 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
- 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61,
- 0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f,
- 0x74, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x36, 0x0a, 0x07, 0x6f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f,
- 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75,
- 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x73, 0x12, 0x5d, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x61,
- 0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
- 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
- 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
- 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67,
- 0x65, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65,
- 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d,
- 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65,
- 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x3b, 0x0a, 0x11, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73,
- 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74,
- 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74,
- 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65,
- 0x6e, 0x64, 0x22, 0x83, 0x01, 0x0a, 0x18, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65,
- 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
- 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
- 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20,
- 0x01, 0x28, 0x05, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x07, 0x6f,
- 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
- 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
- 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xa7, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x72,
- 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
- 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
- 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f,
- 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
- 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52,
- 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
- 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69,
- 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
- 0x6e, 0x73, 0x22, 0x89, 0x02, 0x0a, 0x15, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73,
- 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04,
- 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
- 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02,
- 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
- 0x1f, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03,
- 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65,
- 0x12, 0x38, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28,
- 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x0a, 0x10, 0x63, 0x6c,
- 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x05,
- 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, 0x63, 0x6c, 0x69,
- 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x30, 0x0a, 0x10,
- 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67,
- 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, 0x73,
- 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x22, 0x91,
- 0x09, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21,
- 0x0a, 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x01,
- 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x61, 0x76, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67,
- 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f,
- 0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x12, 0x6a, 0x61, 0x76, 0x61, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x6e,
- 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6d, 0x75, 0x6c, 0x74,
- 0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08,
- 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x6a, 0x61, 0x76, 0x61, 0x4d, 0x75, 0x6c,
- 0x74, 0x69, 0x70, 0x6c, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x44, 0x0a, 0x1d, 0x6a, 0x61,
- 0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x71, 0x75, 0x61,
- 0x6c, 0x73, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x14, 0x20, 0x01, 0x28,
- 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x19, 0x6a, 0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72,
- 0x61, 0x74, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x41, 0x6e, 0x64, 0x48, 0x61, 0x73, 0x68,
- 0x12, 0x3a, 0x0a, 0x16, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f,
- 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x75, 0x74, 0x66, 0x38, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x08,
- 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x53, 0x74, 0x72,
- 0x69, 0x6e, 0x67, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x55, 0x74, 0x66, 0x38, 0x12, 0x53, 0x0a, 0x0c,
- 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01,
- 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
- 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
- 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x05, 0x53,
- 0x50, 0x45, 0x45, 0x44, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x46, 0x6f,
- 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x6f, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18,
- 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x6f, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
- 0x12, 0x35, 0x0a, 0x13, 0x63, 0x63, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73,
- 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66,
- 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x63, 0x63, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53,
- 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x15, 0x6a, 0x61, 0x76, 0x61, 0x5f,
- 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
- 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a,
- 0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x73, 0x12, 0x35, 0x0a, 0x13, 0x70, 0x79, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63,
- 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x3a,
- 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x70, 0x79, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69,
- 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x37, 0x0a, 0x14, 0x70, 0x68, 0x70,
- 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
- 0x73, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x12,
- 0x70, 0x68, 0x70, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
- 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64,
- 0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64,
- 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2e, 0x0a, 0x10, 0x63, 0x63, 0x5f,
- 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x18, 0x1f, 0x20,
- 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0e, 0x63, 0x63, 0x45, 0x6e, 0x61,
- 0x62, 0x6c, 0x65, 0x41, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6f, 0x62, 0x6a,
- 0x63, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x24,
- 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x63, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50,
- 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f,
- 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x25, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x0f, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
- 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78,
- 0x18, 0x27, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x65,
- 0x66, 0x69, 0x78, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x68, 0x70, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
- 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70,
- 0x68, 0x70, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x23, 0x0a,
- 0x0d, 0x70, 0x68, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x29,
- 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x68, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
- 0x63, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x68, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
- 0x74, 0x61, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x2c, 0x20, 0x01,
- 0x28, 0x09, 0x52, 0x14, 0x70, 0x68, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4e,
- 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x62, 0x79,
- 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
- 0x72, 0x75, 0x62, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x58, 0x0a, 0x14, 0x75,
- 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f,
- 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69,
- 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
- 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a,
- 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x10, 0x01,
- 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x5a, 0x45, 0x10, 0x02, 0x12,
- 0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x54, 0x45, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10,
- 0x03, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x26,
- 0x10, 0x27, 0x22, 0xd1, 0x02, 0x0a, 0x0e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
- 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3c, 0x0a, 0x17, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
- 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
- 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x14, 0x6d,
- 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72,
- 0x6d, 0x61, 0x74, 0x12, 0x4c, 0x0a, 0x1f, 0x6e, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61,
- 0x72, 0x64, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x63,
- 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
- 0x6c, 0x73, 0x65, 0x52, 0x1c, 0x6e, 0x6f, 0x53, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44,
- 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f,
- 0x72, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18,
- 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65,
- 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x70, 0x5f,
- 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6d, 0x61, 0x70,
- 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72,
- 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07,
- 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
- 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72,
- 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e,
- 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a,
- 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09,
- 0x4a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x22, 0xe2, 0x03, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64,
- 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65,
- 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70,
- 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x43, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x06, 0x53, 0x54, 0x52,
- 0x49, 0x4e, 0x47, 0x52, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61,
- 0x63, 0x6b, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b,
- 0x65, 0x64, 0x12, 0x47, 0x0a, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01,
- 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
- 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x73, 0x2e, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52,
- 0x4d, 0x41, 0x4c, 0x52, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x04, 0x6c,
- 0x61, 0x7a, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
- 0x52, 0x04, 0x6c, 0x61, 0x7a, 0x79, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63,
- 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73,
- 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a,
- 0x04, 0x77, 0x65, 0x61, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
- 0x73, 0x65, 0x52, 0x04, 0x77, 0x65, 0x61, 0x6b, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e,
- 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65,
- 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75,
- 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
- 0x6f, 0x6e, 0x22, 0x2f, 0x0a, 0x05, 0x43, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x53,
- 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10,
- 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, 0x43,
- 0x45, 0x10, 0x02, 0x22, 0x35, 0x0a, 0x06, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0d, 0x0a,
- 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09,
- 0x4a, 0x53, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x4a,
- 0x53, 0x5f, 0x4e, 0x55, 0x4d, 0x42, 0x45, 0x52, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10,
- 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0x73, 0x0a, 0x0c, 0x4f,
- 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75,
- 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f,
- 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69,
- 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
- 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02,
- 0x22, 0xc0, 0x01, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
- 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18,
- 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x69, 0x61,
- 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18,
- 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65,
- 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e,
- 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
- 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65,
- 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75,
- 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
- 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08,
- 0x05, 0x10, 0x06, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75,
- 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72,
- 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
- 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12,
- 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
- 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
- 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
- 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70,
- 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
- 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80,
- 0x80, 0x80, 0x80, 0x02, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
- 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65,
- 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
- 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58,
- 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
- 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
- 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
- 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
- 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
- 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80,
- 0x80, 0x80, 0x02, 0x22, 0xe0, 0x02, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70,
- 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61,
- 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
- 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x71, 0x0a, 0x11,
- 0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x6c, 0x65, 0x76, 0x65,
- 0x6c, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
- 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65,
- 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f,
- 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x52, 0x10, 0x69,
- 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12,
- 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
- 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
- 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
- 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70,
- 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
- 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x50, 0x0a, 0x10, 0x49, 0x64, 0x65,
- 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x17, 0x0a,
- 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b,
- 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x4f, 0x5f, 0x53, 0x49, 0x44,
- 0x45, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, 0x54, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x49,
- 0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07,
- 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x9a, 0x03, 0x0a, 0x13, 0x55, 0x6e, 0x69, 0x6e, 0x74,
- 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41,
- 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67,
- 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55,
- 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
- 0x6f, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x52, 0x04, 0x6e, 0x61, 0x6d,
- 0x65, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f,
- 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x64, 0x65,
- 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12,
- 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c,
- 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
- 0x76, 0x65, 0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x65,
- 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
- 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65,
- 0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62,
- 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b,
- 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73,
- 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28,
- 0x0c, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x27,
- 0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75,
- 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61,
- 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0x4a, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x50,
- 0x61, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74,
- 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74,
- 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
- 0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
- 0x69, 0x6f, 0x6e, 0x22, 0xa7, 0x02, 0x0a, 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f,
- 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x44, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
- 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
- 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63,
- 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69,
- 0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0xce, 0x01, 0x0a,
- 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74,
- 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74,
- 0x68, 0x12, 0x16, 0x0a, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x42,
- 0x02, 0x10, 0x01, 0x52, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x65, 0x61,
- 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20,
- 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d,
- 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67,
- 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x10, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
- 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x74,
- 0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06,
- 0x20, 0x03, 0x28, 0x09, 0x52, 0x17, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74,
- 0x61, 0x63, 0x68, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xd1, 0x01,
- 0x0a, 0x11, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49,
- 0x6e, 0x66, 0x6f, 0x12, 0x4d, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
- 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x41, 0x6e, 0x6e, 0x6f,
- 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69,
- 0x6f, 0x6e, 0x1a, 0x6d, 0x0a, 0x0a, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
- 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02,
- 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72,
- 0x63, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73,
- 0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x65, 0x67,
- 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x12,
- 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e,
- 0x64, 0x42, 0x8f, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
- 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72,
- 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x48, 0x01, 0x5a, 0x3e, 0x67,
- 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
- 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
- 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
- 0x6f, 0x72, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0xf8, 0x01, 0x01,
- 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1a, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
- 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x52, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74,
- 0x69, 0x6f, 0x6e,
-}
-
-var (
- file_google_protobuf_descriptor_proto_rawDescOnce sync.Once
- file_google_protobuf_descriptor_proto_rawDescData = file_google_protobuf_descriptor_proto_rawDesc
-)
-
-func file_google_protobuf_descriptor_proto_rawDescGZIP() []byte {
- file_google_protobuf_descriptor_proto_rawDescOnce.Do(func() {
- file_google_protobuf_descriptor_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_descriptor_proto_rawDescData)
- })
- return file_google_protobuf_descriptor_proto_rawDescData
-}
-
-var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
-var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 27)
-var file_google_protobuf_descriptor_proto_goTypes = []interface{}{
- (FieldDescriptorProto_Type)(0), // 0: google.protobuf.FieldDescriptorProto.Type
- (FieldDescriptorProto_Label)(0), // 1: google.protobuf.FieldDescriptorProto.Label
- (FileOptions_OptimizeMode)(0), // 2: google.protobuf.FileOptions.OptimizeMode
- (FieldOptions_CType)(0), // 3: google.protobuf.FieldOptions.CType
- (FieldOptions_JSType)(0), // 4: google.protobuf.FieldOptions.JSType
- (MethodOptions_IdempotencyLevel)(0), // 5: google.protobuf.MethodOptions.IdempotencyLevel
- (*FileDescriptorSet)(nil), // 6: google.protobuf.FileDescriptorSet
- (*FileDescriptorProto)(nil), // 7: google.protobuf.FileDescriptorProto
- (*DescriptorProto)(nil), // 8: google.protobuf.DescriptorProto
- (*ExtensionRangeOptions)(nil), // 9: google.protobuf.ExtensionRangeOptions
- (*FieldDescriptorProto)(nil), // 10: google.protobuf.FieldDescriptorProto
- (*OneofDescriptorProto)(nil), // 11: google.protobuf.OneofDescriptorProto
- (*EnumDescriptorProto)(nil), // 12: google.protobuf.EnumDescriptorProto
- (*EnumValueDescriptorProto)(nil), // 13: google.protobuf.EnumValueDescriptorProto
- (*ServiceDescriptorProto)(nil), // 14: google.protobuf.ServiceDescriptorProto
- (*MethodDescriptorProto)(nil), // 15: google.protobuf.MethodDescriptorProto
- (*FileOptions)(nil), // 16: google.protobuf.FileOptions
- (*MessageOptions)(nil), // 17: google.protobuf.MessageOptions
- (*FieldOptions)(nil), // 18: google.protobuf.FieldOptions
- (*OneofOptions)(nil), // 19: google.protobuf.OneofOptions
- (*EnumOptions)(nil), // 20: google.protobuf.EnumOptions
- (*EnumValueOptions)(nil), // 21: google.protobuf.EnumValueOptions
- (*ServiceOptions)(nil), // 22: google.protobuf.ServiceOptions
- (*MethodOptions)(nil), // 23: google.protobuf.MethodOptions
- (*UninterpretedOption)(nil), // 24: google.protobuf.UninterpretedOption
- (*SourceCodeInfo)(nil), // 25: google.protobuf.SourceCodeInfo
- (*GeneratedCodeInfo)(nil), // 26: google.protobuf.GeneratedCodeInfo
- (*DescriptorProto_ExtensionRange)(nil), // 27: google.protobuf.DescriptorProto.ExtensionRange
- (*DescriptorProto_ReservedRange)(nil), // 28: google.protobuf.DescriptorProto.ReservedRange
- (*EnumDescriptorProto_EnumReservedRange)(nil), // 29: google.protobuf.EnumDescriptorProto.EnumReservedRange
- (*UninterpretedOption_NamePart)(nil), // 30: google.protobuf.UninterpretedOption.NamePart
- (*SourceCodeInfo_Location)(nil), // 31: google.protobuf.SourceCodeInfo.Location
- (*GeneratedCodeInfo_Annotation)(nil), // 32: google.protobuf.GeneratedCodeInfo.Annotation
-}
-var file_google_protobuf_descriptor_proto_depIdxs = []int32{
- 7, // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto
- 8, // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto
- 12, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
- 14, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto
- 10, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
- 16, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions
- 25, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo
- 10, // 7: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto
- 10, // 8: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
- 8, // 9: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto
- 12, // 10: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
- 27, // 11: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange
- 11, // 12: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto
- 17, // 13: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions
- 28, // 14: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange
- 24, // 15: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 1, // 16: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label
- 0, // 17: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type
- 18, // 18: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions
- 19, // 19: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions
- 13, // 20: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto
- 20, // 21: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions
- 29, // 22: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange
- 21, // 23: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions
- 15, // 24: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto
- 22, // 25: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions
- 23, // 26: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions
- 2, // 27: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode
- 24, // 28: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 24, // 29: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 3, // 30: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType
- 4, // 31: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType
- 24, // 32: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 24, // 33: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 24, // 34: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 24, // 35: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 24, // 36: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 5, // 37: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel
- 24, // 38: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 30, // 39: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart
- 31, // 40: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location
- 32, // 41: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation
- 9, // 42: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions
- 43, // [43:43] is the sub-list for method output_type
- 43, // [43:43] is the sub-list for method input_type
- 43, // [43:43] is the sub-list for extension type_name
- 43, // [43:43] is the sub-list for extension extendee
- 0, // [0:43] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_descriptor_proto_init() }
-func file_google_protobuf_descriptor_proto_init() {
- if File_google_protobuf_descriptor_proto != nil {
- return
- }
- if !protoimpl.UnsafeEnabled {
- file_google_protobuf_descriptor_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*FileDescriptorSet); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*FileDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*DescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*ExtensionRangeOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*FieldDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*OneofDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*EnumDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*EnumValueDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*ServiceDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MethodDescriptorProto); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*FileOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MessageOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*FieldOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*OneofOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*EnumOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*EnumValueOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*ServiceOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*MethodOptions); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- case 3:
- return &v.extensionFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*UninterpretedOption); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*SourceCodeInfo); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*GeneratedCodeInfo); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*DescriptorProto_ExtensionRange); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*DescriptorProto_ReservedRange); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*EnumDescriptorProto_EnumReservedRange); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*UninterpretedOption_NamePart); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*SourceCodeInfo_Location); i {
- case 0:
- return &v.state
- case 1:
- return &v.sizeCache
- case 2:
- return &v.unknownFields
- default:
- return nil
- }
- }
- file_google_protobuf_descriptor_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
- switch v := v.(*GeneratedCodeInfo_Annotation); 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_descriptor_proto_rawDesc,
- NumEnums: 6,
- NumMessages: 27,
- NumExtensions: 0,
- NumServices: 0,
- },
- GoTypes: file_google_protobuf_descriptor_proto_goTypes,
- DependencyIndexes: file_google_protobuf_descriptor_proto_depIdxs,
- EnumInfos: file_google_protobuf_descriptor_proto_enumTypes,
- MessageInfos: file_google_protobuf_descriptor_proto_msgTypes,
- }.Build()
- File_google_protobuf_descriptor_proto = out.File
- file_google_protobuf_descriptor_proto_rawDesc = nil
- file_google_protobuf_descriptor_proto_goTypes = nil
- file_google_protobuf_descriptor_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
deleted file mode 100644
index 5f9498e..0000000
--- a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
+++ /dev/null
@@ -1,287 +0,0 @@
-// 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
-
-import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- reflect "reflect"
- 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);
-// }
-//
-// 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 := ptypes.MarshalAny(foo)
-// ...
-// foo := &pb.Foo{}
-// if err := ptypes.UnmarshalAny(any, 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.
- //
- // 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"`
-}
-
-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, 0x6f, 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, 0x25, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
- 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 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
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go b/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
deleted file mode 100644
index 3997c60..0000000
--- a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// 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
-
-import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- reflect "reflect"
- sync "sync"
-)
-
-// 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"`
-}
-
-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, 0x7c, 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, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
- 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
- 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
- 0x6e, 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
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go b/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
deleted file mode 100644
index 32a583d..0000000
--- a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
+++ /dev/null
@@ -1,168 +0,0 @@
-// 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);
-// }
-//
-// The JSON representation for `Empty` is empty JSON object `{}`.
-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, 0x76, 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, 0x27, 0x67, 0x69,
- 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f,
- 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f,
- 0x65, 0x6d, 0x70, 0x74, 0x79, 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
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
deleted file mode 100644
index 6fe6d42..0000000
--- a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
+++ /dev/null
@@ -1,271 +0,0 @@
-// 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
-
-import (
- protoreflect "google.golang.org/protobuf/reflect/protoreflect"
- protoimpl "google.golang.org/protobuf/runtime/protoimpl"
- reflect "reflect"
- sync "sync"
-)
-
-// 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 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://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
-// ) 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"`
-}
-
-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,
- 0x7e, 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, 0x2b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
- 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74,
- 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65,
- 0x73, 0x74, 0x61, 0x6d, 0x70, 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
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 0ebb307..a385aa7 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -33,7 +33,7 @@
github.com/gogo/protobuf/gogoproto
github.com/gogo/protobuf/proto
github.com/gogo/protobuf/protoc-gen-gogo/descriptor
-# github.com/golang/protobuf v1.4.2
+# github.com/golang/protobuf v1.3.2
github.com/golang/protobuf/proto
github.com/golang/protobuf/protoc-gen-go/descriptor
github.com/golang/protobuf/ptypes
@@ -212,39 +212,6 @@
google.golang.org/grpc/stats
google.golang.org/grpc/status
google.golang.org/grpc/tap
-# google.golang.org/protobuf v1.23.0
-google.golang.org/protobuf/encoding/prototext
-google.golang.org/protobuf/encoding/protowire
-google.golang.org/protobuf/internal/descfmt
-google.golang.org/protobuf/internal/descopts
-google.golang.org/protobuf/internal/detrand
-google.golang.org/protobuf/internal/encoding/defval
-google.golang.org/protobuf/internal/encoding/messageset
-google.golang.org/protobuf/internal/encoding/tag
-google.golang.org/protobuf/internal/encoding/text
-google.golang.org/protobuf/internal/errors
-google.golang.org/protobuf/internal/fieldnum
-google.golang.org/protobuf/internal/fieldsort
-google.golang.org/protobuf/internal/filedesc
-google.golang.org/protobuf/internal/filetype
-google.golang.org/protobuf/internal/flags
-google.golang.org/protobuf/internal/genname
-google.golang.org/protobuf/internal/impl
-google.golang.org/protobuf/internal/mapsort
-google.golang.org/protobuf/internal/pragma
-google.golang.org/protobuf/internal/set
-google.golang.org/protobuf/internal/strs
-google.golang.org/protobuf/internal/version
-google.golang.org/protobuf/proto
-google.golang.org/protobuf/reflect/protoreflect
-google.golang.org/protobuf/reflect/protoregistry
-google.golang.org/protobuf/runtime/protoiface
-google.golang.org/protobuf/runtime/protoimpl
-google.golang.org/protobuf/types/descriptorpb
-google.golang.org/protobuf/types/known/anypb
-google.golang.org/protobuf/types/known/durationpb
-google.golang.org/protobuf/types/known/emptypb
-google.golang.org/protobuf/types/known/timestamppb
# gopkg.in/jcmturner/aescts.v1 v1.0.1
gopkg.in/jcmturner/aescts.v1
# gopkg.in/jcmturner/dnsutils.v1 v1.0.1