1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: google/protobuf/wrappers.proto 3 4package types 5 6import proto "github.com/gogo/protobuf/proto" 7import fmt "fmt" 8import math "math" 9 10import bytes "bytes" 11 12import strings "strings" 13import reflect "reflect" 14 15import encoding_binary "encoding/binary" 16 17import io "io" 18 19// Reference imports to suppress errors if they are not otherwise used. 20var _ = proto.Marshal 21var _ = fmt.Errorf 22var _ = math.Inf 23 24// This is a compile-time assertion to ensure that this generated file 25// is compatible with the proto package it is being compiled against. 26// A compilation error at this line likely means your copy of the 27// proto package needs to be updated. 28const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 29 30// Wrapper message for `double`. 31// 32// The JSON representation for `DoubleValue` is JSON number. 33type DoubleValue struct { 34 // The double value. 35 Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"` 36 XXX_NoUnkeyedLiteral struct{} `json:"-"` 37 XXX_unrecognized []byte `json:"-"` 38 XXX_sizecache int32 `json:"-"` 39} 40 41func (m *DoubleValue) Reset() { *m = DoubleValue{} } 42func (*DoubleValue) ProtoMessage() {} 43func (*DoubleValue) Descriptor() ([]byte, []int) { 44 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{0} 45} 46func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" } 47func (m *DoubleValue) XXX_Unmarshal(b []byte) error { 48 return m.Unmarshal(b) 49} 50func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 51 if deterministic { 52 return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic) 53 } else { 54 b = b[:cap(b)] 55 n, err := m.MarshalTo(b) 56 if err != nil { 57 return nil, err 58 } 59 return b[:n], nil 60 } 61} 62func (dst *DoubleValue) XXX_Merge(src proto.Message) { 63 xxx_messageInfo_DoubleValue.Merge(dst, src) 64} 65func (m *DoubleValue) XXX_Size() int { 66 return m.Size() 67} 68func (m *DoubleValue) XXX_DiscardUnknown() { 69 xxx_messageInfo_DoubleValue.DiscardUnknown(m) 70} 71 72var xxx_messageInfo_DoubleValue proto.InternalMessageInfo 73 74func (m *DoubleValue) GetValue() float64 { 75 if m != nil { 76 return m.Value 77 } 78 return 0 79} 80 81func (*DoubleValue) XXX_MessageName() string { 82 return "google.protobuf.DoubleValue" 83} 84 85// Wrapper message for `float`. 86// 87// The JSON representation for `FloatValue` is JSON number. 88type FloatValue struct { 89 // The float value. 90 Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"` 91 XXX_NoUnkeyedLiteral struct{} `json:"-"` 92 XXX_unrecognized []byte `json:"-"` 93 XXX_sizecache int32 `json:"-"` 94} 95 96func (m *FloatValue) Reset() { *m = FloatValue{} } 97func (*FloatValue) ProtoMessage() {} 98func (*FloatValue) Descriptor() ([]byte, []int) { 99 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{1} 100} 101func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" } 102func (m *FloatValue) XXX_Unmarshal(b []byte) error { 103 return m.Unmarshal(b) 104} 105func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 106 if deterministic { 107 return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic) 108 } else { 109 b = b[:cap(b)] 110 n, err := m.MarshalTo(b) 111 if err != nil { 112 return nil, err 113 } 114 return b[:n], nil 115 } 116} 117func (dst *FloatValue) XXX_Merge(src proto.Message) { 118 xxx_messageInfo_FloatValue.Merge(dst, src) 119} 120func (m *FloatValue) XXX_Size() int { 121 return m.Size() 122} 123func (m *FloatValue) XXX_DiscardUnknown() { 124 xxx_messageInfo_FloatValue.DiscardUnknown(m) 125} 126 127var xxx_messageInfo_FloatValue proto.InternalMessageInfo 128 129func (m *FloatValue) GetValue() float32 { 130 if m != nil { 131 return m.Value 132 } 133 return 0 134} 135 136func (*FloatValue) XXX_MessageName() string { 137 return "google.protobuf.FloatValue" 138} 139 140// Wrapper message for `int64`. 141// 142// The JSON representation for `Int64Value` is JSON string. 143type Int64Value struct { 144 // The int64 value. 145 Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 146 XXX_NoUnkeyedLiteral struct{} `json:"-"` 147 XXX_unrecognized []byte `json:"-"` 148 XXX_sizecache int32 `json:"-"` 149} 150 151func (m *Int64Value) Reset() { *m = Int64Value{} } 152func (*Int64Value) ProtoMessage() {} 153func (*Int64Value) Descriptor() ([]byte, []int) { 154 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{2} 155} 156func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" } 157func (m *Int64Value) XXX_Unmarshal(b []byte) error { 158 return m.Unmarshal(b) 159} 160func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 161 if deterministic { 162 return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic) 163 } else { 164 b = b[:cap(b)] 165 n, err := m.MarshalTo(b) 166 if err != nil { 167 return nil, err 168 } 169 return b[:n], nil 170 } 171} 172func (dst *Int64Value) XXX_Merge(src proto.Message) { 173 xxx_messageInfo_Int64Value.Merge(dst, src) 174} 175func (m *Int64Value) XXX_Size() int { 176 return m.Size() 177} 178func (m *Int64Value) XXX_DiscardUnknown() { 179 xxx_messageInfo_Int64Value.DiscardUnknown(m) 180} 181 182var xxx_messageInfo_Int64Value proto.InternalMessageInfo 183 184func (m *Int64Value) GetValue() int64 { 185 if m != nil { 186 return m.Value 187 } 188 return 0 189} 190 191func (*Int64Value) XXX_MessageName() string { 192 return "google.protobuf.Int64Value" 193} 194 195// Wrapper message for `uint64`. 196// 197// The JSON representation for `UInt64Value` is JSON string. 198type UInt64Value struct { 199 // The uint64 value. 200 Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 201 XXX_NoUnkeyedLiteral struct{} `json:"-"` 202 XXX_unrecognized []byte `json:"-"` 203 XXX_sizecache int32 `json:"-"` 204} 205 206func (m *UInt64Value) Reset() { *m = UInt64Value{} } 207func (*UInt64Value) ProtoMessage() {} 208func (*UInt64Value) Descriptor() ([]byte, []int) { 209 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{3} 210} 211func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" } 212func (m *UInt64Value) XXX_Unmarshal(b []byte) error { 213 return m.Unmarshal(b) 214} 215func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 216 if deterministic { 217 return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic) 218 } else { 219 b = b[:cap(b)] 220 n, err := m.MarshalTo(b) 221 if err != nil { 222 return nil, err 223 } 224 return b[:n], nil 225 } 226} 227func (dst *UInt64Value) XXX_Merge(src proto.Message) { 228 xxx_messageInfo_UInt64Value.Merge(dst, src) 229} 230func (m *UInt64Value) XXX_Size() int { 231 return m.Size() 232} 233func (m *UInt64Value) XXX_DiscardUnknown() { 234 xxx_messageInfo_UInt64Value.DiscardUnknown(m) 235} 236 237var xxx_messageInfo_UInt64Value proto.InternalMessageInfo 238 239func (m *UInt64Value) GetValue() uint64 { 240 if m != nil { 241 return m.Value 242 } 243 return 0 244} 245 246func (*UInt64Value) XXX_MessageName() string { 247 return "google.protobuf.UInt64Value" 248} 249 250// Wrapper message for `int32`. 251// 252// The JSON representation for `Int32Value` is JSON number. 253type Int32Value struct { 254 // The int32 value. 255 Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 256 XXX_NoUnkeyedLiteral struct{} `json:"-"` 257 XXX_unrecognized []byte `json:"-"` 258 XXX_sizecache int32 `json:"-"` 259} 260 261func (m *Int32Value) Reset() { *m = Int32Value{} } 262func (*Int32Value) ProtoMessage() {} 263func (*Int32Value) Descriptor() ([]byte, []int) { 264 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{4} 265} 266func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" } 267func (m *Int32Value) XXX_Unmarshal(b []byte) error { 268 return m.Unmarshal(b) 269} 270func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 271 if deterministic { 272 return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic) 273 } else { 274 b = b[:cap(b)] 275 n, err := m.MarshalTo(b) 276 if err != nil { 277 return nil, err 278 } 279 return b[:n], nil 280 } 281} 282func (dst *Int32Value) XXX_Merge(src proto.Message) { 283 xxx_messageInfo_Int32Value.Merge(dst, src) 284} 285func (m *Int32Value) XXX_Size() int { 286 return m.Size() 287} 288func (m *Int32Value) XXX_DiscardUnknown() { 289 xxx_messageInfo_Int32Value.DiscardUnknown(m) 290} 291 292var xxx_messageInfo_Int32Value proto.InternalMessageInfo 293 294func (m *Int32Value) GetValue() int32 { 295 if m != nil { 296 return m.Value 297 } 298 return 0 299} 300 301func (*Int32Value) XXX_MessageName() string { 302 return "google.protobuf.Int32Value" 303} 304 305// Wrapper message for `uint32`. 306// 307// The JSON representation for `UInt32Value` is JSON number. 308type UInt32Value struct { 309 // The uint32 value. 310 Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 311 XXX_NoUnkeyedLiteral struct{} `json:"-"` 312 XXX_unrecognized []byte `json:"-"` 313 XXX_sizecache int32 `json:"-"` 314} 315 316func (m *UInt32Value) Reset() { *m = UInt32Value{} } 317func (*UInt32Value) ProtoMessage() {} 318func (*UInt32Value) Descriptor() ([]byte, []int) { 319 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{5} 320} 321func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" } 322func (m *UInt32Value) XXX_Unmarshal(b []byte) error { 323 return m.Unmarshal(b) 324} 325func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 326 if deterministic { 327 return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic) 328 } else { 329 b = b[:cap(b)] 330 n, err := m.MarshalTo(b) 331 if err != nil { 332 return nil, err 333 } 334 return b[:n], nil 335 } 336} 337func (dst *UInt32Value) XXX_Merge(src proto.Message) { 338 xxx_messageInfo_UInt32Value.Merge(dst, src) 339} 340func (m *UInt32Value) XXX_Size() int { 341 return m.Size() 342} 343func (m *UInt32Value) XXX_DiscardUnknown() { 344 xxx_messageInfo_UInt32Value.DiscardUnknown(m) 345} 346 347var xxx_messageInfo_UInt32Value proto.InternalMessageInfo 348 349func (m *UInt32Value) GetValue() uint32 { 350 if m != nil { 351 return m.Value 352 } 353 return 0 354} 355 356func (*UInt32Value) XXX_MessageName() string { 357 return "google.protobuf.UInt32Value" 358} 359 360// Wrapper message for `bool`. 361// 362// The JSON representation for `BoolValue` is JSON `true` and `false`. 363type BoolValue struct { 364 // The bool value. 365 Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 366 XXX_NoUnkeyedLiteral struct{} `json:"-"` 367 XXX_unrecognized []byte `json:"-"` 368 XXX_sizecache int32 `json:"-"` 369} 370 371func (m *BoolValue) Reset() { *m = BoolValue{} } 372func (*BoolValue) ProtoMessage() {} 373func (*BoolValue) Descriptor() ([]byte, []int) { 374 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{6} 375} 376func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" } 377func (m *BoolValue) XXX_Unmarshal(b []byte) error { 378 return m.Unmarshal(b) 379} 380func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 381 if deterministic { 382 return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic) 383 } else { 384 b = b[:cap(b)] 385 n, err := m.MarshalTo(b) 386 if err != nil { 387 return nil, err 388 } 389 return b[:n], nil 390 } 391} 392func (dst *BoolValue) XXX_Merge(src proto.Message) { 393 xxx_messageInfo_BoolValue.Merge(dst, src) 394} 395func (m *BoolValue) XXX_Size() int { 396 return m.Size() 397} 398func (m *BoolValue) XXX_DiscardUnknown() { 399 xxx_messageInfo_BoolValue.DiscardUnknown(m) 400} 401 402var xxx_messageInfo_BoolValue proto.InternalMessageInfo 403 404func (m *BoolValue) GetValue() bool { 405 if m != nil { 406 return m.Value 407 } 408 return false 409} 410 411func (*BoolValue) XXX_MessageName() string { 412 return "google.protobuf.BoolValue" 413} 414 415// Wrapper message for `string`. 416// 417// The JSON representation for `StringValue` is JSON string. 418type StringValue struct { 419 // The string value. 420 Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 421 XXX_NoUnkeyedLiteral struct{} `json:"-"` 422 XXX_unrecognized []byte `json:"-"` 423 XXX_sizecache int32 `json:"-"` 424} 425 426func (m *StringValue) Reset() { *m = StringValue{} } 427func (*StringValue) ProtoMessage() {} 428func (*StringValue) Descriptor() ([]byte, []int) { 429 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{7} 430} 431func (*StringValue) XXX_WellKnownType() string { return "StringValue" } 432func (m *StringValue) XXX_Unmarshal(b []byte) error { 433 return m.Unmarshal(b) 434} 435func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 436 if deterministic { 437 return xxx_messageInfo_StringValue.Marshal(b, m, deterministic) 438 } else { 439 b = b[:cap(b)] 440 n, err := m.MarshalTo(b) 441 if err != nil { 442 return nil, err 443 } 444 return b[:n], nil 445 } 446} 447func (dst *StringValue) XXX_Merge(src proto.Message) { 448 xxx_messageInfo_StringValue.Merge(dst, src) 449} 450func (m *StringValue) XXX_Size() int { 451 return m.Size() 452} 453func (m *StringValue) XXX_DiscardUnknown() { 454 xxx_messageInfo_StringValue.DiscardUnknown(m) 455} 456 457var xxx_messageInfo_StringValue proto.InternalMessageInfo 458 459func (m *StringValue) GetValue() string { 460 if m != nil { 461 return m.Value 462 } 463 return "" 464} 465 466func (*StringValue) XXX_MessageName() string { 467 return "google.protobuf.StringValue" 468} 469 470// Wrapper message for `bytes`. 471// 472// The JSON representation for `BytesValue` is JSON string. 473type BytesValue struct { 474 // The bytes value. 475 Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 476 XXX_NoUnkeyedLiteral struct{} `json:"-"` 477 XXX_unrecognized []byte `json:"-"` 478 XXX_sizecache int32 `json:"-"` 479} 480 481func (m *BytesValue) Reset() { *m = BytesValue{} } 482func (*BytesValue) ProtoMessage() {} 483func (*BytesValue) Descriptor() ([]byte, []int) { 484 return fileDescriptor_wrappers_b0966e4a6118a07f, []int{8} 485} 486func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" } 487func (m *BytesValue) XXX_Unmarshal(b []byte) error { 488 return m.Unmarshal(b) 489} 490func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 491 if deterministic { 492 return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic) 493 } else { 494 b = b[:cap(b)] 495 n, err := m.MarshalTo(b) 496 if err != nil { 497 return nil, err 498 } 499 return b[:n], nil 500 } 501} 502func (dst *BytesValue) XXX_Merge(src proto.Message) { 503 xxx_messageInfo_BytesValue.Merge(dst, src) 504} 505func (m *BytesValue) XXX_Size() int { 506 return m.Size() 507} 508func (m *BytesValue) XXX_DiscardUnknown() { 509 xxx_messageInfo_BytesValue.DiscardUnknown(m) 510} 511 512var xxx_messageInfo_BytesValue proto.InternalMessageInfo 513 514func (m *BytesValue) GetValue() []byte { 515 if m != nil { 516 return m.Value 517 } 518 return nil 519} 520 521func (*BytesValue) XXX_MessageName() string { 522 return "google.protobuf.BytesValue" 523} 524func init() { 525 proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue") 526 proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue") 527 proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value") 528 proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value") 529 proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value") 530 proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value") 531 proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue") 532 proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue") 533 proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue") 534} 535func (this *DoubleValue) Compare(that interface{}) int { 536 if that == nil { 537 if this == nil { 538 return 0 539 } 540 return 1 541 } 542 543 that1, ok := that.(*DoubleValue) 544 if !ok { 545 that2, ok := that.(DoubleValue) 546 if ok { 547 that1 = &that2 548 } else { 549 return 1 550 } 551 } 552 if that1 == nil { 553 if this == nil { 554 return 0 555 } 556 return 1 557 } else if this == nil { 558 return -1 559 } 560 if this.Value != that1.Value { 561 if this.Value < that1.Value { 562 return -1 563 } 564 return 1 565 } 566 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 567 return c 568 } 569 return 0 570} 571func (this *FloatValue) Compare(that interface{}) int { 572 if that == nil { 573 if this == nil { 574 return 0 575 } 576 return 1 577 } 578 579 that1, ok := that.(*FloatValue) 580 if !ok { 581 that2, ok := that.(FloatValue) 582 if ok { 583 that1 = &that2 584 } else { 585 return 1 586 } 587 } 588 if that1 == nil { 589 if this == nil { 590 return 0 591 } 592 return 1 593 } else if this == nil { 594 return -1 595 } 596 if this.Value != that1.Value { 597 if this.Value < that1.Value { 598 return -1 599 } 600 return 1 601 } 602 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 603 return c 604 } 605 return 0 606} 607func (this *Int64Value) Compare(that interface{}) int { 608 if that == nil { 609 if this == nil { 610 return 0 611 } 612 return 1 613 } 614 615 that1, ok := that.(*Int64Value) 616 if !ok { 617 that2, ok := that.(Int64Value) 618 if ok { 619 that1 = &that2 620 } else { 621 return 1 622 } 623 } 624 if that1 == nil { 625 if this == nil { 626 return 0 627 } 628 return 1 629 } else if this == nil { 630 return -1 631 } 632 if this.Value != that1.Value { 633 if this.Value < that1.Value { 634 return -1 635 } 636 return 1 637 } 638 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 639 return c 640 } 641 return 0 642} 643func (this *UInt64Value) Compare(that interface{}) int { 644 if that == nil { 645 if this == nil { 646 return 0 647 } 648 return 1 649 } 650 651 that1, ok := that.(*UInt64Value) 652 if !ok { 653 that2, ok := that.(UInt64Value) 654 if ok { 655 that1 = &that2 656 } else { 657 return 1 658 } 659 } 660 if that1 == nil { 661 if this == nil { 662 return 0 663 } 664 return 1 665 } else if this == nil { 666 return -1 667 } 668 if this.Value != that1.Value { 669 if this.Value < that1.Value { 670 return -1 671 } 672 return 1 673 } 674 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 675 return c 676 } 677 return 0 678} 679func (this *Int32Value) Compare(that interface{}) int { 680 if that == nil { 681 if this == nil { 682 return 0 683 } 684 return 1 685 } 686 687 that1, ok := that.(*Int32Value) 688 if !ok { 689 that2, ok := that.(Int32Value) 690 if ok { 691 that1 = &that2 692 } else { 693 return 1 694 } 695 } 696 if that1 == nil { 697 if this == nil { 698 return 0 699 } 700 return 1 701 } else if this == nil { 702 return -1 703 } 704 if this.Value != that1.Value { 705 if this.Value < that1.Value { 706 return -1 707 } 708 return 1 709 } 710 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 711 return c 712 } 713 return 0 714} 715func (this *UInt32Value) Compare(that interface{}) int { 716 if that == nil { 717 if this == nil { 718 return 0 719 } 720 return 1 721 } 722 723 that1, ok := that.(*UInt32Value) 724 if !ok { 725 that2, ok := that.(UInt32Value) 726 if ok { 727 that1 = &that2 728 } else { 729 return 1 730 } 731 } 732 if that1 == nil { 733 if this == nil { 734 return 0 735 } 736 return 1 737 } else if this == nil { 738 return -1 739 } 740 if this.Value != that1.Value { 741 if this.Value < that1.Value { 742 return -1 743 } 744 return 1 745 } 746 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 747 return c 748 } 749 return 0 750} 751func (this *BoolValue) Compare(that interface{}) int { 752 if that == nil { 753 if this == nil { 754 return 0 755 } 756 return 1 757 } 758 759 that1, ok := that.(*BoolValue) 760 if !ok { 761 that2, ok := that.(BoolValue) 762 if ok { 763 that1 = &that2 764 } else { 765 return 1 766 } 767 } 768 if that1 == nil { 769 if this == nil { 770 return 0 771 } 772 return 1 773 } else if this == nil { 774 return -1 775 } 776 if this.Value != that1.Value { 777 if !this.Value { 778 return -1 779 } 780 return 1 781 } 782 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 783 return c 784 } 785 return 0 786} 787func (this *StringValue) Compare(that interface{}) int { 788 if that == nil { 789 if this == nil { 790 return 0 791 } 792 return 1 793 } 794 795 that1, ok := that.(*StringValue) 796 if !ok { 797 that2, ok := that.(StringValue) 798 if ok { 799 that1 = &that2 800 } else { 801 return 1 802 } 803 } 804 if that1 == nil { 805 if this == nil { 806 return 0 807 } 808 return 1 809 } else if this == nil { 810 return -1 811 } 812 if this.Value != that1.Value { 813 if this.Value < that1.Value { 814 return -1 815 } 816 return 1 817 } 818 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 819 return c 820 } 821 return 0 822} 823func (this *BytesValue) Compare(that interface{}) int { 824 if that == nil { 825 if this == nil { 826 return 0 827 } 828 return 1 829 } 830 831 that1, ok := that.(*BytesValue) 832 if !ok { 833 that2, ok := that.(BytesValue) 834 if ok { 835 that1 = &that2 836 } else { 837 return 1 838 } 839 } 840 if that1 == nil { 841 if this == nil { 842 return 0 843 } 844 return 1 845 } else if this == nil { 846 return -1 847 } 848 if c := bytes.Compare(this.Value, that1.Value); c != 0 { 849 return c 850 } 851 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 852 return c 853 } 854 return 0 855} 856func (this *DoubleValue) Equal(that interface{}) bool { 857 if that == nil { 858 return this == nil 859 } 860 861 that1, ok := that.(*DoubleValue) 862 if !ok { 863 that2, ok := that.(DoubleValue) 864 if ok { 865 that1 = &that2 866 } else { 867 return false 868 } 869 } 870 if that1 == nil { 871 return this == nil 872 } else if this == nil { 873 return false 874 } 875 if this.Value != that1.Value { 876 return false 877 } 878 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 879 return false 880 } 881 return true 882} 883func (this *FloatValue) Equal(that interface{}) bool { 884 if that == nil { 885 return this == nil 886 } 887 888 that1, ok := that.(*FloatValue) 889 if !ok { 890 that2, ok := that.(FloatValue) 891 if ok { 892 that1 = &that2 893 } else { 894 return false 895 } 896 } 897 if that1 == nil { 898 return this == nil 899 } else if this == nil { 900 return false 901 } 902 if this.Value != that1.Value { 903 return false 904 } 905 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 906 return false 907 } 908 return true 909} 910func (this *Int64Value) Equal(that interface{}) bool { 911 if that == nil { 912 return this == nil 913 } 914 915 that1, ok := that.(*Int64Value) 916 if !ok { 917 that2, ok := that.(Int64Value) 918 if ok { 919 that1 = &that2 920 } else { 921 return false 922 } 923 } 924 if that1 == nil { 925 return this == nil 926 } else if this == nil { 927 return false 928 } 929 if this.Value != that1.Value { 930 return false 931 } 932 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 933 return false 934 } 935 return true 936} 937func (this *UInt64Value) Equal(that interface{}) bool { 938 if that == nil { 939 return this == nil 940 } 941 942 that1, ok := that.(*UInt64Value) 943 if !ok { 944 that2, ok := that.(UInt64Value) 945 if ok { 946 that1 = &that2 947 } else { 948 return false 949 } 950 } 951 if that1 == nil { 952 return this == nil 953 } else if this == nil { 954 return false 955 } 956 if this.Value != that1.Value { 957 return false 958 } 959 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 960 return false 961 } 962 return true 963} 964func (this *Int32Value) Equal(that interface{}) bool { 965 if that == nil { 966 return this == nil 967 } 968 969 that1, ok := that.(*Int32Value) 970 if !ok { 971 that2, ok := that.(Int32Value) 972 if ok { 973 that1 = &that2 974 } else { 975 return false 976 } 977 } 978 if that1 == nil { 979 return this == nil 980 } else if this == nil { 981 return false 982 } 983 if this.Value != that1.Value { 984 return false 985 } 986 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 987 return false 988 } 989 return true 990} 991func (this *UInt32Value) Equal(that interface{}) bool { 992 if that == nil { 993 return this == nil 994 } 995 996 that1, ok := that.(*UInt32Value) 997 if !ok { 998 that2, ok := that.(UInt32Value) 999 if ok { 1000 that1 = &that2 1001 } else { 1002 return false 1003 } 1004 } 1005 if that1 == nil { 1006 return this == nil 1007 } else if this == nil { 1008 return false 1009 } 1010 if this.Value != that1.Value { 1011 return false 1012 } 1013 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1014 return false 1015 } 1016 return true 1017} 1018func (this *BoolValue) Equal(that interface{}) bool { 1019 if that == nil { 1020 return this == nil 1021 } 1022 1023 that1, ok := that.(*BoolValue) 1024 if !ok { 1025 that2, ok := that.(BoolValue) 1026 if ok { 1027 that1 = &that2 1028 } else { 1029 return false 1030 } 1031 } 1032 if that1 == nil { 1033 return this == nil 1034 } else if this == nil { 1035 return false 1036 } 1037 if this.Value != that1.Value { 1038 return false 1039 } 1040 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1041 return false 1042 } 1043 return true 1044} 1045func (this *StringValue) Equal(that interface{}) bool { 1046 if that == nil { 1047 return this == nil 1048 } 1049 1050 that1, ok := that.(*StringValue) 1051 if !ok { 1052 that2, ok := that.(StringValue) 1053 if ok { 1054 that1 = &that2 1055 } else { 1056 return false 1057 } 1058 } 1059 if that1 == nil { 1060 return this == nil 1061 } else if this == nil { 1062 return false 1063 } 1064 if this.Value != that1.Value { 1065 return false 1066 } 1067 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1068 return false 1069 } 1070 return true 1071} 1072func (this *BytesValue) Equal(that interface{}) bool { 1073 if that == nil { 1074 return this == nil 1075 } 1076 1077 that1, ok := that.(*BytesValue) 1078 if !ok { 1079 that2, ok := that.(BytesValue) 1080 if ok { 1081 that1 = &that2 1082 } else { 1083 return false 1084 } 1085 } 1086 if that1 == nil { 1087 return this == nil 1088 } else if this == nil { 1089 return false 1090 } 1091 if !bytes.Equal(this.Value, that1.Value) { 1092 return false 1093 } 1094 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 1095 return false 1096 } 1097 return true 1098} 1099func (this *DoubleValue) GoString() string { 1100 if this == nil { 1101 return "nil" 1102 } 1103 s := make([]string, 0, 5) 1104 s = append(s, "&types.DoubleValue{") 1105 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1106 if this.XXX_unrecognized != nil { 1107 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1108 } 1109 s = append(s, "}") 1110 return strings.Join(s, "") 1111} 1112func (this *FloatValue) GoString() string { 1113 if this == nil { 1114 return "nil" 1115 } 1116 s := make([]string, 0, 5) 1117 s = append(s, "&types.FloatValue{") 1118 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1119 if this.XXX_unrecognized != nil { 1120 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1121 } 1122 s = append(s, "}") 1123 return strings.Join(s, "") 1124} 1125func (this *Int64Value) GoString() string { 1126 if this == nil { 1127 return "nil" 1128 } 1129 s := make([]string, 0, 5) 1130 s = append(s, "&types.Int64Value{") 1131 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1132 if this.XXX_unrecognized != nil { 1133 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1134 } 1135 s = append(s, "}") 1136 return strings.Join(s, "") 1137} 1138func (this *UInt64Value) GoString() string { 1139 if this == nil { 1140 return "nil" 1141 } 1142 s := make([]string, 0, 5) 1143 s = append(s, "&types.UInt64Value{") 1144 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1145 if this.XXX_unrecognized != nil { 1146 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1147 } 1148 s = append(s, "}") 1149 return strings.Join(s, "") 1150} 1151func (this *Int32Value) GoString() string { 1152 if this == nil { 1153 return "nil" 1154 } 1155 s := make([]string, 0, 5) 1156 s = append(s, "&types.Int32Value{") 1157 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1158 if this.XXX_unrecognized != nil { 1159 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1160 } 1161 s = append(s, "}") 1162 return strings.Join(s, "") 1163} 1164func (this *UInt32Value) GoString() string { 1165 if this == nil { 1166 return "nil" 1167 } 1168 s := make([]string, 0, 5) 1169 s = append(s, "&types.UInt32Value{") 1170 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1171 if this.XXX_unrecognized != nil { 1172 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1173 } 1174 s = append(s, "}") 1175 return strings.Join(s, "") 1176} 1177func (this *BoolValue) GoString() string { 1178 if this == nil { 1179 return "nil" 1180 } 1181 s := make([]string, 0, 5) 1182 s = append(s, "&types.BoolValue{") 1183 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1184 if this.XXX_unrecognized != nil { 1185 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1186 } 1187 s = append(s, "}") 1188 return strings.Join(s, "") 1189} 1190func (this *StringValue) GoString() string { 1191 if this == nil { 1192 return "nil" 1193 } 1194 s := make([]string, 0, 5) 1195 s = append(s, "&types.StringValue{") 1196 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1197 if this.XXX_unrecognized != nil { 1198 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1199 } 1200 s = append(s, "}") 1201 return strings.Join(s, "") 1202} 1203func (this *BytesValue) GoString() string { 1204 if this == nil { 1205 return "nil" 1206 } 1207 s := make([]string, 0, 5) 1208 s = append(s, "&types.BytesValue{") 1209 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1210 if this.XXX_unrecognized != nil { 1211 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 1212 } 1213 s = append(s, "}") 1214 return strings.Join(s, "") 1215} 1216func valueToGoStringWrappers(v interface{}, typ string) string { 1217 rv := reflect.ValueOf(v) 1218 if rv.IsNil() { 1219 return "nil" 1220 } 1221 pv := reflect.Indirect(rv).Interface() 1222 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) 1223} 1224func (m *DoubleValue) Marshal() (dAtA []byte, err error) { 1225 size := m.Size() 1226 dAtA = make([]byte, size) 1227 n, err := m.MarshalTo(dAtA) 1228 if err != nil { 1229 return nil, err 1230 } 1231 return dAtA[:n], nil 1232} 1233 1234func (m *DoubleValue) MarshalTo(dAtA []byte) (int, error) { 1235 var i int 1236 _ = i 1237 var l int 1238 _ = l 1239 if m.Value != 0 { 1240 dAtA[i] = 0x9 1241 i++ 1242 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value)))) 1243 i += 8 1244 } 1245 if m.XXX_unrecognized != nil { 1246 i += copy(dAtA[i:], m.XXX_unrecognized) 1247 } 1248 return i, nil 1249} 1250 1251func (m *FloatValue) Marshal() (dAtA []byte, err error) { 1252 size := m.Size() 1253 dAtA = make([]byte, size) 1254 n, err := m.MarshalTo(dAtA) 1255 if err != nil { 1256 return nil, err 1257 } 1258 return dAtA[:n], nil 1259} 1260 1261func (m *FloatValue) MarshalTo(dAtA []byte) (int, error) { 1262 var i int 1263 _ = i 1264 var l int 1265 _ = l 1266 if m.Value != 0 { 1267 dAtA[i] = 0xd 1268 i++ 1269 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Value)))) 1270 i += 4 1271 } 1272 if m.XXX_unrecognized != nil { 1273 i += copy(dAtA[i:], m.XXX_unrecognized) 1274 } 1275 return i, nil 1276} 1277 1278func (m *Int64Value) Marshal() (dAtA []byte, err error) { 1279 size := m.Size() 1280 dAtA = make([]byte, size) 1281 n, err := m.MarshalTo(dAtA) 1282 if err != nil { 1283 return nil, err 1284 } 1285 return dAtA[:n], nil 1286} 1287 1288func (m *Int64Value) MarshalTo(dAtA []byte) (int, error) { 1289 var i int 1290 _ = i 1291 var l int 1292 _ = l 1293 if m.Value != 0 { 1294 dAtA[i] = 0x8 1295 i++ 1296 i = encodeVarintWrappers(dAtA, i, uint64(m.Value)) 1297 } 1298 if m.XXX_unrecognized != nil { 1299 i += copy(dAtA[i:], m.XXX_unrecognized) 1300 } 1301 return i, nil 1302} 1303 1304func (m *UInt64Value) Marshal() (dAtA []byte, err error) { 1305 size := m.Size() 1306 dAtA = make([]byte, size) 1307 n, err := m.MarshalTo(dAtA) 1308 if err != nil { 1309 return nil, err 1310 } 1311 return dAtA[:n], nil 1312} 1313 1314func (m *UInt64Value) MarshalTo(dAtA []byte) (int, error) { 1315 var i int 1316 _ = i 1317 var l int 1318 _ = l 1319 if m.Value != 0 { 1320 dAtA[i] = 0x8 1321 i++ 1322 i = encodeVarintWrappers(dAtA, i, uint64(m.Value)) 1323 } 1324 if m.XXX_unrecognized != nil { 1325 i += copy(dAtA[i:], m.XXX_unrecognized) 1326 } 1327 return i, nil 1328} 1329 1330func (m *Int32Value) Marshal() (dAtA []byte, err error) { 1331 size := m.Size() 1332 dAtA = make([]byte, size) 1333 n, err := m.MarshalTo(dAtA) 1334 if err != nil { 1335 return nil, err 1336 } 1337 return dAtA[:n], nil 1338} 1339 1340func (m *Int32Value) MarshalTo(dAtA []byte) (int, error) { 1341 var i int 1342 _ = i 1343 var l int 1344 _ = l 1345 if m.Value != 0 { 1346 dAtA[i] = 0x8 1347 i++ 1348 i = encodeVarintWrappers(dAtA, i, uint64(m.Value)) 1349 } 1350 if m.XXX_unrecognized != nil { 1351 i += copy(dAtA[i:], m.XXX_unrecognized) 1352 } 1353 return i, nil 1354} 1355 1356func (m *UInt32Value) Marshal() (dAtA []byte, err error) { 1357 size := m.Size() 1358 dAtA = make([]byte, size) 1359 n, err := m.MarshalTo(dAtA) 1360 if err != nil { 1361 return nil, err 1362 } 1363 return dAtA[:n], nil 1364} 1365 1366func (m *UInt32Value) MarshalTo(dAtA []byte) (int, error) { 1367 var i int 1368 _ = i 1369 var l int 1370 _ = l 1371 if m.Value != 0 { 1372 dAtA[i] = 0x8 1373 i++ 1374 i = encodeVarintWrappers(dAtA, i, uint64(m.Value)) 1375 } 1376 if m.XXX_unrecognized != nil { 1377 i += copy(dAtA[i:], m.XXX_unrecognized) 1378 } 1379 return i, nil 1380} 1381 1382func (m *BoolValue) Marshal() (dAtA []byte, err error) { 1383 size := m.Size() 1384 dAtA = make([]byte, size) 1385 n, err := m.MarshalTo(dAtA) 1386 if err != nil { 1387 return nil, err 1388 } 1389 return dAtA[:n], nil 1390} 1391 1392func (m *BoolValue) MarshalTo(dAtA []byte) (int, error) { 1393 var i int 1394 _ = i 1395 var l int 1396 _ = l 1397 if m.Value { 1398 dAtA[i] = 0x8 1399 i++ 1400 if m.Value { 1401 dAtA[i] = 1 1402 } else { 1403 dAtA[i] = 0 1404 } 1405 i++ 1406 } 1407 if m.XXX_unrecognized != nil { 1408 i += copy(dAtA[i:], m.XXX_unrecognized) 1409 } 1410 return i, nil 1411} 1412 1413func (m *StringValue) Marshal() (dAtA []byte, err error) { 1414 size := m.Size() 1415 dAtA = make([]byte, size) 1416 n, err := m.MarshalTo(dAtA) 1417 if err != nil { 1418 return nil, err 1419 } 1420 return dAtA[:n], nil 1421} 1422 1423func (m *StringValue) MarshalTo(dAtA []byte) (int, error) { 1424 var i int 1425 _ = i 1426 var l int 1427 _ = l 1428 if len(m.Value) > 0 { 1429 dAtA[i] = 0xa 1430 i++ 1431 i = encodeVarintWrappers(dAtA, i, uint64(len(m.Value))) 1432 i += copy(dAtA[i:], m.Value) 1433 } 1434 if m.XXX_unrecognized != nil { 1435 i += copy(dAtA[i:], m.XXX_unrecognized) 1436 } 1437 return i, nil 1438} 1439 1440func (m *BytesValue) Marshal() (dAtA []byte, err error) { 1441 size := m.Size() 1442 dAtA = make([]byte, size) 1443 n, err := m.MarshalTo(dAtA) 1444 if err != nil { 1445 return nil, err 1446 } 1447 return dAtA[:n], nil 1448} 1449 1450func (m *BytesValue) MarshalTo(dAtA []byte) (int, error) { 1451 var i int 1452 _ = i 1453 var l int 1454 _ = l 1455 if len(m.Value) > 0 { 1456 dAtA[i] = 0xa 1457 i++ 1458 i = encodeVarintWrappers(dAtA, i, uint64(len(m.Value))) 1459 i += copy(dAtA[i:], m.Value) 1460 } 1461 if m.XXX_unrecognized != nil { 1462 i += copy(dAtA[i:], m.XXX_unrecognized) 1463 } 1464 return i, nil 1465} 1466 1467func encodeVarintWrappers(dAtA []byte, offset int, v uint64) int { 1468 for v >= 1<<7 { 1469 dAtA[offset] = uint8(v&0x7f | 0x80) 1470 v >>= 7 1471 offset++ 1472 } 1473 dAtA[offset] = uint8(v) 1474 return offset + 1 1475} 1476func NewPopulatedDoubleValue(r randyWrappers, easy bool) *DoubleValue { 1477 this := &DoubleValue{} 1478 this.Value = float64(r.Float64()) 1479 if r.Intn(2) == 0 { 1480 this.Value *= -1 1481 } 1482 if !easy && r.Intn(10) != 0 { 1483 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1484 } 1485 return this 1486} 1487 1488func NewPopulatedFloatValue(r randyWrappers, easy bool) *FloatValue { 1489 this := &FloatValue{} 1490 this.Value = float32(r.Float32()) 1491 if r.Intn(2) == 0 { 1492 this.Value *= -1 1493 } 1494 if !easy && r.Intn(10) != 0 { 1495 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1496 } 1497 return this 1498} 1499 1500func NewPopulatedInt64Value(r randyWrappers, easy bool) *Int64Value { 1501 this := &Int64Value{} 1502 this.Value = int64(r.Int63()) 1503 if r.Intn(2) == 0 { 1504 this.Value *= -1 1505 } 1506 if !easy && r.Intn(10) != 0 { 1507 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1508 } 1509 return this 1510} 1511 1512func NewPopulatedUInt64Value(r randyWrappers, easy bool) *UInt64Value { 1513 this := &UInt64Value{} 1514 this.Value = uint64(uint64(r.Uint32())) 1515 if !easy && r.Intn(10) != 0 { 1516 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1517 } 1518 return this 1519} 1520 1521func NewPopulatedInt32Value(r randyWrappers, easy bool) *Int32Value { 1522 this := &Int32Value{} 1523 this.Value = int32(r.Int31()) 1524 if r.Intn(2) == 0 { 1525 this.Value *= -1 1526 } 1527 if !easy && r.Intn(10) != 0 { 1528 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1529 } 1530 return this 1531} 1532 1533func NewPopulatedUInt32Value(r randyWrappers, easy bool) *UInt32Value { 1534 this := &UInt32Value{} 1535 this.Value = uint32(r.Uint32()) 1536 if !easy && r.Intn(10) != 0 { 1537 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1538 } 1539 return this 1540} 1541 1542func NewPopulatedBoolValue(r randyWrappers, easy bool) *BoolValue { 1543 this := &BoolValue{} 1544 this.Value = bool(bool(r.Intn(2) == 0)) 1545 if !easy && r.Intn(10) != 0 { 1546 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1547 } 1548 return this 1549} 1550 1551func NewPopulatedStringValue(r randyWrappers, easy bool) *StringValue { 1552 this := &StringValue{} 1553 this.Value = string(randStringWrappers(r)) 1554 if !easy && r.Intn(10) != 0 { 1555 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1556 } 1557 return this 1558} 1559 1560func NewPopulatedBytesValue(r randyWrappers, easy bool) *BytesValue { 1561 this := &BytesValue{} 1562 v1 := r.Intn(100) 1563 this.Value = make([]byte, v1) 1564 for i := 0; i < v1; i++ { 1565 this.Value[i] = byte(r.Intn(256)) 1566 } 1567 if !easy && r.Intn(10) != 0 { 1568 this.XXX_unrecognized = randUnrecognizedWrappers(r, 2) 1569 } 1570 return this 1571} 1572 1573type randyWrappers interface { 1574 Float32() float32 1575 Float64() float64 1576 Int63() int64 1577 Int31() int32 1578 Uint32() uint32 1579 Intn(n int) int 1580} 1581 1582func randUTF8RuneWrappers(r randyWrappers) rune { 1583 ru := r.Intn(62) 1584 if ru < 10 { 1585 return rune(ru + 48) 1586 } else if ru < 36 { 1587 return rune(ru + 55) 1588 } 1589 return rune(ru + 61) 1590} 1591func randStringWrappers(r randyWrappers) string { 1592 v2 := r.Intn(100) 1593 tmps := make([]rune, v2) 1594 for i := 0; i < v2; i++ { 1595 tmps[i] = randUTF8RuneWrappers(r) 1596 } 1597 return string(tmps) 1598} 1599func randUnrecognizedWrappers(r randyWrappers, maxFieldNumber int) (dAtA []byte) { 1600 l := r.Intn(5) 1601 for i := 0; i < l; i++ { 1602 wire := r.Intn(4) 1603 if wire == 3 { 1604 wire = 5 1605 } 1606 fieldNumber := maxFieldNumber + r.Intn(100) 1607 dAtA = randFieldWrappers(dAtA, r, fieldNumber, wire) 1608 } 1609 return dAtA 1610} 1611func randFieldWrappers(dAtA []byte, r randyWrappers, fieldNumber int, wire int) []byte { 1612 key := uint32(fieldNumber)<<3 | uint32(wire) 1613 switch wire { 1614 case 0: 1615 dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key)) 1616 v3 := r.Int63() 1617 if r.Intn(2) == 0 { 1618 v3 *= -1 1619 } 1620 dAtA = encodeVarintPopulateWrappers(dAtA, uint64(v3)) 1621 case 1: 1622 dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key)) 1623 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))) 1624 case 2: 1625 dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key)) 1626 ll := r.Intn(100) 1627 dAtA = encodeVarintPopulateWrappers(dAtA, uint64(ll)) 1628 for j := 0; j < ll; j++ { 1629 dAtA = append(dAtA, byte(r.Intn(256))) 1630 } 1631 default: 1632 dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key)) 1633 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) 1634 } 1635 return dAtA 1636} 1637func encodeVarintPopulateWrappers(dAtA []byte, v uint64) []byte { 1638 for v >= 1<<7 { 1639 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) 1640 v >>= 7 1641 } 1642 dAtA = append(dAtA, uint8(v)) 1643 return dAtA 1644} 1645func (m *DoubleValue) Size() (n int) { 1646 var l int 1647 _ = l 1648 if m.Value != 0 { 1649 n += 9 1650 } 1651 if m.XXX_unrecognized != nil { 1652 n += len(m.XXX_unrecognized) 1653 } 1654 return n 1655} 1656 1657func (m *FloatValue) Size() (n int) { 1658 var l int 1659 _ = l 1660 if m.Value != 0 { 1661 n += 5 1662 } 1663 if m.XXX_unrecognized != nil { 1664 n += len(m.XXX_unrecognized) 1665 } 1666 return n 1667} 1668 1669func (m *Int64Value) Size() (n int) { 1670 var l int 1671 _ = l 1672 if m.Value != 0 { 1673 n += 1 + sovWrappers(uint64(m.Value)) 1674 } 1675 if m.XXX_unrecognized != nil { 1676 n += len(m.XXX_unrecognized) 1677 } 1678 return n 1679} 1680 1681func (m *UInt64Value) Size() (n int) { 1682 var l int 1683 _ = l 1684 if m.Value != 0 { 1685 n += 1 + sovWrappers(uint64(m.Value)) 1686 } 1687 if m.XXX_unrecognized != nil { 1688 n += len(m.XXX_unrecognized) 1689 } 1690 return n 1691} 1692 1693func (m *Int32Value) Size() (n int) { 1694 var l int 1695 _ = l 1696 if m.Value != 0 { 1697 n += 1 + sovWrappers(uint64(m.Value)) 1698 } 1699 if m.XXX_unrecognized != nil { 1700 n += len(m.XXX_unrecognized) 1701 } 1702 return n 1703} 1704 1705func (m *UInt32Value) Size() (n int) { 1706 var l int 1707 _ = l 1708 if m.Value != 0 { 1709 n += 1 + sovWrappers(uint64(m.Value)) 1710 } 1711 if m.XXX_unrecognized != nil { 1712 n += len(m.XXX_unrecognized) 1713 } 1714 return n 1715} 1716 1717func (m *BoolValue) Size() (n int) { 1718 var l int 1719 _ = l 1720 if m.Value { 1721 n += 2 1722 } 1723 if m.XXX_unrecognized != nil { 1724 n += len(m.XXX_unrecognized) 1725 } 1726 return n 1727} 1728 1729func (m *StringValue) Size() (n int) { 1730 var l int 1731 _ = l 1732 l = len(m.Value) 1733 if l > 0 { 1734 n += 1 + l + sovWrappers(uint64(l)) 1735 } 1736 if m.XXX_unrecognized != nil { 1737 n += len(m.XXX_unrecognized) 1738 } 1739 return n 1740} 1741 1742func (m *BytesValue) Size() (n int) { 1743 var l int 1744 _ = l 1745 l = len(m.Value) 1746 if l > 0 { 1747 n += 1 + l + sovWrappers(uint64(l)) 1748 } 1749 if m.XXX_unrecognized != nil { 1750 n += len(m.XXX_unrecognized) 1751 } 1752 return n 1753} 1754 1755func sovWrappers(x uint64) (n int) { 1756 for { 1757 n++ 1758 x >>= 7 1759 if x == 0 { 1760 break 1761 } 1762 } 1763 return n 1764} 1765func sozWrappers(x uint64) (n int) { 1766 return sovWrappers(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 1767} 1768func (this *DoubleValue) String() string { 1769 if this == nil { 1770 return "nil" 1771 } 1772 s := strings.Join([]string{`&DoubleValue{`, 1773 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1774 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1775 `}`, 1776 }, "") 1777 return s 1778} 1779func (this *FloatValue) String() string { 1780 if this == nil { 1781 return "nil" 1782 } 1783 s := strings.Join([]string{`&FloatValue{`, 1784 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1785 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1786 `}`, 1787 }, "") 1788 return s 1789} 1790func (this *Int64Value) String() string { 1791 if this == nil { 1792 return "nil" 1793 } 1794 s := strings.Join([]string{`&Int64Value{`, 1795 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1796 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1797 `}`, 1798 }, "") 1799 return s 1800} 1801func (this *UInt64Value) String() string { 1802 if this == nil { 1803 return "nil" 1804 } 1805 s := strings.Join([]string{`&UInt64Value{`, 1806 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1807 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1808 `}`, 1809 }, "") 1810 return s 1811} 1812func (this *Int32Value) String() string { 1813 if this == nil { 1814 return "nil" 1815 } 1816 s := strings.Join([]string{`&Int32Value{`, 1817 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1818 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1819 `}`, 1820 }, "") 1821 return s 1822} 1823func (this *UInt32Value) String() string { 1824 if this == nil { 1825 return "nil" 1826 } 1827 s := strings.Join([]string{`&UInt32Value{`, 1828 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1829 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1830 `}`, 1831 }, "") 1832 return s 1833} 1834func (this *BoolValue) String() string { 1835 if this == nil { 1836 return "nil" 1837 } 1838 s := strings.Join([]string{`&BoolValue{`, 1839 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1840 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1841 `}`, 1842 }, "") 1843 return s 1844} 1845func (this *StringValue) String() string { 1846 if this == nil { 1847 return "nil" 1848 } 1849 s := strings.Join([]string{`&StringValue{`, 1850 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1851 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1852 `}`, 1853 }, "") 1854 return s 1855} 1856func (this *BytesValue) String() string { 1857 if this == nil { 1858 return "nil" 1859 } 1860 s := strings.Join([]string{`&BytesValue{`, 1861 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1862 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1863 `}`, 1864 }, "") 1865 return s 1866} 1867func valueToStringWrappers(v interface{}) string { 1868 rv := reflect.ValueOf(v) 1869 if rv.IsNil() { 1870 return "nil" 1871 } 1872 pv := reflect.Indirect(rv).Interface() 1873 return fmt.Sprintf("*%v", pv) 1874} 1875func (m *DoubleValue) Unmarshal(dAtA []byte) error { 1876 l := len(dAtA) 1877 iNdEx := 0 1878 for iNdEx < l { 1879 preIndex := iNdEx 1880 var wire uint64 1881 for shift := uint(0); ; shift += 7 { 1882 if shift >= 64 { 1883 return ErrIntOverflowWrappers 1884 } 1885 if iNdEx >= l { 1886 return io.ErrUnexpectedEOF 1887 } 1888 b := dAtA[iNdEx] 1889 iNdEx++ 1890 wire |= (uint64(b) & 0x7F) << shift 1891 if b < 0x80 { 1892 break 1893 } 1894 } 1895 fieldNum := int32(wire >> 3) 1896 wireType := int(wire & 0x7) 1897 if wireType == 4 { 1898 return fmt.Errorf("proto: DoubleValue: wiretype end group for non-group") 1899 } 1900 if fieldNum <= 0 { 1901 return fmt.Errorf("proto: DoubleValue: illegal tag %d (wire type %d)", fieldNum, wire) 1902 } 1903 switch fieldNum { 1904 case 1: 1905 if wireType != 1 { 1906 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 1907 } 1908 var v uint64 1909 if (iNdEx + 8) > l { 1910 return io.ErrUnexpectedEOF 1911 } 1912 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 1913 iNdEx += 8 1914 m.Value = float64(math.Float64frombits(v)) 1915 default: 1916 iNdEx = preIndex 1917 skippy, err := skipWrappers(dAtA[iNdEx:]) 1918 if err != nil { 1919 return err 1920 } 1921 if skippy < 0 { 1922 return ErrInvalidLengthWrappers 1923 } 1924 if (iNdEx + skippy) > l { 1925 return io.ErrUnexpectedEOF 1926 } 1927 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1928 iNdEx += skippy 1929 } 1930 } 1931 1932 if iNdEx > l { 1933 return io.ErrUnexpectedEOF 1934 } 1935 return nil 1936} 1937func (m *FloatValue) Unmarshal(dAtA []byte) error { 1938 l := len(dAtA) 1939 iNdEx := 0 1940 for iNdEx < l { 1941 preIndex := iNdEx 1942 var wire uint64 1943 for shift := uint(0); ; shift += 7 { 1944 if shift >= 64 { 1945 return ErrIntOverflowWrappers 1946 } 1947 if iNdEx >= l { 1948 return io.ErrUnexpectedEOF 1949 } 1950 b := dAtA[iNdEx] 1951 iNdEx++ 1952 wire |= (uint64(b) & 0x7F) << shift 1953 if b < 0x80 { 1954 break 1955 } 1956 } 1957 fieldNum := int32(wire >> 3) 1958 wireType := int(wire & 0x7) 1959 if wireType == 4 { 1960 return fmt.Errorf("proto: FloatValue: wiretype end group for non-group") 1961 } 1962 if fieldNum <= 0 { 1963 return fmt.Errorf("proto: FloatValue: illegal tag %d (wire type %d)", fieldNum, wire) 1964 } 1965 switch fieldNum { 1966 case 1: 1967 if wireType != 5 { 1968 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 1969 } 1970 var v uint32 1971 if (iNdEx + 4) > l { 1972 return io.ErrUnexpectedEOF 1973 } 1974 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) 1975 iNdEx += 4 1976 m.Value = float32(math.Float32frombits(v)) 1977 default: 1978 iNdEx = preIndex 1979 skippy, err := skipWrappers(dAtA[iNdEx:]) 1980 if err != nil { 1981 return err 1982 } 1983 if skippy < 0 { 1984 return ErrInvalidLengthWrappers 1985 } 1986 if (iNdEx + skippy) > l { 1987 return io.ErrUnexpectedEOF 1988 } 1989 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1990 iNdEx += skippy 1991 } 1992 } 1993 1994 if iNdEx > l { 1995 return io.ErrUnexpectedEOF 1996 } 1997 return nil 1998} 1999func (m *Int64Value) Unmarshal(dAtA []byte) error { 2000 l := len(dAtA) 2001 iNdEx := 0 2002 for iNdEx < l { 2003 preIndex := iNdEx 2004 var wire uint64 2005 for shift := uint(0); ; shift += 7 { 2006 if shift >= 64 { 2007 return ErrIntOverflowWrappers 2008 } 2009 if iNdEx >= l { 2010 return io.ErrUnexpectedEOF 2011 } 2012 b := dAtA[iNdEx] 2013 iNdEx++ 2014 wire |= (uint64(b) & 0x7F) << shift 2015 if b < 0x80 { 2016 break 2017 } 2018 } 2019 fieldNum := int32(wire >> 3) 2020 wireType := int(wire & 0x7) 2021 if wireType == 4 { 2022 return fmt.Errorf("proto: Int64Value: wiretype end group for non-group") 2023 } 2024 if fieldNum <= 0 { 2025 return fmt.Errorf("proto: Int64Value: illegal tag %d (wire type %d)", fieldNum, wire) 2026 } 2027 switch fieldNum { 2028 case 1: 2029 if wireType != 0 { 2030 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2031 } 2032 m.Value = 0 2033 for shift := uint(0); ; shift += 7 { 2034 if shift >= 64 { 2035 return ErrIntOverflowWrappers 2036 } 2037 if iNdEx >= l { 2038 return io.ErrUnexpectedEOF 2039 } 2040 b := dAtA[iNdEx] 2041 iNdEx++ 2042 m.Value |= (int64(b) & 0x7F) << shift 2043 if b < 0x80 { 2044 break 2045 } 2046 } 2047 default: 2048 iNdEx = preIndex 2049 skippy, err := skipWrappers(dAtA[iNdEx:]) 2050 if err != nil { 2051 return err 2052 } 2053 if skippy < 0 { 2054 return ErrInvalidLengthWrappers 2055 } 2056 if (iNdEx + skippy) > l { 2057 return io.ErrUnexpectedEOF 2058 } 2059 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2060 iNdEx += skippy 2061 } 2062 } 2063 2064 if iNdEx > l { 2065 return io.ErrUnexpectedEOF 2066 } 2067 return nil 2068} 2069func (m *UInt64Value) Unmarshal(dAtA []byte) error { 2070 l := len(dAtA) 2071 iNdEx := 0 2072 for iNdEx < l { 2073 preIndex := iNdEx 2074 var wire uint64 2075 for shift := uint(0); ; shift += 7 { 2076 if shift >= 64 { 2077 return ErrIntOverflowWrappers 2078 } 2079 if iNdEx >= l { 2080 return io.ErrUnexpectedEOF 2081 } 2082 b := dAtA[iNdEx] 2083 iNdEx++ 2084 wire |= (uint64(b) & 0x7F) << shift 2085 if b < 0x80 { 2086 break 2087 } 2088 } 2089 fieldNum := int32(wire >> 3) 2090 wireType := int(wire & 0x7) 2091 if wireType == 4 { 2092 return fmt.Errorf("proto: UInt64Value: wiretype end group for non-group") 2093 } 2094 if fieldNum <= 0 { 2095 return fmt.Errorf("proto: UInt64Value: illegal tag %d (wire type %d)", fieldNum, wire) 2096 } 2097 switch fieldNum { 2098 case 1: 2099 if wireType != 0 { 2100 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2101 } 2102 m.Value = 0 2103 for shift := uint(0); ; shift += 7 { 2104 if shift >= 64 { 2105 return ErrIntOverflowWrappers 2106 } 2107 if iNdEx >= l { 2108 return io.ErrUnexpectedEOF 2109 } 2110 b := dAtA[iNdEx] 2111 iNdEx++ 2112 m.Value |= (uint64(b) & 0x7F) << shift 2113 if b < 0x80 { 2114 break 2115 } 2116 } 2117 default: 2118 iNdEx = preIndex 2119 skippy, err := skipWrappers(dAtA[iNdEx:]) 2120 if err != nil { 2121 return err 2122 } 2123 if skippy < 0 { 2124 return ErrInvalidLengthWrappers 2125 } 2126 if (iNdEx + skippy) > l { 2127 return io.ErrUnexpectedEOF 2128 } 2129 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2130 iNdEx += skippy 2131 } 2132 } 2133 2134 if iNdEx > l { 2135 return io.ErrUnexpectedEOF 2136 } 2137 return nil 2138} 2139func (m *Int32Value) Unmarshal(dAtA []byte) error { 2140 l := len(dAtA) 2141 iNdEx := 0 2142 for iNdEx < l { 2143 preIndex := iNdEx 2144 var wire uint64 2145 for shift := uint(0); ; shift += 7 { 2146 if shift >= 64 { 2147 return ErrIntOverflowWrappers 2148 } 2149 if iNdEx >= l { 2150 return io.ErrUnexpectedEOF 2151 } 2152 b := dAtA[iNdEx] 2153 iNdEx++ 2154 wire |= (uint64(b) & 0x7F) << shift 2155 if b < 0x80 { 2156 break 2157 } 2158 } 2159 fieldNum := int32(wire >> 3) 2160 wireType := int(wire & 0x7) 2161 if wireType == 4 { 2162 return fmt.Errorf("proto: Int32Value: wiretype end group for non-group") 2163 } 2164 if fieldNum <= 0 { 2165 return fmt.Errorf("proto: Int32Value: illegal tag %d (wire type %d)", fieldNum, wire) 2166 } 2167 switch fieldNum { 2168 case 1: 2169 if wireType != 0 { 2170 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2171 } 2172 m.Value = 0 2173 for shift := uint(0); ; shift += 7 { 2174 if shift >= 64 { 2175 return ErrIntOverflowWrappers 2176 } 2177 if iNdEx >= l { 2178 return io.ErrUnexpectedEOF 2179 } 2180 b := dAtA[iNdEx] 2181 iNdEx++ 2182 m.Value |= (int32(b) & 0x7F) << shift 2183 if b < 0x80 { 2184 break 2185 } 2186 } 2187 default: 2188 iNdEx = preIndex 2189 skippy, err := skipWrappers(dAtA[iNdEx:]) 2190 if err != nil { 2191 return err 2192 } 2193 if skippy < 0 { 2194 return ErrInvalidLengthWrappers 2195 } 2196 if (iNdEx + skippy) > l { 2197 return io.ErrUnexpectedEOF 2198 } 2199 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2200 iNdEx += skippy 2201 } 2202 } 2203 2204 if iNdEx > l { 2205 return io.ErrUnexpectedEOF 2206 } 2207 return nil 2208} 2209func (m *UInt32Value) Unmarshal(dAtA []byte) error { 2210 l := len(dAtA) 2211 iNdEx := 0 2212 for iNdEx < l { 2213 preIndex := iNdEx 2214 var wire uint64 2215 for shift := uint(0); ; shift += 7 { 2216 if shift >= 64 { 2217 return ErrIntOverflowWrappers 2218 } 2219 if iNdEx >= l { 2220 return io.ErrUnexpectedEOF 2221 } 2222 b := dAtA[iNdEx] 2223 iNdEx++ 2224 wire |= (uint64(b) & 0x7F) << shift 2225 if b < 0x80 { 2226 break 2227 } 2228 } 2229 fieldNum := int32(wire >> 3) 2230 wireType := int(wire & 0x7) 2231 if wireType == 4 { 2232 return fmt.Errorf("proto: UInt32Value: wiretype end group for non-group") 2233 } 2234 if fieldNum <= 0 { 2235 return fmt.Errorf("proto: UInt32Value: illegal tag %d (wire type %d)", fieldNum, wire) 2236 } 2237 switch fieldNum { 2238 case 1: 2239 if wireType != 0 { 2240 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2241 } 2242 m.Value = 0 2243 for shift := uint(0); ; shift += 7 { 2244 if shift >= 64 { 2245 return ErrIntOverflowWrappers 2246 } 2247 if iNdEx >= l { 2248 return io.ErrUnexpectedEOF 2249 } 2250 b := dAtA[iNdEx] 2251 iNdEx++ 2252 m.Value |= (uint32(b) & 0x7F) << shift 2253 if b < 0x80 { 2254 break 2255 } 2256 } 2257 default: 2258 iNdEx = preIndex 2259 skippy, err := skipWrappers(dAtA[iNdEx:]) 2260 if err != nil { 2261 return err 2262 } 2263 if skippy < 0 { 2264 return ErrInvalidLengthWrappers 2265 } 2266 if (iNdEx + skippy) > l { 2267 return io.ErrUnexpectedEOF 2268 } 2269 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2270 iNdEx += skippy 2271 } 2272 } 2273 2274 if iNdEx > l { 2275 return io.ErrUnexpectedEOF 2276 } 2277 return nil 2278} 2279func (m *BoolValue) Unmarshal(dAtA []byte) error { 2280 l := len(dAtA) 2281 iNdEx := 0 2282 for iNdEx < l { 2283 preIndex := iNdEx 2284 var wire uint64 2285 for shift := uint(0); ; shift += 7 { 2286 if shift >= 64 { 2287 return ErrIntOverflowWrappers 2288 } 2289 if iNdEx >= l { 2290 return io.ErrUnexpectedEOF 2291 } 2292 b := dAtA[iNdEx] 2293 iNdEx++ 2294 wire |= (uint64(b) & 0x7F) << shift 2295 if b < 0x80 { 2296 break 2297 } 2298 } 2299 fieldNum := int32(wire >> 3) 2300 wireType := int(wire & 0x7) 2301 if wireType == 4 { 2302 return fmt.Errorf("proto: BoolValue: wiretype end group for non-group") 2303 } 2304 if fieldNum <= 0 { 2305 return fmt.Errorf("proto: BoolValue: illegal tag %d (wire type %d)", fieldNum, wire) 2306 } 2307 switch fieldNum { 2308 case 1: 2309 if wireType != 0 { 2310 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2311 } 2312 var v int 2313 for shift := uint(0); ; shift += 7 { 2314 if shift >= 64 { 2315 return ErrIntOverflowWrappers 2316 } 2317 if iNdEx >= l { 2318 return io.ErrUnexpectedEOF 2319 } 2320 b := dAtA[iNdEx] 2321 iNdEx++ 2322 v |= (int(b) & 0x7F) << shift 2323 if b < 0x80 { 2324 break 2325 } 2326 } 2327 m.Value = bool(v != 0) 2328 default: 2329 iNdEx = preIndex 2330 skippy, err := skipWrappers(dAtA[iNdEx:]) 2331 if err != nil { 2332 return err 2333 } 2334 if skippy < 0 { 2335 return ErrInvalidLengthWrappers 2336 } 2337 if (iNdEx + skippy) > l { 2338 return io.ErrUnexpectedEOF 2339 } 2340 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2341 iNdEx += skippy 2342 } 2343 } 2344 2345 if iNdEx > l { 2346 return io.ErrUnexpectedEOF 2347 } 2348 return nil 2349} 2350func (m *StringValue) Unmarshal(dAtA []byte) error { 2351 l := len(dAtA) 2352 iNdEx := 0 2353 for iNdEx < l { 2354 preIndex := iNdEx 2355 var wire uint64 2356 for shift := uint(0); ; shift += 7 { 2357 if shift >= 64 { 2358 return ErrIntOverflowWrappers 2359 } 2360 if iNdEx >= l { 2361 return io.ErrUnexpectedEOF 2362 } 2363 b := dAtA[iNdEx] 2364 iNdEx++ 2365 wire |= (uint64(b) & 0x7F) << shift 2366 if b < 0x80 { 2367 break 2368 } 2369 } 2370 fieldNum := int32(wire >> 3) 2371 wireType := int(wire & 0x7) 2372 if wireType == 4 { 2373 return fmt.Errorf("proto: StringValue: wiretype end group for non-group") 2374 } 2375 if fieldNum <= 0 { 2376 return fmt.Errorf("proto: StringValue: illegal tag %d (wire type %d)", fieldNum, wire) 2377 } 2378 switch fieldNum { 2379 case 1: 2380 if wireType != 2 { 2381 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2382 } 2383 var stringLen uint64 2384 for shift := uint(0); ; shift += 7 { 2385 if shift >= 64 { 2386 return ErrIntOverflowWrappers 2387 } 2388 if iNdEx >= l { 2389 return io.ErrUnexpectedEOF 2390 } 2391 b := dAtA[iNdEx] 2392 iNdEx++ 2393 stringLen |= (uint64(b) & 0x7F) << shift 2394 if b < 0x80 { 2395 break 2396 } 2397 } 2398 intStringLen := int(stringLen) 2399 if intStringLen < 0 { 2400 return ErrInvalidLengthWrappers 2401 } 2402 postIndex := iNdEx + intStringLen 2403 if postIndex > l { 2404 return io.ErrUnexpectedEOF 2405 } 2406 m.Value = string(dAtA[iNdEx:postIndex]) 2407 iNdEx = postIndex 2408 default: 2409 iNdEx = preIndex 2410 skippy, err := skipWrappers(dAtA[iNdEx:]) 2411 if err != nil { 2412 return err 2413 } 2414 if skippy < 0 { 2415 return ErrInvalidLengthWrappers 2416 } 2417 if (iNdEx + skippy) > l { 2418 return io.ErrUnexpectedEOF 2419 } 2420 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2421 iNdEx += skippy 2422 } 2423 } 2424 2425 if iNdEx > l { 2426 return io.ErrUnexpectedEOF 2427 } 2428 return nil 2429} 2430func (m *BytesValue) Unmarshal(dAtA []byte) error { 2431 l := len(dAtA) 2432 iNdEx := 0 2433 for iNdEx < l { 2434 preIndex := iNdEx 2435 var wire uint64 2436 for shift := uint(0); ; shift += 7 { 2437 if shift >= 64 { 2438 return ErrIntOverflowWrappers 2439 } 2440 if iNdEx >= l { 2441 return io.ErrUnexpectedEOF 2442 } 2443 b := dAtA[iNdEx] 2444 iNdEx++ 2445 wire |= (uint64(b) & 0x7F) << shift 2446 if b < 0x80 { 2447 break 2448 } 2449 } 2450 fieldNum := int32(wire >> 3) 2451 wireType := int(wire & 0x7) 2452 if wireType == 4 { 2453 return fmt.Errorf("proto: BytesValue: wiretype end group for non-group") 2454 } 2455 if fieldNum <= 0 { 2456 return fmt.Errorf("proto: BytesValue: illegal tag %d (wire type %d)", fieldNum, wire) 2457 } 2458 switch fieldNum { 2459 case 1: 2460 if wireType != 2 { 2461 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2462 } 2463 var byteLen int 2464 for shift := uint(0); ; shift += 7 { 2465 if shift >= 64 { 2466 return ErrIntOverflowWrappers 2467 } 2468 if iNdEx >= l { 2469 return io.ErrUnexpectedEOF 2470 } 2471 b := dAtA[iNdEx] 2472 iNdEx++ 2473 byteLen |= (int(b) & 0x7F) << shift 2474 if b < 0x80 { 2475 break 2476 } 2477 } 2478 if byteLen < 0 { 2479 return ErrInvalidLengthWrappers 2480 } 2481 postIndex := iNdEx + byteLen 2482 if postIndex > l { 2483 return io.ErrUnexpectedEOF 2484 } 2485 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 2486 if m.Value == nil { 2487 m.Value = []byte{} 2488 } 2489 iNdEx = postIndex 2490 default: 2491 iNdEx = preIndex 2492 skippy, err := skipWrappers(dAtA[iNdEx:]) 2493 if err != nil { 2494 return err 2495 } 2496 if skippy < 0 { 2497 return ErrInvalidLengthWrappers 2498 } 2499 if (iNdEx + skippy) > l { 2500 return io.ErrUnexpectedEOF 2501 } 2502 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2503 iNdEx += skippy 2504 } 2505 } 2506 2507 if iNdEx > l { 2508 return io.ErrUnexpectedEOF 2509 } 2510 return nil 2511} 2512func skipWrappers(dAtA []byte) (n int, err error) { 2513 l := len(dAtA) 2514 iNdEx := 0 2515 for iNdEx < l { 2516 var wire uint64 2517 for shift := uint(0); ; shift += 7 { 2518 if shift >= 64 { 2519 return 0, ErrIntOverflowWrappers 2520 } 2521 if iNdEx >= l { 2522 return 0, io.ErrUnexpectedEOF 2523 } 2524 b := dAtA[iNdEx] 2525 iNdEx++ 2526 wire |= (uint64(b) & 0x7F) << shift 2527 if b < 0x80 { 2528 break 2529 } 2530 } 2531 wireType := int(wire & 0x7) 2532 switch wireType { 2533 case 0: 2534 for shift := uint(0); ; shift += 7 { 2535 if shift >= 64 { 2536 return 0, ErrIntOverflowWrappers 2537 } 2538 if iNdEx >= l { 2539 return 0, io.ErrUnexpectedEOF 2540 } 2541 iNdEx++ 2542 if dAtA[iNdEx-1] < 0x80 { 2543 break 2544 } 2545 } 2546 return iNdEx, nil 2547 case 1: 2548 iNdEx += 8 2549 return iNdEx, nil 2550 case 2: 2551 var length int 2552 for shift := uint(0); ; shift += 7 { 2553 if shift >= 64 { 2554 return 0, ErrIntOverflowWrappers 2555 } 2556 if iNdEx >= l { 2557 return 0, io.ErrUnexpectedEOF 2558 } 2559 b := dAtA[iNdEx] 2560 iNdEx++ 2561 length |= (int(b) & 0x7F) << shift 2562 if b < 0x80 { 2563 break 2564 } 2565 } 2566 iNdEx += length 2567 if length < 0 { 2568 return 0, ErrInvalidLengthWrappers 2569 } 2570 return iNdEx, nil 2571 case 3: 2572 for { 2573 var innerWire uint64 2574 var start int = iNdEx 2575 for shift := uint(0); ; shift += 7 { 2576 if shift >= 64 { 2577 return 0, ErrIntOverflowWrappers 2578 } 2579 if iNdEx >= l { 2580 return 0, io.ErrUnexpectedEOF 2581 } 2582 b := dAtA[iNdEx] 2583 iNdEx++ 2584 innerWire |= (uint64(b) & 0x7F) << shift 2585 if b < 0x80 { 2586 break 2587 } 2588 } 2589 innerWireType := int(innerWire & 0x7) 2590 if innerWireType == 4 { 2591 break 2592 } 2593 next, err := skipWrappers(dAtA[start:]) 2594 if err != nil { 2595 return 0, err 2596 } 2597 iNdEx = start + next 2598 } 2599 return iNdEx, nil 2600 case 4: 2601 return iNdEx, nil 2602 case 5: 2603 iNdEx += 4 2604 return iNdEx, nil 2605 default: 2606 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 2607 } 2608 } 2609 panic("unreachable") 2610} 2611 2612var ( 2613 ErrInvalidLengthWrappers = fmt.Errorf("proto: negative length found during unmarshaling") 2614 ErrIntOverflowWrappers = fmt.Errorf("proto: integer overflow") 2615) 2616 2617func init() { 2618 proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_wrappers_b0966e4a6118a07f) 2619} 2620 2621var fileDescriptor_wrappers_b0966e4a6118a07f = []byte{ 2622 // 289 bytes of a gzipped FileDescriptorProto 2623 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f, 2624 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c, 2625 0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca, 2626 0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c, 2627 0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5, 2628 0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13, 2629 0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8, 2630 0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca, 2631 0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a, 2632 0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x37, 2633 0xe3, 0x85, 0x87, 0x72, 0x0c, 0x37, 0x1e, 0xca, 0x31, 0x7c, 0x78, 0x28, 0xc7, 0xf8, 0xe3, 0xa1, 2634 0x1c, 0x63, 0xc3, 0x23, 0x39, 0xc6, 0x15, 0x8f, 0xe4, 0x18, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 2635 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x17, 0x8f, 0xe4, 0x18, 0x3e, 0x80, 0xc4, 0x1f, 0xcb, 2636 0x31, 0x9e, 0x78, 0x2c, 0xc7, 0xc8, 0x25, 0x9c, 0x9c, 0x9f, 0xab, 0x87, 0x16, 0x25, 0x4e, 0xbc, 2637 0xe1, 0xd0, 0x38, 0x0b, 0x00, 0x89, 0x04, 0x30, 0x46, 0xb1, 0x96, 0x54, 0x16, 0xa4, 0x16, 0xff, 2638 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0xa2, 0x25, 0x00, 2639 0xaa, 0x45, 0x2f, 0x3c, 0x35, 0x27, 0xc7, 0x3b, 0x2f, 0xbf, 0x3c, 0x2f, 0x04, 0xa4, 0x32, 0x89, 2640 0x0d, 0x6c, 0x96, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xff, 0xc7, 0xfe, 0x37, 0x0e, 0x02, 0x00, 2641 0x00, 2642} 2643