1
2
3
4 package asym
5
6 import (
7 bytes "bytes"
8 fmt "fmt"
9 _ "github.com/gogo/protobuf/gogoproto"
10 proto "github.com/gogo/protobuf/proto"
11 io "io"
12 math "math"
13 math_bits "math/bits"
14 )
15
16
17 var _ = proto.Marshal
18 var _ = fmt.Errorf
19 var _ = math.Inf
20
21
22
23
24
25 const _ = proto.GoGoProtoPackageIsVersion3
26
27 type M struct {
28 Arr []MyType `protobuf:"bytes,1,rep,name=arr,customtype=MyType" json:"arr"`
29 XXX_NoUnkeyedLiteral struct{} `json:"-"`
30 XXX_unrecognized []byte `json:"-"`
31 XXX_sizecache int32 `json:"-"`
32 }
33
34 func (m *M) Reset() { *m = M{} }
35 func (m *M) String() string { return proto.CompactTextString(m) }
36 func (*M) ProtoMessage() {}
37 func (*M) Descriptor() ([]byte, []int) {
38 return fileDescriptor_72d286349de177ec, []int{0}
39 }
40 func (m *M) XXX_Unmarshal(b []byte) error {
41 return m.Unmarshal(b)
42 }
43 func (m *M) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
44 if deterministic {
45 return xxx_messageInfo_M.Marshal(b, m, deterministic)
46 } else {
47 b = b[:cap(b)]
48 n, err := m.MarshalToSizedBuffer(b)
49 if err != nil {
50 return nil, err
51 }
52 return b[:n], nil
53 }
54 }
55 func (m *M) XXX_Merge(src proto.Message) {
56 xxx_messageInfo_M.Merge(m, src)
57 }
58 func (m *M) XXX_Size() int {
59 return m.Size()
60 }
61 func (m *M) XXX_DiscardUnknown() {
62 xxx_messageInfo_M.DiscardUnknown(m)
63 }
64
65 var xxx_messageInfo_M proto.InternalMessageInfo
66
67 type MyType struct {
68 XXX_NoUnkeyedLiteral struct{} `json:"-"`
69 XXX_unrecognized []byte `json:"-"`
70 XXX_sizecache int32 `json:"-"`
71 }
72
73 func (m *MyType) Reset() { *m = MyType{} }
74 func (m *MyType) String() string { return proto.CompactTextString(m) }
75 func (*MyType) ProtoMessage() {}
76 func (*MyType) Descriptor() ([]byte, []int) {
77 return fileDescriptor_72d286349de177ec, []int{1}
78 }
79 func (m *MyType) XXX_Unmarshal(b []byte) error {
80 return m.Unmarshal(b)
81 }
82 func (m *MyType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
83 return xxx_messageInfo_MyType.Marshal(b, m, deterministic)
84 }
85 func (m *MyType) XXX_Merge(src proto.Message) {
86 xxx_messageInfo_MyType.Merge(m, src)
87 }
88 func (m *MyType) XXX_Size() int {
89 return xxx_messageInfo_MyType.Size(m)
90 }
91 func (m *MyType) XXX_DiscardUnknown() {
92 xxx_messageInfo_MyType.DiscardUnknown(m)
93 }
94
95 var xxx_messageInfo_MyType proto.InternalMessageInfo
96
97 func init() {
98 proto.RegisterType((*M)(nil), "asym.M")
99 proto.RegisterType((*MyType)(nil), "asym.MyType")
100 }
101
102 func init() { proto.RegisterFile("asym.proto", fileDescriptor_72d286349de177ec) }
103
104 var fileDescriptor_72d286349de177ec = []byte{
105
106 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0x2c, 0xae, 0xcc,
107 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x01, 0xb1, 0xa5, 0x74, 0xd3, 0x33, 0x4b, 0x32,
108 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xd3, 0xf3, 0xd3, 0xf3, 0xf5, 0xc1, 0x92, 0x49, 0xa5,
109 0x69, 0x60, 0x1e, 0x98, 0x03, 0x66, 0x41, 0x34, 0x29, 0xa9, 0x72, 0x31, 0xfa, 0x0a, 0x29, 0x70,
110 0x31, 0x27, 0x16, 0x15, 0x49, 0x30, 0x2a, 0x30, 0x6b, 0xf0, 0x38, 0xf1, 0x9d, 0xb8, 0x27, 0xcf,
111 0x70, 0xeb, 0x9e, 0x3c, 0x9b, 0x6f, 0x65, 0x48, 0x65, 0x41, 0x6a, 0x10, 0x48, 0x4a, 0x49, 0x8a,
112 0x0b, 0xca, 0xb5, 0x12, 0xd8, 0xb1, 0x40, 0x9e, 0xe1, 0xc7, 0x02, 0x79, 0x86, 0x8e, 0x85, 0xf2,
113 0x0c, 0x0b, 0x16, 0xca, 0x33, 0x38, 0x49, 0x3c, 0x78, 0x28, 0xc7, 0xf8, 0xe3, 0xa1, 0x1c, 0xe3,
114 0x8a, 0x47, 0x72, 0x8c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c,
115 0x23, 0x20, 0x00, 0x00, 0xff, 0xff, 0x81, 0x2c, 0x72, 0xc1, 0x9e, 0x00, 0x00, 0x00,
116 }
117
118 func (this *M) VerboseEqual(that interface{}) error {
119 if that == nil {
120 if this == nil {
121 return nil
122 }
123 return fmt.Errorf("that == nil && this != nil")
124 }
125
126 that1, ok := that.(*M)
127 if !ok {
128 that2, ok := that.(M)
129 if ok {
130 that1 = &that2
131 } else {
132 return fmt.Errorf("that is not of type *M")
133 }
134 }
135 if that1 == nil {
136 if this == nil {
137 return nil
138 }
139 return fmt.Errorf("that is type *M but is nil && this != nil")
140 } else if this == nil {
141 return fmt.Errorf("that is type *M but is not nil && this == nil")
142 }
143 if len(this.Arr) != len(that1.Arr) {
144 return fmt.Errorf("Arr this(%v) Not Equal that(%v)", len(this.Arr), len(that1.Arr))
145 }
146 for i := range this.Arr {
147 if !this.Arr[i].Equal(that1.Arr[i]) {
148 return fmt.Errorf("Arr this[%v](%v) Not Equal that[%v](%v)", i, this.Arr[i], i, that1.Arr[i])
149 }
150 }
151 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
152 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
153 }
154 return nil
155 }
156 func (this *M) Equal(that interface{}) bool {
157 if that == nil {
158 return this == nil
159 }
160
161 that1, ok := that.(*M)
162 if !ok {
163 that2, ok := that.(M)
164 if ok {
165 that1 = &that2
166 } else {
167 return false
168 }
169 }
170 if that1 == nil {
171 return this == nil
172 } else if this == nil {
173 return false
174 }
175 if len(this.Arr) != len(that1.Arr) {
176 return false
177 }
178 for i := range this.Arr {
179 if !this.Arr[i].Equal(that1.Arr[i]) {
180 return false
181 }
182 }
183 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
184 return false
185 }
186 return true
187 }
188 func (this *MyType) VerboseEqual(that interface{}) error {
189 if that == nil {
190 if this == nil {
191 return nil
192 }
193 return fmt.Errorf("that == nil && this != nil")
194 }
195
196 that1, ok := that.(*MyType)
197 if !ok {
198 that2, ok := that.(MyType)
199 if ok {
200 that1 = &that2
201 } else {
202 return fmt.Errorf("that is not of type *MyType")
203 }
204 }
205 if that1 == nil {
206 if this == nil {
207 return nil
208 }
209 return fmt.Errorf("that is type *MyType but is nil && this != nil")
210 } else if this == nil {
211 return fmt.Errorf("that is type *MyType but is not nil && this == nil")
212 }
213 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
214 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
215 }
216 return nil
217 }
218 func (this *MyType) Equal(that interface{}) bool {
219 if that == nil {
220 return this == nil
221 }
222
223 that1, ok := that.(*MyType)
224 if !ok {
225 that2, ok := that.(MyType)
226 if ok {
227 that1 = &that2
228 } else {
229 return false
230 }
231 }
232 if that1 == nil {
233 return this == nil
234 } else if this == nil {
235 return false
236 }
237 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
238 return false
239 }
240 return true
241 }
242 func (m *M) Marshal() (dAtA []byte, err error) {
243 size := m.Size()
244 dAtA = make([]byte, size)
245 n, err := m.MarshalToSizedBuffer(dAtA[:size])
246 if err != nil {
247 return nil, err
248 }
249 return dAtA[:n], nil
250 }
251
252 func (m *M) MarshalTo(dAtA []byte) (int, error) {
253 size := m.Size()
254 return m.MarshalToSizedBuffer(dAtA[:size])
255 }
256
257 func (m *M) MarshalToSizedBuffer(dAtA []byte) (int, error) {
258 i := len(dAtA)
259 _ = i
260 var l int
261 _ = l
262 if m.XXX_unrecognized != nil {
263 i -= len(m.XXX_unrecognized)
264 copy(dAtA[i:], m.XXX_unrecognized)
265 }
266 if len(m.Arr) > 0 {
267 for iNdEx := len(m.Arr) - 1; iNdEx >= 0; iNdEx-- {
268 {
269 size := m.Arr[iNdEx].Size()
270 i -= size
271 if _, err := m.Arr[iNdEx].MarshalTo(dAtA[i:]); err != nil {
272 return 0, err
273 }
274 i = encodeVarintAsym(dAtA, i, uint64(size))
275 }
276 i--
277 dAtA[i] = 0xa
278 }
279 }
280 return len(dAtA) - i, nil
281 }
282
283 func encodeVarintAsym(dAtA []byte, offset int, v uint64) int {
284 offset -= sovAsym(v)
285 base := offset
286 for v >= 1<<7 {
287 dAtA[offset] = uint8(v&0x7f | 0x80)
288 v >>= 7
289 offset++
290 }
291 dAtA[offset] = uint8(v)
292 return base
293 }
294 func NewPopulatedM(r randyAsym, easy bool) *M {
295 this := &M{}
296 if r.Intn(5) != 0 {
297 v1 := r.Intn(10)
298 this.Arr = make([]MyType, v1)
299 for i := 0; i < v1; i++ {
300 v2 := NewPopulatedMyType(r)
301 this.Arr[i] = *v2
302 }
303 }
304 if !easy && r.Intn(10) != 0 {
305 this.XXX_unrecognized = randUnrecognizedAsym(r, 2)
306 }
307 return this
308 }
309
310 type randyAsym interface {
311 Float32() float32
312 Float64() float64
313 Int63() int64
314 Int31() int32
315 Uint32() uint32
316 Intn(n int) int
317 }
318
319 func randUTF8RuneAsym(r randyAsym) rune {
320 ru := r.Intn(62)
321 if ru < 10 {
322 return rune(ru + 48)
323 } else if ru < 36 {
324 return rune(ru + 55)
325 }
326 return rune(ru + 61)
327 }
328 func randStringAsym(r randyAsym) string {
329 v3 := r.Intn(100)
330 tmps := make([]rune, v3)
331 for i := 0; i < v3; i++ {
332 tmps[i] = randUTF8RuneAsym(r)
333 }
334 return string(tmps)
335 }
336 func randUnrecognizedAsym(r randyAsym, maxFieldNumber int) (dAtA []byte) {
337 l := r.Intn(5)
338 for i := 0; i < l; i++ {
339 wire := r.Intn(4)
340 if wire == 3 {
341 wire = 5
342 }
343 fieldNumber := maxFieldNumber + r.Intn(100)
344 dAtA = randFieldAsym(dAtA, r, fieldNumber, wire)
345 }
346 return dAtA
347 }
348 func randFieldAsym(dAtA []byte, r randyAsym, fieldNumber int, wire int) []byte {
349 key := uint32(fieldNumber)<<3 | uint32(wire)
350 switch wire {
351 case 0:
352 dAtA = encodeVarintPopulateAsym(dAtA, uint64(key))
353 v4 := r.Int63()
354 if r.Intn(2) == 0 {
355 v4 *= -1
356 }
357 dAtA = encodeVarintPopulateAsym(dAtA, uint64(v4))
358 case 1:
359 dAtA = encodeVarintPopulateAsym(dAtA, uint64(key))
360 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)))
361 case 2:
362 dAtA = encodeVarintPopulateAsym(dAtA, uint64(key))
363 ll := r.Intn(100)
364 dAtA = encodeVarintPopulateAsym(dAtA, uint64(ll))
365 for j := 0; j < ll; j++ {
366 dAtA = append(dAtA, byte(r.Intn(256)))
367 }
368 default:
369 dAtA = encodeVarintPopulateAsym(dAtA, uint64(key))
370 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
371 }
372 return dAtA
373 }
374 func encodeVarintPopulateAsym(dAtA []byte, v uint64) []byte {
375 for v >= 1<<7 {
376 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
377 v >>= 7
378 }
379 dAtA = append(dAtA, uint8(v))
380 return dAtA
381 }
382 func (m *M) Size() (n int) {
383 if m == nil {
384 return 0
385 }
386 var l int
387 _ = l
388 if len(m.Arr) > 0 {
389 for _, e := range m.Arr {
390 l = e.Size()
391 n += 1 + l + sovAsym(uint64(l))
392 }
393 }
394 if m.XXX_unrecognized != nil {
395 n += len(m.XXX_unrecognized)
396 }
397 return n
398 }
399
400 func sovAsym(x uint64) (n int) {
401 return (math_bits.Len64(x|1) + 6) / 7
402 }
403 func sozAsym(x uint64) (n int) {
404 return sovAsym(uint64((x << 1) ^ uint64((int64(x) >> 63))))
405 }
406 func (m *M) Unmarshal(dAtA []byte) error {
407 l := len(dAtA)
408 iNdEx := 0
409 for iNdEx < l {
410 preIndex := iNdEx
411 var wire uint64
412 for shift := uint(0); ; shift += 7 {
413 if shift >= 64 {
414 return ErrIntOverflowAsym
415 }
416 if iNdEx >= l {
417 return io.ErrUnexpectedEOF
418 }
419 b := dAtA[iNdEx]
420 iNdEx++
421 wire |= uint64(b&0x7F) << shift
422 if b < 0x80 {
423 break
424 }
425 }
426 fieldNum := int32(wire >> 3)
427 wireType := int(wire & 0x7)
428 if wireType == 4 {
429 return fmt.Errorf("proto: M: wiretype end group for non-group")
430 }
431 if fieldNum <= 0 {
432 return fmt.Errorf("proto: M: illegal tag %d (wire type %d)", fieldNum, wire)
433 }
434 switch fieldNum {
435 case 1:
436 if wireType != 2 {
437 return fmt.Errorf("proto: wrong wireType = %d for field Arr", wireType)
438 }
439 var byteLen int
440 for shift := uint(0); ; shift += 7 {
441 if shift >= 64 {
442 return ErrIntOverflowAsym
443 }
444 if iNdEx >= l {
445 return io.ErrUnexpectedEOF
446 }
447 b := dAtA[iNdEx]
448 iNdEx++
449 byteLen |= int(b&0x7F) << shift
450 if b < 0x80 {
451 break
452 }
453 }
454 if byteLen < 0 {
455 return ErrInvalidLengthAsym
456 }
457 postIndex := iNdEx + byteLen
458 if postIndex < 0 {
459 return ErrInvalidLengthAsym
460 }
461 if postIndex > l {
462 return io.ErrUnexpectedEOF
463 }
464 var v MyType
465 m.Arr = append(m.Arr, v)
466 if err := m.Arr[len(m.Arr)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
467 return err
468 }
469 iNdEx = postIndex
470 default:
471 iNdEx = preIndex
472 skippy, err := skipAsym(dAtA[iNdEx:])
473 if err != nil {
474 return err
475 }
476 if (skippy < 0) || (iNdEx+skippy) < 0 {
477 return ErrInvalidLengthAsym
478 }
479 if (iNdEx + skippy) > l {
480 return io.ErrUnexpectedEOF
481 }
482 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
483 iNdEx += skippy
484 }
485 }
486
487 if iNdEx > l {
488 return io.ErrUnexpectedEOF
489 }
490 return nil
491 }
492 func (m *MyType) Unmarshal(dAtA []byte) error {
493 l := len(dAtA)
494 iNdEx := 0
495 for iNdEx < l {
496 preIndex := iNdEx
497 var wire uint64
498 for shift := uint(0); ; shift += 7 {
499 if shift >= 64 {
500 return ErrIntOverflowAsym
501 }
502 if iNdEx >= l {
503 return io.ErrUnexpectedEOF
504 }
505 b := dAtA[iNdEx]
506 iNdEx++
507 wire |= uint64(b&0x7F) << shift
508 if b < 0x80 {
509 break
510 }
511 }
512 fieldNum := int32(wire >> 3)
513 wireType := int(wire & 0x7)
514 if wireType == 4 {
515 return fmt.Errorf("proto: MyType: wiretype end group for non-group")
516 }
517 if fieldNum <= 0 {
518 return fmt.Errorf("proto: MyType: illegal tag %d (wire type %d)", fieldNum, wire)
519 }
520 switch fieldNum {
521 default:
522 iNdEx = preIndex
523 skippy, err := skipAsym(dAtA[iNdEx:])
524 if err != nil {
525 return err
526 }
527 if (skippy < 0) || (iNdEx+skippy) < 0 {
528 return ErrInvalidLengthAsym
529 }
530 if (iNdEx + skippy) > l {
531 return io.ErrUnexpectedEOF
532 }
533 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
534 iNdEx += skippy
535 }
536 }
537
538 if iNdEx > l {
539 return io.ErrUnexpectedEOF
540 }
541 return nil
542 }
543 func skipAsym(dAtA []byte) (n int, err error) {
544 l := len(dAtA)
545 iNdEx := 0
546 depth := 0
547 for iNdEx < l {
548 var wire uint64
549 for shift := uint(0); ; shift += 7 {
550 if shift >= 64 {
551 return 0, ErrIntOverflowAsym
552 }
553 if iNdEx >= l {
554 return 0, io.ErrUnexpectedEOF
555 }
556 b := dAtA[iNdEx]
557 iNdEx++
558 wire |= (uint64(b) & 0x7F) << shift
559 if b < 0x80 {
560 break
561 }
562 }
563 wireType := int(wire & 0x7)
564 switch wireType {
565 case 0:
566 for shift := uint(0); ; shift += 7 {
567 if shift >= 64 {
568 return 0, ErrIntOverflowAsym
569 }
570 if iNdEx >= l {
571 return 0, io.ErrUnexpectedEOF
572 }
573 iNdEx++
574 if dAtA[iNdEx-1] < 0x80 {
575 break
576 }
577 }
578 case 1:
579 iNdEx += 8
580 case 2:
581 var length int
582 for shift := uint(0); ; shift += 7 {
583 if shift >= 64 {
584 return 0, ErrIntOverflowAsym
585 }
586 if iNdEx >= l {
587 return 0, io.ErrUnexpectedEOF
588 }
589 b := dAtA[iNdEx]
590 iNdEx++
591 length |= (int(b) & 0x7F) << shift
592 if b < 0x80 {
593 break
594 }
595 }
596 if length < 0 {
597 return 0, ErrInvalidLengthAsym
598 }
599 iNdEx += length
600 case 3:
601 depth++
602 case 4:
603 if depth == 0 {
604 return 0, ErrUnexpectedEndOfGroupAsym
605 }
606 depth--
607 case 5:
608 iNdEx += 4
609 default:
610 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
611 }
612 if iNdEx < 0 {
613 return 0, ErrInvalidLengthAsym
614 }
615 if depth == 0 {
616 return iNdEx, nil
617 }
618 }
619 return 0, io.ErrUnexpectedEOF
620 }
621
622 var (
623 ErrInvalidLengthAsym = fmt.Errorf("proto: negative length found during unmarshaling")
624 ErrIntOverflowAsym = fmt.Errorf("proto: integer overflow")
625 ErrUnexpectedEndOfGroupAsym = fmt.Errorf("proto: unexpected end of group")
626 )
627
View as plain text