1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: unmarshalmerge.proto 3 4package unmarshalmerge 5 6import ( 7 bytes "bytes" 8 encoding_binary "encoding/binary" 9 fmt "fmt" 10 _ "github.com/gogo/protobuf/gogoproto" 11 github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" 12 proto "github.com/gogo/protobuf/proto" 13 io "io" 14 math "math" 15 reflect "reflect" 16 strings "strings" 17) 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package 29 30type Big struct { 31 Sub *Sub `protobuf:"bytes,1,opt,name=Sub" json:"Sub,omitempty"` 32 Number *int64 `protobuf:"varint,2,opt,name=Number" json:"Number,omitempty"` 33 XXX_NoUnkeyedLiteral struct{} `json:"-"` 34 XXX_unrecognized []byte `json:"-"` 35 XXX_sizecache int32 `json:"-"` 36} 37 38func (m *Big) Reset() { *m = Big{} } 39func (*Big) ProtoMessage() {} 40func (*Big) Descriptor() ([]byte, []int) { 41 return fileDescriptor_701a7743bfe9c603, []int{0} 42} 43func (m *Big) XXX_Unmarshal(b []byte) error { 44 return m.Unmarshal(b) 45} 46func (m *Big) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 47 return xxx_messageInfo_Big.Marshal(b, m, deterministic) 48} 49func (m *Big) XXX_Merge(src proto.Message) { 50 xxx_messageInfo_Big.Merge(m, src) 51} 52func (m *Big) XXX_Size() int { 53 return xxx_messageInfo_Big.Size(m) 54} 55func (m *Big) XXX_DiscardUnknown() { 56 xxx_messageInfo_Big.DiscardUnknown(m) 57} 58 59var xxx_messageInfo_Big proto.InternalMessageInfo 60 61func (m *Big) GetSub() *Sub { 62 if m != nil { 63 return m.Sub 64 } 65 return nil 66} 67 68func (m *Big) GetNumber() int64 { 69 if m != nil && m.Number != nil { 70 return *m.Number 71 } 72 return 0 73} 74 75type BigUnsafe struct { 76 Sub *Sub `protobuf:"bytes,1,opt,name=Sub" json:"Sub,omitempty"` 77 Number *int64 `protobuf:"varint,2,opt,name=Number" json:"Number,omitempty"` 78 XXX_NoUnkeyedLiteral struct{} `json:"-"` 79 XXX_unrecognized []byte `json:"-"` 80 XXX_sizecache int32 `json:"-"` 81} 82 83func (m *BigUnsafe) Reset() { *m = BigUnsafe{} } 84func (*BigUnsafe) ProtoMessage() {} 85func (*BigUnsafe) Descriptor() ([]byte, []int) { 86 return fileDescriptor_701a7743bfe9c603, []int{1} 87} 88func (m *BigUnsafe) XXX_Unmarshal(b []byte) error { 89 return xxx_messageInfo_BigUnsafe.Unmarshal(m, b) 90} 91func (m *BigUnsafe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 92 return xxx_messageInfo_BigUnsafe.Marshal(b, m, deterministic) 93} 94func (m *BigUnsafe) XXX_Merge(src proto.Message) { 95 xxx_messageInfo_BigUnsafe.Merge(m, src) 96} 97func (m *BigUnsafe) XXX_Size() int { 98 return xxx_messageInfo_BigUnsafe.Size(m) 99} 100func (m *BigUnsafe) XXX_DiscardUnknown() { 101 xxx_messageInfo_BigUnsafe.DiscardUnknown(m) 102} 103 104var xxx_messageInfo_BigUnsafe proto.InternalMessageInfo 105 106func (m *BigUnsafe) GetSub() *Sub { 107 if m != nil { 108 return m.Sub 109 } 110 return nil 111} 112 113func (m *BigUnsafe) GetNumber() int64 { 114 if m != nil && m.Number != nil { 115 return *m.Number 116 } 117 return 0 118} 119 120type Sub struct { 121 SubNumber *int64 `protobuf:"varint,1,opt,name=SubNumber" json:"SubNumber,omitempty"` 122 XXX_NoUnkeyedLiteral struct{} `json:"-"` 123 XXX_unrecognized []byte `json:"-"` 124 XXX_sizecache int32 `json:"-"` 125} 126 127func (m *Sub) Reset() { *m = Sub{} } 128func (*Sub) ProtoMessage() {} 129func (*Sub) Descriptor() ([]byte, []int) { 130 return fileDescriptor_701a7743bfe9c603, []int{2} 131} 132func (m *Sub) XXX_Unmarshal(b []byte) error { 133 return m.Unmarshal(b) 134} 135func (m *Sub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 136 return xxx_messageInfo_Sub.Marshal(b, m, deterministic) 137} 138func (m *Sub) XXX_Merge(src proto.Message) { 139 xxx_messageInfo_Sub.Merge(m, src) 140} 141func (m *Sub) XXX_Size() int { 142 return xxx_messageInfo_Sub.Size(m) 143} 144func (m *Sub) XXX_DiscardUnknown() { 145 xxx_messageInfo_Sub.DiscardUnknown(m) 146} 147 148var xxx_messageInfo_Sub proto.InternalMessageInfo 149 150func (m *Sub) GetSubNumber() int64 { 151 if m != nil && m.SubNumber != nil { 152 return *m.SubNumber 153 } 154 return 0 155} 156 157type IntMerge struct { 158 Int64 int64 `protobuf:"varint,1,req,name=Int64" json:"Int64"` 159 Int32 int32 `protobuf:"varint,2,opt,name=Int32" json:"Int32"` 160 Sint32 int32 `protobuf:"zigzag32,3,req,name=Sint32" json:"Sint32"` 161 Sint64 int64 `protobuf:"zigzag64,4,opt,name=Sint64" json:"Sint64"` 162 Uint64 uint64 `protobuf:"varint,5,opt,name=Uint64" json:"Uint64"` 163 Uint32 uint32 `protobuf:"varint,6,req,name=Uint32" json:"Uint32"` 164 Fixed64 uint64 `protobuf:"fixed64,7,opt,name=Fixed64" json:"Fixed64"` 165 Fixed32 uint32 `protobuf:"fixed32,8,opt,name=Fixed32" json:"Fixed32"` 166 Sfixed32 int32 `protobuf:"fixed32,9,req,name=Sfixed32" json:"Sfixed32"` 167 Sfixed64 int64 `protobuf:"fixed64,10,opt,name=Sfixed64" json:"Sfixed64"` 168 Bool bool `protobuf:"varint,11,opt,name=Bool" json:"Bool"` 169 XXX_NoUnkeyedLiteral struct{} `json:"-"` 170 XXX_unrecognized []byte `json:"-"` 171 XXX_sizecache int32 `json:"-"` 172} 173 174func (m *IntMerge) Reset() { *m = IntMerge{} } 175func (*IntMerge) ProtoMessage() {} 176func (*IntMerge) Descriptor() ([]byte, []int) { 177 return fileDescriptor_701a7743bfe9c603, []int{3} 178} 179func (m *IntMerge) XXX_Unmarshal(b []byte) error { 180 return m.Unmarshal(b) 181} 182func (m *IntMerge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 183 return xxx_messageInfo_IntMerge.Marshal(b, m, deterministic) 184} 185func (m *IntMerge) XXX_Merge(src proto.Message) { 186 xxx_messageInfo_IntMerge.Merge(m, src) 187} 188func (m *IntMerge) XXX_Size() int { 189 return xxx_messageInfo_IntMerge.Size(m) 190} 191func (m *IntMerge) XXX_DiscardUnknown() { 192 xxx_messageInfo_IntMerge.DiscardUnknown(m) 193} 194 195var xxx_messageInfo_IntMerge proto.InternalMessageInfo 196 197func (m *IntMerge) GetInt64() int64 { 198 if m != nil { 199 return m.Int64 200 } 201 return 0 202} 203 204func (m *IntMerge) GetInt32() int32 { 205 if m != nil { 206 return m.Int32 207 } 208 return 0 209} 210 211func (m *IntMerge) GetSint32() int32 { 212 if m != nil { 213 return m.Sint32 214 } 215 return 0 216} 217 218func (m *IntMerge) GetSint64() int64 { 219 if m != nil { 220 return m.Sint64 221 } 222 return 0 223} 224 225func (m *IntMerge) GetUint64() uint64 { 226 if m != nil { 227 return m.Uint64 228 } 229 return 0 230} 231 232func (m *IntMerge) GetUint32() uint32 { 233 if m != nil { 234 return m.Uint32 235 } 236 return 0 237} 238 239func (m *IntMerge) GetFixed64() uint64 { 240 if m != nil { 241 return m.Fixed64 242 } 243 return 0 244} 245 246func (m *IntMerge) GetFixed32() uint32 { 247 if m != nil { 248 return m.Fixed32 249 } 250 return 0 251} 252 253func (m *IntMerge) GetSfixed32() int32 { 254 if m != nil { 255 return m.Sfixed32 256 } 257 return 0 258} 259 260func (m *IntMerge) GetSfixed64() int64 { 261 if m != nil { 262 return m.Sfixed64 263 } 264 return 0 265} 266 267func (m *IntMerge) GetBool() bool { 268 if m != nil { 269 return m.Bool 270 } 271 return false 272} 273 274func init() { 275 proto.RegisterType((*Big)(nil), "unmarshalmerge.Big") 276 proto.RegisterType((*BigUnsafe)(nil), "unmarshalmerge.BigUnsafe") 277 proto.RegisterType((*Sub)(nil), "unmarshalmerge.Sub") 278 proto.RegisterType((*IntMerge)(nil), "unmarshalmerge.IntMerge") 279} 280 281func init() { proto.RegisterFile("unmarshalmerge.proto", fileDescriptor_701a7743bfe9c603) } 282 283var fileDescriptor_701a7743bfe9c603 = []byte{ 284 // 386 bytes of a gzipped FileDescriptorProto 285 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0xd0, 0xcd, 0x8a, 0x9b, 0x50, 286 0x14, 0x07, 0xf0, 0x1c, 0x35, 0xc6, 0xdc, 0xd0, 0xaf, 0xdb, 0x52, 0x2e, 0x21, 0xdc, 0x5c, 0x02, 287 0x85, 0xdb, 0x45, 0x13, 0x50, 0x71, 0xd1, 0xa5, 0x8b, 0x42, 0x0a, 0x2d, 0x25, 0x92, 0x07, 0x88, 288 0xad, 0x31, 0x42, 0xd4, 0x62, 0x14, 0xba, 0xec, 0x23, 0xf4, 0x15, 0xba, 0x9b, 0x47, 0x98, 0x65, 289 0x96, 0xf3, 0x08, 0xb3, 0x0a, 0xa3, 0x4f, 0x30, 0xcb, 0x59, 0x0e, 0x5e, 0x6f, 0x3e, 0x9c, 0xed, 290 0xec, 0x3c, 0xff, 0xdf, 0xdf, 0x73, 0xe0, 0xa2, 0x77, 0x45, 0x12, 0xaf, 0xb2, 0xdd, 0x66, 0xb5, 291 0x8d, 0x83, 0x2c, 0x0c, 0xa6, 0xbf, 0xb3, 0x34, 0x4f, 0xf1, 0xcb, 0x76, 0x3a, 0xfc, 0x14, 0x46, 292 0xf9, 0xa6, 0xf0, 0xa7, 0x3f, 0xd3, 0x78, 0x16, 0xa6, 0x61, 0x3a, 0x13, 0x35, 0xbf, 0x58, 0x8b, 293 0x49, 0x0c, 0xe2, 0xab, 0xf9, 0x7d, 0xf2, 0x15, 0xa9, 0x6e, 0x14, 0xe2, 0x0f, 0x48, 0xf5, 0x0a, 294 0x9f, 0x00, 0x03, 0x3e, 0x30, 0xdf, 0x4e, 0x9f, 0x5c, 0xf2, 0x0a, 0x7f, 0x51, 0x3b, 0x7e, 0x8f, 295 0xf4, 0xef, 0x45, 0xec, 0x07, 0x19, 0x51, 0x18, 0x70, 0x75, 0x21, 0xa7, 0xcf, 0xda, 0xbf, 0xff, 296 0x63, 0x98, 0xfc, 0x40, 0x7d, 0x37, 0x0a, 0x97, 0xc9, 0x6e, 0xb5, 0x0e, 0x9e, 0xbd, 0x71, 0x5f, 297 0x6f, 0xfc, 0x28, 0x96, 0xe0, 0x11, 0xea, 0x7b, 0x85, 0x2f, 0x7b, 0x20, 0x7a, 0xe7, 0x40, 0x1e, 298 0x3f, 0x28, 0xc8, 0x98, 0x27, 0xf9, 0xb7, 0x7a, 0x3d, 0x1e, 0xa2, 0xee, 0x3c, 0xc9, 0x1d, 0x9b, 299 0x00, 0x53, 0xb8, 0xea, 0x6a, 0x37, 0x87, 0x71, 0x67, 0xd1, 0x44, 0xd2, 0x2c, 0x53, 0x1c, 0xec, 300 0x5e, 0x98, 0x65, 0xe2, 0x11, 0xd2, 0xbd, 0x48, 0xa0, 0xca, 0x14, 0xfe, 0x46, 0xa2, 0xcc, 0x8e, 301 0xea, 0xd8, 0x44, 0x63, 0xc0, 0xf1, 0xa5, 0x3a, 0x76, 0xad, 0xcb, 0x46, 0xbb, 0x0c, 0xb8, 0x76, 302 0xd4, 0x65, 0x4b, 0x2d, 0x93, 0xe8, 0x4c, 0xe1, 0x2f, 0x2e, 0xd5, 0x32, 0x31, 0x45, 0xbd, 0x2f, 303 0xd1, 0x9f, 0xe0, 0x97, 0x63, 0x93, 0x1e, 0x03, 0xae, 0x4b, 0x3e, 0x86, 0x27, 0xb7, 0x4c, 0x62, 304 0x30, 0xe0, 0xbd, 0x96, 0x5b, 0x26, 0x66, 0xc8, 0xf0, 0xd6, 0xb2, 0xd0, 0x67, 0x0a, 0x7f, 0x25, 305 0x0b, 0xa7, 0xf4, 0xdc, 0x70, 0x6c, 0x82, 0x18, 0xf0, 0xd7, 0xed, 0x86, 0x63, 0x63, 0x82, 0x34, 306 0x37, 0x4d, 0xb7, 0x64, 0xc0, 0x80, 0x1b, 0x52, 0x45, 0xd2, 0x3c, 0xb0, 0xcb, 0x6e, 0x4b, 0xda, 307 0xb9, 0x2b, 0x29, 0xdc, 0x97, 0x14, 0x1e, 0x4a, 0x0a, 0x7f, 0x2b, 0x0a, 0x57, 0x15, 0x85, 0xeb, 308 0x8a, 0xc2, 0xbe, 0xa2, 0xf0, 0x18, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x4e, 0xc7, 0x4e, 0xa1, 0x02, 309 0x00, 0x00, 310} 311 312func (this *Big) VerboseEqual(that interface{}) error { 313 if that == nil { 314 if this == nil { 315 return nil 316 } 317 return fmt.Errorf("that == nil && this != nil") 318 } 319 320 that1, ok := that.(*Big) 321 if !ok { 322 that2, ok := that.(Big) 323 if ok { 324 that1 = &that2 325 } else { 326 return fmt.Errorf("that is not of type *Big") 327 } 328 } 329 if that1 == nil { 330 if this == nil { 331 return nil 332 } 333 return fmt.Errorf("that is type *Big but is nil && this != nil") 334 } else if this == nil { 335 return fmt.Errorf("that is type *Big but is not nil && this == nil") 336 } 337 if !this.Sub.Equal(that1.Sub) { 338 return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) 339 } 340 if this.Number != nil && that1.Number != nil { 341 if *this.Number != *that1.Number { 342 return fmt.Errorf("Number this(%v) Not Equal that(%v)", *this.Number, *that1.Number) 343 } 344 } else if this.Number != nil { 345 return fmt.Errorf("this.Number == nil && that.Number != nil") 346 } else if that1.Number != nil { 347 return fmt.Errorf("Number this(%v) Not Equal that(%v)", this.Number, that1.Number) 348 } 349 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 350 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) 351 } 352 return nil 353} 354func (this *Big) Equal(that interface{}) bool { 355 if that == nil { 356 return this == nil 357 } 358 359 that1, ok := that.(*Big) 360 if !ok { 361 that2, ok := that.(Big) 362 if ok { 363 that1 = &that2 364 } else { 365 return false 366 } 367 } 368 if that1 == nil { 369 return this == nil 370 } else if this == nil { 371 return false 372 } 373 if !this.Sub.Equal(that1.Sub) { 374 return false 375 } 376 if this.Number != nil && that1.Number != nil { 377 if *this.Number != *that1.Number { 378 return false 379 } 380 } else if this.Number != nil { 381 return false 382 } else if that1.Number != nil { 383 return false 384 } 385 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 386 return false 387 } 388 return true 389} 390func (this *BigUnsafe) VerboseEqual(that interface{}) error { 391 if that == nil { 392 if this == nil { 393 return nil 394 } 395 return fmt.Errorf("that == nil && this != nil") 396 } 397 398 that1, ok := that.(*BigUnsafe) 399 if !ok { 400 that2, ok := that.(BigUnsafe) 401 if ok { 402 that1 = &that2 403 } else { 404 return fmt.Errorf("that is not of type *BigUnsafe") 405 } 406 } 407 if that1 == nil { 408 if this == nil { 409 return nil 410 } 411 return fmt.Errorf("that is type *BigUnsafe but is nil && this != nil") 412 } else if this == nil { 413 return fmt.Errorf("that is type *BigUnsafe but is not nil && this == nil") 414 } 415 if !this.Sub.Equal(that1.Sub) { 416 return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) 417 } 418 if this.Number != nil && that1.Number != nil { 419 if *this.Number != *that1.Number { 420 return fmt.Errorf("Number this(%v) Not Equal that(%v)", *this.Number, *that1.Number) 421 } 422 } else if this.Number != nil { 423 return fmt.Errorf("this.Number == nil && that.Number != nil") 424 } else if that1.Number != nil { 425 return fmt.Errorf("Number this(%v) Not Equal that(%v)", this.Number, that1.Number) 426 } 427 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 428 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) 429 } 430 return nil 431} 432func (this *BigUnsafe) Equal(that interface{}) bool { 433 if that == nil { 434 return this == nil 435 } 436 437 that1, ok := that.(*BigUnsafe) 438 if !ok { 439 that2, ok := that.(BigUnsafe) 440 if ok { 441 that1 = &that2 442 } else { 443 return false 444 } 445 } 446 if that1 == nil { 447 return this == nil 448 } else if this == nil { 449 return false 450 } 451 if !this.Sub.Equal(that1.Sub) { 452 return false 453 } 454 if this.Number != nil && that1.Number != nil { 455 if *this.Number != *that1.Number { 456 return false 457 } 458 } else if this.Number != nil { 459 return false 460 } else if that1.Number != nil { 461 return false 462 } 463 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 464 return false 465 } 466 return true 467} 468func (this *Sub) VerboseEqual(that interface{}) error { 469 if that == nil { 470 if this == nil { 471 return nil 472 } 473 return fmt.Errorf("that == nil && this != nil") 474 } 475 476 that1, ok := that.(*Sub) 477 if !ok { 478 that2, ok := that.(Sub) 479 if ok { 480 that1 = &that2 481 } else { 482 return fmt.Errorf("that is not of type *Sub") 483 } 484 } 485 if that1 == nil { 486 if this == nil { 487 return nil 488 } 489 return fmt.Errorf("that is type *Sub but is nil && this != nil") 490 } else if this == nil { 491 return fmt.Errorf("that is type *Sub but is not nil && this == nil") 492 } 493 if this.SubNumber != nil && that1.SubNumber != nil { 494 if *this.SubNumber != *that1.SubNumber { 495 return fmt.Errorf("SubNumber this(%v) Not Equal that(%v)", *this.SubNumber, *that1.SubNumber) 496 } 497 } else if this.SubNumber != nil { 498 return fmt.Errorf("this.SubNumber == nil && that.SubNumber != nil") 499 } else if that1.SubNumber != nil { 500 return fmt.Errorf("SubNumber this(%v) Not Equal that(%v)", this.SubNumber, that1.SubNumber) 501 } 502 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 503 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) 504 } 505 return nil 506} 507func (this *Sub) Equal(that interface{}) bool { 508 if that == nil { 509 return this == nil 510 } 511 512 that1, ok := that.(*Sub) 513 if !ok { 514 that2, ok := that.(Sub) 515 if ok { 516 that1 = &that2 517 } else { 518 return false 519 } 520 } 521 if that1 == nil { 522 return this == nil 523 } else if this == nil { 524 return false 525 } 526 if this.SubNumber != nil && that1.SubNumber != nil { 527 if *this.SubNumber != *that1.SubNumber { 528 return false 529 } 530 } else if this.SubNumber != nil { 531 return false 532 } else if that1.SubNumber != nil { 533 return false 534 } 535 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 536 return false 537 } 538 return true 539} 540func (this *IntMerge) VerboseEqual(that interface{}) error { 541 if that == nil { 542 if this == nil { 543 return nil 544 } 545 return fmt.Errorf("that == nil && this != nil") 546 } 547 548 that1, ok := that.(*IntMerge) 549 if !ok { 550 that2, ok := that.(IntMerge) 551 if ok { 552 that1 = &that2 553 } else { 554 return fmt.Errorf("that is not of type *IntMerge") 555 } 556 } 557 if that1 == nil { 558 if this == nil { 559 return nil 560 } 561 return fmt.Errorf("that is type *IntMerge but is nil && this != nil") 562 } else if this == nil { 563 return fmt.Errorf("that is type *IntMerge but is not nil && this == nil") 564 } 565 if this.Int64 != that1.Int64 { 566 return fmt.Errorf("Int64 this(%v) Not Equal that(%v)", this.Int64, that1.Int64) 567 } 568 if this.Int32 != that1.Int32 { 569 return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) 570 } 571 if this.Sint32 != that1.Sint32 { 572 return fmt.Errorf("Sint32 this(%v) Not Equal that(%v)", this.Sint32, that1.Sint32) 573 } 574 if this.Sint64 != that1.Sint64 { 575 return fmt.Errorf("Sint64 this(%v) Not Equal that(%v)", this.Sint64, that1.Sint64) 576 } 577 if this.Uint64 != that1.Uint64 { 578 return fmt.Errorf("Uint64 this(%v) Not Equal that(%v)", this.Uint64, that1.Uint64) 579 } 580 if this.Uint32 != that1.Uint32 { 581 return fmt.Errorf("Uint32 this(%v) Not Equal that(%v)", this.Uint32, that1.Uint32) 582 } 583 if this.Fixed64 != that1.Fixed64 { 584 return fmt.Errorf("Fixed64 this(%v) Not Equal that(%v)", this.Fixed64, that1.Fixed64) 585 } 586 if this.Fixed32 != that1.Fixed32 { 587 return fmt.Errorf("Fixed32 this(%v) Not Equal that(%v)", this.Fixed32, that1.Fixed32) 588 } 589 if this.Sfixed32 != that1.Sfixed32 { 590 return fmt.Errorf("Sfixed32 this(%v) Not Equal that(%v)", this.Sfixed32, that1.Sfixed32) 591 } 592 if this.Sfixed64 != that1.Sfixed64 { 593 return fmt.Errorf("Sfixed64 this(%v) Not Equal that(%v)", this.Sfixed64, that1.Sfixed64) 594 } 595 if this.Bool != that1.Bool { 596 return fmt.Errorf("Bool this(%v) Not Equal that(%v)", this.Bool, that1.Bool) 597 } 598 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 599 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) 600 } 601 return nil 602} 603func (this *IntMerge) Equal(that interface{}) bool { 604 if that == nil { 605 return this == nil 606 } 607 608 that1, ok := that.(*IntMerge) 609 if !ok { 610 that2, ok := that.(IntMerge) 611 if ok { 612 that1 = &that2 613 } else { 614 return false 615 } 616 } 617 if that1 == nil { 618 return this == nil 619 } else if this == nil { 620 return false 621 } 622 if this.Int64 != that1.Int64 { 623 return false 624 } 625 if this.Int32 != that1.Int32 { 626 return false 627 } 628 if this.Sint32 != that1.Sint32 { 629 return false 630 } 631 if this.Sint64 != that1.Sint64 { 632 return false 633 } 634 if this.Uint64 != that1.Uint64 { 635 return false 636 } 637 if this.Uint32 != that1.Uint32 { 638 return false 639 } 640 if this.Fixed64 != that1.Fixed64 { 641 return false 642 } 643 if this.Fixed32 != that1.Fixed32 { 644 return false 645 } 646 if this.Sfixed32 != that1.Sfixed32 { 647 return false 648 } 649 if this.Sfixed64 != that1.Sfixed64 { 650 return false 651 } 652 if this.Bool != that1.Bool { 653 return false 654 } 655 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 656 return false 657 } 658 return true 659} 660func (this *Big) GoString() string { 661 if this == nil { 662 return "nil" 663 } 664 s := make([]string, 0, 6) 665 s = append(s, "&unmarshalmerge.Big{") 666 if this.Sub != nil { 667 s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") 668 } 669 if this.Number != nil { 670 s = append(s, "Number: "+valueToGoStringUnmarshalmerge(this.Number, "int64")+",\n") 671 } 672 if this.XXX_unrecognized != nil { 673 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 674 } 675 s = append(s, "}") 676 return strings.Join(s, "") 677} 678func (this *BigUnsafe) GoString() string { 679 if this == nil { 680 return "nil" 681 } 682 s := make([]string, 0, 6) 683 s = append(s, "&unmarshalmerge.BigUnsafe{") 684 if this.Sub != nil { 685 s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") 686 } 687 if this.Number != nil { 688 s = append(s, "Number: "+valueToGoStringUnmarshalmerge(this.Number, "int64")+",\n") 689 } 690 if this.XXX_unrecognized != nil { 691 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 692 } 693 s = append(s, "}") 694 return strings.Join(s, "") 695} 696func (this *Sub) GoString() string { 697 if this == nil { 698 return "nil" 699 } 700 s := make([]string, 0, 5) 701 s = append(s, "&unmarshalmerge.Sub{") 702 if this.SubNumber != nil { 703 s = append(s, "SubNumber: "+valueToGoStringUnmarshalmerge(this.SubNumber, "int64")+",\n") 704 } 705 if this.XXX_unrecognized != nil { 706 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 707 } 708 s = append(s, "}") 709 return strings.Join(s, "") 710} 711func (this *IntMerge) GoString() string { 712 if this == nil { 713 return "nil" 714 } 715 s := make([]string, 0, 15) 716 s = append(s, "&unmarshalmerge.IntMerge{") 717 s = append(s, "Int64: "+fmt.Sprintf("%#v", this.Int64)+",\n") 718 s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") 719 s = append(s, "Sint32: "+fmt.Sprintf("%#v", this.Sint32)+",\n") 720 s = append(s, "Sint64: "+fmt.Sprintf("%#v", this.Sint64)+",\n") 721 s = append(s, "Uint64: "+fmt.Sprintf("%#v", this.Uint64)+",\n") 722 s = append(s, "Uint32: "+fmt.Sprintf("%#v", this.Uint32)+",\n") 723 s = append(s, "Fixed64: "+fmt.Sprintf("%#v", this.Fixed64)+",\n") 724 s = append(s, "Fixed32: "+fmt.Sprintf("%#v", this.Fixed32)+",\n") 725 s = append(s, "Sfixed32: "+fmt.Sprintf("%#v", this.Sfixed32)+",\n") 726 s = append(s, "Sfixed64: "+fmt.Sprintf("%#v", this.Sfixed64)+",\n") 727 s = append(s, "Bool: "+fmt.Sprintf("%#v", this.Bool)+",\n") 728 if this.XXX_unrecognized != nil { 729 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 730 } 731 s = append(s, "}") 732 return strings.Join(s, "") 733} 734func valueToGoStringUnmarshalmerge(v interface{}, typ string) string { 735 rv := reflect.ValueOf(v) 736 if rv.IsNil() { 737 return "nil" 738 } 739 pv := reflect.Indirect(rv).Interface() 740 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) 741} 742func NewPopulatedBig(r randyUnmarshalmerge, easy bool) *Big { 743 this := &Big{} 744 if r.Intn(5) != 0 { 745 this.Sub = NewPopulatedSub(r, easy) 746 } 747 if r.Intn(5) != 0 { 748 v1 := int64(r.Int63()) 749 if r.Intn(2) == 0 { 750 v1 *= -1 751 } 752 this.Number = &v1 753 } 754 if !easy && r.Intn(10) != 0 { 755 this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 3) 756 } 757 return this 758} 759 760func NewPopulatedBigUnsafe(r randyUnmarshalmerge, easy bool) *BigUnsafe { 761 this := &BigUnsafe{} 762 if r.Intn(5) != 0 { 763 this.Sub = NewPopulatedSub(r, easy) 764 } 765 if r.Intn(5) != 0 { 766 v2 := int64(r.Int63()) 767 if r.Intn(2) == 0 { 768 v2 *= -1 769 } 770 this.Number = &v2 771 } 772 if !easy && r.Intn(10) != 0 { 773 this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 3) 774 } 775 return this 776} 777 778func NewPopulatedSub(r randyUnmarshalmerge, easy bool) *Sub { 779 this := &Sub{} 780 if r.Intn(5) != 0 { 781 v3 := int64(r.Int63()) 782 if r.Intn(2) == 0 { 783 v3 *= -1 784 } 785 this.SubNumber = &v3 786 } 787 if !easy && r.Intn(10) != 0 { 788 this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 2) 789 } 790 return this 791} 792 793func NewPopulatedIntMerge(r randyUnmarshalmerge, easy bool) *IntMerge { 794 this := &IntMerge{} 795 this.Int64 = int64(r.Int63()) 796 if r.Intn(2) == 0 { 797 this.Int64 *= -1 798 } 799 this.Int32 = int32(r.Int31()) 800 if r.Intn(2) == 0 { 801 this.Int32 *= -1 802 } 803 this.Sint32 = int32(r.Int31()) 804 if r.Intn(2) == 0 { 805 this.Sint32 *= -1 806 } 807 this.Sint64 = int64(r.Int63()) 808 if r.Intn(2) == 0 { 809 this.Sint64 *= -1 810 } 811 this.Uint64 = uint64(uint64(r.Uint32())) 812 this.Uint32 = uint32(r.Uint32()) 813 this.Fixed64 = uint64(uint64(r.Uint32())) 814 this.Fixed32 = uint32(r.Uint32()) 815 this.Sfixed32 = int32(r.Int31()) 816 if r.Intn(2) == 0 { 817 this.Sfixed32 *= -1 818 } 819 this.Sfixed64 = int64(r.Int63()) 820 if r.Intn(2) == 0 { 821 this.Sfixed64 *= -1 822 } 823 this.Bool = bool(bool(r.Intn(2) == 0)) 824 if !easy && r.Intn(10) != 0 { 825 this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 12) 826 } 827 return this 828} 829 830type randyUnmarshalmerge interface { 831 Float32() float32 832 Float64() float64 833 Int63() int64 834 Int31() int32 835 Uint32() uint32 836 Intn(n int) int 837} 838 839func randUTF8RuneUnmarshalmerge(r randyUnmarshalmerge) rune { 840 ru := r.Intn(62) 841 if ru < 10 { 842 return rune(ru + 48) 843 } else if ru < 36 { 844 return rune(ru + 55) 845 } 846 return rune(ru + 61) 847} 848func randStringUnmarshalmerge(r randyUnmarshalmerge) string { 849 v4 := r.Intn(100) 850 tmps := make([]rune, v4) 851 for i := 0; i < v4; i++ { 852 tmps[i] = randUTF8RuneUnmarshalmerge(r) 853 } 854 return string(tmps) 855} 856func randUnrecognizedUnmarshalmerge(r randyUnmarshalmerge, maxFieldNumber int) (dAtA []byte) { 857 l := r.Intn(5) 858 for i := 0; i < l; i++ { 859 wire := r.Intn(4) 860 if wire == 3 { 861 wire = 5 862 } 863 fieldNumber := maxFieldNumber + r.Intn(100) 864 dAtA = randFieldUnmarshalmerge(dAtA, r, fieldNumber, wire) 865 } 866 return dAtA 867} 868func randFieldUnmarshalmerge(dAtA []byte, r randyUnmarshalmerge, fieldNumber int, wire int) []byte { 869 key := uint32(fieldNumber)<<3 | uint32(wire) 870 switch wire { 871 case 0: 872 dAtA = encodeVarintPopulateUnmarshalmerge(dAtA, uint64(key)) 873 v5 := r.Int63() 874 if r.Intn(2) == 0 { 875 v5 *= -1 876 } 877 dAtA = encodeVarintPopulateUnmarshalmerge(dAtA, uint64(v5)) 878 case 1: 879 dAtA = encodeVarintPopulateUnmarshalmerge(dAtA, uint64(key)) 880 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))) 881 case 2: 882 dAtA = encodeVarintPopulateUnmarshalmerge(dAtA, uint64(key)) 883 ll := r.Intn(100) 884 dAtA = encodeVarintPopulateUnmarshalmerge(dAtA, uint64(ll)) 885 for j := 0; j < ll; j++ { 886 dAtA = append(dAtA, byte(r.Intn(256))) 887 } 888 default: 889 dAtA = encodeVarintPopulateUnmarshalmerge(dAtA, uint64(key)) 890 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) 891 } 892 return dAtA 893} 894func encodeVarintPopulateUnmarshalmerge(dAtA []byte, v uint64) []byte { 895 for v >= 1<<7 { 896 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) 897 v >>= 7 898 } 899 dAtA = append(dAtA, uint8(v)) 900 return dAtA 901} 902func (this *Big) String() string { 903 if this == nil { 904 return "nil" 905 } 906 s := strings.Join([]string{`&Big{`, 907 `Sub:` + strings.Replace(this.Sub.String(), "Sub", "Sub", 1) + `,`, 908 `Number:` + valueToStringUnmarshalmerge(this.Number) + `,`, 909 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 910 `}`, 911 }, "") 912 return s 913} 914func (this *BigUnsafe) String() string { 915 if this == nil { 916 return "nil" 917 } 918 s := strings.Join([]string{`&BigUnsafe{`, 919 `Sub:` + strings.Replace(this.Sub.String(), "Sub", "Sub", 1) + `,`, 920 `Number:` + valueToStringUnmarshalmerge(this.Number) + `,`, 921 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 922 `}`, 923 }, "") 924 return s 925} 926func (this *Sub) String() string { 927 if this == nil { 928 return "nil" 929 } 930 s := strings.Join([]string{`&Sub{`, 931 `SubNumber:` + valueToStringUnmarshalmerge(this.SubNumber) + `,`, 932 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 933 `}`, 934 }, "") 935 return s 936} 937func (this *IntMerge) String() string { 938 if this == nil { 939 return "nil" 940 } 941 s := strings.Join([]string{`&IntMerge{`, 942 `Int64:` + fmt.Sprintf("%v", this.Int64) + `,`, 943 `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, 944 `Sint32:` + fmt.Sprintf("%v", this.Sint32) + `,`, 945 `Sint64:` + fmt.Sprintf("%v", this.Sint64) + `,`, 946 `Uint64:` + fmt.Sprintf("%v", this.Uint64) + `,`, 947 `Uint32:` + fmt.Sprintf("%v", this.Uint32) + `,`, 948 `Fixed64:` + fmt.Sprintf("%v", this.Fixed64) + `,`, 949 `Fixed32:` + fmt.Sprintf("%v", this.Fixed32) + `,`, 950 `Sfixed32:` + fmt.Sprintf("%v", this.Sfixed32) + `,`, 951 `Sfixed64:` + fmt.Sprintf("%v", this.Sfixed64) + `,`, 952 `Bool:` + fmt.Sprintf("%v", this.Bool) + `,`, 953 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 954 `}`, 955 }, "") 956 return s 957} 958func valueToStringUnmarshalmerge(v interface{}) string { 959 rv := reflect.ValueOf(v) 960 if rv.IsNil() { 961 return "nil" 962 } 963 pv := reflect.Indirect(rv).Interface() 964 return fmt.Sprintf("*%v", pv) 965} 966func (m *Big) Unmarshal(dAtA []byte) error { 967 l := len(dAtA) 968 iNdEx := 0 969 for iNdEx < l { 970 preIndex := iNdEx 971 var wire uint64 972 for shift := uint(0); ; shift += 7 { 973 if shift >= 64 { 974 return ErrIntOverflowUnmarshalmerge 975 } 976 if iNdEx >= l { 977 return io.ErrUnexpectedEOF 978 } 979 b := dAtA[iNdEx] 980 iNdEx++ 981 wire |= uint64(b&0x7F) << shift 982 if b < 0x80 { 983 break 984 } 985 } 986 fieldNum := int32(wire >> 3) 987 wireType := int(wire & 0x7) 988 if wireType == 4 { 989 return fmt.Errorf("proto: Big: wiretype end group for non-group") 990 } 991 if fieldNum <= 0 { 992 return fmt.Errorf("proto: Big: illegal tag %d (wire type %d)", fieldNum, wire) 993 } 994 switch fieldNum { 995 case 1: 996 if wireType != 2 { 997 return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) 998 } 999 var msglen int 1000 for shift := uint(0); ; shift += 7 { 1001 if shift >= 64 { 1002 return ErrIntOverflowUnmarshalmerge 1003 } 1004 if iNdEx >= l { 1005 return io.ErrUnexpectedEOF 1006 } 1007 b := dAtA[iNdEx] 1008 iNdEx++ 1009 msglen |= int(b&0x7F) << shift 1010 if b < 0x80 { 1011 break 1012 } 1013 } 1014 if msglen < 0 { 1015 return ErrInvalidLengthUnmarshalmerge 1016 } 1017 postIndex := iNdEx + msglen 1018 if postIndex < 0 { 1019 return ErrInvalidLengthUnmarshalmerge 1020 } 1021 if postIndex > l { 1022 return io.ErrUnexpectedEOF 1023 } 1024 if m.Sub == nil { 1025 m.Sub = &Sub{} 1026 } 1027 if err := m.Sub.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1028 return err 1029 } 1030 iNdEx = postIndex 1031 case 2: 1032 if wireType != 0 { 1033 return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) 1034 } 1035 var v int64 1036 for shift := uint(0); ; shift += 7 { 1037 if shift >= 64 { 1038 return ErrIntOverflowUnmarshalmerge 1039 } 1040 if iNdEx >= l { 1041 return io.ErrUnexpectedEOF 1042 } 1043 b := dAtA[iNdEx] 1044 iNdEx++ 1045 v |= int64(b&0x7F) << shift 1046 if b < 0x80 { 1047 break 1048 } 1049 } 1050 m.Number = &v 1051 default: 1052 iNdEx = preIndex 1053 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:]) 1054 if err != nil { 1055 return err 1056 } 1057 if skippy < 0 { 1058 return ErrInvalidLengthUnmarshalmerge 1059 } 1060 if (iNdEx + skippy) < 0 { 1061 return ErrInvalidLengthUnmarshalmerge 1062 } 1063 if (iNdEx + skippy) > l { 1064 return io.ErrUnexpectedEOF 1065 } 1066 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1067 iNdEx += skippy 1068 } 1069 } 1070 1071 if iNdEx > l { 1072 return io.ErrUnexpectedEOF 1073 } 1074 return nil 1075} 1076func (m *BigUnsafe) Unmarshal(dAtA []byte) error { 1077 l := len(dAtA) 1078 iNdEx := 0 1079 for iNdEx < l { 1080 preIndex := iNdEx 1081 var wire uint64 1082 for shift := uint(0); ; shift += 7 { 1083 if shift >= 64 { 1084 return ErrIntOverflowUnmarshalmerge 1085 } 1086 if iNdEx >= l { 1087 return io.ErrUnexpectedEOF 1088 } 1089 b := dAtA[iNdEx] 1090 iNdEx++ 1091 wire |= uint64(b&0x7F) << shift 1092 if b < 0x80 { 1093 break 1094 } 1095 } 1096 fieldNum := int32(wire >> 3) 1097 wireType := int(wire & 0x7) 1098 if wireType == 4 { 1099 return fmt.Errorf("proto: BigUnsafe: wiretype end group for non-group") 1100 } 1101 if fieldNum <= 0 { 1102 return fmt.Errorf("proto: BigUnsafe: illegal tag %d (wire type %d)", fieldNum, wire) 1103 } 1104 switch fieldNum { 1105 case 1: 1106 if wireType != 2 { 1107 return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) 1108 } 1109 var msglen int 1110 for shift := uint(0); ; shift += 7 { 1111 if shift >= 64 { 1112 return ErrIntOverflowUnmarshalmerge 1113 } 1114 if iNdEx >= l { 1115 return io.ErrUnexpectedEOF 1116 } 1117 b := dAtA[iNdEx] 1118 iNdEx++ 1119 msglen |= int(b&0x7F) << shift 1120 if b < 0x80 { 1121 break 1122 } 1123 } 1124 if msglen < 0 { 1125 return ErrInvalidLengthUnmarshalmerge 1126 } 1127 postIndex := iNdEx + msglen 1128 if postIndex < 0 { 1129 return ErrInvalidLengthUnmarshalmerge 1130 } 1131 if postIndex > l { 1132 return io.ErrUnexpectedEOF 1133 } 1134 if m.Sub == nil { 1135 m.Sub = &Sub{} 1136 } 1137 if err := m.Sub.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1138 return err 1139 } 1140 iNdEx = postIndex 1141 case 2: 1142 if wireType != 0 { 1143 return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) 1144 } 1145 var v int64 1146 for shift := uint(0); ; shift += 7 { 1147 if shift >= 64 { 1148 return ErrIntOverflowUnmarshalmerge 1149 } 1150 if iNdEx >= l { 1151 return io.ErrUnexpectedEOF 1152 } 1153 b := dAtA[iNdEx] 1154 iNdEx++ 1155 v |= int64(b&0x7F) << shift 1156 if b < 0x80 { 1157 break 1158 } 1159 } 1160 m.Number = &v 1161 default: 1162 iNdEx = preIndex 1163 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:]) 1164 if err != nil { 1165 return err 1166 } 1167 if skippy < 0 { 1168 return ErrInvalidLengthUnmarshalmerge 1169 } 1170 if (iNdEx + skippy) < 0 { 1171 return ErrInvalidLengthUnmarshalmerge 1172 } 1173 if (iNdEx + skippy) > l { 1174 return io.ErrUnexpectedEOF 1175 } 1176 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1177 iNdEx += skippy 1178 } 1179 } 1180 1181 if iNdEx > l { 1182 return io.ErrUnexpectedEOF 1183 } 1184 return nil 1185} 1186func (m *Sub) Unmarshal(dAtA []byte) error { 1187 l := len(dAtA) 1188 iNdEx := 0 1189 for iNdEx < l { 1190 preIndex := iNdEx 1191 var wire uint64 1192 for shift := uint(0); ; shift += 7 { 1193 if shift >= 64 { 1194 return ErrIntOverflowUnmarshalmerge 1195 } 1196 if iNdEx >= l { 1197 return io.ErrUnexpectedEOF 1198 } 1199 b := dAtA[iNdEx] 1200 iNdEx++ 1201 wire |= uint64(b&0x7F) << shift 1202 if b < 0x80 { 1203 break 1204 } 1205 } 1206 fieldNum := int32(wire >> 3) 1207 wireType := int(wire & 0x7) 1208 if wireType == 4 { 1209 return fmt.Errorf("proto: Sub: wiretype end group for non-group") 1210 } 1211 if fieldNum <= 0 { 1212 return fmt.Errorf("proto: Sub: illegal tag %d (wire type %d)", fieldNum, wire) 1213 } 1214 switch fieldNum { 1215 case 1: 1216 if wireType != 0 { 1217 return fmt.Errorf("proto: wrong wireType = %d for field SubNumber", wireType) 1218 } 1219 var v int64 1220 for shift := uint(0); ; shift += 7 { 1221 if shift >= 64 { 1222 return ErrIntOverflowUnmarshalmerge 1223 } 1224 if iNdEx >= l { 1225 return io.ErrUnexpectedEOF 1226 } 1227 b := dAtA[iNdEx] 1228 iNdEx++ 1229 v |= int64(b&0x7F) << shift 1230 if b < 0x80 { 1231 break 1232 } 1233 } 1234 m.SubNumber = &v 1235 default: 1236 iNdEx = preIndex 1237 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:]) 1238 if err != nil { 1239 return err 1240 } 1241 if skippy < 0 { 1242 return ErrInvalidLengthUnmarshalmerge 1243 } 1244 if (iNdEx + skippy) < 0 { 1245 return ErrInvalidLengthUnmarshalmerge 1246 } 1247 if (iNdEx + skippy) > l { 1248 return io.ErrUnexpectedEOF 1249 } 1250 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1251 iNdEx += skippy 1252 } 1253 } 1254 1255 if iNdEx > l { 1256 return io.ErrUnexpectedEOF 1257 } 1258 return nil 1259} 1260func (m *IntMerge) Unmarshal(dAtA []byte) error { 1261 var hasFields [1]uint64 1262 l := len(dAtA) 1263 iNdEx := 0 1264 for iNdEx < l { 1265 preIndex := iNdEx 1266 var wire uint64 1267 for shift := uint(0); ; shift += 7 { 1268 if shift >= 64 { 1269 return ErrIntOverflowUnmarshalmerge 1270 } 1271 if iNdEx >= l { 1272 return io.ErrUnexpectedEOF 1273 } 1274 b := dAtA[iNdEx] 1275 iNdEx++ 1276 wire |= uint64(b&0x7F) << shift 1277 if b < 0x80 { 1278 break 1279 } 1280 } 1281 fieldNum := int32(wire >> 3) 1282 wireType := int(wire & 0x7) 1283 if wireType == 4 { 1284 return fmt.Errorf("proto: IntMerge: wiretype end group for non-group") 1285 } 1286 if fieldNum <= 0 { 1287 return fmt.Errorf("proto: IntMerge: illegal tag %d (wire type %d)", fieldNum, wire) 1288 } 1289 switch fieldNum { 1290 case 1: 1291 if wireType != 0 { 1292 return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType) 1293 } 1294 m.Int64 = 0 1295 for shift := uint(0); ; shift += 7 { 1296 if shift >= 64 { 1297 return ErrIntOverflowUnmarshalmerge 1298 } 1299 if iNdEx >= l { 1300 return io.ErrUnexpectedEOF 1301 } 1302 b := dAtA[iNdEx] 1303 iNdEx++ 1304 m.Int64 |= int64(b&0x7F) << shift 1305 if b < 0x80 { 1306 break 1307 } 1308 } 1309 hasFields[0] |= uint64(0x00000001) 1310 case 2: 1311 if wireType != 0 { 1312 return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) 1313 } 1314 m.Int32 = 0 1315 for shift := uint(0); ; shift += 7 { 1316 if shift >= 64 { 1317 return ErrIntOverflowUnmarshalmerge 1318 } 1319 if iNdEx >= l { 1320 return io.ErrUnexpectedEOF 1321 } 1322 b := dAtA[iNdEx] 1323 iNdEx++ 1324 m.Int32 |= int32(b&0x7F) << shift 1325 if b < 0x80 { 1326 break 1327 } 1328 } 1329 case 3: 1330 if wireType != 0 { 1331 return fmt.Errorf("proto: wrong wireType = %d for field Sint32", wireType) 1332 } 1333 var v int32 1334 for shift := uint(0); ; shift += 7 { 1335 if shift >= 64 { 1336 return ErrIntOverflowUnmarshalmerge 1337 } 1338 if iNdEx >= l { 1339 return io.ErrUnexpectedEOF 1340 } 1341 b := dAtA[iNdEx] 1342 iNdEx++ 1343 v |= int32(b&0x7F) << shift 1344 if b < 0x80 { 1345 break 1346 } 1347 } 1348 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) 1349 m.Sint32 = v 1350 hasFields[0] |= uint64(0x00000002) 1351 case 4: 1352 if wireType != 0 { 1353 return fmt.Errorf("proto: wrong wireType = %d for field Sint64", wireType) 1354 } 1355 var v uint64 1356 for shift := uint(0); ; shift += 7 { 1357 if shift >= 64 { 1358 return ErrIntOverflowUnmarshalmerge 1359 } 1360 if iNdEx >= l { 1361 return io.ErrUnexpectedEOF 1362 } 1363 b := dAtA[iNdEx] 1364 iNdEx++ 1365 v |= uint64(b&0x7F) << shift 1366 if b < 0x80 { 1367 break 1368 } 1369 } 1370 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) 1371 m.Sint64 = int64(v) 1372 case 5: 1373 if wireType != 0 { 1374 return fmt.Errorf("proto: wrong wireType = %d for field Uint64", wireType) 1375 } 1376 m.Uint64 = 0 1377 for shift := uint(0); ; shift += 7 { 1378 if shift >= 64 { 1379 return ErrIntOverflowUnmarshalmerge 1380 } 1381 if iNdEx >= l { 1382 return io.ErrUnexpectedEOF 1383 } 1384 b := dAtA[iNdEx] 1385 iNdEx++ 1386 m.Uint64 |= uint64(b&0x7F) << shift 1387 if b < 0x80 { 1388 break 1389 } 1390 } 1391 case 6: 1392 if wireType != 0 { 1393 return fmt.Errorf("proto: wrong wireType = %d for field Uint32", wireType) 1394 } 1395 m.Uint32 = 0 1396 for shift := uint(0); ; shift += 7 { 1397 if shift >= 64 { 1398 return ErrIntOverflowUnmarshalmerge 1399 } 1400 if iNdEx >= l { 1401 return io.ErrUnexpectedEOF 1402 } 1403 b := dAtA[iNdEx] 1404 iNdEx++ 1405 m.Uint32 |= uint32(b&0x7F) << shift 1406 if b < 0x80 { 1407 break 1408 } 1409 } 1410 hasFields[0] |= uint64(0x00000004) 1411 case 7: 1412 if wireType != 1 { 1413 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64", wireType) 1414 } 1415 m.Fixed64 = 0 1416 if (iNdEx + 8) > l { 1417 return io.ErrUnexpectedEOF 1418 } 1419 m.Fixed64 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 1420 iNdEx += 8 1421 case 8: 1422 if wireType != 5 { 1423 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32", wireType) 1424 } 1425 m.Fixed32 = 0 1426 if (iNdEx + 4) > l { 1427 return io.ErrUnexpectedEOF 1428 } 1429 m.Fixed32 = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) 1430 iNdEx += 4 1431 case 9: 1432 if wireType != 5 { 1433 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32", wireType) 1434 } 1435 m.Sfixed32 = 0 1436 if (iNdEx + 4) > l { 1437 return io.ErrUnexpectedEOF 1438 } 1439 m.Sfixed32 = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) 1440 iNdEx += 4 1441 hasFields[0] |= uint64(0x00000008) 1442 case 10: 1443 if wireType != 1 { 1444 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64", wireType) 1445 } 1446 m.Sfixed64 = 0 1447 if (iNdEx + 8) > l { 1448 return io.ErrUnexpectedEOF 1449 } 1450 m.Sfixed64 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 1451 iNdEx += 8 1452 case 11: 1453 if wireType != 0 { 1454 return fmt.Errorf("proto: wrong wireType = %d for field Bool", wireType) 1455 } 1456 var v int 1457 for shift := uint(0); ; shift += 7 { 1458 if shift >= 64 { 1459 return ErrIntOverflowUnmarshalmerge 1460 } 1461 if iNdEx >= l { 1462 return io.ErrUnexpectedEOF 1463 } 1464 b := dAtA[iNdEx] 1465 iNdEx++ 1466 v |= int(b&0x7F) << shift 1467 if b < 0x80 { 1468 break 1469 } 1470 } 1471 m.Bool = bool(v != 0) 1472 default: 1473 iNdEx = preIndex 1474 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:]) 1475 if err != nil { 1476 return err 1477 } 1478 if skippy < 0 { 1479 return ErrInvalidLengthUnmarshalmerge 1480 } 1481 if (iNdEx + skippy) < 0 { 1482 return ErrInvalidLengthUnmarshalmerge 1483 } 1484 if (iNdEx + skippy) > l { 1485 return io.ErrUnexpectedEOF 1486 } 1487 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1488 iNdEx += skippy 1489 } 1490 } 1491 if hasFields[0]&uint64(0x00000001) == 0 { 1492 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int64") 1493 } 1494 if hasFields[0]&uint64(0x00000002) == 0 { 1495 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Sint32") 1496 } 1497 if hasFields[0]&uint64(0x00000004) == 0 { 1498 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Uint32") 1499 } 1500 if hasFields[0]&uint64(0x00000008) == 0 { 1501 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Sfixed32") 1502 } 1503 1504 if iNdEx > l { 1505 return io.ErrUnexpectedEOF 1506 } 1507 return nil 1508} 1509func skipUnmarshalmerge(dAtA []byte) (n int, err error) { 1510 l := len(dAtA) 1511 iNdEx := 0 1512 depth := 0 1513 for iNdEx < l { 1514 var wire uint64 1515 for shift := uint(0); ; shift += 7 { 1516 if shift >= 64 { 1517 return 0, ErrIntOverflowUnmarshalmerge 1518 } 1519 if iNdEx >= l { 1520 return 0, io.ErrUnexpectedEOF 1521 } 1522 b := dAtA[iNdEx] 1523 iNdEx++ 1524 wire |= (uint64(b) & 0x7F) << shift 1525 if b < 0x80 { 1526 break 1527 } 1528 } 1529 wireType := int(wire & 0x7) 1530 switch wireType { 1531 case 0: 1532 for shift := uint(0); ; shift += 7 { 1533 if shift >= 64 { 1534 return 0, ErrIntOverflowUnmarshalmerge 1535 } 1536 if iNdEx >= l { 1537 return 0, io.ErrUnexpectedEOF 1538 } 1539 iNdEx++ 1540 if dAtA[iNdEx-1] < 0x80 { 1541 break 1542 } 1543 } 1544 case 1: 1545 iNdEx += 8 1546 case 2: 1547 var length int 1548 for shift := uint(0); ; shift += 7 { 1549 if shift >= 64 { 1550 return 0, ErrIntOverflowUnmarshalmerge 1551 } 1552 if iNdEx >= l { 1553 return 0, io.ErrUnexpectedEOF 1554 } 1555 b := dAtA[iNdEx] 1556 iNdEx++ 1557 length |= (int(b) & 0x7F) << shift 1558 if b < 0x80 { 1559 break 1560 } 1561 } 1562 if length < 0 { 1563 return 0, ErrInvalidLengthUnmarshalmerge 1564 } 1565 iNdEx += length 1566 case 3: 1567 depth++ 1568 case 4: 1569 if depth == 0 { 1570 return 0, ErrUnexpectedEndOfGroupUnmarshalmerge 1571 } 1572 depth-- 1573 case 5: 1574 iNdEx += 4 1575 default: 1576 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1577 } 1578 if iNdEx < 0 { 1579 return 0, ErrInvalidLengthUnmarshalmerge 1580 } 1581 if depth == 0 { 1582 return iNdEx, nil 1583 } 1584 } 1585 return 0, io.ErrUnexpectedEOF 1586} 1587 1588var ( 1589 ErrInvalidLengthUnmarshalmerge = fmt.Errorf("proto: negative length found during unmarshaling") 1590 ErrIntOverflowUnmarshalmerge = fmt.Errorf("proto: integer overflow") 1591 ErrUnexpectedEndOfGroupUnmarshalmerge = fmt.Errorf("proto: unexpected end of group") 1592) 1593