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