1
2
3
4 package stdtypes
5
6 import (
7 bytes "bytes"
8 fmt "fmt"
9 _ "github.com/gogo/protobuf/gogoproto"
10 proto "github.com/gogo/protobuf/proto"
11 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
12 _ "github.com/gogo/protobuf/types"
13 github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
14 math "math"
15 math_bits "math/bits"
16 reflect "reflect"
17 strings "strings"
18 time "time"
19 )
20
21
22 var _ = proto.Marshal
23 var _ = fmt.Errorf
24 var _ = math.Inf
25 var _ = time.Kitchen
26
27
28
29
30
31 const _ = proto.GoGoProtoPackageIsVersion3
32
33 type StdTypes struct {
34 NullableTimestamp *time.Time `protobuf:"bytes,1,opt,name=nullableTimestamp,proto3,stdtime" json:"nullableTimestamp,omitempty"`
35 NullableDuration *time.Duration `protobuf:"bytes,2,opt,name=nullableDuration,proto3,stdduration" json:"nullableDuration,omitempty"`
36 Timestamp time.Time `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
37 Duration time.Duration `protobuf:"bytes,4,opt,name=duration,proto3,stdduration" json:"duration"`
38 NullableDouble *float64 `protobuf:"bytes,5,opt,name=nullableDouble,proto3,wktptr" json:"nullableDouble,omitempty"`
39 NonnullDouble float64 `protobuf:"bytes,6,opt,name=nonnullDouble,proto3,wktptr" json:"nonnullDouble"`
40 NullableFloat *float32 `protobuf:"bytes,7,opt,name=nullableFloat,proto3,wktptr" json:"nullableFloat,omitempty"`
41 NonnullFloat float32 `protobuf:"bytes,8,opt,name=nonnullFloat,proto3,wktptr" json:"nonnullFloat"`
42 NullableInt64 *int64 `protobuf:"bytes,9,opt,name=nullableInt64,proto3,wktptr" json:"nullableInt64,omitempty"`
43 NonnullInt64 int64 `protobuf:"bytes,10,opt,name=nonnullInt64,proto3,wktptr" json:"nonnullInt64"`
44 NullableUInt64 *uint64 `protobuf:"bytes,11,opt,name=nullableUInt64,proto3,wktptr" json:"nullableUInt64,omitempty"`
45 NonnullUInt64 uint64 `protobuf:"bytes,12,opt,name=nonnullUInt64,proto3,wktptr" json:"nonnullUInt64"`
46 NullableInt32 *int32 `protobuf:"bytes,13,opt,name=nullableInt32,proto3,wktptr" json:"nullableInt32,omitempty"`
47 NonnullInt32 int32 `protobuf:"bytes,14,opt,name=nonnullInt32,proto3,wktptr" json:"nonnullInt32"`
48 NullableUInt32 *uint32 `protobuf:"bytes,15,opt,name=nullableUInt32,proto3,wktptr" json:"nullableUInt32,omitempty"`
49 NonnullUInt32 uint32 `protobuf:"bytes,16,opt,name=nonnullUInt32,proto3,wktptr" json:"nonnullUInt32"`
50 NullableBool *bool `protobuf:"bytes,17,opt,name=nullableBool,proto3,wktptr" json:"nullableBool,omitempty"`
51 NonnullBool bool `protobuf:"bytes,18,opt,name=nonnullBool,proto3,wktptr" json:"nonnullBool"`
52 NullableString *string `protobuf:"bytes,19,opt,name=nullableString,proto3,wktptr" json:"nullableString,omitempty"`
53 NonnullString string `protobuf:"bytes,20,opt,name=nonnullString,proto3,wktptr" json:"nonnullString"`
54 NullableBytes *[]byte `protobuf:"bytes,21,opt,name=nullableBytes,proto3,wktptr" json:"nullableBytes,omitempty"`
55 NonnullBytes []byte `protobuf:"bytes,22,opt,name=nonnullBytes,proto3,wktptr" json:"nonnullBytes"`
56 XXX_NoUnkeyedLiteral struct{} `json:"-"`
57 XXX_unrecognized []byte `json:"-"`
58 XXX_sizecache int32 `json:"-"`
59 }
60
61 func (m *StdTypes) Reset() { *m = StdTypes{} }
62 func (m *StdTypes) String() string { return proto.CompactTextString(m) }
63 func (*StdTypes) ProtoMessage() {}
64 func (*StdTypes) Descriptor() ([]byte, []int) {
65 return fileDescriptor_fa784ced32c4280a, []int{0}
66 }
67 func (m *StdTypes) XXX_Unmarshal(b []byte) error {
68 return xxx_messageInfo_StdTypes.Unmarshal(m, b)
69 }
70 func (m *StdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
71 return xxx_messageInfo_StdTypes.Marshal(b, m, deterministic)
72 }
73 func (m *StdTypes) XXX_Merge(src proto.Message) {
74 xxx_messageInfo_StdTypes.Merge(m, src)
75 }
76 func (m *StdTypes) XXX_Size() int {
77 return xxx_messageInfo_StdTypes.Size(m)
78 }
79 func (m *StdTypes) XXX_DiscardUnknown() {
80 xxx_messageInfo_StdTypes.DiscardUnknown(m)
81 }
82
83 var xxx_messageInfo_StdTypes proto.InternalMessageInfo
84
85 func (m *StdTypes) GetNullableTimestamp() *time.Time {
86 if m != nil {
87 return m.NullableTimestamp
88 }
89 return nil
90 }
91
92 func (m *StdTypes) GetNullableDuration() *time.Duration {
93 if m != nil {
94 return m.NullableDuration
95 }
96 return nil
97 }
98
99 func (m *StdTypes) GetTimestamp() time.Time {
100 if m != nil {
101 return m.Timestamp
102 }
103 return time.Time{}
104 }
105
106 func (m *StdTypes) GetDuration() time.Duration {
107 if m != nil {
108 return m.Duration
109 }
110 return 0
111 }
112
113 func (m *StdTypes) GetNullableDouble() *float64 {
114 if m != nil {
115 return m.NullableDouble
116 }
117 return nil
118 }
119
120 func (m *StdTypes) GetNonnullDouble() float64 {
121 if m != nil {
122 return m.NonnullDouble
123 }
124 return 0
125 }
126
127 func (m *StdTypes) GetNullableFloat() *float32 {
128 if m != nil {
129 return m.NullableFloat
130 }
131 return nil
132 }
133
134 func (m *StdTypes) GetNonnullFloat() float32 {
135 if m != nil {
136 return m.NonnullFloat
137 }
138 return 0
139 }
140
141 func (m *StdTypes) GetNullableInt64() *int64 {
142 if m != nil {
143 return m.NullableInt64
144 }
145 return nil
146 }
147
148 func (m *StdTypes) GetNonnullInt64() int64 {
149 if m != nil {
150 return m.NonnullInt64
151 }
152 return 0
153 }
154
155 func (m *StdTypes) GetNullableUInt64() *uint64 {
156 if m != nil {
157 return m.NullableUInt64
158 }
159 return nil
160 }
161
162 func (m *StdTypes) GetNonnullUInt64() uint64 {
163 if m != nil {
164 return m.NonnullUInt64
165 }
166 return 0
167 }
168
169 func (m *StdTypes) GetNullableInt32() *int32 {
170 if m != nil {
171 return m.NullableInt32
172 }
173 return nil
174 }
175
176 func (m *StdTypes) GetNonnullInt32() int32 {
177 if m != nil {
178 return m.NonnullInt32
179 }
180 return 0
181 }
182
183 func (m *StdTypes) GetNullableUInt32() *uint32 {
184 if m != nil {
185 return m.NullableUInt32
186 }
187 return nil
188 }
189
190 func (m *StdTypes) GetNonnullUInt32() uint32 {
191 if m != nil {
192 return m.NonnullUInt32
193 }
194 return 0
195 }
196
197 func (m *StdTypes) GetNullableBool() *bool {
198 if m != nil {
199 return m.NullableBool
200 }
201 return nil
202 }
203
204 func (m *StdTypes) GetNonnullBool() bool {
205 if m != nil {
206 return m.NonnullBool
207 }
208 return false
209 }
210
211 func (m *StdTypes) GetNullableString() *string {
212 if m != nil {
213 return m.NullableString
214 }
215 return nil
216 }
217
218 func (m *StdTypes) GetNonnullString() string {
219 if m != nil {
220 return m.NonnullString
221 }
222 return ""
223 }
224
225 func (m *StdTypes) GetNullableBytes() *[]byte {
226 if m != nil {
227 return m.NullableBytes
228 }
229 return nil
230 }
231
232 func (m *StdTypes) GetNonnullBytes() []byte {
233 if m != nil {
234 return m.NonnullBytes
235 }
236 return []byte{}
237 }
238
239 type RepStdTypes struct {
240 NullableTimestamps []*time.Time `protobuf:"bytes,1,rep,name=nullableTimestamps,proto3,stdtime" json:"nullableTimestamps,omitempty"`
241 NullableDurations []*time.Duration `protobuf:"bytes,2,rep,name=nullableDurations,proto3,stdduration" json:"nullableDurations,omitempty"`
242 Timestamps []time.Time `protobuf:"bytes,3,rep,name=timestamps,proto3,stdtime" json:"timestamps"`
243 Durations []time.Duration `protobuf:"bytes,4,rep,name=durations,proto3,stdduration" json:"durations"`
244 NullableDouble []*float64 `protobuf:"bytes,5,rep,name=nullableDouble,proto3,wktptr" json:"nullableDouble,omitempty"`
245 NonnullDouble []float64 `protobuf:"bytes,6,rep,name=nonnullDouble,proto3,wktptr" json:"nonnullDouble"`
246 NullableFloat []*float32 `protobuf:"bytes,7,rep,name=nullableFloat,proto3,wktptr" json:"nullableFloat,omitempty"`
247 NonnullFloat []float32 `protobuf:"bytes,8,rep,name=nonnullFloat,proto3,wktptr" json:"nonnullFloat"`
248 NullableInt64 []*int64 `protobuf:"bytes,9,rep,name=nullableInt64,proto3,wktptr" json:"nullableInt64,omitempty"`
249 NonnullInt64 []int64 `protobuf:"bytes,10,rep,name=nonnullInt64,proto3,wktptr" json:"nonnullInt64"`
250 NullableUInt64 []*uint64 `protobuf:"bytes,11,rep,name=nullableUInt64,proto3,wktptr" json:"nullableUInt64,omitempty"`
251 NonnullUInt64 []uint64 `protobuf:"bytes,12,rep,name=nonnullUInt64,proto3,wktptr" json:"nonnullUInt64"`
252 NullableInt32 []*int32 `protobuf:"bytes,13,rep,name=nullableInt32,proto3,wktptr" json:"nullableInt32,omitempty"`
253 NonnullInt32 []int32 `protobuf:"bytes,14,rep,name=nonnullInt32,proto3,wktptr" json:"nonnullInt32"`
254 NullableUInt32 []*uint32 `protobuf:"bytes,15,rep,name=nullableUInt32,proto3,wktptr" json:"nullableUInt32,omitempty"`
255 NonnullUInt32 []uint32 `protobuf:"bytes,16,rep,name=nonnullUInt32,proto3,wktptr" json:"nonnullUInt32"`
256 NullableBool []*bool `protobuf:"bytes,17,rep,name=nullableBool,proto3,wktptr" json:"nullableBool,omitempty"`
257 NonnullBool []bool `protobuf:"bytes,18,rep,name=nonnullBool,proto3,wktptr" json:"nonnullBool"`
258 NullableString []*string `protobuf:"bytes,19,rep,name=nullableString,proto3,wktptr" json:"nullableString,omitempty"`
259 NonnullString []string `protobuf:"bytes,20,rep,name=nonnullString,proto3,wktptr" json:"nonnullString"`
260 NullableBytes []*[]byte `protobuf:"bytes,21,rep,name=nullableBytes,proto3,wktptr" json:"nullableBytes,omitempty"`
261 NonnullBytes [][]byte `protobuf:"bytes,22,rep,name=nonnullBytes,proto3,wktptr" json:"nonnullBytes"`
262 XXX_NoUnkeyedLiteral struct{} `json:"-"`
263 XXX_unrecognized []byte `json:"-"`
264 XXX_sizecache int32 `json:"-"`
265 }
266
267 func (m *RepStdTypes) Reset() { *m = RepStdTypes{} }
268 func (m *RepStdTypes) String() string { return proto.CompactTextString(m) }
269 func (*RepStdTypes) ProtoMessage() {}
270 func (*RepStdTypes) Descriptor() ([]byte, []int) {
271 return fileDescriptor_fa784ced32c4280a, []int{1}
272 }
273 func (m *RepStdTypes) XXX_Unmarshal(b []byte) error {
274 return xxx_messageInfo_RepStdTypes.Unmarshal(m, b)
275 }
276 func (m *RepStdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
277 return xxx_messageInfo_RepStdTypes.Marshal(b, m, deterministic)
278 }
279 func (m *RepStdTypes) XXX_Merge(src proto.Message) {
280 xxx_messageInfo_RepStdTypes.Merge(m, src)
281 }
282 func (m *RepStdTypes) XXX_Size() int {
283 return xxx_messageInfo_RepStdTypes.Size(m)
284 }
285 func (m *RepStdTypes) XXX_DiscardUnknown() {
286 xxx_messageInfo_RepStdTypes.DiscardUnknown(m)
287 }
288
289 var xxx_messageInfo_RepStdTypes proto.InternalMessageInfo
290
291 func (m *RepStdTypes) GetNullableTimestamps() []*time.Time {
292 if m != nil {
293 return m.NullableTimestamps
294 }
295 return nil
296 }
297
298 func (m *RepStdTypes) GetNullableDurations() []*time.Duration {
299 if m != nil {
300 return m.NullableDurations
301 }
302 return nil
303 }
304
305 func (m *RepStdTypes) GetTimestamps() []time.Time {
306 if m != nil {
307 return m.Timestamps
308 }
309 return nil
310 }
311
312 func (m *RepStdTypes) GetDurations() []time.Duration {
313 if m != nil {
314 return m.Durations
315 }
316 return nil
317 }
318
319 func (m *RepStdTypes) GetNullableDouble() []*float64 {
320 if m != nil {
321 return m.NullableDouble
322 }
323 return nil
324 }
325
326 func (m *RepStdTypes) GetNonnullDouble() []float64 {
327 if m != nil {
328 return m.NonnullDouble
329 }
330 return nil
331 }
332
333 func (m *RepStdTypes) GetNullableFloat() []*float32 {
334 if m != nil {
335 return m.NullableFloat
336 }
337 return nil
338 }
339
340 func (m *RepStdTypes) GetNonnullFloat() []float32 {
341 if m != nil {
342 return m.NonnullFloat
343 }
344 return nil
345 }
346
347 func (m *RepStdTypes) GetNullableInt64() []*int64 {
348 if m != nil {
349 return m.NullableInt64
350 }
351 return nil
352 }
353
354 func (m *RepStdTypes) GetNonnullInt64() []int64 {
355 if m != nil {
356 return m.NonnullInt64
357 }
358 return nil
359 }
360
361 func (m *RepStdTypes) GetNullableUInt64() []*uint64 {
362 if m != nil {
363 return m.NullableUInt64
364 }
365 return nil
366 }
367
368 func (m *RepStdTypes) GetNonnullUInt64() []uint64 {
369 if m != nil {
370 return m.NonnullUInt64
371 }
372 return nil
373 }
374
375 func (m *RepStdTypes) GetNullableInt32() []*int32 {
376 if m != nil {
377 return m.NullableInt32
378 }
379 return nil
380 }
381
382 func (m *RepStdTypes) GetNonnullInt32() []int32 {
383 if m != nil {
384 return m.NonnullInt32
385 }
386 return nil
387 }
388
389 func (m *RepStdTypes) GetNullableUInt32() []*uint32 {
390 if m != nil {
391 return m.NullableUInt32
392 }
393 return nil
394 }
395
396 func (m *RepStdTypes) GetNonnullUInt32() []uint32 {
397 if m != nil {
398 return m.NonnullUInt32
399 }
400 return nil
401 }
402
403 func (m *RepStdTypes) GetNullableBool() []*bool {
404 if m != nil {
405 return m.NullableBool
406 }
407 return nil
408 }
409
410 func (m *RepStdTypes) GetNonnullBool() []bool {
411 if m != nil {
412 return m.NonnullBool
413 }
414 return nil
415 }
416
417 func (m *RepStdTypes) GetNullableString() []*string {
418 if m != nil {
419 return m.NullableString
420 }
421 return nil
422 }
423
424 func (m *RepStdTypes) GetNonnullString() []string {
425 if m != nil {
426 return m.NonnullString
427 }
428 return nil
429 }
430
431 func (m *RepStdTypes) GetNullableBytes() []*[]byte {
432 if m != nil {
433 return m.NullableBytes
434 }
435 return nil
436 }
437
438 func (m *RepStdTypes) GetNonnullBytes() [][]byte {
439 if m != nil {
440 return m.NonnullBytes
441 }
442 return nil
443 }
444
445 type MapStdTypes struct {
446 NullableTimestamp map[int32]*time.Time `protobuf:"bytes,1,rep,name=nullableTimestamp,proto3,stdtime" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
447 Timestamp map[int32]time.Time `protobuf:"bytes,2,rep,name=timestamp,proto3,stdtime" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
448 NullableDuration map[int32]*time.Duration `protobuf:"bytes,3,rep,name=nullableDuration,proto3,stdduration" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
449 Duration map[int32]time.Duration `protobuf:"bytes,4,rep,name=duration,proto3,stdduration" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
450 NullableDouble map[int32]*float64 `protobuf:"bytes,5,rep,name=nullableDouble,proto3,wktptr" json:"nullableDouble,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
451 NonnullDouble map[int32]float64 `protobuf:"bytes,6,rep,name=nonnullDouble,proto3,wktptr" json:"nonnullDouble" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
452 NullableFloat map[int32]*float32 `protobuf:"bytes,7,rep,name=nullableFloat,proto3,wktptr" json:"nullableFloat,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
453 NonnullFloat map[int32]float32 `protobuf:"bytes,8,rep,name=nonnullFloat,proto3,wktptr" json:"nonnullFloat" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
454 NullableInt64 map[int32]*int64 `protobuf:"bytes,9,rep,name=nullableInt64,proto3,wktptr" json:"nullableInt64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
455 NonnullInt64 map[int32]int64 `protobuf:"bytes,10,rep,name=nonnullInt64,proto3,wktptr" json:"nonnullInt64" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
456 NullableUInt64 map[int32]*uint64 `protobuf:"bytes,11,rep,name=nullableUInt64,proto3,wktptr" json:"nullableUInt64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
457 NonnullUInt64 map[int32]uint64 `protobuf:"bytes,12,rep,name=nonnullUInt64,proto3,wktptr" json:"nonnullUInt64" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
458 NullableInt32 map[int32]*int32 `protobuf:"bytes,13,rep,name=nullableInt32,proto3,wktptr" json:"nullableInt32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
459 NonnullInt32 map[int32]int32 `protobuf:"bytes,14,rep,name=nonnullInt32,proto3,wktptr" json:"nonnullInt32" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
460 NullableUInt32 map[int32]*uint32 `protobuf:"bytes,15,rep,name=nullableUInt32,proto3,wktptr" json:"nullableUInt32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
461 NonnullUInt32 map[int32]uint32 `protobuf:"bytes,16,rep,name=nonnullUInt32,proto3,wktptr" json:"nonnullUInt32" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
462 NullableBool map[int32]*bool `protobuf:"bytes,17,rep,name=nullableBool,proto3,wktptr" json:"nullableBool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
463 NonnullBool map[int32]bool `protobuf:"bytes,18,rep,name=nonnullBool,proto3,wktptr" json:"nonnullBool" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
464 NullableString map[int32]*string `protobuf:"bytes,19,rep,name=nullableString,proto3,wktptr" json:"nullableString,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
465 NonnullString map[int32]string `protobuf:"bytes,20,rep,name=nonnullString,proto3,wktptr" json:"nonnullString" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
466 NullableBytes map[int32]*[]byte `protobuf:"bytes,21,rep,name=nullableBytes,proto3,wktptr" json:"nullableBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
467 NonnullBytes map[int32][]byte `protobuf:"bytes,22,rep,name=nonnullBytes,proto3,wktptr" json:"nonnullBytes" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
468 XXX_NoUnkeyedLiteral struct{} `json:"-"`
469 XXX_unrecognized []byte `json:"-"`
470 XXX_sizecache int32 `json:"-"`
471 }
472
473 func (m *MapStdTypes) Reset() { *m = MapStdTypes{} }
474 func (m *MapStdTypes) String() string { return proto.CompactTextString(m) }
475 func (*MapStdTypes) ProtoMessage() {}
476 func (*MapStdTypes) Descriptor() ([]byte, []int) {
477 return fileDescriptor_fa784ced32c4280a, []int{2}
478 }
479 func (m *MapStdTypes) XXX_Unmarshal(b []byte) error {
480 return xxx_messageInfo_MapStdTypes.Unmarshal(m, b)
481 }
482 func (m *MapStdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
483 return xxx_messageInfo_MapStdTypes.Marshal(b, m, deterministic)
484 }
485 func (m *MapStdTypes) XXX_Merge(src proto.Message) {
486 xxx_messageInfo_MapStdTypes.Merge(m, src)
487 }
488 func (m *MapStdTypes) XXX_Size() int {
489 return xxx_messageInfo_MapStdTypes.Size(m)
490 }
491 func (m *MapStdTypes) XXX_DiscardUnknown() {
492 xxx_messageInfo_MapStdTypes.DiscardUnknown(m)
493 }
494
495 var xxx_messageInfo_MapStdTypes proto.InternalMessageInfo
496
497 func (m *MapStdTypes) GetNullableTimestamp() map[int32]*time.Time {
498 if m != nil {
499 return m.NullableTimestamp
500 }
501 return nil
502 }
503
504 func (m *MapStdTypes) GetTimestamp() map[int32]time.Time {
505 if m != nil {
506 return m.Timestamp
507 }
508 return nil
509 }
510
511 func (m *MapStdTypes) GetNullableDuration() map[int32]*time.Duration {
512 if m != nil {
513 return m.NullableDuration
514 }
515 return nil
516 }
517
518 func (m *MapStdTypes) GetDuration() map[int32]time.Duration {
519 if m != nil {
520 return m.Duration
521 }
522 return nil
523 }
524
525 func (m *MapStdTypes) GetNullableDouble() map[int32]*float64 {
526 if m != nil {
527 return m.NullableDouble
528 }
529 return nil
530 }
531
532 func (m *MapStdTypes) GetNonnullDouble() map[int32]float64 {
533 if m != nil {
534 return m.NonnullDouble
535 }
536 return nil
537 }
538
539 func (m *MapStdTypes) GetNullableFloat() map[int32]*float32 {
540 if m != nil {
541 return m.NullableFloat
542 }
543 return nil
544 }
545
546 func (m *MapStdTypes) GetNonnullFloat() map[int32]float32 {
547 if m != nil {
548 return m.NonnullFloat
549 }
550 return nil
551 }
552
553 func (m *MapStdTypes) GetNullableInt64() map[int32]*int64 {
554 if m != nil {
555 return m.NullableInt64
556 }
557 return nil
558 }
559
560 func (m *MapStdTypes) GetNonnullInt64() map[int32]int64 {
561 if m != nil {
562 return m.NonnullInt64
563 }
564 return nil
565 }
566
567 func (m *MapStdTypes) GetNullableUInt64() map[int32]*uint64 {
568 if m != nil {
569 return m.NullableUInt64
570 }
571 return nil
572 }
573
574 func (m *MapStdTypes) GetNonnullUInt64() map[int32]uint64 {
575 if m != nil {
576 return m.NonnullUInt64
577 }
578 return nil
579 }
580
581 func (m *MapStdTypes) GetNullableInt32() map[int32]*int32 {
582 if m != nil {
583 return m.NullableInt32
584 }
585 return nil
586 }
587
588 func (m *MapStdTypes) GetNonnullInt32() map[int32]int32 {
589 if m != nil {
590 return m.NonnullInt32
591 }
592 return nil
593 }
594
595 func (m *MapStdTypes) GetNullableUInt32() map[int32]*uint32 {
596 if m != nil {
597 return m.NullableUInt32
598 }
599 return nil
600 }
601
602 func (m *MapStdTypes) GetNonnullUInt32() map[int32]uint32 {
603 if m != nil {
604 return m.NonnullUInt32
605 }
606 return nil
607 }
608
609 func (m *MapStdTypes) GetNullableBool() map[int32]*bool {
610 if m != nil {
611 return m.NullableBool
612 }
613 return nil
614 }
615
616 func (m *MapStdTypes) GetNonnullBool() map[int32]bool {
617 if m != nil {
618 return m.NonnullBool
619 }
620 return nil
621 }
622
623 func (m *MapStdTypes) GetNullableString() map[int32]*string {
624 if m != nil {
625 return m.NullableString
626 }
627 return nil
628 }
629
630 func (m *MapStdTypes) GetNonnullString() map[int32]string {
631 if m != nil {
632 return m.NonnullString
633 }
634 return nil
635 }
636
637 func (m *MapStdTypes) GetNullableBytes() map[int32]*[]byte {
638 if m != nil {
639 return m.NullableBytes
640 }
641 return nil
642 }
643
644 func (m *MapStdTypes) GetNonnullBytes() map[int32][]byte {
645 if m != nil {
646 return m.NonnullBytes
647 }
648 return nil
649 }
650
651 type OneofStdTypes struct {
652
653
654
655
656
657
658
659
660
661
662
663
664 OneOfStdTimes isOneofStdTypes_OneOfStdTimes `protobuf_oneof:"OneOfStdTimes"`
665 XXX_NoUnkeyedLiteral struct{} `json:"-"`
666 XXX_unrecognized []byte `json:"-"`
667 XXX_sizecache int32 `json:"-"`
668 }
669
670 func (m *OneofStdTypes) Reset() { *m = OneofStdTypes{} }
671 func (m *OneofStdTypes) String() string { return proto.CompactTextString(m) }
672 func (*OneofStdTypes) ProtoMessage() {}
673 func (*OneofStdTypes) Descriptor() ([]byte, []int) {
674 return fileDescriptor_fa784ced32c4280a, []int{3}
675 }
676 func (m *OneofStdTypes) XXX_Unmarshal(b []byte) error {
677 return xxx_messageInfo_OneofStdTypes.Unmarshal(m, b)
678 }
679 func (m *OneofStdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
680 return xxx_messageInfo_OneofStdTypes.Marshal(b, m, deterministic)
681 }
682 func (m *OneofStdTypes) XXX_Merge(src proto.Message) {
683 xxx_messageInfo_OneofStdTypes.Merge(m, src)
684 }
685 func (m *OneofStdTypes) XXX_Size() int {
686 return xxx_messageInfo_OneofStdTypes.Size(m)
687 }
688 func (m *OneofStdTypes) XXX_DiscardUnknown() {
689 xxx_messageInfo_OneofStdTypes.DiscardUnknown(m)
690 }
691
692 var xxx_messageInfo_OneofStdTypes proto.InternalMessageInfo
693
694 type isOneofStdTypes_OneOfStdTimes interface {
695 isOneofStdTypes_OneOfStdTimes()
696 Equal(interface{}) bool
697 VerboseEqual(interface{}) error
698 Size() int
699 }
700
701 type OneofStdTypes_Timestamp struct {
702 Timestamp *time.Time `protobuf:"bytes,1,opt,name=timestamp,proto3,oneof,stdtime" json:"timestamp,omitempty"`
703 }
704 type OneofStdTypes_Duration struct {
705 Duration *time.Duration `protobuf:"bytes,2,opt,name=duration,proto3,oneof,stdduration" json:"duration,omitempty"`
706 }
707 type OneofStdTypes_RepDouble struct {
708 RepDouble *float64 `protobuf:"bytes,3,opt,name=repDouble,proto3,oneof,wktptr" json:"repDouble,omitempty"`
709 }
710 type OneofStdTypes_RepFloat struct {
711 RepFloat *float32 `protobuf:"bytes,4,opt,name=repFloat,proto3,oneof,wktptr" json:"repFloat,omitempty"`
712 }
713 type OneofStdTypes_RepInt64 struct {
714 RepInt64 *int64 `protobuf:"bytes,5,opt,name=repInt64,proto3,oneof,wktptr" json:"repInt64,omitempty"`
715 }
716 type OneofStdTypes_RepUInt64 struct {
717 RepUInt64 *uint64 `protobuf:"bytes,6,opt,name=repUInt64,proto3,oneof,wktptr" json:"repUInt64,omitempty"`
718 }
719 type OneofStdTypes_RepInt32 struct {
720 RepInt32 *int32 `protobuf:"bytes,7,opt,name=repInt32,proto3,oneof,wktptr" json:"repInt32,omitempty"`
721 }
722 type OneofStdTypes_RepUInt32 struct {
723 RepUInt32 *uint32 `protobuf:"bytes,8,opt,name=repUInt32,proto3,oneof,wktptr" json:"repUInt32,omitempty"`
724 }
725 type OneofStdTypes_RepBool struct {
726 RepBool *bool `protobuf:"bytes,9,opt,name=repBool,proto3,oneof,wktptr" json:"repBool,omitempty"`
727 }
728 type OneofStdTypes_RepString struct {
729 RepString *string `protobuf:"bytes,10,opt,name=repString,proto3,oneof,wktptr" json:"repString,omitempty"`
730 }
731 type OneofStdTypes_RepBytes struct {
732 RepBytes *[]byte `protobuf:"bytes,11,opt,name=repBytes,proto3,oneof,wktptr" json:"repBytes,omitempty"`
733 }
734
735 func (*OneofStdTypes_Timestamp) isOneofStdTypes_OneOfStdTimes() {}
736 func (*OneofStdTypes_Duration) isOneofStdTypes_OneOfStdTimes() {}
737 func (*OneofStdTypes_RepDouble) isOneofStdTypes_OneOfStdTimes() {}
738 func (*OneofStdTypes_RepFloat) isOneofStdTypes_OneOfStdTimes() {}
739 func (*OneofStdTypes_RepInt64) isOneofStdTypes_OneOfStdTimes() {}
740 func (*OneofStdTypes_RepUInt64) isOneofStdTypes_OneOfStdTimes() {}
741 func (*OneofStdTypes_RepInt32) isOneofStdTypes_OneOfStdTimes() {}
742 func (*OneofStdTypes_RepUInt32) isOneofStdTypes_OneOfStdTimes() {}
743 func (*OneofStdTypes_RepBool) isOneofStdTypes_OneOfStdTimes() {}
744 func (*OneofStdTypes_RepString) isOneofStdTypes_OneOfStdTimes() {}
745 func (*OneofStdTypes_RepBytes) isOneofStdTypes_OneOfStdTimes() {}
746
747 func (m *OneofStdTypes) GetOneOfStdTimes() isOneofStdTypes_OneOfStdTimes {
748 if m != nil {
749 return m.OneOfStdTimes
750 }
751 return nil
752 }
753
754 func (m *OneofStdTypes) GetTimestamp() *time.Time {
755 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_Timestamp); ok {
756 return x.Timestamp
757 }
758 return nil
759 }
760
761 func (m *OneofStdTypes) GetDuration() *time.Duration {
762 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_Duration); ok {
763 return x.Duration
764 }
765 return nil
766 }
767
768 func (m *OneofStdTypes) GetRepDouble() *float64 {
769 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepDouble); ok {
770 return x.RepDouble
771 }
772 return nil
773 }
774
775 func (m *OneofStdTypes) GetRepFloat() *float32 {
776 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepFloat); ok {
777 return x.RepFloat
778 }
779 return nil
780 }
781
782 func (m *OneofStdTypes) GetRepInt64() *int64 {
783 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepInt64); ok {
784 return x.RepInt64
785 }
786 return nil
787 }
788
789 func (m *OneofStdTypes) GetRepUInt64() *uint64 {
790 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepUInt64); ok {
791 return x.RepUInt64
792 }
793 return nil
794 }
795
796 func (m *OneofStdTypes) GetRepInt32() *int32 {
797 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepInt32); ok {
798 return x.RepInt32
799 }
800 return nil
801 }
802
803 func (m *OneofStdTypes) GetRepUInt32() *uint32 {
804 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepUInt32); ok {
805 return x.RepUInt32
806 }
807 return nil
808 }
809
810 func (m *OneofStdTypes) GetRepBool() *bool {
811 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepBool); ok {
812 return x.RepBool
813 }
814 return nil
815 }
816
817 func (m *OneofStdTypes) GetRepString() *string {
818 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepString); ok {
819 return x.RepString
820 }
821 return nil
822 }
823
824 func (m *OneofStdTypes) GetRepBytes() *[]byte {
825 if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepBytes); ok {
826 return x.RepBytes
827 }
828 return nil
829 }
830
831
832 func (*OneofStdTypes) XXX_OneofWrappers() []interface{} {
833 return []interface{}{
834 (*OneofStdTypes_Timestamp)(nil),
835 (*OneofStdTypes_Duration)(nil),
836 (*OneofStdTypes_RepDouble)(nil),
837 (*OneofStdTypes_RepFloat)(nil),
838 (*OneofStdTypes_RepInt64)(nil),
839 (*OneofStdTypes_RepUInt64)(nil),
840 (*OneofStdTypes_RepInt32)(nil),
841 (*OneofStdTypes_RepUInt32)(nil),
842 (*OneofStdTypes_RepBool)(nil),
843 (*OneofStdTypes_RepString)(nil),
844 (*OneofStdTypes_RepBytes)(nil),
845 }
846 }
847
848 func init() {
849 proto.RegisterType((*StdTypes)(nil), "stdtypes.StdTypes")
850 proto.RegisterType((*RepStdTypes)(nil), "stdtypes.RepStdTypes")
851 proto.RegisterType((*MapStdTypes)(nil), "stdtypes.MapStdTypes")
852 proto.RegisterMapType((map[int32]time.Duration)(nil), "stdtypes.MapStdTypes.DurationEntry")
853 proto.RegisterMapType((map[int32]bool)(nil), "stdtypes.MapStdTypes.NonnullBoolEntry")
854 proto.RegisterMapType((map[int32][]byte)(nil), "stdtypes.MapStdTypes.NonnullBytesEntry")
855 proto.RegisterMapType((map[int32]float64)(nil), "stdtypes.MapStdTypes.NonnullDoubleEntry")
856 proto.RegisterMapType((map[int32]float32)(nil), "stdtypes.MapStdTypes.NonnullFloatEntry")
857 proto.RegisterMapType((map[int32]int32)(nil), "stdtypes.MapStdTypes.NonnullInt32Entry")
858 proto.RegisterMapType((map[int32]int64)(nil), "stdtypes.MapStdTypes.NonnullInt64Entry")
859 proto.RegisterMapType((map[int32]string)(nil), "stdtypes.MapStdTypes.NonnullStringEntry")
860 proto.RegisterMapType((map[int32]uint32)(nil), "stdtypes.MapStdTypes.NonnullUInt32Entry")
861 proto.RegisterMapType((map[int32]uint64)(nil), "stdtypes.MapStdTypes.NonnullUInt64Entry")
862 proto.RegisterMapType((map[int32]*bool)(nil), "stdtypes.MapStdTypes.NullableBoolEntry")
863 proto.RegisterMapType((map[int32]*[]byte)(nil), "stdtypes.MapStdTypes.NullableBytesEntry")
864 proto.RegisterMapType((map[int32]*float64)(nil), "stdtypes.MapStdTypes.NullableDoubleEntry")
865 proto.RegisterMapType((map[int32]*time.Duration)(nil), "stdtypes.MapStdTypes.NullableDurationEntry")
866 proto.RegisterMapType((map[int32]*float32)(nil), "stdtypes.MapStdTypes.NullableFloatEntry")
867 proto.RegisterMapType((map[int32]*int32)(nil), "stdtypes.MapStdTypes.NullableInt32Entry")
868 proto.RegisterMapType((map[int32]*int64)(nil), "stdtypes.MapStdTypes.NullableInt64Entry")
869 proto.RegisterMapType((map[int32]*string)(nil), "stdtypes.MapStdTypes.NullableStringEntry")
870 proto.RegisterMapType((map[int32]*time.Time)(nil), "stdtypes.MapStdTypes.NullableTimestampEntry")
871 proto.RegisterMapType((map[int32]*uint32)(nil), "stdtypes.MapStdTypes.NullableUInt32Entry")
872 proto.RegisterMapType((map[int32]*uint64)(nil), "stdtypes.MapStdTypes.NullableUInt64Entry")
873 proto.RegisterMapType((map[int32]time.Time)(nil), "stdtypes.MapStdTypes.TimestampEntry")
874 proto.RegisterType((*OneofStdTypes)(nil), "stdtypes.OneofStdTypes")
875 }
876
877 func init() { proto.RegisterFile("stdtypes.proto", fileDescriptor_fa784ced32c4280a) }
878
879 var fileDescriptor_fa784ced32c4280a = []byte{
880
881 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x99, 0x4f, 0x6f, 0x1b, 0xc5,
882 0x1b, 0xc7, 0xbd, 0x19, 0x3b, 0xb5, 0xc7, 0x76, 0x9a, 0x4c, 0x7f, 0xad, 0xf6, 0x67, 0xd0, 0xa6,
883 0x0a, 0x88, 0x06, 0x51, 0x1c, 0xd8, 0x45, 0x08, 0x21, 0x50, 0xc1, 0x0a, 0x25, 0x81, 0xfe, 0x01,
884 0xd7, 0x6e, 0x2c, 0xa0, 0x50, 0x9b, 0x6c, 0x4d, 0x84, 0xe3, 0xb5, 0xec, 0x35, 0x28, 0x37, 0x5e,
885 0x02, 0x47, 0x8e, 0x1c, 0xb9, 0x73, 0xe1, 0xc8, 0xb1, 0x47, 0x5e, 0x01, 0x34, 0xe6, 0x0d, 0x20,
886 0xb8, 0xf4, 0x82, 0x84, 0x76, 0x66, 0x76, 0x77, 0x76, 0xf7, 0x99, 0xdd, 0x95, 0x35, 0xbe, 0x25,
887 0x99, 0x79, 0x3e, 0xfe, 0xee, 0xe3, 0x51, 0x3e, 0x7e, 0x3c, 0x78, 0x63, 0xe6, 0x1e, 0xbb, 0x67,
888 0x13, 0x7b, 0xd6, 0x9c, 0x4c, 0x1d, 0xd7, 0x21, 0x65, 0xff, 0xf7, 0xc6, 0xcb, 0xc3, 0x13, 0xf7,
889 0xab, 0xf9, 0xa0, 0xf9, 0xa5, 0x73, 0xba, 0x37, 0x74, 0x86, 0xce, 0x1e, 0xdd, 0x30, 0x98, 0x3f,
890 0xa2, 0xbf, 0xd1, 0x5f, 0xe8, 0x4f, 0xac, 0xb0, 0x61, 0x0c, 0x1d, 0x67, 0x38, 0xb2, 0xc3, 0x5d,
891 0xc7, 0xf3, 0x69, 0xdf, 0x3d, 0x71, 0xc6, 0x7c, 0x7d, 0x3b, 0xbe, 0xee, 0x9e, 0x9c, 0xda, 0x33,
892 0xb7, 0x7f, 0x3a, 0x91, 0x01, 0xbe, 0x9d, 0xf6, 0x27, 0x13, 0x7b, 0xca, 0x93, 0xed, 0xfc, 0x5d,
893 0xc3, 0xe5, 0x7b, 0xee, 0x71, 0xc7, 0x0b, 0x47, 0xee, 0xe0, 0xad, 0xf1, 0x7c, 0x34, 0xea, 0x0f,
894 0x46, 0x76, 0xc7, 0xe7, 0xe8, 0xda, 0x55, 0x6d, 0xb7, 0x6a, 0x36, 0x9a, 0x0c, 0xd4, 0xf4, 0x41,
895 0xcd, 0x60, 0x47, 0xab, 0xf8, 0xfd, 0x1f, 0xdb, 0x5a, 0x3b, 0x59, 0x4a, 0x3e, 0xc4, 0x9b, 0xfe,
896 0x1f, 0xf7, 0x79, 0x6e, 0x7d, 0x8d, 0xe2, 0xfe, 0x9f, 0xc0, 0xf9, 0x1b, 0x5a, 0xc5, 0x1f, 0x3c,
897 0x5a, 0xa2, 0x90, 0xb4, 0x70, 0x25, 0x78, 0x38, 0x1d, 0x65, 0x86, 0x2a, 0x3f, 0xfe, 0x7d, 0xbb,
898 0x40, 0x83, 0x85, 0x65, 0xe4, 0x06, 0x2e, 0xfb, 0x0d, 0xd4, 0x8b, 0x59, 0x41, 0x28, 0x81, 0x86,
899 0x09, 0x8a, 0xc8, 0x07, 0x78, 0x23, 0x08, 0xe6, 0xcc, 0x07, 0x23, 0x5b, 0x2f, 0x51, 0xcc, 0xb3,
900 0x49, 0x0c, 0x5d, 0xbe, 0xdf, 0x1f, 0xcd, 0xed, 0x56, 0xf1, 0x47, 0x8f, 0x12, 0xab, 0x24, 0xb7,
901 0x70, 0x7d, 0xec, 0x8c, 0xbd, 0x3f, 0x72, 0xd4, 0x7a, 0x0e, 0x14, 0x0d, 0x45, 0x71, 0xd1, 0x62,
902 0xf2, 0x3e, 0xae, 0xfb, 0xfc, 0x9b, 0x23, 0xa7, 0xef, 0xea, 0x17, 0x28, 0xed, 0x99, 0x04, 0x8d,
903 0xae, 0x8a, 0xb9, 0xa2, 0x75, 0xe4, 0x10, 0xd7, 0x38, 0x99, 0x71, 0xca, 0xd9, 0x9c, 0x30, 0x54,
904 0xa4, 0x54, 0xcc, 0x74, 0x38, 0x76, 0x5f, 0x7f, 0x4d, 0xaf, 0x48, 0x58, 0x74, 0x15, 0xcc, 0x44,
905 0x57, 0x84, 0x4c, 0x8c, 0x83, 0xb3, 0x39, 0xc9, 0x4c, 0x0c, 0x25, 0xbc, 0x83, 0x5d, 0x06, 0xab,
906 0x4a, 0xda, 0xde, 0x4d, 0xa4, 0x8a, 0x55, 0x0a, 0xef, 0x20, 0x47, 0xd5, 0x72, 0xa0, 0x92, 0xef,
907 0x20, 0xa7, 0x45, 0xbb, 0x65, 0x99, 0x7a, 0x5d, 0xfe, 0x94, 0x96, 0x29, 0xeb, 0x96, 0x65, 0x46,
908 0xbb, 0x65, 0x99, 0xfa, 0x46, 0x36, 0x07, 0xec, 0x96, 0x65, 0xc6, 0xbb, 0x65, 0x99, 0xfa, 0xc5,
909 0x94, 0x47, 0x8c, 0xa6, 0x8a, 0x55, 0xc6, 0xba, 0x65, 0x99, 0xfa, 0x66, 0x0e, 0x14, 0xdc, 0x2d,
910 0xcb, 0x24, 0xfb, 0xb8, 0xe6, 0xf3, 0x5b, 0x8e, 0x33, 0xd2, 0xb7, 0x24, 0xff, 0x11, 0xbc, 0x45,
911 0x31, 0x55, 0xa4, 0x8a, 0xdc, 0xc4, 0x55, 0x8e, 0xa5, 0x10, 0x92, 0x09, 0x09, 0xf3, 0x88, 0x85,
912 0x62, 0x9f, 0xee, 0xb9, 0xd3, 0x93, 0xf1, 0x50, 0xbf, 0x24, 0x79, 0x38, 0xb6, 0x0c, 0xf6, 0x89,
913 0x2d, 0x09, 0x7d, 0xe2, 0xa8, 0xff, 0xe5, 0x40, 0x25, 0xfb, 0xc4, 0x69, 0xc2, 0xa9, 0x6a, 0x9d,
914 0xb9, 0xf6, 0x4c, 0xbf, 0x2c, 0x39, 0x0d, 0x74, 0x15, 0x3c, 0x55, 0x74, 0x45, 0x38, 0x55, 0x8c,
915 0x73, 0x25, 0x9b, 0x93, 0x3c, 0x55, 0x74, 0x71, 0xe7, 0xdf, 0x1a, 0xae, 0xb6, 0xed, 0x49, 0xe0,
916 0x9d, 0x8f, 0x30, 0x49, 0xc8, 0x63, 0xa6, 0x6b, 0x57, 0x51, 0x2e, 0xf1, 0x00, 0xb5, 0xe4, 0x76,
917 0x68, 0x32, 0xff, 0xff, 0xf9, 0x4c, 0x5f, 0xa3, 0xc0, 0x4c, 0xf5, 0x24, 0x2b, 0xc9, 0x3e, 0xc6,
918 0x6e, 0x18, 0x0c, 0x65, 0x06, 0x0b, 0xe5, 0x23, 0xd4, 0x91, 0x77, 0x71, 0xe5, 0x38, 0x08, 0x53,
919 0xcc, 0x0a, 0x13, 0xea, 0x27, 0xac, 0x02, 0xfd, 0x83, 0xd4, 0xf9, 0x07, 0x29, 0xf5, 0x0f, 0x52,
920 0xe4, 0x1f, 0xa4, 0xd0, 0x3f, 0x48, 0x91, 0x7f, 0x90, 0x4a, 0xff, 0x20, 0x75, 0xfe, 0x41, 0x4a,
921 0xfd, 0x83, 0x14, 0xf9, 0x07, 0xa9, 0xf4, 0x0f, 0x52, 0xe7, 0x1f, 0xa4, 0xd2, 0x3f, 0x48, 0x85,
922 0x7f, 0x90, 0x3a, 0xff, 0x20, 0x75, 0xfe, 0x41, 0x4a, 0xfd, 0x83, 0x14, 0xf9, 0x07, 0x2d, 0xeb,
923 0x9f, 0x9f, 0xb7, 0x71, 0xf5, 0x76, 0x3f, 0xf4, 0xcf, 0x43, 0x78, 0xee, 0xf1, 0xf8, 0xd7, 0x9b,
924 0xc1, 0x28, 0x27, 0x54, 0x34, 0xef, 0xc4, 0xb7, 0xbf, 0x37, 0x76, 0xa7, 0x67, 0xf2, 0x49, 0xe8,
925 0x96, 0x38, 0xbc, 0x30, 0x0f, 0x3d, 0x0f, 0x93, 0x63, 0x44, 0x70, 0x8c, 0x79, 0x00, 0xcc, 0x55,
926 0x4c, 0x4a, 0x2f, 0xa5, 0xc7, 0xf5, 0x77, 0xf3, 0xb4, 0x92, 0x49, 0xeb, 0x30, 0x32, 0x25, 0x79,
927 0xd8, 0xe7, 0x60, 0x6c, 0x14, 0x07, 0xcd, 0x4b, 0x47, 0x12, 0x5f, 0xbd, 0x98, 0x91, 0x93, 0xee,
928 0xe5, 0x29, 0x41, 0x79, 0xf5, 0x60, 0x79, 0xed, 0x4a, 0xb8, 0xe2, 0x56, 0x21, 0x2d, 0x24, 0xb2,
929 0x0e, 0x2c, 0xb2, 0xdd, 0xf4, 0xc4, 0x74, 0xab, 0x18, 0x38, 0x66, 0xb5, 0x2e, 0x68, 0xb5, 0x6b,
930 0xa9, 0x71, 0x05, 0xa6, 0xcc, 0x70, 0x1d, 0xd8, 0x70, 0x19, 0x61, 0xe9, 0x56, 0x30, 0x2c, 0x33,
931 0x41, 0x17, 0xd4, 0x5d, 0x7a, 0x58, 0x81, 0x29, 0x53, 0xdf, 0x91, 0x44, 0x7d, 0x19, 0x87, 0xa1,
932 0x9b, 0x88, 0x1b, 0xf7, 0x60, 0x0f, 0xf6, 0x60, 0xfa, 0x61, 0xe8, 0x82, 0x89, 0x63, 0x4e, 0xec,
933 0xc0, 0x4e, 0xcc, 0xee, 0xaf, 0x65, 0xca, 0xfa, 0x6b, 0x99, 0xd1, 0xfe, 0x06, 0x82, 0xcc, 0xec,
934 0xaf, 0xcf, 0x94, 0xc9, 0xf2, 0x48, 0x22, 0xcb, 0x1c, 0xfd, 0x8d, 0xc6, 0x8d, 0x9b, 0xb3, 0x07,
935 0x9b, 0x33, 0xbb, 0xbf, 0xc9, 0xc4, 0x31, 0x8b, 0x7e, 0x0c, 0x5a, 0xf4, 0x5a, 0x7a, 0x60, 0x6f,
936 0xa7, 0x18, 0x37, 0xaa, 0xd4, 0x36, 0xa4, 0xd4, 0x17, 0x52, 0xa3, 0x86, 0x40, 0x89, 0x5e, 0x8f,
937 0x24, 0x7a, 0xcd, 0xe8, 0x2c, 0xdb, 0x0b, 0x76, 0x96, 0xdb, 0xb1, 0x07, 0xbb, 0x36, 0xbd, 0xb3,
938 0x22, 0x56, 0xea, 0xdd, 0x0e, 0xec, 0xdd, 0x8c, 0x93, 0x4b, 0xb7, 0x82, 0x27, 0x97, 0x49, 0xb8,
939 0x0b, 0x4a, 0x38, 0xfd, 0xe4, 0x0a, 0x4c, 0x89, 0x90, 0x1b, 0x0f, 0xf1, 0x15, 0xd8, 0xa8, 0x64,
940 0x13, 0xa3, 0xaf, 0xed, 0x33, 0xfa, 0x25, 0x64, 0xa9, 0xed, 0xfd, 0x48, 0x5e, 0xc1, 0xa5, 0x6f,
941 0x3c, 0xbb, 0xf3, 0x6f, 0x12, 0x53, 0xc6, 0xb0, 0x36, 0xdb, 0xf8, 0xe6, 0xda, 0x1b, 0x5a, 0xa3,
942 0x87, 0x37, 0x56, 0x44, 0xfe, 0x1c, 0x5f, 0x06, 0xf5, 0x0a, 0xbc, 0xc0, 0x5e, 0xf4, 0x05, 0xe4,
943 0xc3, 0x9f, 0xc8, 0xbf, 0x8f, 0xeb, 0x2b, 0xe1, 0x7e, 0x81, 0x2f, 0x01, 0xba, 0x05, 0xe8, 0x66,
944 0x94, 0x9e, 0x3a, 0x1f, 0x46, 0x1b, 0x43, 0x92, 0xde, 0x55, 0xc8, 0x7f, 0x80, 0x49, 0xd2, 0xbe,
945 0x00, 0xff, 0xd5, 0x28, 0x3f, 0x6d, 0x92, 0x14, 0xf1, 0x9f, 0xe1, 0xad, 0x84, 0x87, 0xd5, 0xd1,
946 0x85, 0xf0, 0xa1, 0x87, 0x96, 0xc1, 0x87, 0x93, 0x1d, 0x1c, 0x7e, 0x15, 0x74, 0xe1, 0xe8, 0x74,
947 0x53, 0xf9, 0x99, 0x6f, 0x6d, 0x17, 0x7e, 0x81, 0xf0, 0xe8, 0xac, 0x86, 0x1f, 0xed, 0x3e, 0xb7,
948 0xd4, 0x92, 0xfd, 0xe1, 0x93, 0xa2, 0xb4, 0xfb, 0xca, 0xe9, 0xb1, 0xee, 0xcb, 0xf9, 0xb9, 0xba,
949 0x03, 0xbc, 0x40, 0xb4, 0xfb, 0xea, 0xf9, 0x9f, 0xe2, 0xad, 0x84, 0xca, 0x97, 0xf9, 0x77, 0x1c,
950 0x4c, 0xc5, 0x22, 0xfc, 0x13, 0xbc, 0x19, 0xb7, 0xba, 0x32, 0xb6, 0xd0, 0x79, 0xc1, 0xc1, 0xcb,
951 0x74, 0x46, 0x18, 0x9d, 0xe1, 0xce, 0xaf, 0x86, 0x2f, 0x9c, 0xfb, 0xd0, 0xca, 0xcb, 0x9c, 0xcc,
952 0x70, 0xc8, 0x86, 0xcf, 0xfd, 0x0a, 0xe8, 0x3b, 0xff, 0x94, 0x70, 0xfd, 0xee, 0xd8, 0x76, 0x1e,
953 0x05, 0x73, 0xfb, 0x3b, 0xe2, 0x54, 0x9d, 0xf3, 0x9e, 0xf2, 0xa0, 0x20, 0x4e, 0xd2, 0x6f, 0x0b,
954 0xa3, 0x6e, 0xbe, 0x9b, 0xc9, 0x83, 0x82, 0x30, 0xde, 0xb6, 0x70, 0x65, 0x6a, 0x4f, 0xf8, 0x04,
955 0x8a, 0xf2, 0xde, 0x04, 0x7a, 0x11, 0x82, 0x32, 0x72, 0x03, 0x97, 0xa7, 0xf6, 0x84, 0x4d, 0x85,
956 0xc5, 0x9c, 0x77, 0x76, 0x5e, 0x08, 0xbf, 0x88, 0x03, 0xd8, 0xe0, 0x53, 0xca, 0x79, 0xc1, 0xc6,
957 0x01, 0x6c, 0xc8, 0x61, 0x4f, 0xc1, 0x47, 0xa7, 0xf5, 0xbc, 0xb7, 0x61, 0xfc, 0x29, 0xf8, 0xa0,
958 0x14, 0x84, 0xb0, 0x4c, 0xe9, 0xcd, 0x63, 0xfc, 0x1b, 0xba, 0x30, 0x84, 0x65, 0x0a, 0x21, 0x2c,
959 0x93, 0xdf, 0x39, 0xe6, 0xf8, 0x92, 0x4f, 0x08, 0x61, 0x99, 0xe4, 0x2d, 0x7c, 0x61, 0x6a, 0x4f,
960 0xe8, 0xc7, 0xfe, 0x4a, 0xbe, 0xeb, 0xa0, 0x83, 0x42, 0xdb, 0x2f, 0xe1, 0x09, 0xf8, 0xe7, 0x70,
961 0x9c, 0xf7, 0xfa, 0x86, 0x27, 0xe0, 0x9f, 0xba, 0x59, 0x1b, 0xd8, 0x67, 0xe3, 0x6a, 0xce, 0x8b,
962 0x16, 0xde, 0x06, 0xfa, 0xe7, 0xd6, 0x45, 0x7a, 0xc6, 0xef, 0xd2, 0x33, 0xee, 0x9d, 0xd2, 0xd6,
963 0xf5, 0x27, 0xe7, 0x86, 0xf6, 0xd7, 0xb9, 0xa1, 0x3d, 0x3d, 0x37, 0xb4, 0x9f, 0x16, 0x86, 0xf6,
964 0xcb, 0xc2, 0xd0, 0x7e, 0x5d, 0x18, 0xda, 0xe3, 0x85, 0x51, 0xf8, 0x6d, 0x61, 0x14, 0x9e, 0x2c,
965 0x0c, 0xed, 0xe9, 0xc2, 0x28, 0x7c, 0xf7, 0xa7, 0x51, 0x18, 0xac, 0xd3, 0x57, 0xb1, 0xfe, 0x0b,
966 0x00, 0x00, 0xff, 0xff, 0xd9, 0x80, 0xa9, 0x4d, 0x81, 0x20, 0x00, 0x00,
967 }
968
969 func (this *StdTypes) VerboseEqual(that interface{}) error {
970 if that == nil {
971 if this == nil {
972 return nil
973 }
974 return fmt.Errorf("that == nil && this != nil")
975 }
976
977 that1, ok := that.(*StdTypes)
978 if !ok {
979 that2, ok := that.(StdTypes)
980 if ok {
981 that1 = &that2
982 } else {
983 return fmt.Errorf("that is not of type *StdTypes")
984 }
985 }
986 if that1 == nil {
987 if this == nil {
988 return nil
989 }
990 return fmt.Errorf("that is type *StdTypes but is nil && this != nil")
991 } else if this == nil {
992 return fmt.Errorf("that is type *StdTypes but is not nil && this == nil")
993 }
994 if that1.NullableTimestamp == nil {
995 if this.NullableTimestamp != nil {
996 return fmt.Errorf("this.NullableTimestamp != nil && that1.NullableTimestamp == nil")
997 }
998 } else if !this.NullableTimestamp.Equal(*that1.NullableTimestamp) {
999 return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", this.NullableTimestamp, that1.NullableTimestamp)
1000 }
1001 if this.NullableDuration != nil && that1.NullableDuration != nil {
1002 if *this.NullableDuration != *that1.NullableDuration {
1003 return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", *this.NullableDuration, *that1.NullableDuration)
1004 }
1005 } else if this.NullableDuration != nil {
1006 return fmt.Errorf("this.NullableDuration == nil && that.NullableDuration != nil")
1007 } else if that1.NullableDuration != nil {
1008 return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", this.NullableDuration, that1.NullableDuration)
1009 }
1010 if !this.Timestamp.Equal(that1.Timestamp) {
1011 return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
1012 }
1013 if this.Duration != that1.Duration {
1014 return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
1015 }
1016 if this.NullableDouble != nil && that1.NullableDouble != nil {
1017 if *this.NullableDouble != *that1.NullableDouble {
1018 return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", *this.NullableDouble, *that1.NullableDouble)
1019 }
1020 } else if this.NullableDouble != nil {
1021 return fmt.Errorf("this.NullableDouble == nil && that.NullableDouble != nil")
1022 } else if that1.NullableDouble != nil {
1023 return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", this.NullableDouble, that1.NullableDouble)
1024 }
1025 if this.NonnullDouble != that1.NonnullDouble {
1026 return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", this.NonnullDouble, that1.NonnullDouble)
1027 }
1028 if this.NullableFloat != nil && that1.NullableFloat != nil {
1029 if *this.NullableFloat != *that1.NullableFloat {
1030 return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", *this.NullableFloat, *that1.NullableFloat)
1031 }
1032 } else if this.NullableFloat != nil {
1033 return fmt.Errorf("this.NullableFloat == nil && that.NullableFloat != nil")
1034 } else if that1.NullableFloat != nil {
1035 return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", this.NullableFloat, that1.NullableFloat)
1036 }
1037 if this.NonnullFloat != that1.NonnullFloat {
1038 return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", this.NonnullFloat, that1.NonnullFloat)
1039 }
1040 if this.NullableInt64 != nil && that1.NullableInt64 != nil {
1041 if *this.NullableInt64 != *that1.NullableInt64 {
1042 return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", *this.NullableInt64, *that1.NullableInt64)
1043 }
1044 } else if this.NullableInt64 != nil {
1045 return fmt.Errorf("this.NullableInt64 == nil && that.NullableInt64 != nil")
1046 } else if that1.NullableInt64 != nil {
1047 return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", this.NullableInt64, that1.NullableInt64)
1048 }
1049 if this.NonnullInt64 != that1.NonnullInt64 {
1050 return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", this.NonnullInt64, that1.NonnullInt64)
1051 }
1052 if this.NullableUInt64 != nil && that1.NullableUInt64 != nil {
1053 if *this.NullableUInt64 != *that1.NullableUInt64 {
1054 return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", *this.NullableUInt64, *that1.NullableUInt64)
1055 }
1056 } else if this.NullableUInt64 != nil {
1057 return fmt.Errorf("this.NullableUInt64 == nil && that.NullableUInt64 != nil")
1058 } else if that1.NullableUInt64 != nil {
1059 return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", this.NullableUInt64, that1.NullableUInt64)
1060 }
1061 if this.NonnullUInt64 != that1.NonnullUInt64 {
1062 return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", this.NonnullUInt64, that1.NonnullUInt64)
1063 }
1064 if this.NullableInt32 != nil && that1.NullableInt32 != nil {
1065 if *this.NullableInt32 != *that1.NullableInt32 {
1066 return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", *this.NullableInt32, *that1.NullableInt32)
1067 }
1068 } else if this.NullableInt32 != nil {
1069 return fmt.Errorf("this.NullableInt32 == nil && that.NullableInt32 != nil")
1070 } else if that1.NullableInt32 != nil {
1071 return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", this.NullableInt32, that1.NullableInt32)
1072 }
1073 if this.NonnullInt32 != that1.NonnullInt32 {
1074 return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", this.NonnullInt32, that1.NonnullInt32)
1075 }
1076 if this.NullableUInt32 != nil && that1.NullableUInt32 != nil {
1077 if *this.NullableUInt32 != *that1.NullableUInt32 {
1078 return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", *this.NullableUInt32, *that1.NullableUInt32)
1079 }
1080 } else if this.NullableUInt32 != nil {
1081 return fmt.Errorf("this.NullableUInt32 == nil && that.NullableUInt32 != nil")
1082 } else if that1.NullableUInt32 != nil {
1083 return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", this.NullableUInt32, that1.NullableUInt32)
1084 }
1085 if this.NonnullUInt32 != that1.NonnullUInt32 {
1086 return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", this.NonnullUInt32, that1.NonnullUInt32)
1087 }
1088 if this.NullableBool != nil && that1.NullableBool != nil {
1089 if *this.NullableBool != *that1.NullableBool {
1090 return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", *this.NullableBool, *that1.NullableBool)
1091 }
1092 } else if this.NullableBool != nil {
1093 return fmt.Errorf("this.NullableBool == nil && that.NullableBool != nil")
1094 } else if that1.NullableBool != nil {
1095 return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", this.NullableBool, that1.NullableBool)
1096 }
1097 if this.NonnullBool != that1.NonnullBool {
1098 return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", this.NonnullBool, that1.NonnullBool)
1099 }
1100 if this.NullableString != nil && that1.NullableString != nil {
1101 if *this.NullableString != *that1.NullableString {
1102 return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", *this.NullableString, *that1.NullableString)
1103 }
1104 } else if this.NullableString != nil {
1105 return fmt.Errorf("this.NullableString == nil && that.NullableString != nil")
1106 } else if that1.NullableString != nil {
1107 return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", this.NullableString, that1.NullableString)
1108 }
1109 if this.NonnullString != that1.NonnullString {
1110 return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", this.NonnullString, that1.NonnullString)
1111 }
1112 if that1.NullableBytes == nil {
1113 if this.NullableBytes != nil {
1114 return fmt.Errorf("this.NullableBytes != nil && that1.NullableBytes == nil")
1115 }
1116 } else if !bytes.Equal(*this.NullableBytes, *that1.NullableBytes) {
1117 return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", this.NullableBytes, that1.NullableBytes)
1118 }
1119 if !bytes.Equal(this.NonnullBytes, that1.NonnullBytes) {
1120 return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", this.NonnullBytes, that1.NonnullBytes)
1121 }
1122 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1123 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1124 }
1125 return nil
1126 }
1127 func (this *StdTypes) Equal(that interface{}) bool {
1128 if that == nil {
1129 return this == nil
1130 }
1131
1132 that1, ok := that.(*StdTypes)
1133 if !ok {
1134 that2, ok := that.(StdTypes)
1135 if ok {
1136 that1 = &that2
1137 } else {
1138 return false
1139 }
1140 }
1141 if that1 == nil {
1142 return this == nil
1143 } else if this == nil {
1144 return false
1145 }
1146 if that1.NullableTimestamp == nil {
1147 if this.NullableTimestamp != nil {
1148 return false
1149 }
1150 } else if !this.NullableTimestamp.Equal(*that1.NullableTimestamp) {
1151 return false
1152 }
1153 if this.NullableDuration != nil && that1.NullableDuration != nil {
1154 if *this.NullableDuration != *that1.NullableDuration {
1155 return false
1156 }
1157 } else if this.NullableDuration != nil {
1158 return false
1159 } else if that1.NullableDuration != nil {
1160 return false
1161 }
1162 if !this.Timestamp.Equal(that1.Timestamp) {
1163 return false
1164 }
1165 if this.Duration != that1.Duration {
1166 return false
1167 }
1168 if this.NullableDouble != nil && that1.NullableDouble != nil {
1169 if *this.NullableDouble != *that1.NullableDouble {
1170 return false
1171 }
1172 } else if this.NullableDouble != nil {
1173 return false
1174 } else if that1.NullableDouble != nil {
1175 return false
1176 }
1177 if this.NonnullDouble != that1.NonnullDouble {
1178 return false
1179 }
1180 if this.NullableFloat != nil && that1.NullableFloat != nil {
1181 if *this.NullableFloat != *that1.NullableFloat {
1182 return false
1183 }
1184 } else if this.NullableFloat != nil {
1185 return false
1186 } else if that1.NullableFloat != nil {
1187 return false
1188 }
1189 if this.NonnullFloat != that1.NonnullFloat {
1190 return false
1191 }
1192 if this.NullableInt64 != nil && that1.NullableInt64 != nil {
1193 if *this.NullableInt64 != *that1.NullableInt64 {
1194 return false
1195 }
1196 } else if this.NullableInt64 != nil {
1197 return false
1198 } else if that1.NullableInt64 != nil {
1199 return false
1200 }
1201 if this.NonnullInt64 != that1.NonnullInt64 {
1202 return false
1203 }
1204 if this.NullableUInt64 != nil && that1.NullableUInt64 != nil {
1205 if *this.NullableUInt64 != *that1.NullableUInt64 {
1206 return false
1207 }
1208 } else if this.NullableUInt64 != nil {
1209 return false
1210 } else if that1.NullableUInt64 != nil {
1211 return false
1212 }
1213 if this.NonnullUInt64 != that1.NonnullUInt64 {
1214 return false
1215 }
1216 if this.NullableInt32 != nil && that1.NullableInt32 != nil {
1217 if *this.NullableInt32 != *that1.NullableInt32 {
1218 return false
1219 }
1220 } else if this.NullableInt32 != nil {
1221 return false
1222 } else if that1.NullableInt32 != nil {
1223 return false
1224 }
1225 if this.NonnullInt32 != that1.NonnullInt32 {
1226 return false
1227 }
1228 if this.NullableUInt32 != nil && that1.NullableUInt32 != nil {
1229 if *this.NullableUInt32 != *that1.NullableUInt32 {
1230 return false
1231 }
1232 } else if this.NullableUInt32 != nil {
1233 return false
1234 } else if that1.NullableUInt32 != nil {
1235 return false
1236 }
1237 if this.NonnullUInt32 != that1.NonnullUInt32 {
1238 return false
1239 }
1240 if this.NullableBool != nil && that1.NullableBool != nil {
1241 if *this.NullableBool != *that1.NullableBool {
1242 return false
1243 }
1244 } else if this.NullableBool != nil {
1245 return false
1246 } else if that1.NullableBool != nil {
1247 return false
1248 }
1249 if this.NonnullBool != that1.NonnullBool {
1250 return false
1251 }
1252 if this.NullableString != nil && that1.NullableString != nil {
1253 if *this.NullableString != *that1.NullableString {
1254 return false
1255 }
1256 } else if this.NullableString != nil {
1257 return false
1258 } else if that1.NullableString != nil {
1259 return false
1260 }
1261 if this.NonnullString != that1.NonnullString {
1262 return false
1263 }
1264 if that1.NullableBytes == nil {
1265 if this.NullableBytes != nil {
1266 return false
1267 }
1268 } else if !bytes.Equal(*this.NullableBytes, *that1.NullableBytes) {
1269 return false
1270 }
1271 if !bytes.Equal(this.NonnullBytes, that1.NonnullBytes) {
1272 return false
1273 }
1274 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1275 return false
1276 }
1277 return true
1278 }
1279 func (this *RepStdTypes) VerboseEqual(that interface{}) error {
1280 if that == nil {
1281 if this == nil {
1282 return nil
1283 }
1284 return fmt.Errorf("that == nil && this != nil")
1285 }
1286
1287 that1, ok := that.(*RepStdTypes)
1288 if !ok {
1289 that2, ok := that.(RepStdTypes)
1290 if ok {
1291 that1 = &that2
1292 } else {
1293 return fmt.Errorf("that is not of type *RepStdTypes")
1294 }
1295 }
1296 if that1 == nil {
1297 if this == nil {
1298 return nil
1299 }
1300 return fmt.Errorf("that is type *RepStdTypes but is nil && this != nil")
1301 } else if this == nil {
1302 return fmt.Errorf("that is type *RepStdTypes but is not nil && this == nil")
1303 }
1304 if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
1305 return fmt.Errorf("NullableTimestamps this(%v) Not Equal that(%v)", len(this.NullableTimestamps), len(that1.NullableTimestamps))
1306 }
1307 for i := range this.NullableTimestamps {
1308 if !this.NullableTimestamps[i].Equal(*that1.NullableTimestamps[i]) {
1309 return fmt.Errorf("NullableTimestamps this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamps[i], i, that1.NullableTimestamps[i])
1310 }
1311 }
1312 if len(this.NullableDurations) != len(that1.NullableDurations) {
1313 return fmt.Errorf("NullableDurations this(%v) Not Equal that(%v)", len(this.NullableDurations), len(that1.NullableDurations))
1314 }
1315 for i := range this.NullableDurations {
1316 if dthis, dthat := this.NullableDurations[i], that1.NullableDurations[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1317 return fmt.Errorf("NullableDurations this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDurations[i], i, that1.NullableDurations[i])
1318 }
1319 }
1320 if len(this.Timestamps) != len(that1.Timestamps) {
1321 return fmt.Errorf("Timestamps this(%v) Not Equal that(%v)", len(this.Timestamps), len(that1.Timestamps))
1322 }
1323 for i := range this.Timestamps {
1324 if !this.Timestamps[i].Equal(that1.Timestamps[i]) {
1325 return fmt.Errorf("Timestamps this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamps[i], i, that1.Timestamps[i])
1326 }
1327 }
1328 if len(this.Durations) != len(that1.Durations) {
1329 return fmt.Errorf("Durations this(%v) Not Equal that(%v)", len(this.Durations), len(that1.Durations))
1330 }
1331 for i := range this.Durations {
1332 if this.Durations[i] != that1.Durations[i] {
1333 return fmt.Errorf("Durations this[%v](%v) Not Equal that[%v](%v)", i, this.Durations[i], i, that1.Durations[i])
1334 }
1335 }
1336 if len(this.NullableDouble) != len(that1.NullableDouble) {
1337 return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", len(this.NullableDouble), len(that1.NullableDouble))
1338 }
1339 for i := range this.NullableDouble {
1340 if dthis, dthat := this.NullableDouble[i], that1.NullableDouble[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1341 return fmt.Errorf("NullableDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDouble[i], i, that1.NullableDouble[i])
1342 }
1343 }
1344 if len(this.NonnullDouble) != len(that1.NonnullDouble) {
1345 return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", len(this.NonnullDouble), len(that1.NonnullDouble))
1346 }
1347 for i := range this.NonnullDouble {
1348 if this.NonnullDouble[i] != that1.NonnullDouble[i] {
1349 return fmt.Errorf("NonnullDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullDouble[i], i, that1.NonnullDouble[i])
1350 }
1351 }
1352 if len(this.NullableFloat) != len(that1.NullableFloat) {
1353 return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", len(this.NullableFloat), len(that1.NullableFloat))
1354 }
1355 for i := range this.NullableFloat {
1356 if dthis, dthat := this.NullableFloat[i], that1.NullableFloat[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1357 return fmt.Errorf("NullableFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NullableFloat[i], i, that1.NullableFloat[i])
1358 }
1359 }
1360 if len(this.NonnullFloat) != len(that1.NonnullFloat) {
1361 return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", len(this.NonnullFloat), len(that1.NonnullFloat))
1362 }
1363 for i := range this.NonnullFloat {
1364 if this.NonnullFloat[i] != that1.NonnullFloat[i] {
1365 return fmt.Errorf("NonnullFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullFloat[i], i, that1.NonnullFloat[i])
1366 }
1367 }
1368 if len(this.NullableInt64) != len(that1.NullableInt64) {
1369 return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", len(this.NullableInt64), len(that1.NullableInt64))
1370 }
1371 for i := range this.NullableInt64 {
1372 if dthis, dthat := this.NullableInt64[i], that1.NullableInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1373 return fmt.Errorf("NullableInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt64[i], i, that1.NullableInt64[i])
1374 }
1375 }
1376 if len(this.NonnullInt64) != len(that1.NonnullInt64) {
1377 return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", len(this.NonnullInt64), len(that1.NonnullInt64))
1378 }
1379 for i := range this.NonnullInt64 {
1380 if this.NonnullInt64[i] != that1.NonnullInt64[i] {
1381 return fmt.Errorf("NonnullInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt64[i], i, that1.NonnullInt64[i])
1382 }
1383 }
1384 if len(this.NullableUInt64) != len(that1.NullableUInt64) {
1385 return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", len(this.NullableUInt64), len(that1.NullableUInt64))
1386 }
1387 for i := range this.NullableUInt64 {
1388 if dthis, dthat := this.NullableUInt64[i], that1.NullableUInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1389 return fmt.Errorf("NullableUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt64[i], i, that1.NullableUInt64[i])
1390 }
1391 }
1392 if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
1393 return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", len(this.NonnullUInt64), len(that1.NonnullUInt64))
1394 }
1395 for i := range this.NonnullUInt64 {
1396 if this.NonnullUInt64[i] != that1.NonnullUInt64[i] {
1397 return fmt.Errorf("NonnullUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt64[i], i, that1.NonnullUInt64[i])
1398 }
1399 }
1400 if len(this.NullableInt32) != len(that1.NullableInt32) {
1401 return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", len(this.NullableInt32), len(that1.NullableInt32))
1402 }
1403 for i := range this.NullableInt32 {
1404 if dthis, dthat := this.NullableInt32[i], that1.NullableInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1405 return fmt.Errorf("NullableInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt32[i], i, that1.NullableInt32[i])
1406 }
1407 }
1408 if len(this.NonnullInt32) != len(that1.NonnullInt32) {
1409 return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", len(this.NonnullInt32), len(that1.NonnullInt32))
1410 }
1411 for i := range this.NonnullInt32 {
1412 if this.NonnullInt32[i] != that1.NonnullInt32[i] {
1413 return fmt.Errorf("NonnullInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt32[i], i, that1.NonnullInt32[i])
1414 }
1415 }
1416 if len(this.NullableUInt32) != len(that1.NullableUInt32) {
1417 return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", len(this.NullableUInt32), len(that1.NullableUInt32))
1418 }
1419 for i := range this.NullableUInt32 {
1420 if dthis, dthat := this.NullableUInt32[i], that1.NullableUInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1421 return fmt.Errorf("NullableUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt32[i], i, that1.NullableUInt32[i])
1422 }
1423 }
1424 if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
1425 return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", len(this.NonnullUInt32), len(that1.NonnullUInt32))
1426 }
1427 for i := range this.NonnullUInt32 {
1428 if this.NonnullUInt32[i] != that1.NonnullUInt32[i] {
1429 return fmt.Errorf("NonnullUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt32[i], i, that1.NonnullUInt32[i])
1430 }
1431 }
1432 if len(this.NullableBool) != len(that1.NullableBool) {
1433 return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", len(this.NullableBool), len(that1.NullableBool))
1434 }
1435 for i := range this.NullableBool {
1436 if dthis, dthat := this.NullableBool[i], that1.NullableBool[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1437 return fmt.Errorf("NullableBool this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBool[i], i, that1.NullableBool[i])
1438 }
1439 }
1440 if len(this.NonnullBool) != len(that1.NonnullBool) {
1441 return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", len(this.NonnullBool), len(that1.NonnullBool))
1442 }
1443 for i := range this.NonnullBool {
1444 if this.NonnullBool[i] != that1.NonnullBool[i] {
1445 return fmt.Errorf("NonnullBool this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBool[i], i, that1.NonnullBool[i])
1446 }
1447 }
1448 if len(this.NullableString) != len(that1.NullableString) {
1449 return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", len(this.NullableString), len(that1.NullableString))
1450 }
1451 for i := range this.NullableString {
1452 if dthis, dthat := this.NullableString[i], that1.NullableString[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1453 return fmt.Errorf("NullableString this[%v](%v) Not Equal that[%v](%v)", i, this.NullableString[i], i, that1.NullableString[i])
1454 }
1455 }
1456 if len(this.NonnullString) != len(that1.NonnullString) {
1457 return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", len(this.NonnullString), len(that1.NonnullString))
1458 }
1459 for i := range this.NonnullString {
1460 if this.NonnullString[i] != that1.NonnullString[i] {
1461 return fmt.Errorf("NonnullString this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullString[i], i, that1.NonnullString[i])
1462 }
1463 }
1464 if len(this.NullableBytes) != len(that1.NullableBytes) {
1465 return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", len(this.NullableBytes), len(that1.NullableBytes))
1466 }
1467 for i := range this.NullableBytes {
1468 if !bytes.Equal(*this.NullableBytes[i], *that1.NullableBytes[i]) {
1469 return fmt.Errorf("NullableBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBytes[i], i, that1.NullableBytes[i])
1470 }
1471 }
1472 if len(this.NonnullBytes) != len(that1.NonnullBytes) {
1473 return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", len(this.NonnullBytes), len(that1.NonnullBytes))
1474 }
1475 for i := range this.NonnullBytes {
1476 if !bytes.Equal(this.NonnullBytes[i], that1.NonnullBytes[i]) {
1477 return fmt.Errorf("NonnullBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBytes[i], i, that1.NonnullBytes[i])
1478 }
1479 }
1480 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1481 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1482 }
1483 return nil
1484 }
1485 func (this *RepStdTypes) Equal(that interface{}) bool {
1486 if that == nil {
1487 return this == nil
1488 }
1489
1490 that1, ok := that.(*RepStdTypes)
1491 if !ok {
1492 that2, ok := that.(RepStdTypes)
1493 if ok {
1494 that1 = &that2
1495 } else {
1496 return false
1497 }
1498 }
1499 if that1 == nil {
1500 return this == nil
1501 } else if this == nil {
1502 return false
1503 }
1504 if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
1505 return false
1506 }
1507 for i := range this.NullableTimestamps {
1508 if !this.NullableTimestamps[i].Equal(*that1.NullableTimestamps[i]) {
1509 return false
1510 }
1511 }
1512 if len(this.NullableDurations) != len(that1.NullableDurations) {
1513 return false
1514 }
1515 for i := range this.NullableDurations {
1516 if dthis, dthat := this.NullableDurations[i], that1.NullableDurations[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1517 return false
1518 }
1519 }
1520 if len(this.Timestamps) != len(that1.Timestamps) {
1521 return false
1522 }
1523 for i := range this.Timestamps {
1524 if !this.Timestamps[i].Equal(that1.Timestamps[i]) {
1525 return false
1526 }
1527 }
1528 if len(this.Durations) != len(that1.Durations) {
1529 return false
1530 }
1531 for i := range this.Durations {
1532 if this.Durations[i] != that1.Durations[i] {
1533 return false
1534 }
1535 }
1536 if len(this.NullableDouble) != len(that1.NullableDouble) {
1537 return false
1538 }
1539 for i := range this.NullableDouble {
1540 if dthis, dthat := this.NullableDouble[i], that1.NullableDouble[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1541 return false
1542 }
1543 }
1544 if len(this.NonnullDouble) != len(that1.NonnullDouble) {
1545 return false
1546 }
1547 for i := range this.NonnullDouble {
1548 if this.NonnullDouble[i] != that1.NonnullDouble[i] {
1549 return false
1550 }
1551 }
1552 if len(this.NullableFloat) != len(that1.NullableFloat) {
1553 return false
1554 }
1555 for i := range this.NullableFloat {
1556 if dthis, dthat := this.NullableFloat[i], that1.NullableFloat[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1557 return false
1558 }
1559 }
1560 if len(this.NonnullFloat) != len(that1.NonnullFloat) {
1561 return false
1562 }
1563 for i := range this.NonnullFloat {
1564 if this.NonnullFloat[i] != that1.NonnullFloat[i] {
1565 return false
1566 }
1567 }
1568 if len(this.NullableInt64) != len(that1.NullableInt64) {
1569 return false
1570 }
1571 for i := range this.NullableInt64 {
1572 if dthis, dthat := this.NullableInt64[i], that1.NullableInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1573 return false
1574 }
1575 }
1576 if len(this.NonnullInt64) != len(that1.NonnullInt64) {
1577 return false
1578 }
1579 for i := range this.NonnullInt64 {
1580 if this.NonnullInt64[i] != that1.NonnullInt64[i] {
1581 return false
1582 }
1583 }
1584 if len(this.NullableUInt64) != len(that1.NullableUInt64) {
1585 return false
1586 }
1587 for i := range this.NullableUInt64 {
1588 if dthis, dthat := this.NullableUInt64[i], that1.NullableUInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1589 return false
1590 }
1591 }
1592 if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
1593 return false
1594 }
1595 for i := range this.NonnullUInt64 {
1596 if this.NonnullUInt64[i] != that1.NonnullUInt64[i] {
1597 return false
1598 }
1599 }
1600 if len(this.NullableInt32) != len(that1.NullableInt32) {
1601 return false
1602 }
1603 for i := range this.NullableInt32 {
1604 if dthis, dthat := this.NullableInt32[i], that1.NullableInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1605 return false
1606 }
1607 }
1608 if len(this.NonnullInt32) != len(that1.NonnullInt32) {
1609 return false
1610 }
1611 for i := range this.NonnullInt32 {
1612 if this.NonnullInt32[i] != that1.NonnullInt32[i] {
1613 return false
1614 }
1615 }
1616 if len(this.NullableUInt32) != len(that1.NullableUInt32) {
1617 return false
1618 }
1619 for i := range this.NullableUInt32 {
1620 if dthis, dthat := this.NullableUInt32[i], that1.NullableUInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1621 return false
1622 }
1623 }
1624 if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
1625 return false
1626 }
1627 for i := range this.NonnullUInt32 {
1628 if this.NonnullUInt32[i] != that1.NonnullUInt32[i] {
1629 return false
1630 }
1631 }
1632 if len(this.NullableBool) != len(that1.NullableBool) {
1633 return false
1634 }
1635 for i := range this.NullableBool {
1636 if dthis, dthat := this.NullableBool[i], that1.NullableBool[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1637 return false
1638 }
1639 }
1640 if len(this.NonnullBool) != len(that1.NonnullBool) {
1641 return false
1642 }
1643 for i := range this.NonnullBool {
1644 if this.NonnullBool[i] != that1.NonnullBool[i] {
1645 return false
1646 }
1647 }
1648 if len(this.NullableString) != len(that1.NullableString) {
1649 return false
1650 }
1651 for i := range this.NullableString {
1652 if dthis, dthat := this.NullableString[i], that1.NullableString[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1653 return false
1654 }
1655 }
1656 if len(this.NonnullString) != len(that1.NonnullString) {
1657 return false
1658 }
1659 for i := range this.NonnullString {
1660 if this.NonnullString[i] != that1.NonnullString[i] {
1661 return false
1662 }
1663 }
1664 if len(this.NullableBytes) != len(that1.NullableBytes) {
1665 return false
1666 }
1667 for i := range this.NullableBytes {
1668 if !bytes.Equal(*this.NullableBytes[i], *that1.NullableBytes[i]) {
1669 return false
1670 }
1671 }
1672 if len(this.NonnullBytes) != len(that1.NonnullBytes) {
1673 return false
1674 }
1675 for i := range this.NonnullBytes {
1676 if !bytes.Equal(this.NonnullBytes[i], that1.NonnullBytes[i]) {
1677 return false
1678 }
1679 }
1680 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1681 return false
1682 }
1683 return true
1684 }
1685 func (this *MapStdTypes) VerboseEqual(that interface{}) error {
1686 if that == nil {
1687 if this == nil {
1688 return nil
1689 }
1690 return fmt.Errorf("that == nil && this != nil")
1691 }
1692
1693 that1, ok := that.(*MapStdTypes)
1694 if !ok {
1695 that2, ok := that.(MapStdTypes)
1696 if ok {
1697 that1 = &that2
1698 } else {
1699 return fmt.Errorf("that is not of type *MapStdTypes")
1700 }
1701 }
1702 if that1 == nil {
1703 if this == nil {
1704 return nil
1705 }
1706 return fmt.Errorf("that is type *MapStdTypes but is nil && this != nil")
1707 } else if this == nil {
1708 return fmt.Errorf("that is type *MapStdTypes but is not nil && this == nil")
1709 }
1710 if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
1711 return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", len(this.NullableTimestamp), len(that1.NullableTimestamp))
1712 }
1713 for i := range this.NullableTimestamp {
1714 if !this.NullableTimestamp[i].Equal(*that1.NullableTimestamp[i]) {
1715 return fmt.Errorf("NullableTimestamp this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamp[i], i, that1.NullableTimestamp[i])
1716 }
1717 }
1718 if len(this.Timestamp) != len(that1.Timestamp) {
1719 return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", len(this.Timestamp), len(that1.Timestamp))
1720 }
1721 for i := range this.Timestamp {
1722 if !this.Timestamp[i].Equal(that1.Timestamp[i]) {
1723 return fmt.Errorf("Timestamp this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamp[i], i, that1.Timestamp[i])
1724 }
1725 }
1726 if len(this.NullableDuration) != len(that1.NullableDuration) {
1727 return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", len(this.NullableDuration), len(that1.NullableDuration))
1728 }
1729 for i := range this.NullableDuration {
1730 if dthis, dthat := this.NullableDuration[i], that1.NullableDuration[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1731 return fmt.Errorf("NullableDuration this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDuration[i], i, that1.NullableDuration[i])
1732 }
1733 }
1734 if len(this.Duration) != len(that1.Duration) {
1735 return fmt.Errorf("Duration this(%v) Not Equal that(%v)", len(this.Duration), len(that1.Duration))
1736 }
1737 for i := range this.Duration {
1738 if this.Duration[i] != that1.Duration[i] {
1739 return fmt.Errorf("Duration this[%v](%v) Not Equal that[%v](%v)", i, this.Duration[i], i, that1.Duration[i])
1740 }
1741 }
1742 if len(this.NullableDouble) != len(that1.NullableDouble) {
1743 return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", len(this.NullableDouble), len(that1.NullableDouble))
1744 }
1745 for i := range this.NullableDouble {
1746 a := this.NullableDouble[i]
1747 b := that1.NullableDouble[i]
1748 if *a != *b {
1749 return fmt.Errorf("NullableDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDouble[i], i, that1.NullableDouble[i])
1750 }
1751 }
1752 if len(this.NonnullDouble) != len(that1.NonnullDouble) {
1753 return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", len(this.NonnullDouble), len(that1.NonnullDouble))
1754 }
1755 for i := range this.NonnullDouble {
1756 a := this.NonnullDouble[i]
1757 b := that1.NonnullDouble[i]
1758 if a != b {
1759 return fmt.Errorf("NonnullDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullDouble[i], i, that1.NonnullDouble[i])
1760 }
1761 }
1762 if len(this.NullableFloat) != len(that1.NullableFloat) {
1763 return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", len(this.NullableFloat), len(that1.NullableFloat))
1764 }
1765 for i := range this.NullableFloat {
1766 a := this.NullableFloat[i]
1767 b := that1.NullableFloat[i]
1768 if *a != *b {
1769 return fmt.Errorf("NullableFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NullableFloat[i], i, that1.NullableFloat[i])
1770 }
1771 }
1772 if len(this.NonnullFloat) != len(that1.NonnullFloat) {
1773 return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", len(this.NonnullFloat), len(that1.NonnullFloat))
1774 }
1775 for i := range this.NonnullFloat {
1776 a := this.NonnullFloat[i]
1777 b := that1.NonnullFloat[i]
1778 if a != b {
1779 return fmt.Errorf("NonnullFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullFloat[i], i, that1.NonnullFloat[i])
1780 }
1781 }
1782 if len(this.NullableInt64) != len(that1.NullableInt64) {
1783 return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", len(this.NullableInt64), len(that1.NullableInt64))
1784 }
1785 for i := range this.NullableInt64 {
1786 a := this.NullableInt64[i]
1787 b := that1.NullableInt64[i]
1788 if *a != *b {
1789 return fmt.Errorf("NullableInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt64[i], i, that1.NullableInt64[i])
1790 }
1791 }
1792 if len(this.NonnullInt64) != len(that1.NonnullInt64) {
1793 return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", len(this.NonnullInt64), len(that1.NonnullInt64))
1794 }
1795 for i := range this.NonnullInt64 {
1796 a := this.NonnullInt64[i]
1797 b := that1.NonnullInt64[i]
1798 if a != b {
1799 return fmt.Errorf("NonnullInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt64[i], i, that1.NonnullInt64[i])
1800 }
1801 }
1802 if len(this.NullableUInt64) != len(that1.NullableUInt64) {
1803 return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", len(this.NullableUInt64), len(that1.NullableUInt64))
1804 }
1805 for i := range this.NullableUInt64 {
1806 a := this.NullableUInt64[i]
1807 b := that1.NullableUInt64[i]
1808 if *a != *b {
1809 return fmt.Errorf("NullableUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt64[i], i, that1.NullableUInt64[i])
1810 }
1811 }
1812 if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
1813 return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", len(this.NonnullUInt64), len(that1.NonnullUInt64))
1814 }
1815 for i := range this.NonnullUInt64 {
1816 a := this.NonnullUInt64[i]
1817 b := that1.NonnullUInt64[i]
1818 if a != b {
1819 return fmt.Errorf("NonnullUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt64[i], i, that1.NonnullUInt64[i])
1820 }
1821 }
1822 if len(this.NullableInt32) != len(that1.NullableInt32) {
1823 return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", len(this.NullableInt32), len(that1.NullableInt32))
1824 }
1825 for i := range this.NullableInt32 {
1826 a := this.NullableInt32[i]
1827 b := that1.NullableInt32[i]
1828 if *a != *b {
1829 return fmt.Errorf("NullableInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt32[i], i, that1.NullableInt32[i])
1830 }
1831 }
1832 if len(this.NonnullInt32) != len(that1.NonnullInt32) {
1833 return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", len(this.NonnullInt32), len(that1.NonnullInt32))
1834 }
1835 for i := range this.NonnullInt32 {
1836 a := this.NonnullInt32[i]
1837 b := that1.NonnullInt32[i]
1838 if a != b {
1839 return fmt.Errorf("NonnullInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt32[i], i, that1.NonnullInt32[i])
1840 }
1841 }
1842 if len(this.NullableUInt32) != len(that1.NullableUInt32) {
1843 return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", len(this.NullableUInt32), len(that1.NullableUInt32))
1844 }
1845 for i := range this.NullableUInt32 {
1846 a := this.NullableUInt32[i]
1847 b := that1.NullableUInt32[i]
1848 if *a != *b {
1849 return fmt.Errorf("NullableUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt32[i], i, that1.NullableUInt32[i])
1850 }
1851 }
1852 if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
1853 return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", len(this.NonnullUInt32), len(that1.NonnullUInt32))
1854 }
1855 for i := range this.NonnullUInt32 {
1856 a := this.NonnullUInt32[i]
1857 b := that1.NonnullUInt32[i]
1858 if a != b {
1859 return fmt.Errorf("NonnullUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt32[i], i, that1.NonnullUInt32[i])
1860 }
1861 }
1862 if len(this.NullableBool) != len(that1.NullableBool) {
1863 return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", len(this.NullableBool), len(that1.NullableBool))
1864 }
1865 for i := range this.NullableBool {
1866 a := this.NullableBool[i]
1867 b := that1.NullableBool[i]
1868 if *a != *b {
1869 return fmt.Errorf("NullableBool this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBool[i], i, that1.NullableBool[i])
1870 }
1871 }
1872 if len(this.NonnullBool) != len(that1.NonnullBool) {
1873 return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", len(this.NonnullBool), len(that1.NonnullBool))
1874 }
1875 for i := range this.NonnullBool {
1876 a := this.NonnullBool[i]
1877 b := that1.NonnullBool[i]
1878 if a != b {
1879 return fmt.Errorf("NonnullBool this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBool[i], i, that1.NonnullBool[i])
1880 }
1881 }
1882 if len(this.NullableString) != len(that1.NullableString) {
1883 return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", len(this.NullableString), len(that1.NullableString))
1884 }
1885 for i := range this.NullableString {
1886 a := this.NullableString[i]
1887 b := that1.NullableString[i]
1888 if *a != *b {
1889 return fmt.Errorf("NullableString this[%v](%v) Not Equal that[%v](%v)", i, this.NullableString[i], i, that1.NullableString[i])
1890 }
1891 }
1892 if len(this.NonnullString) != len(that1.NonnullString) {
1893 return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", len(this.NonnullString), len(that1.NonnullString))
1894 }
1895 for i := range this.NonnullString {
1896 a := this.NonnullString[i]
1897 b := that1.NonnullString[i]
1898 if a != b {
1899 return fmt.Errorf("NonnullString this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullString[i], i, that1.NonnullString[i])
1900 }
1901 }
1902 if len(this.NullableBytes) != len(that1.NullableBytes) {
1903 return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", len(this.NullableBytes), len(that1.NullableBytes))
1904 }
1905 for i := range this.NullableBytes {
1906 a := this.NullableBytes[i]
1907 b := that1.NullableBytes[i]
1908 if !bytes.Equal(*a, *b) {
1909 return fmt.Errorf("NullableBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBytes[i], i, that1.NullableBytes[i])
1910 }
1911 }
1912 if len(this.NonnullBytes) != len(that1.NonnullBytes) {
1913 return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", len(this.NonnullBytes), len(that1.NonnullBytes))
1914 }
1915 for i := range this.NonnullBytes {
1916 a := this.NonnullBytes[i]
1917 b := that1.NonnullBytes[i]
1918 if !bytes.Equal(a, b) {
1919 return fmt.Errorf("NonnullBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBytes[i], i, that1.NonnullBytes[i])
1920 }
1921 }
1922 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1923 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1924 }
1925 return nil
1926 }
1927 func (this *MapStdTypes) Equal(that interface{}) bool {
1928 if that == nil {
1929 return this == nil
1930 }
1931
1932 that1, ok := that.(*MapStdTypes)
1933 if !ok {
1934 that2, ok := that.(MapStdTypes)
1935 if ok {
1936 that1 = &that2
1937 } else {
1938 return false
1939 }
1940 }
1941 if that1 == nil {
1942 return this == nil
1943 } else if this == nil {
1944 return false
1945 }
1946 if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
1947 return false
1948 }
1949 for i := range this.NullableTimestamp {
1950 if !this.NullableTimestamp[i].Equal(*that1.NullableTimestamp[i]) {
1951 return false
1952 }
1953 }
1954 if len(this.Timestamp) != len(that1.Timestamp) {
1955 return false
1956 }
1957 for i := range this.Timestamp {
1958 if !this.Timestamp[i].Equal(that1.Timestamp[i]) {
1959 return false
1960 }
1961 }
1962 if len(this.NullableDuration) != len(that1.NullableDuration) {
1963 return false
1964 }
1965 for i := range this.NullableDuration {
1966 if dthis, dthat := this.NullableDuration[i], that1.NullableDuration[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
1967 return false
1968 }
1969 }
1970 if len(this.Duration) != len(that1.Duration) {
1971 return false
1972 }
1973 for i := range this.Duration {
1974 if this.Duration[i] != that1.Duration[i] {
1975 return false
1976 }
1977 }
1978 if len(this.NullableDouble) != len(that1.NullableDouble) {
1979 return false
1980 }
1981 for i := range this.NullableDouble {
1982 a := this.NullableDouble[i]
1983 b := that1.NullableDouble[i]
1984 if *a != *b {
1985 return false
1986 }
1987 }
1988 if len(this.NonnullDouble) != len(that1.NonnullDouble) {
1989 return false
1990 }
1991 for i := range this.NonnullDouble {
1992 a := this.NonnullDouble[i]
1993 b := that1.NonnullDouble[i]
1994 if a != b {
1995 return false
1996 }
1997 }
1998 if len(this.NullableFloat) != len(that1.NullableFloat) {
1999 return false
2000 }
2001 for i := range this.NullableFloat {
2002 a := this.NullableFloat[i]
2003 b := that1.NullableFloat[i]
2004 if *a != *b {
2005 return false
2006 }
2007 }
2008 if len(this.NonnullFloat) != len(that1.NonnullFloat) {
2009 return false
2010 }
2011 for i := range this.NonnullFloat {
2012 a := this.NonnullFloat[i]
2013 b := that1.NonnullFloat[i]
2014 if a != b {
2015 return false
2016 }
2017 }
2018 if len(this.NullableInt64) != len(that1.NullableInt64) {
2019 return false
2020 }
2021 for i := range this.NullableInt64 {
2022 a := this.NullableInt64[i]
2023 b := that1.NullableInt64[i]
2024 if *a != *b {
2025 return false
2026 }
2027 }
2028 if len(this.NonnullInt64) != len(that1.NonnullInt64) {
2029 return false
2030 }
2031 for i := range this.NonnullInt64 {
2032 a := this.NonnullInt64[i]
2033 b := that1.NonnullInt64[i]
2034 if a != b {
2035 return false
2036 }
2037 }
2038 if len(this.NullableUInt64) != len(that1.NullableUInt64) {
2039 return false
2040 }
2041 for i := range this.NullableUInt64 {
2042 a := this.NullableUInt64[i]
2043 b := that1.NullableUInt64[i]
2044 if *a != *b {
2045 return false
2046 }
2047 }
2048 if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
2049 return false
2050 }
2051 for i := range this.NonnullUInt64 {
2052 a := this.NonnullUInt64[i]
2053 b := that1.NonnullUInt64[i]
2054 if a != b {
2055 return false
2056 }
2057 }
2058 if len(this.NullableInt32) != len(that1.NullableInt32) {
2059 return false
2060 }
2061 for i := range this.NullableInt32 {
2062 a := this.NullableInt32[i]
2063 b := that1.NullableInt32[i]
2064 if *a != *b {
2065 return false
2066 }
2067 }
2068 if len(this.NonnullInt32) != len(that1.NonnullInt32) {
2069 return false
2070 }
2071 for i := range this.NonnullInt32 {
2072 a := this.NonnullInt32[i]
2073 b := that1.NonnullInt32[i]
2074 if a != b {
2075 return false
2076 }
2077 }
2078 if len(this.NullableUInt32) != len(that1.NullableUInt32) {
2079 return false
2080 }
2081 for i := range this.NullableUInt32 {
2082 a := this.NullableUInt32[i]
2083 b := that1.NullableUInt32[i]
2084 if *a != *b {
2085 return false
2086 }
2087 }
2088 if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
2089 return false
2090 }
2091 for i := range this.NonnullUInt32 {
2092 a := this.NonnullUInt32[i]
2093 b := that1.NonnullUInt32[i]
2094 if a != b {
2095 return false
2096 }
2097 }
2098 if len(this.NullableBool) != len(that1.NullableBool) {
2099 return false
2100 }
2101 for i := range this.NullableBool {
2102 a := this.NullableBool[i]
2103 b := that1.NullableBool[i]
2104 if *a != *b {
2105 return false
2106 }
2107 }
2108 if len(this.NonnullBool) != len(that1.NonnullBool) {
2109 return false
2110 }
2111 for i := range this.NonnullBool {
2112 a := this.NonnullBool[i]
2113 b := that1.NonnullBool[i]
2114 if a != b {
2115 return false
2116 }
2117 }
2118 if len(this.NullableString) != len(that1.NullableString) {
2119 return false
2120 }
2121 for i := range this.NullableString {
2122 a := this.NullableString[i]
2123 b := that1.NullableString[i]
2124 if *a != *b {
2125 return false
2126 }
2127 }
2128 if len(this.NonnullString) != len(that1.NonnullString) {
2129 return false
2130 }
2131 for i := range this.NonnullString {
2132 a := this.NonnullString[i]
2133 b := that1.NonnullString[i]
2134 if a != b {
2135 return false
2136 }
2137 }
2138 if len(this.NullableBytes) != len(that1.NullableBytes) {
2139 return false
2140 }
2141 for i := range this.NullableBytes {
2142 a := this.NullableBytes[i]
2143 b := that1.NullableBytes[i]
2144 if !bytes.Equal(*a, *b) {
2145 return false
2146 }
2147 }
2148 if len(this.NonnullBytes) != len(that1.NonnullBytes) {
2149 return false
2150 }
2151 for i := range this.NonnullBytes {
2152 a := this.NonnullBytes[i]
2153 b := that1.NonnullBytes[i]
2154 if !bytes.Equal(a, b) {
2155 return false
2156 }
2157 }
2158 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2159 return false
2160 }
2161 return true
2162 }
2163 func (this *OneofStdTypes) VerboseEqual(that interface{}) error {
2164 if that == nil {
2165 if this == nil {
2166 return nil
2167 }
2168 return fmt.Errorf("that == nil && this != nil")
2169 }
2170
2171 that1, ok := that.(*OneofStdTypes)
2172 if !ok {
2173 that2, ok := that.(OneofStdTypes)
2174 if ok {
2175 that1 = &that2
2176 } else {
2177 return fmt.Errorf("that is not of type *OneofStdTypes")
2178 }
2179 }
2180 if that1 == nil {
2181 if this == nil {
2182 return nil
2183 }
2184 return fmt.Errorf("that is type *OneofStdTypes but is nil && this != nil")
2185 } else if this == nil {
2186 return fmt.Errorf("that is type *OneofStdTypes but is not nil && this == nil")
2187 }
2188 if that1.OneOfStdTimes == nil {
2189 if this.OneOfStdTimes != nil {
2190 return fmt.Errorf("this.OneOfStdTimes != nil && that1.OneOfStdTimes == nil")
2191 }
2192 } else if this.OneOfStdTimes == nil {
2193 return fmt.Errorf("this.OneOfStdTimes == nil && that1.OneOfStdTimes != nil")
2194 } else if err := this.OneOfStdTimes.VerboseEqual(that1.OneOfStdTimes); err != nil {
2195 return err
2196 }
2197 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2198 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2199 }
2200 return nil
2201 }
2202 func (this *OneofStdTypes_Timestamp) VerboseEqual(that interface{}) error {
2203 if that == nil {
2204 if this == nil {
2205 return nil
2206 }
2207 return fmt.Errorf("that == nil && this != nil")
2208 }
2209
2210 that1, ok := that.(*OneofStdTypes_Timestamp)
2211 if !ok {
2212 that2, ok := that.(OneofStdTypes_Timestamp)
2213 if ok {
2214 that1 = &that2
2215 } else {
2216 return fmt.Errorf("that is not of type *OneofStdTypes_Timestamp")
2217 }
2218 }
2219 if that1 == nil {
2220 if this == nil {
2221 return nil
2222 }
2223 return fmt.Errorf("that is type *OneofStdTypes_Timestamp but is nil && this != nil")
2224 } else if this == nil {
2225 return fmt.Errorf("that is type *OneofStdTypes_Timestamp but is not nil && this == nil")
2226 }
2227 if that1.Timestamp == nil {
2228 if this.Timestamp != nil {
2229 return fmt.Errorf("this.Timestamp != nil && that1.Timestamp == nil")
2230 }
2231 } else if !this.Timestamp.Equal(*that1.Timestamp) {
2232 return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
2233 }
2234 return nil
2235 }
2236 func (this *OneofStdTypes_Duration) VerboseEqual(that interface{}) error {
2237 if that == nil {
2238 if this == nil {
2239 return nil
2240 }
2241 return fmt.Errorf("that == nil && this != nil")
2242 }
2243
2244 that1, ok := that.(*OneofStdTypes_Duration)
2245 if !ok {
2246 that2, ok := that.(OneofStdTypes_Duration)
2247 if ok {
2248 that1 = &that2
2249 } else {
2250 return fmt.Errorf("that is not of type *OneofStdTypes_Duration")
2251 }
2252 }
2253 if that1 == nil {
2254 if this == nil {
2255 return nil
2256 }
2257 return fmt.Errorf("that is type *OneofStdTypes_Duration but is nil && this != nil")
2258 } else if this == nil {
2259 return fmt.Errorf("that is type *OneofStdTypes_Duration but is not nil && this == nil")
2260 }
2261 if this.Duration != nil && that1.Duration != nil {
2262 if *this.Duration != *that1.Duration {
2263 return fmt.Errorf("Duration this(%v) Not Equal that(%v)", *this.Duration, *that1.Duration)
2264 }
2265 } else if this.Duration != nil {
2266 return fmt.Errorf("this.Duration == nil && that.Duration != nil")
2267 } else if that1.Duration != nil {
2268 return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
2269 }
2270 return nil
2271 }
2272 func (this *OneofStdTypes_RepDouble) VerboseEqual(that interface{}) error {
2273 if that == nil {
2274 if this == nil {
2275 return nil
2276 }
2277 return fmt.Errorf("that == nil && this != nil")
2278 }
2279
2280 that1, ok := that.(*OneofStdTypes_RepDouble)
2281 if !ok {
2282 that2, ok := that.(OneofStdTypes_RepDouble)
2283 if ok {
2284 that1 = &that2
2285 } else {
2286 return fmt.Errorf("that is not of type *OneofStdTypes_RepDouble")
2287 }
2288 }
2289 if that1 == nil {
2290 if this == nil {
2291 return nil
2292 }
2293 return fmt.Errorf("that is type *OneofStdTypes_RepDouble but is nil && this != nil")
2294 } else if this == nil {
2295 return fmt.Errorf("that is type *OneofStdTypes_RepDouble but is not nil && this == nil")
2296 }
2297 if this.RepDouble != nil && that1.RepDouble != nil {
2298 if *this.RepDouble != *that1.RepDouble {
2299 return fmt.Errorf("RepDouble this(%v) Not Equal that(%v)", *this.RepDouble, *that1.RepDouble)
2300 }
2301 } else if this.RepDouble != nil {
2302 return fmt.Errorf("this.RepDouble == nil && that.RepDouble != nil")
2303 } else if that1.RepDouble != nil {
2304 return fmt.Errorf("RepDouble this(%v) Not Equal that(%v)", this.RepDouble, that1.RepDouble)
2305 }
2306 return nil
2307 }
2308 func (this *OneofStdTypes_RepFloat) VerboseEqual(that interface{}) error {
2309 if that == nil {
2310 if this == nil {
2311 return nil
2312 }
2313 return fmt.Errorf("that == nil && this != nil")
2314 }
2315
2316 that1, ok := that.(*OneofStdTypes_RepFloat)
2317 if !ok {
2318 that2, ok := that.(OneofStdTypes_RepFloat)
2319 if ok {
2320 that1 = &that2
2321 } else {
2322 return fmt.Errorf("that is not of type *OneofStdTypes_RepFloat")
2323 }
2324 }
2325 if that1 == nil {
2326 if this == nil {
2327 return nil
2328 }
2329 return fmt.Errorf("that is type *OneofStdTypes_RepFloat but is nil && this != nil")
2330 } else if this == nil {
2331 return fmt.Errorf("that is type *OneofStdTypes_RepFloat but is not nil && this == nil")
2332 }
2333 if this.RepFloat != nil && that1.RepFloat != nil {
2334 if *this.RepFloat != *that1.RepFloat {
2335 return fmt.Errorf("RepFloat this(%v) Not Equal that(%v)", *this.RepFloat, *that1.RepFloat)
2336 }
2337 } else if this.RepFloat != nil {
2338 return fmt.Errorf("this.RepFloat == nil && that.RepFloat != nil")
2339 } else if that1.RepFloat != nil {
2340 return fmt.Errorf("RepFloat this(%v) Not Equal that(%v)", this.RepFloat, that1.RepFloat)
2341 }
2342 return nil
2343 }
2344 func (this *OneofStdTypes_RepInt64) VerboseEqual(that interface{}) error {
2345 if that == nil {
2346 if this == nil {
2347 return nil
2348 }
2349 return fmt.Errorf("that == nil && this != nil")
2350 }
2351
2352 that1, ok := that.(*OneofStdTypes_RepInt64)
2353 if !ok {
2354 that2, ok := that.(OneofStdTypes_RepInt64)
2355 if ok {
2356 that1 = &that2
2357 } else {
2358 return fmt.Errorf("that is not of type *OneofStdTypes_RepInt64")
2359 }
2360 }
2361 if that1 == nil {
2362 if this == nil {
2363 return nil
2364 }
2365 return fmt.Errorf("that is type *OneofStdTypes_RepInt64 but is nil && this != nil")
2366 } else if this == nil {
2367 return fmt.Errorf("that is type *OneofStdTypes_RepInt64 but is not nil && this == nil")
2368 }
2369 if this.RepInt64 != nil && that1.RepInt64 != nil {
2370 if *this.RepInt64 != *that1.RepInt64 {
2371 return fmt.Errorf("RepInt64 this(%v) Not Equal that(%v)", *this.RepInt64, *that1.RepInt64)
2372 }
2373 } else if this.RepInt64 != nil {
2374 return fmt.Errorf("this.RepInt64 == nil && that.RepInt64 != nil")
2375 } else if that1.RepInt64 != nil {
2376 return fmt.Errorf("RepInt64 this(%v) Not Equal that(%v)", this.RepInt64, that1.RepInt64)
2377 }
2378 return nil
2379 }
2380 func (this *OneofStdTypes_RepUInt64) VerboseEqual(that interface{}) error {
2381 if that == nil {
2382 if this == nil {
2383 return nil
2384 }
2385 return fmt.Errorf("that == nil && this != nil")
2386 }
2387
2388 that1, ok := that.(*OneofStdTypes_RepUInt64)
2389 if !ok {
2390 that2, ok := that.(OneofStdTypes_RepUInt64)
2391 if ok {
2392 that1 = &that2
2393 } else {
2394 return fmt.Errorf("that is not of type *OneofStdTypes_RepUInt64")
2395 }
2396 }
2397 if that1 == nil {
2398 if this == nil {
2399 return nil
2400 }
2401 return fmt.Errorf("that is type *OneofStdTypes_RepUInt64 but is nil && this != nil")
2402 } else if this == nil {
2403 return fmt.Errorf("that is type *OneofStdTypes_RepUInt64 but is not nil && this == nil")
2404 }
2405 if this.RepUInt64 != nil && that1.RepUInt64 != nil {
2406 if *this.RepUInt64 != *that1.RepUInt64 {
2407 return fmt.Errorf("RepUInt64 this(%v) Not Equal that(%v)", *this.RepUInt64, *that1.RepUInt64)
2408 }
2409 } else if this.RepUInt64 != nil {
2410 return fmt.Errorf("this.RepUInt64 == nil && that.RepUInt64 != nil")
2411 } else if that1.RepUInt64 != nil {
2412 return fmt.Errorf("RepUInt64 this(%v) Not Equal that(%v)", this.RepUInt64, that1.RepUInt64)
2413 }
2414 return nil
2415 }
2416 func (this *OneofStdTypes_RepInt32) VerboseEqual(that interface{}) error {
2417 if that == nil {
2418 if this == nil {
2419 return nil
2420 }
2421 return fmt.Errorf("that == nil && this != nil")
2422 }
2423
2424 that1, ok := that.(*OneofStdTypes_RepInt32)
2425 if !ok {
2426 that2, ok := that.(OneofStdTypes_RepInt32)
2427 if ok {
2428 that1 = &that2
2429 } else {
2430 return fmt.Errorf("that is not of type *OneofStdTypes_RepInt32")
2431 }
2432 }
2433 if that1 == nil {
2434 if this == nil {
2435 return nil
2436 }
2437 return fmt.Errorf("that is type *OneofStdTypes_RepInt32 but is nil && this != nil")
2438 } else if this == nil {
2439 return fmt.Errorf("that is type *OneofStdTypes_RepInt32 but is not nil && this == nil")
2440 }
2441 if this.RepInt32 != nil && that1.RepInt32 != nil {
2442 if *this.RepInt32 != *that1.RepInt32 {
2443 return fmt.Errorf("RepInt32 this(%v) Not Equal that(%v)", *this.RepInt32, *that1.RepInt32)
2444 }
2445 } else if this.RepInt32 != nil {
2446 return fmt.Errorf("this.RepInt32 == nil && that.RepInt32 != nil")
2447 } else if that1.RepInt32 != nil {
2448 return fmt.Errorf("RepInt32 this(%v) Not Equal that(%v)", this.RepInt32, that1.RepInt32)
2449 }
2450 return nil
2451 }
2452 func (this *OneofStdTypes_RepUInt32) VerboseEqual(that interface{}) error {
2453 if that == nil {
2454 if this == nil {
2455 return nil
2456 }
2457 return fmt.Errorf("that == nil && this != nil")
2458 }
2459
2460 that1, ok := that.(*OneofStdTypes_RepUInt32)
2461 if !ok {
2462 that2, ok := that.(OneofStdTypes_RepUInt32)
2463 if ok {
2464 that1 = &that2
2465 } else {
2466 return fmt.Errorf("that is not of type *OneofStdTypes_RepUInt32")
2467 }
2468 }
2469 if that1 == nil {
2470 if this == nil {
2471 return nil
2472 }
2473 return fmt.Errorf("that is type *OneofStdTypes_RepUInt32 but is nil && this != nil")
2474 } else if this == nil {
2475 return fmt.Errorf("that is type *OneofStdTypes_RepUInt32 but is not nil && this == nil")
2476 }
2477 if this.RepUInt32 != nil && that1.RepUInt32 != nil {
2478 if *this.RepUInt32 != *that1.RepUInt32 {
2479 return fmt.Errorf("RepUInt32 this(%v) Not Equal that(%v)", *this.RepUInt32, *that1.RepUInt32)
2480 }
2481 } else if this.RepUInt32 != nil {
2482 return fmt.Errorf("this.RepUInt32 == nil && that.RepUInt32 != nil")
2483 } else if that1.RepUInt32 != nil {
2484 return fmt.Errorf("RepUInt32 this(%v) Not Equal that(%v)", this.RepUInt32, that1.RepUInt32)
2485 }
2486 return nil
2487 }
2488 func (this *OneofStdTypes_RepBool) VerboseEqual(that interface{}) error {
2489 if that == nil {
2490 if this == nil {
2491 return nil
2492 }
2493 return fmt.Errorf("that == nil && this != nil")
2494 }
2495
2496 that1, ok := that.(*OneofStdTypes_RepBool)
2497 if !ok {
2498 that2, ok := that.(OneofStdTypes_RepBool)
2499 if ok {
2500 that1 = &that2
2501 } else {
2502 return fmt.Errorf("that is not of type *OneofStdTypes_RepBool")
2503 }
2504 }
2505 if that1 == nil {
2506 if this == nil {
2507 return nil
2508 }
2509 return fmt.Errorf("that is type *OneofStdTypes_RepBool but is nil && this != nil")
2510 } else if this == nil {
2511 return fmt.Errorf("that is type *OneofStdTypes_RepBool but is not nil && this == nil")
2512 }
2513 if this.RepBool != nil && that1.RepBool != nil {
2514 if *this.RepBool != *that1.RepBool {
2515 return fmt.Errorf("RepBool this(%v) Not Equal that(%v)", *this.RepBool, *that1.RepBool)
2516 }
2517 } else if this.RepBool != nil {
2518 return fmt.Errorf("this.RepBool == nil && that.RepBool != nil")
2519 } else if that1.RepBool != nil {
2520 return fmt.Errorf("RepBool this(%v) Not Equal that(%v)", this.RepBool, that1.RepBool)
2521 }
2522 return nil
2523 }
2524 func (this *OneofStdTypes_RepString) VerboseEqual(that interface{}) error {
2525 if that == nil {
2526 if this == nil {
2527 return nil
2528 }
2529 return fmt.Errorf("that == nil && this != nil")
2530 }
2531
2532 that1, ok := that.(*OneofStdTypes_RepString)
2533 if !ok {
2534 that2, ok := that.(OneofStdTypes_RepString)
2535 if ok {
2536 that1 = &that2
2537 } else {
2538 return fmt.Errorf("that is not of type *OneofStdTypes_RepString")
2539 }
2540 }
2541 if that1 == nil {
2542 if this == nil {
2543 return nil
2544 }
2545 return fmt.Errorf("that is type *OneofStdTypes_RepString but is nil && this != nil")
2546 } else if this == nil {
2547 return fmt.Errorf("that is type *OneofStdTypes_RepString but is not nil && this == nil")
2548 }
2549 if this.RepString != nil && that1.RepString != nil {
2550 if *this.RepString != *that1.RepString {
2551 return fmt.Errorf("RepString this(%v) Not Equal that(%v)", *this.RepString, *that1.RepString)
2552 }
2553 } else if this.RepString != nil {
2554 return fmt.Errorf("this.RepString == nil && that.RepString != nil")
2555 } else if that1.RepString != nil {
2556 return fmt.Errorf("RepString this(%v) Not Equal that(%v)", this.RepString, that1.RepString)
2557 }
2558 return nil
2559 }
2560 func (this *OneofStdTypes_RepBytes) VerboseEqual(that interface{}) error {
2561 if that == nil {
2562 if this == nil {
2563 return nil
2564 }
2565 return fmt.Errorf("that == nil && this != nil")
2566 }
2567
2568 that1, ok := that.(*OneofStdTypes_RepBytes)
2569 if !ok {
2570 that2, ok := that.(OneofStdTypes_RepBytes)
2571 if ok {
2572 that1 = &that2
2573 } else {
2574 return fmt.Errorf("that is not of type *OneofStdTypes_RepBytes")
2575 }
2576 }
2577 if that1 == nil {
2578 if this == nil {
2579 return nil
2580 }
2581 return fmt.Errorf("that is type *OneofStdTypes_RepBytes but is nil && this != nil")
2582 } else if this == nil {
2583 return fmt.Errorf("that is type *OneofStdTypes_RepBytes but is not nil && this == nil")
2584 }
2585 if that1.RepBytes == nil {
2586 if this.RepBytes != nil {
2587 return fmt.Errorf("this.RepBytes != nil && that1.RepBytes == nil")
2588 }
2589 } else if !bytes.Equal(*this.RepBytes, *that1.RepBytes) {
2590 return fmt.Errorf("RepBytes this(%v) Not Equal that(%v)", this.RepBytes, that1.RepBytes)
2591 }
2592 return nil
2593 }
2594 func (this *OneofStdTypes) Equal(that interface{}) bool {
2595 if that == nil {
2596 return this == nil
2597 }
2598
2599 that1, ok := that.(*OneofStdTypes)
2600 if !ok {
2601 that2, ok := that.(OneofStdTypes)
2602 if ok {
2603 that1 = &that2
2604 } else {
2605 return false
2606 }
2607 }
2608 if that1 == nil {
2609 return this == nil
2610 } else if this == nil {
2611 return false
2612 }
2613 if that1.OneOfStdTimes == nil {
2614 if this.OneOfStdTimes != nil {
2615 return false
2616 }
2617 } else if this.OneOfStdTimes == nil {
2618 return false
2619 } else if !this.OneOfStdTimes.Equal(that1.OneOfStdTimes) {
2620 return false
2621 }
2622 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2623 return false
2624 }
2625 return true
2626 }
2627 func (this *OneofStdTypes_Timestamp) Equal(that interface{}) bool {
2628 if that == nil {
2629 return this == nil
2630 }
2631
2632 that1, ok := that.(*OneofStdTypes_Timestamp)
2633 if !ok {
2634 that2, ok := that.(OneofStdTypes_Timestamp)
2635 if ok {
2636 that1 = &that2
2637 } else {
2638 return false
2639 }
2640 }
2641 if that1 == nil {
2642 return this == nil
2643 } else if this == nil {
2644 return false
2645 }
2646 if that1.Timestamp == nil {
2647 if this.Timestamp != nil {
2648 return false
2649 }
2650 } else if !this.Timestamp.Equal(*that1.Timestamp) {
2651 return false
2652 }
2653 return true
2654 }
2655 func (this *OneofStdTypes_Duration) Equal(that interface{}) bool {
2656 if that == nil {
2657 return this == nil
2658 }
2659
2660 that1, ok := that.(*OneofStdTypes_Duration)
2661 if !ok {
2662 that2, ok := that.(OneofStdTypes_Duration)
2663 if ok {
2664 that1 = &that2
2665 } else {
2666 return false
2667 }
2668 }
2669 if that1 == nil {
2670 return this == nil
2671 } else if this == nil {
2672 return false
2673 }
2674 if this.Duration != nil && that1.Duration != nil {
2675 if *this.Duration != *that1.Duration {
2676 return false
2677 }
2678 } else if this.Duration != nil {
2679 return false
2680 } else if that1.Duration != nil {
2681 return false
2682 }
2683 return true
2684 }
2685 func (this *OneofStdTypes_RepDouble) Equal(that interface{}) bool {
2686 if that == nil {
2687 return this == nil
2688 }
2689
2690 that1, ok := that.(*OneofStdTypes_RepDouble)
2691 if !ok {
2692 that2, ok := that.(OneofStdTypes_RepDouble)
2693 if ok {
2694 that1 = &that2
2695 } else {
2696 return false
2697 }
2698 }
2699 if that1 == nil {
2700 return this == nil
2701 } else if this == nil {
2702 return false
2703 }
2704 if this.RepDouble != nil && that1.RepDouble != nil {
2705 if *this.RepDouble != *that1.RepDouble {
2706 return false
2707 }
2708 } else if this.RepDouble != nil {
2709 return false
2710 } else if that1.RepDouble != nil {
2711 return false
2712 }
2713 return true
2714 }
2715 func (this *OneofStdTypes_RepFloat) Equal(that interface{}) bool {
2716 if that == nil {
2717 return this == nil
2718 }
2719
2720 that1, ok := that.(*OneofStdTypes_RepFloat)
2721 if !ok {
2722 that2, ok := that.(OneofStdTypes_RepFloat)
2723 if ok {
2724 that1 = &that2
2725 } else {
2726 return false
2727 }
2728 }
2729 if that1 == nil {
2730 return this == nil
2731 } else if this == nil {
2732 return false
2733 }
2734 if this.RepFloat != nil && that1.RepFloat != nil {
2735 if *this.RepFloat != *that1.RepFloat {
2736 return false
2737 }
2738 } else if this.RepFloat != nil {
2739 return false
2740 } else if that1.RepFloat != nil {
2741 return false
2742 }
2743 return true
2744 }
2745 func (this *OneofStdTypes_RepInt64) Equal(that interface{}) bool {
2746 if that == nil {
2747 return this == nil
2748 }
2749
2750 that1, ok := that.(*OneofStdTypes_RepInt64)
2751 if !ok {
2752 that2, ok := that.(OneofStdTypes_RepInt64)
2753 if ok {
2754 that1 = &that2
2755 } else {
2756 return false
2757 }
2758 }
2759 if that1 == nil {
2760 return this == nil
2761 } else if this == nil {
2762 return false
2763 }
2764 if this.RepInt64 != nil && that1.RepInt64 != nil {
2765 if *this.RepInt64 != *that1.RepInt64 {
2766 return false
2767 }
2768 } else if this.RepInt64 != nil {
2769 return false
2770 } else if that1.RepInt64 != nil {
2771 return false
2772 }
2773 return true
2774 }
2775 func (this *OneofStdTypes_RepUInt64) Equal(that interface{}) bool {
2776 if that == nil {
2777 return this == nil
2778 }
2779
2780 that1, ok := that.(*OneofStdTypes_RepUInt64)
2781 if !ok {
2782 that2, ok := that.(OneofStdTypes_RepUInt64)
2783 if ok {
2784 that1 = &that2
2785 } else {
2786 return false
2787 }
2788 }
2789 if that1 == nil {
2790 return this == nil
2791 } else if this == nil {
2792 return false
2793 }
2794 if this.RepUInt64 != nil && that1.RepUInt64 != nil {
2795 if *this.RepUInt64 != *that1.RepUInt64 {
2796 return false
2797 }
2798 } else if this.RepUInt64 != nil {
2799 return false
2800 } else if that1.RepUInt64 != nil {
2801 return false
2802 }
2803 return true
2804 }
2805 func (this *OneofStdTypes_RepInt32) Equal(that interface{}) bool {
2806 if that == nil {
2807 return this == nil
2808 }
2809
2810 that1, ok := that.(*OneofStdTypes_RepInt32)
2811 if !ok {
2812 that2, ok := that.(OneofStdTypes_RepInt32)
2813 if ok {
2814 that1 = &that2
2815 } else {
2816 return false
2817 }
2818 }
2819 if that1 == nil {
2820 return this == nil
2821 } else if this == nil {
2822 return false
2823 }
2824 if this.RepInt32 != nil && that1.RepInt32 != nil {
2825 if *this.RepInt32 != *that1.RepInt32 {
2826 return false
2827 }
2828 } else if this.RepInt32 != nil {
2829 return false
2830 } else if that1.RepInt32 != nil {
2831 return false
2832 }
2833 return true
2834 }
2835 func (this *OneofStdTypes_RepUInt32) Equal(that interface{}) bool {
2836 if that == nil {
2837 return this == nil
2838 }
2839
2840 that1, ok := that.(*OneofStdTypes_RepUInt32)
2841 if !ok {
2842 that2, ok := that.(OneofStdTypes_RepUInt32)
2843 if ok {
2844 that1 = &that2
2845 } else {
2846 return false
2847 }
2848 }
2849 if that1 == nil {
2850 return this == nil
2851 } else if this == nil {
2852 return false
2853 }
2854 if this.RepUInt32 != nil && that1.RepUInt32 != nil {
2855 if *this.RepUInt32 != *that1.RepUInt32 {
2856 return false
2857 }
2858 } else if this.RepUInt32 != nil {
2859 return false
2860 } else if that1.RepUInt32 != nil {
2861 return false
2862 }
2863 return true
2864 }
2865 func (this *OneofStdTypes_RepBool) Equal(that interface{}) bool {
2866 if that == nil {
2867 return this == nil
2868 }
2869
2870 that1, ok := that.(*OneofStdTypes_RepBool)
2871 if !ok {
2872 that2, ok := that.(OneofStdTypes_RepBool)
2873 if ok {
2874 that1 = &that2
2875 } else {
2876 return false
2877 }
2878 }
2879 if that1 == nil {
2880 return this == nil
2881 } else if this == nil {
2882 return false
2883 }
2884 if this.RepBool != nil && that1.RepBool != nil {
2885 if *this.RepBool != *that1.RepBool {
2886 return false
2887 }
2888 } else if this.RepBool != nil {
2889 return false
2890 } else if that1.RepBool != nil {
2891 return false
2892 }
2893 return true
2894 }
2895 func (this *OneofStdTypes_RepString) Equal(that interface{}) bool {
2896 if that == nil {
2897 return this == nil
2898 }
2899
2900 that1, ok := that.(*OneofStdTypes_RepString)
2901 if !ok {
2902 that2, ok := that.(OneofStdTypes_RepString)
2903 if ok {
2904 that1 = &that2
2905 } else {
2906 return false
2907 }
2908 }
2909 if that1 == nil {
2910 return this == nil
2911 } else if this == nil {
2912 return false
2913 }
2914 if this.RepString != nil && that1.RepString != nil {
2915 if *this.RepString != *that1.RepString {
2916 return false
2917 }
2918 } else if this.RepString != nil {
2919 return false
2920 } else if that1.RepString != nil {
2921 return false
2922 }
2923 return true
2924 }
2925 func (this *OneofStdTypes_RepBytes) Equal(that interface{}) bool {
2926 if that == nil {
2927 return this == nil
2928 }
2929
2930 that1, ok := that.(*OneofStdTypes_RepBytes)
2931 if !ok {
2932 that2, ok := that.(OneofStdTypes_RepBytes)
2933 if ok {
2934 that1 = &that2
2935 } else {
2936 return false
2937 }
2938 }
2939 if that1 == nil {
2940 return this == nil
2941 } else if this == nil {
2942 return false
2943 }
2944 if that1.RepBytes == nil {
2945 if this.RepBytes != nil {
2946 return false
2947 }
2948 } else if !bytes.Equal(*this.RepBytes, *that1.RepBytes) {
2949 return false
2950 }
2951 return true
2952 }
2953 func (this *StdTypes) GoString() string {
2954 if this == nil {
2955 return "nil"
2956 }
2957 s := make([]string, 0, 26)
2958 s = append(s, "&stdtypes.StdTypes{")
2959 s = append(s, "NullableTimestamp: "+fmt.Sprintf("%#v", this.NullableTimestamp)+",\n")
2960 s = append(s, "NullableDuration: "+fmt.Sprintf("%#v", this.NullableDuration)+",\n")
2961 s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
2962 s = append(s, "Duration: "+fmt.Sprintf("%#v", this.Duration)+",\n")
2963 s = append(s, "NullableDouble: "+fmt.Sprintf("%#v", this.NullableDouble)+",\n")
2964 s = append(s, "NonnullDouble: "+fmt.Sprintf("%#v", this.NonnullDouble)+",\n")
2965 s = append(s, "NullableFloat: "+fmt.Sprintf("%#v", this.NullableFloat)+",\n")
2966 s = append(s, "NonnullFloat: "+fmt.Sprintf("%#v", this.NonnullFloat)+",\n")
2967 s = append(s, "NullableInt64: "+fmt.Sprintf("%#v", this.NullableInt64)+",\n")
2968 s = append(s, "NonnullInt64: "+fmt.Sprintf("%#v", this.NonnullInt64)+",\n")
2969 s = append(s, "NullableUInt64: "+fmt.Sprintf("%#v", this.NullableUInt64)+",\n")
2970 s = append(s, "NonnullUInt64: "+fmt.Sprintf("%#v", this.NonnullUInt64)+",\n")
2971 s = append(s, "NullableInt32: "+fmt.Sprintf("%#v", this.NullableInt32)+",\n")
2972 s = append(s, "NonnullInt32: "+fmt.Sprintf("%#v", this.NonnullInt32)+",\n")
2973 s = append(s, "NullableUInt32: "+fmt.Sprintf("%#v", this.NullableUInt32)+",\n")
2974 s = append(s, "NonnullUInt32: "+fmt.Sprintf("%#v", this.NonnullUInt32)+",\n")
2975 s = append(s, "NullableBool: "+fmt.Sprintf("%#v", this.NullableBool)+",\n")
2976 s = append(s, "NonnullBool: "+fmt.Sprintf("%#v", this.NonnullBool)+",\n")
2977 s = append(s, "NullableString: "+fmt.Sprintf("%#v", this.NullableString)+",\n")
2978 s = append(s, "NonnullString: "+fmt.Sprintf("%#v", this.NonnullString)+",\n")
2979 s = append(s, "NullableBytes: "+fmt.Sprintf("%#v", this.NullableBytes)+",\n")
2980 s = append(s, "NonnullBytes: "+fmt.Sprintf("%#v", this.NonnullBytes)+",\n")
2981 if this.XXX_unrecognized != nil {
2982 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2983 }
2984 s = append(s, "}")
2985 return strings.Join(s, "")
2986 }
2987 func (this *RepStdTypes) GoString() string {
2988 if this == nil {
2989 return "nil"
2990 }
2991 s := make([]string, 0, 26)
2992 s = append(s, "&stdtypes.RepStdTypes{")
2993 s = append(s, "NullableTimestamps: "+fmt.Sprintf("%#v", this.NullableTimestamps)+",\n")
2994 s = append(s, "NullableDurations: "+fmt.Sprintf("%#v", this.NullableDurations)+",\n")
2995 s = append(s, "Timestamps: "+fmt.Sprintf("%#v", this.Timestamps)+",\n")
2996 s = append(s, "Durations: "+fmt.Sprintf("%#v", this.Durations)+",\n")
2997 s = append(s, "NullableDouble: "+fmt.Sprintf("%#v", this.NullableDouble)+",\n")
2998 s = append(s, "NonnullDouble: "+fmt.Sprintf("%#v", this.NonnullDouble)+",\n")
2999 s = append(s, "NullableFloat: "+fmt.Sprintf("%#v", this.NullableFloat)+",\n")
3000 s = append(s, "NonnullFloat: "+fmt.Sprintf("%#v", this.NonnullFloat)+",\n")
3001 s = append(s, "NullableInt64: "+fmt.Sprintf("%#v", this.NullableInt64)+",\n")
3002 s = append(s, "NonnullInt64: "+fmt.Sprintf("%#v", this.NonnullInt64)+",\n")
3003 s = append(s, "NullableUInt64: "+fmt.Sprintf("%#v", this.NullableUInt64)+",\n")
3004 s = append(s, "NonnullUInt64: "+fmt.Sprintf("%#v", this.NonnullUInt64)+",\n")
3005 s = append(s, "NullableInt32: "+fmt.Sprintf("%#v", this.NullableInt32)+",\n")
3006 s = append(s, "NonnullInt32: "+fmt.Sprintf("%#v", this.NonnullInt32)+",\n")
3007 s = append(s, "NullableUInt32: "+fmt.Sprintf("%#v", this.NullableUInt32)+",\n")
3008 s = append(s, "NonnullUInt32: "+fmt.Sprintf("%#v", this.NonnullUInt32)+",\n")
3009 s = append(s, "NullableBool: "+fmt.Sprintf("%#v", this.NullableBool)+",\n")
3010 s = append(s, "NonnullBool: "+fmt.Sprintf("%#v", this.NonnullBool)+",\n")
3011 s = append(s, "NullableString: "+fmt.Sprintf("%#v", this.NullableString)+",\n")
3012 s = append(s, "NonnullString: "+fmt.Sprintf("%#v", this.NonnullString)+",\n")
3013 s = append(s, "NullableBytes: "+fmt.Sprintf("%#v", this.NullableBytes)+",\n")
3014 s = append(s, "NonnullBytes: "+fmt.Sprintf("%#v", this.NonnullBytes)+",\n")
3015 if this.XXX_unrecognized != nil {
3016 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3017 }
3018 s = append(s, "}")
3019 return strings.Join(s, "")
3020 }
3021 func (this *MapStdTypes) GoString() string {
3022 if this == nil {
3023 return "nil"
3024 }
3025 s := make([]string, 0, 26)
3026 s = append(s, "&stdtypes.MapStdTypes{")
3027 keysForNullableTimestamp := make([]int32, 0, len(this.NullableTimestamp))
3028 for k := range this.NullableTimestamp {
3029 keysForNullableTimestamp = append(keysForNullableTimestamp, k)
3030 }
3031 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableTimestamp)
3032 mapStringForNullableTimestamp := "map[int32]*time.Time{"
3033 for _, k := range keysForNullableTimestamp {
3034 mapStringForNullableTimestamp += fmt.Sprintf("%#v: %#v,", k, this.NullableTimestamp[k])
3035 }
3036 mapStringForNullableTimestamp += "}"
3037 if this.NullableTimestamp != nil {
3038 s = append(s, "NullableTimestamp: "+mapStringForNullableTimestamp+",\n")
3039 }
3040 keysForTimestamp := make([]int32, 0, len(this.Timestamp))
3041 for k := range this.Timestamp {
3042 keysForTimestamp = append(keysForTimestamp, k)
3043 }
3044 github_com_gogo_protobuf_sortkeys.Int32s(keysForTimestamp)
3045 mapStringForTimestamp := "map[int32]time.Time{"
3046 for _, k := range keysForTimestamp {
3047 mapStringForTimestamp += fmt.Sprintf("%#v: %#v,", k, this.Timestamp[k])
3048 }
3049 mapStringForTimestamp += "}"
3050 if this.Timestamp != nil {
3051 s = append(s, "Timestamp: "+mapStringForTimestamp+",\n")
3052 }
3053 keysForNullableDuration := make([]int32, 0, len(this.NullableDuration))
3054 for k := range this.NullableDuration {
3055 keysForNullableDuration = append(keysForNullableDuration, k)
3056 }
3057 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableDuration)
3058 mapStringForNullableDuration := "map[int32]*time.Duration{"
3059 for _, k := range keysForNullableDuration {
3060 mapStringForNullableDuration += fmt.Sprintf("%#v: %#v,", k, this.NullableDuration[k])
3061 }
3062 mapStringForNullableDuration += "}"
3063 if this.NullableDuration != nil {
3064 s = append(s, "NullableDuration: "+mapStringForNullableDuration+",\n")
3065 }
3066 keysForDuration := make([]int32, 0, len(this.Duration))
3067 for k := range this.Duration {
3068 keysForDuration = append(keysForDuration, k)
3069 }
3070 github_com_gogo_protobuf_sortkeys.Int32s(keysForDuration)
3071 mapStringForDuration := "map[int32]time.Duration{"
3072 for _, k := range keysForDuration {
3073 mapStringForDuration += fmt.Sprintf("%#v: %#v,", k, this.Duration[k])
3074 }
3075 mapStringForDuration += "}"
3076 if this.Duration != nil {
3077 s = append(s, "Duration: "+mapStringForDuration+",\n")
3078 }
3079 keysForNullableDouble := make([]int32, 0, len(this.NullableDouble))
3080 for k := range this.NullableDouble {
3081 keysForNullableDouble = append(keysForNullableDouble, k)
3082 }
3083 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableDouble)
3084 mapStringForNullableDouble := "map[int32]*float64{"
3085 for _, k := range keysForNullableDouble {
3086 mapStringForNullableDouble += fmt.Sprintf("%#v: %#v,", k, this.NullableDouble[k])
3087 }
3088 mapStringForNullableDouble += "}"
3089 if this.NullableDouble != nil {
3090 s = append(s, "NullableDouble: "+mapStringForNullableDouble+",\n")
3091 }
3092 keysForNonnullDouble := make([]int32, 0, len(this.NonnullDouble))
3093 for k := range this.NonnullDouble {
3094 keysForNonnullDouble = append(keysForNonnullDouble, k)
3095 }
3096 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullDouble)
3097 mapStringForNonnullDouble := "map[int32]float64{"
3098 for _, k := range keysForNonnullDouble {
3099 mapStringForNonnullDouble += fmt.Sprintf("%#v: %#v,", k, this.NonnullDouble[k])
3100 }
3101 mapStringForNonnullDouble += "}"
3102 if this.NonnullDouble != nil {
3103 s = append(s, "NonnullDouble: "+mapStringForNonnullDouble+",\n")
3104 }
3105 keysForNullableFloat := make([]int32, 0, len(this.NullableFloat))
3106 for k := range this.NullableFloat {
3107 keysForNullableFloat = append(keysForNullableFloat, k)
3108 }
3109 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableFloat)
3110 mapStringForNullableFloat := "map[int32]*float32{"
3111 for _, k := range keysForNullableFloat {
3112 mapStringForNullableFloat += fmt.Sprintf("%#v: %#v,", k, this.NullableFloat[k])
3113 }
3114 mapStringForNullableFloat += "}"
3115 if this.NullableFloat != nil {
3116 s = append(s, "NullableFloat: "+mapStringForNullableFloat+",\n")
3117 }
3118 keysForNonnullFloat := make([]int32, 0, len(this.NonnullFloat))
3119 for k := range this.NonnullFloat {
3120 keysForNonnullFloat = append(keysForNonnullFloat, k)
3121 }
3122 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullFloat)
3123 mapStringForNonnullFloat := "map[int32]float32{"
3124 for _, k := range keysForNonnullFloat {
3125 mapStringForNonnullFloat += fmt.Sprintf("%#v: %#v,", k, this.NonnullFloat[k])
3126 }
3127 mapStringForNonnullFloat += "}"
3128 if this.NonnullFloat != nil {
3129 s = append(s, "NonnullFloat: "+mapStringForNonnullFloat+",\n")
3130 }
3131 keysForNullableInt64 := make([]int32, 0, len(this.NullableInt64))
3132 for k := range this.NullableInt64 {
3133 keysForNullableInt64 = append(keysForNullableInt64, k)
3134 }
3135 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableInt64)
3136 mapStringForNullableInt64 := "map[int32]*int64{"
3137 for _, k := range keysForNullableInt64 {
3138 mapStringForNullableInt64 += fmt.Sprintf("%#v: %#v,", k, this.NullableInt64[k])
3139 }
3140 mapStringForNullableInt64 += "}"
3141 if this.NullableInt64 != nil {
3142 s = append(s, "NullableInt64: "+mapStringForNullableInt64+",\n")
3143 }
3144 keysForNonnullInt64 := make([]int32, 0, len(this.NonnullInt64))
3145 for k := range this.NonnullInt64 {
3146 keysForNonnullInt64 = append(keysForNonnullInt64, k)
3147 }
3148 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullInt64)
3149 mapStringForNonnullInt64 := "map[int32]int64{"
3150 for _, k := range keysForNonnullInt64 {
3151 mapStringForNonnullInt64 += fmt.Sprintf("%#v: %#v,", k, this.NonnullInt64[k])
3152 }
3153 mapStringForNonnullInt64 += "}"
3154 if this.NonnullInt64 != nil {
3155 s = append(s, "NonnullInt64: "+mapStringForNonnullInt64+",\n")
3156 }
3157 keysForNullableUInt64 := make([]int32, 0, len(this.NullableUInt64))
3158 for k := range this.NullableUInt64 {
3159 keysForNullableUInt64 = append(keysForNullableUInt64, k)
3160 }
3161 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableUInt64)
3162 mapStringForNullableUInt64 := "map[int32]*uint64{"
3163 for _, k := range keysForNullableUInt64 {
3164 mapStringForNullableUInt64 += fmt.Sprintf("%#v: %#v,", k, this.NullableUInt64[k])
3165 }
3166 mapStringForNullableUInt64 += "}"
3167 if this.NullableUInt64 != nil {
3168 s = append(s, "NullableUInt64: "+mapStringForNullableUInt64+",\n")
3169 }
3170 keysForNonnullUInt64 := make([]int32, 0, len(this.NonnullUInt64))
3171 for k := range this.NonnullUInt64 {
3172 keysForNonnullUInt64 = append(keysForNonnullUInt64, k)
3173 }
3174 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullUInt64)
3175 mapStringForNonnullUInt64 := "map[int32]uint64{"
3176 for _, k := range keysForNonnullUInt64 {
3177 mapStringForNonnullUInt64 += fmt.Sprintf("%#v: %#v,", k, this.NonnullUInt64[k])
3178 }
3179 mapStringForNonnullUInt64 += "}"
3180 if this.NonnullUInt64 != nil {
3181 s = append(s, "NonnullUInt64: "+mapStringForNonnullUInt64+",\n")
3182 }
3183 keysForNullableInt32 := make([]int32, 0, len(this.NullableInt32))
3184 for k := range this.NullableInt32 {
3185 keysForNullableInt32 = append(keysForNullableInt32, k)
3186 }
3187 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableInt32)
3188 mapStringForNullableInt32 := "map[int32]*int32{"
3189 for _, k := range keysForNullableInt32 {
3190 mapStringForNullableInt32 += fmt.Sprintf("%#v: %#v,", k, this.NullableInt32[k])
3191 }
3192 mapStringForNullableInt32 += "}"
3193 if this.NullableInt32 != nil {
3194 s = append(s, "NullableInt32: "+mapStringForNullableInt32+",\n")
3195 }
3196 keysForNonnullInt32 := make([]int32, 0, len(this.NonnullInt32))
3197 for k := range this.NonnullInt32 {
3198 keysForNonnullInt32 = append(keysForNonnullInt32, k)
3199 }
3200 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullInt32)
3201 mapStringForNonnullInt32 := "map[int32]int32{"
3202 for _, k := range keysForNonnullInt32 {
3203 mapStringForNonnullInt32 += fmt.Sprintf("%#v: %#v,", k, this.NonnullInt32[k])
3204 }
3205 mapStringForNonnullInt32 += "}"
3206 if this.NonnullInt32 != nil {
3207 s = append(s, "NonnullInt32: "+mapStringForNonnullInt32+",\n")
3208 }
3209 keysForNullableUInt32 := make([]int32, 0, len(this.NullableUInt32))
3210 for k := range this.NullableUInt32 {
3211 keysForNullableUInt32 = append(keysForNullableUInt32, k)
3212 }
3213 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableUInt32)
3214 mapStringForNullableUInt32 := "map[int32]*uint32{"
3215 for _, k := range keysForNullableUInt32 {
3216 mapStringForNullableUInt32 += fmt.Sprintf("%#v: %#v,", k, this.NullableUInt32[k])
3217 }
3218 mapStringForNullableUInt32 += "}"
3219 if this.NullableUInt32 != nil {
3220 s = append(s, "NullableUInt32: "+mapStringForNullableUInt32+",\n")
3221 }
3222 keysForNonnullUInt32 := make([]int32, 0, len(this.NonnullUInt32))
3223 for k := range this.NonnullUInt32 {
3224 keysForNonnullUInt32 = append(keysForNonnullUInt32, k)
3225 }
3226 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullUInt32)
3227 mapStringForNonnullUInt32 := "map[int32]uint32{"
3228 for _, k := range keysForNonnullUInt32 {
3229 mapStringForNonnullUInt32 += fmt.Sprintf("%#v: %#v,", k, this.NonnullUInt32[k])
3230 }
3231 mapStringForNonnullUInt32 += "}"
3232 if this.NonnullUInt32 != nil {
3233 s = append(s, "NonnullUInt32: "+mapStringForNonnullUInt32+",\n")
3234 }
3235 keysForNullableBool := make([]int32, 0, len(this.NullableBool))
3236 for k := range this.NullableBool {
3237 keysForNullableBool = append(keysForNullableBool, k)
3238 }
3239 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableBool)
3240 mapStringForNullableBool := "map[int32]*bool{"
3241 for _, k := range keysForNullableBool {
3242 mapStringForNullableBool += fmt.Sprintf("%#v: %#v,", k, this.NullableBool[k])
3243 }
3244 mapStringForNullableBool += "}"
3245 if this.NullableBool != nil {
3246 s = append(s, "NullableBool: "+mapStringForNullableBool+",\n")
3247 }
3248 keysForNonnullBool := make([]int32, 0, len(this.NonnullBool))
3249 for k := range this.NonnullBool {
3250 keysForNonnullBool = append(keysForNonnullBool, k)
3251 }
3252 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullBool)
3253 mapStringForNonnullBool := "map[int32]bool{"
3254 for _, k := range keysForNonnullBool {
3255 mapStringForNonnullBool += fmt.Sprintf("%#v: %#v,", k, this.NonnullBool[k])
3256 }
3257 mapStringForNonnullBool += "}"
3258 if this.NonnullBool != nil {
3259 s = append(s, "NonnullBool: "+mapStringForNonnullBool+",\n")
3260 }
3261 keysForNullableString := make([]int32, 0, len(this.NullableString))
3262 for k := range this.NullableString {
3263 keysForNullableString = append(keysForNullableString, k)
3264 }
3265 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableString)
3266 mapStringForNullableString := "map[int32]*string{"
3267 for _, k := range keysForNullableString {
3268 mapStringForNullableString += fmt.Sprintf("%#v: %#v,", k, this.NullableString[k])
3269 }
3270 mapStringForNullableString += "}"
3271 if this.NullableString != nil {
3272 s = append(s, "NullableString: "+mapStringForNullableString+",\n")
3273 }
3274 keysForNonnullString := make([]int32, 0, len(this.NonnullString))
3275 for k := range this.NonnullString {
3276 keysForNonnullString = append(keysForNonnullString, k)
3277 }
3278 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullString)
3279 mapStringForNonnullString := "map[int32]string{"
3280 for _, k := range keysForNonnullString {
3281 mapStringForNonnullString += fmt.Sprintf("%#v: %#v,", k, this.NonnullString[k])
3282 }
3283 mapStringForNonnullString += "}"
3284 if this.NonnullString != nil {
3285 s = append(s, "NonnullString: "+mapStringForNonnullString+",\n")
3286 }
3287 keysForNullableBytes := make([]int32, 0, len(this.NullableBytes))
3288 for k := range this.NullableBytes {
3289 keysForNullableBytes = append(keysForNullableBytes, k)
3290 }
3291 github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableBytes)
3292 mapStringForNullableBytes := "map[int32]*[]byte{"
3293 for _, k := range keysForNullableBytes {
3294 mapStringForNullableBytes += fmt.Sprintf("%#v: %#v,", k, this.NullableBytes[k])
3295 }
3296 mapStringForNullableBytes += "}"
3297 if this.NullableBytes != nil {
3298 s = append(s, "NullableBytes: "+mapStringForNullableBytes+",\n")
3299 }
3300 keysForNonnullBytes := make([]int32, 0, len(this.NonnullBytes))
3301 for k := range this.NonnullBytes {
3302 keysForNonnullBytes = append(keysForNonnullBytes, k)
3303 }
3304 github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullBytes)
3305 mapStringForNonnullBytes := "map[int32][]byte{"
3306 for _, k := range keysForNonnullBytes {
3307 mapStringForNonnullBytes += fmt.Sprintf("%#v: %#v,", k, this.NonnullBytes[k])
3308 }
3309 mapStringForNonnullBytes += "}"
3310 if this.NonnullBytes != nil {
3311 s = append(s, "NonnullBytes: "+mapStringForNonnullBytes+",\n")
3312 }
3313 if this.XXX_unrecognized != nil {
3314 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3315 }
3316 s = append(s, "}")
3317 return strings.Join(s, "")
3318 }
3319 func (this *OneofStdTypes) GoString() string {
3320 if this == nil {
3321 return "nil"
3322 }
3323 s := make([]string, 0, 15)
3324 s = append(s, "&stdtypes.OneofStdTypes{")
3325 if this.OneOfStdTimes != nil {
3326 s = append(s, "OneOfStdTimes: "+fmt.Sprintf("%#v", this.OneOfStdTimes)+",\n")
3327 }
3328 if this.XXX_unrecognized != nil {
3329 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3330 }
3331 s = append(s, "}")
3332 return strings.Join(s, "")
3333 }
3334 func (this *OneofStdTypes_Timestamp) GoString() string {
3335 if this == nil {
3336 return "nil"
3337 }
3338 s := strings.Join([]string{`&stdtypes.OneofStdTypes_Timestamp{` +
3339 `Timestamp:` + fmt.Sprintf("%#v", this.Timestamp) + `}`}, ", ")
3340 return s
3341 }
3342 func (this *OneofStdTypes_Duration) GoString() string {
3343 if this == nil {
3344 return "nil"
3345 }
3346 s := strings.Join([]string{`&stdtypes.OneofStdTypes_Duration{` +
3347 `Duration:` + fmt.Sprintf("%#v", this.Duration) + `}`}, ", ")
3348 return s
3349 }
3350 func (this *OneofStdTypes_RepDouble) GoString() string {
3351 if this == nil {
3352 return "nil"
3353 }
3354 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepDouble{` +
3355 `RepDouble:` + fmt.Sprintf("%#v", this.RepDouble) + `}`}, ", ")
3356 return s
3357 }
3358 func (this *OneofStdTypes_RepFloat) GoString() string {
3359 if this == nil {
3360 return "nil"
3361 }
3362 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepFloat{` +
3363 `RepFloat:` + fmt.Sprintf("%#v", this.RepFloat) + `}`}, ", ")
3364 return s
3365 }
3366 func (this *OneofStdTypes_RepInt64) GoString() string {
3367 if this == nil {
3368 return "nil"
3369 }
3370 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepInt64{` +
3371 `RepInt64:` + fmt.Sprintf("%#v", this.RepInt64) + `}`}, ", ")
3372 return s
3373 }
3374 func (this *OneofStdTypes_RepUInt64) GoString() string {
3375 if this == nil {
3376 return "nil"
3377 }
3378 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepUInt64{` +
3379 `RepUInt64:` + fmt.Sprintf("%#v", this.RepUInt64) + `}`}, ", ")
3380 return s
3381 }
3382 func (this *OneofStdTypes_RepInt32) GoString() string {
3383 if this == nil {
3384 return "nil"
3385 }
3386 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepInt32{` +
3387 `RepInt32:` + fmt.Sprintf("%#v", this.RepInt32) + `}`}, ", ")
3388 return s
3389 }
3390 func (this *OneofStdTypes_RepUInt32) GoString() string {
3391 if this == nil {
3392 return "nil"
3393 }
3394 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepUInt32{` +
3395 `RepUInt32:` + fmt.Sprintf("%#v", this.RepUInt32) + `}`}, ", ")
3396 return s
3397 }
3398 func (this *OneofStdTypes_RepBool) GoString() string {
3399 if this == nil {
3400 return "nil"
3401 }
3402 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepBool{` +
3403 `RepBool:` + fmt.Sprintf("%#v", this.RepBool) + `}`}, ", ")
3404 return s
3405 }
3406 func (this *OneofStdTypes_RepString) GoString() string {
3407 if this == nil {
3408 return "nil"
3409 }
3410 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepString{` +
3411 `RepString:` + fmt.Sprintf("%#v", this.RepString) + `}`}, ", ")
3412 return s
3413 }
3414 func (this *OneofStdTypes_RepBytes) GoString() string {
3415 if this == nil {
3416 return "nil"
3417 }
3418 s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepBytes{` +
3419 `RepBytes:` + fmt.Sprintf("%#v", this.RepBytes) + `}`}, ", ")
3420 return s
3421 }
3422 func valueToGoStringStdtypes(v interface{}, typ string) string {
3423 rv := reflect.ValueOf(v)
3424 if rv.IsNil() {
3425 return "nil"
3426 }
3427 pv := reflect.Indirect(rv).Interface()
3428 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
3429 }
3430 func NewPopulatedStdTypes(r randyStdtypes, easy bool) *StdTypes {
3431 this := &StdTypes{}
3432 if r.Intn(5) != 0 {
3433 this.NullableTimestamp = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3434 }
3435 if r.Intn(5) != 0 {
3436 this.NullableDuration = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3437 }
3438 v1 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3439 this.Timestamp = *v1
3440 v2 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3441 this.Duration = *v2
3442 if r.Intn(5) != 0 {
3443 this.NullableDouble = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
3444 }
3445 v3 := github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
3446 this.NonnullDouble = *v3
3447 if r.Intn(5) != 0 {
3448 this.NullableFloat = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
3449 }
3450 v4 := github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
3451 this.NonnullFloat = *v4
3452 if r.Intn(5) != 0 {
3453 this.NullableInt64 = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
3454 }
3455 v5 := github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
3456 this.NonnullInt64 = *v5
3457 if r.Intn(5) != 0 {
3458 this.NullableUInt64 = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
3459 }
3460 v6 := github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
3461 this.NonnullUInt64 = *v6
3462 if r.Intn(5) != 0 {
3463 this.NullableInt32 = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
3464 }
3465 v7 := github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
3466 this.NonnullInt32 = *v7
3467 if r.Intn(5) != 0 {
3468 this.NullableUInt32 = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
3469 }
3470 v8 := github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
3471 this.NonnullUInt32 = *v8
3472 if r.Intn(5) != 0 {
3473 this.NullableBool = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
3474 }
3475 v9 := github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
3476 this.NonnullBool = *v9
3477 if r.Intn(5) != 0 {
3478 this.NullableString = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
3479 }
3480 v10 := github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
3481 this.NonnullString = *v10
3482 if r.Intn(5) != 0 {
3483 this.NullableBytes = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
3484 }
3485 v11 := github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
3486 this.NonnullBytes = *v11
3487 if !easy && r.Intn(10) != 0 {
3488 this.XXX_unrecognized = randUnrecognizedStdtypes(r, 23)
3489 }
3490 return this
3491 }
3492
3493 func NewPopulatedRepStdTypes(r randyStdtypes, easy bool) *RepStdTypes {
3494 this := &RepStdTypes{}
3495 if r.Intn(5) != 0 {
3496 v12 := r.Intn(5)
3497 this.NullableTimestamps = make([]*time.Time, v12)
3498 for i := 0; i < v12; i++ {
3499 this.NullableTimestamps[i] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3500 }
3501 }
3502 if r.Intn(5) != 0 {
3503 v13 := r.Intn(5)
3504 this.NullableDurations = make([]*time.Duration, v13)
3505 for i := 0; i < v13; i++ {
3506 this.NullableDurations[i] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3507 }
3508 }
3509 if r.Intn(5) != 0 {
3510 v14 := r.Intn(5)
3511 this.Timestamps = make([]time.Time, v14)
3512 for i := 0; i < v14; i++ {
3513 v15 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3514 this.Timestamps[i] = *v15
3515 }
3516 }
3517 if r.Intn(5) != 0 {
3518 v16 := r.Intn(5)
3519 this.Durations = make([]time.Duration, v16)
3520 for i := 0; i < v16; i++ {
3521 v17 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3522 this.Durations[i] = *v17
3523 }
3524 }
3525 if r.Intn(5) != 0 {
3526 v18 := r.Intn(5)
3527 this.NullableDouble = make([]*float64, v18)
3528 for i := 0; i < v18; i++ {
3529 this.NullableDouble[i] = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
3530 }
3531 }
3532 if r.Intn(5) != 0 {
3533 v19 := r.Intn(5)
3534 this.NonnullDouble = make([]float64, v19)
3535 for i := 0; i < v19; i++ {
3536 v20 := github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
3537 this.NonnullDouble[i] = *v20
3538 }
3539 }
3540 if r.Intn(5) != 0 {
3541 v21 := r.Intn(5)
3542 this.NullableFloat = make([]*float32, v21)
3543 for i := 0; i < v21; i++ {
3544 this.NullableFloat[i] = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
3545 }
3546 }
3547 if r.Intn(5) != 0 {
3548 v22 := r.Intn(5)
3549 this.NonnullFloat = make([]float32, v22)
3550 for i := 0; i < v22; i++ {
3551 v23 := github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
3552 this.NonnullFloat[i] = *v23
3553 }
3554 }
3555 if r.Intn(5) != 0 {
3556 v24 := r.Intn(5)
3557 this.NullableInt64 = make([]*int64, v24)
3558 for i := 0; i < v24; i++ {
3559 this.NullableInt64[i] = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
3560 }
3561 }
3562 if r.Intn(5) != 0 {
3563 v25 := r.Intn(5)
3564 this.NonnullInt64 = make([]int64, v25)
3565 for i := 0; i < v25; i++ {
3566 v26 := github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
3567 this.NonnullInt64[i] = *v26
3568 }
3569 }
3570 if r.Intn(5) != 0 {
3571 v27 := r.Intn(5)
3572 this.NullableUInt64 = make([]*uint64, v27)
3573 for i := 0; i < v27; i++ {
3574 this.NullableUInt64[i] = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
3575 }
3576 }
3577 if r.Intn(5) != 0 {
3578 v28 := r.Intn(5)
3579 this.NonnullUInt64 = make([]uint64, v28)
3580 for i := 0; i < v28; i++ {
3581 v29 := github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
3582 this.NonnullUInt64[i] = *v29
3583 }
3584 }
3585 if r.Intn(5) != 0 {
3586 v30 := r.Intn(5)
3587 this.NullableInt32 = make([]*int32, v30)
3588 for i := 0; i < v30; i++ {
3589 this.NullableInt32[i] = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
3590 }
3591 }
3592 if r.Intn(5) != 0 {
3593 v31 := r.Intn(5)
3594 this.NonnullInt32 = make([]int32, v31)
3595 for i := 0; i < v31; i++ {
3596 v32 := github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
3597 this.NonnullInt32[i] = *v32
3598 }
3599 }
3600 if r.Intn(5) != 0 {
3601 v33 := r.Intn(5)
3602 this.NullableUInt32 = make([]*uint32, v33)
3603 for i := 0; i < v33; i++ {
3604 this.NullableUInt32[i] = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
3605 }
3606 }
3607 if r.Intn(5) != 0 {
3608 v34 := r.Intn(5)
3609 this.NonnullUInt32 = make([]uint32, v34)
3610 for i := 0; i < v34; i++ {
3611 v35 := github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
3612 this.NonnullUInt32[i] = *v35
3613 }
3614 }
3615 if r.Intn(5) != 0 {
3616 v36 := r.Intn(5)
3617 this.NullableBool = make([]*bool, v36)
3618 for i := 0; i < v36; i++ {
3619 this.NullableBool[i] = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
3620 }
3621 }
3622 if r.Intn(5) != 0 {
3623 v37 := r.Intn(5)
3624 this.NonnullBool = make([]bool, v37)
3625 for i := 0; i < v37; i++ {
3626 v38 := github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
3627 this.NonnullBool[i] = *v38
3628 }
3629 }
3630 if r.Intn(5) != 0 {
3631 v39 := r.Intn(5)
3632 this.NullableString = make([]*string, v39)
3633 for i := 0; i < v39; i++ {
3634 this.NullableString[i] = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
3635 }
3636 }
3637 if r.Intn(5) != 0 {
3638 v40 := r.Intn(5)
3639 this.NonnullString = make([]string, v40)
3640 for i := 0; i < v40; i++ {
3641 v41 := github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
3642 this.NonnullString[i] = *v41
3643 }
3644 }
3645 if r.Intn(5) != 0 {
3646 v42 := r.Intn(5)
3647 this.NullableBytes = make([]*[]byte, v42)
3648 for i := 0; i < v42; i++ {
3649 this.NullableBytes[i] = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
3650 }
3651 }
3652 if r.Intn(5) != 0 {
3653 v43 := r.Intn(5)
3654 this.NonnullBytes = make([][]byte, v43)
3655 for i := 0; i < v43; i++ {
3656 v44 := github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
3657 this.NonnullBytes[i] = *v44
3658 }
3659 }
3660 if !easy && r.Intn(10) != 0 {
3661 this.XXX_unrecognized = randUnrecognizedStdtypes(r, 23)
3662 }
3663 return this
3664 }
3665
3666 func NewPopulatedMapStdTypes(r randyStdtypes, easy bool) *MapStdTypes {
3667 this := &MapStdTypes{}
3668 if r.Intn(5) != 0 {
3669 v45 := r.Intn(10)
3670 this.NullableTimestamp = make(map[int32]*time.Time)
3671 for i := 0; i < v45; i++ {
3672 this.NullableTimestamp[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3673 }
3674 }
3675 if r.Intn(5) != 0 {
3676 v46 := r.Intn(10)
3677 this.Timestamp = make(map[int32]time.Time)
3678 for i := 0; i < v46; i++ {
3679 this.Timestamp[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3680 }
3681 }
3682 if r.Intn(5) != 0 {
3683 v47 := r.Intn(10)
3684 this.NullableDuration = make(map[int32]*time.Duration)
3685 for i := 0; i < v47; i++ {
3686 this.NullableDuration[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3687 }
3688 }
3689 if r.Intn(5) != 0 {
3690 v48 := r.Intn(10)
3691 this.Duration = make(map[int32]time.Duration)
3692 for i := 0; i < v48; i++ {
3693 this.Duration[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3694 }
3695 }
3696 if r.Intn(5) != 0 {
3697 v49 := r.Intn(10)
3698 this.NullableDouble = make(map[int32]*float64)
3699 for i := 0; i < v49; i++ {
3700 this.NullableDouble[int32(r.Int31())] = (*float64)(github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy))
3701 }
3702 }
3703 if r.Intn(5) != 0 {
3704 v50 := r.Intn(10)
3705 this.NonnullDouble = make(map[int32]float64)
3706 for i := 0; i < v50; i++ {
3707 this.NonnullDouble[int32(r.Int31())] = (float64)(*github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy))
3708 }
3709 }
3710 if r.Intn(5) != 0 {
3711 v51 := r.Intn(10)
3712 this.NullableFloat = make(map[int32]*float32)
3713 for i := 0; i < v51; i++ {
3714 this.NullableFloat[int32(r.Int31())] = (*float32)(github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy))
3715 }
3716 }
3717 if r.Intn(5) != 0 {
3718 v52 := r.Intn(10)
3719 this.NonnullFloat = make(map[int32]float32)
3720 for i := 0; i < v52; i++ {
3721 this.NonnullFloat[int32(r.Int31())] = (float32)(*github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy))
3722 }
3723 }
3724 if r.Intn(5) != 0 {
3725 v53 := r.Intn(10)
3726 this.NullableInt64 = make(map[int32]*int64)
3727 for i := 0; i < v53; i++ {
3728 this.NullableInt64[int32(r.Int31())] = (*int64)(github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy))
3729 }
3730 }
3731 if r.Intn(5) != 0 {
3732 v54 := r.Intn(10)
3733 this.NonnullInt64 = make(map[int32]int64)
3734 for i := 0; i < v54; i++ {
3735 this.NonnullInt64[int32(r.Int31())] = (int64)(*github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy))
3736 }
3737 }
3738 if r.Intn(5) != 0 {
3739 v55 := r.Intn(10)
3740 this.NullableUInt64 = make(map[int32]*uint64)
3741 for i := 0; i < v55; i++ {
3742 this.NullableUInt64[int32(r.Int31())] = (*uint64)(github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy))
3743 }
3744 }
3745 if r.Intn(5) != 0 {
3746 v56 := r.Intn(10)
3747 this.NonnullUInt64 = make(map[int32]uint64)
3748 for i := 0; i < v56; i++ {
3749 this.NonnullUInt64[int32(r.Int31())] = (uint64)(*github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy))
3750 }
3751 }
3752 if r.Intn(5) != 0 {
3753 v57 := r.Intn(10)
3754 this.NullableInt32 = make(map[int32]*int32)
3755 for i := 0; i < v57; i++ {
3756 this.NullableInt32[int32(r.Int31())] = (*int32)(github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy))
3757 }
3758 }
3759 if r.Intn(5) != 0 {
3760 v58 := r.Intn(10)
3761 this.NonnullInt32 = make(map[int32]int32)
3762 for i := 0; i < v58; i++ {
3763 this.NonnullInt32[int32(r.Int31())] = (int32)(*github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy))
3764 }
3765 }
3766 if r.Intn(5) != 0 {
3767 v59 := r.Intn(10)
3768 this.NullableUInt32 = make(map[int32]*uint32)
3769 for i := 0; i < v59; i++ {
3770 this.NullableUInt32[int32(r.Int31())] = (*uint32)(github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy))
3771 }
3772 }
3773 if r.Intn(5) != 0 {
3774 v60 := r.Intn(10)
3775 this.NonnullUInt32 = make(map[int32]uint32)
3776 for i := 0; i < v60; i++ {
3777 this.NonnullUInt32[int32(r.Int31())] = (uint32)(*github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy))
3778 }
3779 }
3780 if r.Intn(5) != 0 {
3781 v61 := r.Intn(10)
3782 this.NullableBool = make(map[int32]*bool)
3783 for i := 0; i < v61; i++ {
3784 this.NullableBool[int32(r.Int31())] = (*bool)(github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy))
3785 }
3786 }
3787 if r.Intn(5) != 0 {
3788 v62 := r.Intn(10)
3789 this.NonnullBool = make(map[int32]bool)
3790 for i := 0; i < v62; i++ {
3791 this.NonnullBool[int32(r.Int31())] = (bool)(*github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy))
3792 }
3793 }
3794 if r.Intn(5) != 0 {
3795 v63 := r.Intn(10)
3796 this.NullableString = make(map[int32]*string)
3797 for i := 0; i < v63; i++ {
3798 this.NullableString[int32(r.Int31())] = (*string)(github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy))
3799 }
3800 }
3801 if r.Intn(5) != 0 {
3802 v64 := r.Intn(10)
3803 this.NonnullString = make(map[int32]string)
3804 for i := 0; i < v64; i++ {
3805 this.NonnullString[int32(r.Int31())] = (string)(*github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy))
3806 }
3807 }
3808 if r.Intn(5) != 0 {
3809 v65 := r.Intn(10)
3810 this.NullableBytes = make(map[int32]*[]byte)
3811 for i := 0; i < v65; i++ {
3812 this.NullableBytes[int32(r.Int31())] = (*[]byte)(github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy))
3813 }
3814 }
3815 if r.Intn(5) != 0 {
3816 v66 := r.Intn(10)
3817 this.NonnullBytes = make(map[int32][]byte)
3818 for i := 0; i < v66; i++ {
3819 this.NonnullBytes[int32(r.Int31())] = ([]byte)(*github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy))
3820 }
3821 }
3822 if !easy && r.Intn(10) != 0 {
3823 this.XXX_unrecognized = randUnrecognizedStdtypes(r, 23)
3824 }
3825 return this
3826 }
3827
3828 func NewPopulatedOneofStdTypes(r randyStdtypes, easy bool) *OneofStdTypes {
3829 this := &OneofStdTypes{}
3830 oneofNumber_OneOfStdTimes := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}[r.Intn(11)]
3831 switch oneofNumber_OneOfStdTimes {
3832 case 1:
3833 this.OneOfStdTimes = NewPopulatedOneofStdTypes_Timestamp(r, easy)
3834 case 2:
3835 this.OneOfStdTimes = NewPopulatedOneofStdTypes_Duration(r, easy)
3836 case 3:
3837 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepDouble(r, easy)
3838 case 4:
3839 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepFloat(r, easy)
3840 case 5:
3841 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepInt64(r, easy)
3842 case 6:
3843 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepUInt64(r, easy)
3844 case 7:
3845 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepInt32(r, easy)
3846 case 8:
3847 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepUInt32(r, easy)
3848 case 9:
3849 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepBool(r, easy)
3850 case 10:
3851 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepString(r, easy)
3852 case 11:
3853 this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepBytes(r, easy)
3854 }
3855 if !easy && r.Intn(10) != 0 {
3856 this.XXX_unrecognized = randUnrecognizedStdtypes(r, 12)
3857 }
3858 return this
3859 }
3860
3861 func NewPopulatedOneofStdTypes_Timestamp(r randyStdtypes, easy bool) *OneofStdTypes_Timestamp {
3862 this := &OneofStdTypes_Timestamp{}
3863 this.Timestamp = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
3864 return this
3865 }
3866 func NewPopulatedOneofStdTypes_Duration(r randyStdtypes, easy bool) *OneofStdTypes_Duration {
3867 this := &OneofStdTypes_Duration{}
3868 this.Duration = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
3869 return this
3870 }
3871 func NewPopulatedOneofStdTypes_RepDouble(r randyStdtypes, easy bool) *OneofStdTypes_RepDouble {
3872 this := &OneofStdTypes_RepDouble{}
3873 this.RepDouble = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
3874 return this
3875 }
3876 func NewPopulatedOneofStdTypes_RepFloat(r randyStdtypes, easy bool) *OneofStdTypes_RepFloat {
3877 this := &OneofStdTypes_RepFloat{}
3878 this.RepFloat = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
3879 return this
3880 }
3881 func NewPopulatedOneofStdTypes_RepInt64(r randyStdtypes, easy bool) *OneofStdTypes_RepInt64 {
3882 this := &OneofStdTypes_RepInt64{}
3883 this.RepInt64 = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
3884 return this
3885 }
3886 func NewPopulatedOneofStdTypes_RepUInt64(r randyStdtypes, easy bool) *OneofStdTypes_RepUInt64 {
3887 this := &OneofStdTypes_RepUInt64{}
3888 this.RepUInt64 = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
3889 return this
3890 }
3891 func NewPopulatedOneofStdTypes_RepInt32(r randyStdtypes, easy bool) *OneofStdTypes_RepInt32 {
3892 this := &OneofStdTypes_RepInt32{}
3893 this.RepInt32 = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
3894 return this
3895 }
3896 func NewPopulatedOneofStdTypes_RepUInt32(r randyStdtypes, easy bool) *OneofStdTypes_RepUInt32 {
3897 this := &OneofStdTypes_RepUInt32{}
3898 this.RepUInt32 = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
3899 return this
3900 }
3901 func NewPopulatedOneofStdTypes_RepBool(r randyStdtypes, easy bool) *OneofStdTypes_RepBool {
3902 this := &OneofStdTypes_RepBool{}
3903 this.RepBool = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
3904 return this
3905 }
3906 func NewPopulatedOneofStdTypes_RepString(r randyStdtypes, easy bool) *OneofStdTypes_RepString {
3907 this := &OneofStdTypes_RepString{}
3908 this.RepString = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
3909 return this
3910 }
3911 func NewPopulatedOneofStdTypes_RepBytes(r randyStdtypes, easy bool) *OneofStdTypes_RepBytes {
3912 this := &OneofStdTypes_RepBytes{}
3913 this.RepBytes = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
3914 return this
3915 }
3916
3917 type randyStdtypes interface {
3918 Float32() float32
3919 Float64() float64
3920 Int63() int64
3921 Int31() int32
3922 Uint32() uint32
3923 Intn(n int) int
3924 }
3925
3926 func randUTF8RuneStdtypes(r randyStdtypes) rune {
3927 ru := r.Intn(62)
3928 if ru < 10 {
3929 return rune(ru + 48)
3930 } else if ru < 36 {
3931 return rune(ru + 55)
3932 }
3933 return rune(ru + 61)
3934 }
3935 func randStringStdtypes(r randyStdtypes) string {
3936 v67 := r.Intn(100)
3937 tmps := make([]rune, v67)
3938 for i := 0; i < v67; i++ {
3939 tmps[i] = randUTF8RuneStdtypes(r)
3940 }
3941 return string(tmps)
3942 }
3943 func randUnrecognizedStdtypes(r randyStdtypes, maxFieldNumber int) (dAtA []byte) {
3944 l := r.Intn(5)
3945 for i := 0; i < l; i++ {
3946 wire := r.Intn(4)
3947 if wire == 3 {
3948 wire = 5
3949 }
3950 fieldNumber := maxFieldNumber + r.Intn(100)
3951 dAtA = randFieldStdtypes(dAtA, r, fieldNumber, wire)
3952 }
3953 return dAtA
3954 }
3955 func randFieldStdtypes(dAtA []byte, r randyStdtypes, fieldNumber int, wire int) []byte {
3956 key := uint32(fieldNumber)<<3 | uint32(wire)
3957 switch wire {
3958 case 0:
3959 dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(key))
3960 v68 := r.Int63()
3961 if r.Intn(2) == 0 {
3962 v68 *= -1
3963 }
3964 dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(v68))
3965 case 1:
3966 dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(key))
3967 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)))
3968 case 2:
3969 dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(key))
3970 ll := r.Intn(100)
3971 dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(ll))
3972 for j := 0; j < ll; j++ {
3973 dAtA = append(dAtA, byte(r.Intn(256)))
3974 }
3975 default:
3976 dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(key))
3977 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
3978 }
3979 return dAtA
3980 }
3981 func encodeVarintPopulateStdtypes(dAtA []byte, v uint64) []byte {
3982 for v >= 1<<7 {
3983 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
3984 v >>= 7
3985 }
3986 dAtA = append(dAtA, uint8(v))
3987 return dAtA
3988 }
3989 func (m *StdTypes) Size() (n int) {
3990 if m == nil {
3991 return 0
3992 }
3993 var l int
3994 _ = l
3995 if m.NullableTimestamp != nil {
3996 l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.NullableTimestamp)
3997 n += 1 + l + sovStdtypes(uint64(l))
3998 }
3999 if m.NullableDuration != nil {
4000 l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.NullableDuration)
4001 n += 1 + l + sovStdtypes(uint64(l))
4002 }
4003 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
4004 n += 1 + l + sovStdtypes(uint64(l))
4005 l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)
4006 n += 1 + l + sovStdtypes(uint64(l))
4007 if m.NullableDouble != nil {
4008 l = github_com_gogo_protobuf_types.SizeOfStdDouble(*m.NullableDouble)
4009 n += 1 + l + sovStdtypes(uint64(l))
4010 }
4011 l = github_com_gogo_protobuf_types.SizeOfStdDouble(m.NonnullDouble)
4012 n += 1 + l + sovStdtypes(uint64(l))
4013 if m.NullableFloat != nil {
4014 l = github_com_gogo_protobuf_types.SizeOfStdFloat(*m.NullableFloat)
4015 n += 1 + l + sovStdtypes(uint64(l))
4016 }
4017 l = github_com_gogo_protobuf_types.SizeOfStdFloat(m.NonnullFloat)
4018 n += 1 + l + sovStdtypes(uint64(l))
4019 if m.NullableInt64 != nil {
4020 l = github_com_gogo_protobuf_types.SizeOfStdInt64(*m.NullableInt64)
4021 n += 1 + l + sovStdtypes(uint64(l))
4022 }
4023 l = github_com_gogo_protobuf_types.SizeOfStdInt64(m.NonnullInt64)
4024 n += 1 + l + sovStdtypes(uint64(l))
4025 if m.NullableUInt64 != nil {
4026 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.NullableUInt64)
4027 n += 1 + l + sovStdtypes(uint64(l))
4028 }
4029 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(m.NonnullUInt64)
4030 n += 1 + l + sovStdtypes(uint64(l))
4031 if m.NullableInt32 != nil {
4032 l = github_com_gogo_protobuf_types.SizeOfStdInt32(*m.NullableInt32)
4033 n += 1 + l + sovStdtypes(uint64(l))
4034 }
4035 l = github_com_gogo_protobuf_types.SizeOfStdInt32(m.NonnullInt32)
4036 n += 1 + l + sovStdtypes(uint64(l))
4037 if m.NullableUInt32 != nil {
4038 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.NullableUInt32)
4039 n += 1 + l + sovStdtypes(uint64(l))
4040 }
4041 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(m.NonnullUInt32)
4042 n += 2 + l + sovStdtypes(uint64(l))
4043 if m.NullableBool != nil {
4044 l = github_com_gogo_protobuf_types.SizeOfStdBool(*m.NullableBool)
4045 n += 2 + l + sovStdtypes(uint64(l))
4046 }
4047 l = github_com_gogo_protobuf_types.SizeOfStdBool(m.NonnullBool)
4048 n += 2 + l + sovStdtypes(uint64(l))
4049 if m.NullableString != nil {
4050 l = github_com_gogo_protobuf_types.SizeOfStdString(*m.NullableString)
4051 n += 2 + l + sovStdtypes(uint64(l))
4052 }
4053 l = github_com_gogo_protobuf_types.SizeOfStdString(m.NonnullString)
4054 n += 2 + l + sovStdtypes(uint64(l))
4055 if m.NullableBytes != nil {
4056 l = github_com_gogo_protobuf_types.SizeOfStdBytes(*m.NullableBytes)
4057 n += 2 + l + sovStdtypes(uint64(l))
4058 }
4059 l = github_com_gogo_protobuf_types.SizeOfStdBytes(m.NonnullBytes)
4060 n += 2 + l + sovStdtypes(uint64(l))
4061 if m.XXX_unrecognized != nil {
4062 n += len(m.XXX_unrecognized)
4063 }
4064 return n
4065 }
4066
4067 func (m *RepStdTypes) Size() (n int) {
4068 if m == nil {
4069 return 0
4070 }
4071 var l int
4072 _ = l
4073 if len(m.NullableTimestamps) > 0 {
4074 for _, e := range m.NullableTimestamps {
4075 l = github_com_gogo_protobuf_types.SizeOfStdTime(*e)
4076 n += 1 + l + sovStdtypes(uint64(l))
4077 }
4078 }
4079 if len(m.NullableDurations) > 0 {
4080 for _, e := range m.NullableDurations {
4081 l = github_com_gogo_protobuf_types.SizeOfStdDuration(*e)
4082 n += 1 + l + sovStdtypes(uint64(l))
4083 }
4084 }
4085 if len(m.Timestamps) > 0 {
4086 for _, e := range m.Timestamps {
4087 l = github_com_gogo_protobuf_types.SizeOfStdTime(e)
4088 n += 1 + l + sovStdtypes(uint64(l))
4089 }
4090 }
4091 if len(m.Durations) > 0 {
4092 for _, e := range m.Durations {
4093 l = github_com_gogo_protobuf_types.SizeOfStdDuration(e)
4094 n += 1 + l + sovStdtypes(uint64(l))
4095 }
4096 }
4097 if len(m.NullableDouble) > 0 {
4098 for _, e := range m.NullableDouble {
4099 l = github_com_gogo_protobuf_types.SizeOfStdDouble(*e)
4100 n += 1 + l + sovStdtypes(uint64(l))
4101 }
4102 }
4103 if len(m.NonnullDouble) > 0 {
4104 for _, e := range m.NonnullDouble {
4105 l = github_com_gogo_protobuf_types.SizeOfStdDouble(e)
4106 n += 1 + l + sovStdtypes(uint64(l))
4107 }
4108 }
4109 if len(m.NullableFloat) > 0 {
4110 for _, e := range m.NullableFloat {
4111 l = github_com_gogo_protobuf_types.SizeOfStdFloat(*e)
4112 n += 1 + l + sovStdtypes(uint64(l))
4113 }
4114 }
4115 if len(m.NonnullFloat) > 0 {
4116 for _, e := range m.NonnullFloat {
4117 l = github_com_gogo_protobuf_types.SizeOfStdFloat(e)
4118 n += 1 + l + sovStdtypes(uint64(l))
4119 }
4120 }
4121 if len(m.NullableInt64) > 0 {
4122 for _, e := range m.NullableInt64 {
4123 l = github_com_gogo_protobuf_types.SizeOfStdInt64(*e)
4124 n += 1 + l + sovStdtypes(uint64(l))
4125 }
4126 }
4127 if len(m.NonnullInt64) > 0 {
4128 for _, e := range m.NonnullInt64 {
4129 l = github_com_gogo_protobuf_types.SizeOfStdInt64(e)
4130 n += 1 + l + sovStdtypes(uint64(l))
4131 }
4132 }
4133 if len(m.NullableUInt64) > 0 {
4134 for _, e := range m.NullableUInt64 {
4135 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*e)
4136 n += 1 + l + sovStdtypes(uint64(l))
4137 }
4138 }
4139 if len(m.NonnullUInt64) > 0 {
4140 for _, e := range m.NonnullUInt64 {
4141 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(e)
4142 n += 1 + l + sovStdtypes(uint64(l))
4143 }
4144 }
4145 if len(m.NullableInt32) > 0 {
4146 for _, e := range m.NullableInt32 {
4147 l = github_com_gogo_protobuf_types.SizeOfStdInt32(*e)
4148 n += 1 + l + sovStdtypes(uint64(l))
4149 }
4150 }
4151 if len(m.NonnullInt32) > 0 {
4152 for _, e := range m.NonnullInt32 {
4153 l = github_com_gogo_protobuf_types.SizeOfStdInt32(e)
4154 n += 1 + l + sovStdtypes(uint64(l))
4155 }
4156 }
4157 if len(m.NullableUInt32) > 0 {
4158 for _, e := range m.NullableUInt32 {
4159 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*e)
4160 n += 1 + l + sovStdtypes(uint64(l))
4161 }
4162 }
4163 if len(m.NonnullUInt32) > 0 {
4164 for _, e := range m.NonnullUInt32 {
4165 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(e)
4166 n += 2 + l + sovStdtypes(uint64(l))
4167 }
4168 }
4169 if len(m.NullableBool) > 0 {
4170 for _, e := range m.NullableBool {
4171 l = github_com_gogo_protobuf_types.SizeOfStdBool(*e)
4172 n += 2 + l + sovStdtypes(uint64(l))
4173 }
4174 }
4175 if len(m.NonnullBool) > 0 {
4176 for _, e := range m.NonnullBool {
4177 l = github_com_gogo_protobuf_types.SizeOfStdBool(e)
4178 n += 2 + l + sovStdtypes(uint64(l))
4179 }
4180 }
4181 if len(m.NullableString) > 0 {
4182 for _, e := range m.NullableString {
4183 l = github_com_gogo_protobuf_types.SizeOfStdString(*e)
4184 n += 2 + l + sovStdtypes(uint64(l))
4185 }
4186 }
4187 if len(m.NonnullString) > 0 {
4188 for _, e := range m.NonnullString {
4189 l = github_com_gogo_protobuf_types.SizeOfStdString(e)
4190 n += 2 + l + sovStdtypes(uint64(l))
4191 }
4192 }
4193 if len(m.NullableBytes) > 0 {
4194 for _, e := range m.NullableBytes {
4195 l = github_com_gogo_protobuf_types.SizeOfStdBytes(*e)
4196 n += 2 + l + sovStdtypes(uint64(l))
4197 }
4198 }
4199 if len(m.NonnullBytes) > 0 {
4200 for _, e := range m.NonnullBytes {
4201 l = github_com_gogo_protobuf_types.SizeOfStdBytes(e)
4202 n += 2 + l + sovStdtypes(uint64(l))
4203 }
4204 }
4205 if m.XXX_unrecognized != nil {
4206 n += len(m.XXX_unrecognized)
4207 }
4208 return n
4209 }
4210
4211 func (m *MapStdTypes) Size() (n int) {
4212 if m == nil {
4213 return 0
4214 }
4215 var l int
4216 _ = l
4217 if len(m.NullableTimestamp) > 0 {
4218 for k, v := range m.NullableTimestamp {
4219 _ = k
4220 _ = v
4221 l = 0
4222 if v != nil {
4223 l = github_com_gogo_protobuf_types.SizeOfStdTime(*v)
4224 l += 1 + sovStdtypes(uint64(l))
4225 }
4226 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4227 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4228 }
4229 }
4230 if len(m.Timestamp) > 0 {
4231 for k, v := range m.Timestamp {
4232 _ = k
4233 _ = v
4234 l = github_com_gogo_protobuf_types.SizeOfStdTime(v)
4235 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4236 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4237 }
4238 }
4239 if len(m.NullableDuration) > 0 {
4240 for k, v := range m.NullableDuration {
4241 _ = k
4242 _ = v
4243 l = 0
4244 if v != nil {
4245 l = github_com_gogo_protobuf_types.SizeOfStdDuration(*v)
4246 l += 1 + sovStdtypes(uint64(l))
4247 }
4248 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4249 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4250 }
4251 }
4252 if len(m.Duration) > 0 {
4253 for k, v := range m.Duration {
4254 _ = k
4255 _ = v
4256 l = github_com_gogo_protobuf_types.SizeOfStdDuration(v)
4257 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4258 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4259 }
4260 }
4261 if len(m.NullableDouble) > 0 {
4262 for k, v := range m.NullableDouble {
4263 _ = k
4264 _ = v
4265 l = 0
4266 if v != nil {
4267 l = github_com_gogo_protobuf_types.SizeOfStdDouble(*v)
4268 l += 1 + sovStdtypes(uint64(l))
4269 }
4270 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4271 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4272 }
4273 }
4274 if len(m.NonnullDouble) > 0 {
4275 for k, v := range m.NonnullDouble {
4276 _ = k
4277 _ = v
4278 l = github_com_gogo_protobuf_types.SizeOfStdDouble(v)
4279 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4280 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4281 }
4282 }
4283 if len(m.NullableFloat) > 0 {
4284 for k, v := range m.NullableFloat {
4285 _ = k
4286 _ = v
4287 l = 0
4288 if v != nil {
4289 l = github_com_gogo_protobuf_types.SizeOfStdFloat(*v)
4290 l += 1 + sovStdtypes(uint64(l))
4291 }
4292 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4293 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4294 }
4295 }
4296 if len(m.NonnullFloat) > 0 {
4297 for k, v := range m.NonnullFloat {
4298 _ = k
4299 _ = v
4300 l = github_com_gogo_protobuf_types.SizeOfStdFloat(v)
4301 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4302 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4303 }
4304 }
4305 if len(m.NullableInt64) > 0 {
4306 for k, v := range m.NullableInt64 {
4307 _ = k
4308 _ = v
4309 l = 0
4310 if v != nil {
4311 l = github_com_gogo_protobuf_types.SizeOfStdInt64(*v)
4312 l += 1 + sovStdtypes(uint64(l))
4313 }
4314 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4315 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4316 }
4317 }
4318 if len(m.NonnullInt64) > 0 {
4319 for k, v := range m.NonnullInt64 {
4320 _ = k
4321 _ = v
4322 l = github_com_gogo_protobuf_types.SizeOfStdInt64(v)
4323 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4324 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4325 }
4326 }
4327 if len(m.NullableUInt64) > 0 {
4328 for k, v := range m.NullableUInt64 {
4329 _ = k
4330 _ = v
4331 l = 0
4332 if v != nil {
4333 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*v)
4334 l += 1 + sovStdtypes(uint64(l))
4335 }
4336 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4337 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4338 }
4339 }
4340 if len(m.NonnullUInt64) > 0 {
4341 for k, v := range m.NonnullUInt64 {
4342 _ = k
4343 _ = v
4344 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(v)
4345 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4346 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4347 }
4348 }
4349 if len(m.NullableInt32) > 0 {
4350 for k, v := range m.NullableInt32 {
4351 _ = k
4352 _ = v
4353 l = 0
4354 if v != nil {
4355 l = github_com_gogo_protobuf_types.SizeOfStdInt32(*v)
4356 l += 1 + sovStdtypes(uint64(l))
4357 }
4358 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4359 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4360 }
4361 }
4362 if len(m.NonnullInt32) > 0 {
4363 for k, v := range m.NonnullInt32 {
4364 _ = k
4365 _ = v
4366 l = github_com_gogo_protobuf_types.SizeOfStdInt32(v)
4367 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4368 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4369 }
4370 }
4371 if len(m.NullableUInt32) > 0 {
4372 for k, v := range m.NullableUInt32 {
4373 _ = k
4374 _ = v
4375 l = 0
4376 if v != nil {
4377 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*v)
4378 l += 1 + sovStdtypes(uint64(l))
4379 }
4380 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4381 n += mapEntrySize + 1 + sovStdtypes(uint64(mapEntrySize))
4382 }
4383 }
4384 if len(m.NonnullUInt32) > 0 {
4385 for k, v := range m.NonnullUInt32 {
4386 _ = k
4387 _ = v
4388 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(v)
4389 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4390 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4391 }
4392 }
4393 if len(m.NullableBool) > 0 {
4394 for k, v := range m.NullableBool {
4395 _ = k
4396 _ = v
4397 l = 0
4398 if v != nil {
4399 l = github_com_gogo_protobuf_types.SizeOfStdBool(*v)
4400 l += 1 + sovStdtypes(uint64(l))
4401 }
4402 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4403 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4404 }
4405 }
4406 if len(m.NonnullBool) > 0 {
4407 for k, v := range m.NonnullBool {
4408 _ = k
4409 _ = v
4410 l = github_com_gogo_protobuf_types.SizeOfStdBool(v)
4411 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4412 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4413 }
4414 }
4415 if len(m.NullableString) > 0 {
4416 for k, v := range m.NullableString {
4417 _ = k
4418 _ = v
4419 l = 0
4420 if v != nil {
4421 l = github_com_gogo_protobuf_types.SizeOfStdString(*v)
4422 l += 1 + sovStdtypes(uint64(l))
4423 }
4424 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4425 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4426 }
4427 }
4428 if len(m.NonnullString) > 0 {
4429 for k, v := range m.NonnullString {
4430 _ = k
4431 _ = v
4432 l = github_com_gogo_protobuf_types.SizeOfStdString(v)
4433 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4434 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4435 }
4436 }
4437 if len(m.NullableBytes) > 0 {
4438 for k, v := range m.NullableBytes {
4439 _ = k
4440 _ = v
4441 l = 0
4442 if v != nil {
4443 l = github_com_gogo_protobuf_types.SizeOfStdBytes(*v)
4444 l += 1 + sovStdtypes(uint64(l))
4445 }
4446 mapEntrySize := 1 + sovStdtypes(uint64(k)) + l
4447 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4448 }
4449 }
4450 if len(m.NonnullBytes) > 0 {
4451 for k, v := range m.NonnullBytes {
4452 _ = k
4453 _ = v
4454 l = github_com_gogo_protobuf_types.SizeOfStdBytes(v)
4455 mapEntrySize := 1 + sovStdtypes(uint64(k)) + 1 + l + sovStdtypes(uint64(l))
4456 n += mapEntrySize + 2 + sovStdtypes(uint64(mapEntrySize))
4457 }
4458 }
4459 if m.XXX_unrecognized != nil {
4460 n += len(m.XXX_unrecognized)
4461 }
4462 return n
4463 }
4464
4465 func (m *OneofStdTypes) Size() (n int) {
4466 if m == nil {
4467 return 0
4468 }
4469 var l int
4470 _ = l
4471 if m.OneOfStdTimes != nil {
4472 n += m.OneOfStdTimes.Size()
4473 }
4474 if m.XXX_unrecognized != nil {
4475 n += len(m.XXX_unrecognized)
4476 }
4477 return n
4478 }
4479
4480 func (m *OneofStdTypes_Timestamp) Size() (n int) {
4481 if m == nil {
4482 return 0
4483 }
4484 var l int
4485 _ = l
4486 if m.Timestamp != nil {
4487 l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)
4488 n += 1 + l + sovStdtypes(uint64(l))
4489 }
4490 return n
4491 }
4492 func (m *OneofStdTypes_Duration) Size() (n int) {
4493 if m == nil {
4494 return 0
4495 }
4496 var l int
4497 _ = l
4498 if m.Duration != nil {
4499 l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Duration)
4500 n += 1 + l + sovStdtypes(uint64(l))
4501 }
4502 return n
4503 }
4504 func (m *OneofStdTypes_RepDouble) Size() (n int) {
4505 if m == nil {
4506 return 0
4507 }
4508 var l int
4509 _ = l
4510 if m.RepDouble != nil {
4511 l = github_com_gogo_protobuf_types.SizeOfStdDouble(*m.RepDouble)
4512 n += 1 + l + sovStdtypes(uint64(l))
4513 }
4514 return n
4515 }
4516 func (m *OneofStdTypes_RepFloat) Size() (n int) {
4517 if m == nil {
4518 return 0
4519 }
4520 var l int
4521 _ = l
4522 if m.RepFloat != nil {
4523 l = github_com_gogo_protobuf_types.SizeOfStdFloat(*m.RepFloat)
4524 n += 1 + l + sovStdtypes(uint64(l))
4525 }
4526 return n
4527 }
4528 func (m *OneofStdTypes_RepInt64) Size() (n int) {
4529 if m == nil {
4530 return 0
4531 }
4532 var l int
4533 _ = l
4534 if m.RepInt64 != nil {
4535 l = github_com_gogo_protobuf_types.SizeOfStdInt64(*m.RepInt64)
4536 n += 1 + l + sovStdtypes(uint64(l))
4537 }
4538 return n
4539 }
4540 func (m *OneofStdTypes_RepUInt64) Size() (n int) {
4541 if m == nil {
4542 return 0
4543 }
4544 var l int
4545 _ = l
4546 if m.RepUInt64 != nil {
4547 l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.RepUInt64)
4548 n += 1 + l + sovStdtypes(uint64(l))
4549 }
4550 return n
4551 }
4552 func (m *OneofStdTypes_RepInt32) Size() (n int) {
4553 if m == nil {
4554 return 0
4555 }
4556 var l int
4557 _ = l
4558 if m.RepInt32 != nil {
4559 l = github_com_gogo_protobuf_types.SizeOfStdInt32(*m.RepInt32)
4560 n += 1 + l + sovStdtypes(uint64(l))
4561 }
4562 return n
4563 }
4564 func (m *OneofStdTypes_RepUInt32) Size() (n int) {
4565 if m == nil {
4566 return 0
4567 }
4568 var l int
4569 _ = l
4570 if m.RepUInt32 != nil {
4571 l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.RepUInt32)
4572 n += 1 + l + sovStdtypes(uint64(l))
4573 }
4574 return n
4575 }
4576 func (m *OneofStdTypes_RepBool) Size() (n int) {
4577 if m == nil {
4578 return 0
4579 }
4580 var l int
4581 _ = l
4582 if m.RepBool != nil {
4583 l = github_com_gogo_protobuf_types.SizeOfStdBool(*m.RepBool)
4584 n += 1 + l + sovStdtypes(uint64(l))
4585 }
4586 return n
4587 }
4588 func (m *OneofStdTypes_RepString) Size() (n int) {
4589 if m == nil {
4590 return 0
4591 }
4592 var l int
4593 _ = l
4594 if m.RepString != nil {
4595 l = github_com_gogo_protobuf_types.SizeOfStdString(*m.RepString)
4596 n += 1 + l + sovStdtypes(uint64(l))
4597 }
4598 return n
4599 }
4600 func (m *OneofStdTypes_RepBytes) Size() (n int) {
4601 if m == nil {
4602 return 0
4603 }
4604 var l int
4605 _ = l
4606 if m.RepBytes != nil {
4607 l = github_com_gogo_protobuf_types.SizeOfStdBytes(*m.RepBytes)
4608 n += 1 + l + sovStdtypes(uint64(l))
4609 }
4610 return n
4611 }
4612
4613 func sovStdtypes(x uint64) (n int) {
4614 return (math_bits.Len64(x|1) + 6) / 7
4615 }
4616 func sozStdtypes(x uint64) (n int) {
4617 return sovStdtypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
4618 }
4619
View as plain text