1
2
3
4 package types
5
6 import (
7 bytes "bytes"
8 encoding_binary "encoding/binary"
9 fmt "fmt"
10 proto "github.com/gogo/protobuf/proto"
11 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
12 io "io"
13 math "math"
14 math_bits "math/bits"
15 reflect "reflect"
16 strconv "strconv"
17 strings "strings"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25
26
27
28
29 const _ = proto.GoGoProtoPackageIsVersion3
30
31
32
33
34
35 type NullValue int32
36
37 const (
38
39 NullValue_NULL_VALUE NullValue = 0
40 )
41
42 var NullValue_name = map[int32]string{
43 0: "NULL_VALUE",
44 }
45
46 var NullValue_value = map[string]int32{
47 "NULL_VALUE": 0,
48 }
49
50 func (NullValue) EnumDescriptor() ([]byte, []int) {
51 return fileDescriptor_df322afd6c9fb402, []int{0}
52 }
53
54 func (NullValue) XXX_WellKnownType() string { return "NullValue" }
55
56
57
58
59
60
61
62
63
64 type Struct struct {
65
66 Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
67 XXX_NoUnkeyedLiteral struct{} `json:"-"`
68 XXX_unrecognized []byte `json:"-"`
69 XXX_sizecache int32 `json:"-"`
70 }
71
72 func (m *Struct) Reset() { *m = Struct{} }
73 func (*Struct) ProtoMessage() {}
74 func (*Struct) Descriptor() ([]byte, []int) {
75 return fileDescriptor_df322afd6c9fb402, []int{0}
76 }
77 func (*Struct) XXX_WellKnownType() string { return "Struct" }
78 func (m *Struct) XXX_Unmarshal(b []byte) error {
79 return m.Unmarshal(b)
80 }
81 func (m *Struct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
82 if deterministic {
83 return xxx_messageInfo_Struct.Marshal(b, m, deterministic)
84 } else {
85 b = b[:cap(b)]
86 n, err := m.MarshalToSizedBuffer(b)
87 if err != nil {
88 return nil, err
89 }
90 return b[:n], nil
91 }
92 }
93 func (m *Struct) XXX_Merge(src proto.Message) {
94 xxx_messageInfo_Struct.Merge(m, src)
95 }
96 func (m *Struct) XXX_Size() int {
97 return m.Size()
98 }
99 func (m *Struct) XXX_DiscardUnknown() {
100 xxx_messageInfo_Struct.DiscardUnknown(m)
101 }
102
103 var xxx_messageInfo_Struct proto.InternalMessageInfo
104
105 func (m *Struct) GetFields() map[string]*Value {
106 if m != nil {
107 return m.Fields
108 }
109 return nil
110 }
111
112 func (*Struct) XXX_MessageName() string {
113 return "google.protobuf.Struct"
114 }
115
116
117
118
119
120
121
122 type Value struct {
123
124
125
126
127
128
129
130
131
132 Kind isValue_Kind `protobuf_oneof:"kind"`
133 XXX_NoUnkeyedLiteral struct{} `json:"-"`
134 XXX_unrecognized []byte `json:"-"`
135 XXX_sizecache int32 `json:"-"`
136 }
137
138 func (m *Value) Reset() { *m = Value{} }
139 func (*Value) ProtoMessage() {}
140 func (*Value) Descriptor() ([]byte, []int) {
141 return fileDescriptor_df322afd6c9fb402, []int{1}
142 }
143 func (*Value) XXX_WellKnownType() string { return "Value" }
144 func (m *Value) XXX_Unmarshal(b []byte) error {
145 return m.Unmarshal(b)
146 }
147 func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
148 if deterministic {
149 return xxx_messageInfo_Value.Marshal(b, m, deterministic)
150 } else {
151 b = b[:cap(b)]
152 n, err := m.MarshalToSizedBuffer(b)
153 if err != nil {
154 return nil, err
155 }
156 return b[:n], nil
157 }
158 }
159 func (m *Value) XXX_Merge(src proto.Message) {
160 xxx_messageInfo_Value.Merge(m, src)
161 }
162 func (m *Value) XXX_Size() int {
163 return m.Size()
164 }
165 func (m *Value) XXX_DiscardUnknown() {
166 xxx_messageInfo_Value.DiscardUnknown(m)
167 }
168
169 var xxx_messageInfo_Value proto.InternalMessageInfo
170
171 type isValue_Kind interface {
172 isValue_Kind()
173 Equal(interface{}) bool
174 MarshalTo([]byte) (int, error)
175 Size() int
176 Compare(interface{}) int
177 }
178
179 type Value_NullValue struct {
180 NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof" json:"null_value,omitempty"`
181 }
182 type Value_NumberValue struct {
183 NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof" json:"number_value,omitempty"`
184 }
185 type Value_StringValue struct {
186 StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
187 }
188 type Value_BoolValue struct {
189 BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof" json:"bool_value,omitempty"`
190 }
191 type Value_StructValue struct {
192 StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof" json:"struct_value,omitempty"`
193 }
194 type Value_ListValue struct {
195 ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof" json:"list_value,omitempty"`
196 }
197
198 func (*Value_NullValue) isValue_Kind() {}
199 func (*Value_NumberValue) isValue_Kind() {}
200 func (*Value_StringValue) isValue_Kind() {}
201 func (*Value_BoolValue) isValue_Kind() {}
202 func (*Value_StructValue) isValue_Kind() {}
203 func (*Value_ListValue) isValue_Kind() {}
204
205 func (m *Value) GetKind() isValue_Kind {
206 if m != nil {
207 return m.Kind
208 }
209 return nil
210 }
211
212 func (m *Value) GetNullValue() NullValue {
213 if x, ok := m.GetKind().(*Value_NullValue); ok {
214 return x.NullValue
215 }
216 return NullValue_NULL_VALUE
217 }
218
219 func (m *Value) GetNumberValue() float64 {
220 if x, ok := m.GetKind().(*Value_NumberValue); ok {
221 return x.NumberValue
222 }
223 return 0
224 }
225
226 func (m *Value) GetStringValue() string {
227 if x, ok := m.GetKind().(*Value_StringValue); ok {
228 return x.StringValue
229 }
230 return ""
231 }
232
233 func (m *Value) GetBoolValue() bool {
234 if x, ok := m.GetKind().(*Value_BoolValue); ok {
235 return x.BoolValue
236 }
237 return false
238 }
239
240 func (m *Value) GetStructValue() *Struct {
241 if x, ok := m.GetKind().(*Value_StructValue); ok {
242 return x.StructValue
243 }
244 return nil
245 }
246
247 func (m *Value) GetListValue() *ListValue {
248 if x, ok := m.GetKind().(*Value_ListValue); ok {
249 return x.ListValue
250 }
251 return nil
252 }
253
254
255 func (*Value) XXX_OneofWrappers() []interface{} {
256 return []interface{}{
257 (*Value_NullValue)(nil),
258 (*Value_NumberValue)(nil),
259 (*Value_StringValue)(nil),
260 (*Value_BoolValue)(nil),
261 (*Value_StructValue)(nil),
262 (*Value_ListValue)(nil),
263 }
264 }
265
266 func (*Value) XXX_MessageName() string {
267 return "google.protobuf.Value"
268 }
269
270
271
272
273 type ListValue struct {
274
275 Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
276 XXX_NoUnkeyedLiteral struct{} `json:"-"`
277 XXX_unrecognized []byte `json:"-"`
278 XXX_sizecache int32 `json:"-"`
279 }
280
281 func (m *ListValue) Reset() { *m = ListValue{} }
282 func (*ListValue) ProtoMessage() {}
283 func (*ListValue) Descriptor() ([]byte, []int) {
284 return fileDescriptor_df322afd6c9fb402, []int{2}
285 }
286 func (*ListValue) XXX_WellKnownType() string { return "ListValue" }
287 func (m *ListValue) XXX_Unmarshal(b []byte) error {
288 return m.Unmarshal(b)
289 }
290 func (m *ListValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
291 if deterministic {
292 return xxx_messageInfo_ListValue.Marshal(b, m, deterministic)
293 } else {
294 b = b[:cap(b)]
295 n, err := m.MarshalToSizedBuffer(b)
296 if err != nil {
297 return nil, err
298 }
299 return b[:n], nil
300 }
301 }
302 func (m *ListValue) XXX_Merge(src proto.Message) {
303 xxx_messageInfo_ListValue.Merge(m, src)
304 }
305 func (m *ListValue) XXX_Size() int {
306 return m.Size()
307 }
308 func (m *ListValue) XXX_DiscardUnknown() {
309 xxx_messageInfo_ListValue.DiscardUnknown(m)
310 }
311
312 var xxx_messageInfo_ListValue proto.InternalMessageInfo
313
314 func (m *ListValue) GetValues() []*Value {
315 if m != nil {
316 return m.Values
317 }
318 return nil
319 }
320
321 func (*ListValue) XXX_MessageName() string {
322 return "google.protobuf.ListValue"
323 }
324 func init() {
325 proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
326 proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
327 proto.RegisterMapType((map[string]*Value)(nil), "google.protobuf.Struct.FieldsEntry")
328 proto.RegisterType((*Value)(nil), "google.protobuf.Value")
329 proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
330 }
331
332 func init() { proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor_df322afd6c9fb402) }
333
334 var fileDescriptor_df322afd6c9fb402 = []byte{
335
336 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xb1, 0x6f, 0xd3, 0x40,
337 0x14, 0xc6, 0xfd, 0x9c, 0xc6, 0x22, 0xcf, 0xa8, 0x54, 0x87, 0x04, 0x51, 0x41, 0x47, 0x94, 0x2e,
338 0x11, 0x42, 0xae, 0x14, 0x16, 0x44, 0x58, 0x88, 0x54, 0x5a, 0x89, 0xa8, 0x32, 0x86, 0x16, 0x89,
339 0x25, 0xc2, 0xae, 0x1b, 0x59, 0xbd, 0xde, 0x55, 0xf6, 0x1d, 0x28, 0x1b, 0x0b, 0xff, 0x03, 0x33,
340 0x13, 0x62, 0xe4, 0xaf, 0xe8, 0xc8, 0xc8, 0x48, 0xdc, 0x85, 0xb1, 0x63, 0x47, 0x74, 0x77, 0xb6,
341 0x41, 0x8d, 0xb2, 0xf9, 0x7d, 0xf7, 0x7b, 0xdf, 0x7b, 0xdf, 0x33, 0xde, 0x9f, 0x09, 0x31, 0x63,
342 0xe9, 0xf6, 0x59, 0x2e, 0xa4, 0x88, 0xd5, 0xf1, 0x76, 0x21, 0x73, 0x95, 0xc8, 0xc0, 0xd4, 0xe4,
343 0x96, 0x7d, 0x0d, 0xea, 0xd7, 0xfe, 0x17, 0x40, 0xef, 0xb5, 0x21, 0xc8, 0x08, 0xbd, 0xe3, 0x2c,
344 0x65, 0x47, 0x45, 0x17, 0x7a, 0xad, 0x81, 0x3f, 0xdc, 0x0a, 0xae, 0xc1, 0x81, 0x05, 0x83, 0x17,
345 0x86, 0xda, 0xe1, 0x32, 0x9f, 0x47, 0x55, 0xcb, 0xe6, 0x2b, 0xf4, 0xff, 0x93, 0xc9, 0x06, 0xb6,
346 0x4e, 0xd2, 0x79, 0x17, 0x7a, 0x30, 0xe8, 0x44, 0xfa, 0x93, 0x3c, 0xc2, 0xf6, 0x87, 0xf7, 0x4c,
347 0xa5, 0x5d, 0xb7, 0x07, 0x03, 0x7f, 0x78, 0x67, 0xc9, 0xfc, 0x50, 0xbf, 0x46, 0x16, 0x7a, 0xea,
348 0x3e, 0x81, 0xfe, 0x0f, 0x17, 0xdb, 0x46, 0x24, 0x23, 0x44, 0xae, 0x18, 0x9b, 0x5a, 0x03, 0x6d,
349 0xba, 0x3e, 0xdc, 0x5c, 0x32, 0xd8, 0x57, 0x8c, 0x19, 0x7e, 0xcf, 0x89, 0x3a, 0xbc, 0x2e, 0xc8,
350 0x16, 0xde, 0xe4, 0xea, 0x34, 0x4e, 0xf3, 0xe9, 0xbf, 0xf9, 0xb0, 0xe7, 0x44, 0xbe, 0x55, 0x1b,
351 0xa8, 0x90, 0x79, 0xc6, 0x67, 0x15, 0xd4, 0xd2, 0x8b, 0x6b, 0xc8, 0xaa, 0x16, 0x7a, 0x80, 0x18,
352 0x0b, 0x51, 0xaf, 0xb1, 0xd6, 0x83, 0xc1, 0x0d, 0x3d, 0x4a, 0x6b, 0x16, 0x78, 0x66, 0x5c, 0x54,
353 0x22, 0x2b, 0xa4, 0x6d, 0xa2, 0xde, 0x5d, 0x71, 0xc7, 0xca, 0x5e, 0x25, 0xb2, 0x49, 0xc9, 0xb2,
354 0xa2, 0xee, 0xf5, 0x4c, 0xef, 0x72, 0xca, 0x49, 0x56, 0xc8, 0x26, 0x25, 0xab, 0x8b, 0xb1, 0x87,
355 0x6b, 0x27, 0x19, 0x3f, 0xea, 0x8f, 0xb0, 0xd3, 0x10, 0x24, 0x40, 0xcf, 0x98, 0xd5, 0x7f, 0x74,
356 0xd5, 0xd1, 0x2b, 0xea, 0xe1, 0x3d, 0xec, 0x34, 0x47, 0x24, 0xeb, 0x88, 0xfb, 0x07, 0x93, 0xc9,
357 0xf4, 0xf0, 0xf9, 0xe4, 0x60, 0x67, 0xc3, 0x19, 0x7f, 0x86, 0x5f, 0x0b, 0xea, 0x5c, 0x2e, 0x28,
358 0x5c, 0x2d, 0x28, 0x7c, 0x2a, 0x29, 0x7c, 0x2b, 0x29, 0x9c, 0x97, 0x14, 0x7e, 0x96, 0x14, 0x7e,
359 0x97, 0x14, 0xfe, 0x94, 0xd4, 0xb9, 0xd4, 0xfa, 0x05, 0x85, 0xf3, 0x0b, 0x0a, 0x78, 0x3b, 0x11,
360 0xa7, 0xd7, 0x47, 0x8e, 0x7d, 0x9b, 0x3e, 0xd4, 0x75, 0x08, 0xef, 0xda, 0x72, 0x7e, 0x96, 0x16,
361 0x57, 0x00, 0x5f, 0xdd, 0xd6, 0x6e, 0x38, 0xfe, 0xee, 0xd2, 0x5d, 0xdb, 0x10, 0xd6, 0x3b, 0xbe,
362 0x4d, 0x19, 0x7b, 0xc9, 0xc5, 0x47, 0xfe, 0x46, 0x93, 0xb1, 0x67, 0x9c, 0x1e, 0xff, 0x0d, 0x00,
363 0x00, 0xff, 0xff, 0x26, 0x30, 0xdb, 0xbe, 0xe9, 0x02, 0x00, 0x00,
364 }
365
366 func (this *Struct) Compare(that interface{}) int {
367 if that == nil {
368 if this == nil {
369 return 0
370 }
371 return 1
372 }
373
374 that1, ok := that.(*Struct)
375 if !ok {
376 that2, ok := that.(Struct)
377 if ok {
378 that1 = &that2
379 } else {
380 return 1
381 }
382 }
383 if that1 == nil {
384 if this == nil {
385 return 0
386 }
387 return 1
388 } else if this == nil {
389 return -1
390 }
391 if len(this.Fields) != len(that1.Fields) {
392 if len(this.Fields) < len(that1.Fields) {
393 return -1
394 }
395 return 1
396 }
397 for i := range this.Fields {
398 if c := this.Fields[i].Compare(that1.Fields[i]); c != 0 {
399 return c
400 }
401 }
402 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
403 return c
404 }
405 return 0
406 }
407 func (this *Value) Compare(that interface{}) int {
408 if that == nil {
409 if this == nil {
410 return 0
411 }
412 return 1
413 }
414
415 that1, ok := that.(*Value)
416 if !ok {
417 that2, ok := that.(Value)
418 if ok {
419 that1 = &that2
420 } else {
421 return 1
422 }
423 }
424 if that1 == nil {
425 if this == nil {
426 return 0
427 }
428 return 1
429 } else if this == nil {
430 return -1
431 }
432 if that1.Kind == nil {
433 if this.Kind != nil {
434 return 1
435 }
436 } else if this.Kind == nil {
437 return -1
438 } else {
439 thisType := -1
440 switch this.Kind.(type) {
441 case *Value_NullValue:
442 thisType = 0
443 case *Value_NumberValue:
444 thisType = 1
445 case *Value_StringValue:
446 thisType = 2
447 case *Value_BoolValue:
448 thisType = 3
449 case *Value_StructValue:
450 thisType = 4
451 case *Value_ListValue:
452 thisType = 5
453 default:
454 panic(fmt.Sprintf("compare: unexpected type %T in oneof", this.Kind))
455 }
456 that1Type := -1
457 switch that1.Kind.(type) {
458 case *Value_NullValue:
459 that1Type = 0
460 case *Value_NumberValue:
461 that1Type = 1
462 case *Value_StringValue:
463 that1Type = 2
464 case *Value_BoolValue:
465 that1Type = 3
466 case *Value_StructValue:
467 that1Type = 4
468 case *Value_ListValue:
469 that1Type = 5
470 default:
471 panic(fmt.Sprintf("compare: unexpected type %T in oneof", that1.Kind))
472 }
473 if thisType == that1Type {
474 if c := this.Kind.Compare(that1.Kind); c != 0 {
475 return c
476 }
477 } else if thisType < that1Type {
478 return -1
479 } else if thisType > that1Type {
480 return 1
481 }
482 }
483 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
484 return c
485 }
486 return 0
487 }
488 func (this *Value_NullValue) Compare(that interface{}) int {
489 if that == nil {
490 if this == nil {
491 return 0
492 }
493 return 1
494 }
495
496 that1, ok := that.(*Value_NullValue)
497 if !ok {
498 that2, ok := that.(Value_NullValue)
499 if ok {
500 that1 = &that2
501 } else {
502 return 1
503 }
504 }
505 if that1 == nil {
506 if this == nil {
507 return 0
508 }
509 return 1
510 } else if this == nil {
511 return -1
512 }
513 if this.NullValue != that1.NullValue {
514 if this.NullValue < that1.NullValue {
515 return -1
516 }
517 return 1
518 }
519 return 0
520 }
521 func (this *Value_NumberValue) Compare(that interface{}) int {
522 if that == nil {
523 if this == nil {
524 return 0
525 }
526 return 1
527 }
528
529 that1, ok := that.(*Value_NumberValue)
530 if !ok {
531 that2, ok := that.(Value_NumberValue)
532 if ok {
533 that1 = &that2
534 } else {
535 return 1
536 }
537 }
538 if that1 == nil {
539 if this == nil {
540 return 0
541 }
542 return 1
543 } else if this == nil {
544 return -1
545 }
546 if this.NumberValue != that1.NumberValue {
547 if this.NumberValue < that1.NumberValue {
548 return -1
549 }
550 return 1
551 }
552 return 0
553 }
554 func (this *Value_StringValue) Compare(that interface{}) int {
555 if that == nil {
556 if this == nil {
557 return 0
558 }
559 return 1
560 }
561
562 that1, ok := that.(*Value_StringValue)
563 if !ok {
564 that2, ok := that.(Value_StringValue)
565 if ok {
566 that1 = &that2
567 } else {
568 return 1
569 }
570 }
571 if that1 == nil {
572 if this == nil {
573 return 0
574 }
575 return 1
576 } else if this == nil {
577 return -1
578 }
579 if this.StringValue != that1.StringValue {
580 if this.StringValue < that1.StringValue {
581 return -1
582 }
583 return 1
584 }
585 return 0
586 }
587 func (this *Value_BoolValue) Compare(that interface{}) int {
588 if that == nil {
589 if this == nil {
590 return 0
591 }
592 return 1
593 }
594
595 that1, ok := that.(*Value_BoolValue)
596 if !ok {
597 that2, ok := that.(Value_BoolValue)
598 if ok {
599 that1 = &that2
600 } else {
601 return 1
602 }
603 }
604 if that1 == nil {
605 if this == nil {
606 return 0
607 }
608 return 1
609 } else if this == nil {
610 return -1
611 }
612 if this.BoolValue != that1.BoolValue {
613 if !this.BoolValue {
614 return -1
615 }
616 return 1
617 }
618 return 0
619 }
620 func (this *Value_StructValue) Compare(that interface{}) int {
621 if that == nil {
622 if this == nil {
623 return 0
624 }
625 return 1
626 }
627
628 that1, ok := that.(*Value_StructValue)
629 if !ok {
630 that2, ok := that.(Value_StructValue)
631 if ok {
632 that1 = &that2
633 } else {
634 return 1
635 }
636 }
637 if that1 == nil {
638 if this == nil {
639 return 0
640 }
641 return 1
642 } else if this == nil {
643 return -1
644 }
645 if c := this.StructValue.Compare(that1.StructValue); c != 0 {
646 return c
647 }
648 return 0
649 }
650 func (this *Value_ListValue) Compare(that interface{}) int {
651 if that == nil {
652 if this == nil {
653 return 0
654 }
655 return 1
656 }
657
658 that1, ok := that.(*Value_ListValue)
659 if !ok {
660 that2, ok := that.(Value_ListValue)
661 if ok {
662 that1 = &that2
663 } else {
664 return 1
665 }
666 }
667 if that1 == nil {
668 if this == nil {
669 return 0
670 }
671 return 1
672 } else if this == nil {
673 return -1
674 }
675 if c := this.ListValue.Compare(that1.ListValue); c != 0 {
676 return c
677 }
678 return 0
679 }
680 func (this *ListValue) Compare(that interface{}) int {
681 if that == nil {
682 if this == nil {
683 return 0
684 }
685 return 1
686 }
687
688 that1, ok := that.(*ListValue)
689 if !ok {
690 that2, ok := that.(ListValue)
691 if ok {
692 that1 = &that2
693 } else {
694 return 1
695 }
696 }
697 if that1 == nil {
698 if this == nil {
699 return 0
700 }
701 return 1
702 } else if this == nil {
703 return -1
704 }
705 if len(this.Values) != len(that1.Values) {
706 if len(this.Values) < len(that1.Values) {
707 return -1
708 }
709 return 1
710 }
711 for i := range this.Values {
712 if c := this.Values[i].Compare(that1.Values[i]); c != 0 {
713 return c
714 }
715 }
716 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
717 return c
718 }
719 return 0
720 }
721 func (x NullValue) String() string {
722 s, ok := NullValue_name[int32(x)]
723 if ok {
724 return s
725 }
726 return strconv.Itoa(int(x))
727 }
728 func (this *Struct) Equal(that interface{}) bool {
729 if that == nil {
730 return this == nil
731 }
732
733 that1, ok := that.(*Struct)
734 if !ok {
735 that2, ok := that.(Struct)
736 if ok {
737 that1 = &that2
738 } else {
739 return false
740 }
741 }
742 if that1 == nil {
743 return this == nil
744 } else if this == nil {
745 return false
746 }
747 if len(this.Fields) != len(that1.Fields) {
748 return false
749 }
750 for i := range this.Fields {
751 if !this.Fields[i].Equal(that1.Fields[i]) {
752 return false
753 }
754 }
755 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
756 return false
757 }
758 return true
759 }
760 func (this *Value) Equal(that interface{}) bool {
761 if that == nil {
762 return this == nil
763 }
764
765 that1, ok := that.(*Value)
766 if !ok {
767 that2, ok := that.(Value)
768 if ok {
769 that1 = &that2
770 } else {
771 return false
772 }
773 }
774 if that1 == nil {
775 return this == nil
776 } else if this == nil {
777 return false
778 }
779 if that1.Kind == nil {
780 if this.Kind != nil {
781 return false
782 }
783 } else if this.Kind == nil {
784 return false
785 } else if !this.Kind.Equal(that1.Kind) {
786 return false
787 }
788 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
789 return false
790 }
791 return true
792 }
793 func (this *Value_NullValue) Equal(that interface{}) bool {
794 if that == nil {
795 return this == nil
796 }
797
798 that1, ok := that.(*Value_NullValue)
799 if !ok {
800 that2, ok := that.(Value_NullValue)
801 if ok {
802 that1 = &that2
803 } else {
804 return false
805 }
806 }
807 if that1 == nil {
808 return this == nil
809 } else if this == nil {
810 return false
811 }
812 if this.NullValue != that1.NullValue {
813 return false
814 }
815 return true
816 }
817 func (this *Value_NumberValue) Equal(that interface{}) bool {
818 if that == nil {
819 return this == nil
820 }
821
822 that1, ok := that.(*Value_NumberValue)
823 if !ok {
824 that2, ok := that.(Value_NumberValue)
825 if ok {
826 that1 = &that2
827 } else {
828 return false
829 }
830 }
831 if that1 == nil {
832 return this == nil
833 } else if this == nil {
834 return false
835 }
836 if this.NumberValue != that1.NumberValue {
837 return false
838 }
839 return true
840 }
841 func (this *Value_StringValue) Equal(that interface{}) bool {
842 if that == nil {
843 return this == nil
844 }
845
846 that1, ok := that.(*Value_StringValue)
847 if !ok {
848 that2, ok := that.(Value_StringValue)
849 if ok {
850 that1 = &that2
851 } else {
852 return false
853 }
854 }
855 if that1 == nil {
856 return this == nil
857 } else if this == nil {
858 return false
859 }
860 if this.StringValue != that1.StringValue {
861 return false
862 }
863 return true
864 }
865 func (this *Value_BoolValue) Equal(that interface{}) bool {
866 if that == nil {
867 return this == nil
868 }
869
870 that1, ok := that.(*Value_BoolValue)
871 if !ok {
872 that2, ok := that.(Value_BoolValue)
873 if ok {
874 that1 = &that2
875 } else {
876 return false
877 }
878 }
879 if that1 == nil {
880 return this == nil
881 } else if this == nil {
882 return false
883 }
884 if this.BoolValue != that1.BoolValue {
885 return false
886 }
887 return true
888 }
889 func (this *Value_StructValue) Equal(that interface{}) bool {
890 if that == nil {
891 return this == nil
892 }
893
894 that1, ok := that.(*Value_StructValue)
895 if !ok {
896 that2, ok := that.(Value_StructValue)
897 if ok {
898 that1 = &that2
899 } else {
900 return false
901 }
902 }
903 if that1 == nil {
904 return this == nil
905 } else if this == nil {
906 return false
907 }
908 if !this.StructValue.Equal(that1.StructValue) {
909 return false
910 }
911 return true
912 }
913 func (this *Value_ListValue) Equal(that interface{}) bool {
914 if that == nil {
915 return this == nil
916 }
917
918 that1, ok := that.(*Value_ListValue)
919 if !ok {
920 that2, ok := that.(Value_ListValue)
921 if ok {
922 that1 = &that2
923 } else {
924 return false
925 }
926 }
927 if that1 == nil {
928 return this == nil
929 } else if this == nil {
930 return false
931 }
932 if !this.ListValue.Equal(that1.ListValue) {
933 return false
934 }
935 return true
936 }
937 func (this *ListValue) Equal(that interface{}) bool {
938 if that == nil {
939 return this == nil
940 }
941
942 that1, ok := that.(*ListValue)
943 if !ok {
944 that2, ok := that.(ListValue)
945 if ok {
946 that1 = &that2
947 } else {
948 return false
949 }
950 }
951 if that1 == nil {
952 return this == nil
953 } else if this == nil {
954 return false
955 }
956 if len(this.Values) != len(that1.Values) {
957 return false
958 }
959 for i := range this.Values {
960 if !this.Values[i].Equal(that1.Values[i]) {
961 return false
962 }
963 }
964 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
965 return false
966 }
967 return true
968 }
969 func (this *Struct) GoString() string {
970 if this == nil {
971 return "nil"
972 }
973 s := make([]string, 0, 5)
974 s = append(s, "&types.Struct{")
975 keysForFields := make([]string, 0, len(this.Fields))
976 for k := range this.Fields {
977 keysForFields = append(keysForFields, k)
978 }
979 github_com_gogo_protobuf_sortkeys.Strings(keysForFields)
980 mapStringForFields := "map[string]*Value{"
981 for _, k := range keysForFields {
982 mapStringForFields += fmt.Sprintf("%#v: %#v,", k, this.Fields[k])
983 }
984 mapStringForFields += "}"
985 if this.Fields != nil {
986 s = append(s, "Fields: "+mapStringForFields+",\n")
987 }
988 if this.XXX_unrecognized != nil {
989 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
990 }
991 s = append(s, "}")
992 return strings.Join(s, "")
993 }
994 func (this *Value) GoString() string {
995 if this == nil {
996 return "nil"
997 }
998 s := make([]string, 0, 10)
999 s = append(s, "&types.Value{")
1000 if this.Kind != nil {
1001 s = append(s, "Kind: "+fmt.Sprintf("%#v", this.Kind)+",\n")
1002 }
1003 if this.XXX_unrecognized != nil {
1004 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1005 }
1006 s = append(s, "}")
1007 return strings.Join(s, "")
1008 }
1009 func (this *Value_NullValue) GoString() string {
1010 if this == nil {
1011 return "nil"
1012 }
1013 s := strings.Join([]string{`&types.Value_NullValue{` +
1014 `NullValue:` + fmt.Sprintf("%#v", this.NullValue) + `}`}, ", ")
1015 return s
1016 }
1017 func (this *Value_NumberValue) GoString() string {
1018 if this == nil {
1019 return "nil"
1020 }
1021 s := strings.Join([]string{`&types.Value_NumberValue{` +
1022 `NumberValue:` + fmt.Sprintf("%#v", this.NumberValue) + `}`}, ", ")
1023 return s
1024 }
1025 func (this *Value_StringValue) GoString() string {
1026 if this == nil {
1027 return "nil"
1028 }
1029 s := strings.Join([]string{`&types.Value_StringValue{` +
1030 `StringValue:` + fmt.Sprintf("%#v", this.StringValue) + `}`}, ", ")
1031 return s
1032 }
1033 func (this *Value_BoolValue) GoString() string {
1034 if this == nil {
1035 return "nil"
1036 }
1037 s := strings.Join([]string{`&types.Value_BoolValue{` +
1038 `BoolValue:` + fmt.Sprintf("%#v", this.BoolValue) + `}`}, ", ")
1039 return s
1040 }
1041 func (this *Value_StructValue) GoString() string {
1042 if this == nil {
1043 return "nil"
1044 }
1045 s := strings.Join([]string{`&types.Value_StructValue{` +
1046 `StructValue:` + fmt.Sprintf("%#v", this.StructValue) + `}`}, ", ")
1047 return s
1048 }
1049 func (this *Value_ListValue) GoString() string {
1050 if this == nil {
1051 return "nil"
1052 }
1053 s := strings.Join([]string{`&types.Value_ListValue{` +
1054 `ListValue:` + fmt.Sprintf("%#v", this.ListValue) + `}`}, ", ")
1055 return s
1056 }
1057 func (this *ListValue) GoString() string {
1058 if this == nil {
1059 return "nil"
1060 }
1061 s := make([]string, 0, 5)
1062 s = append(s, "&types.ListValue{")
1063 if this.Values != nil {
1064 s = append(s, "Values: "+fmt.Sprintf("%#v", this.Values)+",\n")
1065 }
1066 if this.XXX_unrecognized != nil {
1067 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1068 }
1069 s = append(s, "}")
1070 return strings.Join(s, "")
1071 }
1072 func valueToGoStringStruct(v interface{}, typ string) string {
1073 rv := reflect.ValueOf(v)
1074 if rv.IsNil() {
1075 return "nil"
1076 }
1077 pv := reflect.Indirect(rv).Interface()
1078 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
1079 }
1080 func (m *Struct) Marshal() (dAtA []byte, err error) {
1081 size := m.Size()
1082 dAtA = make([]byte, size)
1083 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1084 if err != nil {
1085 return nil, err
1086 }
1087 return dAtA[:n], nil
1088 }
1089
1090 func (m *Struct) MarshalTo(dAtA []byte) (int, error) {
1091 size := m.Size()
1092 return m.MarshalToSizedBuffer(dAtA[:size])
1093 }
1094
1095 func (m *Struct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1096 i := len(dAtA)
1097 _ = i
1098 var l int
1099 _ = l
1100 if m.XXX_unrecognized != nil {
1101 i -= len(m.XXX_unrecognized)
1102 copy(dAtA[i:], m.XXX_unrecognized)
1103 }
1104 if len(m.Fields) > 0 {
1105 for k := range m.Fields {
1106 v := m.Fields[k]
1107 baseI := i
1108 if v != nil {
1109 {
1110 size, err := v.MarshalToSizedBuffer(dAtA[:i])
1111 if err != nil {
1112 return 0, err
1113 }
1114 i -= size
1115 i = encodeVarintStruct(dAtA, i, uint64(size))
1116 }
1117 i--
1118 dAtA[i] = 0x12
1119 }
1120 i -= len(k)
1121 copy(dAtA[i:], k)
1122 i = encodeVarintStruct(dAtA, i, uint64(len(k)))
1123 i--
1124 dAtA[i] = 0xa
1125 i = encodeVarintStruct(dAtA, i, uint64(baseI-i))
1126 i--
1127 dAtA[i] = 0xa
1128 }
1129 }
1130 return len(dAtA) - i, nil
1131 }
1132
1133 func (m *Value) Marshal() (dAtA []byte, err error) {
1134 size := m.Size()
1135 dAtA = make([]byte, size)
1136 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1137 if err != nil {
1138 return nil, err
1139 }
1140 return dAtA[:n], nil
1141 }
1142
1143 func (m *Value) MarshalTo(dAtA []byte) (int, error) {
1144 size := m.Size()
1145 return m.MarshalToSizedBuffer(dAtA[:size])
1146 }
1147
1148 func (m *Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1149 i := len(dAtA)
1150 _ = i
1151 var l int
1152 _ = l
1153 if m.XXX_unrecognized != nil {
1154 i -= len(m.XXX_unrecognized)
1155 copy(dAtA[i:], m.XXX_unrecognized)
1156 }
1157 if m.Kind != nil {
1158 {
1159 size := m.Kind.Size()
1160 i -= size
1161 if _, err := m.Kind.MarshalTo(dAtA[i:]); err != nil {
1162 return 0, err
1163 }
1164 }
1165 }
1166 return len(dAtA) - i, nil
1167 }
1168
1169 func (m *Value_NullValue) MarshalTo(dAtA []byte) (int, error) {
1170 size := m.Size()
1171 return m.MarshalToSizedBuffer(dAtA[:size])
1172 }
1173
1174 func (m *Value_NullValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1175 i := len(dAtA)
1176 i = encodeVarintStruct(dAtA, i, uint64(m.NullValue))
1177 i--
1178 dAtA[i] = 0x8
1179 return len(dAtA) - i, nil
1180 }
1181 func (m *Value_NumberValue) MarshalTo(dAtA []byte) (int, error) {
1182 size := m.Size()
1183 return m.MarshalToSizedBuffer(dAtA[:size])
1184 }
1185
1186 func (m *Value_NumberValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1187 i := len(dAtA)
1188 i -= 8
1189 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.NumberValue))))
1190 i--
1191 dAtA[i] = 0x11
1192 return len(dAtA) - i, nil
1193 }
1194 func (m *Value_StringValue) MarshalTo(dAtA []byte) (int, error) {
1195 size := m.Size()
1196 return m.MarshalToSizedBuffer(dAtA[:size])
1197 }
1198
1199 func (m *Value_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1200 i := len(dAtA)
1201 i -= len(m.StringValue)
1202 copy(dAtA[i:], m.StringValue)
1203 i = encodeVarintStruct(dAtA, i, uint64(len(m.StringValue)))
1204 i--
1205 dAtA[i] = 0x1a
1206 return len(dAtA) - i, nil
1207 }
1208 func (m *Value_BoolValue) MarshalTo(dAtA []byte) (int, error) {
1209 size := m.Size()
1210 return m.MarshalToSizedBuffer(dAtA[:size])
1211 }
1212
1213 func (m *Value_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1214 i := len(dAtA)
1215 i--
1216 if m.BoolValue {
1217 dAtA[i] = 1
1218 } else {
1219 dAtA[i] = 0
1220 }
1221 i--
1222 dAtA[i] = 0x20
1223 return len(dAtA) - i, nil
1224 }
1225 func (m *Value_StructValue) MarshalTo(dAtA []byte) (int, error) {
1226 size := m.Size()
1227 return m.MarshalToSizedBuffer(dAtA[:size])
1228 }
1229
1230 func (m *Value_StructValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1231 i := len(dAtA)
1232 if m.StructValue != nil {
1233 {
1234 size, err := m.StructValue.MarshalToSizedBuffer(dAtA[:i])
1235 if err != nil {
1236 return 0, err
1237 }
1238 i -= size
1239 i = encodeVarintStruct(dAtA, i, uint64(size))
1240 }
1241 i--
1242 dAtA[i] = 0x2a
1243 }
1244 return len(dAtA) - i, nil
1245 }
1246 func (m *Value_ListValue) MarshalTo(dAtA []byte) (int, error) {
1247 size := m.Size()
1248 return m.MarshalToSizedBuffer(dAtA[:size])
1249 }
1250
1251 func (m *Value_ListValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1252 i := len(dAtA)
1253 if m.ListValue != nil {
1254 {
1255 size, err := m.ListValue.MarshalToSizedBuffer(dAtA[:i])
1256 if err != nil {
1257 return 0, err
1258 }
1259 i -= size
1260 i = encodeVarintStruct(dAtA, i, uint64(size))
1261 }
1262 i--
1263 dAtA[i] = 0x32
1264 }
1265 return len(dAtA) - i, nil
1266 }
1267 func (m *ListValue) Marshal() (dAtA []byte, err error) {
1268 size := m.Size()
1269 dAtA = make([]byte, size)
1270 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1271 if err != nil {
1272 return nil, err
1273 }
1274 return dAtA[:n], nil
1275 }
1276
1277 func (m *ListValue) MarshalTo(dAtA []byte) (int, error) {
1278 size := m.Size()
1279 return m.MarshalToSizedBuffer(dAtA[:size])
1280 }
1281
1282 func (m *ListValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1283 i := len(dAtA)
1284 _ = i
1285 var l int
1286 _ = l
1287 if m.XXX_unrecognized != nil {
1288 i -= len(m.XXX_unrecognized)
1289 copy(dAtA[i:], m.XXX_unrecognized)
1290 }
1291 if len(m.Values) > 0 {
1292 for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
1293 {
1294 size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1295 if err != nil {
1296 return 0, err
1297 }
1298 i -= size
1299 i = encodeVarintStruct(dAtA, i, uint64(size))
1300 }
1301 i--
1302 dAtA[i] = 0xa
1303 }
1304 }
1305 return len(dAtA) - i, nil
1306 }
1307
1308 func encodeVarintStruct(dAtA []byte, offset int, v uint64) int {
1309 offset -= sovStruct(v)
1310 base := offset
1311 for v >= 1<<7 {
1312 dAtA[offset] = uint8(v&0x7f | 0x80)
1313 v >>= 7
1314 offset++
1315 }
1316 dAtA[offset] = uint8(v)
1317 return base
1318 }
1319 func NewPopulatedStruct(r randyStruct, easy bool) *Struct {
1320 this := &Struct{}
1321 if r.Intn(5) == 0 {
1322 v1 := r.Intn(10)
1323 this.Fields = make(map[string]*Value)
1324 for i := 0; i < v1; i++ {
1325 this.Fields[randStringStruct(r)] = NewPopulatedValue(r, easy)
1326 }
1327 }
1328 if !easy && r.Intn(10) != 0 {
1329 this.XXX_unrecognized = randUnrecognizedStruct(r, 2)
1330 }
1331 return this
1332 }
1333
1334 func NewPopulatedValue(r randyStruct, easy bool) *Value {
1335 this := &Value{}
1336 oneofNumber_Kind := []int32{1, 2, 3, 4, 5, 6}[r.Intn(6)]
1337 switch oneofNumber_Kind {
1338 case 1:
1339 this.Kind = NewPopulatedValue_NullValue(r, easy)
1340 case 2:
1341 this.Kind = NewPopulatedValue_NumberValue(r, easy)
1342 case 3:
1343 this.Kind = NewPopulatedValue_StringValue(r, easy)
1344 case 4:
1345 this.Kind = NewPopulatedValue_BoolValue(r, easy)
1346 case 5:
1347 this.Kind = NewPopulatedValue_StructValue(r, easy)
1348 case 6:
1349 this.Kind = NewPopulatedValue_ListValue(r, easy)
1350 }
1351 if !easy && r.Intn(10) != 0 {
1352 this.XXX_unrecognized = randUnrecognizedStruct(r, 7)
1353 }
1354 return this
1355 }
1356
1357 func NewPopulatedValue_NullValue(r randyStruct, easy bool) *Value_NullValue {
1358 this := &Value_NullValue{}
1359 this.NullValue = NullValue([]int32{0}[r.Intn(1)])
1360 return this
1361 }
1362 func NewPopulatedValue_NumberValue(r randyStruct, easy bool) *Value_NumberValue {
1363 this := &Value_NumberValue{}
1364 this.NumberValue = float64(r.Float64())
1365 if r.Intn(2) == 0 {
1366 this.NumberValue *= -1
1367 }
1368 return this
1369 }
1370 func NewPopulatedValue_StringValue(r randyStruct, easy bool) *Value_StringValue {
1371 this := &Value_StringValue{}
1372 this.StringValue = string(randStringStruct(r))
1373 return this
1374 }
1375 func NewPopulatedValue_BoolValue(r randyStruct, easy bool) *Value_BoolValue {
1376 this := &Value_BoolValue{}
1377 this.BoolValue = bool(bool(r.Intn(2) == 0))
1378 return this
1379 }
1380 func NewPopulatedValue_StructValue(r randyStruct, easy bool) *Value_StructValue {
1381 this := &Value_StructValue{}
1382 this.StructValue = NewPopulatedStruct(r, easy)
1383 return this
1384 }
1385 func NewPopulatedValue_ListValue(r randyStruct, easy bool) *Value_ListValue {
1386 this := &Value_ListValue{}
1387 this.ListValue = NewPopulatedListValue(r, easy)
1388 return this
1389 }
1390 func NewPopulatedListValue(r randyStruct, easy bool) *ListValue {
1391 this := &ListValue{}
1392 if r.Intn(5) == 0 {
1393 v2 := r.Intn(5)
1394 this.Values = make([]*Value, v2)
1395 for i := 0; i < v2; i++ {
1396 this.Values[i] = NewPopulatedValue(r, easy)
1397 }
1398 }
1399 if !easy && r.Intn(10) != 0 {
1400 this.XXX_unrecognized = randUnrecognizedStruct(r, 2)
1401 }
1402 return this
1403 }
1404
1405 type randyStruct interface {
1406 Float32() float32
1407 Float64() float64
1408 Int63() int64
1409 Int31() int32
1410 Uint32() uint32
1411 Intn(n int) int
1412 }
1413
1414 func randUTF8RuneStruct(r randyStruct) rune {
1415 ru := r.Intn(62)
1416 if ru < 10 {
1417 return rune(ru + 48)
1418 } else if ru < 36 {
1419 return rune(ru + 55)
1420 }
1421 return rune(ru + 61)
1422 }
1423 func randStringStruct(r randyStruct) string {
1424 v3 := r.Intn(100)
1425 tmps := make([]rune, v3)
1426 for i := 0; i < v3; i++ {
1427 tmps[i] = randUTF8RuneStruct(r)
1428 }
1429 return string(tmps)
1430 }
1431 func randUnrecognizedStruct(r randyStruct, maxFieldNumber int) (dAtA []byte) {
1432 l := r.Intn(5)
1433 for i := 0; i < l; i++ {
1434 wire := r.Intn(4)
1435 if wire == 3 {
1436 wire = 5
1437 }
1438 fieldNumber := maxFieldNumber + r.Intn(100)
1439 dAtA = randFieldStruct(dAtA, r, fieldNumber, wire)
1440 }
1441 return dAtA
1442 }
1443 func randFieldStruct(dAtA []byte, r randyStruct, fieldNumber int, wire int) []byte {
1444 key := uint32(fieldNumber)<<3 | uint32(wire)
1445 switch wire {
1446 case 0:
1447 dAtA = encodeVarintPopulateStruct(dAtA, uint64(key))
1448 v4 := r.Int63()
1449 if r.Intn(2) == 0 {
1450 v4 *= -1
1451 }
1452 dAtA = encodeVarintPopulateStruct(dAtA, uint64(v4))
1453 case 1:
1454 dAtA = encodeVarintPopulateStruct(dAtA, uint64(key))
1455 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)))
1456 case 2:
1457 dAtA = encodeVarintPopulateStruct(dAtA, uint64(key))
1458 ll := r.Intn(100)
1459 dAtA = encodeVarintPopulateStruct(dAtA, uint64(ll))
1460 for j := 0; j < ll; j++ {
1461 dAtA = append(dAtA, byte(r.Intn(256)))
1462 }
1463 default:
1464 dAtA = encodeVarintPopulateStruct(dAtA, uint64(key))
1465 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
1466 }
1467 return dAtA
1468 }
1469 func encodeVarintPopulateStruct(dAtA []byte, v uint64) []byte {
1470 for v >= 1<<7 {
1471 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
1472 v >>= 7
1473 }
1474 dAtA = append(dAtA, uint8(v))
1475 return dAtA
1476 }
1477 func (m *Struct) Size() (n int) {
1478 if m == nil {
1479 return 0
1480 }
1481 var l int
1482 _ = l
1483 if len(m.Fields) > 0 {
1484 for k, v := range m.Fields {
1485 _ = k
1486 _ = v
1487 l = 0
1488 if v != nil {
1489 l = v.Size()
1490 l += 1 + sovStruct(uint64(l))
1491 }
1492 mapEntrySize := 1 + len(k) + sovStruct(uint64(len(k))) + l
1493 n += mapEntrySize + 1 + sovStruct(uint64(mapEntrySize))
1494 }
1495 }
1496 if m.XXX_unrecognized != nil {
1497 n += len(m.XXX_unrecognized)
1498 }
1499 return n
1500 }
1501
1502 func (m *Value) Size() (n int) {
1503 if m == nil {
1504 return 0
1505 }
1506 var l int
1507 _ = l
1508 if m.Kind != nil {
1509 n += m.Kind.Size()
1510 }
1511 if m.XXX_unrecognized != nil {
1512 n += len(m.XXX_unrecognized)
1513 }
1514 return n
1515 }
1516
1517 func (m *Value_NullValue) Size() (n int) {
1518 if m == nil {
1519 return 0
1520 }
1521 var l int
1522 _ = l
1523 n += 1 + sovStruct(uint64(m.NullValue))
1524 return n
1525 }
1526 func (m *Value_NumberValue) Size() (n int) {
1527 if m == nil {
1528 return 0
1529 }
1530 var l int
1531 _ = l
1532 n += 9
1533 return n
1534 }
1535 func (m *Value_StringValue) Size() (n int) {
1536 if m == nil {
1537 return 0
1538 }
1539 var l int
1540 _ = l
1541 l = len(m.StringValue)
1542 n += 1 + l + sovStruct(uint64(l))
1543 return n
1544 }
1545 func (m *Value_BoolValue) Size() (n int) {
1546 if m == nil {
1547 return 0
1548 }
1549 var l int
1550 _ = l
1551 n += 2
1552 return n
1553 }
1554 func (m *Value_StructValue) Size() (n int) {
1555 if m == nil {
1556 return 0
1557 }
1558 var l int
1559 _ = l
1560 if m.StructValue != nil {
1561 l = m.StructValue.Size()
1562 n += 1 + l + sovStruct(uint64(l))
1563 }
1564 return n
1565 }
1566 func (m *Value_ListValue) Size() (n int) {
1567 if m == nil {
1568 return 0
1569 }
1570 var l int
1571 _ = l
1572 if m.ListValue != nil {
1573 l = m.ListValue.Size()
1574 n += 1 + l + sovStruct(uint64(l))
1575 }
1576 return n
1577 }
1578 func (m *ListValue) Size() (n int) {
1579 if m == nil {
1580 return 0
1581 }
1582 var l int
1583 _ = l
1584 if len(m.Values) > 0 {
1585 for _, e := range m.Values {
1586 l = e.Size()
1587 n += 1 + l + sovStruct(uint64(l))
1588 }
1589 }
1590 if m.XXX_unrecognized != nil {
1591 n += len(m.XXX_unrecognized)
1592 }
1593 return n
1594 }
1595
1596 func sovStruct(x uint64) (n int) {
1597 return (math_bits.Len64(x|1) + 6) / 7
1598 }
1599 func sozStruct(x uint64) (n int) {
1600 return sovStruct(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1601 }
1602 func (this *Struct) String() string {
1603 if this == nil {
1604 return "nil"
1605 }
1606 keysForFields := make([]string, 0, len(this.Fields))
1607 for k := range this.Fields {
1608 keysForFields = append(keysForFields, k)
1609 }
1610 github_com_gogo_protobuf_sortkeys.Strings(keysForFields)
1611 mapStringForFields := "map[string]*Value{"
1612 for _, k := range keysForFields {
1613 mapStringForFields += fmt.Sprintf("%v: %v,", k, this.Fields[k])
1614 }
1615 mapStringForFields += "}"
1616 s := strings.Join([]string{`&Struct{`,
1617 `Fields:` + mapStringForFields + `,`,
1618 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1619 `}`,
1620 }, "")
1621 return s
1622 }
1623 func (this *Value) String() string {
1624 if this == nil {
1625 return "nil"
1626 }
1627 s := strings.Join([]string{`&Value{`,
1628 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
1629 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1630 `}`,
1631 }, "")
1632 return s
1633 }
1634 func (this *Value_NullValue) String() string {
1635 if this == nil {
1636 return "nil"
1637 }
1638 s := strings.Join([]string{`&Value_NullValue{`,
1639 `NullValue:` + fmt.Sprintf("%v", this.NullValue) + `,`,
1640 `}`,
1641 }, "")
1642 return s
1643 }
1644 func (this *Value_NumberValue) String() string {
1645 if this == nil {
1646 return "nil"
1647 }
1648 s := strings.Join([]string{`&Value_NumberValue{`,
1649 `NumberValue:` + fmt.Sprintf("%v", this.NumberValue) + `,`,
1650 `}`,
1651 }, "")
1652 return s
1653 }
1654 func (this *Value_StringValue) String() string {
1655 if this == nil {
1656 return "nil"
1657 }
1658 s := strings.Join([]string{`&Value_StringValue{`,
1659 `StringValue:` + fmt.Sprintf("%v", this.StringValue) + `,`,
1660 `}`,
1661 }, "")
1662 return s
1663 }
1664 func (this *Value_BoolValue) String() string {
1665 if this == nil {
1666 return "nil"
1667 }
1668 s := strings.Join([]string{`&Value_BoolValue{`,
1669 `BoolValue:` + fmt.Sprintf("%v", this.BoolValue) + `,`,
1670 `}`,
1671 }, "")
1672 return s
1673 }
1674 func (this *Value_StructValue) String() string {
1675 if this == nil {
1676 return "nil"
1677 }
1678 s := strings.Join([]string{`&Value_StructValue{`,
1679 `StructValue:` + strings.Replace(fmt.Sprintf("%v", this.StructValue), "Struct", "Struct", 1) + `,`,
1680 `}`,
1681 }, "")
1682 return s
1683 }
1684 func (this *Value_ListValue) String() string {
1685 if this == nil {
1686 return "nil"
1687 }
1688 s := strings.Join([]string{`&Value_ListValue{`,
1689 `ListValue:` + strings.Replace(fmt.Sprintf("%v", this.ListValue), "ListValue", "ListValue", 1) + `,`,
1690 `}`,
1691 }, "")
1692 return s
1693 }
1694 func (this *ListValue) String() string {
1695 if this == nil {
1696 return "nil"
1697 }
1698 repeatedStringForValues := "[]*Value{"
1699 for _, f := range this.Values {
1700 repeatedStringForValues += strings.Replace(f.String(), "Value", "Value", 1) + ","
1701 }
1702 repeatedStringForValues += "}"
1703 s := strings.Join([]string{`&ListValue{`,
1704 `Values:` + repeatedStringForValues + `,`,
1705 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1706 `}`,
1707 }, "")
1708 return s
1709 }
1710 func valueToStringStruct(v interface{}) string {
1711 rv := reflect.ValueOf(v)
1712 if rv.IsNil() {
1713 return "nil"
1714 }
1715 pv := reflect.Indirect(rv).Interface()
1716 return fmt.Sprintf("*%v", pv)
1717 }
1718 func (m *Struct) Unmarshal(dAtA []byte) error {
1719 l := len(dAtA)
1720 iNdEx := 0
1721 for iNdEx < l {
1722 preIndex := iNdEx
1723 var wire uint64
1724 for shift := uint(0); ; shift += 7 {
1725 if shift >= 64 {
1726 return ErrIntOverflowStruct
1727 }
1728 if iNdEx >= l {
1729 return io.ErrUnexpectedEOF
1730 }
1731 b := dAtA[iNdEx]
1732 iNdEx++
1733 wire |= uint64(b&0x7F) << shift
1734 if b < 0x80 {
1735 break
1736 }
1737 }
1738 fieldNum := int32(wire >> 3)
1739 wireType := int(wire & 0x7)
1740 if wireType == 4 {
1741 return fmt.Errorf("proto: Struct: wiretype end group for non-group")
1742 }
1743 if fieldNum <= 0 {
1744 return fmt.Errorf("proto: Struct: illegal tag %d (wire type %d)", fieldNum, wire)
1745 }
1746 switch fieldNum {
1747 case 1:
1748 if wireType != 2 {
1749 return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
1750 }
1751 var msglen int
1752 for shift := uint(0); ; shift += 7 {
1753 if shift >= 64 {
1754 return ErrIntOverflowStruct
1755 }
1756 if iNdEx >= l {
1757 return io.ErrUnexpectedEOF
1758 }
1759 b := dAtA[iNdEx]
1760 iNdEx++
1761 msglen |= int(b&0x7F) << shift
1762 if b < 0x80 {
1763 break
1764 }
1765 }
1766 if msglen < 0 {
1767 return ErrInvalidLengthStruct
1768 }
1769 postIndex := iNdEx + msglen
1770 if postIndex < 0 {
1771 return ErrInvalidLengthStruct
1772 }
1773 if postIndex > l {
1774 return io.ErrUnexpectedEOF
1775 }
1776 if m.Fields == nil {
1777 m.Fields = make(map[string]*Value)
1778 }
1779 var mapkey string
1780 var mapvalue *Value
1781 for iNdEx < postIndex {
1782 entryPreIndex := iNdEx
1783 var wire uint64
1784 for shift := uint(0); ; shift += 7 {
1785 if shift >= 64 {
1786 return ErrIntOverflowStruct
1787 }
1788 if iNdEx >= l {
1789 return io.ErrUnexpectedEOF
1790 }
1791 b := dAtA[iNdEx]
1792 iNdEx++
1793 wire |= uint64(b&0x7F) << shift
1794 if b < 0x80 {
1795 break
1796 }
1797 }
1798 fieldNum := int32(wire >> 3)
1799 if fieldNum == 1 {
1800 var stringLenmapkey uint64
1801 for shift := uint(0); ; shift += 7 {
1802 if shift >= 64 {
1803 return ErrIntOverflowStruct
1804 }
1805 if iNdEx >= l {
1806 return io.ErrUnexpectedEOF
1807 }
1808 b := dAtA[iNdEx]
1809 iNdEx++
1810 stringLenmapkey |= uint64(b&0x7F) << shift
1811 if b < 0x80 {
1812 break
1813 }
1814 }
1815 intStringLenmapkey := int(stringLenmapkey)
1816 if intStringLenmapkey < 0 {
1817 return ErrInvalidLengthStruct
1818 }
1819 postStringIndexmapkey := iNdEx + intStringLenmapkey
1820 if postStringIndexmapkey < 0 {
1821 return ErrInvalidLengthStruct
1822 }
1823 if postStringIndexmapkey > l {
1824 return io.ErrUnexpectedEOF
1825 }
1826 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1827 iNdEx = postStringIndexmapkey
1828 } else if fieldNum == 2 {
1829 var mapmsglen int
1830 for shift := uint(0); ; shift += 7 {
1831 if shift >= 64 {
1832 return ErrIntOverflowStruct
1833 }
1834 if iNdEx >= l {
1835 return io.ErrUnexpectedEOF
1836 }
1837 b := dAtA[iNdEx]
1838 iNdEx++
1839 mapmsglen |= int(b&0x7F) << shift
1840 if b < 0x80 {
1841 break
1842 }
1843 }
1844 if mapmsglen < 0 {
1845 return ErrInvalidLengthStruct
1846 }
1847 postmsgIndex := iNdEx + mapmsglen
1848 if postmsgIndex < 0 {
1849 return ErrInvalidLengthStruct
1850 }
1851 if postmsgIndex > l {
1852 return io.ErrUnexpectedEOF
1853 }
1854 mapvalue = &Value{}
1855 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
1856 return err
1857 }
1858 iNdEx = postmsgIndex
1859 } else {
1860 iNdEx = entryPreIndex
1861 skippy, err := skipStruct(dAtA[iNdEx:])
1862 if err != nil {
1863 return err
1864 }
1865 if (skippy < 0) || (iNdEx+skippy) < 0 {
1866 return ErrInvalidLengthStruct
1867 }
1868 if (iNdEx + skippy) > postIndex {
1869 return io.ErrUnexpectedEOF
1870 }
1871 iNdEx += skippy
1872 }
1873 }
1874 m.Fields[mapkey] = mapvalue
1875 iNdEx = postIndex
1876 default:
1877 iNdEx = preIndex
1878 skippy, err := skipStruct(dAtA[iNdEx:])
1879 if err != nil {
1880 return err
1881 }
1882 if (skippy < 0) || (iNdEx+skippy) < 0 {
1883 return ErrInvalidLengthStruct
1884 }
1885 if (iNdEx + skippy) > l {
1886 return io.ErrUnexpectedEOF
1887 }
1888 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1889 iNdEx += skippy
1890 }
1891 }
1892
1893 if iNdEx > l {
1894 return io.ErrUnexpectedEOF
1895 }
1896 return nil
1897 }
1898 func (m *Value) Unmarshal(dAtA []byte) error {
1899 l := len(dAtA)
1900 iNdEx := 0
1901 for iNdEx < l {
1902 preIndex := iNdEx
1903 var wire uint64
1904 for shift := uint(0); ; shift += 7 {
1905 if shift >= 64 {
1906 return ErrIntOverflowStruct
1907 }
1908 if iNdEx >= l {
1909 return io.ErrUnexpectedEOF
1910 }
1911 b := dAtA[iNdEx]
1912 iNdEx++
1913 wire |= uint64(b&0x7F) << shift
1914 if b < 0x80 {
1915 break
1916 }
1917 }
1918 fieldNum := int32(wire >> 3)
1919 wireType := int(wire & 0x7)
1920 if wireType == 4 {
1921 return fmt.Errorf("proto: Value: wiretype end group for non-group")
1922 }
1923 if fieldNum <= 0 {
1924 return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire)
1925 }
1926 switch fieldNum {
1927 case 1:
1928 if wireType != 0 {
1929 return fmt.Errorf("proto: wrong wireType = %d for field NullValue", wireType)
1930 }
1931 var v NullValue
1932 for shift := uint(0); ; shift += 7 {
1933 if shift >= 64 {
1934 return ErrIntOverflowStruct
1935 }
1936 if iNdEx >= l {
1937 return io.ErrUnexpectedEOF
1938 }
1939 b := dAtA[iNdEx]
1940 iNdEx++
1941 v |= NullValue(b&0x7F) << shift
1942 if b < 0x80 {
1943 break
1944 }
1945 }
1946 m.Kind = &Value_NullValue{v}
1947 case 2:
1948 if wireType != 1 {
1949 return fmt.Errorf("proto: wrong wireType = %d for field NumberValue", wireType)
1950 }
1951 var v uint64
1952 if (iNdEx + 8) > l {
1953 return io.ErrUnexpectedEOF
1954 }
1955 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
1956 iNdEx += 8
1957 m.Kind = &Value_NumberValue{float64(math.Float64frombits(v))}
1958 case 3:
1959 if wireType != 2 {
1960 return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
1961 }
1962 var stringLen uint64
1963 for shift := uint(0); ; shift += 7 {
1964 if shift >= 64 {
1965 return ErrIntOverflowStruct
1966 }
1967 if iNdEx >= l {
1968 return io.ErrUnexpectedEOF
1969 }
1970 b := dAtA[iNdEx]
1971 iNdEx++
1972 stringLen |= uint64(b&0x7F) << shift
1973 if b < 0x80 {
1974 break
1975 }
1976 }
1977 intStringLen := int(stringLen)
1978 if intStringLen < 0 {
1979 return ErrInvalidLengthStruct
1980 }
1981 postIndex := iNdEx + intStringLen
1982 if postIndex < 0 {
1983 return ErrInvalidLengthStruct
1984 }
1985 if postIndex > l {
1986 return io.ErrUnexpectedEOF
1987 }
1988 m.Kind = &Value_StringValue{string(dAtA[iNdEx:postIndex])}
1989 iNdEx = postIndex
1990 case 4:
1991 if wireType != 0 {
1992 return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
1993 }
1994 var v int
1995 for shift := uint(0); ; shift += 7 {
1996 if shift >= 64 {
1997 return ErrIntOverflowStruct
1998 }
1999 if iNdEx >= l {
2000 return io.ErrUnexpectedEOF
2001 }
2002 b := dAtA[iNdEx]
2003 iNdEx++
2004 v |= int(b&0x7F) << shift
2005 if b < 0x80 {
2006 break
2007 }
2008 }
2009 b := bool(v != 0)
2010 m.Kind = &Value_BoolValue{b}
2011 case 5:
2012 if wireType != 2 {
2013 return fmt.Errorf("proto: wrong wireType = %d for field StructValue", wireType)
2014 }
2015 var msglen int
2016 for shift := uint(0); ; shift += 7 {
2017 if shift >= 64 {
2018 return ErrIntOverflowStruct
2019 }
2020 if iNdEx >= l {
2021 return io.ErrUnexpectedEOF
2022 }
2023 b := dAtA[iNdEx]
2024 iNdEx++
2025 msglen |= int(b&0x7F) << shift
2026 if b < 0x80 {
2027 break
2028 }
2029 }
2030 if msglen < 0 {
2031 return ErrInvalidLengthStruct
2032 }
2033 postIndex := iNdEx + msglen
2034 if postIndex < 0 {
2035 return ErrInvalidLengthStruct
2036 }
2037 if postIndex > l {
2038 return io.ErrUnexpectedEOF
2039 }
2040 v := &Struct{}
2041 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2042 return err
2043 }
2044 m.Kind = &Value_StructValue{v}
2045 iNdEx = postIndex
2046 case 6:
2047 if wireType != 2 {
2048 return fmt.Errorf("proto: wrong wireType = %d for field ListValue", wireType)
2049 }
2050 var msglen int
2051 for shift := uint(0); ; shift += 7 {
2052 if shift >= 64 {
2053 return ErrIntOverflowStruct
2054 }
2055 if iNdEx >= l {
2056 return io.ErrUnexpectedEOF
2057 }
2058 b := dAtA[iNdEx]
2059 iNdEx++
2060 msglen |= int(b&0x7F) << shift
2061 if b < 0x80 {
2062 break
2063 }
2064 }
2065 if msglen < 0 {
2066 return ErrInvalidLengthStruct
2067 }
2068 postIndex := iNdEx + msglen
2069 if postIndex < 0 {
2070 return ErrInvalidLengthStruct
2071 }
2072 if postIndex > l {
2073 return io.ErrUnexpectedEOF
2074 }
2075 v := &ListValue{}
2076 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2077 return err
2078 }
2079 m.Kind = &Value_ListValue{v}
2080 iNdEx = postIndex
2081 default:
2082 iNdEx = preIndex
2083 skippy, err := skipStruct(dAtA[iNdEx:])
2084 if err != nil {
2085 return err
2086 }
2087 if (skippy < 0) || (iNdEx+skippy) < 0 {
2088 return ErrInvalidLengthStruct
2089 }
2090 if (iNdEx + skippy) > l {
2091 return io.ErrUnexpectedEOF
2092 }
2093 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2094 iNdEx += skippy
2095 }
2096 }
2097
2098 if iNdEx > l {
2099 return io.ErrUnexpectedEOF
2100 }
2101 return nil
2102 }
2103 func (m *ListValue) Unmarshal(dAtA []byte) error {
2104 l := len(dAtA)
2105 iNdEx := 0
2106 for iNdEx < l {
2107 preIndex := iNdEx
2108 var wire uint64
2109 for shift := uint(0); ; shift += 7 {
2110 if shift >= 64 {
2111 return ErrIntOverflowStruct
2112 }
2113 if iNdEx >= l {
2114 return io.ErrUnexpectedEOF
2115 }
2116 b := dAtA[iNdEx]
2117 iNdEx++
2118 wire |= uint64(b&0x7F) << shift
2119 if b < 0x80 {
2120 break
2121 }
2122 }
2123 fieldNum := int32(wire >> 3)
2124 wireType := int(wire & 0x7)
2125 if wireType == 4 {
2126 return fmt.Errorf("proto: ListValue: wiretype end group for non-group")
2127 }
2128 if fieldNum <= 0 {
2129 return fmt.Errorf("proto: ListValue: illegal tag %d (wire type %d)", fieldNum, wire)
2130 }
2131 switch fieldNum {
2132 case 1:
2133 if wireType != 2 {
2134 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
2135 }
2136 var msglen int
2137 for shift := uint(0); ; shift += 7 {
2138 if shift >= 64 {
2139 return ErrIntOverflowStruct
2140 }
2141 if iNdEx >= l {
2142 return io.ErrUnexpectedEOF
2143 }
2144 b := dAtA[iNdEx]
2145 iNdEx++
2146 msglen |= int(b&0x7F) << shift
2147 if b < 0x80 {
2148 break
2149 }
2150 }
2151 if msglen < 0 {
2152 return ErrInvalidLengthStruct
2153 }
2154 postIndex := iNdEx + msglen
2155 if postIndex < 0 {
2156 return ErrInvalidLengthStruct
2157 }
2158 if postIndex > l {
2159 return io.ErrUnexpectedEOF
2160 }
2161 m.Values = append(m.Values, &Value{})
2162 if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2163 return err
2164 }
2165 iNdEx = postIndex
2166 default:
2167 iNdEx = preIndex
2168 skippy, err := skipStruct(dAtA[iNdEx:])
2169 if err != nil {
2170 return err
2171 }
2172 if (skippy < 0) || (iNdEx+skippy) < 0 {
2173 return ErrInvalidLengthStruct
2174 }
2175 if (iNdEx + skippy) > l {
2176 return io.ErrUnexpectedEOF
2177 }
2178 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2179 iNdEx += skippy
2180 }
2181 }
2182
2183 if iNdEx > l {
2184 return io.ErrUnexpectedEOF
2185 }
2186 return nil
2187 }
2188 func skipStruct(dAtA []byte) (n int, err error) {
2189 l := len(dAtA)
2190 iNdEx := 0
2191 depth := 0
2192 for iNdEx < l {
2193 var wire uint64
2194 for shift := uint(0); ; shift += 7 {
2195 if shift >= 64 {
2196 return 0, ErrIntOverflowStruct
2197 }
2198 if iNdEx >= l {
2199 return 0, io.ErrUnexpectedEOF
2200 }
2201 b := dAtA[iNdEx]
2202 iNdEx++
2203 wire |= (uint64(b) & 0x7F) << shift
2204 if b < 0x80 {
2205 break
2206 }
2207 }
2208 wireType := int(wire & 0x7)
2209 switch wireType {
2210 case 0:
2211 for shift := uint(0); ; shift += 7 {
2212 if shift >= 64 {
2213 return 0, ErrIntOverflowStruct
2214 }
2215 if iNdEx >= l {
2216 return 0, io.ErrUnexpectedEOF
2217 }
2218 iNdEx++
2219 if dAtA[iNdEx-1] < 0x80 {
2220 break
2221 }
2222 }
2223 case 1:
2224 iNdEx += 8
2225 case 2:
2226 var length int
2227 for shift := uint(0); ; shift += 7 {
2228 if shift >= 64 {
2229 return 0, ErrIntOverflowStruct
2230 }
2231 if iNdEx >= l {
2232 return 0, io.ErrUnexpectedEOF
2233 }
2234 b := dAtA[iNdEx]
2235 iNdEx++
2236 length |= (int(b) & 0x7F) << shift
2237 if b < 0x80 {
2238 break
2239 }
2240 }
2241 if length < 0 {
2242 return 0, ErrInvalidLengthStruct
2243 }
2244 iNdEx += length
2245 case 3:
2246 depth++
2247 case 4:
2248 if depth == 0 {
2249 return 0, ErrUnexpectedEndOfGroupStruct
2250 }
2251 depth--
2252 case 5:
2253 iNdEx += 4
2254 default:
2255 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2256 }
2257 if iNdEx < 0 {
2258 return 0, ErrInvalidLengthStruct
2259 }
2260 if depth == 0 {
2261 return iNdEx, nil
2262 }
2263 }
2264 return 0, io.ErrUnexpectedEOF
2265 }
2266
2267 var (
2268 ErrInvalidLengthStruct = fmt.Errorf("proto: negative length found during unmarshaling")
2269 ErrIntOverflowStruct = fmt.Errorf("proto: integer overflow")
2270 ErrUnexpectedEndOfGroupStruct = fmt.Errorf("proto: unexpected end of group")
2271 )
2272
View as plain text