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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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_c5239a825c7dfb53, []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 if m == nil { 1647 return 0 1648 } 1649 var l int 1650 _ = l 1651 if m.Value != 0 { 1652 n += 9 1653 } 1654 if m.XXX_unrecognized != nil { 1655 n += len(m.XXX_unrecognized) 1656 } 1657 return n 1658} 1659 1660func (m *FloatValue) Size() (n int) { 1661 if m == nil { 1662 return 0 1663 } 1664 var l int 1665 _ = l 1666 if m.Value != 0 { 1667 n += 5 1668 } 1669 if m.XXX_unrecognized != nil { 1670 n += len(m.XXX_unrecognized) 1671 } 1672 return n 1673} 1674 1675func (m *Int64Value) Size() (n int) { 1676 if m == nil { 1677 return 0 1678 } 1679 var l int 1680 _ = l 1681 if m.Value != 0 { 1682 n += 1 + sovWrappers(uint64(m.Value)) 1683 } 1684 if m.XXX_unrecognized != nil { 1685 n += len(m.XXX_unrecognized) 1686 } 1687 return n 1688} 1689 1690func (m *UInt64Value) Size() (n int) { 1691 if m == nil { 1692 return 0 1693 } 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 *Int32Value) Size() (n int) { 1706 if m == nil { 1707 return 0 1708 } 1709 var l int 1710 _ = l 1711 if m.Value != 0 { 1712 n += 1 + sovWrappers(uint64(m.Value)) 1713 } 1714 if m.XXX_unrecognized != nil { 1715 n += len(m.XXX_unrecognized) 1716 } 1717 return n 1718} 1719 1720func (m *UInt32Value) Size() (n int) { 1721 if m == nil { 1722 return 0 1723 } 1724 var l int 1725 _ = l 1726 if m.Value != 0 { 1727 n += 1 + sovWrappers(uint64(m.Value)) 1728 } 1729 if m.XXX_unrecognized != nil { 1730 n += len(m.XXX_unrecognized) 1731 } 1732 return n 1733} 1734 1735func (m *BoolValue) Size() (n int) { 1736 if m == nil { 1737 return 0 1738 } 1739 var l int 1740 _ = l 1741 if m.Value { 1742 n += 2 1743 } 1744 if m.XXX_unrecognized != nil { 1745 n += len(m.XXX_unrecognized) 1746 } 1747 return n 1748} 1749 1750func (m *StringValue) Size() (n int) { 1751 if m == nil { 1752 return 0 1753 } 1754 var l int 1755 _ = l 1756 l = len(m.Value) 1757 if l > 0 { 1758 n += 1 + l + sovWrappers(uint64(l)) 1759 } 1760 if m.XXX_unrecognized != nil { 1761 n += len(m.XXX_unrecognized) 1762 } 1763 return n 1764} 1765 1766func (m *BytesValue) Size() (n int) { 1767 if m == nil { 1768 return 0 1769 } 1770 var l int 1771 _ = l 1772 l = len(m.Value) 1773 if l > 0 { 1774 n += 1 + l + sovWrappers(uint64(l)) 1775 } 1776 if m.XXX_unrecognized != nil { 1777 n += len(m.XXX_unrecognized) 1778 } 1779 return n 1780} 1781 1782func sovWrappers(x uint64) (n int) { 1783 for { 1784 n++ 1785 x >>= 7 1786 if x == 0 { 1787 break 1788 } 1789 } 1790 return n 1791} 1792func sozWrappers(x uint64) (n int) { 1793 return sovWrappers(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 1794} 1795func (this *DoubleValue) String() string { 1796 if this == nil { 1797 return "nil" 1798 } 1799 s := strings.Join([]string{`&DoubleValue{`, 1800 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1801 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1802 `}`, 1803 }, "") 1804 return s 1805} 1806func (this *FloatValue) String() string { 1807 if this == nil { 1808 return "nil" 1809 } 1810 s := strings.Join([]string{`&FloatValue{`, 1811 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1812 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1813 `}`, 1814 }, "") 1815 return s 1816} 1817func (this *Int64Value) String() string { 1818 if this == nil { 1819 return "nil" 1820 } 1821 s := strings.Join([]string{`&Int64Value{`, 1822 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1823 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1824 `}`, 1825 }, "") 1826 return s 1827} 1828func (this *UInt64Value) String() string { 1829 if this == nil { 1830 return "nil" 1831 } 1832 s := strings.Join([]string{`&UInt64Value{`, 1833 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1834 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1835 `}`, 1836 }, "") 1837 return s 1838} 1839func (this *Int32Value) String() string { 1840 if this == nil { 1841 return "nil" 1842 } 1843 s := strings.Join([]string{`&Int32Value{`, 1844 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1845 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1846 `}`, 1847 }, "") 1848 return s 1849} 1850func (this *UInt32Value) String() string { 1851 if this == nil { 1852 return "nil" 1853 } 1854 s := strings.Join([]string{`&UInt32Value{`, 1855 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1856 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1857 `}`, 1858 }, "") 1859 return s 1860} 1861func (this *BoolValue) String() string { 1862 if this == nil { 1863 return "nil" 1864 } 1865 s := strings.Join([]string{`&BoolValue{`, 1866 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1867 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1868 `}`, 1869 }, "") 1870 return s 1871} 1872func (this *StringValue) String() string { 1873 if this == nil { 1874 return "nil" 1875 } 1876 s := strings.Join([]string{`&StringValue{`, 1877 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1878 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1879 `}`, 1880 }, "") 1881 return s 1882} 1883func (this *BytesValue) String() string { 1884 if this == nil { 1885 return "nil" 1886 } 1887 s := strings.Join([]string{`&BytesValue{`, 1888 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 1889 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1890 `}`, 1891 }, "") 1892 return s 1893} 1894func valueToStringWrappers(v interface{}) string { 1895 rv := reflect.ValueOf(v) 1896 if rv.IsNil() { 1897 return "nil" 1898 } 1899 pv := reflect.Indirect(rv).Interface() 1900 return fmt.Sprintf("*%v", pv) 1901} 1902func (m *DoubleValue) Unmarshal(dAtA []byte) error { 1903 l := len(dAtA) 1904 iNdEx := 0 1905 for iNdEx < l { 1906 preIndex := iNdEx 1907 var wire uint64 1908 for shift := uint(0); ; shift += 7 { 1909 if shift >= 64 { 1910 return ErrIntOverflowWrappers 1911 } 1912 if iNdEx >= l { 1913 return io.ErrUnexpectedEOF 1914 } 1915 b := dAtA[iNdEx] 1916 iNdEx++ 1917 wire |= (uint64(b) & 0x7F) << shift 1918 if b < 0x80 { 1919 break 1920 } 1921 } 1922 fieldNum := int32(wire >> 3) 1923 wireType := int(wire & 0x7) 1924 if wireType == 4 { 1925 return fmt.Errorf("proto: DoubleValue: wiretype end group for non-group") 1926 } 1927 if fieldNum <= 0 { 1928 return fmt.Errorf("proto: DoubleValue: illegal tag %d (wire type %d)", fieldNum, wire) 1929 } 1930 switch fieldNum { 1931 case 1: 1932 if wireType != 1 { 1933 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 1934 } 1935 var v uint64 1936 if (iNdEx + 8) > l { 1937 return io.ErrUnexpectedEOF 1938 } 1939 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 1940 iNdEx += 8 1941 m.Value = float64(math.Float64frombits(v)) 1942 default: 1943 iNdEx = preIndex 1944 skippy, err := skipWrappers(dAtA[iNdEx:]) 1945 if err != nil { 1946 return err 1947 } 1948 if skippy < 0 { 1949 return ErrInvalidLengthWrappers 1950 } 1951 if (iNdEx + skippy) > l { 1952 return io.ErrUnexpectedEOF 1953 } 1954 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1955 iNdEx += skippy 1956 } 1957 } 1958 1959 if iNdEx > l { 1960 return io.ErrUnexpectedEOF 1961 } 1962 return nil 1963} 1964func (m *FloatValue) Unmarshal(dAtA []byte) error { 1965 l := len(dAtA) 1966 iNdEx := 0 1967 for iNdEx < l { 1968 preIndex := iNdEx 1969 var wire uint64 1970 for shift := uint(0); ; shift += 7 { 1971 if shift >= 64 { 1972 return ErrIntOverflowWrappers 1973 } 1974 if iNdEx >= l { 1975 return io.ErrUnexpectedEOF 1976 } 1977 b := dAtA[iNdEx] 1978 iNdEx++ 1979 wire |= (uint64(b) & 0x7F) << shift 1980 if b < 0x80 { 1981 break 1982 } 1983 } 1984 fieldNum := int32(wire >> 3) 1985 wireType := int(wire & 0x7) 1986 if wireType == 4 { 1987 return fmt.Errorf("proto: FloatValue: wiretype end group for non-group") 1988 } 1989 if fieldNum <= 0 { 1990 return fmt.Errorf("proto: FloatValue: illegal tag %d (wire type %d)", fieldNum, wire) 1991 } 1992 switch fieldNum { 1993 case 1: 1994 if wireType != 5 { 1995 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 1996 } 1997 var v uint32 1998 if (iNdEx + 4) > l { 1999 return io.ErrUnexpectedEOF 2000 } 2001 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) 2002 iNdEx += 4 2003 m.Value = float32(math.Float32frombits(v)) 2004 default: 2005 iNdEx = preIndex 2006 skippy, err := skipWrappers(dAtA[iNdEx:]) 2007 if err != nil { 2008 return err 2009 } 2010 if skippy < 0 { 2011 return ErrInvalidLengthWrappers 2012 } 2013 if (iNdEx + skippy) > l { 2014 return io.ErrUnexpectedEOF 2015 } 2016 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2017 iNdEx += skippy 2018 } 2019 } 2020 2021 if iNdEx > l { 2022 return io.ErrUnexpectedEOF 2023 } 2024 return nil 2025} 2026func (m *Int64Value) Unmarshal(dAtA []byte) error { 2027 l := len(dAtA) 2028 iNdEx := 0 2029 for iNdEx < l { 2030 preIndex := iNdEx 2031 var wire uint64 2032 for shift := uint(0); ; shift += 7 { 2033 if shift >= 64 { 2034 return ErrIntOverflowWrappers 2035 } 2036 if iNdEx >= l { 2037 return io.ErrUnexpectedEOF 2038 } 2039 b := dAtA[iNdEx] 2040 iNdEx++ 2041 wire |= (uint64(b) & 0x7F) << shift 2042 if b < 0x80 { 2043 break 2044 } 2045 } 2046 fieldNum := int32(wire >> 3) 2047 wireType := int(wire & 0x7) 2048 if wireType == 4 { 2049 return fmt.Errorf("proto: Int64Value: wiretype end group for non-group") 2050 } 2051 if fieldNum <= 0 { 2052 return fmt.Errorf("proto: Int64Value: illegal tag %d (wire type %d)", fieldNum, wire) 2053 } 2054 switch fieldNum { 2055 case 1: 2056 if wireType != 0 { 2057 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2058 } 2059 m.Value = 0 2060 for shift := uint(0); ; shift += 7 { 2061 if shift >= 64 { 2062 return ErrIntOverflowWrappers 2063 } 2064 if iNdEx >= l { 2065 return io.ErrUnexpectedEOF 2066 } 2067 b := dAtA[iNdEx] 2068 iNdEx++ 2069 m.Value |= (int64(b) & 0x7F) << shift 2070 if b < 0x80 { 2071 break 2072 } 2073 } 2074 default: 2075 iNdEx = preIndex 2076 skippy, err := skipWrappers(dAtA[iNdEx:]) 2077 if err != nil { 2078 return err 2079 } 2080 if skippy < 0 { 2081 return ErrInvalidLengthWrappers 2082 } 2083 if (iNdEx + skippy) > l { 2084 return io.ErrUnexpectedEOF 2085 } 2086 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2087 iNdEx += skippy 2088 } 2089 } 2090 2091 if iNdEx > l { 2092 return io.ErrUnexpectedEOF 2093 } 2094 return nil 2095} 2096func (m *UInt64Value) Unmarshal(dAtA []byte) error { 2097 l := len(dAtA) 2098 iNdEx := 0 2099 for iNdEx < l { 2100 preIndex := iNdEx 2101 var wire uint64 2102 for shift := uint(0); ; shift += 7 { 2103 if shift >= 64 { 2104 return ErrIntOverflowWrappers 2105 } 2106 if iNdEx >= l { 2107 return io.ErrUnexpectedEOF 2108 } 2109 b := dAtA[iNdEx] 2110 iNdEx++ 2111 wire |= (uint64(b) & 0x7F) << shift 2112 if b < 0x80 { 2113 break 2114 } 2115 } 2116 fieldNum := int32(wire >> 3) 2117 wireType := int(wire & 0x7) 2118 if wireType == 4 { 2119 return fmt.Errorf("proto: UInt64Value: wiretype end group for non-group") 2120 } 2121 if fieldNum <= 0 { 2122 return fmt.Errorf("proto: UInt64Value: illegal tag %d (wire type %d)", fieldNum, wire) 2123 } 2124 switch fieldNum { 2125 case 1: 2126 if wireType != 0 { 2127 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2128 } 2129 m.Value = 0 2130 for shift := uint(0); ; shift += 7 { 2131 if shift >= 64 { 2132 return ErrIntOverflowWrappers 2133 } 2134 if iNdEx >= l { 2135 return io.ErrUnexpectedEOF 2136 } 2137 b := dAtA[iNdEx] 2138 iNdEx++ 2139 m.Value |= (uint64(b) & 0x7F) << shift 2140 if b < 0x80 { 2141 break 2142 } 2143 } 2144 default: 2145 iNdEx = preIndex 2146 skippy, err := skipWrappers(dAtA[iNdEx:]) 2147 if err != nil { 2148 return err 2149 } 2150 if skippy < 0 { 2151 return ErrInvalidLengthWrappers 2152 } 2153 if (iNdEx + skippy) > l { 2154 return io.ErrUnexpectedEOF 2155 } 2156 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2157 iNdEx += skippy 2158 } 2159 } 2160 2161 if iNdEx > l { 2162 return io.ErrUnexpectedEOF 2163 } 2164 return nil 2165} 2166func (m *Int32Value) Unmarshal(dAtA []byte) error { 2167 l := len(dAtA) 2168 iNdEx := 0 2169 for iNdEx < l { 2170 preIndex := iNdEx 2171 var wire uint64 2172 for shift := uint(0); ; shift += 7 { 2173 if shift >= 64 { 2174 return ErrIntOverflowWrappers 2175 } 2176 if iNdEx >= l { 2177 return io.ErrUnexpectedEOF 2178 } 2179 b := dAtA[iNdEx] 2180 iNdEx++ 2181 wire |= (uint64(b) & 0x7F) << shift 2182 if b < 0x80 { 2183 break 2184 } 2185 } 2186 fieldNum := int32(wire >> 3) 2187 wireType := int(wire & 0x7) 2188 if wireType == 4 { 2189 return fmt.Errorf("proto: Int32Value: wiretype end group for non-group") 2190 } 2191 if fieldNum <= 0 { 2192 return fmt.Errorf("proto: Int32Value: illegal tag %d (wire type %d)", fieldNum, wire) 2193 } 2194 switch fieldNum { 2195 case 1: 2196 if wireType != 0 { 2197 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2198 } 2199 m.Value = 0 2200 for shift := uint(0); ; shift += 7 { 2201 if shift >= 64 { 2202 return ErrIntOverflowWrappers 2203 } 2204 if iNdEx >= l { 2205 return io.ErrUnexpectedEOF 2206 } 2207 b := dAtA[iNdEx] 2208 iNdEx++ 2209 m.Value |= (int32(b) & 0x7F) << shift 2210 if b < 0x80 { 2211 break 2212 } 2213 } 2214 default: 2215 iNdEx = preIndex 2216 skippy, err := skipWrappers(dAtA[iNdEx:]) 2217 if err != nil { 2218 return err 2219 } 2220 if skippy < 0 { 2221 return ErrInvalidLengthWrappers 2222 } 2223 if (iNdEx + skippy) > l { 2224 return io.ErrUnexpectedEOF 2225 } 2226 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2227 iNdEx += skippy 2228 } 2229 } 2230 2231 if iNdEx > l { 2232 return io.ErrUnexpectedEOF 2233 } 2234 return nil 2235} 2236func (m *UInt32Value) Unmarshal(dAtA []byte) error { 2237 l := len(dAtA) 2238 iNdEx := 0 2239 for iNdEx < l { 2240 preIndex := iNdEx 2241 var wire uint64 2242 for shift := uint(0); ; shift += 7 { 2243 if shift >= 64 { 2244 return ErrIntOverflowWrappers 2245 } 2246 if iNdEx >= l { 2247 return io.ErrUnexpectedEOF 2248 } 2249 b := dAtA[iNdEx] 2250 iNdEx++ 2251 wire |= (uint64(b) & 0x7F) << shift 2252 if b < 0x80 { 2253 break 2254 } 2255 } 2256 fieldNum := int32(wire >> 3) 2257 wireType := int(wire & 0x7) 2258 if wireType == 4 { 2259 return fmt.Errorf("proto: UInt32Value: wiretype end group for non-group") 2260 } 2261 if fieldNum <= 0 { 2262 return fmt.Errorf("proto: UInt32Value: illegal tag %d (wire type %d)", fieldNum, wire) 2263 } 2264 switch fieldNum { 2265 case 1: 2266 if wireType != 0 { 2267 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2268 } 2269 m.Value = 0 2270 for shift := uint(0); ; shift += 7 { 2271 if shift >= 64 { 2272 return ErrIntOverflowWrappers 2273 } 2274 if iNdEx >= l { 2275 return io.ErrUnexpectedEOF 2276 } 2277 b := dAtA[iNdEx] 2278 iNdEx++ 2279 m.Value |= (uint32(b) & 0x7F) << shift 2280 if b < 0x80 { 2281 break 2282 } 2283 } 2284 default: 2285 iNdEx = preIndex 2286 skippy, err := skipWrappers(dAtA[iNdEx:]) 2287 if err != nil { 2288 return err 2289 } 2290 if skippy < 0 { 2291 return ErrInvalidLengthWrappers 2292 } 2293 if (iNdEx + skippy) > l { 2294 return io.ErrUnexpectedEOF 2295 } 2296 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2297 iNdEx += skippy 2298 } 2299 } 2300 2301 if iNdEx > l { 2302 return io.ErrUnexpectedEOF 2303 } 2304 return nil 2305} 2306func (m *BoolValue) Unmarshal(dAtA []byte) error { 2307 l := len(dAtA) 2308 iNdEx := 0 2309 for iNdEx < l { 2310 preIndex := iNdEx 2311 var wire uint64 2312 for shift := uint(0); ; shift += 7 { 2313 if shift >= 64 { 2314 return ErrIntOverflowWrappers 2315 } 2316 if iNdEx >= l { 2317 return io.ErrUnexpectedEOF 2318 } 2319 b := dAtA[iNdEx] 2320 iNdEx++ 2321 wire |= (uint64(b) & 0x7F) << shift 2322 if b < 0x80 { 2323 break 2324 } 2325 } 2326 fieldNum := int32(wire >> 3) 2327 wireType := int(wire & 0x7) 2328 if wireType == 4 { 2329 return fmt.Errorf("proto: BoolValue: wiretype end group for non-group") 2330 } 2331 if fieldNum <= 0 { 2332 return fmt.Errorf("proto: BoolValue: illegal tag %d (wire type %d)", fieldNum, wire) 2333 } 2334 switch fieldNum { 2335 case 1: 2336 if wireType != 0 { 2337 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2338 } 2339 var v int 2340 for shift := uint(0); ; shift += 7 { 2341 if shift >= 64 { 2342 return ErrIntOverflowWrappers 2343 } 2344 if iNdEx >= l { 2345 return io.ErrUnexpectedEOF 2346 } 2347 b := dAtA[iNdEx] 2348 iNdEx++ 2349 v |= (int(b) & 0x7F) << shift 2350 if b < 0x80 { 2351 break 2352 } 2353 } 2354 m.Value = bool(v != 0) 2355 default: 2356 iNdEx = preIndex 2357 skippy, err := skipWrappers(dAtA[iNdEx:]) 2358 if err != nil { 2359 return err 2360 } 2361 if skippy < 0 { 2362 return ErrInvalidLengthWrappers 2363 } 2364 if (iNdEx + skippy) > l { 2365 return io.ErrUnexpectedEOF 2366 } 2367 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2368 iNdEx += skippy 2369 } 2370 } 2371 2372 if iNdEx > l { 2373 return io.ErrUnexpectedEOF 2374 } 2375 return nil 2376} 2377func (m *StringValue) Unmarshal(dAtA []byte) error { 2378 l := len(dAtA) 2379 iNdEx := 0 2380 for iNdEx < l { 2381 preIndex := iNdEx 2382 var wire uint64 2383 for shift := uint(0); ; shift += 7 { 2384 if shift >= 64 { 2385 return ErrIntOverflowWrappers 2386 } 2387 if iNdEx >= l { 2388 return io.ErrUnexpectedEOF 2389 } 2390 b := dAtA[iNdEx] 2391 iNdEx++ 2392 wire |= (uint64(b) & 0x7F) << shift 2393 if b < 0x80 { 2394 break 2395 } 2396 } 2397 fieldNum := int32(wire >> 3) 2398 wireType := int(wire & 0x7) 2399 if wireType == 4 { 2400 return fmt.Errorf("proto: StringValue: wiretype end group for non-group") 2401 } 2402 if fieldNum <= 0 { 2403 return fmt.Errorf("proto: StringValue: illegal tag %d (wire type %d)", fieldNum, wire) 2404 } 2405 switch fieldNum { 2406 case 1: 2407 if wireType != 2 { 2408 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2409 } 2410 var stringLen uint64 2411 for shift := uint(0); ; shift += 7 { 2412 if shift >= 64 { 2413 return ErrIntOverflowWrappers 2414 } 2415 if iNdEx >= l { 2416 return io.ErrUnexpectedEOF 2417 } 2418 b := dAtA[iNdEx] 2419 iNdEx++ 2420 stringLen |= (uint64(b) & 0x7F) << shift 2421 if b < 0x80 { 2422 break 2423 } 2424 } 2425 intStringLen := int(stringLen) 2426 if intStringLen < 0 { 2427 return ErrInvalidLengthWrappers 2428 } 2429 postIndex := iNdEx + intStringLen 2430 if postIndex > l { 2431 return io.ErrUnexpectedEOF 2432 } 2433 m.Value = string(dAtA[iNdEx:postIndex]) 2434 iNdEx = postIndex 2435 default: 2436 iNdEx = preIndex 2437 skippy, err := skipWrappers(dAtA[iNdEx:]) 2438 if err != nil { 2439 return err 2440 } 2441 if skippy < 0 { 2442 return ErrInvalidLengthWrappers 2443 } 2444 if (iNdEx + skippy) > l { 2445 return io.ErrUnexpectedEOF 2446 } 2447 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2448 iNdEx += skippy 2449 } 2450 } 2451 2452 if iNdEx > l { 2453 return io.ErrUnexpectedEOF 2454 } 2455 return nil 2456} 2457func (m *BytesValue) Unmarshal(dAtA []byte) error { 2458 l := len(dAtA) 2459 iNdEx := 0 2460 for iNdEx < l { 2461 preIndex := iNdEx 2462 var wire uint64 2463 for shift := uint(0); ; shift += 7 { 2464 if shift >= 64 { 2465 return ErrIntOverflowWrappers 2466 } 2467 if iNdEx >= l { 2468 return io.ErrUnexpectedEOF 2469 } 2470 b := dAtA[iNdEx] 2471 iNdEx++ 2472 wire |= (uint64(b) & 0x7F) << shift 2473 if b < 0x80 { 2474 break 2475 } 2476 } 2477 fieldNum := int32(wire >> 3) 2478 wireType := int(wire & 0x7) 2479 if wireType == 4 { 2480 return fmt.Errorf("proto: BytesValue: wiretype end group for non-group") 2481 } 2482 if fieldNum <= 0 { 2483 return fmt.Errorf("proto: BytesValue: illegal tag %d (wire type %d)", fieldNum, wire) 2484 } 2485 switch fieldNum { 2486 case 1: 2487 if wireType != 2 { 2488 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2489 } 2490 var byteLen int 2491 for shift := uint(0); ; shift += 7 { 2492 if shift >= 64 { 2493 return ErrIntOverflowWrappers 2494 } 2495 if iNdEx >= l { 2496 return io.ErrUnexpectedEOF 2497 } 2498 b := dAtA[iNdEx] 2499 iNdEx++ 2500 byteLen |= (int(b) & 0x7F) << shift 2501 if b < 0x80 { 2502 break 2503 } 2504 } 2505 if byteLen < 0 { 2506 return ErrInvalidLengthWrappers 2507 } 2508 postIndex := iNdEx + byteLen 2509 if postIndex > l { 2510 return io.ErrUnexpectedEOF 2511 } 2512 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 2513 if m.Value == nil { 2514 m.Value = []byte{} 2515 } 2516 iNdEx = postIndex 2517 default: 2518 iNdEx = preIndex 2519 skippy, err := skipWrappers(dAtA[iNdEx:]) 2520 if err != nil { 2521 return err 2522 } 2523 if skippy < 0 { 2524 return ErrInvalidLengthWrappers 2525 } 2526 if (iNdEx + skippy) > l { 2527 return io.ErrUnexpectedEOF 2528 } 2529 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2530 iNdEx += skippy 2531 } 2532 } 2533 2534 if iNdEx > l { 2535 return io.ErrUnexpectedEOF 2536 } 2537 return nil 2538} 2539func skipWrappers(dAtA []byte) (n int, err error) { 2540 l := len(dAtA) 2541 iNdEx := 0 2542 for iNdEx < l { 2543 var wire uint64 2544 for shift := uint(0); ; shift += 7 { 2545 if shift >= 64 { 2546 return 0, ErrIntOverflowWrappers 2547 } 2548 if iNdEx >= l { 2549 return 0, io.ErrUnexpectedEOF 2550 } 2551 b := dAtA[iNdEx] 2552 iNdEx++ 2553 wire |= (uint64(b) & 0x7F) << shift 2554 if b < 0x80 { 2555 break 2556 } 2557 } 2558 wireType := int(wire & 0x7) 2559 switch wireType { 2560 case 0: 2561 for shift := uint(0); ; shift += 7 { 2562 if shift >= 64 { 2563 return 0, ErrIntOverflowWrappers 2564 } 2565 if iNdEx >= l { 2566 return 0, io.ErrUnexpectedEOF 2567 } 2568 iNdEx++ 2569 if dAtA[iNdEx-1] < 0x80 { 2570 break 2571 } 2572 } 2573 return iNdEx, nil 2574 case 1: 2575 iNdEx += 8 2576 return iNdEx, nil 2577 case 2: 2578 var length int 2579 for shift := uint(0); ; shift += 7 { 2580 if shift >= 64 { 2581 return 0, ErrIntOverflowWrappers 2582 } 2583 if iNdEx >= l { 2584 return 0, io.ErrUnexpectedEOF 2585 } 2586 b := dAtA[iNdEx] 2587 iNdEx++ 2588 length |= (int(b) & 0x7F) << shift 2589 if b < 0x80 { 2590 break 2591 } 2592 } 2593 iNdEx += length 2594 if length < 0 { 2595 return 0, ErrInvalidLengthWrappers 2596 } 2597 return iNdEx, nil 2598 case 3: 2599 for { 2600 var innerWire uint64 2601 var start int = iNdEx 2602 for shift := uint(0); ; shift += 7 { 2603 if shift >= 64 { 2604 return 0, ErrIntOverflowWrappers 2605 } 2606 if iNdEx >= l { 2607 return 0, io.ErrUnexpectedEOF 2608 } 2609 b := dAtA[iNdEx] 2610 iNdEx++ 2611 innerWire |= (uint64(b) & 0x7F) << shift 2612 if b < 0x80 { 2613 break 2614 } 2615 } 2616 innerWireType := int(innerWire & 0x7) 2617 if innerWireType == 4 { 2618 break 2619 } 2620 next, err := skipWrappers(dAtA[start:]) 2621 if err != nil { 2622 return 0, err 2623 } 2624 iNdEx = start + next 2625 } 2626 return iNdEx, nil 2627 case 4: 2628 return iNdEx, nil 2629 case 5: 2630 iNdEx += 4 2631 return iNdEx, nil 2632 default: 2633 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 2634 } 2635 } 2636 panic("unreachable") 2637} 2638 2639var ( 2640 ErrInvalidLengthWrappers = fmt.Errorf("proto: negative length found during unmarshaling") 2641 ErrIntOverflowWrappers = fmt.Errorf("proto: integer overflow") 2642) 2643 2644func init() { 2645 proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_wrappers_c5239a825c7dfb53) 2646} 2647 2648var fileDescriptor_wrappers_c5239a825c7dfb53 = []byte{ 2649 // 285 bytes of a gzipped FileDescriptorProto 2650 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f, 2651 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c, 2652 0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca, 2653 0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c, 2654 0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5, 2655 0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13, 2656 0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8, 2657 0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca, 2658 0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a, 2659 0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x3b, 2660 0xe3, 0x8d, 0x87, 0x72, 0x0c, 0x1f, 0x1e, 0xca, 0x31, 0xfe, 0x78, 0x28, 0xc7, 0xd8, 0xf0, 0x48, 2661 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 2662 0x48, 0x8e, 0xf1, 0xc5, 0x23, 0x39, 0x86, 0x0f, 0x20, 0xf1, 0xc7, 0x72, 0x8c, 0x27, 0x1e, 0xcb, 2663 0x31, 0x72, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x45, 0x87, 0x13, 0x6f, 0x38, 0x34, 0xbe, 0x02, 2664 0x40, 0x22, 0x01, 0x8c, 0x51, 0xac, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x3f, 0x18, 0x19, 0x17, 0x31, 2665 0x31, 0xbb, 0x07, 0x38, 0xad, 0x62, 0x92, 0x73, 0x87, 0x68, 0x09, 0x80, 0x6a, 0xd1, 0x0b, 0x4f, 2666 0xcd, 0xc9, 0xf1, 0xce, 0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0xa9, 0x4c, 0x62, 0x03, 0x9b, 0x65, 0x0c, 2667 0x08, 0x00, 0x00, 0xff, 0xff, 0x31, 0x55, 0x64, 0x90, 0x0a, 0x02, 0x00, 0x00, 2668} 2669