mirror of
https://github.com/rocky-linux/peridot.git
synced 2024-10-19 07:55:07 +00:00
5473 lines
133 KiB
Go
5473 lines
133 KiB
Go
|
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
||
|
// source: google/rpc/error_details.proto
|
||
|
|
||
|
package rpc
|
||
|
|
||
|
import (
|
||
|
bytes "bytes"
|
||
|
fmt "fmt"
|
||
|
proto "github.com/gogo/protobuf/proto"
|
||
|
github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
|
||
|
types "github.com/gogo/protobuf/types"
|
||
|
io "io"
|
||
|
math "math"
|
||
|
math_bits "math/bits"
|
||
|
reflect "reflect"
|
||
|
strings "strings"
|
||
|
)
|
||
|
|
||
|
// Reference imports to suppress errors if they are not otherwise used.
|
||
|
var _ = proto.Marshal
|
||
|
var _ = fmt.Errorf
|
||
|
var _ = math.Inf
|
||
|
|
||
|
// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package
|
||
|
|
||
|
// Describes when the clients can retry a failed request. Clients could ignore
|
||
|
// the recommendation here or retry when this information is missing from error
|
||
|
// responses.
|
||
|
//
|
||
|
// It's always recommended that clients should use exponential backoff when
|
||
|
// retrying.
|
||
|
//
|
||
|
// Clients should wait until `retry_delay` amount of time has passed since
|
||
|
// receiving the error response before retrying. If retrying requests also
|
||
|
// fail, clients should use an exponential backoff scheme to gradually increase
|
||
|
// the delay between retries based on `retry_delay`, until either a maximum
|
||
|
// number of retries have been reached or a maximum retry delay cap has been
|
||
|
// reached.
|
||
|
type RetryInfo struct {
|
||
|
// Clients should wait at least this long between retrying the same request.
|
||
|
RetryDelay *types.Duration `protobuf:"bytes,1,opt,name=retry_delay,json=retryDelay,proto3" json:"retry_delay,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *RetryInfo) Reset() { *m = RetryInfo{} }
|
||
|
func (*RetryInfo) ProtoMessage() {}
|
||
|
func (*RetryInfo) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{0}
|
||
|
}
|
||
|
func (m *RetryInfo) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *RetryInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_RetryInfo.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *RetryInfo) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_RetryInfo.Merge(m, src)
|
||
|
}
|
||
|
func (m *RetryInfo) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *RetryInfo) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_RetryInfo.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_RetryInfo proto.InternalMessageInfo
|
||
|
|
||
|
func (m *RetryInfo) GetRetryDelay() *types.Duration {
|
||
|
if m != nil {
|
||
|
return m.RetryDelay
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*RetryInfo) XXX_MessageName() string {
|
||
|
return "google.rpc.RetryInfo"
|
||
|
}
|
||
|
|
||
|
// Describes additional debugging info.
|
||
|
type DebugInfo struct {
|
||
|
// The stack trace entries indicating where the error occurred.
|
||
|
StackEntries []string `protobuf:"bytes,1,rep,name=stack_entries,json=stackEntries,proto3" json:"stack_entries,omitempty"`
|
||
|
// Additional debugging information provided by the server.
|
||
|
Detail string `protobuf:"bytes,2,opt,name=detail,proto3" json:"detail,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *DebugInfo) Reset() { *m = DebugInfo{} }
|
||
|
func (*DebugInfo) ProtoMessage() {}
|
||
|
func (*DebugInfo) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{1}
|
||
|
}
|
||
|
func (m *DebugInfo) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *DebugInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_DebugInfo.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *DebugInfo) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_DebugInfo.Merge(m, src)
|
||
|
}
|
||
|
func (m *DebugInfo) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *DebugInfo) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_DebugInfo.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_DebugInfo proto.InternalMessageInfo
|
||
|
|
||
|
func (m *DebugInfo) GetStackEntries() []string {
|
||
|
if m != nil {
|
||
|
return m.StackEntries
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *DebugInfo) GetDetail() string {
|
||
|
if m != nil {
|
||
|
return m.Detail
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*DebugInfo) XXX_MessageName() string {
|
||
|
return "google.rpc.DebugInfo"
|
||
|
}
|
||
|
|
||
|
// Describes how a quota check failed.
|
||
|
//
|
||
|
// For example if a daily limit was exceeded for the calling project,
|
||
|
// a service could respond with a QuotaFailure detail containing the project
|
||
|
// id and the description of the quota limit that was exceeded. If the
|
||
|
// calling project hasn't enabled the service in the developer console, then
|
||
|
// a service could respond with the project id and set `service_disabled`
|
||
|
// to true.
|
||
|
//
|
||
|
// Also see RetryInfo and Help types for other details about handling a
|
||
|
// quota failure.
|
||
|
type QuotaFailure struct {
|
||
|
// Describes all quota violations.
|
||
|
Violations []*QuotaFailure_Violation `protobuf:"bytes,1,rep,name=violations,proto3" json:"violations,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure) Reset() { *m = QuotaFailure{} }
|
||
|
func (*QuotaFailure) ProtoMessage() {}
|
||
|
func (*QuotaFailure) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{2}
|
||
|
}
|
||
|
func (m *QuotaFailure) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *QuotaFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_QuotaFailure.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *QuotaFailure) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_QuotaFailure.Merge(m, src)
|
||
|
}
|
||
|
func (m *QuotaFailure) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *QuotaFailure) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_QuotaFailure.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_QuotaFailure proto.InternalMessageInfo
|
||
|
|
||
|
func (m *QuotaFailure) GetViolations() []*QuotaFailure_Violation {
|
||
|
if m != nil {
|
||
|
return m.Violations
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*QuotaFailure) XXX_MessageName() string {
|
||
|
return "google.rpc.QuotaFailure"
|
||
|
}
|
||
|
|
||
|
// A message type used to describe a single quota violation. For example, a
|
||
|
// daily quota or a custom quota that was exceeded.
|
||
|
type QuotaFailure_Violation struct {
|
||
|
// The subject on which the quota check failed.
|
||
|
// For example, "clientip:<ip address of client>" or "project:<Google
|
||
|
// developer project id>".
|
||
|
Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
|
||
|
// A description of how the quota check failed. Clients can use this
|
||
|
// description to find more about the quota configuration in the service's
|
||
|
// public documentation, or find the relevant quota limit to adjust through
|
||
|
// developer console.
|
||
|
//
|
||
|
// For example: "Service disabled" or "Daily Limit for read operations
|
||
|
// exceeded".
|
||
|
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure_Violation) Reset() { *m = QuotaFailure_Violation{} }
|
||
|
func (*QuotaFailure_Violation) ProtoMessage() {}
|
||
|
func (*QuotaFailure_Violation) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{2, 0}
|
||
|
}
|
||
|
func (m *QuotaFailure_Violation) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *QuotaFailure_Violation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_QuotaFailure_Violation.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *QuotaFailure_Violation) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_QuotaFailure_Violation.Merge(m, src)
|
||
|
}
|
||
|
func (m *QuotaFailure_Violation) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *QuotaFailure_Violation) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_QuotaFailure_Violation.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_QuotaFailure_Violation proto.InternalMessageInfo
|
||
|
|
||
|
func (m *QuotaFailure_Violation) GetSubject() string {
|
||
|
if m != nil {
|
||
|
return m.Subject
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure_Violation) GetDescription() string {
|
||
|
if m != nil {
|
||
|
return m.Description
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*QuotaFailure_Violation) XXX_MessageName() string {
|
||
|
return "google.rpc.QuotaFailure.Violation"
|
||
|
}
|
||
|
|
||
|
// Describes the cause of the error with structured details.
|
||
|
//
|
||
|
// Example of an error when contacting the "pubsub.googleapis.com" API when it
|
||
|
// is not enabled:
|
||
|
//
|
||
|
// { "reason": "API_DISABLED"
|
||
|
// "domain": "googleapis.com"
|
||
|
// "metadata": {
|
||
|
// "resource": "projects/123",
|
||
|
// "service": "pubsub.googleapis.com"
|
||
|
// }
|
||
|
// }
|
||
|
//
|
||
|
// This response indicates that the pubsub.googleapis.com API is not enabled.
|
||
|
//
|
||
|
// Example of an error that is returned when attempting to create a Spanner
|
||
|
// instance in a region that is out of stock:
|
||
|
//
|
||
|
// { "reason": "STOCKOUT"
|
||
|
// "domain": "spanner.googleapis.com",
|
||
|
// "metadata": {
|
||
|
// "availableRegions": "us-central1,us-east2"
|
||
|
// }
|
||
|
// }
|
||
|
type ErrorInfo struct {
|
||
|
// The reason of the error. This is a constant value that identifies the
|
||
|
// proximate cause of the error. Error reasons are unique within a particular
|
||
|
// domain of errors. This should be at most 63 characters and match
|
||
|
// /[A-Z0-9_]+/.
|
||
|
Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"`
|
||
|
// The logical grouping to which the "reason" belongs. The error domain
|
||
|
// is typically the registered service name of the tool or product that
|
||
|
// generates the error. Example: "pubsub.googleapis.com". If the error is
|
||
|
// generated by some common infrastructure, the error domain must be a
|
||
|
// globally unique value that identifies the infrastructure. For Google API
|
||
|
// infrastructure, the error domain is "googleapis.com".
|
||
|
Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
|
||
|
// Additional structured details about this error.
|
||
|
//
|
||
|
// Keys should match /[a-zA-Z0-9-_]/ and be limited to 64 characters in
|
||
|
// length. When identifying the current value of an exceeded limit, the units
|
||
|
// should be contained in the key, not the value. For example, rather than
|
||
|
// {"instanceLimit": "100/request"}, should be returned as,
|
||
|
// {"instanceLimitPerRequest": "100"}, if the client exceeds the number of
|
||
|
// instances that can be created in a single (batch) request.
|
||
|
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) Reset() { *m = ErrorInfo{} }
|
||
|
func (*ErrorInfo) ProtoMessage() {}
|
||
|
func (*ErrorInfo) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{3}
|
||
|
}
|
||
|
func (m *ErrorInfo) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *ErrorInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_ErrorInfo.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *ErrorInfo) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ErrorInfo.Merge(m, src)
|
||
|
}
|
||
|
func (m *ErrorInfo) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *ErrorInfo) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ErrorInfo.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ErrorInfo proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ErrorInfo) GetReason() string {
|
||
|
if m != nil {
|
||
|
return m.Reason
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) GetDomain() string {
|
||
|
if m != nil {
|
||
|
return m.Domain
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) GetMetadata() map[string]string {
|
||
|
if m != nil {
|
||
|
return m.Metadata
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*ErrorInfo) XXX_MessageName() string {
|
||
|
return "google.rpc.ErrorInfo"
|
||
|
}
|
||
|
|
||
|
// Describes what preconditions have failed.
|
||
|
//
|
||
|
// For example, if an RPC failed because it required the Terms of Service to be
|
||
|
// acknowledged, it could list the terms of service violation in the
|
||
|
// PreconditionFailure message.
|
||
|
type PreconditionFailure struct {
|
||
|
// Describes all precondition violations.
|
||
|
Violations []*PreconditionFailure_Violation `protobuf:"bytes,1,rep,name=violations,proto3" json:"violations,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure) Reset() { *m = PreconditionFailure{} }
|
||
|
func (*PreconditionFailure) ProtoMessage() {}
|
||
|
func (*PreconditionFailure) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{4}
|
||
|
}
|
||
|
func (m *PreconditionFailure) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *PreconditionFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_PreconditionFailure.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *PreconditionFailure) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_PreconditionFailure.Merge(m, src)
|
||
|
}
|
||
|
func (m *PreconditionFailure) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *PreconditionFailure) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_PreconditionFailure.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_PreconditionFailure proto.InternalMessageInfo
|
||
|
|
||
|
func (m *PreconditionFailure) GetViolations() []*PreconditionFailure_Violation {
|
||
|
if m != nil {
|
||
|
return m.Violations
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*PreconditionFailure) XXX_MessageName() string {
|
||
|
return "google.rpc.PreconditionFailure"
|
||
|
}
|
||
|
|
||
|
// A message type used to describe a single precondition failure.
|
||
|
type PreconditionFailure_Violation struct {
|
||
|
// The type of PreconditionFailure. We recommend using a service-specific
|
||
|
// enum type to define the supported precondition violation subjects. For
|
||
|
// example, "TOS" for "Terms of Service violation".
|
||
|
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
|
||
|
// The subject, relative to the type, that failed.
|
||
|
// For example, "google.com/cloud" relative to the "TOS" type would indicate
|
||
|
// which terms of service is being referenced.
|
||
|
Subject string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
|
||
|
// A description of how the precondition failed. Developers can use this
|
||
|
// description to understand how to fix the failure.
|
||
|
//
|
||
|
// For example: "Terms of service not accepted".
|
||
|
Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) Reset() { *m = PreconditionFailure_Violation{} }
|
||
|
func (*PreconditionFailure_Violation) ProtoMessage() {}
|
||
|
func (*PreconditionFailure_Violation) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{4, 0}
|
||
|
}
|
||
|
func (m *PreconditionFailure_Violation) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *PreconditionFailure_Violation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_PreconditionFailure_Violation.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *PreconditionFailure_Violation) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_PreconditionFailure_Violation.Merge(m, src)
|
||
|
}
|
||
|
func (m *PreconditionFailure_Violation) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *PreconditionFailure_Violation) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_PreconditionFailure_Violation.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_PreconditionFailure_Violation proto.InternalMessageInfo
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) GetType() string {
|
||
|
if m != nil {
|
||
|
return m.Type
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) GetSubject() string {
|
||
|
if m != nil {
|
||
|
return m.Subject
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) GetDescription() string {
|
||
|
if m != nil {
|
||
|
return m.Description
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*PreconditionFailure_Violation) XXX_MessageName() string {
|
||
|
return "google.rpc.PreconditionFailure.Violation"
|
||
|
}
|
||
|
|
||
|
// Describes violations in a client request. This error type focuses on the
|
||
|
// syntactic aspects of the request.
|
||
|
type BadRequest struct {
|
||
|
// Describes all violations in a client request.
|
||
|
FieldViolations []*BadRequest_FieldViolation `protobuf:"bytes,1,rep,name=field_violations,json=fieldViolations,proto3" json:"field_violations,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest) Reset() { *m = BadRequest{} }
|
||
|
func (*BadRequest) ProtoMessage() {}
|
||
|
func (*BadRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{5}
|
||
|
}
|
||
|
func (m *BadRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *BadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_BadRequest.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *BadRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_BadRequest.Merge(m, src)
|
||
|
}
|
||
|
func (m *BadRequest) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *BadRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_BadRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_BadRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *BadRequest) GetFieldViolations() []*BadRequest_FieldViolation {
|
||
|
if m != nil {
|
||
|
return m.FieldViolations
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*BadRequest) XXX_MessageName() string {
|
||
|
return "google.rpc.BadRequest"
|
||
|
}
|
||
|
|
||
|
// A message type used to describe a single bad request field.
|
||
|
type BadRequest_FieldViolation struct {
|
||
|
// A path leading to a field in the request body. The value will be a
|
||
|
// sequence of dot-separated identifiers that identify a protocol buffer
|
||
|
// field. E.g., "field_violations.field" would identify this field.
|
||
|
Field string `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"`
|
||
|
// A description of why the request element is bad.
|
||
|
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) Reset() { *m = BadRequest_FieldViolation{} }
|
||
|
func (*BadRequest_FieldViolation) ProtoMessage() {}
|
||
|
func (*BadRequest_FieldViolation) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{5, 0}
|
||
|
}
|
||
|
func (m *BadRequest_FieldViolation) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *BadRequest_FieldViolation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_BadRequest_FieldViolation.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *BadRequest_FieldViolation) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_BadRequest_FieldViolation.Merge(m, src)
|
||
|
}
|
||
|
func (m *BadRequest_FieldViolation) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *BadRequest_FieldViolation) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_BadRequest_FieldViolation.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_BadRequest_FieldViolation proto.InternalMessageInfo
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) GetField() string {
|
||
|
if m != nil {
|
||
|
return m.Field
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) GetDescription() string {
|
||
|
if m != nil {
|
||
|
return m.Description
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*BadRequest_FieldViolation) XXX_MessageName() string {
|
||
|
return "google.rpc.BadRequest.FieldViolation"
|
||
|
}
|
||
|
|
||
|
// Contains metadata about the request that clients can attach when filing a bug
|
||
|
// or providing other forms of feedback.
|
||
|
type RequestInfo struct {
|
||
|
// An opaque string that should only be interpreted by the service generating
|
||
|
// it. For example, it can be used to identify requests in the service's logs.
|
||
|
RequestId string `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
|
||
|
// Any data that was used to serve this request. For example, an encrypted
|
||
|
// stack trace that can be sent back to the service provider for debugging.
|
||
|
ServingData string `protobuf:"bytes,2,opt,name=serving_data,json=servingData,proto3" json:"serving_data,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *RequestInfo) Reset() { *m = RequestInfo{} }
|
||
|
func (*RequestInfo) ProtoMessage() {}
|
||
|
func (*RequestInfo) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{6}
|
||
|
}
|
||
|
func (m *RequestInfo) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *RequestInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_RequestInfo.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *RequestInfo) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_RequestInfo.Merge(m, src)
|
||
|
}
|
||
|
func (m *RequestInfo) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *RequestInfo) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_RequestInfo.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_RequestInfo proto.InternalMessageInfo
|
||
|
|
||
|
func (m *RequestInfo) GetRequestId() string {
|
||
|
if m != nil {
|
||
|
return m.RequestId
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *RequestInfo) GetServingData() string {
|
||
|
if m != nil {
|
||
|
return m.ServingData
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*RequestInfo) XXX_MessageName() string {
|
||
|
return "google.rpc.RequestInfo"
|
||
|
}
|
||
|
|
||
|
// Describes the resource that is being accessed.
|
||
|
type ResourceInfo struct {
|
||
|
// A name for the type of resource being accessed, e.g. "sql table",
|
||
|
// "cloud storage bucket", "file", "Google calendar"; or the type URL
|
||
|
// of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic".
|
||
|
ResourceType string `protobuf:"bytes,1,opt,name=resource_type,json=resourceType,proto3" json:"resource_type,omitempty"`
|
||
|
// The name of the resource being accessed. For example, a shared calendar
|
||
|
// name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current
|
||
|
// error is [google.rpc.Code.PERMISSION_DENIED][google.rpc.Code.PERMISSION_DENIED].
|
||
|
ResourceName string `protobuf:"bytes,2,opt,name=resource_name,json=resourceName,proto3" json:"resource_name,omitempty"`
|
||
|
// The owner of the resource (optional).
|
||
|
// For example, "user:<owner email>" or "project:<Google developer project
|
||
|
// id>".
|
||
|
Owner string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
|
||
|
// Describes what error is encountered when accessing this resource.
|
||
|
// For example, updating a cloud project may require the `writer` permission
|
||
|
// on the developer console project.
|
||
|
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) Reset() { *m = ResourceInfo{} }
|
||
|
func (*ResourceInfo) ProtoMessage() {}
|
||
|
func (*ResourceInfo) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{7}
|
||
|
}
|
||
|
func (m *ResourceInfo) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *ResourceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_ResourceInfo.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *ResourceInfo) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ResourceInfo.Merge(m, src)
|
||
|
}
|
||
|
func (m *ResourceInfo) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *ResourceInfo) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ResourceInfo.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ResourceInfo proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ResourceInfo) GetResourceType() string {
|
||
|
if m != nil {
|
||
|
return m.ResourceType
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) GetResourceName() string {
|
||
|
if m != nil {
|
||
|
return m.ResourceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) GetOwner() string {
|
||
|
if m != nil {
|
||
|
return m.Owner
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) GetDescription() string {
|
||
|
if m != nil {
|
||
|
return m.Description
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*ResourceInfo) XXX_MessageName() string {
|
||
|
return "google.rpc.ResourceInfo"
|
||
|
}
|
||
|
|
||
|
// Provides links to documentation or for performing an out of band action.
|
||
|
//
|
||
|
// For example, if a quota check failed with an error indicating the calling
|
||
|
// project hasn't enabled the accessed service, this can contain a URL pointing
|
||
|
// directly to the right place in the developer console to flip the bit.
|
||
|
type Help struct {
|
||
|
// URL(s) pointing to additional information on handling the current error.
|
||
|
Links []*Help_Link `protobuf:"bytes,1,rep,name=links,proto3" json:"links,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Help) Reset() { *m = Help{} }
|
||
|
func (*Help) ProtoMessage() {}
|
||
|
func (*Help) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{8}
|
||
|
}
|
||
|
func (m *Help) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *Help) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_Help.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *Help) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Help.Merge(m, src)
|
||
|
}
|
||
|
func (m *Help) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *Help) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Help.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Help proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Help) GetLinks() []*Help_Link {
|
||
|
if m != nil {
|
||
|
return m.Links
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*Help) XXX_MessageName() string {
|
||
|
return "google.rpc.Help"
|
||
|
}
|
||
|
|
||
|
// Describes a URL link.
|
||
|
type Help_Link struct {
|
||
|
// Describes what the link offers.
|
||
|
Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
|
||
|
// The URL of the link.
|
||
|
Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Help_Link) Reset() { *m = Help_Link{} }
|
||
|
func (*Help_Link) ProtoMessage() {}
|
||
|
func (*Help_Link) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{8, 0}
|
||
|
}
|
||
|
func (m *Help_Link) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *Help_Link) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_Help_Link.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *Help_Link) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Help_Link.Merge(m, src)
|
||
|
}
|
||
|
func (m *Help_Link) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *Help_Link) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Help_Link.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Help_Link proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Help_Link) GetDescription() string {
|
||
|
if m != nil {
|
||
|
return m.Description
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *Help_Link) GetUrl() string {
|
||
|
if m != nil {
|
||
|
return m.Url
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*Help_Link) XXX_MessageName() string {
|
||
|
return "google.rpc.Help.Link"
|
||
|
}
|
||
|
|
||
|
// Provides a localized error message that is safe to return to the user
|
||
|
// which can be attached to an RPC error.
|
||
|
type LocalizedMessage struct {
|
||
|
// The locale used following the specification defined at
|
||
|
// http://www.rfc-editor.org/rfc/bcp/bcp47.txt.
|
||
|
// Examples are: "en-US", "fr-CH", "es-MX"
|
||
|
Locale string `protobuf:"bytes,1,opt,name=locale,proto3" json:"locale,omitempty"`
|
||
|
// The localized error message in the above locale.
|
||
|
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *LocalizedMessage) Reset() { *m = LocalizedMessage{} }
|
||
|
func (*LocalizedMessage) ProtoMessage() {}
|
||
|
func (*LocalizedMessage) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_851816e4d6b6361a, []int{9}
|
||
|
}
|
||
|
func (m *LocalizedMessage) XXX_Unmarshal(b []byte) error {
|
||
|
return m.Unmarshal(b)
|
||
|
}
|
||
|
func (m *LocalizedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
if deterministic {
|
||
|
return xxx_messageInfo_LocalizedMessage.Marshal(b, m, deterministic)
|
||
|
} else {
|
||
|
b = b[:cap(b)]
|
||
|
n, err := m.MarshalToSizedBuffer(b)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return b[:n], nil
|
||
|
}
|
||
|
}
|
||
|
func (m *LocalizedMessage) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_LocalizedMessage.Merge(m, src)
|
||
|
}
|
||
|
func (m *LocalizedMessage) XXX_Size() int {
|
||
|
return m.Size()
|
||
|
}
|
||
|
func (m *LocalizedMessage) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_LocalizedMessage.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_LocalizedMessage proto.InternalMessageInfo
|
||
|
|
||
|
func (m *LocalizedMessage) GetLocale() string {
|
||
|
if m != nil {
|
||
|
return m.Locale
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *LocalizedMessage) GetMessage() string {
|
||
|
if m != nil {
|
||
|
return m.Message
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (*LocalizedMessage) XXX_MessageName() string {
|
||
|
return "google.rpc.LocalizedMessage"
|
||
|
}
|
||
|
func init() {
|
||
|
proto.RegisterType((*RetryInfo)(nil), "google.rpc.RetryInfo")
|
||
|
proto.RegisterType((*DebugInfo)(nil), "google.rpc.DebugInfo")
|
||
|
proto.RegisterType((*QuotaFailure)(nil), "google.rpc.QuotaFailure")
|
||
|
proto.RegisterType((*QuotaFailure_Violation)(nil), "google.rpc.QuotaFailure.Violation")
|
||
|
proto.RegisterType((*ErrorInfo)(nil), "google.rpc.ErrorInfo")
|
||
|
proto.RegisterMapType((map[string]string)(nil), "google.rpc.ErrorInfo.MetadataEntry")
|
||
|
proto.RegisterType((*PreconditionFailure)(nil), "google.rpc.PreconditionFailure")
|
||
|
proto.RegisterType((*PreconditionFailure_Violation)(nil), "google.rpc.PreconditionFailure.Violation")
|
||
|
proto.RegisterType((*BadRequest)(nil), "google.rpc.BadRequest")
|
||
|
proto.RegisterType((*BadRequest_FieldViolation)(nil), "google.rpc.BadRequest.FieldViolation")
|
||
|
proto.RegisterType((*RequestInfo)(nil), "google.rpc.RequestInfo")
|
||
|
proto.RegisterType((*ResourceInfo)(nil), "google.rpc.ResourceInfo")
|
||
|
proto.RegisterType((*Help)(nil), "google.rpc.Help")
|
||
|
proto.RegisterType((*Help_Link)(nil), "google.rpc.Help.Link")
|
||
|
proto.RegisterType((*LocalizedMessage)(nil), "google.rpc.LocalizedMessage")
|
||
|
}
|
||
|
|
||
|
func init() { proto.RegisterFile("google/rpc/error_details.proto", fileDescriptor_851816e4d6b6361a) }
|
||
|
|
||
|
var fileDescriptor_851816e4d6b6361a = []byte{
|
||
|
// 710 bytes of a gzipped FileDescriptorProto
|
||
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x3f, 0x6f, 0xd3, 0x4e,
|
||
|
0x18, 0xee, 0x25, 0x69, 0x7f, 0x3f, 0xbf, 0x49, 0x4b, 0x31, 0x50, 0x85, 0x48, 0x58, 0xc1, 0x15,
|
||
|
0x52, 0x11, 0x92, 0x2b, 0x95, 0x05, 0x95, 0x01, 0x29, 0xa4, 0xff, 0xa4, 0x16, 0x82, 0x85, 0x18,
|
||
|
0x60, 0x88, 0x2e, 0xf6, 0x9b, 0xe8, 0x88, 0xe3, 0x0b, 0x67, 0xbb, 0x28, 0x4c, 0x7c, 0x04, 0x76,
|
||
|
0x36, 0xa6, 0x7e, 0x05, 0x06, 0xf6, 0x8e, 0x1d, 0x19, 0x49, 0xba, 0x30, 0x76, 0x64, 0x44, 0x77,
|
||
|
0x3e, 0xa7, 0x6e, 0x53, 0x10, 0xdb, 0x3d, 0xef, 0x3d, 0xf7, 0xdc, 0xfb, 0x3c, 0x7a, 0xef, 0xc0,
|
||
|
0xea, 0x71, 0xde, 0x0b, 0x70, 0x5d, 0x0c, 0xbd, 0x75, 0x14, 0x82, 0x8b, 0xb6, 0x8f, 0x31, 0x65,
|
||
|
0x41, 0xe4, 0x0c, 0x05, 0x8f, 0xb9, 0x09, 0xe9, 0xbe, 0x23, 0x86, 0x5e, 0x2d, 0xe3, 0xaa, 0x9d,
|
||
|
0x4e, 0xd2, 0x5d, 0xf7, 0x13, 0x41, 0x63, 0xc6, 0xc3, 0x94, 0x6b, 0xef, 0x80, 0xe1, 0x62, 0x2c,
|
||
|
0x46, 0x7b, 0x61, 0x97, 0x9b, 0x9b, 0x50, 0x16, 0x12, 0xb4, 0x7d, 0x0c, 0xe8, 0xa8, 0x4a, 0xea,
|
||
|
0x64, 0xad, 0xbc, 0x71, 0xdb, 0xd1, 0x72, 0x99, 0x84, 0xd3, 0xd4, 0x12, 0x2e, 0x28, 0x76, 0x53,
|
||
|
0x92, 0xed, 0x5d, 0x30, 0x9a, 0xd8, 0x49, 0x7a, 0x4a, 0x68, 0x15, 0x16, 0xa3, 0x98, 0x7a, 0xfd,
|
||
|
0x36, 0x86, 0xb1, 0x60, 0x18, 0x55, 0x49, 0xbd, 0xb8, 0x66, 0xb8, 0x15, 0x55, 0xdc, 0x4a, 0x6b,
|
||
|
0xe6, 0x0a, 0x2c, 0xa4, 0x7d, 0x57, 0x0b, 0x75, 0xb2, 0x66, 0xb8, 0x1a, 0xd9, 0x9f, 0x09, 0x54,
|
||
|
0x5e, 0x24, 0x3c, 0xa6, 0xdb, 0x94, 0x05, 0x89, 0x40, 0xb3, 0x01, 0x70, 0xc8, 0x78, 0xa0, 0xee,
|
||
|
0x4c, 0xa5, 0xca, 0x1b, 0xb6, 0x73, 0x6e, 0xd2, 0xc9, 0xb3, 0x9d, 0x57, 0x19, 0xd5, 0xcd, 0x9d,
|
||
|
0xaa, 0xed, 0x80, 0x31, 0xdd, 0x30, 0xab, 0xf0, 0x5f, 0x94, 0x74, 0xde, 0xa2, 0x17, 0x2b, 0x8f,
|
||
|
0x86, 0x9b, 0x41, 0xb3, 0x0e, 0x65, 0x1f, 0x23, 0x4f, 0xb0, 0xa1, 0x24, 0xea, 0xc6, 0xf2, 0x25,
|
||
|
0xfb, 0x2b, 0x01, 0x63, 0x4b, 0x86, 0xae, 0x8c, 0xae, 0xc0, 0x82, 0x40, 0x1a, 0xf1, 0x50, 0x0b,
|
||
|
0x69, 0xa4, 0xbc, 0xf1, 0x01, 0x65, 0xe1, 0xd4, 0x9b, 0x42, 0xe6, 0x13, 0xf8, 0x7f, 0x80, 0x31,
|
||
|
0xf5, 0x69, 0x4c, 0xab, 0x45, 0x65, 0x64, 0x35, 0x6f, 0x64, 0x2a, 0xec, 0x1c, 0x68, 0x96, 0x0c,
|
||
|
0x6b, 0xe4, 0x4e, 0x0f, 0xd5, 0x1e, 0xc3, 0xe2, 0x85, 0x2d, 0x73, 0x19, 0x8a, 0x7d, 0x1c, 0xe9,
|
||
|
0xeb, 0xe5, 0xd2, 0xbc, 0x09, 0xf3, 0x87, 0x34, 0x48, 0x50, 0x5f, 0x9d, 0x82, 0xcd, 0xc2, 0x23,
|
||
|
0x62, 0x7f, 0x23, 0x70, 0xa3, 0x25, 0xd0, 0xe3, 0xa1, 0xcf, 0xa4, 0x99, 0x2c, 0xe0, 0xbd, 0x2b,
|
||
|
0x02, 0xbe, 0x9f, 0xef, 0xeb, 0x8a, 0x43, 0x7f, 0xc8, 0xf9, 0x4d, 0x3e, 0x67, 0x13, 0x4a, 0xf1,
|
||
|
0x68, 0x88, 0xba, 0x39, 0xb5, 0xce, 0x67, 0x5f, 0xf8, 0x6b, 0xf6, 0xc5, 0xd9, 0xec, 0x8f, 0x08,
|
||
|
0x40, 0x83, 0xfa, 0x2e, 0xbe, 0x4b, 0x30, 0x8a, 0xcd, 0x16, 0x2c, 0x77, 0x19, 0x06, 0x7e, 0x7b,
|
||
|
0xa6, 0xf9, 0x7b, 0xf9, 0xe6, 0xcf, 0x4f, 0x38, 0xdb, 0x92, 0x7e, 0xde, 0xf8, 0xb5, 0xee, 0x05,
|
||
|
0x1c, 0xd5, 0x76, 0x61, 0xe9, 0x22, 0x45, 0x86, 0xa9, 0x48, 0xda, 0x43, 0x0a, 0xfe, 0x61, 0x4c,
|
||
|
0x9e, 0x43, 0x59, 0x5f, 0xaa, 0xe6, 0xe4, 0x0e, 0x80, 0x48, 0x61, 0x9b, 0x65, 0x5a, 0x86, 0xae,
|
||
|
0xec, 0xf9, 0xe6, 0x5d, 0xa8, 0x44, 0x28, 0x0e, 0x59, 0xd8, 0x6b, 0xab, 0xd1, 0xd0, 0x82, 0xba,
|
||
|
0xd6, 0xa4, 0x31, 0xb5, 0x3f, 0x11, 0xa8, 0xb8, 0x18, 0xf1, 0x44, 0x78, 0x98, 0xbd, 0x31, 0xa1,
|
||
|
0x71, 0x3b, 0x97, 0x72, 0x25, 0x2b, 0xbe, 0x94, 0x69, 0xe7, 0x49, 0x21, 0x1d, 0x64, 0x33, 0x31,
|
||
|
0x25, 0x3d, 0xa3, 0x03, 0x94, 0x1e, 0xf9, 0xfb, 0x10, 0x85, 0x8e, 0x3c, 0x05, 0x97, 0x3d, 0x96,
|
||
|
0x66, 0x3d, 0x72, 0x28, 0xed, 0x62, 0x30, 0x34, 0x1f, 0xc0, 0x7c, 0xc0, 0xc2, 0x7e, 0x16, 0xfe,
|
||
|
0xad, 0x7c, 0xf8, 0x92, 0xe0, 0xec, 0xb3, 0xb0, 0xef, 0xa6, 0x9c, 0xda, 0x26, 0x94, 0x24, 0xbc,
|
||
|
0x2c, 0x4f, 0x66, 0xe4, 0xe5, 0x64, 0x27, 0x22, 0xfb, 0x1c, 0xe4, 0xd2, 0x6e, 0xc2, 0xf2, 0x3e,
|
||
|
0xf7, 0x68, 0xc0, 0x3e, 0xa0, 0x7f, 0x80, 0x51, 0x44, 0x7b, 0x28, 0x5f, 0x5a, 0x20, 0x6b, 0x99,
|
||
|
0x7f, 0x8d, 0xe4, 0x9c, 0x0d, 0x52, 0x4a, 0x36, 0x67, 0x1a, 0x36, 0xfc, 0x93, 0xb1, 0x35, 0xf7,
|
||
|
0x7d, 0x6c, 0xcd, 0x9d, 0x8d, 0x2d, 0xf2, 0x6b, 0x6c, 0x91, 0x8f, 0x13, 0x8b, 0x1c, 0x4d, 0x2c,
|
||
|
0x72, 0x3c, 0xb1, 0xc8, 0xc9, 0xc4, 0x22, 0x3f, 0x26, 0x16, 0xf9, 0x39, 0xb1, 0xe6, 0xce, 0x64,
|
||
|
0xfd, 0xd4, 0x22, 0xc7, 0xa7, 0x16, 0x81, 0x25, 0x8f, 0x0f, 0x72, 0xc6, 0x1a, 0xd7, 0xd5, 0x5b,
|
||
|
0x6d, 0xa6, 0x1f, 0x6f, 0x4b, 0x7e, 0x8d, 0x2d, 0xf2, 0xba, 0x28, 0x86, 0xde, 0x97, 0x42, 0xd1,
|
||
|
0x6d, 0x3d, 0xed, 0x2c, 0xa8, 0xef, 0xf2, 0xe1, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x94, 0xc6,
|
||
|
0xb7, 0xdd, 0xad, 0x05, 0x00, 0x00,
|
||
|
}
|
||
|
|
||
|
func (this *RetryInfo) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*RetryInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(RetryInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if c := this.RetryDelay.Compare(that1.RetryDelay); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *DebugInfo) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*DebugInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(DebugInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if len(this.StackEntries) != len(that1.StackEntries) {
|
||
|
if len(this.StackEntries) < len(that1.StackEntries) {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
for i := range this.StackEntries {
|
||
|
if this.StackEntries[i] != that1.StackEntries[i] {
|
||
|
if this.StackEntries[i] < that1.StackEntries[i] {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if this.Detail != that1.Detail {
|
||
|
if this.Detail < that1.Detail {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *QuotaFailure) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*QuotaFailure)
|
||
|
if !ok {
|
||
|
that2, ok := that.(QuotaFailure)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if len(this.Violations) != len(that1.Violations) {
|
||
|
if len(this.Violations) < len(that1.Violations) {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
for i := range this.Violations {
|
||
|
if c := this.Violations[i].Compare(that1.Violations[i]); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *QuotaFailure_Violation) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*QuotaFailure_Violation)
|
||
|
if !ok {
|
||
|
that2, ok := that.(QuotaFailure_Violation)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.Subject != that1.Subject {
|
||
|
if this.Subject < that1.Subject {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
if this.Description < that1.Description {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *ErrorInfo) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*ErrorInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(ErrorInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.Reason != that1.Reason {
|
||
|
if this.Reason < that1.Reason {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Domain != that1.Domain {
|
||
|
if this.Domain < that1.Domain {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if len(this.Metadata) != len(that1.Metadata) {
|
||
|
if len(this.Metadata) < len(that1.Metadata) {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
for i := range this.Metadata {
|
||
|
if this.Metadata[i] != that1.Metadata[i] {
|
||
|
if this.Metadata[i] < that1.Metadata[i] {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *PreconditionFailure) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*PreconditionFailure)
|
||
|
if !ok {
|
||
|
that2, ok := that.(PreconditionFailure)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if len(this.Violations) != len(that1.Violations) {
|
||
|
if len(this.Violations) < len(that1.Violations) {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
for i := range this.Violations {
|
||
|
if c := this.Violations[i].Compare(that1.Violations[i]); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *PreconditionFailure_Violation) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*PreconditionFailure_Violation)
|
||
|
if !ok {
|
||
|
that2, ok := that.(PreconditionFailure_Violation)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.Type != that1.Type {
|
||
|
if this.Type < that1.Type {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Subject != that1.Subject {
|
||
|
if this.Subject < that1.Subject {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
if this.Description < that1.Description {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *BadRequest) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*BadRequest)
|
||
|
if !ok {
|
||
|
that2, ok := that.(BadRequest)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if len(this.FieldViolations) != len(that1.FieldViolations) {
|
||
|
if len(this.FieldViolations) < len(that1.FieldViolations) {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
for i := range this.FieldViolations {
|
||
|
if c := this.FieldViolations[i].Compare(that1.FieldViolations[i]); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *BadRequest_FieldViolation) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*BadRequest_FieldViolation)
|
||
|
if !ok {
|
||
|
that2, ok := that.(BadRequest_FieldViolation)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.Field != that1.Field {
|
||
|
if this.Field < that1.Field {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
if this.Description < that1.Description {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *RequestInfo) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*RequestInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(RequestInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.RequestId != that1.RequestId {
|
||
|
if this.RequestId < that1.RequestId {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.ServingData != that1.ServingData {
|
||
|
if this.ServingData < that1.ServingData {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *ResourceInfo) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*ResourceInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(ResourceInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.ResourceType != that1.ResourceType {
|
||
|
if this.ResourceType < that1.ResourceType {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.ResourceName != that1.ResourceName {
|
||
|
if this.ResourceName < that1.ResourceName {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Owner != that1.Owner {
|
||
|
if this.Owner < that1.Owner {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
if this.Description < that1.Description {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *Help) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*Help)
|
||
|
if !ok {
|
||
|
that2, ok := that.(Help)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if len(this.Links) != len(that1.Links) {
|
||
|
if len(this.Links) < len(that1.Links) {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
for i := range this.Links {
|
||
|
if c := this.Links[i].Compare(that1.Links[i]); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *Help_Link) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*Help_Link)
|
||
|
if !ok {
|
||
|
that2, ok := that.(Help_Link)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
if this.Description < that1.Description {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Url != that1.Url {
|
||
|
if this.Url < that1.Url {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *LocalizedMessage) Compare(that interface{}) int {
|
||
|
if that == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*LocalizedMessage)
|
||
|
if !ok {
|
||
|
that2, ok := that.(LocalizedMessage)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return 1
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
if this == nil {
|
||
|
return 0
|
||
|
}
|
||
|
return 1
|
||
|
} else if this == nil {
|
||
|
return -1
|
||
|
}
|
||
|
if this.Locale != that1.Locale {
|
||
|
if this.Locale < that1.Locale {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if this.Message != that1.Message {
|
||
|
if this.Message < that1.Message {
|
||
|
return -1
|
||
|
}
|
||
|
return 1
|
||
|
}
|
||
|
if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
|
||
|
return c
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
func (this *RetryInfo) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*RetryInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(RetryInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if !this.RetryDelay.Equal(that1.RetryDelay) {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *DebugInfo) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*DebugInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(DebugInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if len(this.StackEntries) != len(that1.StackEntries) {
|
||
|
return false
|
||
|
}
|
||
|
for i := range this.StackEntries {
|
||
|
if this.StackEntries[i] != that1.StackEntries[i] {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if this.Detail != that1.Detail {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *QuotaFailure) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*QuotaFailure)
|
||
|
if !ok {
|
||
|
that2, ok := that.(QuotaFailure)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if len(this.Violations) != len(that1.Violations) {
|
||
|
return false
|
||
|
}
|
||
|
for i := range this.Violations {
|
||
|
if !this.Violations[i].Equal(that1.Violations[i]) {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *QuotaFailure_Violation) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*QuotaFailure_Violation)
|
||
|
if !ok {
|
||
|
that2, ok := that.(QuotaFailure_Violation)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.Subject != that1.Subject {
|
||
|
return false
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *ErrorInfo) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*ErrorInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(ErrorInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.Reason != that1.Reason {
|
||
|
return false
|
||
|
}
|
||
|
if this.Domain != that1.Domain {
|
||
|
return false
|
||
|
}
|
||
|
if len(this.Metadata) != len(that1.Metadata) {
|
||
|
return false
|
||
|
}
|
||
|
for i := range this.Metadata {
|
||
|
if this.Metadata[i] != that1.Metadata[i] {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *PreconditionFailure) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*PreconditionFailure)
|
||
|
if !ok {
|
||
|
that2, ok := that.(PreconditionFailure)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if len(this.Violations) != len(that1.Violations) {
|
||
|
return false
|
||
|
}
|
||
|
for i := range this.Violations {
|
||
|
if !this.Violations[i].Equal(that1.Violations[i]) {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *PreconditionFailure_Violation) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*PreconditionFailure_Violation)
|
||
|
if !ok {
|
||
|
that2, ok := that.(PreconditionFailure_Violation)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.Type != that1.Type {
|
||
|
return false
|
||
|
}
|
||
|
if this.Subject != that1.Subject {
|
||
|
return false
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *BadRequest) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*BadRequest)
|
||
|
if !ok {
|
||
|
that2, ok := that.(BadRequest)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if len(this.FieldViolations) != len(that1.FieldViolations) {
|
||
|
return false
|
||
|
}
|
||
|
for i := range this.FieldViolations {
|
||
|
if !this.FieldViolations[i].Equal(that1.FieldViolations[i]) {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *BadRequest_FieldViolation) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*BadRequest_FieldViolation)
|
||
|
if !ok {
|
||
|
that2, ok := that.(BadRequest_FieldViolation)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.Field != that1.Field {
|
||
|
return false
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *RequestInfo) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*RequestInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(RequestInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.RequestId != that1.RequestId {
|
||
|
return false
|
||
|
}
|
||
|
if this.ServingData != that1.ServingData {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *ResourceInfo) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*ResourceInfo)
|
||
|
if !ok {
|
||
|
that2, ok := that.(ResourceInfo)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.ResourceType != that1.ResourceType {
|
||
|
return false
|
||
|
}
|
||
|
if this.ResourceName != that1.ResourceName {
|
||
|
return false
|
||
|
}
|
||
|
if this.Owner != that1.Owner {
|
||
|
return false
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *Help) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*Help)
|
||
|
if !ok {
|
||
|
that2, ok := that.(Help)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if len(this.Links) != len(that1.Links) {
|
||
|
return false
|
||
|
}
|
||
|
for i := range this.Links {
|
||
|
if !this.Links[i].Equal(that1.Links[i]) {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *Help_Link) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*Help_Link)
|
||
|
if !ok {
|
||
|
that2, ok := that.(Help_Link)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.Description != that1.Description {
|
||
|
return false
|
||
|
}
|
||
|
if this.Url != that1.Url {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *LocalizedMessage) Equal(that interface{}) bool {
|
||
|
if that == nil {
|
||
|
return this == nil
|
||
|
}
|
||
|
|
||
|
that1, ok := that.(*LocalizedMessage)
|
||
|
if !ok {
|
||
|
that2, ok := that.(LocalizedMessage)
|
||
|
if ok {
|
||
|
that1 = &that2
|
||
|
} else {
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
if that1 == nil {
|
||
|
return this == nil
|
||
|
} else if this == nil {
|
||
|
return false
|
||
|
}
|
||
|
if this.Locale != that1.Locale {
|
||
|
return false
|
||
|
}
|
||
|
if this.Message != that1.Message {
|
||
|
return false
|
||
|
}
|
||
|
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
|
||
|
return false
|
||
|
}
|
||
|
return true
|
||
|
}
|
||
|
func (this *RetryInfo) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 5)
|
||
|
s = append(s, "&rpc.RetryInfo{")
|
||
|
if this.RetryDelay != nil {
|
||
|
s = append(s, "RetryDelay: "+fmt.Sprintf("%#v", this.RetryDelay)+",\n")
|
||
|
}
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *DebugInfo) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 6)
|
||
|
s = append(s, "&rpc.DebugInfo{")
|
||
|
s = append(s, "StackEntries: "+fmt.Sprintf("%#v", this.StackEntries)+",\n")
|
||
|
s = append(s, "Detail: "+fmt.Sprintf("%#v", this.Detail)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *QuotaFailure) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 5)
|
||
|
s = append(s, "&rpc.QuotaFailure{")
|
||
|
if this.Violations != nil {
|
||
|
s = append(s, "Violations: "+fmt.Sprintf("%#v", this.Violations)+",\n")
|
||
|
}
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *QuotaFailure_Violation) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 6)
|
||
|
s = append(s, "&rpc.QuotaFailure_Violation{")
|
||
|
s = append(s, "Subject: "+fmt.Sprintf("%#v", this.Subject)+",\n")
|
||
|
s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *ErrorInfo) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 7)
|
||
|
s = append(s, "&rpc.ErrorInfo{")
|
||
|
s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
|
||
|
s = append(s, "Domain: "+fmt.Sprintf("%#v", this.Domain)+",\n")
|
||
|
keysForMetadata := make([]string, 0, len(this.Metadata))
|
||
|
for k, _ := range this.Metadata {
|
||
|
keysForMetadata = append(keysForMetadata, k)
|
||
|
}
|
||
|
github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
|
||
|
mapStringForMetadata := "map[string]string{"
|
||
|
for _, k := range keysForMetadata {
|
||
|
mapStringForMetadata += fmt.Sprintf("%#v: %#v,", k, this.Metadata[k])
|
||
|
}
|
||
|
mapStringForMetadata += "}"
|
||
|
if this.Metadata != nil {
|
||
|
s = append(s, "Metadata: "+mapStringForMetadata+",\n")
|
||
|
}
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *PreconditionFailure) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 5)
|
||
|
s = append(s, "&rpc.PreconditionFailure{")
|
||
|
if this.Violations != nil {
|
||
|
s = append(s, "Violations: "+fmt.Sprintf("%#v", this.Violations)+",\n")
|
||
|
}
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *PreconditionFailure_Violation) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 7)
|
||
|
s = append(s, "&rpc.PreconditionFailure_Violation{")
|
||
|
s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
|
||
|
s = append(s, "Subject: "+fmt.Sprintf("%#v", this.Subject)+",\n")
|
||
|
s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *BadRequest) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 5)
|
||
|
s = append(s, "&rpc.BadRequest{")
|
||
|
if this.FieldViolations != nil {
|
||
|
s = append(s, "FieldViolations: "+fmt.Sprintf("%#v", this.FieldViolations)+",\n")
|
||
|
}
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *BadRequest_FieldViolation) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 6)
|
||
|
s = append(s, "&rpc.BadRequest_FieldViolation{")
|
||
|
s = append(s, "Field: "+fmt.Sprintf("%#v", this.Field)+",\n")
|
||
|
s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *RequestInfo) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 6)
|
||
|
s = append(s, "&rpc.RequestInfo{")
|
||
|
s = append(s, "RequestId: "+fmt.Sprintf("%#v", this.RequestId)+",\n")
|
||
|
s = append(s, "ServingData: "+fmt.Sprintf("%#v", this.ServingData)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *ResourceInfo) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 8)
|
||
|
s = append(s, "&rpc.ResourceInfo{")
|
||
|
s = append(s, "ResourceType: "+fmt.Sprintf("%#v", this.ResourceType)+",\n")
|
||
|
s = append(s, "ResourceName: "+fmt.Sprintf("%#v", this.ResourceName)+",\n")
|
||
|
s = append(s, "Owner: "+fmt.Sprintf("%#v", this.Owner)+",\n")
|
||
|
s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *Help) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 5)
|
||
|
s = append(s, "&rpc.Help{")
|
||
|
if this.Links != nil {
|
||
|
s = append(s, "Links: "+fmt.Sprintf("%#v", this.Links)+",\n")
|
||
|
}
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *Help_Link) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 6)
|
||
|
s = append(s, "&rpc.Help_Link{")
|
||
|
s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n")
|
||
|
s = append(s, "Url: "+fmt.Sprintf("%#v", this.Url)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func (this *LocalizedMessage) GoString() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := make([]string, 0, 6)
|
||
|
s = append(s, "&rpc.LocalizedMessage{")
|
||
|
s = append(s, "Locale: "+fmt.Sprintf("%#v", this.Locale)+",\n")
|
||
|
s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
|
||
|
if this.XXX_unrecognized != nil {
|
||
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
||
|
}
|
||
|
s = append(s, "}")
|
||
|
return strings.Join(s, "")
|
||
|
}
|
||
|
func valueToGoStringErrorDetails(v interface{}, typ string) string {
|
||
|
rv := reflect.ValueOf(v)
|
||
|
if rv.IsNil() {
|
||
|
return "nil"
|
||
|
}
|
||
|
pv := reflect.Indirect(rv).Interface()
|
||
|
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
|
||
|
}
|
||
|
func (m *RetryInfo) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *RetryInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *RetryInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if m.RetryDelay != nil {
|
||
|
{
|
||
|
size, err := m.RetryDelay.MarshalToSizedBuffer(dAtA[:i])
|
||
|
if err != nil {
|
||
|
return 0, err
|
||
|
}
|
||
|
i -= size
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(size))
|
||
|
}
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *DebugInfo) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *DebugInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *DebugInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Detail) > 0 {
|
||
|
i -= len(m.Detail)
|
||
|
copy(dAtA[i:], m.Detail)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Detail)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.StackEntries) > 0 {
|
||
|
for iNdEx := len(m.StackEntries) - 1; iNdEx >= 0; iNdEx-- {
|
||
|
i -= len(m.StackEntries[iNdEx])
|
||
|
copy(dAtA[i:], m.StackEntries[iNdEx])
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.StackEntries[iNdEx])))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Violations) > 0 {
|
||
|
for iNdEx := len(m.Violations) - 1; iNdEx >= 0; iNdEx-- {
|
||
|
{
|
||
|
size, err := m.Violations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||
|
if err != nil {
|
||
|
return 0, err
|
||
|
}
|
||
|
i -= size
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(size))
|
||
|
}
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure_Violation) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure_Violation) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure_Violation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Description) > 0 {
|
||
|
i -= len(m.Description)
|
||
|
copy(dAtA[i:], m.Description)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.Subject) > 0 {
|
||
|
i -= len(m.Subject)
|
||
|
copy(dAtA[i:], m.Subject)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Subject)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Metadata) > 0 {
|
||
|
for k := range m.Metadata {
|
||
|
v := m.Metadata[k]
|
||
|
baseI := i
|
||
|
i -= len(v)
|
||
|
copy(dAtA[i:], v)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(v)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
i -= len(k)
|
||
|
copy(dAtA[i:], k)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(k)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(baseI-i))
|
||
|
i--
|
||
|
dAtA[i] = 0x1a
|
||
|
}
|
||
|
}
|
||
|
if len(m.Domain) > 0 {
|
||
|
i -= len(m.Domain)
|
||
|
copy(dAtA[i:], m.Domain)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Domain)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.Reason) > 0 {
|
||
|
i -= len(m.Reason)
|
||
|
copy(dAtA[i:], m.Reason)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Reason)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Violations) > 0 {
|
||
|
for iNdEx := len(m.Violations) - 1; iNdEx >= 0; iNdEx-- {
|
||
|
{
|
||
|
size, err := m.Violations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||
|
if err != nil {
|
||
|
return 0, err
|
||
|
}
|
||
|
i -= size
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(size))
|
||
|
}
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Description) > 0 {
|
||
|
i -= len(m.Description)
|
||
|
copy(dAtA[i:], m.Description)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description)))
|
||
|
i--
|
||
|
dAtA[i] = 0x1a
|
||
|
}
|
||
|
if len(m.Subject) > 0 {
|
||
|
i -= len(m.Subject)
|
||
|
copy(dAtA[i:], m.Subject)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Subject)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.Type) > 0 {
|
||
|
i -= len(m.Type)
|
||
|
copy(dAtA[i:], m.Type)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Type)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.FieldViolations) > 0 {
|
||
|
for iNdEx := len(m.FieldViolations) - 1; iNdEx >= 0; iNdEx-- {
|
||
|
{
|
||
|
size, err := m.FieldViolations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||
|
if err != nil {
|
||
|
return 0, err
|
||
|
}
|
||
|
i -= size
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(size))
|
||
|
}
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Description) > 0 {
|
||
|
i -= len(m.Description)
|
||
|
copy(dAtA[i:], m.Description)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.Field) > 0 {
|
||
|
i -= len(m.Field)
|
||
|
copy(dAtA[i:], m.Field)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Field)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *RequestInfo) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *RequestInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *RequestInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.ServingData) > 0 {
|
||
|
i -= len(m.ServingData)
|
||
|
copy(dAtA[i:], m.ServingData)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.ServingData)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.RequestId) > 0 {
|
||
|
i -= len(m.RequestId)
|
||
|
copy(dAtA[i:], m.RequestId)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.RequestId)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Description) > 0 {
|
||
|
i -= len(m.Description)
|
||
|
copy(dAtA[i:], m.Description)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description)))
|
||
|
i--
|
||
|
dAtA[i] = 0x22
|
||
|
}
|
||
|
if len(m.Owner) > 0 {
|
||
|
i -= len(m.Owner)
|
||
|
copy(dAtA[i:], m.Owner)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Owner)))
|
||
|
i--
|
||
|
dAtA[i] = 0x1a
|
||
|
}
|
||
|
if len(m.ResourceName) > 0 {
|
||
|
i -= len(m.ResourceName)
|
||
|
copy(dAtA[i:], m.ResourceName)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.ResourceName)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.ResourceType) > 0 {
|
||
|
i -= len(m.ResourceType)
|
||
|
copy(dAtA[i:], m.ResourceType)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.ResourceType)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *Help) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *Help) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *Help) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Links) > 0 {
|
||
|
for iNdEx := len(m.Links) - 1; iNdEx >= 0; iNdEx-- {
|
||
|
{
|
||
|
size, err := m.Links[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||
|
if err != nil {
|
||
|
return 0, err
|
||
|
}
|
||
|
i -= size
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(size))
|
||
|
}
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *Help_Link) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *Help_Link) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *Help_Link) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Url) > 0 {
|
||
|
i -= len(m.Url)
|
||
|
copy(dAtA[i:], m.Url)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Url)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.Description) > 0 {
|
||
|
i -= len(m.Description)
|
||
|
copy(dAtA[i:], m.Description)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func (m *LocalizedMessage) Marshal() (dAtA []byte, err error) {
|
||
|
size := m.Size()
|
||
|
dAtA = make([]byte, size)
|
||
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return dAtA[:n], nil
|
||
|
}
|
||
|
|
||
|
func (m *LocalizedMessage) MarshalTo(dAtA []byte) (int, error) {
|
||
|
size := m.Size()
|
||
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
|
}
|
||
|
|
||
|
func (m *LocalizedMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
|
i := len(dAtA)
|
||
|
_ = i
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
i -= len(m.XXX_unrecognized)
|
||
|
copy(dAtA[i:], m.XXX_unrecognized)
|
||
|
}
|
||
|
if len(m.Message) > 0 {
|
||
|
i -= len(m.Message)
|
||
|
copy(dAtA[i:], m.Message)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Message)))
|
||
|
i--
|
||
|
dAtA[i] = 0x12
|
||
|
}
|
||
|
if len(m.Locale) > 0 {
|
||
|
i -= len(m.Locale)
|
||
|
copy(dAtA[i:], m.Locale)
|
||
|
i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Locale)))
|
||
|
i--
|
||
|
dAtA[i] = 0xa
|
||
|
}
|
||
|
return len(dAtA) - i, nil
|
||
|
}
|
||
|
|
||
|
func encodeVarintErrorDetails(dAtA []byte, offset int, v uint64) int {
|
||
|
offset -= sovErrorDetails(v)
|
||
|
base := offset
|
||
|
for v >= 1<<7 {
|
||
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
||
|
v >>= 7
|
||
|
offset++
|
||
|
}
|
||
|
dAtA[offset] = uint8(v)
|
||
|
return base
|
||
|
}
|
||
|
func NewPopulatedRetryInfo(r randyErrorDetails, easy bool) *RetryInfo {
|
||
|
this := &RetryInfo{}
|
||
|
if r.Intn(5) != 0 {
|
||
|
this.RetryDelay = types.NewPopulatedDuration(r, easy)
|
||
|
}
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedDebugInfo(r randyErrorDetails, easy bool) *DebugInfo {
|
||
|
this := &DebugInfo{}
|
||
|
v1 := r.Intn(10)
|
||
|
this.StackEntries = make([]string, v1)
|
||
|
for i := 0; i < v1; i++ {
|
||
|
this.StackEntries[i] = string(randStringErrorDetails(r))
|
||
|
}
|
||
|
this.Detail = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedQuotaFailure(r randyErrorDetails, easy bool) *QuotaFailure {
|
||
|
this := &QuotaFailure{}
|
||
|
if r.Intn(5) != 0 {
|
||
|
v2 := r.Intn(5)
|
||
|
this.Violations = make([]*QuotaFailure_Violation, v2)
|
||
|
for i := 0; i < v2; i++ {
|
||
|
this.Violations[i] = NewPopulatedQuotaFailure_Violation(r, easy)
|
||
|
}
|
||
|
}
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedQuotaFailure_Violation(r randyErrorDetails, easy bool) *QuotaFailure_Violation {
|
||
|
this := &QuotaFailure_Violation{}
|
||
|
this.Subject = string(randStringErrorDetails(r))
|
||
|
this.Description = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedErrorInfo(r randyErrorDetails, easy bool) *ErrorInfo {
|
||
|
this := &ErrorInfo{}
|
||
|
this.Reason = string(randStringErrorDetails(r))
|
||
|
this.Domain = string(randStringErrorDetails(r))
|
||
|
if r.Intn(5) != 0 {
|
||
|
v3 := r.Intn(10)
|
||
|
this.Metadata = make(map[string]string)
|
||
|
for i := 0; i < v3; i++ {
|
||
|
this.Metadata[randStringErrorDetails(r)] = randStringErrorDetails(r)
|
||
|
}
|
||
|
}
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 4)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedPreconditionFailure(r randyErrorDetails, easy bool) *PreconditionFailure {
|
||
|
this := &PreconditionFailure{}
|
||
|
if r.Intn(5) != 0 {
|
||
|
v4 := r.Intn(5)
|
||
|
this.Violations = make([]*PreconditionFailure_Violation, v4)
|
||
|
for i := 0; i < v4; i++ {
|
||
|
this.Violations[i] = NewPopulatedPreconditionFailure_Violation(r, easy)
|
||
|
}
|
||
|
}
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedPreconditionFailure_Violation(r randyErrorDetails, easy bool) *PreconditionFailure_Violation {
|
||
|
this := &PreconditionFailure_Violation{}
|
||
|
this.Type = string(randStringErrorDetails(r))
|
||
|
this.Subject = string(randStringErrorDetails(r))
|
||
|
this.Description = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 4)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedBadRequest(r randyErrorDetails, easy bool) *BadRequest {
|
||
|
this := &BadRequest{}
|
||
|
if r.Intn(5) != 0 {
|
||
|
v5 := r.Intn(5)
|
||
|
this.FieldViolations = make([]*BadRequest_FieldViolation, v5)
|
||
|
for i := 0; i < v5; i++ {
|
||
|
this.FieldViolations[i] = NewPopulatedBadRequest_FieldViolation(r, easy)
|
||
|
}
|
||
|
}
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedBadRequest_FieldViolation(r randyErrorDetails, easy bool) *BadRequest_FieldViolation {
|
||
|
this := &BadRequest_FieldViolation{}
|
||
|
this.Field = string(randStringErrorDetails(r))
|
||
|
this.Description = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedRequestInfo(r randyErrorDetails, easy bool) *RequestInfo {
|
||
|
this := &RequestInfo{}
|
||
|
this.RequestId = string(randStringErrorDetails(r))
|
||
|
this.ServingData = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedResourceInfo(r randyErrorDetails, easy bool) *ResourceInfo {
|
||
|
this := &ResourceInfo{}
|
||
|
this.ResourceType = string(randStringErrorDetails(r))
|
||
|
this.ResourceName = string(randStringErrorDetails(r))
|
||
|
this.Owner = string(randStringErrorDetails(r))
|
||
|
this.Description = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 5)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedHelp(r randyErrorDetails, easy bool) *Help {
|
||
|
this := &Help{}
|
||
|
if r.Intn(5) != 0 {
|
||
|
v6 := r.Intn(5)
|
||
|
this.Links = make([]*Help_Link, v6)
|
||
|
for i := 0; i < v6; i++ {
|
||
|
this.Links[i] = NewPopulatedHelp_Link(r, easy)
|
||
|
}
|
||
|
}
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedHelp_Link(r randyErrorDetails, easy bool) *Help_Link {
|
||
|
this := &Help_Link{}
|
||
|
this.Description = string(randStringErrorDetails(r))
|
||
|
this.Url = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
func NewPopulatedLocalizedMessage(r randyErrorDetails, easy bool) *LocalizedMessage {
|
||
|
this := &LocalizedMessage{}
|
||
|
this.Locale = string(randStringErrorDetails(r))
|
||
|
this.Message = string(randStringErrorDetails(r))
|
||
|
if !easy && r.Intn(10) != 0 {
|
||
|
this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3)
|
||
|
}
|
||
|
return this
|
||
|
}
|
||
|
|
||
|
type randyErrorDetails interface {
|
||
|
Float32() float32
|
||
|
Float64() float64
|
||
|
Int63() int64
|
||
|
Int31() int32
|
||
|
Uint32() uint32
|
||
|
Intn(n int) int
|
||
|
}
|
||
|
|
||
|
func randUTF8RuneErrorDetails(r randyErrorDetails) rune {
|
||
|
ru := r.Intn(62)
|
||
|
if ru < 10 {
|
||
|
return rune(ru + 48)
|
||
|
} else if ru < 36 {
|
||
|
return rune(ru + 55)
|
||
|
}
|
||
|
return rune(ru + 61)
|
||
|
}
|
||
|
func randStringErrorDetails(r randyErrorDetails) string {
|
||
|
v7 := r.Intn(100)
|
||
|
tmps := make([]rune, v7)
|
||
|
for i := 0; i < v7; i++ {
|
||
|
tmps[i] = randUTF8RuneErrorDetails(r)
|
||
|
}
|
||
|
return string(tmps)
|
||
|
}
|
||
|
func randUnrecognizedErrorDetails(r randyErrorDetails, maxFieldNumber int) (dAtA []byte) {
|
||
|
l := r.Intn(5)
|
||
|
for i := 0; i < l; i++ {
|
||
|
wire := r.Intn(4)
|
||
|
if wire == 3 {
|
||
|
wire = 5
|
||
|
}
|
||
|
fieldNumber := maxFieldNumber + r.Intn(100)
|
||
|
dAtA = randFieldErrorDetails(dAtA, r, fieldNumber, wire)
|
||
|
}
|
||
|
return dAtA
|
||
|
}
|
||
|
func randFieldErrorDetails(dAtA []byte, r randyErrorDetails, fieldNumber int, wire int) []byte {
|
||
|
key := uint32(fieldNumber)<<3 | uint32(wire)
|
||
|
switch wire {
|
||
|
case 0:
|
||
|
dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key))
|
||
|
v8 := r.Int63()
|
||
|
if r.Intn(2) == 0 {
|
||
|
v8 *= -1
|
||
|
}
|
||
|
dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(v8))
|
||
|
case 1:
|
||
|
dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key))
|
||
|
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
|
||
|
case 2:
|
||
|
dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key))
|
||
|
ll := r.Intn(100)
|
||
|
dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(ll))
|
||
|
for j := 0; j < ll; j++ {
|
||
|
dAtA = append(dAtA, byte(r.Intn(256)))
|
||
|
}
|
||
|
default:
|
||
|
dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key))
|
||
|
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
|
||
|
}
|
||
|
return dAtA
|
||
|
}
|
||
|
func encodeVarintPopulateErrorDetails(dAtA []byte, v uint64) []byte {
|
||
|
for v >= 1<<7 {
|
||
|
dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
|
||
|
v >>= 7
|
||
|
}
|
||
|
dAtA = append(dAtA, uint8(v))
|
||
|
return dAtA
|
||
|
}
|
||
|
func (m *RetryInfo) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
if m.RetryDelay != nil {
|
||
|
l = m.RetryDelay.Size()
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *DebugInfo) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
if len(m.StackEntries) > 0 {
|
||
|
for _, s := range m.StackEntries {
|
||
|
l = len(s)
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
}
|
||
|
l = len(m.Detail)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
if len(m.Violations) > 0 {
|
||
|
for _, e := range m.Violations {
|
||
|
l = e.Size()
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *QuotaFailure_Violation) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.Subject)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Description)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *ErrorInfo) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.Reason)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Domain)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if len(m.Metadata) > 0 {
|
||
|
for k, v := range m.Metadata {
|
||
|
_ = k
|
||
|
_ = v
|
||
|
mapEntrySize := 1 + len(k) + sovErrorDetails(uint64(len(k))) + 1 + len(v) + sovErrorDetails(uint64(len(v)))
|
||
|
n += mapEntrySize + 1 + sovErrorDetails(uint64(mapEntrySize))
|
||
|
}
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
if len(m.Violations) > 0 {
|
||
|
for _, e := range m.Violations {
|
||
|
l = e.Size()
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *PreconditionFailure_Violation) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.Type)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Subject)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Description)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
if len(m.FieldViolations) > 0 {
|
||
|
for _, e := range m.FieldViolations {
|
||
|
l = e.Size()
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *BadRequest_FieldViolation) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.Field)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Description)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *RequestInfo) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.RequestId)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.ServingData)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *ResourceInfo) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.ResourceType)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.ResourceName)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Owner)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Description)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *Help) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
if len(m.Links) > 0 {
|
||
|
for _, e := range m.Links {
|
||
|
l = e.Size()
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *Help_Link) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.Description)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Url)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func (m *LocalizedMessage) Size() (n int) {
|
||
|
if m == nil {
|
||
|
return 0
|
||
|
}
|
||
|
var l int
|
||
|
_ = l
|
||
|
l = len(m.Locale)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
l = len(m.Message)
|
||
|
if l > 0 {
|
||
|
n += 1 + l + sovErrorDetails(uint64(l))
|
||
|
}
|
||
|
if m.XXX_unrecognized != nil {
|
||
|
n += len(m.XXX_unrecognized)
|
||
|
}
|
||
|
return n
|
||
|
}
|
||
|
|
||
|
func sovErrorDetails(x uint64) (n int) {
|
||
|
return (math_bits.Len64(x|1) + 6) / 7
|
||
|
}
|
||
|
func sozErrorDetails(x uint64) (n int) {
|
||
|
return sovErrorDetails(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
||
|
}
|
||
|
func (this *RetryInfo) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&RetryInfo{`,
|
||
|
`RetryDelay:` + strings.Replace(fmt.Sprintf("%v", this.RetryDelay), "Duration", "types.Duration", 1) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *DebugInfo) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&DebugInfo{`,
|
||
|
`StackEntries:` + fmt.Sprintf("%v", this.StackEntries) + `,`,
|
||
|
`Detail:` + fmt.Sprintf("%v", this.Detail) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *QuotaFailure) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
repeatedStringForViolations := "[]*QuotaFailure_Violation{"
|
||
|
for _, f := range this.Violations {
|
||
|
repeatedStringForViolations += strings.Replace(fmt.Sprintf("%v", f), "QuotaFailure_Violation", "QuotaFailure_Violation", 1) + ","
|
||
|
}
|
||
|
repeatedStringForViolations += "}"
|
||
|
s := strings.Join([]string{`&QuotaFailure{`,
|
||
|
`Violations:` + repeatedStringForViolations + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *QuotaFailure_Violation) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&QuotaFailure_Violation{`,
|
||
|
`Subject:` + fmt.Sprintf("%v", this.Subject) + `,`,
|
||
|
`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *ErrorInfo) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
keysForMetadata := make([]string, 0, len(this.Metadata))
|
||
|
for k, _ := range this.Metadata {
|
||
|
keysForMetadata = append(keysForMetadata, k)
|
||
|
}
|
||
|
github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
|
||
|
mapStringForMetadata := "map[string]string{"
|
||
|
for _, k := range keysForMetadata {
|
||
|
mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k])
|
||
|
}
|
||
|
mapStringForMetadata += "}"
|
||
|
s := strings.Join([]string{`&ErrorInfo{`,
|
||
|
`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
|
||
|
`Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
|
||
|
`Metadata:` + mapStringForMetadata + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *PreconditionFailure) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
repeatedStringForViolations := "[]*PreconditionFailure_Violation{"
|
||
|
for _, f := range this.Violations {
|
||
|
repeatedStringForViolations += strings.Replace(fmt.Sprintf("%v", f), "PreconditionFailure_Violation", "PreconditionFailure_Violation", 1) + ","
|
||
|
}
|
||
|
repeatedStringForViolations += "}"
|
||
|
s := strings.Join([]string{`&PreconditionFailure{`,
|
||
|
`Violations:` + repeatedStringForViolations + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *PreconditionFailure_Violation) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&PreconditionFailure_Violation{`,
|
||
|
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
|
||
|
`Subject:` + fmt.Sprintf("%v", this.Subject) + `,`,
|
||
|
`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *BadRequest) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
repeatedStringForFieldViolations := "[]*BadRequest_FieldViolation{"
|
||
|
for _, f := range this.FieldViolations {
|
||
|
repeatedStringForFieldViolations += strings.Replace(fmt.Sprintf("%v", f), "BadRequest_FieldViolation", "BadRequest_FieldViolation", 1) + ","
|
||
|
}
|
||
|
repeatedStringForFieldViolations += "}"
|
||
|
s := strings.Join([]string{`&BadRequest{`,
|
||
|
`FieldViolations:` + repeatedStringForFieldViolations + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *BadRequest_FieldViolation) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&BadRequest_FieldViolation{`,
|
||
|
`Field:` + fmt.Sprintf("%v", this.Field) + `,`,
|
||
|
`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *RequestInfo) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&RequestInfo{`,
|
||
|
`RequestId:` + fmt.Sprintf("%v", this.RequestId) + `,`,
|
||
|
`ServingData:` + fmt.Sprintf("%v", this.ServingData) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *ResourceInfo) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&ResourceInfo{`,
|
||
|
`ResourceType:` + fmt.Sprintf("%v", this.ResourceType) + `,`,
|
||
|
`ResourceName:` + fmt.Sprintf("%v", this.ResourceName) + `,`,
|
||
|
`Owner:` + fmt.Sprintf("%v", this.Owner) + `,`,
|
||
|
`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *Help) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
repeatedStringForLinks := "[]*Help_Link{"
|
||
|
for _, f := range this.Links {
|
||
|
repeatedStringForLinks += strings.Replace(fmt.Sprintf("%v", f), "Help_Link", "Help_Link", 1) + ","
|
||
|
}
|
||
|
repeatedStringForLinks += "}"
|
||
|
s := strings.Join([]string{`&Help{`,
|
||
|
`Links:` + repeatedStringForLinks + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *Help_Link) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&Help_Link{`,
|
||
|
`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
|
||
|
`Url:` + fmt.Sprintf("%v", this.Url) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func (this *LocalizedMessage) String() string {
|
||
|
if this == nil {
|
||
|
return "nil"
|
||
|
}
|
||
|
s := strings.Join([]string{`&LocalizedMessage{`,
|
||
|
`Locale:` + fmt.Sprintf("%v", this.Locale) + `,`,
|
||
|
`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
|
||
|
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
|
||
|
`}`,
|
||
|
}, "")
|
||
|
return s
|
||
|
}
|
||
|
func valueToStringErrorDetails(v interface{}) string {
|
||
|
rv := reflect.ValueOf(v)
|
||
|
if rv.IsNil() {
|
||
|
return "nil"
|
||
|
}
|
||
|
pv := reflect.Indirect(rv).Interface()
|
||
|
return fmt.Sprintf("*%v", pv)
|
||
|
}
|
||
|
func (m *RetryInfo) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: RetryInfo: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: RetryInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field RetryDelay", wireType)
|
||
|
}
|
||
|
var msglen int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
msglen |= int(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if msglen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + msglen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
if m.RetryDelay == nil {
|
||
|
m.RetryDelay = &types.Duration{}
|
||
|
}
|
||
|
if err := m.RetryDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *DebugInfo) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: DebugInfo: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: DebugInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field StackEntries", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.StackEntries = append(m.StackEntries, string(dAtA[iNdEx:postIndex]))
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Detail = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *QuotaFailure) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: QuotaFailure: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: QuotaFailure: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Violations", wireType)
|
||
|
}
|
||
|
var msglen int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
msglen |= int(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if msglen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + msglen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Violations = append(m.Violations, &QuotaFailure_Violation{})
|
||
|
if err := m.Violations[len(m.Violations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *QuotaFailure_Violation) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: Violation: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: Violation: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Subject = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Description = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *ErrorInfo) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: ErrorInfo: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: ErrorInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Reason = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Domain = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 3:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
|
||
|
}
|
||
|
var msglen int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
msglen |= int(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if msglen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + msglen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
if m.Metadata == nil {
|
||
|
m.Metadata = make(map[string]string)
|
||
|
}
|
||
|
var mapkey string
|
||
|
var mapvalue string
|
||
|
for iNdEx < postIndex {
|
||
|
entryPreIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
if fieldNum == 1 {
|
||
|
var stringLenmapkey uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLenmapkey |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLenmapkey := int(stringLenmapkey)
|
||
|
if intStringLenmapkey < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postStringIndexmapkey := iNdEx + intStringLenmapkey
|
||
|
if postStringIndexmapkey < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postStringIndexmapkey > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
|
||
|
iNdEx = postStringIndexmapkey
|
||
|
} else if fieldNum == 2 {
|
||
|
var stringLenmapvalue uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLenmapvalue |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLenmapvalue := int(stringLenmapvalue)
|
||
|
if intStringLenmapvalue < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
|
||
|
if postStringIndexmapvalue < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postStringIndexmapvalue > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
|
||
|
iNdEx = postStringIndexmapvalue
|
||
|
} else {
|
||
|
iNdEx = entryPreIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > postIndex {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
m.Metadata[mapkey] = mapvalue
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *PreconditionFailure) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: PreconditionFailure: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: PreconditionFailure: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Violations", wireType)
|
||
|
}
|
||
|
var msglen int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
msglen |= int(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if msglen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + msglen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Violations = append(m.Violations, &PreconditionFailure_Violation{})
|
||
|
if err := m.Violations[len(m.Violations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *PreconditionFailure_Violation) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: Violation: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: Violation: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Type = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Subject = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 3:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Description = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *BadRequest) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: BadRequest: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: BadRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field FieldViolations", wireType)
|
||
|
}
|
||
|
var msglen int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
msglen |= int(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if msglen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + msglen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.FieldViolations = append(m.FieldViolations, &BadRequest_FieldViolation{})
|
||
|
if err := m.FieldViolations[len(m.FieldViolations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *BadRequest_FieldViolation) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: FieldViolation: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: FieldViolation: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Field = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Description = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *RequestInfo) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: RequestInfo: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: RequestInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.RequestId = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field ServingData", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.ServingData = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *ResourceInfo) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: ResourceInfo: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: ResourceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field ResourceType", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.ResourceType = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field ResourceName", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.ResourceName = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 3:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Owner = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 4:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Description = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *Help) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: Help: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: Help: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
|
||
|
}
|
||
|
var msglen int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
msglen |= int(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if msglen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + msglen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Links = append(m.Links, &Help_Link{})
|
||
|
if err := m.Links[len(m.Links)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *Help_Link) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: Link: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: Link: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Description = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Url = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func (m *LocalizedMessage) Unmarshal(dAtA []byte) error {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
for iNdEx < l {
|
||
|
preIndex := iNdEx
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
fieldNum := int32(wire >> 3)
|
||
|
wireType := int(wire & 0x7)
|
||
|
if wireType == 4 {
|
||
|
return fmt.Errorf("proto: LocalizedMessage: wiretype end group for non-group")
|
||
|
}
|
||
|
if fieldNum <= 0 {
|
||
|
return fmt.Errorf("proto: LocalizedMessage: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
|
}
|
||
|
switch fieldNum {
|
||
|
case 1:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Locale", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Locale = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
case 2:
|
||
|
if wireType != 2 {
|
||
|
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
|
||
|
}
|
||
|
var stringLen uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
stringLen |= uint64(b&0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
intStringLen := int(stringLen)
|
||
|
if intStringLen < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
postIndex := iNdEx + intStringLen
|
||
|
if postIndex < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if postIndex > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.Message = string(dAtA[iNdEx:postIndex])
|
||
|
iNdEx = postIndex
|
||
|
default:
|
||
|
iNdEx = preIndex
|
||
|
skippy, err := skipErrorDetails(dAtA[iNdEx:])
|
||
|
if err != nil {
|
||
|
return err
|
||
|
}
|
||
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||
|
return ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if (iNdEx + skippy) > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
||
|
iNdEx += skippy
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if iNdEx > l {
|
||
|
return io.ErrUnexpectedEOF
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
func skipErrorDetails(dAtA []byte) (n int, err error) {
|
||
|
l := len(dAtA)
|
||
|
iNdEx := 0
|
||
|
depth := 0
|
||
|
for iNdEx < l {
|
||
|
var wire uint64
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return 0, ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return 0, io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
wire |= (uint64(b) & 0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
wireType := int(wire & 0x7)
|
||
|
switch wireType {
|
||
|
case 0:
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return 0, ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return 0, io.ErrUnexpectedEOF
|
||
|
}
|
||
|
iNdEx++
|
||
|
if dAtA[iNdEx-1] < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
case 1:
|
||
|
iNdEx += 8
|
||
|
case 2:
|
||
|
var length int
|
||
|
for shift := uint(0); ; shift += 7 {
|
||
|
if shift >= 64 {
|
||
|
return 0, ErrIntOverflowErrorDetails
|
||
|
}
|
||
|
if iNdEx >= l {
|
||
|
return 0, io.ErrUnexpectedEOF
|
||
|
}
|
||
|
b := dAtA[iNdEx]
|
||
|
iNdEx++
|
||
|
length |= (int(b) & 0x7F) << shift
|
||
|
if b < 0x80 {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if length < 0 {
|
||
|
return 0, ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
iNdEx += length
|
||
|
case 3:
|
||
|
depth++
|
||
|
case 4:
|
||
|
if depth == 0 {
|
||
|
return 0, ErrUnexpectedEndOfGroupErrorDetails
|
||
|
}
|
||
|
depth--
|
||
|
case 5:
|
||
|
iNdEx += 4
|
||
|
default:
|
||
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
||
|
}
|
||
|
if iNdEx < 0 {
|
||
|
return 0, ErrInvalidLengthErrorDetails
|
||
|
}
|
||
|
if depth == 0 {
|
||
|
return iNdEx, nil
|
||
|
}
|
||
|
}
|
||
|
return 0, io.ErrUnexpectedEOF
|
||
|
}
|
||
|
|
||
|
var (
|
||
|
ErrInvalidLengthErrorDetails = fmt.Errorf("proto: negative length found during unmarshaling")
|
||
|
ErrIntOverflowErrorDetails = fmt.Errorf("proto: integer overflow")
|
||
|
ErrUnexpectedEndOfGroupErrorDetails = fmt.Errorf("proto: unexpected end of group")
|
||
|
)
|