1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: google/rpc/error_details.proto 3 4package rpc 5 6import ( 7 bytes "bytes" 8 fmt "fmt" 9 proto "github.com/gogo/protobuf/proto" 10 types "github.com/gogo/protobuf/types" 11 io "io" 12 math "math" 13 math_bits "math/bits" 14 reflect "reflect" 15 strings "strings" 16) 17 18// Reference imports to suppress errors if they are not otherwise used. 19var _ = proto.Marshal 20var _ = fmt.Errorf 21var _ = math.Inf 22 23// This is a compile-time assertion to ensure that this generated file 24// is compatible with the proto package it is being compiled against. 25// A compilation error at this line likely means your copy of the 26// proto package needs to be updated. 27const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 28 29// Describes when the clients can retry a failed request. Clients could ignore 30// the recommendation here or retry when this information is missing from error 31// responses. 32// 33// It's always recommended that clients should use exponential backoff when 34// retrying. 35// 36// Clients should wait until `retry_delay` amount of time has passed since 37// receiving the error response before retrying. If retrying requests also 38// fail, clients should use an exponential backoff scheme to gradually increase 39// the delay between retries based on `retry_delay`, until either a maximum 40// number of retires have been reached or a maximum retry delay cap has been 41// reached. 42type RetryInfo struct { 43 // Clients should wait at least this long between retrying the same request. 44 RetryDelay *types.Duration `protobuf:"bytes,1,opt,name=retry_delay,json=retryDelay,proto3" json:"retry_delay,omitempty"` 45 XXX_NoUnkeyedLiteral struct{} `json:"-"` 46 XXX_unrecognized []byte `json:"-"` 47 XXX_sizecache int32 `json:"-"` 48} 49 50func (m *RetryInfo) Reset() { *m = RetryInfo{} } 51func (*RetryInfo) ProtoMessage() {} 52func (*RetryInfo) Descriptor() ([]byte, []int) { 53 return fileDescriptor_851816e4d6b6361a, []int{0} 54} 55func (m *RetryInfo) XXX_Unmarshal(b []byte) error { 56 return m.Unmarshal(b) 57} 58func (m *RetryInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 59 if deterministic { 60 return xxx_messageInfo_RetryInfo.Marshal(b, m, deterministic) 61 } else { 62 b = b[:cap(b)] 63 n, err := m.MarshalToSizedBuffer(b) 64 if err != nil { 65 return nil, err 66 } 67 return b[:n], nil 68 } 69} 70func (m *RetryInfo) XXX_Merge(src proto.Message) { 71 xxx_messageInfo_RetryInfo.Merge(m, src) 72} 73func (m *RetryInfo) XXX_Size() int { 74 return m.Size() 75} 76func (m *RetryInfo) XXX_DiscardUnknown() { 77 xxx_messageInfo_RetryInfo.DiscardUnknown(m) 78} 79 80var xxx_messageInfo_RetryInfo proto.InternalMessageInfo 81 82func (m *RetryInfo) GetRetryDelay() *types.Duration { 83 if m != nil { 84 return m.RetryDelay 85 } 86 return nil 87} 88 89func (*RetryInfo) XXX_MessageName() string { 90 return "google.rpc.RetryInfo" 91} 92 93// Describes additional debugging info. 94type DebugInfo struct { 95 // The stack trace entries indicating where the error occurred. 96 StackEntries []string `protobuf:"bytes,1,rep,name=stack_entries,json=stackEntries,proto3" json:"stack_entries,omitempty"` 97 // Additional debugging information provided by the server. 98 Detail string `protobuf:"bytes,2,opt,name=detail,proto3" json:"detail,omitempty"` 99 XXX_NoUnkeyedLiteral struct{} `json:"-"` 100 XXX_unrecognized []byte `json:"-"` 101 XXX_sizecache int32 `json:"-"` 102} 103 104func (m *DebugInfo) Reset() { *m = DebugInfo{} } 105func (*DebugInfo) ProtoMessage() {} 106func (*DebugInfo) Descriptor() ([]byte, []int) { 107 return fileDescriptor_851816e4d6b6361a, []int{1} 108} 109func (m *DebugInfo) XXX_Unmarshal(b []byte) error { 110 return m.Unmarshal(b) 111} 112func (m *DebugInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 113 if deterministic { 114 return xxx_messageInfo_DebugInfo.Marshal(b, m, deterministic) 115 } else { 116 b = b[:cap(b)] 117 n, err := m.MarshalToSizedBuffer(b) 118 if err != nil { 119 return nil, err 120 } 121 return b[:n], nil 122 } 123} 124func (m *DebugInfo) XXX_Merge(src proto.Message) { 125 xxx_messageInfo_DebugInfo.Merge(m, src) 126} 127func (m *DebugInfo) XXX_Size() int { 128 return m.Size() 129} 130func (m *DebugInfo) XXX_DiscardUnknown() { 131 xxx_messageInfo_DebugInfo.DiscardUnknown(m) 132} 133 134var xxx_messageInfo_DebugInfo proto.InternalMessageInfo 135 136func (m *DebugInfo) GetStackEntries() []string { 137 if m != nil { 138 return m.StackEntries 139 } 140 return nil 141} 142 143func (m *DebugInfo) GetDetail() string { 144 if m != nil { 145 return m.Detail 146 } 147 return "" 148} 149 150func (*DebugInfo) XXX_MessageName() string { 151 return "google.rpc.DebugInfo" 152} 153 154// Describes how a quota check failed. 155// 156// For example if a daily limit was exceeded for the calling project, 157// a service could respond with a QuotaFailure detail containing the project 158// id and the description of the quota limit that was exceeded. If the 159// calling project hasn't enabled the service in the developer console, then 160// a service could respond with the project id and set `service_disabled` 161// to true. 162// 163// Also see RetryDetail and Help types for other details about handling a 164// quota failure. 165type QuotaFailure struct { 166 // Describes all quota violations. 167 Violations []*QuotaFailure_Violation `protobuf:"bytes,1,rep,name=violations,proto3" json:"violations,omitempty"` 168 XXX_NoUnkeyedLiteral struct{} `json:"-"` 169 XXX_unrecognized []byte `json:"-"` 170 XXX_sizecache int32 `json:"-"` 171} 172 173func (m *QuotaFailure) Reset() { *m = QuotaFailure{} } 174func (*QuotaFailure) ProtoMessage() {} 175func (*QuotaFailure) Descriptor() ([]byte, []int) { 176 return fileDescriptor_851816e4d6b6361a, []int{2} 177} 178func (m *QuotaFailure) XXX_Unmarshal(b []byte) error { 179 return m.Unmarshal(b) 180} 181func (m *QuotaFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 182 if deterministic { 183 return xxx_messageInfo_QuotaFailure.Marshal(b, m, deterministic) 184 } else { 185 b = b[:cap(b)] 186 n, err := m.MarshalToSizedBuffer(b) 187 if err != nil { 188 return nil, err 189 } 190 return b[:n], nil 191 } 192} 193func (m *QuotaFailure) XXX_Merge(src proto.Message) { 194 xxx_messageInfo_QuotaFailure.Merge(m, src) 195} 196func (m *QuotaFailure) XXX_Size() int { 197 return m.Size() 198} 199func (m *QuotaFailure) XXX_DiscardUnknown() { 200 xxx_messageInfo_QuotaFailure.DiscardUnknown(m) 201} 202 203var xxx_messageInfo_QuotaFailure proto.InternalMessageInfo 204 205func (m *QuotaFailure) GetViolations() []*QuotaFailure_Violation { 206 if m != nil { 207 return m.Violations 208 } 209 return nil 210} 211 212func (*QuotaFailure) XXX_MessageName() string { 213 return "google.rpc.QuotaFailure" 214} 215 216// A message type used to describe a single quota violation. For example, a 217// daily quota or a custom quota that was exceeded. 218type QuotaFailure_Violation struct { 219 // The subject on which the quota check failed. 220 // For example, "clientip:<ip address of client>" or "project:<Google 221 // developer project id>". 222 Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"` 223 // A description of how the quota check failed. Clients can use this 224 // description to find more about the quota configuration in the service's 225 // public documentation, or find the relevant quota limit to adjust through 226 // developer console. 227 // 228 // For example: "Service disabled" or "Daily Limit for read operations 229 // exceeded". 230 Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` 231 XXX_NoUnkeyedLiteral struct{} `json:"-"` 232 XXX_unrecognized []byte `json:"-"` 233 XXX_sizecache int32 `json:"-"` 234} 235 236func (m *QuotaFailure_Violation) Reset() { *m = QuotaFailure_Violation{} } 237func (*QuotaFailure_Violation) ProtoMessage() {} 238func (*QuotaFailure_Violation) Descriptor() ([]byte, []int) { 239 return fileDescriptor_851816e4d6b6361a, []int{2, 0} 240} 241func (m *QuotaFailure_Violation) XXX_Unmarshal(b []byte) error { 242 return m.Unmarshal(b) 243} 244func (m *QuotaFailure_Violation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 245 if deterministic { 246 return xxx_messageInfo_QuotaFailure_Violation.Marshal(b, m, deterministic) 247 } else { 248 b = b[:cap(b)] 249 n, err := m.MarshalToSizedBuffer(b) 250 if err != nil { 251 return nil, err 252 } 253 return b[:n], nil 254 } 255} 256func (m *QuotaFailure_Violation) XXX_Merge(src proto.Message) { 257 xxx_messageInfo_QuotaFailure_Violation.Merge(m, src) 258} 259func (m *QuotaFailure_Violation) XXX_Size() int { 260 return m.Size() 261} 262func (m *QuotaFailure_Violation) XXX_DiscardUnknown() { 263 xxx_messageInfo_QuotaFailure_Violation.DiscardUnknown(m) 264} 265 266var xxx_messageInfo_QuotaFailure_Violation proto.InternalMessageInfo 267 268func (m *QuotaFailure_Violation) GetSubject() string { 269 if m != nil { 270 return m.Subject 271 } 272 return "" 273} 274 275func (m *QuotaFailure_Violation) GetDescription() string { 276 if m != nil { 277 return m.Description 278 } 279 return "" 280} 281 282func (*QuotaFailure_Violation) XXX_MessageName() string { 283 return "google.rpc.QuotaFailure.Violation" 284} 285 286// Describes what preconditions have failed. 287// 288// For example, if an RPC failed because it required the Terms of Service to be 289// acknowledged, it could list the terms of service violation in the 290// PreconditionFailure message. 291type PreconditionFailure struct { 292 // Describes all precondition violations. 293 Violations []*PreconditionFailure_Violation `protobuf:"bytes,1,rep,name=violations,proto3" json:"violations,omitempty"` 294 XXX_NoUnkeyedLiteral struct{} `json:"-"` 295 XXX_unrecognized []byte `json:"-"` 296 XXX_sizecache int32 `json:"-"` 297} 298 299func (m *PreconditionFailure) Reset() { *m = PreconditionFailure{} } 300func (*PreconditionFailure) ProtoMessage() {} 301func (*PreconditionFailure) Descriptor() ([]byte, []int) { 302 return fileDescriptor_851816e4d6b6361a, []int{3} 303} 304func (m *PreconditionFailure) XXX_Unmarshal(b []byte) error { 305 return m.Unmarshal(b) 306} 307func (m *PreconditionFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 308 if deterministic { 309 return xxx_messageInfo_PreconditionFailure.Marshal(b, m, deterministic) 310 } else { 311 b = b[:cap(b)] 312 n, err := m.MarshalToSizedBuffer(b) 313 if err != nil { 314 return nil, err 315 } 316 return b[:n], nil 317 } 318} 319func (m *PreconditionFailure) XXX_Merge(src proto.Message) { 320 xxx_messageInfo_PreconditionFailure.Merge(m, src) 321} 322func (m *PreconditionFailure) XXX_Size() int { 323 return m.Size() 324} 325func (m *PreconditionFailure) XXX_DiscardUnknown() { 326 xxx_messageInfo_PreconditionFailure.DiscardUnknown(m) 327} 328 329var xxx_messageInfo_PreconditionFailure proto.InternalMessageInfo 330 331func (m *PreconditionFailure) GetViolations() []*PreconditionFailure_Violation { 332 if m != nil { 333 return m.Violations 334 } 335 return nil 336} 337 338func (*PreconditionFailure) XXX_MessageName() string { 339 return "google.rpc.PreconditionFailure" 340} 341 342// A message type used to describe a single precondition failure. 343type PreconditionFailure_Violation struct { 344 // The type of PreconditionFailure. We recommend using a service-specific 345 // enum type to define the supported precondition violation types. For 346 // example, "TOS" for "Terms of Service violation". 347 Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` 348 // The subject, relative to the type, that failed. 349 // For example, "google.com/cloud" relative to the "TOS" type would 350 // indicate which terms of service is being referenced. 351 Subject string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"` 352 // A description of how the precondition failed. Developers can use this 353 // description to understand how to fix the failure. 354 // 355 // For example: "Terms of service not accepted". 356 Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` 357 XXX_NoUnkeyedLiteral struct{} `json:"-"` 358 XXX_unrecognized []byte `json:"-"` 359 XXX_sizecache int32 `json:"-"` 360} 361 362func (m *PreconditionFailure_Violation) Reset() { *m = PreconditionFailure_Violation{} } 363func (*PreconditionFailure_Violation) ProtoMessage() {} 364func (*PreconditionFailure_Violation) Descriptor() ([]byte, []int) { 365 return fileDescriptor_851816e4d6b6361a, []int{3, 0} 366} 367func (m *PreconditionFailure_Violation) XXX_Unmarshal(b []byte) error { 368 return m.Unmarshal(b) 369} 370func (m *PreconditionFailure_Violation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 371 if deterministic { 372 return xxx_messageInfo_PreconditionFailure_Violation.Marshal(b, m, deterministic) 373 } else { 374 b = b[:cap(b)] 375 n, err := m.MarshalToSizedBuffer(b) 376 if err != nil { 377 return nil, err 378 } 379 return b[:n], nil 380 } 381} 382func (m *PreconditionFailure_Violation) XXX_Merge(src proto.Message) { 383 xxx_messageInfo_PreconditionFailure_Violation.Merge(m, src) 384} 385func (m *PreconditionFailure_Violation) XXX_Size() int { 386 return m.Size() 387} 388func (m *PreconditionFailure_Violation) XXX_DiscardUnknown() { 389 xxx_messageInfo_PreconditionFailure_Violation.DiscardUnknown(m) 390} 391 392var xxx_messageInfo_PreconditionFailure_Violation proto.InternalMessageInfo 393 394func (m *PreconditionFailure_Violation) GetType() string { 395 if m != nil { 396 return m.Type 397 } 398 return "" 399} 400 401func (m *PreconditionFailure_Violation) GetSubject() string { 402 if m != nil { 403 return m.Subject 404 } 405 return "" 406} 407 408func (m *PreconditionFailure_Violation) GetDescription() string { 409 if m != nil { 410 return m.Description 411 } 412 return "" 413} 414 415func (*PreconditionFailure_Violation) XXX_MessageName() string { 416 return "google.rpc.PreconditionFailure.Violation" 417} 418 419// Describes violations in a client request. This error type focuses on the 420// syntactic aspects of the request. 421type BadRequest struct { 422 // Describes all violations in a client request. 423 FieldViolations []*BadRequest_FieldViolation `protobuf:"bytes,1,rep,name=field_violations,json=fieldViolations,proto3" json:"field_violations,omitempty"` 424 XXX_NoUnkeyedLiteral struct{} `json:"-"` 425 XXX_unrecognized []byte `json:"-"` 426 XXX_sizecache int32 `json:"-"` 427} 428 429func (m *BadRequest) Reset() { *m = BadRequest{} } 430func (*BadRequest) ProtoMessage() {} 431func (*BadRequest) Descriptor() ([]byte, []int) { 432 return fileDescriptor_851816e4d6b6361a, []int{4} 433} 434func (m *BadRequest) XXX_Unmarshal(b []byte) error { 435 return m.Unmarshal(b) 436} 437func (m *BadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 438 if deterministic { 439 return xxx_messageInfo_BadRequest.Marshal(b, m, deterministic) 440 } else { 441 b = b[:cap(b)] 442 n, err := m.MarshalToSizedBuffer(b) 443 if err != nil { 444 return nil, err 445 } 446 return b[:n], nil 447 } 448} 449func (m *BadRequest) XXX_Merge(src proto.Message) { 450 xxx_messageInfo_BadRequest.Merge(m, src) 451} 452func (m *BadRequest) XXX_Size() int { 453 return m.Size() 454} 455func (m *BadRequest) XXX_DiscardUnknown() { 456 xxx_messageInfo_BadRequest.DiscardUnknown(m) 457} 458 459var xxx_messageInfo_BadRequest proto.InternalMessageInfo 460 461func (m *BadRequest) GetFieldViolations() []*BadRequest_FieldViolation { 462 if m != nil { 463 return m.FieldViolations 464 } 465 return nil 466} 467 468func (*BadRequest) XXX_MessageName() string { 469 return "google.rpc.BadRequest" 470} 471 472// A message type used to describe a single bad request field. 473type BadRequest_FieldViolation struct { 474 // A path leading to a field in the request body. The value will be a 475 // sequence of dot-separated identifiers that identify a protocol buffer 476 // field. E.g., "field_violations.field" would identify this field. 477 Field string `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"` 478 // A description of why the request element is bad. 479 Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` 480 XXX_NoUnkeyedLiteral struct{} `json:"-"` 481 XXX_unrecognized []byte `json:"-"` 482 XXX_sizecache int32 `json:"-"` 483} 484 485func (m *BadRequest_FieldViolation) Reset() { *m = BadRequest_FieldViolation{} } 486func (*BadRequest_FieldViolation) ProtoMessage() {} 487func (*BadRequest_FieldViolation) Descriptor() ([]byte, []int) { 488 return fileDescriptor_851816e4d6b6361a, []int{4, 0} 489} 490func (m *BadRequest_FieldViolation) XXX_Unmarshal(b []byte) error { 491 return m.Unmarshal(b) 492} 493func (m *BadRequest_FieldViolation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 494 if deterministic { 495 return xxx_messageInfo_BadRequest_FieldViolation.Marshal(b, m, deterministic) 496 } else { 497 b = b[:cap(b)] 498 n, err := m.MarshalToSizedBuffer(b) 499 if err != nil { 500 return nil, err 501 } 502 return b[:n], nil 503 } 504} 505func (m *BadRequest_FieldViolation) XXX_Merge(src proto.Message) { 506 xxx_messageInfo_BadRequest_FieldViolation.Merge(m, src) 507} 508func (m *BadRequest_FieldViolation) XXX_Size() int { 509 return m.Size() 510} 511func (m *BadRequest_FieldViolation) XXX_DiscardUnknown() { 512 xxx_messageInfo_BadRequest_FieldViolation.DiscardUnknown(m) 513} 514 515var xxx_messageInfo_BadRequest_FieldViolation proto.InternalMessageInfo 516 517func (m *BadRequest_FieldViolation) GetField() string { 518 if m != nil { 519 return m.Field 520 } 521 return "" 522} 523 524func (m *BadRequest_FieldViolation) GetDescription() string { 525 if m != nil { 526 return m.Description 527 } 528 return "" 529} 530 531func (*BadRequest_FieldViolation) XXX_MessageName() string { 532 return "google.rpc.BadRequest.FieldViolation" 533} 534 535// Contains metadata about the request that clients can attach when filing a bug 536// or providing other forms of feedback. 537type RequestInfo struct { 538 // An opaque string that should only be interpreted by the service generating 539 // it. For example, it can be used to identify requests in the service's logs. 540 RequestId string `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` 541 // Any data that was used to serve this request. For example, an encrypted 542 // stack trace that can be sent back to the service provider for debugging. 543 ServingData string `protobuf:"bytes,2,opt,name=serving_data,json=servingData,proto3" json:"serving_data,omitempty"` 544 XXX_NoUnkeyedLiteral struct{} `json:"-"` 545 XXX_unrecognized []byte `json:"-"` 546 XXX_sizecache int32 `json:"-"` 547} 548 549func (m *RequestInfo) Reset() { *m = RequestInfo{} } 550func (*RequestInfo) ProtoMessage() {} 551func (*RequestInfo) Descriptor() ([]byte, []int) { 552 return fileDescriptor_851816e4d6b6361a, []int{5} 553} 554func (m *RequestInfo) XXX_Unmarshal(b []byte) error { 555 return m.Unmarshal(b) 556} 557func (m *RequestInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 558 if deterministic { 559 return xxx_messageInfo_RequestInfo.Marshal(b, m, deterministic) 560 } else { 561 b = b[:cap(b)] 562 n, err := m.MarshalToSizedBuffer(b) 563 if err != nil { 564 return nil, err 565 } 566 return b[:n], nil 567 } 568} 569func (m *RequestInfo) XXX_Merge(src proto.Message) { 570 xxx_messageInfo_RequestInfo.Merge(m, src) 571} 572func (m *RequestInfo) XXX_Size() int { 573 return m.Size() 574} 575func (m *RequestInfo) XXX_DiscardUnknown() { 576 xxx_messageInfo_RequestInfo.DiscardUnknown(m) 577} 578 579var xxx_messageInfo_RequestInfo proto.InternalMessageInfo 580 581func (m *RequestInfo) GetRequestId() string { 582 if m != nil { 583 return m.RequestId 584 } 585 return "" 586} 587 588func (m *RequestInfo) GetServingData() string { 589 if m != nil { 590 return m.ServingData 591 } 592 return "" 593} 594 595func (*RequestInfo) XXX_MessageName() string { 596 return "google.rpc.RequestInfo" 597} 598 599// Describes the resource that is being accessed. 600type ResourceInfo struct { 601 // A name for the type of resource being accessed, e.g. "sql table", 602 // "cloud storage bucket", "file", "Google calendar"; or the type URL 603 // of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic". 604 ResourceType string `protobuf:"bytes,1,opt,name=resource_type,json=resourceType,proto3" json:"resource_type,omitempty"` 605 // The name of the resource being accessed. For example, a shared calendar 606 // name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current 607 // error is 608 // [google.rpc.Code.PERMISSION_DENIED][google.rpc.Code.PERMISSION_DENIED]. 609 ResourceName string `protobuf:"bytes,2,opt,name=resource_name,json=resourceName,proto3" json:"resource_name,omitempty"` 610 // The owner of the resource (optional). 611 // For example, "user:<owner email>" or "project:<Google developer project 612 // id>". 613 Owner string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"` 614 // Describes what error is encountered when accessing this resource. 615 // For example, updating a cloud project may require the `writer` permission 616 // on the developer console project. 617 Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` 618 XXX_NoUnkeyedLiteral struct{} `json:"-"` 619 XXX_unrecognized []byte `json:"-"` 620 XXX_sizecache int32 `json:"-"` 621} 622 623func (m *ResourceInfo) Reset() { *m = ResourceInfo{} } 624func (*ResourceInfo) ProtoMessage() {} 625func (*ResourceInfo) Descriptor() ([]byte, []int) { 626 return fileDescriptor_851816e4d6b6361a, []int{6} 627} 628func (m *ResourceInfo) XXX_Unmarshal(b []byte) error { 629 return m.Unmarshal(b) 630} 631func (m *ResourceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 632 if deterministic { 633 return xxx_messageInfo_ResourceInfo.Marshal(b, m, deterministic) 634 } else { 635 b = b[:cap(b)] 636 n, err := m.MarshalToSizedBuffer(b) 637 if err != nil { 638 return nil, err 639 } 640 return b[:n], nil 641 } 642} 643func (m *ResourceInfo) XXX_Merge(src proto.Message) { 644 xxx_messageInfo_ResourceInfo.Merge(m, src) 645} 646func (m *ResourceInfo) XXX_Size() int { 647 return m.Size() 648} 649func (m *ResourceInfo) XXX_DiscardUnknown() { 650 xxx_messageInfo_ResourceInfo.DiscardUnknown(m) 651} 652 653var xxx_messageInfo_ResourceInfo proto.InternalMessageInfo 654 655func (m *ResourceInfo) GetResourceType() string { 656 if m != nil { 657 return m.ResourceType 658 } 659 return "" 660} 661 662func (m *ResourceInfo) GetResourceName() string { 663 if m != nil { 664 return m.ResourceName 665 } 666 return "" 667} 668 669func (m *ResourceInfo) GetOwner() string { 670 if m != nil { 671 return m.Owner 672 } 673 return "" 674} 675 676func (m *ResourceInfo) GetDescription() string { 677 if m != nil { 678 return m.Description 679 } 680 return "" 681} 682 683func (*ResourceInfo) XXX_MessageName() string { 684 return "google.rpc.ResourceInfo" 685} 686 687// Provides links to documentation or for performing an out of band action. 688// 689// For example, if a quota check failed with an error indicating the calling 690// project hasn't enabled the accessed service, this can contain a URL pointing 691// directly to the right place in the developer console to flip the bit. 692type Help struct { 693 // URL(s) pointing to additional information on handling the current error. 694 Links []*Help_Link `protobuf:"bytes,1,rep,name=links,proto3" json:"links,omitempty"` 695 XXX_NoUnkeyedLiteral struct{} `json:"-"` 696 XXX_unrecognized []byte `json:"-"` 697 XXX_sizecache int32 `json:"-"` 698} 699 700func (m *Help) Reset() { *m = Help{} } 701func (*Help) ProtoMessage() {} 702func (*Help) Descriptor() ([]byte, []int) { 703 return fileDescriptor_851816e4d6b6361a, []int{7} 704} 705func (m *Help) XXX_Unmarshal(b []byte) error { 706 return m.Unmarshal(b) 707} 708func (m *Help) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 709 if deterministic { 710 return xxx_messageInfo_Help.Marshal(b, m, deterministic) 711 } else { 712 b = b[:cap(b)] 713 n, err := m.MarshalToSizedBuffer(b) 714 if err != nil { 715 return nil, err 716 } 717 return b[:n], nil 718 } 719} 720func (m *Help) XXX_Merge(src proto.Message) { 721 xxx_messageInfo_Help.Merge(m, src) 722} 723func (m *Help) XXX_Size() int { 724 return m.Size() 725} 726func (m *Help) XXX_DiscardUnknown() { 727 xxx_messageInfo_Help.DiscardUnknown(m) 728} 729 730var xxx_messageInfo_Help proto.InternalMessageInfo 731 732func (m *Help) GetLinks() []*Help_Link { 733 if m != nil { 734 return m.Links 735 } 736 return nil 737} 738 739func (*Help) XXX_MessageName() string { 740 return "google.rpc.Help" 741} 742 743// Describes a URL link. 744type Help_Link struct { 745 // Describes what the link offers. 746 Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"` 747 // The URL of the link. 748 Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` 749 XXX_NoUnkeyedLiteral struct{} `json:"-"` 750 XXX_unrecognized []byte `json:"-"` 751 XXX_sizecache int32 `json:"-"` 752} 753 754func (m *Help_Link) Reset() { *m = Help_Link{} } 755func (*Help_Link) ProtoMessage() {} 756func (*Help_Link) Descriptor() ([]byte, []int) { 757 return fileDescriptor_851816e4d6b6361a, []int{7, 0} 758} 759func (m *Help_Link) XXX_Unmarshal(b []byte) error { 760 return m.Unmarshal(b) 761} 762func (m *Help_Link) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 763 if deterministic { 764 return xxx_messageInfo_Help_Link.Marshal(b, m, deterministic) 765 } else { 766 b = b[:cap(b)] 767 n, err := m.MarshalToSizedBuffer(b) 768 if err != nil { 769 return nil, err 770 } 771 return b[:n], nil 772 } 773} 774func (m *Help_Link) XXX_Merge(src proto.Message) { 775 xxx_messageInfo_Help_Link.Merge(m, src) 776} 777func (m *Help_Link) XXX_Size() int { 778 return m.Size() 779} 780func (m *Help_Link) XXX_DiscardUnknown() { 781 xxx_messageInfo_Help_Link.DiscardUnknown(m) 782} 783 784var xxx_messageInfo_Help_Link proto.InternalMessageInfo 785 786func (m *Help_Link) GetDescription() string { 787 if m != nil { 788 return m.Description 789 } 790 return "" 791} 792 793func (m *Help_Link) GetUrl() string { 794 if m != nil { 795 return m.Url 796 } 797 return "" 798} 799 800func (*Help_Link) XXX_MessageName() string { 801 return "google.rpc.Help.Link" 802} 803 804// Provides a localized error message that is safe to return to the user 805// which can be attached to an RPC error. 806type LocalizedMessage struct { 807 // The locale used following the specification defined at 808 // http://www.rfc-editor.org/rfc/bcp/bcp47.txt. 809 // Examples are: "en-US", "fr-CH", "es-MX" 810 Locale string `protobuf:"bytes,1,opt,name=locale,proto3" json:"locale,omitempty"` 811 // The localized error message in the above locale. 812 Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` 813 XXX_NoUnkeyedLiteral struct{} `json:"-"` 814 XXX_unrecognized []byte `json:"-"` 815 XXX_sizecache int32 `json:"-"` 816} 817 818func (m *LocalizedMessage) Reset() { *m = LocalizedMessage{} } 819func (*LocalizedMessage) ProtoMessage() {} 820func (*LocalizedMessage) Descriptor() ([]byte, []int) { 821 return fileDescriptor_851816e4d6b6361a, []int{8} 822} 823func (m *LocalizedMessage) XXX_Unmarshal(b []byte) error { 824 return m.Unmarshal(b) 825} 826func (m *LocalizedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 827 if deterministic { 828 return xxx_messageInfo_LocalizedMessage.Marshal(b, m, deterministic) 829 } else { 830 b = b[:cap(b)] 831 n, err := m.MarshalToSizedBuffer(b) 832 if err != nil { 833 return nil, err 834 } 835 return b[:n], nil 836 } 837} 838func (m *LocalizedMessage) XXX_Merge(src proto.Message) { 839 xxx_messageInfo_LocalizedMessage.Merge(m, src) 840} 841func (m *LocalizedMessage) XXX_Size() int { 842 return m.Size() 843} 844func (m *LocalizedMessage) XXX_DiscardUnknown() { 845 xxx_messageInfo_LocalizedMessage.DiscardUnknown(m) 846} 847 848var xxx_messageInfo_LocalizedMessage proto.InternalMessageInfo 849 850func (m *LocalizedMessage) GetLocale() string { 851 if m != nil { 852 return m.Locale 853 } 854 return "" 855} 856 857func (m *LocalizedMessage) GetMessage() string { 858 if m != nil { 859 return m.Message 860 } 861 return "" 862} 863 864func (*LocalizedMessage) XXX_MessageName() string { 865 return "google.rpc.LocalizedMessage" 866} 867func init() { 868 proto.RegisterType((*RetryInfo)(nil), "google.rpc.RetryInfo") 869 proto.RegisterType((*DebugInfo)(nil), "google.rpc.DebugInfo") 870 proto.RegisterType((*QuotaFailure)(nil), "google.rpc.QuotaFailure") 871 proto.RegisterType((*QuotaFailure_Violation)(nil), "google.rpc.QuotaFailure.Violation") 872 proto.RegisterType((*PreconditionFailure)(nil), "google.rpc.PreconditionFailure") 873 proto.RegisterType((*PreconditionFailure_Violation)(nil), "google.rpc.PreconditionFailure.Violation") 874 proto.RegisterType((*BadRequest)(nil), "google.rpc.BadRequest") 875 proto.RegisterType((*BadRequest_FieldViolation)(nil), "google.rpc.BadRequest.FieldViolation") 876 proto.RegisterType((*RequestInfo)(nil), "google.rpc.RequestInfo") 877 proto.RegisterType((*ResourceInfo)(nil), "google.rpc.ResourceInfo") 878 proto.RegisterType((*Help)(nil), "google.rpc.Help") 879 proto.RegisterType((*Help_Link)(nil), "google.rpc.Help.Link") 880 proto.RegisterType((*LocalizedMessage)(nil), "google.rpc.LocalizedMessage") 881} 882 883func init() { proto.RegisterFile("google/rpc/error_details.proto", fileDescriptor_851816e4d6b6361a) } 884 885var fileDescriptor_851816e4d6b6361a = []byte{ 886 // 624 bytes of a gzipped FileDescriptorProto 887 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xbf, 0x6f, 0xd3, 0x40, 888 0x18, 0xed, 0x35, 0x69, 0x91, 0xbf, 0x84, 0x52, 0xcc, 0x0f, 0x85, 0x48, 0x9c, 0x82, 0x11, 0x52, 889 0x11, 0x92, 0x2b, 0x95, 0xad, 0x63, 0x48, 0x7f, 0x49, 0x05, 0x82, 0x85, 0x18, 0x60, 0xb0, 0x2e, 890 0xf6, 0x97, 0xe8, 0xa8, 0xe3, 0x33, 0x67, 0xbb, 0xa8, 0x4c, 0xfc, 0x09, 0xec, 0x6c, 0x4c, 0xfd, 891 0x27, 0xd8, 0x3b, 0x76, 0x64, 0x24, 0xe9, 0xc2, 0xd8, 0x91, 0x11, 0x9d, 0x7d, 0xd7, 0xba, 0x4d, 892 0x41, 0x6c, 0x7e, 0xef, 0xde, 0x3d, 0xbf, 0xf7, 0xe9, 0xee, 0x80, 0x8e, 0x84, 0x18, 0x45, 0xb8, 893 0x2a, 0x93, 0x60, 0x15, 0xa5, 0x14, 0xd2, 0x0f, 0x31, 0x63, 0x3c, 0x4a, 0xdd, 0x44, 0x8a, 0x4c, 894 0xd8, 0x50, 0xae, 0xbb, 0x32, 0x09, 0xda, 0x46, 0x5b, 0xac, 0x0c, 0xf2, 0xe1, 0x6a, 0x98, 0x4b, 895 0x96, 0x71, 0x11, 0x97, 0x5a, 0x67, 0x0b, 0x2c, 0x0f, 0x33, 0x79, 0xb0, 0x13, 0x0f, 0x85, 0xbd, 896 0x0e, 0x0d, 0xa9, 0x80, 0x1f, 0x62, 0xc4, 0x0e, 0x5a, 0xa4, 0x43, 0x56, 0x1a, 0x6b, 0xf7, 0x5c, 897 0x6d, 0x67, 0x2c, 0xdc, 0x9e, 0xb6, 0xf0, 0xa0, 0x50, 0xf7, 0x94, 0xd8, 0xd9, 0x06, 0xab, 0x87, 898 0x83, 0x7c, 0x54, 0x18, 0x3d, 0x84, 0xeb, 0x69, 0xc6, 0x82, 0x3d, 0x1f, 0xe3, 0x4c, 0x72, 0x4c, 899 0x5b, 0xa4, 0x53, 0x5b, 0xb1, 0xbc, 0x66, 0x41, 0x6e, 0x94, 0x9c, 0x7d, 0x17, 0x16, 0xcb, 0xdc, 900 0xad, 0xf9, 0x0e, 0x59, 0xb1, 0x3c, 0x8d, 0x9c, 0xaf, 0x04, 0x9a, 0xaf, 0x72, 0x91, 0xb1, 0x4d, 901 0xc6, 0xa3, 0x5c, 0xa2, 0xdd, 0x05, 0xd8, 0xe7, 0x22, 0x2a, 0xfe, 0x59, 0x5a, 0x35, 0xd6, 0x1c, 902 0xf7, 0xbc, 0xa4, 0x5b, 0x55, 0xbb, 0x6f, 0x8c, 0xd4, 0xab, 0xec, 0x6a, 0x6f, 0x81, 0x75, 0xb6, 903 0x60, 0xb7, 0xe0, 0x5a, 0x9a, 0x0f, 0xde, 0x63, 0x90, 0x15, 0x1d, 0x2d, 0xcf, 0x40, 0xbb, 0x03, 904 0x8d, 0x10, 0xd3, 0x40, 0xf2, 0x44, 0x09, 0x75, 0xb0, 0x2a, 0xe5, 0x7c, 0x27, 0x70, 0xab, 0x2f, 905 0x31, 0x10, 0x71, 0xc8, 0x15, 0x61, 0x42, 0xee, 0x5c, 0x11, 0xf2, 0x71, 0x35, 0xe4, 0x15, 0x9b, 906 0xfe, 0x92, 0xf5, 0x5d, 0x35, 0xab, 0x0d, 0xf5, 0xec, 0x20, 0x41, 0x1d, 0xb4, 0xf8, 0xae, 0xe6, 907 0x9f, 0xff, 0x67, 0xfe, 0xda, 0x6c, 0xfe, 0x43, 0x02, 0xd0, 0x65, 0xa1, 0x87, 0x1f, 0x72, 0x4c, 908 0x33, 0xbb, 0x0f, 0xcb, 0x43, 0x8e, 0x51, 0xe8, 0xcf, 0x84, 0x7f, 0x54, 0x0d, 0x7f, 0xbe, 0xc3, 909 0xdd, 0x54, 0xf2, 0xf3, 0xe0, 0x37, 0x86, 0x17, 0x70, 0xda, 0xde, 0x86, 0xa5, 0x8b, 0x12, 0xfb, 910 0x36, 0x2c, 0x14, 0x22, 0xdd, 0xa1, 0x04, 0xff, 0x31, 0xea, 0x97, 0xd0, 0xd0, 0x3f, 0x2d, 0x0e, 911 0xd5, 0x7d, 0x00, 0x59, 0x42, 0x9f, 0x1b, 0x2f, 0x4b, 0x33, 0x3b, 0xa1, 0xfd, 0x00, 0x9a, 0x29, 912 0xca, 0x7d, 0x1e, 0x8f, 0xfc, 0x90, 0x65, 0xcc, 0x18, 0x6a, 0xae, 0xc7, 0x32, 0xe6, 0x7c, 0x21, 913 0xd0, 0xf4, 0x30, 0x15, 0xb9, 0x0c, 0xd0, 0x9c, 0x53, 0xa9, 0xb1, 0x5f, 0x99, 0x72, 0xd3, 0x90, 914 0xaf, 0xd5, 0xb4, 0xab, 0xa2, 0x98, 0x8d, 0x51, 0x3b, 0x9f, 0x89, 0x5e, 0xb0, 0x31, 0xaa, 0x8e, 915 0xe2, 0x63, 0x8c, 0x52, 0x8f, 0xbc, 0x04, 0x97, 0x3b, 0xd6, 0x67, 0x3b, 0x0a, 0xa8, 0x6f, 0x63, 916 0x94, 0xd8, 0x4f, 0x60, 0x21, 0xe2, 0xf1, 0x9e, 0x19, 0xfe, 0x9d, 0xea, 0xf0, 0x95, 0xc0, 0xdd, 917 0xe5, 0xf1, 0x9e, 0x57, 0x6a, 0xda, 0xeb, 0x50, 0x57, 0xf0, 0xb2, 0x3d, 0x99, 0xb1, 0xb7, 0x97, 918 0xa1, 0x96, 0x4b, 0x73, 0xc1, 0xd4, 0xa7, 0xd3, 0x83, 0xe5, 0x5d, 0x11, 0xb0, 0x88, 0x7f, 0xc2, 919 0xf0, 0x39, 0xa6, 0x29, 0x1b, 0xa1, 0xba, 0x89, 0x91, 0xe2, 0x4c, 0x7f, 0x8d, 0xd4, 0x39, 0x1b, 920 0x97, 0x12, 0x73, 0xce, 0x34, 0xec, 0x86, 0xc7, 0x13, 0x3a, 0xf7, 0x63, 0x42, 0xe7, 0x4e, 0x27, 921 0x94, 0xfc, 0x9e, 0x50, 0xf2, 0x79, 0x4a, 0xc9, 0xe1, 0x94, 0x92, 0xa3, 0x29, 0x25, 0xc7, 0x53, 922 0x4a, 0x7e, 0x4e, 0x29, 0xf9, 0x35, 0xa5, 0x73, 0xa7, 0x8a, 0x3f, 0xa1, 0xe4, 0xe8, 0x84, 0x12, 923 0x58, 0x0a, 0xc4, 0xb8, 0x52, 0xac, 0x7b, 0x73, 0x43, 0xbd, 0x5e, 0xbd, 0xf2, 0xf1, 0xea, 0xab, 924 0xe7, 0xa5, 0x4f, 0xde, 0xd6, 0x64, 0x12, 0x7c, 0x9b, 0xaf, 0x79, 0xfd, 0x67, 0x83, 0xc5, 0xe2, 925 0xc9, 0x79, 0xfa, 0x27, 0x00, 0x00, 0xff, 0xff, 0x63, 0xe4, 0x76, 0x26, 0xf1, 0x04, 0x00, 0x00, 926} 927 928func (this *RetryInfo) Compare(that interface{}) int { 929 if that == nil { 930 if this == nil { 931 return 0 932 } 933 return 1 934 } 935 936 that1, ok := that.(*RetryInfo) 937 if !ok { 938 that2, ok := that.(RetryInfo) 939 if ok { 940 that1 = &that2 941 } else { 942 return 1 943 } 944 } 945 if that1 == nil { 946 if this == nil { 947 return 0 948 } 949 return 1 950 } else if this == nil { 951 return -1 952 } 953 if c := this.RetryDelay.Compare(that1.RetryDelay); c != 0 { 954 return c 955 } 956 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 957 return c 958 } 959 return 0 960} 961func (this *DebugInfo) Compare(that interface{}) int { 962 if that == nil { 963 if this == nil { 964 return 0 965 } 966 return 1 967 } 968 969 that1, ok := that.(*DebugInfo) 970 if !ok { 971 that2, ok := that.(DebugInfo) 972 if ok { 973 that1 = &that2 974 } else { 975 return 1 976 } 977 } 978 if that1 == nil { 979 if this == nil { 980 return 0 981 } 982 return 1 983 } else if this == nil { 984 return -1 985 } 986 if len(this.StackEntries) != len(that1.StackEntries) { 987 if len(this.StackEntries) < len(that1.StackEntries) { 988 return -1 989 } 990 return 1 991 } 992 for i := range this.StackEntries { 993 if this.StackEntries[i] != that1.StackEntries[i] { 994 if this.StackEntries[i] < that1.StackEntries[i] { 995 return -1 996 } 997 return 1 998 } 999 } 1000 if this.Detail != that1.Detail { 1001 if this.Detail < that1.Detail { 1002 return -1 1003 } 1004 return 1 1005 } 1006 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1007 return c 1008 } 1009 return 0 1010} 1011func (this *QuotaFailure) Compare(that interface{}) int { 1012 if that == nil { 1013 if this == nil { 1014 return 0 1015 } 1016 return 1 1017 } 1018 1019 that1, ok := that.(*QuotaFailure) 1020 if !ok { 1021 that2, ok := that.(QuotaFailure) 1022 if ok { 1023 that1 = &that2 1024 } else { 1025 return 1 1026 } 1027 } 1028 if that1 == nil { 1029 if this == nil { 1030 return 0 1031 } 1032 return 1 1033 } else if this == nil { 1034 return -1 1035 } 1036 if len(this.Violations) != len(that1.Violations) { 1037 if len(this.Violations) < len(that1.Violations) { 1038 return -1 1039 } 1040 return 1 1041 } 1042 for i := range this.Violations { 1043 if c := this.Violations[i].Compare(that1.Violations[i]); c != 0 { 1044 return c 1045 } 1046 } 1047 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1048 return c 1049 } 1050 return 0 1051} 1052func (this *QuotaFailure_Violation) Compare(that interface{}) int { 1053 if that == nil { 1054 if this == nil { 1055 return 0 1056 } 1057 return 1 1058 } 1059 1060 that1, ok := that.(*QuotaFailure_Violation) 1061 if !ok { 1062 that2, ok := that.(QuotaFailure_Violation) 1063 if ok { 1064 that1 = &that2 1065 } else { 1066 return 1 1067 } 1068 } 1069 if that1 == nil { 1070 if this == nil { 1071 return 0 1072 } 1073 return 1 1074 } else if this == nil { 1075 return -1 1076 } 1077 if this.Subject != that1.Subject { 1078 if this.Subject < that1.Subject { 1079 return -1 1080 } 1081 return 1 1082 } 1083 if this.Description != that1.Description { 1084 if this.Description < that1.Description { 1085 return -1 1086 } 1087 return 1 1088 } 1089 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1090 return c 1091 } 1092 return 0 1093} 1094func (this *PreconditionFailure) Compare(that interface{}) int { 1095 if that == nil { 1096 if this == nil { 1097 return 0 1098 } 1099 return 1 1100 } 1101 1102 that1, ok := that.(*PreconditionFailure) 1103 if !ok { 1104 that2, ok := that.(PreconditionFailure) 1105 if ok { 1106 that1 = &that2 1107 } else { 1108 return 1 1109 } 1110 } 1111 if that1 == nil { 1112 if this == nil { 1113 return 0 1114 } 1115 return 1 1116 } else if this == nil { 1117 return -1 1118 } 1119 if len(this.Violations) != len(that1.Violations) { 1120 if len(this.Violations) < len(that1.Violations) { 1121 return -1 1122 } 1123 return 1 1124 } 1125 for i := range this.Violations { 1126 if c := this.Violations[i].Compare(that1.Violations[i]); c != 0 { 1127 return c 1128 } 1129 } 1130 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1131 return c 1132 } 1133 return 0 1134} 1135func (this *PreconditionFailure_Violation) Compare(that interface{}) int { 1136 if that == nil { 1137 if this == nil { 1138 return 0 1139 } 1140 return 1 1141 } 1142 1143 that1, ok := that.(*PreconditionFailure_Violation) 1144 if !ok { 1145 that2, ok := that.(PreconditionFailure_Violation) 1146 if ok { 1147 that1 = &that2 1148 } else { 1149 return 1 1150 } 1151 } 1152 if that1 == nil { 1153 if this == nil { 1154 return 0 1155 } 1156 return 1 1157 } else if this == nil { 1158 return -1 1159 } 1160 if this.Type != that1.Type { 1161 if this.Type < that1.Type { 1162 return -1 1163 } 1164 return 1 1165 } 1166 if this.Subject != that1.Subject { 1167 if this.Subject < that1.Subject { 1168 return -1 1169 } 1170 return 1 1171 } 1172 if this.Description != that1.Description { 1173 if this.Description < that1.Description { 1174 return -1 1175 } 1176 return 1 1177 } 1178 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1179 return c 1180 } 1181 return 0 1182} 1183func (this *BadRequest) Compare(that interface{}) int { 1184 if that == nil { 1185 if this == nil { 1186 return 0 1187 } 1188 return 1 1189 } 1190 1191 that1, ok := that.(*BadRequest) 1192 if !ok { 1193 that2, ok := that.(BadRequest) 1194 if ok { 1195 that1 = &that2 1196 } else { 1197 return 1 1198 } 1199 } 1200 if that1 == nil { 1201 if this == nil { 1202 return 0 1203 } 1204 return 1 1205 } else if this == nil { 1206 return -1 1207 } 1208 if len(this.FieldViolations) != len(that1.FieldViolations) { 1209 if len(this.FieldViolations) < len(that1.FieldViolations) { 1210 return -1 1211 } 1212 return 1 1213 } 1214 for i := range this.FieldViolations { 1215 if c := this.FieldViolations[i].Compare(that1.FieldViolations[i]); c != 0 { 1216 return c 1217 } 1218 } 1219 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1220 return c 1221 } 1222 return 0 1223} 1224func (this *BadRequest_FieldViolation) Compare(that interface{}) int { 1225 if that == nil { 1226 if this == nil { 1227 return 0 1228 } 1229 return 1 1230 } 1231 1232 that1, ok := that.(*BadRequest_FieldViolation) 1233 if !ok { 1234 that2, ok := that.(BadRequest_FieldViolation) 1235 if ok { 1236 that1 = &that2 1237 } else { 1238 return 1 1239 } 1240 } 1241 if that1 == nil { 1242 if this == nil { 1243 return 0 1244 } 1245 return 1 1246 } else if this == nil { 1247 return -1 1248 } 1249 if this.Field != that1.Field { 1250 if this.Field < that1.Field { 1251 return -1 1252 } 1253 return 1 1254 } 1255 if this.Description != that1.Description { 1256 if this.Description < that1.Description { 1257 return -1 1258 } 1259 return 1 1260 } 1261 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1262 return c 1263 } 1264 return 0 1265} 1266func (this *RequestInfo) Compare(that interface{}) int { 1267 if that == nil { 1268 if this == nil { 1269 return 0 1270 } 1271 return 1 1272 } 1273 1274 that1, ok := that.(*RequestInfo) 1275 if !ok { 1276 that2, ok := that.(RequestInfo) 1277 if ok { 1278 that1 = &that2 1279 } else { 1280 return 1 1281 } 1282 } 1283 if that1 == nil { 1284 if this == nil { 1285 return 0 1286 } 1287 return 1 1288 } else if this == nil { 1289 return -1 1290 } 1291 if this.RequestId != that1.RequestId { 1292 if this.RequestId < that1.RequestId { 1293 return -1 1294 } 1295 return 1 1296 } 1297 if this.ServingData != that1.ServingData { 1298 if this.ServingData < that1.ServingData { 1299 return -1 1300 } 1301 return 1 1302 } 1303 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1304 return c 1305 } 1306 return 0 1307} 1308func (this *ResourceInfo) Compare(that interface{}) int { 1309 if that == nil { 1310 if this == nil { 1311 return 0 1312 } 1313 return 1 1314 } 1315 1316 that1, ok := that.(*ResourceInfo) 1317 if !ok { 1318 that2, ok := that.(ResourceInfo) 1319 if ok { 1320 that1 = &that2 1321 } else { 1322 return 1 1323 } 1324 } 1325 if that1 == nil { 1326 if this == nil { 1327 return 0 1328 } 1329 return 1 1330 } else if this == nil { 1331 return -1 1332 } 1333 if this.ResourceType != that1.ResourceType { 1334 if this.ResourceType < that1.ResourceType { 1335 return -1 1336 } 1337 return 1 1338 } 1339 if this.ResourceName != that1.ResourceName { 1340 if this.ResourceName < that1.ResourceName { 1341 return -1 1342 } 1343 return 1 1344 } 1345 if this.Owner != that1.Owner { 1346 if this.Owner < that1.Owner { 1347 return -1 1348 } 1349 return 1 1350 } 1351 if this.Description != that1.Description { 1352 if this.Description < that1.Description { 1353 return -1 1354 } 1355 return 1 1356 } 1357 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1358 return c 1359 } 1360 return 0 1361} 1362func (this *Help) Compare(that interface{}) int { 1363 if that == nil { 1364 if this == nil { 1365 return 0 1366 } 1367 return 1 1368 } 1369 1370 that1, ok := that.(*Help) 1371 if !ok { 1372 that2, ok := that.(Help) 1373 if ok { 1374 that1 = &that2 1375 } else { 1376 return 1 1377 } 1378 } 1379 if that1 == nil { 1380 if this == nil { 1381 return 0 1382 } 1383 return 1 1384 } else if this == nil { 1385 return -1 1386 } 1387 if len(this.Links) != len(that1.Links) { 1388 if len(this.Links) < len(that1.Links) { 1389 return -1 1390 } 1391 return 1 1392 } 1393 for i := range this.Links { 1394 if c := this.Links[i].Compare(that1.Links[i]); c != 0 { 1395 return c 1396 } 1397 } 1398 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1399 return c 1400 } 1401 return 0 1402} 1403func (this *Help_Link) Compare(that interface{}) int { 1404 if that == nil { 1405 if this == nil { 1406 return 0 1407 } 1408 return 1 1409 } 1410 1411 that1, ok := that.(*Help_Link) 1412 if !ok { 1413 that2, ok := that.(Help_Link) 1414 if ok { 1415 that1 = &that2 1416 } else { 1417 return 1 1418 } 1419 } 1420 if that1 == nil { 1421 if this == nil { 1422 return 0 1423 } 1424 return 1 1425 } else if this == nil { 1426 return -1 1427 } 1428 if this.Description != that1.Description { 1429 if this.Description < that1.Description { 1430 return -1 1431 } 1432 return 1 1433 } 1434 if this.Url != that1.Url { 1435 if this.Url < that1.Url { 1436 return -1 1437 } 1438 return 1 1439 } 1440 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1441 return c 1442 } 1443 return 0 1444} 1445func (this *LocalizedMessage) Compare(that interface{}) int { 1446 if that == nil { 1447 if this == nil { 1448 return 0 1449 } 1450 return 1 1451 } 1452 1453 that1, ok := that.(*LocalizedMessage) 1454 if !ok { 1455 that2, ok := that.(LocalizedMessage) 1456 if ok { 1457 that1 = &that2 1458 } else { 1459 return 1 1460 } 1461 } 1462 if that1 == nil { 1463 if this == nil { 1464 return 0 1465 } 1466 return 1 1467 } else if this == nil { 1468 return -1 1469 } 1470 if this.Locale != that1.Locale { 1471 if this.Locale < that1.Locale { 1472 return -1 1473 } 1474 return 1 1475 } 1476 if this.Message != that1.Message { 1477 if this.Message < that1.Message { 1478 return -1 1479 } 1480 return 1 1481 } 1482 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 1483 return c 1484 } 1485 return 0 1486} 1487func (this *RetryInfo) Equal(that interface{}) bool { 1488 if that == nil { 1489 return this == nil 1490 } 1491 1492 that1, ok := that.(*RetryInfo) 1493 if !ok { 1494 that2, ok := that.(RetryInfo) 1495 if ok { 1496 that1 = &that2 1497 } else { 1498 return false 1499 } 1500 } 1501 if that1 == nil { 1502 return this == nil 1503 } else if this == nil { 1504 return false 1505 } 1506 if !this.RetryDelay.Equal(that1.RetryDelay) { 1507 return false 1508 } 1509 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1510 return false 1511 } 1512 return true 1513} 1514func (this *DebugInfo) Equal(that interface{}) bool { 1515 if that == nil { 1516 return this == nil 1517 } 1518 1519 that1, ok := that.(*DebugInfo) 1520 if !ok { 1521 that2, ok := that.(DebugInfo) 1522 if ok { 1523 that1 = &that2 1524 } else { 1525 return false 1526 } 1527 } 1528 if that1 == nil { 1529 return this == nil 1530 } else if this == nil { 1531 return false 1532 } 1533 if len(this.StackEntries) != len(that1.StackEntries) { 1534 return false 1535 } 1536 for i := range this.StackEntries { 1537 if this.StackEntries[i] != that1.StackEntries[i] { 1538 return false 1539 } 1540 } 1541 if this.Detail != that1.Detail { 1542 return false 1543 } 1544 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1545 return false 1546 } 1547 return true 1548} 1549func (this *QuotaFailure) Equal(that interface{}) bool { 1550 if that == nil { 1551 return this == nil 1552 } 1553 1554 that1, ok := that.(*QuotaFailure) 1555 if !ok { 1556 that2, ok := that.(QuotaFailure) 1557 if ok { 1558 that1 = &that2 1559 } else { 1560 return false 1561 } 1562 } 1563 if that1 == nil { 1564 return this == nil 1565 } else if this == nil { 1566 return false 1567 } 1568 if len(this.Violations) != len(that1.Violations) { 1569 return false 1570 } 1571 for i := range this.Violations { 1572 if !this.Violations[i].Equal(that1.Violations[i]) { 1573 return false 1574 } 1575 } 1576 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1577 return false 1578 } 1579 return true 1580} 1581func (this *QuotaFailure_Violation) Equal(that interface{}) bool { 1582 if that == nil { 1583 return this == nil 1584 } 1585 1586 that1, ok := that.(*QuotaFailure_Violation) 1587 if !ok { 1588 that2, ok := that.(QuotaFailure_Violation) 1589 if ok { 1590 that1 = &that2 1591 } else { 1592 return false 1593 } 1594 } 1595 if that1 == nil { 1596 return this == nil 1597 } else if this == nil { 1598 return false 1599 } 1600 if this.Subject != that1.Subject { 1601 return false 1602 } 1603 if this.Description != that1.Description { 1604 return false 1605 } 1606 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1607 return false 1608 } 1609 return true 1610} 1611func (this *PreconditionFailure) Equal(that interface{}) bool { 1612 if that == nil { 1613 return this == nil 1614 } 1615 1616 that1, ok := that.(*PreconditionFailure) 1617 if !ok { 1618 that2, ok := that.(PreconditionFailure) 1619 if ok { 1620 that1 = &that2 1621 } else { 1622 return false 1623 } 1624 } 1625 if that1 == nil { 1626 return this == nil 1627 } else if this == nil { 1628 return false 1629 } 1630 if len(this.Violations) != len(that1.Violations) { 1631 return false 1632 } 1633 for i := range this.Violations { 1634 if !this.Violations[i].Equal(that1.Violations[i]) { 1635 return false 1636 } 1637 } 1638 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1639 return false 1640 } 1641 return true 1642} 1643func (this *PreconditionFailure_Violation) Equal(that interface{}) bool { 1644 if that == nil { 1645 return this == nil 1646 } 1647 1648 that1, ok := that.(*PreconditionFailure_Violation) 1649 if !ok { 1650 that2, ok := that.(PreconditionFailure_Violation) 1651 if ok { 1652 that1 = &that2 1653 } else { 1654 return false 1655 } 1656 } 1657 if that1 == nil { 1658 return this == nil 1659 } else if this == nil { 1660 return false 1661 } 1662 if this.Type != that1.Type { 1663 return false 1664 } 1665 if this.Subject != that1.Subject { 1666 return false 1667 } 1668 if this.Description != that1.Description { 1669 return false 1670 } 1671 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1672 return false 1673 } 1674 return true 1675} 1676func (this *BadRequest) Equal(that interface{}) bool { 1677 if that == nil { 1678 return this == nil 1679 } 1680 1681 that1, ok := that.(*BadRequest) 1682 if !ok { 1683 that2, ok := that.(BadRequest) 1684 if ok { 1685 that1 = &that2 1686 } else { 1687 return false 1688 } 1689 } 1690 if that1 == nil { 1691 return this == nil 1692 } else if this == nil { 1693 return false 1694 } 1695 if len(this.FieldViolations) != len(that1.FieldViolations) { 1696 return false 1697 } 1698 for i := range this.FieldViolations { 1699 if !this.FieldViolations[i].Equal(that1.FieldViolations[i]) { 1700 return false 1701 } 1702 } 1703 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1704 return false 1705 } 1706 return true 1707} 1708func (this *BadRequest_FieldViolation) Equal(that interface{}) bool { 1709 if that == nil { 1710 return this == nil 1711 } 1712 1713 that1, ok := that.(*BadRequest_FieldViolation) 1714 if !ok { 1715 that2, ok := that.(BadRequest_FieldViolation) 1716 if ok { 1717 that1 = &that2 1718 } else { 1719 return false 1720 } 1721 } 1722 if that1 == nil { 1723 return this == nil 1724 } else if this == nil { 1725 return false 1726 } 1727 if this.Field != that1.Field { 1728 return false 1729 } 1730 if this.Description != that1.Description { 1731 return false 1732 } 1733 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1734 return false 1735 } 1736 return true 1737} 1738func (this *RequestInfo) Equal(that interface{}) bool { 1739 if that == nil { 1740 return this == nil 1741 } 1742 1743 that1, ok := that.(*RequestInfo) 1744 if !ok { 1745 that2, ok := that.(RequestInfo) 1746 if ok { 1747 that1 = &that2 1748 } else { 1749 return false 1750 } 1751 } 1752 if that1 == nil { 1753 return this == nil 1754 } else if this == nil { 1755 return false 1756 } 1757 if this.RequestId != that1.RequestId { 1758 return false 1759 } 1760 if this.ServingData != that1.ServingData { 1761 return false 1762 } 1763 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1764 return false 1765 } 1766 return true 1767} 1768func (this *ResourceInfo) Equal(that interface{}) bool { 1769 if that == nil { 1770 return this == nil 1771 } 1772 1773 that1, ok := that.(*ResourceInfo) 1774 if !ok { 1775 that2, ok := that.(ResourceInfo) 1776 if ok { 1777 that1 = &that2 1778 } else { 1779 return false 1780 } 1781 } 1782 if that1 == nil { 1783 return this == nil 1784 } else if this == nil { 1785 return false 1786 } 1787 if this.ResourceType != that1.ResourceType { 1788 return false 1789 } 1790 if this.ResourceName != that1.ResourceName { 1791 return false 1792 } 1793 if this.Owner != that1.Owner { 1794 return false 1795 } 1796 if this.Description != that1.Description { 1797 return false 1798 } 1799 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1800 return false 1801 } 1802 return true 1803} 1804func (this *Help) Equal(that interface{}) bool { 1805 if that == nil { 1806 return this == nil 1807 } 1808 1809 that1, ok := that.(*Help) 1810 if !ok { 1811 that2, ok := that.(Help) 1812 if ok { 1813 that1 = &that2 1814 } else { 1815 return false 1816 } 1817 } 1818 if that1 == nil { 1819 return this == nil 1820 } else if this == nil { 1821 return false 1822 } 1823 if len(this.Links) != len(that1.Links) { 1824 return false 1825 } 1826 for i := range this.Links { 1827 if !this.Links[i].Equal(that1.Links[i]) { 1828 return false 1829 } 1830 } 1831 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1832 return false 1833 } 1834 return true 1835} 1836func (this *Help_Link) Equal(that interface{}) bool { 1837 if that == nil { 1838 return this == nil 1839 } 1840 1841 that1, ok := that.(*Help_Link) 1842 if !ok { 1843 that2, ok := that.(Help_Link) 1844 if ok { 1845 that1 = &that2 1846 } else { 1847 return false 1848 } 1849 } 1850 if that1 == nil { 1851 return this == nil 1852 } else if this == nil { 1853 return false 1854 } 1855 if this.Description != that1.Description { 1856 return false 1857 } 1858 if this.Url != that1.Url { 1859 return false 1860 } 1861 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1862 return false 1863 } 1864 return true 1865} 1866func (this *LocalizedMessage) Equal(that interface{}) bool { 1867 if that == nil { 1868 return this == nil 1869 } 1870 1871 that1, ok := that.(*LocalizedMessage) 1872 if !ok { 1873 that2, ok := that.(LocalizedMessage) 1874 if ok { 1875 that1 = &that2 1876 } else { 1877 return false 1878 } 1879 } 1880 if that1 == nil { 1881 return this == nil 1882 } else if this == nil { 1883 return false 1884 } 1885 if this.Locale != that1.Locale { 1886 return false 1887 } 1888 if this.Message != that1.Message { 1889 return false 1890 } 1891 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1892 return false 1893 } 1894 return true 1895} 1896func (this *RetryInfo) GoString() string { 1897 if this == nil { 1898 return "nil" 1899 } 1900 s := make([]string, 0, 5) 1901 s = append(s, "&rpc.RetryInfo{") 1902 if this.RetryDelay != nil { 1903 s = append(s, "RetryDelay: "+fmt.Sprintf("%#v", this.RetryDelay)+",\n") 1904 } 1905 if this.XXX_unrecognized != nil { 1906 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1907 } 1908 s = append(s, "}") 1909 return strings.Join(s, "") 1910} 1911func (this *DebugInfo) GoString() string { 1912 if this == nil { 1913 return "nil" 1914 } 1915 s := make([]string, 0, 6) 1916 s = append(s, "&rpc.DebugInfo{") 1917 s = append(s, "StackEntries: "+fmt.Sprintf("%#v", this.StackEntries)+",\n") 1918 s = append(s, "Detail: "+fmt.Sprintf("%#v", this.Detail)+",\n") 1919 if this.XXX_unrecognized != nil { 1920 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1921 } 1922 s = append(s, "}") 1923 return strings.Join(s, "") 1924} 1925func (this *QuotaFailure) GoString() string { 1926 if this == nil { 1927 return "nil" 1928 } 1929 s := make([]string, 0, 5) 1930 s = append(s, "&rpc.QuotaFailure{") 1931 if this.Violations != nil { 1932 s = append(s, "Violations: "+fmt.Sprintf("%#v", this.Violations)+",\n") 1933 } 1934 if this.XXX_unrecognized != nil { 1935 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1936 } 1937 s = append(s, "}") 1938 return strings.Join(s, "") 1939} 1940func (this *QuotaFailure_Violation) GoString() string { 1941 if this == nil { 1942 return "nil" 1943 } 1944 s := make([]string, 0, 6) 1945 s = append(s, "&rpc.QuotaFailure_Violation{") 1946 s = append(s, "Subject: "+fmt.Sprintf("%#v", this.Subject)+",\n") 1947 s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n") 1948 if this.XXX_unrecognized != nil { 1949 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1950 } 1951 s = append(s, "}") 1952 return strings.Join(s, "") 1953} 1954func (this *PreconditionFailure) GoString() string { 1955 if this == nil { 1956 return "nil" 1957 } 1958 s := make([]string, 0, 5) 1959 s = append(s, "&rpc.PreconditionFailure{") 1960 if this.Violations != nil { 1961 s = append(s, "Violations: "+fmt.Sprintf("%#v", this.Violations)+",\n") 1962 } 1963 if this.XXX_unrecognized != nil { 1964 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1965 } 1966 s = append(s, "}") 1967 return strings.Join(s, "") 1968} 1969func (this *PreconditionFailure_Violation) GoString() string { 1970 if this == nil { 1971 return "nil" 1972 } 1973 s := make([]string, 0, 7) 1974 s = append(s, "&rpc.PreconditionFailure_Violation{") 1975 s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") 1976 s = append(s, "Subject: "+fmt.Sprintf("%#v", this.Subject)+",\n") 1977 s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n") 1978 if this.XXX_unrecognized != nil { 1979 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1980 } 1981 s = append(s, "}") 1982 return strings.Join(s, "") 1983} 1984func (this *BadRequest) GoString() string { 1985 if this == nil { 1986 return "nil" 1987 } 1988 s := make([]string, 0, 5) 1989 s = append(s, "&rpc.BadRequest{") 1990 if this.FieldViolations != nil { 1991 s = append(s, "FieldViolations: "+fmt.Sprintf("%#v", this.FieldViolations)+",\n") 1992 } 1993 if this.XXX_unrecognized != nil { 1994 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1995 } 1996 s = append(s, "}") 1997 return strings.Join(s, "") 1998} 1999func (this *BadRequest_FieldViolation) GoString() string { 2000 if this == nil { 2001 return "nil" 2002 } 2003 s := make([]string, 0, 6) 2004 s = append(s, "&rpc.BadRequest_FieldViolation{") 2005 s = append(s, "Field: "+fmt.Sprintf("%#v", this.Field)+",\n") 2006 s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n") 2007 if this.XXX_unrecognized != nil { 2008 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 2009 } 2010 s = append(s, "}") 2011 return strings.Join(s, "") 2012} 2013func (this *RequestInfo) GoString() string { 2014 if this == nil { 2015 return "nil" 2016 } 2017 s := make([]string, 0, 6) 2018 s = append(s, "&rpc.RequestInfo{") 2019 s = append(s, "RequestId: "+fmt.Sprintf("%#v", this.RequestId)+",\n") 2020 s = append(s, "ServingData: "+fmt.Sprintf("%#v", this.ServingData)+",\n") 2021 if this.XXX_unrecognized != nil { 2022 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 2023 } 2024 s = append(s, "}") 2025 return strings.Join(s, "") 2026} 2027func (this *ResourceInfo) GoString() string { 2028 if this == nil { 2029 return "nil" 2030 } 2031 s := make([]string, 0, 8) 2032 s = append(s, "&rpc.ResourceInfo{") 2033 s = append(s, "ResourceType: "+fmt.Sprintf("%#v", this.ResourceType)+",\n") 2034 s = append(s, "ResourceName: "+fmt.Sprintf("%#v", this.ResourceName)+",\n") 2035 s = append(s, "Owner: "+fmt.Sprintf("%#v", this.Owner)+",\n") 2036 s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n") 2037 if this.XXX_unrecognized != nil { 2038 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 2039 } 2040 s = append(s, "}") 2041 return strings.Join(s, "") 2042} 2043func (this *Help) GoString() string { 2044 if this == nil { 2045 return "nil" 2046 } 2047 s := make([]string, 0, 5) 2048 s = append(s, "&rpc.Help{") 2049 if this.Links != nil { 2050 s = append(s, "Links: "+fmt.Sprintf("%#v", this.Links)+",\n") 2051 } 2052 if this.XXX_unrecognized != nil { 2053 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 2054 } 2055 s = append(s, "}") 2056 return strings.Join(s, "") 2057} 2058func (this *Help_Link) GoString() string { 2059 if this == nil { 2060 return "nil" 2061 } 2062 s := make([]string, 0, 6) 2063 s = append(s, "&rpc.Help_Link{") 2064 s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n") 2065 s = append(s, "Url: "+fmt.Sprintf("%#v", this.Url)+",\n") 2066 if this.XXX_unrecognized != nil { 2067 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 2068 } 2069 s = append(s, "}") 2070 return strings.Join(s, "") 2071} 2072func (this *LocalizedMessage) GoString() string { 2073 if this == nil { 2074 return "nil" 2075 } 2076 s := make([]string, 0, 6) 2077 s = append(s, "&rpc.LocalizedMessage{") 2078 s = append(s, "Locale: "+fmt.Sprintf("%#v", this.Locale)+",\n") 2079 s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n") 2080 if this.XXX_unrecognized != nil { 2081 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 2082 } 2083 s = append(s, "}") 2084 return strings.Join(s, "") 2085} 2086func valueToGoStringErrorDetails(v interface{}, typ string) string { 2087 rv := reflect.ValueOf(v) 2088 if rv.IsNil() { 2089 return "nil" 2090 } 2091 pv := reflect.Indirect(rv).Interface() 2092 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) 2093} 2094func (m *RetryInfo) Marshal() (dAtA []byte, err error) { 2095 size := m.Size() 2096 dAtA = make([]byte, size) 2097 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2098 if err != nil { 2099 return nil, err 2100 } 2101 return dAtA[:n], nil 2102} 2103 2104func (m *RetryInfo) MarshalTo(dAtA []byte) (int, error) { 2105 size := m.Size() 2106 return m.MarshalToSizedBuffer(dAtA[:size]) 2107} 2108 2109func (m *RetryInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2110 i := len(dAtA) 2111 _ = i 2112 var l int 2113 _ = l 2114 if m.XXX_unrecognized != nil { 2115 i -= len(m.XXX_unrecognized) 2116 copy(dAtA[i:], m.XXX_unrecognized) 2117 } 2118 if m.RetryDelay != nil { 2119 { 2120 size, err := m.RetryDelay.MarshalToSizedBuffer(dAtA[:i]) 2121 if err != nil { 2122 return 0, err 2123 } 2124 i -= size 2125 i = encodeVarintErrorDetails(dAtA, i, uint64(size)) 2126 } 2127 i-- 2128 dAtA[i] = 0xa 2129 } 2130 return len(dAtA) - i, nil 2131} 2132 2133func (m *DebugInfo) Marshal() (dAtA []byte, err error) { 2134 size := m.Size() 2135 dAtA = make([]byte, size) 2136 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2137 if err != nil { 2138 return nil, err 2139 } 2140 return dAtA[:n], nil 2141} 2142 2143func (m *DebugInfo) MarshalTo(dAtA []byte) (int, error) { 2144 size := m.Size() 2145 return m.MarshalToSizedBuffer(dAtA[:size]) 2146} 2147 2148func (m *DebugInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2149 i := len(dAtA) 2150 _ = i 2151 var l int 2152 _ = l 2153 if m.XXX_unrecognized != nil { 2154 i -= len(m.XXX_unrecognized) 2155 copy(dAtA[i:], m.XXX_unrecognized) 2156 } 2157 if len(m.Detail) > 0 { 2158 i -= len(m.Detail) 2159 copy(dAtA[i:], m.Detail) 2160 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Detail))) 2161 i-- 2162 dAtA[i] = 0x12 2163 } 2164 if len(m.StackEntries) > 0 { 2165 for iNdEx := len(m.StackEntries) - 1; iNdEx >= 0; iNdEx-- { 2166 i -= len(m.StackEntries[iNdEx]) 2167 copy(dAtA[i:], m.StackEntries[iNdEx]) 2168 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.StackEntries[iNdEx]))) 2169 i-- 2170 dAtA[i] = 0xa 2171 } 2172 } 2173 return len(dAtA) - i, nil 2174} 2175 2176func (m *QuotaFailure) Marshal() (dAtA []byte, err error) { 2177 size := m.Size() 2178 dAtA = make([]byte, size) 2179 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2180 if err != nil { 2181 return nil, err 2182 } 2183 return dAtA[:n], nil 2184} 2185 2186func (m *QuotaFailure) MarshalTo(dAtA []byte) (int, error) { 2187 size := m.Size() 2188 return m.MarshalToSizedBuffer(dAtA[:size]) 2189} 2190 2191func (m *QuotaFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2192 i := len(dAtA) 2193 _ = i 2194 var l int 2195 _ = l 2196 if m.XXX_unrecognized != nil { 2197 i -= len(m.XXX_unrecognized) 2198 copy(dAtA[i:], m.XXX_unrecognized) 2199 } 2200 if len(m.Violations) > 0 { 2201 for iNdEx := len(m.Violations) - 1; iNdEx >= 0; iNdEx-- { 2202 { 2203 size, err := m.Violations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2204 if err != nil { 2205 return 0, err 2206 } 2207 i -= size 2208 i = encodeVarintErrorDetails(dAtA, i, uint64(size)) 2209 } 2210 i-- 2211 dAtA[i] = 0xa 2212 } 2213 } 2214 return len(dAtA) - i, nil 2215} 2216 2217func (m *QuotaFailure_Violation) Marshal() (dAtA []byte, err error) { 2218 size := m.Size() 2219 dAtA = make([]byte, size) 2220 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2221 if err != nil { 2222 return nil, err 2223 } 2224 return dAtA[:n], nil 2225} 2226 2227func (m *QuotaFailure_Violation) MarshalTo(dAtA []byte) (int, error) { 2228 size := m.Size() 2229 return m.MarshalToSizedBuffer(dAtA[:size]) 2230} 2231 2232func (m *QuotaFailure_Violation) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2233 i := len(dAtA) 2234 _ = i 2235 var l int 2236 _ = l 2237 if m.XXX_unrecognized != nil { 2238 i -= len(m.XXX_unrecognized) 2239 copy(dAtA[i:], m.XXX_unrecognized) 2240 } 2241 if len(m.Description) > 0 { 2242 i -= len(m.Description) 2243 copy(dAtA[i:], m.Description) 2244 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description))) 2245 i-- 2246 dAtA[i] = 0x12 2247 } 2248 if len(m.Subject) > 0 { 2249 i -= len(m.Subject) 2250 copy(dAtA[i:], m.Subject) 2251 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Subject))) 2252 i-- 2253 dAtA[i] = 0xa 2254 } 2255 return len(dAtA) - i, nil 2256} 2257 2258func (m *PreconditionFailure) Marshal() (dAtA []byte, err error) { 2259 size := m.Size() 2260 dAtA = make([]byte, size) 2261 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2262 if err != nil { 2263 return nil, err 2264 } 2265 return dAtA[:n], nil 2266} 2267 2268func (m *PreconditionFailure) MarshalTo(dAtA []byte) (int, error) { 2269 size := m.Size() 2270 return m.MarshalToSizedBuffer(dAtA[:size]) 2271} 2272 2273func (m *PreconditionFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2274 i := len(dAtA) 2275 _ = i 2276 var l int 2277 _ = l 2278 if m.XXX_unrecognized != nil { 2279 i -= len(m.XXX_unrecognized) 2280 copy(dAtA[i:], m.XXX_unrecognized) 2281 } 2282 if len(m.Violations) > 0 { 2283 for iNdEx := len(m.Violations) - 1; iNdEx >= 0; iNdEx-- { 2284 { 2285 size, err := m.Violations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2286 if err != nil { 2287 return 0, err 2288 } 2289 i -= size 2290 i = encodeVarintErrorDetails(dAtA, i, uint64(size)) 2291 } 2292 i-- 2293 dAtA[i] = 0xa 2294 } 2295 } 2296 return len(dAtA) - i, nil 2297} 2298 2299func (m *PreconditionFailure_Violation) Marshal() (dAtA []byte, err error) { 2300 size := m.Size() 2301 dAtA = make([]byte, size) 2302 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2303 if err != nil { 2304 return nil, err 2305 } 2306 return dAtA[:n], nil 2307} 2308 2309func (m *PreconditionFailure_Violation) MarshalTo(dAtA []byte) (int, error) { 2310 size := m.Size() 2311 return m.MarshalToSizedBuffer(dAtA[:size]) 2312} 2313 2314func (m *PreconditionFailure_Violation) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2315 i := len(dAtA) 2316 _ = i 2317 var l int 2318 _ = l 2319 if m.XXX_unrecognized != nil { 2320 i -= len(m.XXX_unrecognized) 2321 copy(dAtA[i:], m.XXX_unrecognized) 2322 } 2323 if len(m.Description) > 0 { 2324 i -= len(m.Description) 2325 copy(dAtA[i:], m.Description) 2326 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description))) 2327 i-- 2328 dAtA[i] = 0x1a 2329 } 2330 if len(m.Subject) > 0 { 2331 i -= len(m.Subject) 2332 copy(dAtA[i:], m.Subject) 2333 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Subject))) 2334 i-- 2335 dAtA[i] = 0x12 2336 } 2337 if len(m.Type) > 0 { 2338 i -= len(m.Type) 2339 copy(dAtA[i:], m.Type) 2340 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Type))) 2341 i-- 2342 dAtA[i] = 0xa 2343 } 2344 return len(dAtA) - i, nil 2345} 2346 2347func (m *BadRequest) Marshal() (dAtA []byte, err error) { 2348 size := m.Size() 2349 dAtA = make([]byte, size) 2350 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2351 if err != nil { 2352 return nil, err 2353 } 2354 return dAtA[:n], nil 2355} 2356 2357func (m *BadRequest) MarshalTo(dAtA []byte) (int, error) { 2358 size := m.Size() 2359 return m.MarshalToSizedBuffer(dAtA[:size]) 2360} 2361 2362func (m *BadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2363 i := len(dAtA) 2364 _ = i 2365 var l int 2366 _ = l 2367 if m.XXX_unrecognized != nil { 2368 i -= len(m.XXX_unrecognized) 2369 copy(dAtA[i:], m.XXX_unrecognized) 2370 } 2371 if len(m.FieldViolations) > 0 { 2372 for iNdEx := len(m.FieldViolations) - 1; iNdEx >= 0; iNdEx-- { 2373 { 2374 size, err := m.FieldViolations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2375 if err != nil { 2376 return 0, err 2377 } 2378 i -= size 2379 i = encodeVarintErrorDetails(dAtA, i, uint64(size)) 2380 } 2381 i-- 2382 dAtA[i] = 0xa 2383 } 2384 } 2385 return len(dAtA) - i, nil 2386} 2387 2388func (m *BadRequest_FieldViolation) Marshal() (dAtA []byte, err error) { 2389 size := m.Size() 2390 dAtA = make([]byte, size) 2391 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2392 if err != nil { 2393 return nil, err 2394 } 2395 return dAtA[:n], nil 2396} 2397 2398func (m *BadRequest_FieldViolation) MarshalTo(dAtA []byte) (int, error) { 2399 size := m.Size() 2400 return m.MarshalToSizedBuffer(dAtA[:size]) 2401} 2402 2403func (m *BadRequest_FieldViolation) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2404 i := len(dAtA) 2405 _ = i 2406 var l int 2407 _ = l 2408 if m.XXX_unrecognized != nil { 2409 i -= len(m.XXX_unrecognized) 2410 copy(dAtA[i:], m.XXX_unrecognized) 2411 } 2412 if len(m.Description) > 0 { 2413 i -= len(m.Description) 2414 copy(dAtA[i:], m.Description) 2415 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description))) 2416 i-- 2417 dAtA[i] = 0x12 2418 } 2419 if len(m.Field) > 0 { 2420 i -= len(m.Field) 2421 copy(dAtA[i:], m.Field) 2422 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Field))) 2423 i-- 2424 dAtA[i] = 0xa 2425 } 2426 return len(dAtA) - i, nil 2427} 2428 2429func (m *RequestInfo) Marshal() (dAtA []byte, err error) { 2430 size := m.Size() 2431 dAtA = make([]byte, size) 2432 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2433 if err != nil { 2434 return nil, err 2435 } 2436 return dAtA[:n], nil 2437} 2438 2439func (m *RequestInfo) MarshalTo(dAtA []byte) (int, error) { 2440 size := m.Size() 2441 return m.MarshalToSizedBuffer(dAtA[:size]) 2442} 2443 2444func (m *RequestInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2445 i := len(dAtA) 2446 _ = i 2447 var l int 2448 _ = l 2449 if m.XXX_unrecognized != nil { 2450 i -= len(m.XXX_unrecognized) 2451 copy(dAtA[i:], m.XXX_unrecognized) 2452 } 2453 if len(m.ServingData) > 0 { 2454 i -= len(m.ServingData) 2455 copy(dAtA[i:], m.ServingData) 2456 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.ServingData))) 2457 i-- 2458 dAtA[i] = 0x12 2459 } 2460 if len(m.RequestId) > 0 { 2461 i -= len(m.RequestId) 2462 copy(dAtA[i:], m.RequestId) 2463 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.RequestId))) 2464 i-- 2465 dAtA[i] = 0xa 2466 } 2467 return len(dAtA) - i, nil 2468} 2469 2470func (m *ResourceInfo) Marshal() (dAtA []byte, err error) { 2471 size := m.Size() 2472 dAtA = make([]byte, size) 2473 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2474 if err != nil { 2475 return nil, err 2476 } 2477 return dAtA[:n], nil 2478} 2479 2480func (m *ResourceInfo) MarshalTo(dAtA []byte) (int, error) { 2481 size := m.Size() 2482 return m.MarshalToSizedBuffer(dAtA[:size]) 2483} 2484 2485func (m *ResourceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2486 i := len(dAtA) 2487 _ = i 2488 var l int 2489 _ = l 2490 if m.XXX_unrecognized != nil { 2491 i -= len(m.XXX_unrecognized) 2492 copy(dAtA[i:], m.XXX_unrecognized) 2493 } 2494 if len(m.Description) > 0 { 2495 i -= len(m.Description) 2496 copy(dAtA[i:], m.Description) 2497 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description))) 2498 i-- 2499 dAtA[i] = 0x22 2500 } 2501 if len(m.Owner) > 0 { 2502 i -= len(m.Owner) 2503 copy(dAtA[i:], m.Owner) 2504 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Owner))) 2505 i-- 2506 dAtA[i] = 0x1a 2507 } 2508 if len(m.ResourceName) > 0 { 2509 i -= len(m.ResourceName) 2510 copy(dAtA[i:], m.ResourceName) 2511 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.ResourceName))) 2512 i-- 2513 dAtA[i] = 0x12 2514 } 2515 if len(m.ResourceType) > 0 { 2516 i -= len(m.ResourceType) 2517 copy(dAtA[i:], m.ResourceType) 2518 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.ResourceType))) 2519 i-- 2520 dAtA[i] = 0xa 2521 } 2522 return len(dAtA) - i, nil 2523} 2524 2525func (m *Help) Marshal() (dAtA []byte, err error) { 2526 size := m.Size() 2527 dAtA = make([]byte, size) 2528 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2529 if err != nil { 2530 return nil, err 2531 } 2532 return dAtA[:n], nil 2533} 2534 2535func (m *Help) MarshalTo(dAtA []byte) (int, error) { 2536 size := m.Size() 2537 return m.MarshalToSizedBuffer(dAtA[:size]) 2538} 2539 2540func (m *Help) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2541 i := len(dAtA) 2542 _ = i 2543 var l int 2544 _ = l 2545 if m.XXX_unrecognized != nil { 2546 i -= len(m.XXX_unrecognized) 2547 copy(dAtA[i:], m.XXX_unrecognized) 2548 } 2549 if len(m.Links) > 0 { 2550 for iNdEx := len(m.Links) - 1; iNdEx >= 0; iNdEx-- { 2551 { 2552 size, err := m.Links[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2553 if err != nil { 2554 return 0, err 2555 } 2556 i -= size 2557 i = encodeVarintErrorDetails(dAtA, i, uint64(size)) 2558 } 2559 i-- 2560 dAtA[i] = 0xa 2561 } 2562 } 2563 return len(dAtA) - i, nil 2564} 2565 2566func (m *Help_Link) Marshal() (dAtA []byte, err error) { 2567 size := m.Size() 2568 dAtA = make([]byte, size) 2569 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2570 if err != nil { 2571 return nil, err 2572 } 2573 return dAtA[:n], nil 2574} 2575 2576func (m *Help_Link) MarshalTo(dAtA []byte) (int, error) { 2577 size := m.Size() 2578 return m.MarshalToSizedBuffer(dAtA[:size]) 2579} 2580 2581func (m *Help_Link) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2582 i := len(dAtA) 2583 _ = i 2584 var l int 2585 _ = l 2586 if m.XXX_unrecognized != nil { 2587 i -= len(m.XXX_unrecognized) 2588 copy(dAtA[i:], m.XXX_unrecognized) 2589 } 2590 if len(m.Url) > 0 { 2591 i -= len(m.Url) 2592 copy(dAtA[i:], m.Url) 2593 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Url))) 2594 i-- 2595 dAtA[i] = 0x12 2596 } 2597 if len(m.Description) > 0 { 2598 i -= len(m.Description) 2599 copy(dAtA[i:], m.Description) 2600 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Description))) 2601 i-- 2602 dAtA[i] = 0xa 2603 } 2604 return len(dAtA) - i, nil 2605} 2606 2607func (m *LocalizedMessage) Marshal() (dAtA []byte, err error) { 2608 size := m.Size() 2609 dAtA = make([]byte, size) 2610 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2611 if err != nil { 2612 return nil, err 2613 } 2614 return dAtA[:n], nil 2615} 2616 2617func (m *LocalizedMessage) MarshalTo(dAtA []byte) (int, error) { 2618 size := m.Size() 2619 return m.MarshalToSizedBuffer(dAtA[:size]) 2620} 2621 2622func (m *LocalizedMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2623 i := len(dAtA) 2624 _ = i 2625 var l int 2626 _ = l 2627 if m.XXX_unrecognized != nil { 2628 i -= len(m.XXX_unrecognized) 2629 copy(dAtA[i:], m.XXX_unrecognized) 2630 } 2631 if len(m.Message) > 0 { 2632 i -= len(m.Message) 2633 copy(dAtA[i:], m.Message) 2634 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Message))) 2635 i-- 2636 dAtA[i] = 0x12 2637 } 2638 if len(m.Locale) > 0 { 2639 i -= len(m.Locale) 2640 copy(dAtA[i:], m.Locale) 2641 i = encodeVarintErrorDetails(dAtA, i, uint64(len(m.Locale))) 2642 i-- 2643 dAtA[i] = 0xa 2644 } 2645 return len(dAtA) - i, nil 2646} 2647 2648func encodeVarintErrorDetails(dAtA []byte, offset int, v uint64) int { 2649 offset -= sovErrorDetails(v) 2650 base := offset 2651 for v >= 1<<7 { 2652 dAtA[offset] = uint8(v&0x7f | 0x80) 2653 v >>= 7 2654 offset++ 2655 } 2656 dAtA[offset] = uint8(v) 2657 return base 2658} 2659func NewPopulatedRetryInfo(r randyErrorDetails, easy bool) *RetryInfo { 2660 this := &RetryInfo{} 2661 if r.Intn(5) != 0 { 2662 this.RetryDelay = types.NewPopulatedDuration(r, easy) 2663 } 2664 if !easy && r.Intn(10) != 0 { 2665 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2) 2666 } 2667 return this 2668} 2669 2670func NewPopulatedDebugInfo(r randyErrorDetails, easy bool) *DebugInfo { 2671 this := &DebugInfo{} 2672 v1 := r.Intn(10) 2673 this.StackEntries = make([]string, v1) 2674 for i := 0; i < v1; i++ { 2675 this.StackEntries[i] = string(randStringErrorDetails(r)) 2676 } 2677 this.Detail = string(randStringErrorDetails(r)) 2678 if !easy && r.Intn(10) != 0 { 2679 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3) 2680 } 2681 return this 2682} 2683 2684func NewPopulatedQuotaFailure(r randyErrorDetails, easy bool) *QuotaFailure { 2685 this := &QuotaFailure{} 2686 if r.Intn(5) != 0 { 2687 v2 := r.Intn(5) 2688 this.Violations = make([]*QuotaFailure_Violation, v2) 2689 for i := 0; i < v2; i++ { 2690 this.Violations[i] = NewPopulatedQuotaFailure_Violation(r, easy) 2691 } 2692 } 2693 if !easy && r.Intn(10) != 0 { 2694 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2) 2695 } 2696 return this 2697} 2698 2699func NewPopulatedQuotaFailure_Violation(r randyErrorDetails, easy bool) *QuotaFailure_Violation { 2700 this := &QuotaFailure_Violation{} 2701 this.Subject = string(randStringErrorDetails(r)) 2702 this.Description = string(randStringErrorDetails(r)) 2703 if !easy && r.Intn(10) != 0 { 2704 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3) 2705 } 2706 return this 2707} 2708 2709func NewPopulatedPreconditionFailure(r randyErrorDetails, easy bool) *PreconditionFailure { 2710 this := &PreconditionFailure{} 2711 if r.Intn(5) != 0 { 2712 v3 := r.Intn(5) 2713 this.Violations = make([]*PreconditionFailure_Violation, v3) 2714 for i := 0; i < v3; i++ { 2715 this.Violations[i] = NewPopulatedPreconditionFailure_Violation(r, easy) 2716 } 2717 } 2718 if !easy && r.Intn(10) != 0 { 2719 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2) 2720 } 2721 return this 2722} 2723 2724func NewPopulatedPreconditionFailure_Violation(r randyErrorDetails, easy bool) *PreconditionFailure_Violation { 2725 this := &PreconditionFailure_Violation{} 2726 this.Type = string(randStringErrorDetails(r)) 2727 this.Subject = string(randStringErrorDetails(r)) 2728 this.Description = string(randStringErrorDetails(r)) 2729 if !easy && r.Intn(10) != 0 { 2730 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 4) 2731 } 2732 return this 2733} 2734 2735func NewPopulatedBadRequest(r randyErrorDetails, easy bool) *BadRequest { 2736 this := &BadRequest{} 2737 if r.Intn(5) != 0 { 2738 v4 := r.Intn(5) 2739 this.FieldViolations = make([]*BadRequest_FieldViolation, v4) 2740 for i := 0; i < v4; i++ { 2741 this.FieldViolations[i] = NewPopulatedBadRequest_FieldViolation(r, easy) 2742 } 2743 } 2744 if !easy && r.Intn(10) != 0 { 2745 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2) 2746 } 2747 return this 2748} 2749 2750func NewPopulatedBadRequest_FieldViolation(r randyErrorDetails, easy bool) *BadRequest_FieldViolation { 2751 this := &BadRequest_FieldViolation{} 2752 this.Field = string(randStringErrorDetails(r)) 2753 this.Description = string(randStringErrorDetails(r)) 2754 if !easy && r.Intn(10) != 0 { 2755 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3) 2756 } 2757 return this 2758} 2759 2760func NewPopulatedRequestInfo(r randyErrorDetails, easy bool) *RequestInfo { 2761 this := &RequestInfo{} 2762 this.RequestId = string(randStringErrorDetails(r)) 2763 this.ServingData = string(randStringErrorDetails(r)) 2764 if !easy && r.Intn(10) != 0 { 2765 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3) 2766 } 2767 return this 2768} 2769 2770func NewPopulatedResourceInfo(r randyErrorDetails, easy bool) *ResourceInfo { 2771 this := &ResourceInfo{} 2772 this.ResourceType = string(randStringErrorDetails(r)) 2773 this.ResourceName = string(randStringErrorDetails(r)) 2774 this.Owner = string(randStringErrorDetails(r)) 2775 this.Description = string(randStringErrorDetails(r)) 2776 if !easy && r.Intn(10) != 0 { 2777 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 5) 2778 } 2779 return this 2780} 2781 2782func NewPopulatedHelp(r randyErrorDetails, easy bool) *Help { 2783 this := &Help{} 2784 if r.Intn(5) != 0 { 2785 v5 := r.Intn(5) 2786 this.Links = make([]*Help_Link, v5) 2787 for i := 0; i < v5; i++ { 2788 this.Links[i] = NewPopulatedHelp_Link(r, easy) 2789 } 2790 } 2791 if !easy && r.Intn(10) != 0 { 2792 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 2) 2793 } 2794 return this 2795} 2796 2797func NewPopulatedHelp_Link(r randyErrorDetails, easy bool) *Help_Link { 2798 this := &Help_Link{} 2799 this.Description = string(randStringErrorDetails(r)) 2800 this.Url = string(randStringErrorDetails(r)) 2801 if !easy && r.Intn(10) != 0 { 2802 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3) 2803 } 2804 return this 2805} 2806 2807func NewPopulatedLocalizedMessage(r randyErrorDetails, easy bool) *LocalizedMessage { 2808 this := &LocalizedMessage{} 2809 this.Locale = string(randStringErrorDetails(r)) 2810 this.Message = string(randStringErrorDetails(r)) 2811 if !easy && r.Intn(10) != 0 { 2812 this.XXX_unrecognized = randUnrecognizedErrorDetails(r, 3) 2813 } 2814 return this 2815} 2816 2817type randyErrorDetails interface { 2818 Float32() float32 2819 Float64() float64 2820 Int63() int64 2821 Int31() int32 2822 Uint32() uint32 2823 Intn(n int) int 2824} 2825 2826func randUTF8RuneErrorDetails(r randyErrorDetails) rune { 2827 ru := r.Intn(62) 2828 if ru < 10 { 2829 return rune(ru + 48) 2830 } else if ru < 36 { 2831 return rune(ru + 55) 2832 } 2833 return rune(ru + 61) 2834} 2835func randStringErrorDetails(r randyErrorDetails) string { 2836 v6 := r.Intn(100) 2837 tmps := make([]rune, v6) 2838 for i := 0; i < v6; i++ { 2839 tmps[i] = randUTF8RuneErrorDetails(r) 2840 } 2841 return string(tmps) 2842} 2843func randUnrecognizedErrorDetails(r randyErrorDetails, maxFieldNumber int) (dAtA []byte) { 2844 l := r.Intn(5) 2845 for i := 0; i < l; i++ { 2846 wire := r.Intn(4) 2847 if wire == 3 { 2848 wire = 5 2849 } 2850 fieldNumber := maxFieldNumber + r.Intn(100) 2851 dAtA = randFieldErrorDetails(dAtA, r, fieldNumber, wire) 2852 } 2853 return dAtA 2854} 2855func randFieldErrorDetails(dAtA []byte, r randyErrorDetails, fieldNumber int, wire int) []byte { 2856 key := uint32(fieldNumber)<<3 | uint32(wire) 2857 switch wire { 2858 case 0: 2859 dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key)) 2860 v7 := r.Int63() 2861 if r.Intn(2) == 0 { 2862 v7 *= -1 2863 } 2864 dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(v7)) 2865 case 1: 2866 dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key)) 2867 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))) 2868 case 2: 2869 dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key)) 2870 ll := r.Intn(100) 2871 dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(ll)) 2872 for j := 0; j < ll; j++ { 2873 dAtA = append(dAtA, byte(r.Intn(256))) 2874 } 2875 default: 2876 dAtA = encodeVarintPopulateErrorDetails(dAtA, uint64(key)) 2877 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) 2878 } 2879 return dAtA 2880} 2881func encodeVarintPopulateErrorDetails(dAtA []byte, v uint64) []byte { 2882 for v >= 1<<7 { 2883 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) 2884 v >>= 7 2885 } 2886 dAtA = append(dAtA, uint8(v)) 2887 return dAtA 2888} 2889func (m *RetryInfo) Size() (n int) { 2890 if m == nil { 2891 return 0 2892 } 2893 var l int 2894 _ = l 2895 if m.RetryDelay != nil { 2896 l = m.RetryDelay.Size() 2897 n += 1 + l + sovErrorDetails(uint64(l)) 2898 } 2899 if m.XXX_unrecognized != nil { 2900 n += len(m.XXX_unrecognized) 2901 } 2902 return n 2903} 2904 2905func (m *DebugInfo) Size() (n int) { 2906 if m == nil { 2907 return 0 2908 } 2909 var l int 2910 _ = l 2911 if len(m.StackEntries) > 0 { 2912 for _, s := range m.StackEntries { 2913 l = len(s) 2914 n += 1 + l + sovErrorDetails(uint64(l)) 2915 } 2916 } 2917 l = len(m.Detail) 2918 if l > 0 { 2919 n += 1 + l + sovErrorDetails(uint64(l)) 2920 } 2921 if m.XXX_unrecognized != nil { 2922 n += len(m.XXX_unrecognized) 2923 } 2924 return n 2925} 2926 2927func (m *QuotaFailure) Size() (n int) { 2928 if m == nil { 2929 return 0 2930 } 2931 var l int 2932 _ = l 2933 if len(m.Violations) > 0 { 2934 for _, e := range m.Violations { 2935 l = e.Size() 2936 n += 1 + l + sovErrorDetails(uint64(l)) 2937 } 2938 } 2939 if m.XXX_unrecognized != nil { 2940 n += len(m.XXX_unrecognized) 2941 } 2942 return n 2943} 2944 2945func (m *QuotaFailure_Violation) Size() (n int) { 2946 if m == nil { 2947 return 0 2948 } 2949 var l int 2950 _ = l 2951 l = len(m.Subject) 2952 if l > 0 { 2953 n += 1 + l + sovErrorDetails(uint64(l)) 2954 } 2955 l = len(m.Description) 2956 if l > 0 { 2957 n += 1 + l + sovErrorDetails(uint64(l)) 2958 } 2959 if m.XXX_unrecognized != nil { 2960 n += len(m.XXX_unrecognized) 2961 } 2962 return n 2963} 2964 2965func (m *PreconditionFailure) Size() (n int) { 2966 if m == nil { 2967 return 0 2968 } 2969 var l int 2970 _ = l 2971 if len(m.Violations) > 0 { 2972 for _, e := range m.Violations { 2973 l = e.Size() 2974 n += 1 + l + sovErrorDetails(uint64(l)) 2975 } 2976 } 2977 if m.XXX_unrecognized != nil { 2978 n += len(m.XXX_unrecognized) 2979 } 2980 return n 2981} 2982 2983func (m *PreconditionFailure_Violation) Size() (n int) { 2984 if m == nil { 2985 return 0 2986 } 2987 var l int 2988 _ = l 2989 l = len(m.Type) 2990 if l > 0 { 2991 n += 1 + l + sovErrorDetails(uint64(l)) 2992 } 2993 l = len(m.Subject) 2994 if l > 0 { 2995 n += 1 + l + sovErrorDetails(uint64(l)) 2996 } 2997 l = len(m.Description) 2998 if l > 0 { 2999 n += 1 + l + sovErrorDetails(uint64(l)) 3000 } 3001 if m.XXX_unrecognized != nil { 3002 n += len(m.XXX_unrecognized) 3003 } 3004 return n 3005} 3006 3007func (m *BadRequest) Size() (n int) { 3008 if m == nil { 3009 return 0 3010 } 3011 var l int 3012 _ = l 3013 if len(m.FieldViolations) > 0 { 3014 for _, e := range m.FieldViolations { 3015 l = e.Size() 3016 n += 1 + l + sovErrorDetails(uint64(l)) 3017 } 3018 } 3019 if m.XXX_unrecognized != nil { 3020 n += len(m.XXX_unrecognized) 3021 } 3022 return n 3023} 3024 3025func (m *BadRequest_FieldViolation) Size() (n int) { 3026 if m == nil { 3027 return 0 3028 } 3029 var l int 3030 _ = l 3031 l = len(m.Field) 3032 if l > 0 { 3033 n += 1 + l + sovErrorDetails(uint64(l)) 3034 } 3035 l = len(m.Description) 3036 if l > 0 { 3037 n += 1 + l + sovErrorDetails(uint64(l)) 3038 } 3039 if m.XXX_unrecognized != nil { 3040 n += len(m.XXX_unrecognized) 3041 } 3042 return n 3043} 3044 3045func (m *RequestInfo) Size() (n int) { 3046 if m == nil { 3047 return 0 3048 } 3049 var l int 3050 _ = l 3051 l = len(m.RequestId) 3052 if l > 0 { 3053 n += 1 + l + sovErrorDetails(uint64(l)) 3054 } 3055 l = len(m.ServingData) 3056 if l > 0 { 3057 n += 1 + l + sovErrorDetails(uint64(l)) 3058 } 3059 if m.XXX_unrecognized != nil { 3060 n += len(m.XXX_unrecognized) 3061 } 3062 return n 3063} 3064 3065func (m *ResourceInfo) Size() (n int) { 3066 if m == nil { 3067 return 0 3068 } 3069 var l int 3070 _ = l 3071 l = len(m.ResourceType) 3072 if l > 0 { 3073 n += 1 + l + sovErrorDetails(uint64(l)) 3074 } 3075 l = len(m.ResourceName) 3076 if l > 0 { 3077 n += 1 + l + sovErrorDetails(uint64(l)) 3078 } 3079 l = len(m.Owner) 3080 if l > 0 { 3081 n += 1 + l + sovErrorDetails(uint64(l)) 3082 } 3083 l = len(m.Description) 3084 if l > 0 { 3085 n += 1 + l + sovErrorDetails(uint64(l)) 3086 } 3087 if m.XXX_unrecognized != nil { 3088 n += len(m.XXX_unrecognized) 3089 } 3090 return n 3091} 3092 3093func (m *Help) Size() (n int) { 3094 if m == nil { 3095 return 0 3096 } 3097 var l int 3098 _ = l 3099 if len(m.Links) > 0 { 3100 for _, e := range m.Links { 3101 l = e.Size() 3102 n += 1 + l + sovErrorDetails(uint64(l)) 3103 } 3104 } 3105 if m.XXX_unrecognized != nil { 3106 n += len(m.XXX_unrecognized) 3107 } 3108 return n 3109} 3110 3111func (m *Help_Link) Size() (n int) { 3112 if m == nil { 3113 return 0 3114 } 3115 var l int 3116 _ = l 3117 l = len(m.Description) 3118 if l > 0 { 3119 n += 1 + l + sovErrorDetails(uint64(l)) 3120 } 3121 l = len(m.Url) 3122 if l > 0 { 3123 n += 1 + l + sovErrorDetails(uint64(l)) 3124 } 3125 if m.XXX_unrecognized != nil { 3126 n += len(m.XXX_unrecognized) 3127 } 3128 return n 3129} 3130 3131func (m *LocalizedMessage) Size() (n int) { 3132 if m == nil { 3133 return 0 3134 } 3135 var l int 3136 _ = l 3137 l = len(m.Locale) 3138 if l > 0 { 3139 n += 1 + l + sovErrorDetails(uint64(l)) 3140 } 3141 l = len(m.Message) 3142 if l > 0 { 3143 n += 1 + l + sovErrorDetails(uint64(l)) 3144 } 3145 if m.XXX_unrecognized != nil { 3146 n += len(m.XXX_unrecognized) 3147 } 3148 return n 3149} 3150 3151func sovErrorDetails(x uint64) (n int) { 3152 return (math_bits.Len64(x|1) + 6) / 7 3153} 3154func sozErrorDetails(x uint64) (n int) { 3155 return sovErrorDetails(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 3156} 3157func (this *RetryInfo) String() string { 3158 if this == nil { 3159 return "nil" 3160 } 3161 s := strings.Join([]string{`&RetryInfo{`, 3162 `RetryDelay:` + strings.Replace(fmt.Sprintf("%v", this.RetryDelay), "Duration", "types.Duration", 1) + `,`, 3163 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3164 `}`, 3165 }, "") 3166 return s 3167} 3168func (this *DebugInfo) String() string { 3169 if this == nil { 3170 return "nil" 3171 } 3172 s := strings.Join([]string{`&DebugInfo{`, 3173 `StackEntries:` + fmt.Sprintf("%v", this.StackEntries) + `,`, 3174 `Detail:` + fmt.Sprintf("%v", this.Detail) + `,`, 3175 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3176 `}`, 3177 }, "") 3178 return s 3179} 3180func (this *QuotaFailure) String() string { 3181 if this == nil { 3182 return "nil" 3183 } 3184 repeatedStringForViolations := "[]*QuotaFailure_Violation{" 3185 for _, f := range this.Violations { 3186 repeatedStringForViolations += strings.Replace(fmt.Sprintf("%v", f), "QuotaFailure_Violation", "QuotaFailure_Violation", 1) + "," 3187 } 3188 repeatedStringForViolations += "}" 3189 s := strings.Join([]string{`&QuotaFailure{`, 3190 `Violations:` + repeatedStringForViolations + `,`, 3191 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3192 `}`, 3193 }, "") 3194 return s 3195} 3196func (this *QuotaFailure_Violation) String() string { 3197 if this == nil { 3198 return "nil" 3199 } 3200 s := strings.Join([]string{`&QuotaFailure_Violation{`, 3201 `Subject:` + fmt.Sprintf("%v", this.Subject) + `,`, 3202 `Description:` + fmt.Sprintf("%v", this.Description) + `,`, 3203 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3204 `}`, 3205 }, "") 3206 return s 3207} 3208func (this *PreconditionFailure) String() string { 3209 if this == nil { 3210 return "nil" 3211 } 3212 repeatedStringForViolations := "[]*PreconditionFailure_Violation{" 3213 for _, f := range this.Violations { 3214 repeatedStringForViolations += strings.Replace(fmt.Sprintf("%v", f), "PreconditionFailure_Violation", "PreconditionFailure_Violation", 1) + "," 3215 } 3216 repeatedStringForViolations += "}" 3217 s := strings.Join([]string{`&PreconditionFailure{`, 3218 `Violations:` + repeatedStringForViolations + `,`, 3219 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3220 `}`, 3221 }, "") 3222 return s 3223} 3224func (this *PreconditionFailure_Violation) String() string { 3225 if this == nil { 3226 return "nil" 3227 } 3228 s := strings.Join([]string{`&PreconditionFailure_Violation{`, 3229 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3230 `Subject:` + fmt.Sprintf("%v", this.Subject) + `,`, 3231 `Description:` + fmt.Sprintf("%v", this.Description) + `,`, 3232 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3233 `}`, 3234 }, "") 3235 return s 3236} 3237func (this *BadRequest) String() string { 3238 if this == nil { 3239 return "nil" 3240 } 3241 repeatedStringForFieldViolations := "[]*BadRequest_FieldViolation{" 3242 for _, f := range this.FieldViolations { 3243 repeatedStringForFieldViolations += strings.Replace(fmt.Sprintf("%v", f), "BadRequest_FieldViolation", "BadRequest_FieldViolation", 1) + "," 3244 } 3245 repeatedStringForFieldViolations += "}" 3246 s := strings.Join([]string{`&BadRequest{`, 3247 `FieldViolations:` + repeatedStringForFieldViolations + `,`, 3248 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3249 `}`, 3250 }, "") 3251 return s 3252} 3253func (this *BadRequest_FieldViolation) String() string { 3254 if this == nil { 3255 return "nil" 3256 } 3257 s := strings.Join([]string{`&BadRequest_FieldViolation{`, 3258 `Field:` + fmt.Sprintf("%v", this.Field) + `,`, 3259 `Description:` + fmt.Sprintf("%v", this.Description) + `,`, 3260 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3261 `}`, 3262 }, "") 3263 return s 3264} 3265func (this *RequestInfo) String() string { 3266 if this == nil { 3267 return "nil" 3268 } 3269 s := strings.Join([]string{`&RequestInfo{`, 3270 `RequestId:` + fmt.Sprintf("%v", this.RequestId) + `,`, 3271 `ServingData:` + fmt.Sprintf("%v", this.ServingData) + `,`, 3272 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3273 `}`, 3274 }, "") 3275 return s 3276} 3277func (this *ResourceInfo) String() string { 3278 if this == nil { 3279 return "nil" 3280 } 3281 s := strings.Join([]string{`&ResourceInfo{`, 3282 `ResourceType:` + fmt.Sprintf("%v", this.ResourceType) + `,`, 3283 `ResourceName:` + fmt.Sprintf("%v", this.ResourceName) + `,`, 3284 `Owner:` + fmt.Sprintf("%v", this.Owner) + `,`, 3285 `Description:` + fmt.Sprintf("%v", this.Description) + `,`, 3286 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3287 `}`, 3288 }, "") 3289 return s 3290} 3291func (this *Help) String() string { 3292 if this == nil { 3293 return "nil" 3294 } 3295 repeatedStringForLinks := "[]*Help_Link{" 3296 for _, f := range this.Links { 3297 repeatedStringForLinks += strings.Replace(fmt.Sprintf("%v", f), "Help_Link", "Help_Link", 1) + "," 3298 } 3299 repeatedStringForLinks += "}" 3300 s := strings.Join([]string{`&Help{`, 3301 `Links:` + repeatedStringForLinks + `,`, 3302 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3303 `}`, 3304 }, "") 3305 return s 3306} 3307func (this *Help_Link) String() string { 3308 if this == nil { 3309 return "nil" 3310 } 3311 s := strings.Join([]string{`&Help_Link{`, 3312 `Description:` + fmt.Sprintf("%v", this.Description) + `,`, 3313 `Url:` + fmt.Sprintf("%v", this.Url) + `,`, 3314 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3315 `}`, 3316 }, "") 3317 return s 3318} 3319func (this *LocalizedMessage) String() string { 3320 if this == nil { 3321 return "nil" 3322 } 3323 s := strings.Join([]string{`&LocalizedMessage{`, 3324 `Locale:` + fmt.Sprintf("%v", this.Locale) + `,`, 3325 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 3326 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 3327 `}`, 3328 }, "") 3329 return s 3330} 3331func valueToStringErrorDetails(v interface{}) string { 3332 rv := reflect.ValueOf(v) 3333 if rv.IsNil() { 3334 return "nil" 3335 } 3336 pv := reflect.Indirect(rv).Interface() 3337 return fmt.Sprintf("*%v", pv) 3338} 3339func (m *RetryInfo) Unmarshal(dAtA []byte) error { 3340 l := len(dAtA) 3341 iNdEx := 0 3342 for iNdEx < l { 3343 preIndex := iNdEx 3344 var wire uint64 3345 for shift := uint(0); ; shift += 7 { 3346 if shift >= 64 { 3347 return ErrIntOverflowErrorDetails 3348 } 3349 if iNdEx >= l { 3350 return io.ErrUnexpectedEOF 3351 } 3352 b := dAtA[iNdEx] 3353 iNdEx++ 3354 wire |= uint64(b&0x7F) << shift 3355 if b < 0x80 { 3356 break 3357 } 3358 } 3359 fieldNum := int32(wire >> 3) 3360 wireType := int(wire & 0x7) 3361 if wireType == 4 { 3362 return fmt.Errorf("proto: RetryInfo: wiretype end group for non-group") 3363 } 3364 if fieldNum <= 0 { 3365 return fmt.Errorf("proto: RetryInfo: illegal tag %d (wire type %d)", fieldNum, wire) 3366 } 3367 switch fieldNum { 3368 case 1: 3369 if wireType != 2 { 3370 return fmt.Errorf("proto: wrong wireType = %d for field RetryDelay", wireType) 3371 } 3372 var msglen int 3373 for shift := uint(0); ; shift += 7 { 3374 if shift >= 64 { 3375 return ErrIntOverflowErrorDetails 3376 } 3377 if iNdEx >= l { 3378 return io.ErrUnexpectedEOF 3379 } 3380 b := dAtA[iNdEx] 3381 iNdEx++ 3382 msglen |= int(b&0x7F) << shift 3383 if b < 0x80 { 3384 break 3385 } 3386 } 3387 if msglen < 0 { 3388 return ErrInvalidLengthErrorDetails 3389 } 3390 postIndex := iNdEx + msglen 3391 if postIndex < 0 { 3392 return ErrInvalidLengthErrorDetails 3393 } 3394 if postIndex > l { 3395 return io.ErrUnexpectedEOF 3396 } 3397 if m.RetryDelay == nil { 3398 m.RetryDelay = &types.Duration{} 3399 } 3400 if err := m.RetryDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3401 return err 3402 } 3403 iNdEx = postIndex 3404 default: 3405 iNdEx = preIndex 3406 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 3407 if err != nil { 3408 return err 3409 } 3410 if skippy < 0 { 3411 return ErrInvalidLengthErrorDetails 3412 } 3413 if (iNdEx + skippy) < 0 { 3414 return ErrInvalidLengthErrorDetails 3415 } 3416 if (iNdEx + skippy) > l { 3417 return io.ErrUnexpectedEOF 3418 } 3419 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3420 iNdEx += skippy 3421 } 3422 } 3423 3424 if iNdEx > l { 3425 return io.ErrUnexpectedEOF 3426 } 3427 return nil 3428} 3429func (m *DebugInfo) Unmarshal(dAtA []byte) error { 3430 l := len(dAtA) 3431 iNdEx := 0 3432 for iNdEx < l { 3433 preIndex := iNdEx 3434 var wire uint64 3435 for shift := uint(0); ; shift += 7 { 3436 if shift >= 64 { 3437 return ErrIntOverflowErrorDetails 3438 } 3439 if iNdEx >= l { 3440 return io.ErrUnexpectedEOF 3441 } 3442 b := dAtA[iNdEx] 3443 iNdEx++ 3444 wire |= uint64(b&0x7F) << shift 3445 if b < 0x80 { 3446 break 3447 } 3448 } 3449 fieldNum := int32(wire >> 3) 3450 wireType := int(wire & 0x7) 3451 if wireType == 4 { 3452 return fmt.Errorf("proto: DebugInfo: wiretype end group for non-group") 3453 } 3454 if fieldNum <= 0 { 3455 return fmt.Errorf("proto: DebugInfo: illegal tag %d (wire type %d)", fieldNum, wire) 3456 } 3457 switch fieldNum { 3458 case 1: 3459 if wireType != 2 { 3460 return fmt.Errorf("proto: wrong wireType = %d for field StackEntries", wireType) 3461 } 3462 var stringLen uint64 3463 for shift := uint(0); ; shift += 7 { 3464 if shift >= 64 { 3465 return ErrIntOverflowErrorDetails 3466 } 3467 if iNdEx >= l { 3468 return io.ErrUnexpectedEOF 3469 } 3470 b := dAtA[iNdEx] 3471 iNdEx++ 3472 stringLen |= uint64(b&0x7F) << shift 3473 if b < 0x80 { 3474 break 3475 } 3476 } 3477 intStringLen := int(stringLen) 3478 if intStringLen < 0 { 3479 return ErrInvalidLengthErrorDetails 3480 } 3481 postIndex := iNdEx + intStringLen 3482 if postIndex < 0 { 3483 return ErrInvalidLengthErrorDetails 3484 } 3485 if postIndex > l { 3486 return io.ErrUnexpectedEOF 3487 } 3488 m.StackEntries = append(m.StackEntries, string(dAtA[iNdEx:postIndex])) 3489 iNdEx = postIndex 3490 case 2: 3491 if wireType != 2 { 3492 return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType) 3493 } 3494 var stringLen uint64 3495 for shift := uint(0); ; shift += 7 { 3496 if shift >= 64 { 3497 return ErrIntOverflowErrorDetails 3498 } 3499 if iNdEx >= l { 3500 return io.ErrUnexpectedEOF 3501 } 3502 b := dAtA[iNdEx] 3503 iNdEx++ 3504 stringLen |= uint64(b&0x7F) << shift 3505 if b < 0x80 { 3506 break 3507 } 3508 } 3509 intStringLen := int(stringLen) 3510 if intStringLen < 0 { 3511 return ErrInvalidLengthErrorDetails 3512 } 3513 postIndex := iNdEx + intStringLen 3514 if postIndex < 0 { 3515 return ErrInvalidLengthErrorDetails 3516 } 3517 if postIndex > l { 3518 return io.ErrUnexpectedEOF 3519 } 3520 m.Detail = string(dAtA[iNdEx:postIndex]) 3521 iNdEx = postIndex 3522 default: 3523 iNdEx = preIndex 3524 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 3525 if err != nil { 3526 return err 3527 } 3528 if skippy < 0 { 3529 return ErrInvalidLengthErrorDetails 3530 } 3531 if (iNdEx + skippy) < 0 { 3532 return ErrInvalidLengthErrorDetails 3533 } 3534 if (iNdEx + skippy) > l { 3535 return io.ErrUnexpectedEOF 3536 } 3537 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3538 iNdEx += skippy 3539 } 3540 } 3541 3542 if iNdEx > l { 3543 return io.ErrUnexpectedEOF 3544 } 3545 return nil 3546} 3547func (m *QuotaFailure) Unmarshal(dAtA []byte) error { 3548 l := len(dAtA) 3549 iNdEx := 0 3550 for iNdEx < l { 3551 preIndex := iNdEx 3552 var wire uint64 3553 for shift := uint(0); ; shift += 7 { 3554 if shift >= 64 { 3555 return ErrIntOverflowErrorDetails 3556 } 3557 if iNdEx >= l { 3558 return io.ErrUnexpectedEOF 3559 } 3560 b := dAtA[iNdEx] 3561 iNdEx++ 3562 wire |= uint64(b&0x7F) << shift 3563 if b < 0x80 { 3564 break 3565 } 3566 } 3567 fieldNum := int32(wire >> 3) 3568 wireType := int(wire & 0x7) 3569 if wireType == 4 { 3570 return fmt.Errorf("proto: QuotaFailure: wiretype end group for non-group") 3571 } 3572 if fieldNum <= 0 { 3573 return fmt.Errorf("proto: QuotaFailure: illegal tag %d (wire type %d)", fieldNum, wire) 3574 } 3575 switch fieldNum { 3576 case 1: 3577 if wireType != 2 { 3578 return fmt.Errorf("proto: wrong wireType = %d for field Violations", wireType) 3579 } 3580 var msglen int 3581 for shift := uint(0); ; shift += 7 { 3582 if shift >= 64 { 3583 return ErrIntOverflowErrorDetails 3584 } 3585 if iNdEx >= l { 3586 return io.ErrUnexpectedEOF 3587 } 3588 b := dAtA[iNdEx] 3589 iNdEx++ 3590 msglen |= int(b&0x7F) << shift 3591 if b < 0x80 { 3592 break 3593 } 3594 } 3595 if msglen < 0 { 3596 return ErrInvalidLengthErrorDetails 3597 } 3598 postIndex := iNdEx + msglen 3599 if postIndex < 0 { 3600 return ErrInvalidLengthErrorDetails 3601 } 3602 if postIndex > l { 3603 return io.ErrUnexpectedEOF 3604 } 3605 m.Violations = append(m.Violations, &QuotaFailure_Violation{}) 3606 if err := m.Violations[len(m.Violations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3607 return err 3608 } 3609 iNdEx = postIndex 3610 default: 3611 iNdEx = preIndex 3612 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 3613 if err != nil { 3614 return err 3615 } 3616 if skippy < 0 { 3617 return ErrInvalidLengthErrorDetails 3618 } 3619 if (iNdEx + skippy) < 0 { 3620 return ErrInvalidLengthErrorDetails 3621 } 3622 if (iNdEx + skippy) > l { 3623 return io.ErrUnexpectedEOF 3624 } 3625 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3626 iNdEx += skippy 3627 } 3628 } 3629 3630 if iNdEx > l { 3631 return io.ErrUnexpectedEOF 3632 } 3633 return nil 3634} 3635func (m *QuotaFailure_Violation) Unmarshal(dAtA []byte) error { 3636 l := len(dAtA) 3637 iNdEx := 0 3638 for iNdEx < l { 3639 preIndex := iNdEx 3640 var wire uint64 3641 for shift := uint(0); ; shift += 7 { 3642 if shift >= 64 { 3643 return ErrIntOverflowErrorDetails 3644 } 3645 if iNdEx >= l { 3646 return io.ErrUnexpectedEOF 3647 } 3648 b := dAtA[iNdEx] 3649 iNdEx++ 3650 wire |= uint64(b&0x7F) << shift 3651 if b < 0x80 { 3652 break 3653 } 3654 } 3655 fieldNum := int32(wire >> 3) 3656 wireType := int(wire & 0x7) 3657 if wireType == 4 { 3658 return fmt.Errorf("proto: Violation: wiretype end group for non-group") 3659 } 3660 if fieldNum <= 0 { 3661 return fmt.Errorf("proto: Violation: illegal tag %d (wire type %d)", fieldNum, wire) 3662 } 3663 switch fieldNum { 3664 case 1: 3665 if wireType != 2 { 3666 return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType) 3667 } 3668 var stringLen uint64 3669 for shift := uint(0); ; shift += 7 { 3670 if shift >= 64 { 3671 return ErrIntOverflowErrorDetails 3672 } 3673 if iNdEx >= l { 3674 return io.ErrUnexpectedEOF 3675 } 3676 b := dAtA[iNdEx] 3677 iNdEx++ 3678 stringLen |= uint64(b&0x7F) << shift 3679 if b < 0x80 { 3680 break 3681 } 3682 } 3683 intStringLen := int(stringLen) 3684 if intStringLen < 0 { 3685 return ErrInvalidLengthErrorDetails 3686 } 3687 postIndex := iNdEx + intStringLen 3688 if postIndex < 0 { 3689 return ErrInvalidLengthErrorDetails 3690 } 3691 if postIndex > l { 3692 return io.ErrUnexpectedEOF 3693 } 3694 m.Subject = string(dAtA[iNdEx:postIndex]) 3695 iNdEx = postIndex 3696 case 2: 3697 if wireType != 2 { 3698 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) 3699 } 3700 var stringLen uint64 3701 for shift := uint(0); ; shift += 7 { 3702 if shift >= 64 { 3703 return ErrIntOverflowErrorDetails 3704 } 3705 if iNdEx >= l { 3706 return io.ErrUnexpectedEOF 3707 } 3708 b := dAtA[iNdEx] 3709 iNdEx++ 3710 stringLen |= uint64(b&0x7F) << shift 3711 if b < 0x80 { 3712 break 3713 } 3714 } 3715 intStringLen := int(stringLen) 3716 if intStringLen < 0 { 3717 return ErrInvalidLengthErrorDetails 3718 } 3719 postIndex := iNdEx + intStringLen 3720 if postIndex < 0 { 3721 return ErrInvalidLengthErrorDetails 3722 } 3723 if postIndex > l { 3724 return io.ErrUnexpectedEOF 3725 } 3726 m.Description = string(dAtA[iNdEx:postIndex]) 3727 iNdEx = postIndex 3728 default: 3729 iNdEx = preIndex 3730 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 3731 if err != nil { 3732 return err 3733 } 3734 if skippy < 0 { 3735 return ErrInvalidLengthErrorDetails 3736 } 3737 if (iNdEx + skippy) < 0 { 3738 return ErrInvalidLengthErrorDetails 3739 } 3740 if (iNdEx + skippy) > l { 3741 return io.ErrUnexpectedEOF 3742 } 3743 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3744 iNdEx += skippy 3745 } 3746 } 3747 3748 if iNdEx > l { 3749 return io.ErrUnexpectedEOF 3750 } 3751 return nil 3752} 3753func (m *PreconditionFailure) Unmarshal(dAtA []byte) error { 3754 l := len(dAtA) 3755 iNdEx := 0 3756 for iNdEx < l { 3757 preIndex := iNdEx 3758 var wire uint64 3759 for shift := uint(0); ; shift += 7 { 3760 if shift >= 64 { 3761 return ErrIntOverflowErrorDetails 3762 } 3763 if iNdEx >= l { 3764 return io.ErrUnexpectedEOF 3765 } 3766 b := dAtA[iNdEx] 3767 iNdEx++ 3768 wire |= uint64(b&0x7F) << shift 3769 if b < 0x80 { 3770 break 3771 } 3772 } 3773 fieldNum := int32(wire >> 3) 3774 wireType := int(wire & 0x7) 3775 if wireType == 4 { 3776 return fmt.Errorf("proto: PreconditionFailure: wiretype end group for non-group") 3777 } 3778 if fieldNum <= 0 { 3779 return fmt.Errorf("proto: PreconditionFailure: illegal tag %d (wire type %d)", fieldNum, wire) 3780 } 3781 switch fieldNum { 3782 case 1: 3783 if wireType != 2 { 3784 return fmt.Errorf("proto: wrong wireType = %d for field Violations", wireType) 3785 } 3786 var msglen int 3787 for shift := uint(0); ; shift += 7 { 3788 if shift >= 64 { 3789 return ErrIntOverflowErrorDetails 3790 } 3791 if iNdEx >= l { 3792 return io.ErrUnexpectedEOF 3793 } 3794 b := dAtA[iNdEx] 3795 iNdEx++ 3796 msglen |= int(b&0x7F) << shift 3797 if b < 0x80 { 3798 break 3799 } 3800 } 3801 if msglen < 0 { 3802 return ErrInvalidLengthErrorDetails 3803 } 3804 postIndex := iNdEx + msglen 3805 if postIndex < 0 { 3806 return ErrInvalidLengthErrorDetails 3807 } 3808 if postIndex > l { 3809 return io.ErrUnexpectedEOF 3810 } 3811 m.Violations = append(m.Violations, &PreconditionFailure_Violation{}) 3812 if err := m.Violations[len(m.Violations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3813 return err 3814 } 3815 iNdEx = postIndex 3816 default: 3817 iNdEx = preIndex 3818 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 3819 if err != nil { 3820 return err 3821 } 3822 if skippy < 0 { 3823 return ErrInvalidLengthErrorDetails 3824 } 3825 if (iNdEx + skippy) < 0 { 3826 return ErrInvalidLengthErrorDetails 3827 } 3828 if (iNdEx + skippy) > l { 3829 return io.ErrUnexpectedEOF 3830 } 3831 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3832 iNdEx += skippy 3833 } 3834 } 3835 3836 if iNdEx > l { 3837 return io.ErrUnexpectedEOF 3838 } 3839 return nil 3840} 3841func (m *PreconditionFailure_Violation) Unmarshal(dAtA []byte) error { 3842 l := len(dAtA) 3843 iNdEx := 0 3844 for iNdEx < l { 3845 preIndex := iNdEx 3846 var wire uint64 3847 for shift := uint(0); ; shift += 7 { 3848 if shift >= 64 { 3849 return ErrIntOverflowErrorDetails 3850 } 3851 if iNdEx >= l { 3852 return io.ErrUnexpectedEOF 3853 } 3854 b := dAtA[iNdEx] 3855 iNdEx++ 3856 wire |= uint64(b&0x7F) << shift 3857 if b < 0x80 { 3858 break 3859 } 3860 } 3861 fieldNum := int32(wire >> 3) 3862 wireType := int(wire & 0x7) 3863 if wireType == 4 { 3864 return fmt.Errorf("proto: Violation: wiretype end group for non-group") 3865 } 3866 if fieldNum <= 0 { 3867 return fmt.Errorf("proto: Violation: illegal tag %d (wire type %d)", fieldNum, wire) 3868 } 3869 switch fieldNum { 3870 case 1: 3871 if wireType != 2 { 3872 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 3873 } 3874 var stringLen uint64 3875 for shift := uint(0); ; shift += 7 { 3876 if shift >= 64 { 3877 return ErrIntOverflowErrorDetails 3878 } 3879 if iNdEx >= l { 3880 return io.ErrUnexpectedEOF 3881 } 3882 b := dAtA[iNdEx] 3883 iNdEx++ 3884 stringLen |= uint64(b&0x7F) << shift 3885 if b < 0x80 { 3886 break 3887 } 3888 } 3889 intStringLen := int(stringLen) 3890 if intStringLen < 0 { 3891 return ErrInvalidLengthErrorDetails 3892 } 3893 postIndex := iNdEx + intStringLen 3894 if postIndex < 0 { 3895 return ErrInvalidLengthErrorDetails 3896 } 3897 if postIndex > l { 3898 return io.ErrUnexpectedEOF 3899 } 3900 m.Type = string(dAtA[iNdEx:postIndex]) 3901 iNdEx = postIndex 3902 case 2: 3903 if wireType != 2 { 3904 return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType) 3905 } 3906 var stringLen uint64 3907 for shift := uint(0); ; shift += 7 { 3908 if shift >= 64 { 3909 return ErrIntOverflowErrorDetails 3910 } 3911 if iNdEx >= l { 3912 return io.ErrUnexpectedEOF 3913 } 3914 b := dAtA[iNdEx] 3915 iNdEx++ 3916 stringLen |= uint64(b&0x7F) << shift 3917 if b < 0x80 { 3918 break 3919 } 3920 } 3921 intStringLen := int(stringLen) 3922 if intStringLen < 0 { 3923 return ErrInvalidLengthErrorDetails 3924 } 3925 postIndex := iNdEx + intStringLen 3926 if postIndex < 0 { 3927 return ErrInvalidLengthErrorDetails 3928 } 3929 if postIndex > l { 3930 return io.ErrUnexpectedEOF 3931 } 3932 m.Subject = string(dAtA[iNdEx:postIndex]) 3933 iNdEx = postIndex 3934 case 3: 3935 if wireType != 2 { 3936 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) 3937 } 3938 var stringLen uint64 3939 for shift := uint(0); ; shift += 7 { 3940 if shift >= 64 { 3941 return ErrIntOverflowErrorDetails 3942 } 3943 if iNdEx >= l { 3944 return io.ErrUnexpectedEOF 3945 } 3946 b := dAtA[iNdEx] 3947 iNdEx++ 3948 stringLen |= uint64(b&0x7F) << shift 3949 if b < 0x80 { 3950 break 3951 } 3952 } 3953 intStringLen := int(stringLen) 3954 if intStringLen < 0 { 3955 return ErrInvalidLengthErrorDetails 3956 } 3957 postIndex := iNdEx + intStringLen 3958 if postIndex < 0 { 3959 return ErrInvalidLengthErrorDetails 3960 } 3961 if postIndex > l { 3962 return io.ErrUnexpectedEOF 3963 } 3964 m.Description = string(dAtA[iNdEx:postIndex]) 3965 iNdEx = postIndex 3966 default: 3967 iNdEx = preIndex 3968 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 3969 if err != nil { 3970 return err 3971 } 3972 if skippy < 0 { 3973 return ErrInvalidLengthErrorDetails 3974 } 3975 if (iNdEx + skippy) < 0 { 3976 return ErrInvalidLengthErrorDetails 3977 } 3978 if (iNdEx + skippy) > l { 3979 return io.ErrUnexpectedEOF 3980 } 3981 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3982 iNdEx += skippy 3983 } 3984 } 3985 3986 if iNdEx > l { 3987 return io.ErrUnexpectedEOF 3988 } 3989 return nil 3990} 3991func (m *BadRequest) Unmarshal(dAtA []byte) error { 3992 l := len(dAtA) 3993 iNdEx := 0 3994 for iNdEx < l { 3995 preIndex := iNdEx 3996 var wire uint64 3997 for shift := uint(0); ; shift += 7 { 3998 if shift >= 64 { 3999 return ErrIntOverflowErrorDetails 4000 } 4001 if iNdEx >= l { 4002 return io.ErrUnexpectedEOF 4003 } 4004 b := dAtA[iNdEx] 4005 iNdEx++ 4006 wire |= uint64(b&0x7F) << shift 4007 if b < 0x80 { 4008 break 4009 } 4010 } 4011 fieldNum := int32(wire >> 3) 4012 wireType := int(wire & 0x7) 4013 if wireType == 4 { 4014 return fmt.Errorf("proto: BadRequest: wiretype end group for non-group") 4015 } 4016 if fieldNum <= 0 { 4017 return fmt.Errorf("proto: BadRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4018 } 4019 switch fieldNum { 4020 case 1: 4021 if wireType != 2 { 4022 return fmt.Errorf("proto: wrong wireType = %d for field FieldViolations", wireType) 4023 } 4024 var msglen int 4025 for shift := uint(0); ; shift += 7 { 4026 if shift >= 64 { 4027 return ErrIntOverflowErrorDetails 4028 } 4029 if iNdEx >= l { 4030 return io.ErrUnexpectedEOF 4031 } 4032 b := dAtA[iNdEx] 4033 iNdEx++ 4034 msglen |= int(b&0x7F) << shift 4035 if b < 0x80 { 4036 break 4037 } 4038 } 4039 if msglen < 0 { 4040 return ErrInvalidLengthErrorDetails 4041 } 4042 postIndex := iNdEx + msglen 4043 if postIndex < 0 { 4044 return ErrInvalidLengthErrorDetails 4045 } 4046 if postIndex > l { 4047 return io.ErrUnexpectedEOF 4048 } 4049 m.FieldViolations = append(m.FieldViolations, &BadRequest_FieldViolation{}) 4050 if err := m.FieldViolations[len(m.FieldViolations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4051 return err 4052 } 4053 iNdEx = postIndex 4054 default: 4055 iNdEx = preIndex 4056 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4057 if err != nil { 4058 return err 4059 } 4060 if skippy < 0 { 4061 return ErrInvalidLengthErrorDetails 4062 } 4063 if (iNdEx + skippy) < 0 { 4064 return ErrInvalidLengthErrorDetails 4065 } 4066 if (iNdEx + skippy) > l { 4067 return io.ErrUnexpectedEOF 4068 } 4069 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4070 iNdEx += skippy 4071 } 4072 } 4073 4074 if iNdEx > l { 4075 return io.ErrUnexpectedEOF 4076 } 4077 return nil 4078} 4079func (m *BadRequest_FieldViolation) Unmarshal(dAtA []byte) error { 4080 l := len(dAtA) 4081 iNdEx := 0 4082 for iNdEx < l { 4083 preIndex := iNdEx 4084 var wire uint64 4085 for shift := uint(0); ; shift += 7 { 4086 if shift >= 64 { 4087 return ErrIntOverflowErrorDetails 4088 } 4089 if iNdEx >= l { 4090 return io.ErrUnexpectedEOF 4091 } 4092 b := dAtA[iNdEx] 4093 iNdEx++ 4094 wire |= uint64(b&0x7F) << shift 4095 if b < 0x80 { 4096 break 4097 } 4098 } 4099 fieldNum := int32(wire >> 3) 4100 wireType := int(wire & 0x7) 4101 if wireType == 4 { 4102 return fmt.Errorf("proto: FieldViolation: wiretype end group for non-group") 4103 } 4104 if fieldNum <= 0 { 4105 return fmt.Errorf("proto: FieldViolation: illegal tag %d (wire type %d)", fieldNum, wire) 4106 } 4107 switch fieldNum { 4108 case 1: 4109 if wireType != 2 { 4110 return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType) 4111 } 4112 var stringLen uint64 4113 for shift := uint(0); ; shift += 7 { 4114 if shift >= 64 { 4115 return ErrIntOverflowErrorDetails 4116 } 4117 if iNdEx >= l { 4118 return io.ErrUnexpectedEOF 4119 } 4120 b := dAtA[iNdEx] 4121 iNdEx++ 4122 stringLen |= uint64(b&0x7F) << shift 4123 if b < 0x80 { 4124 break 4125 } 4126 } 4127 intStringLen := int(stringLen) 4128 if intStringLen < 0 { 4129 return ErrInvalidLengthErrorDetails 4130 } 4131 postIndex := iNdEx + intStringLen 4132 if postIndex < 0 { 4133 return ErrInvalidLengthErrorDetails 4134 } 4135 if postIndex > l { 4136 return io.ErrUnexpectedEOF 4137 } 4138 m.Field = string(dAtA[iNdEx:postIndex]) 4139 iNdEx = postIndex 4140 case 2: 4141 if wireType != 2 { 4142 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) 4143 } 4144 var stringLen uint64 4145 for shift := uint(0); ; shift += 7 { 4146 if shift >= 64 { 4147 return ErrIntOverflowErrorDetails 4148 } 4149 if iNdEx >= l { 4150 return io.ErrUnexpectedEOF 4151 } 4152 b := dAtA[iNdEx] 4153 iNdEx++ 4154 stringLen |= uint64(b&0x7F) << shift 4155 if b < 0x80 { 4156 break 4157 } 4158 } 4159 intStringLen := int(stringLen) 4160 if intStringLen < 0 { 4161 return ErrInvalidLengthErrorDetails 4162 } 4163 postIndex := iNdEx + intStringLen 4164 if postIndex < 0 { 4165 return ErrInvalidLengthErrorDetails 4166 } 4167 if postIndex > l { 4168 return io.ErrUnexpectedEOF 4169 } 4170 m.Description = string(dAtA[iNdEx:postIndex]) 4171 iNdEx = postIndex 4172 default: 4173 iNdEx = preIndex 4174 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4175 if err != nil { 4176 return err 4177 } 4178 if skippy < 0 { 4179 return ErrInvalidLengthErrorDetails 4180 } 4181 if (iNdEx + skippy) < 0 { 4182 return ErrInvalidLengthErrorDetails 4183 } 4184 if (iNdEx + skippy) > l { 4185 return io.ErrUnexpectedEOF 4186 } 4187 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4188 iNdEx += skippy 4189 } 4190 } 4191 4192 if iNdEx > l { 4193 return io.ErrUnexpectedEOF 4194 } 4195 return nil 4196} 4197func (m *RequestInfo) Unmarshal(dAtA []byte) error { 4198 l := len(dAtA) 4199 iNdEx := 0 4200 for iNdEx < l { 4201 preIndex := iNdEx 4202 var wire uint64 4203 for shift := uint(0); ; shift += 7 { 4204 if shift >= 64 { 4205 return ErrIntOverflowErrorDetails 4206 } 4207 if iNdEx >= l { 4208 return io.ErrUnexpectedEOF 4209 } 4210 b := dAtA[iNdEx] 4211 iNdEx++ 4212 wire |= uint64(b&0x7F) << shift 4213 if b < 0x80 { 4214 break 4215 } 4216 } 4217 fieldNum := int32(wire >> 3) 4218 wireType := int(wire & 0x7) 4219 if wireType == 4 { 4220 return fmt.Errorf("proto: RequestInfo: wiretype end group for non-group") 4221 } 4222 if fieldNum <= 0 { 4223 return fmt.Errorf("proto: RequestInfo: illegal tag %d (wire type %d)", fieldNum, wire) 4224 } 4225 switch fieldNum { 4226 case 1: 4227 if wireType != 2 { 4228 return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType) 4229 } 4230 var stringLen uint64 4231 for shift := uint(0); ; shift += 7 { 4232 if shift >= 64 { 4233 return ErrIntOverflowErrorDetails 4234 } 4235 if iNdEx >= l { 4236 return io.ErrUnexpectedEOF 4237 } 4238 b := dAtA[iNdEx] 4239 iNdEx++ 4240 stringLen |= uint64(b&0x7F) << shift 4241 if b < 0x80 { 4242 break 4243 } 4244 } 4245 intStringLen := int(stringLen) 4246 if intStringLen < 0 { 4247 return ErrInvalidLengthErrorDetails 4248 } 4249 postIndex := iNdEx + intStringLen 4250 if postIndex < 0 { 4251 return ErrInvalidLengthErrorDetails 4252 } 4253 if postIndex > l { 4254 return io.ErrUnexpectedEOF 4255 } 4256 m.RequestId = string(dAtA[iNdEx:postIndex]) 4257 iNdEx = postIndex 4258 case 2: 4259 if wireType != 2 { 4260 return fmt.Errorf("proto: wrong wireType = %d for field ServingData", wireType) 4261 } 4262 var stringLen uint64 4263 for shift := uint(0); ; shift += 7 { 4264 if shift >= 64 { 4265 return ErrIntOverflowErrorDetails 4266 } 4267 if iNdEx >= l { 4268 return io.ErrUnexpectedEOF 4269 } 4270 b := dAtA[iNdEx] 4271 iNdEx++ 4272 stringLen |= uint64(b&0x7F) << shift 4273 if b < 0x80 { 4274 break 4275 } 4276 } 4277 intStringLen := int(stringLen) 4278 if intStringLen < 0 { 4279 return ErrInvalidLengthErrorDetails 4280 } 4281 postIndex := iNdEx + intStringLen 4282 if postIndex < 0 { 4283 return ErrInvalidLengthErrorDetails 4284 } 4285 if postIndex > l { 4286 return io.ErrUnexpectedEOF 4287 } 4288 m.ServingData = string(dAtA[iNdEx:postIndex]) 4289 iNdEx = postIndex 4290 default: 4291 iNdEx = preIndex 4292 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4293 if err != nil { 4294 return err 4295 } 4296 if skippy < 0 { 4297 return ErrInvalidLengthErrorDetails 4298 } 4299 if (iNdEx + skippy) < 0 { 4300 return ErrInvalidLengthErrorDetails 4301 } 4302 if (iNdEx + skippy) > l { 4303 return io.ErrUnexpectedEOF 4304 } 4305 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4306 iNdEx += skippy 4307 } 4308 } 4309 4310 if iNdEx > l { 4311 return io.ErrUnexpectedEOF 4312 } 4313 return nil 4314} 4315func (m *ResourceInfo) Unmarshal(dAtA []byte) error { 4316 l := len(dAtA) 4317 iNdEx := 0 4318 for iNdEx < l { 4319 preIndex := iNdEx 4320 var wire uint64 4321 for shift := uint(0); ; shift += 7 { 4322 if shift >= 64 { 4323 return ErrIntOverflowErrorDetails 4324 } 4325 if iNdEx >= l { 4326 return io.ErrUnexpectedEOF 4327 } 4328 b := dAtA[iNdEx] 4329 iNdEx++ 4330 wire |= uint64(b&0x7F) << shift 4331 if b < 0x80 { 4332 break 4333 } 4334 } 4335 fieldNum := int32(wire >> 3) 4336 wireType := int(wire & 0x7) 4337 if wireType == 4 { 4338 return fmt.Errorf("proto: ResourceInfo: wiretype end group for non-group") 4339 } 4340 if fieldNum <= 0 { 4341 return fmt.Errorf("proto: ResourceInfo: illegal tag %d (wire type %d)", fieldNum, wire) 4342 } 4343 switch fieldNum { 4344 case 1: 4345 if wireType != 2 { 4346 return fmt.Errorf("proto: wrong wireType = %d for field ResourceType", wireType) 4347 } 4348 var stringLen uint64 4349 for shift := uint(0); ; shift += 7 { 4350 if shift >= 64 { 4351 return ErrIntOverflowErrorDetails 4352 } 4353 if iNdEx >= l { 4354 return io.ErrUnexpectedEOF 4355 } 4356 b := dAtA[iNdEx] 4357 iNdEx++ 4358 stringLen |= uint64(b&0x7F) << shift 4359 if b < 0x80 { 4360 break 4361 } 4362 } 4363 intStringLen := int(stringLen) 4364 if intStringLen < 0 { 4365 return ErrInvalidLengthErrorDetails 4366 } 4367 postIndex := iNdEx + intStringLen 4368 if postIndex < 0 { 4369 return ErrInvalidLengthErrorDetails 4370 } 4371 if postIndex > l { 4372 return io.ErrUnexpectedEOF 4373 } 4374 m.ResourceType = string(dAtA[iNdEx:postIndex]) 4375 iNdEx = postIndex 4376 case 2: 4377 if wireType != 2 { 4378 return fmt.Errorf("proto: wrong wireType = %d for field ResourceName", wireType) 4379 } 4380 var stringLen uint64 4381 for shift := uint(0); ; shift += 7 { 4382 if shift >= 64 { 4383 return ErrIntOverflowErrorDetails 4384 } 4385 if iNdEx >= l { 4386 return io.ErrUnexpectedEOF 4387 } 4388 b := dAtA[iNdEx] 4389 iNdEx++ 4390 stringLen |= uint64(b&0x7F) << shift 4391 if b < 0x80 { 4392 break 4393 } 4394 } 4395 intStringLen := int(stringLen) 4396 if intStringLen < 0 { 4397 return ErrInvalidLengthErrorDetails 4398 } 4399 postIndex := iNdEx + intStringLen 4400 if postIndex < 0 { 4401 return ErrInvalidLengthErrorDetails 4402 } 4403 if postIndex > l { 4404 return io.ErrUnexpectedEOF 4405 } 4406 m.ResourceName = string(dAtA[iNdEx:postIndex]) 4407 iNdEx = postIndex 4408 case 3: 4409 if wireType != 2 { 4410 return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) 4411 } 4412 var stringLen uint64 4413 for shift := uint(0); ; shift += 7 { 4414 if shift >= 64 { 4415 return ErrIntOverflowErrorDetails 4416 } 4417 if iNdEx >= l { 4418 return io.ErrUnexpectedEOF 4419 } 4420 b := dAtA[iNdEx] 4421 iNdEx++ 4422 stringLen |= uint64(b&0x7F) << shift 4423 if b < 0x80 { 4424 break 4425 } 4426 } 4427 intStringLen := int(stringLen) 4428 if intStringLen < 0 { 4429 return ErrInvalidLengthErrorDetails 4430 } 4431 postIndex := iNdEx + intStringLen 4432 if postIndex < 0 { 4433 return ErrInvalidLengthErrorDetails 4434 } 4435 if postIndex > l { 4436 return io.ErrUnexpectedEOF 4437 } 4438 m.Owner = string(dAtA[iNdEx:postIndex]) 4439 iNdEx = postIndex 4440 case 4: 4441 if wireType != 2 { 4442 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) 4443 } 4444 var stringLen uint64 4445 for shift := uint(0); ; shift += 7 { 4446 if shift >= 64 { 4447 return ErrIntOverflowErrorDetails 4448 } 4449 if iNdEx >= l { 4450 return io.ErrUnexpectedEOF 4451 } 4452 b := dAtA[iNdEx] 4453 iNdEx++ 4454 stringLen |= uint64(b&0x7F) << shift 4455 if b < 0x80 { 4456 break 4457 } 4458 } 4459 intStringLen := int(stringLen) 4460 if intStringLen < 0 { 4461 return ErrInvalidLengthErrorDetails 4462 } 4463 postIndex := iNdEx + intStringLen 4464 if postIndex < 0 { 4465 return ErrInvalidLengthErrorDetails 4466 } 4467 if postIndex > l { 4468 return io.ErrUnexpectedEOF 4469 } 4470 m.Description = string(dAtA[iNdEx:postIndex]) 4471 iNdEx = postIndex 4472 default: 4473 iNdEx = preIndex 4474 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4475 if err != nil { 4476 return err 4477 } 4478 if skippy < 0 { 4479 return ErrInvalidLengthErrorDetails 4480 } 4481 if (iNdEx + skippy) < 0 { 4482 return ErrInvalidLengthErrorDetails 4483 } 4484 if (iNdEx + skippy) > l { 4485 return io.ErrUnexpectedEOF 4486 } 4487 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4488 iNdEx += skippy 4489 } 4490 } 4491 4492 if iNdEx > l { 4493 return io.ErrUnexpectedEOF 4494 } 4495 return nil 4496} 4497func (m *Help) Unmarshal(dAtA []byte) error { 4498 l := len(dAtA) 4499 iNdEx := 0 4500 for iNdEx < l { 4501 preIndex := iNdEx 4502 var wire uint64 4503 for shift := uint(0); ; shift += 7 { 4504 if shift >= 64 { 4505 return ErrIntOverflowErrorDetails 4506 } 4507 if iNdEx >= l { 4508 return io.ErrUnexpectedEOF 4509 } 4510 b := dAtA[iNdEx] 4511 iNdEx++ 4512 wire |= uint64(b&0x7F) << shift 4513 if b < 0x80 { 4514 break 4515 } 4516 } 4517 fieldNum := int32(wire >> 3) 4518 wireType := int(wire & 0x7) 4519 if wireType == 4 { 4520 return fmt.Errorf("proto: Help: wiretype end group for non-group") 4521 } 4522 if fieldNum <= 0 { 4523 return fmt.Errorf("proto: Help: illegal tag %d (wire type %d)", fieldNum, wire) 4524 } 4525 switch fieldNum { 4526 case 1: 4527 if wireType != 2 { 4528 return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType) 4529 } 4530 var msglen int 4531 for shift := uint(0); ; shift += 7 { 4532 if shift >= 64 { 4533 return ErrIntOverflowErrorDetails 4534 } 4535 if iNdEx >= l { 4536 return io.ErrUnexpectedEOF 4537 } 4538 b := dAtA[iNdEx] 4539 iNdEx++ 4540 msglen |= int(b&0x7F) << shift 4541 if b < 0x80 { 4542 break 4543 } 4544 } 4545 if msglen < 0 { 4546 return ErrInvalidLengthErrorDetails 4547 } 4548 postIndex := iNdEx + msglen 4549 if postIndex < 0 { 4550 return ErrInvalidLengthErrorDetails 4551 } 4552 if postIndex > l { 4553 return io.ErrUnexpectedEOF 4554 } 4555 m.Links = append(m.Links, &Help_Link{}) 4556 if err := m.Links[len(m.Links)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4557 return err 4558 } 4559 iNdEx = postIndex 4560 default: 4561 iNdEx = preIndex 4562 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4563 if err != nil { 4564 return err 4565 } 4566 if skippy < 0 { 4567 return ErrInvalidLengthErrorDetails 4568 } 4569 if (iNdEx + skippy) < 0 { 4570 return ErrInvalidLengthErrorDetails 4571 } 4572 if (iNdEx + skippy) > l { 4573 return io.ErrUnexpectedEOF 4574 } 4575 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4576 iNdEx += skippy 4577 } 4578 } 4579 4580 if iNdEx > l { 4581 return io.ErrUnexpectedEOF 4582 } 4583 return nil 4584} 4585func (m *Help_Link) Unmarshal(dAtA []byte) error { 4586 l := len(dAtA) 4587 iNdEx := 0 4588 for iNdEx < l { 4589 preIndex := iNdEx 4590 var wire uint64 4591 for shift := uint(0); ; shift += 7 { 4592 if shift >= 64 { 4593 return ErrIntOverflowErrorDetails 4594 } 4595 if iNdEx >= l { 4596 return io.ErrUnexpectedEOF 4597 } 4598 b := dAtA[iNdEx] 4599 iNdEx++ 4600 wire |= uint64(b&0x7F) << shift 4601 if b < 0x80 { 4602 break 4603 } 4604 } 4605 fieldNum := int32(wire >> 3) 4606 wireType := int(wire & 0x7) 4607 if wireType == 4 { 4608 return fmt.Errorf("proto: Link: wiretype end group for non-group") 4609 } 4610 if fieldNum <= 0 { 4611 return fmt.Errorf("proto: Link: illegal tag %d (wire type %d)", fieldNum, wire) 4612 } 4613 switch fieldNum { 4614 case 1: 4615 if wireType != 2 { 4616 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) 4617 } 4618 var stringLen uint64 4619 for shift := uint(0); ; shift += 7 { 4620 if shift >= 64 { 4621 return ErrIntOverflowErrorDetails 4622 } 4623 if iNdEx >= l { 4624 return io.ErrUnexpectedEOF 4625 } 4626 b := dAtA[iNdEx] 4627 iNdEx++ 4628 stringLen |= uint64(b&0x7F) << shift 4629 if b < 0x80 { 4630 break 4631 } 4632 } 4633 intStringLen := int(stringLen) 4634 if intStringLen < 0 { 4635 return ErrInvalidLengthErrorDetails 4636 } 4637 postIndex := iNdEx + intStringLen 4638 if postIndex < 0 { 4639 return ErrInvalidLengthErrorDetails 4640 } 4641 if postIndex > l { 4642 return io.ErrUnexpectedEOF 4643 } 4644 m.Description = string(dAtA[iNdEx:postIndex]) 4645 iNdEx = postIndex 4646 case 2: 4647 if wireType != 2 { 4648 return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType) 4649 } 4650 var stringLen uint64 4651 for shift := uint(0); ; shift += 7 { 4652 if shift >= 64 { 4653 return ErrIntOverflowErrorDetails 4654 } 4655 if iNdEx >= l { 4656 return io.ErrUnexpectedEOF 4657 } 4658 b := dAtA[iNdEx] 4659 iNdEx++ 4660 stringLen |= uint64(b&0x7F) << shift 4661 if b < 0x80 { 4662 break 4663 } 4664 } 4665 intStringLen := int(stringLen) 4666 if intStringLen < 0 { 4667 return ErrInvalidLengthErrorDetails 4668 } 4669 postIndex := iNdEx + intStringLen 4670 if postIndex < 0 { 4671 return ErrInvalidLengthErrorDetails 4672 } 4673 if postIndex > l { 4674 return io.ErrUnexpectedEOF 4675 } 4676 m.Url = string(dAtA[iNdEx:postIndex]) 4677 iNdEx = postIndex 4678 default: 4679 iNdEx = preIndex 4680 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4681 if err != nil { 4682 return err 4683 } 4684 if skippy < 0 { 4685 return ErrInvalidLengthErrorDetails 4686 } 4687 if (iNdEx + skippy) < 0 { 4688 return ErrInvalidLengthErrorDetails 4689 } 4690 if (iNdEx + skippy) > l { 4691 return io.ErrUnexpectedEOF 4692 } 4693 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4694 iNdEx += skippy 4695 } 4696 } 4697 4698 if iNdEx > l { 4699 return io.ErrUnexpectedEOF 4700 } 4701 return nil 4702} 4703func (m *LocalizedMessage) Unmarshal(dAtA []byte) error { 4704 l := len(dAtA) 4705 iNdEx := 0 4706 for iNdEx < l { 4707 preIndex := iNdEx 4708 var wire uint64 4709 for shift := uint(0); ; shift += 7 { 4710 if shift >= 64 { 4711 return ErrIntOverflowErrorDetails 4712 } 4713 if iNdEx >= l { 4714 return io.ErrUnexpectedEOF 4715 } 4716 b := dAtA[iNdEx] 4717 iNdEx++ 4718 wire |= uint64(b&0x7F) << shift 4719 if b < 0x80 { 4720 break 4721 } 4722 } 4723 fieldNum := int32(wire >> 3) 4724 wireType := int(wire & 0x7) 4725 if wireType == 4 { 4726 return fmt.Errorf("proto: LocalizedMessage: wiretype end group for non-group") 4727 } 4728 if fieldNum <= 0 { 4729 return fmt.Errorf("proto: LocalizedMessage: illegal tag %d (wire type %d)", fieldNum, wire) 4730 } 4731 switch fieldNum { 4732 case 1: 4733 if wireType != 2 { 4734 return fmt.Errorf("proto: wrong wireType = %d for field Locale", wireType) 4735 } 4736 var stringLen uint64 4737 for shift := uint(0); ; shift += 7 { 4738 if shift >= 64 { 4739 return ErrIntOverflowErrorDetails 4740 } 4741 if iNdEx >= l { 4742 return io.ErrUnexpectedEOF 4743 } 4744 b := dAtA[iNdEx] 4745 iNdEx++ 4746 stringLen |= uint64(b&0x7F) << shift 4747 if b < 0x80 { 4748 break 4749 } 4750 } 4751 intStringLen := int(stringLen) 4752 if intStringLen < 0 { 4753 return ErrInvalidLengthErrorDetails 4754 } 4755 postIndex := iNdEx + intStringLen 4756 if postIndex < 0 { 4757 return ErrInvalidLengthErrorDetails 4758 } 4759 if postIndex > l { 4760 return io.ErrUnexpectedEOF 4761 } 4762 m.Locale = string(dAtA[iNdEx:postIndex]) 4763 iNdEx = postIndex 4764 case 2: 4765 if wireType != 2 { 4766 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 4767 } 4768 var stringLen uint64 4769 for shift := uint(0); ; shift += 7 { 4770 if shift >= 64 { 4771 return ErrIntOverflowErrorDetails 4772 } 4773 if iNdEx >= l { 4774 return io.ErrUnexpectedEOF 4775 } 4776 b := dAtA[iNdEx] 4777 iNdEx++ 4778 stringLen |= uint64(b&0x7F) << shift 4779 if b < 0x80 { 4780 break 4781 } 4782 } 4783 intStringLen := int(stringLen) 4784 if intStringLen < 0 { 4785 return ErrInvalidLengthErrorDetails 4786 } 4787 postIndex := iNdEx + intStringLen 4788 if postIndex < 0 { 4789 return ErrInvalidLengthErrorDetails 4790 } 4791 if postIndex > l { 4792 return io.ErrUnexpectedEOF 4793 } 4794 m.Message = string(dAtA[iNdEx:postIndex]) 4795 iNdEx = postIndex 4796 default: 4797 iNdEx = preIndex 4798 skippy, err := skipErrorDetails(dAtA[iNdEx:]) 4799 if err != nil { 4800 return err 4801 } 4802 if skippy < 0 { 4803 return ErrInvalidLengthErrorDetails 4804 } 4805 if (iNdEx + skippy) < 0 { 4806 return ErrInvalidLengthErrorDetails 4807 } 4808 if (iNdEx + skippy) > l { 4809 return io.ErrUnexpectedEOF 4810 } 4811 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4812 iNdEx += skippy 4813 } 4814 } 4815 4816 if iNdEx > l { 4817 return io.ErrUnexpectedEOF 4818 } 4819 return nil 4820} 4821func skipErrorDetails(dAtA []byte) (n int, err error) { 4822 l := len(dAtA) 4823 iNdEx := 0 4824 depth := 0 4825 for iNdEx < l { 4826 var wire uint64 4827 for shift := uint(0); ; shift += 7 { 4828 if shift >= 64 { 4829 return 0, ErrIntOverflowErrorDetails 4830 } 4831 if iNdEx >= l { 4832 return 0, io.ErrUnexpectedEOF 4833 } 4834 b := dAtA[iNdEx] 4835 iNdEx++ 4836 wire |= (uint64(b) & 0x7F) << shift 4837 if b < 0x80 { 4838 break 4839 } 4840 } 4841 wireType := int(wire & 0x7) 4842 switch wireType { 4843 case 0: 4844 for shift := uint(0); ; shift += 7 { 4845 if shift >= 64 { 4846 return 0, ErrIntOverflowErrorDetails 4847 } 4848 if iNdEx >= l { 4849 return 0, io.ErrUnexpectedEOF 4850 } 4851 iNdEx++ 4852 if dAtA[iNdEx-1] < 0x80 { 4853 break 4854 } 4855 } 4856 case 1: 4857 iNdEx += 8 4858 case 2: 4859 var length int 4860 for shift := uint(0); ; shift += 7 { 4861 if shift >= 64 { 4862 return 0, ErrIntOverflowErrorDetails 4863 } 4864 if iNdEx >= l { 4865 return 0, io.ErrUnexpectedEOF 4866 } 4867 b := dAtA[iNdEx] 4868 iNdEx++ 4869 length |= (int(b) & 0x7F) << shift 4870 if b < 0x80 { 4871 break 4872 } 4873 } 4874 if length < 0 { 4875 return 0, ErrInvalidLengthErrorDetails 4876 } 4877 iNdEx += length 4878 case 3: 4879 depth++ 4880 case 4: 4881 if depth == 0 { 4882 return 0, ErrUnexpectedEndOfGroupErrorDetails 4883 } 4884 depth-- 4885 case 5: 4886 iNdEx += 4 4887 default: 4888 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 4889 } 4890 if iNdEx < 0 { 4891 return 0, ErrInvalidLengthErrorDetails 4892 } 4893 if depth == 0 { 4894 return iNdEx, nil 4895 } 4896 } 4897 return 0, io.ErrUnexpectedEOF 4898} 4899 4900var ( 4901 ErrInvalidLengthErrorDetails = fmt.Errorf("proto: negative length found during unmarshaling") 4902 ErrIntOverflowErrorDetails = fmt.Errorf("proto: integer overflow") 4903 ErrUnexpectedEndOfGroupErrorDetails = fmt.Errorf("proto: unexpected end of group") 4904) 4905