1
2
3
4 package unmarshalmerge
5
6 import (
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
20 var _ = proto.Marshal
21 var _ = fmt.Errorf
22 var _ = math.Inf
23
24
25
26
27
28 const _ = proto.GoGoProtoPackageIsVersion3
29
30 type 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
38 func (m *Big) Reset() { *m = Big{} }
39 func (*Big) ProtoMessage() {}
40 func (*Big) Descriptor() ([]byte, []int) {
41 return fileDescriptor_701a7743bfe9c603, []int{0}
42 }
43 func (m *Big) XXX_Unmarshal(b []byte) error {
44 return m.Unmarshal(b)
45 }
46 func (m *Big) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
47 return xxx_messageInfo_Big.Marshal(b, m, deterministic)
48 }
49 func (m *Big) XXX_Merge(src proto.Message) {
50 xxx_messageInfo_Big.Merge(m, src)
51 }
52 func (m *Big) XXX_Size() int {
53 return xxx_messageInfo_Big.Size(m)
54 }
55 func (m *Big) XXX_DiscardUnknown() {
56 xxx_messageInfo_Big.DiscardUnknown(m)
57 }
58
59 var xxx_messageInfo_Big proto.InternalMessageInfo
60
61 func (m *Big) GetSub() *Sub {
62 if m != nil {
63 return m.Sub
64 }
65 return nil
66 }
67
68 func (m *Big) GetNumber() int64 {
69 if m != nil && m.Number != nil {
70 return *m.Number
71 }
72 return 0
73 }
74
75 type 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
83 func (m *BigUnsafe) Reset() { *m = BigUnsafe{} }
84 func (*BigUnsafe) ProtoMessage() {}
85 func (*BigUnsafe) Descriptor() ([]byte, []int) {
86 return fileDescriptor_701a7743bfe9c603, []int{1}
87 }
88 func (m *BigUnsafe) XXX_Unmarshal(b []byte) error {
89 return xxx_messageInfo_BigUnsafe.Unmarshal(m, b)
90 }
91 func (m *BigUnsafe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
92 return xxx_messageInfo_BigUnsafe.Marshal(b, m, deterministic)
93 }
94 func (m *BigUnsafe) XXX_Merge(src proto.Message) {
95 xxx_messageInfo_BigUnsafe.Merge(m, src)
96 }
97 func (m *BigUnsafe) XXX_Size() int {
98 return xxx_messageInfo_BigUnsafe.Size(m)
99 }
100 func (m *BigUnsafe) XXX_DiscardUnknown() {
101 xxx_messageInfo_BigUnsafe.DiscardUnknown(m)
102 }
103
104 var xxx_messageInfo_BigUnsafe proto.InternalMessageInfo
105
106 func (m *BigUnsafe) GetSub() *Sub {
107 if m != nil {
108 return m.Sub
109 }
110 return nil
111 }
112
113 func (m *BigUnsafe) GetNumber() int64 {
114 if m != nil && m.Number != nil {
115 return *m.Number
116 }
117 return 0
118 }
119
120 type 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
127 func (m *Sub) Reset() { *m = Sub{} }
128 func (*Sub) ProtoMessage() {}
129 func (*Sub) Descriptor() ([]byte, []int) {
130 return fileDescriptor_701a7743bfe9c603, []int{2}
131 }
132 func (m *Sub) XXX_Unmarshal(b []byte) error {
133 return m.Unmarshal(b)
134 }
135 func (m *Sub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
136 return xxx_messageInfo_Sub.Marshal(b, m, deterministic)
137 }
138 func (m *Sub) XXX_Merge(src proto.Message) {
139 xxx_messageInfo_Sub.Merge(m, src)
140 }
141 func (m *Sub) XXX_Size() int {
142 return xxx_messageInfo_Sub.Size(m)
143 }
144 func (m *Sub) XXX_DiscardUnknown() {
145 xxx_messageInfo_Sub.DiscardUnknown(m)
146 }
147
148 var xxx_messageInfo_Sub proto.InternalMessageInfo
149
150 func (m *Sub) GetSubNumber() int64 {
151 if m != nil && m.SubNumber != nil {
152 return *m.SubNumber
153 }
154 return 0
155 }
156
157 type 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
174 func (m *IntMerge) Reset() { *m = IntMerge{} }
175 func (*IntMerge) ProtoMessage() {}
176 func (*IntMerge) Descriptor() ([]byte, []int) {
177 return fileDescriptor_701a7743bfe9c603, []int{3}
178 }
179 func (m *IntMerge) XXX_Unmarshal(b []byte) error {
180 return m.Unmarshal(b)
181 }
182 func (m *IntMerge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
183 return xxx_messageInfo_IntMerge.Marshal(b, m, deterministic)
184 }
185 func (m *IntMerge) XXX_Merge(src proto.Message) {
186 xxx_messageInfo_IntMerge.Merge(m, src)
187 }
188 func (m *IntMerge) XXX_Size() int {
189 return xxx_messageInfo_IntMerge.Size(m)
190 }
191 func (m *IntMerge) XXX_DiscardUnknown() {
192 xxx_messageInfo_IntMerge.DiscardUnknown(m)
193 }
194
195 var xxx_messageInfo_IntMerge proto.InternalMessageInfo
196
197 func (m *IntMerge) GetInt64() int64 {
198 if m != nil {
199 return m.Int64
200 }
201 return 0
202 }
203
204 func (m *IntMerge) GetInt32() int32 {
205 if m != nil {
206 return m.Int32
207 }
208 return 0
209 }
210
211 func (m *IntMerge) GetSint32() int32 {
212 if m != nil {
213 return m.Sint32
214 }
215 return 0
216 }
217
218 func (m *IntMerge) GetSint64() int64 {
219 if m != nil {
220 return m.Sint64
221 }
222 return 0
223 }
224
225 func (m *IntMerge) GetUint64() uint64 {
226 if m != nil {
227 return m.Uint64
228 }
229 return 0
230 }
231
232 func (m *IntMerge) GetUint32() uint32 {
233 if m != nil {
234 return m.Uint32
235 }
236 return 0
237 }
238
239 func (m *IntMerge) GetFixed64() uint64 {
240 if m != nil {
241 return m.Fixed64
242 }
243 return 0
244 }
245
246 func (m *IntMerge) GetFixed32() uint32 {
247 if m != nil {
248 return m.Fixed32
249 }
250 return 0
251 }
252
253 func (m *IntMerge) GetSfixed32() int32 {
254 if m != nil {
255 return m.Sfixed32
256 }
257 return 0
258 }
259
260 func (m *IntMerge) GetSfixed64() int64 {
261 if m != nil {
262 return m.Sfixed64
263 }
264 return 0
265 }
266
267 func (m *IntMerge) GetBool() bool {
268 if m != nil {
269 return m.Bool
270 }
271 return false
272 }
273
274 func 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
281 func init() { proto.RegisterFile("unmarshalmerge.proto", fileDescriptor_701a7743bfe9c603) }
282
283 var fileDescriptor_701a7743bfe9c603 = []byte{
284
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
312 func (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 }
354 func (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 }
390 func (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 }
432 func (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 }
468 func (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 }
507 func (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 }
540 func (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 }
603 func (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 }
660 func (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 }
678 func (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 }
696 func (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 }
711 func (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 }
734 func 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 }
742 func 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
760 func 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
778 func 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
793 func 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
830 type randyUnmarshalmerge interface {
831 Float32() float32
832 Float64() float64
833 Int63() int64
834 Int31() int32
835 Uint32() uint32
836 Intn(n int) int
837 }
838
839 func 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 }
848 func 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 }
856 func 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 }
868 func 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 }
894 func 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 }
902 func (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 }
914 func (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 }
926 func (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 }
937 func (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 }
958 func 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 }
966 func (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) || (iNdEx+skippy) < 0 {
1058 return ErrInvalidLengthUnmarshalmerge
1059 }
1060 if (iNdEx + skippy) > l {
1061 return io.ErrUnexpectedEOF
1062 }
1063 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1064 iNdEx += skippy
1065 }
1066 }
1067
1068 if iNdEx > l {
1069 return io.ErrUnexpectedEOF
1070 }
1071 return nil
1072 }
1073 func (m *BigUnsafe) Unmarshal(dAtA []byte) error {
1074 l := len(dAtA)
1075 iNdEx := 0
1076 for iNdEx < l {
1077 preIndex := iNdEx
1078 var wire uint64
1079 for shift := uint(0); ; shift += 7 {
1080 if shift >= 64 {
1081 return ErrIntOverflowUnmarshalmerge
1082 }
1083 if iNdEx >= l {
1084 return io.ErrUnexpectedEOF
1085 }
1086 b := dAtA[iNdEx]
1087 iNdEx++
1088 wire |= uint64(b&0x7F) << shift
1089 if b < 0x80 {
1090 break
1091 }
1092 }
1093 fieldNum := int32(wire >> 3)
1094 wireType := int(wire & 0x7)
1095 if wireType == 4 {
1096 return fmt.Errorf("proto: BigUnsafe: wiretype end group for non-group")
1097 }
1098 if fieldNum <= 0 {
1099 return fmt.Errorf("proto: BigUnsafe: illegal tag %d (wire type %d)", fieldNum, wire)
1100 }
1101 switch fieldNum {
1102 case 1:
1103 if wireType != 2 {
1104 return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType)
1105 }
1106 var msglen int
1107 for shift := uint(0); ; shift += 7 {
1108 if shift >= 64 {
1109 return ErrIntOverflowUnmarshalmerge
1110 }
1111 if iNdEx >= l {
1112 return io.ErrUnexpectedEOF
1113 }
1114 b := dAtA[iNdEx]
1115 iNdEx++
1116 msglen |= int(b&0x7F) << shift
1117 if b < 0x80 {
1118 break
1119 }
1120 }
1121 if msglen < 0 {
1122 return ErrInvalidLengthUnmarshalmerge
1123 }
1124 postIndex := iNdEx + msglen
1125 if postIndex < 0 {
1126 return ErrInvalidLengthUnmarshalmerge
1127 }
1128 if postIndex > l {
1129 return io.ErrUnexpectedEOF
1130 }
1131 if m.Sub == nil {
1132 m.Sub = &Sub{}
1133 }
1134 if err := m.Sub.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1135 return err
1136 }
1137 iNdEx = postIndex
1138 case 2:
1139 if wireType != 0 {
1140 return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
1141 }
1142 var v int64
1143 for shift := uint(0); ; shift += 7 {
1144 if shift >= 64 {
1145 return ErrIntOverflowUnmarshalmerge
1146 }
1147 if iNdEx >= l {
1148 return io.ErrUnexpectedEOF
1149 }
1150 b := dAtA[iNdEx]
1151 iNdEx++
1152 v |= int64(b&0x7F) << shift
1153 if b < 0x80 {
1154 break
1155 }
1156 }
1157 m.Number = &v
1158 default:
1159 iNdEx = preIndex
1160 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:])
1161 if err != nil {
1162 return err
1163 }
1164 if (skippy < 0) || (iNdEx+skippy) < 0 {
1165 return ErrInvalidLengthUnmarshalmerge
1166 }
1167 if (iNdEx + skippy) > l {
1168 return io.ErrUnexpectedEOF
1169 }
1170 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1171 iNdEx += skippy
1172 }
1173 }
1174
1175 if iNdEx > l {
1176 return io.ErrUnexpectedEOF
1177 }
1178 return nil
1179 }
1180 func (m *Sub) Unmarshal(dAtA []byte) error {
1181 l := len(dAtA)
1182 iNdEx := 0
1183 for iNdEx < l {
1184 preIndex := iNdEx
1185 var wire uint64
1186 for shift := uint(0); ; shift += 7 {
1187 if shift >= 64 {
1188 return ErrIntOverflowUnmarshalmerge
1189 }
1190 if iNdEx >= l {
1191 return io.ErrUnexpectedEOF
1192 }
1193 b := dAtA[iNdEx]
1194 iNdEx++
1195 wire |= uint64(b&0x7F) << shift
1196 if b < 0x80 {
1197 break
1198 }
1199 }
1200 fieldNum := int32(wire >> 3)
1201 wireType := int(wire & 0x7)
1202 if wireType == 4 {
1203 return fmt.Errorf("proto: Sub: wiretype end group for non-group")
1204 }
1205 if fieldNum <= 0 {
1206 return fmt.Errorf("proto: Sub: illegal tag %d (wire type %d)", fieldNum, wire)
1207 }
1208 switch fieldNum {
1209 case 1:
1210 if wireType != 0 {
1211 return fmt.Errorf("proto: wrong wireType = %d for field SubNumber", wireType)
1212 }
1213 var v int64
1214 for shift := uint(0); ; shift += 7 {
1215 if shift >= 64 {
1216 return ErrIntOverflowUnmarshalmerge
1217 }
1218 if iNdEx >= l {
1219 return io.ErrUnexpectedEOF
1220 }
1221 b := dAtA[iNdEx]
1222 iNdEx++
1223 v |= int64(b&0x7F) << shift
1224 if b < 0x80 {
1225 break
1226 }
1227 }
1228 m.SubNumber = &v
1229 default:
1230 iNdEx = preIndex
1231 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:])
1232 if err != nil {
1233 return err
1234 }
1235 if (skippy < 0) || (iNdEx+skippy) < 0 {
1236 return ErrInvalidLengthUnmarshalmerge
1237 }
1238 if (iNdEx + skippy) > l {
1239 return io.ErrUnexpectedEOF
1240 }
1241 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1242 iNdEx += skippy
1243 }
1244 }
1245
1246 if iNdEx > l {
1247 return io.ErrUnexpectedEOF
1248 }
1249 return nil
1250 }
1251 func (m *IntMerge) Unmarshal(dAtA []byte) error {
1252 var hasFields [1]uint64
1253 l := len(dAtA)
1254 iNdEx := 0
1255 for iNdEx < l {
1256 preIndex := iNdEx
1257 var wire uint64
1258 for shift := uint(0); ; shift += 7 {
1259 if shift >= 64 {
1260 return ErrIntOverflowUnmarshalmerge
1261 }
1262 if iNdEx >= l {
1263 return io.ErrUnexpectedEOF
1264 }
1265 b := dAtA[iNdEx]
1266 iNdEx++
1267 wire |= uint64(b&0x7F) << shift
1268 if b < 0x80 {
1269 break
1270 }
1271 }
1272 fieldNum := int32(wire >> 3)
1273 wireType := int(wire & 0x7)
1274 if wireType == 4 {
1275 return fmt.Errorf("proto: IntMerge: wiretype end group for non-group")
1276 }
1277 if fieldNum <= 0 {
1278 return fmt.Errorf("proto: IntMerge: illegal tag %d (wire type %d)", fieldNum, wire)
1279 }
1280 switch fieldNum {
1281 case 1:
1282 if wireType != 0 {
1283 return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType)
1284 }
1285 m.Int64 = 0
1286 for shift := uint(0); ; shift += 7 {
1287 if shift >= 64 {
1288 return ErrIntOverflowUnmarshalmerge
1289 }
1290 if iNdEx >= l {
1291 return io.ErrUnexpectedEOF
1292 }
1293 b := dAtA[iNdEx]
1294 iNdEx++
1295 m.Int64 |= int64(b&0x7F) << shift
1296 if b < 0x80 {
1297 break
1298 }
1299 }
1300 hasFields[0] |= uint64(0x00000001)
1301 case 2:
1302 if wireType != 0 {
1303 return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType)
1304 }
1305 m.Int32 = 0
1306 for shift := uint(0); ; shift += 7 {
1307 if shift >= 64 {
1308 return ErrIntOverflowUnmarshalmerge
1309 }
1310 if iNdEx >= l {
1311 return io.ErrUnexpectedEOF
1312 }
1313 b := dAtA[iNdEx]
1314 iNdEx++
1315 m.Int32 |= int32(b&0x7F) << shift
1316 if b < 0x80 {
1317 break
1318 }
1319 }
1320 case 3:
1321 if wireType != 0 {
1322 return fmt.Errorf("proto: wrong wireType = %d for field Sint32", wireType)
1323 }
1324 var v int32
1325 for shift := uint(0); ; shift += 7 {
1326 if shift >= 64 {
1327 return ErrIntOverflowUnmarshalmerge
1328 }
1329 if iNdEx >= l {
1330 return io.ErrUnexpectedEOF
1331 }
1332 b := dAtA[iNdEx]
1333 iNdEx++
1334 v |= int32(b&0x7F) << shift
1335 if b < 0x80 {
1336 break
1337 }
1338 }
1339 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
1340 m.Sint32 = v
1341 hasFields[0] |= uint64(0x00000002)
1342 case 4:
1343 if wireType != 0 {
1344 return fmt.Errorf("proto: wrong wireType = %d for field Sint64", wireType)
1345 }
1346 var v uint64
1347 for shift := uint(0); ; shift += 7 {
1348 if shift >= 64 {
1349 return ErrIntOverflowUnmarshalmerge
1350 }
1351 if iNdEx >= l {
1352 return io.ErrUnexpectedEOF
1353 }
1354 b := dAtA[iNdEx]
1355 iNdEx++
1356 v |= uint64(b&0x7F) << shift
1357 if b < 0x80 {
1358 break
1359 }
1360 }
1361 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
1362 m.Sint64 = int64(v)
1363 case 5:
1364 if wireType != 0 {
1365 return fmt.Errorf("proto: wrong wireType = %d for field Uint64", wireType)
1366 }
1367 m.Uint64 = 0
1368 for shift := uint(0); ; shift += 7 {
1369 if shift >= 64 {
1370 return ErrIntOverflowUnmarshalmerge
1371 }
1372 if iNdEx >= l {
1373 return io.ErrUnexpectedEOF
1374 }
1375 b := dAtA[iNdEx]
1376 iNdEx++
1377 m.Uint64 |= uint64(b&0x7F) << shift
1378 if b < 0x80 {
1379 break
1380 }
1381 }
1382 case 6:
1383 if wireType != 0 {
1384 return fmt.Errorf("proto: wrong wireType = %d for field Uint32", wireType)
1385 }
1386 m.Uint32 = 0
1387 for shift := uint(0); ; shift += 7 {
1388 if shift >= 64 {
1389 return ErrIntOverflowUnmarshalmerge
1390 }
1391 if iNdEx >= l {
1392 return io.ErrUnexpectedEOF
1393 }
1394 b := dAtA[iNdEx]
1395 iNdEx++
1396 m.Uint32 |= uint32(b&0x7F) << shift
1397 if b < 0x80 {
1398 break
1399 }
1400 }
1401 hasFields[0] |= uint64(0x00000004)
1402 case 7:
1403 if wireType != 1 {
1404 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64", wireType)
1405 }
1406 m.Fixed64 = 0
1407 if (iNdEx + 8) > l {
1408 return io.ErrUnexpectedEOF
1409 }
1410 m.Fixed64 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
1411 iNdEx += 8
1412 case 8:
1413 if wireType != 5 {
1414 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32", wireType)
1415 }
1416 m.Fixed32 = 0
1417 if (iNdEx + 4) > l {
1418 return io.ErrUnexpectedEOF
1419 }
1420 m.Fixed32 = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
1421 iNdEx += 4
1422 case 9:
1423 if wireType != 5 {
1424 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32", wireType)
1425 }
1426 m.Sfixed32 = 0
1427 if (iNdEx + 4) > l {
1428 return io.ErrUnexpectedEOF
1429 }
1430 m.Sfixed32 = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
1431 iNdEx += 4
1432 hasFields[0] |= uint64(0x00000008)
1433 case 10:
1434 if wireType != 1 {
1435 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64", wireType)
1436 }
1437 m.Sfixed64 = 0
1438 if (iNdEx + 8) > l {
1439 return io.ErrUnexpectedEOF
1440 }
1441 m.Sfixed64 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
1442 iNdEx += 8
1443 case 11:
1444 if wireType != 0 {
1445 return fmt.Errorf("proto: wrong wireType = %d for field Bool", wireType)
1446 }
1447 var v int
1448 for shift := uint(0); ; shift += 7 {
1449 if shift >= 64 {
1450 return ErrIntOverflowUnmarshalmerge
1451 }
1452 if iNdEx >= l {
1453 return io.ErrUnexpectedEOF
1454 }
1455 b := dAtA[iNdEx]
1456 iNdEx++
1457 v |= int(b&0x7F) << shift
1458 if b < 0x80 {
1459 break
1460 }
1461 }
1462 m.Bool = bool(v != 0)
1463 default:
1464 iNdEx = preIndex
1465 skippy, err := skipUnmarshalmerge(dAtA[iNdEx:])
1466 if err != nil {
1467 return err
1468 }
1469 if (skippy < 0) || (iNdEx+skippy) < 0 {
1470 return ErrInvalidLengthUnmarshalmerge
1471 }
1472 if (iNdEx + skippy) > l {
1473 return io.ErrUnexpectedEOF
1474 }
1475 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1476 iNdEx += skippy
1477 }
1478 }
1479 if hasFields[0]&uint64(0x00000001) == 0 {
1480 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int64")
1481 }
1482 if hasFields[0]&uint64(0x00000002) == 0 {
1483 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Sint32")
1484 }
1485 if hasFields[0]&uint64(0x00000004) == 0 {
1486 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Uint32")
1487 }
1488 if hasFields[0]&uint64(0x00000008) == 0 {
1489 return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Sfixed32")
1490 }
1491
1492 if iNdEx > l {
1493 return io.ErrUnexpectedEOF
1494 }
1495 return nil
1496 }
1497 func skipUnmarshalmerge(dAtA []byte) (n int, err error) {
1498 l := len(dAtA)
1499 iNdEx := 0
1500 depth := 0
1501 for iNdEx < l {
1502 var wire uint64
1503 for shift := uint(0); ; shift += 7 {
1504 if shift >= 64 {
1505 return 0, ErrIntOverflowUnmarshalmerge
1506 }
1507 if iNdEx >= l {
1508 return 0, io.ErrUnexpectedEOF
1509 }
1510 b := dAtA[iNdEx]
1511 iNdEx++
1512 wire |= (uint64(b) & 0x7F) << shift
1513 if b < 0x80 {
1514 break
1515 }
1516 }
1517 wireType := int(wire & 0x7)
1518 switch wireType {
1519 case 0:
1520 for shift := uint(0); ; shift += 7 {
1521 if shift >= 64 {
1522 return 0, ErrIntOverflowUnmarshalmerge
1523 }
1524 if iNdEx >= l {
1525 return 0, io.ErrUnexpectedEOF
1526 }
1527 iNdEx++
1528 if dAtA[iNdEx-1] < 0x80 {
1529 break
1530 }
1531 }
1532 case 1:
1533 iNdEx += 8
1534 case 2:
1535 var length int
1536 for shift := uint(0); ; shift += 7 {
1537 if shift >= 64 {
1538 return 0, ErrIntOverflowUnmarshalmerge
1539 }
1540 if iNdEx >= l {
1541 return 0, io.ErrUnexpectedEOF
1542 }
1543 b := dAtA[iNdEx]
1544 iNdEx++
1545 length |= (int(b) & 0x7F) << shift
1546 if b < 0x80 {
1547 break
1548 }
1549 }
1550 if length < 0 {
1551 return 0, ErrInvalidLengthUnmarshalmerge
1552 }
1553 iNdEx += length
1554 case 3:
1555 depth++
1556 case 4:
1557 if depth == 0 {
1558 return 0, ErrUnexpectedEndOfGroupUnmarshalmerge
1559 }
1560 depth--
1561 case 5:
1562 iNdEx += 4
1563 default:
1564 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1565 }
1566 if iNdEx < 0 {
1567 return 0, ErrInvalidLengthUnmarshalmerge
1568 }
1569 if depth == 0 {
1570 return iNdEx, nil
1571 }
1572 }
1573 return 0, io.ErrUnexpectedEOF
1574 }
1575
1576 var (
1577 ErrInvalidLengthUnmarshalmerge = fmt.Errorf("proto: negative length found during unmarshaling")
1578 ErrIntOverflowUnmarshalmerge = fmt.Errorf("proto: integer overflow")
1579 ErrUnexpectedEndOfGroupUnmarshalmerge = fmt.Errorf("proto: unexpected end of group")
1580 )
1581
View as plain text