Debian Codegraph @

envoy/config/core/v3/base_vtproto.pb.go

raw
1 //go:build vtprotobuf
2 // +build vtprotobuf
3
4 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
5 // source: envoy/config/core/v3/base.proto
6
7 package corev3
8
9 import (
10 binary "encoding/binary"
11 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
12 anypb "github.com/planetscale/vtprotobuf/types/known/anypb"
13 structpb "github.com/planetscale/vtprotobuf/types/known/structpb"
14 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
15 proto "google.golang.org/protobuf/proto"
16 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
17 math "math"
18 )
19
20 const (
21 // Verify that this generated code is sufficiently up-to-date.
22 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
23 // Verify that runtime/protoimpl is sufficiently up-to-date.
24 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
25 )
26
27 func (m *Locality) MarshalVTStrict() (dAtA []byte, err error) {
28 if m == nil {
29 return nil, nil
30 }
31 size := m.SizeVT()
32 dAtA = make([]byte, size)
33 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
34 if err != nil {
35 return nil, err
36 }
37 return dAtA[:n], nil
38 }
39
40 func (m *Locality) MarshalToVTStrict(dAtA []byte) (int, error) {
41 size := m.SizeVT()
42 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
43 }
44
45 func (m *Locality) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
46 if m == nil {
47 return 0, nil
48 }
49 i := len(dAtA)
50 _ = i
51 var l int
52 _ = l
53 if m.unknownFields != nil {
54 i -= len(m.unknownFields)
55 copy(dAtA[i:], m.unknownFields)
56 }
57 if len(m.SubZone) > 0 {
58 i -= len(m.SubZone)
59 copy(dAtA[i:], m.SubZone)
60 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SubZone)))
61 i--
62 dAtA[i] = 0x1a
63 }
64 if len(m.Zone) > 0 {
65 i -= len(m.Zone)
66 copy(dAtA[i:], m.Zone)
67 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Zone)))
68 i--
69 dAtA[i] = 0x12
70 }
71 if len(m.Region) > 0 {
72 i -= len(m.Region)
73 copy(dAtA[i:], m.Region)
74 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Region)))
75 i--
76 dAtA[i] = 0xa
77 }
78 return len(dAtA) - i, nil
79 }
80
81 func (m *BuildVersion) MarshalVTStrict() (dAtA []byte, err error) {
82 if m == nil {
83 return nil, nil
84 }
85 size := m.SizeVT()
86 dAtA = make([]byte, size)
87 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
88 if err != nil {
89 return nil, err
90 }
91 return dAtA[:n], nil
92 }
93
94 func (m *BuildVersion) MarshalToVTStrict(dAtA []byte) (int, error) {
95 size := m.SizeVT()
96 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
97 }
98
99 func (m *BuildVersion) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
100 if m == nil {
101 return 0, nil
102 }
103 i := len(dAtA)
104 _ = i
105 var l int
106 _ = l
107 if m.unknownFields != nil {
108 i -= len(m.unknownFields)
109 copy(dAtA[i:], m.unknownFields)
110 }
111 if m.Metadata != nil {
112 size, err := (*structpb.Struct)(m.Metadata).MarshalToSizedBufferVTStrict(dAtA[:i])
113 if err != nil {
114 return 0, err
115 }
116 i -= size
117 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
118 i--
119 dAtA[i] = 0x12
120 }
121 if m.Version != nil {
122 if vtmsg, ok := interface{}(m.Version).(interface {
123 MarshalToSizedBufferVTStrict([]byte) (int, error)
124 }); ok {
125 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
126 if err != nil {
127 return 0, err
128 }
129 i -= size
130 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
131 } else {
132 encoded, err := proto.Marshal(m.Version)
133 if err != nil {
134 return 0, err
135 }
136 i -= len(encoded)
137 copy(dAtA[i:], encoded)
138 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
139 }
140 i--
141 dAtA[i] = 0xa
142 }
143 return len(dAtA) - i, nil
144 }
145
146 func (m *Extension) MarshalVTStrict() (dAtA []byte, err error) {
147 if m == nil {
148 return nil, nil
149 }
150 size := m.SizeVT()
151 dAtA = make([]byte, size)
152 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
153 if err != nil {
154 return nil, err
155 }
156 return dAtA[:n], nil
157 }
158
159 func (m *Extension) MarshalToVTStrict(dAtA []byte) (int, error) {
160 size := m.SizeVT()
161 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
162 }
163
164 func (m *Extension) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
165 if m == nil {
166 return 0, nil
167 }
168 i := len(dAtA)
169 _ = i
170 var l int
171 _ = l
172 if m.unknownFields != nil {
173 i -= len(m.unknownFields)
174 copy(dAtA[i:], m.unknownFields)
175 }
176 if len(m.TypeUrls) > 0 {
177 for iNdEx := len(m.TypeUrls) - 1; iNdEx >= 0; iNdEx-- {
178 i -= len(m.TypeUrls[iNdEx])
179 copy(dAtA[i:], m.TypeUrls[iNdEx])
180 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TypeUrls[iNdEx])))
181 i--
182 dAtA[i] = 0x32
183 }
184 }
185 if m.Disabled {
186 i--
187 if m.Disabled {
188 dAtA[i] = 1
189 } else {
190 dAtA[i] = 0
191 }
192 i--
193 dAtA[i] = 0x28
194 }
195 if m.Version != nil {
196 size, err := m.Version.MarshalToSizedBufferVTStrict(dAtA[:i])
197 if err != nil {
198 return 0, err
199 }
200 i -= size
201 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
202 i--
203 dAtA[i] = 0x22
204 }
205 if len(m.TypeDescriptor) > 0 {
206 i -= len(m.TypeDescriptor)
207 copy(dAtA[i:], m.TypeDescriptor)
208 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TypeDescriptor)))
209 i--
210 dAtA[i] = 0x1a
211 }
212 if len(m.Category) > 0 {
213 i -= len(m.Category)
214 copy(dAtA[i:], m.Category)
215 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Category)))
216 i--
217 dAtA[i] = 0x12
218 }
219 if len(m.Name) > 0 {
220 i -= len(m.Name)
221 copy(dAtA[i:], m.Name)
222 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
223 i--
224 dAtA[i] = 0xa
225 }
226 return len(dAtA) - i, nil
227 }
228
229 func (m *Node) MarshalVTStrict() (dAtA []byte, err error) {
230 if m == nil {
231 return nil, nil
232 }
233 size := m.SizeVT()
234 dAtA = make([]byte, size)
235 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
236 if err != nil {
237 return nil, err
238 }
239 return dAtA[:n], nil
240 }
241
242 func (m *Node) MarshalToVTStrict(dAtA []byte) (int, error) {
243 size := m.SizeVT()
244 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
245 }
246
247 func (m *Node) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
248 if m == nil {
249 return 0, nil
250 }
251 i := len(dAtA)
252 _ = i
253 var l int
254 _ = l
255 if m.unknownFields != nil {
256 i -= len(m.unknownFields)
257 copy(dAtA[i:], m.unknownFields)
258 }
259 if len(m.DynamicParameters) > 0 {
260 for k := range m.DynamicParameters {
261 v := m.DynamicParameters[k]
262 baseI := i
263 if vtmsg, ok := interface{}(v).(interface {
264 MarshalToSizedBufferVTStrict([]byte) (int, error)
265 }); ok {
266 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
267 if err != nil {
268 return 0, err
269 }
270 i -= size
271 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
272 } else {
273 encoded, err := proto.Marshal(v)
274 if err != nil {
275 return 0, err
276 }
277 i -= len(encoded)
278 copy(dAtA[i:], encoded)
279 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
280 }
281 i--
282 dAtA[i] = 0x12
283 i -= len(k)
284 copy(dAtA[i:], k)
285 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
286 i--
287 dAtA[i] = 0xa
288 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
289 i--
290 dAtA[i] = 0x62
291 }
292 }
293 if len(m.ListeningAddresses) > 0 {
294 for iNdEx := len(m.ListeningAddresses) - 1; iNdEx >= 0; iNdEx-- {
295 size, err := m.ListeningAddresses[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
296 if err != nil {
297 return 0, err
298 }
299 i -= size
300 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
301 i--
302 dAtA[i] = 0x5a
303 }
304 }
305 if len(m.ClientFeatures) > 0 {
306 for iNdEx := len(m.ClientFeatures) - 1; iNdEx >= 0; iNdEx-- {
307 i -= len(m.ClientFeatures[iNdEx])
308 copy(dAtA[i:], m.ClientFeatures[iNdEx])
309 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientFeatures[iNdEx])))
310 i--
311 dAtA[i] = 0x52
312 }
313 }
314 if len(m.Extensions) > 0 {
315 for iNdEx := len(m.Extensions) - 1; iNdEx >= 0; iNdEx-- {
316 size, err := m.Extensions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
317 if err != nil {
318 return 0, err
319 }
320 i -= size
321 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
322 i--
323 dAtA[i] = 0x4a
324 }
325 }
326 if msg, ok := m.UserAgentVersionType.(*Node_UserAgentBuildVersion); ok {
327 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
328 if err != nil {
329 return 0, err
330 }
331 i -= size
332 }
333 if msg, ok := m.UserAgentVersionType.(*Node_UserAgentVersion); ok {
334 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
335 if err != nil {
336 return 0, err
337 }
338 i -= size
339 }
340 if len(m.UserAgentName) > 0 {
341 i -= len(m.UserAgentName)
342 copy(dAtA[i:], m.UserAgentName)
343 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.UserAgentName)))
344 i--
345 dAtA[i] = 0x32
346 }
347 if m.Locality != nil {
348 size, err := m.Locality.MarshalToSizedBufferVTStrict(dAtA[:i])
349 if err != nil {
350 return 0, err
351 }
352 i -= size
353 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
354 i--
355 dAtA[i] = 0x22
356 }
357 if m.Metadata != nil {
358 size, err := (*structpb.Struct)(m.Metadata).MarshalToSizedBufferVTStrict(dAtA[:i])
359 if err != nil {
360 return 0, err
361 }
362 i -= size
363 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
364 i--
365 dAtA[i] = 0x1a
366 }
367 if len(m.Cluster) > 0 {
368 i -= len(m.Cluster)
369 copy(dAtA[i:], m.Cluster)
370 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Cluster)))
371 i--
372 dAtA[i] = 0x12
373 }
374 if len(m.Id) > 0 {
375 i -= len(m.Id)
376 copy(dAtA[i:], m.Id)
377 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id)))
378 i--
379 dAtA[i] = 0xa
380 }
381 return len(dAtA) - i, nil
382 }
383
384 func (m *Node_UserAgentVersion) MarshalToVTStrict(dAtA []byte) (int, error) {
385 size := m.SizeVT()
386 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
387 }
388
389 func (m *Node_UserAgentVersion) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
390 i := len(dAtA)
391 i -= len(m.UserAgentVersion)
392 copy(dAtA[i:], m.UserAgentVersion)
393 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.UserAgentVersion)))
394 i--
395 dAtA[i] = 0x3a
396 return len(dAtA) - i, nil
397 }
398 func (m *Node_UserAgentBuildVersion) MarshalToVTStrict(dAtA []byte) (int, error) {
399 size := m.SizeVT()
400 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
401 }
402
403 func (m *Node_UserAgentBuildVersion) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
404 i := len(dAtA)
405 if m.UserAgentBuildVersion != nil {
406 size, err := m.UserAgentBuildVersion.MarshalToSizedBufferVTStrict(dAtA[:i])
407 if err != nil {
408 return 0, err
409 }
410 i -= size
411 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
412 i--
413 dAtA[i] = 0x42
414 } else {
415 i = protohelpers.EncodeVarint(dAtA, i, 0)
416 i--
417 dAtA[i] = 0x42
418 }
419 return len(dAtA) - i, nil
420 }
421 func (m *Metadata) MarshalVTStrict() (dAtA []byte, err error) {
422 if m == nil {
423 return nil, nil
424 }
425 size := m.SizeVT()
426 dAtA = make([]byte, size)
427 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
428 if err != nil {
429 return nil, err
430 }
431 return dAtA[:n], nil
432 }
433
434 func (m *Metadata) MarshalToVTStrict(dAtA []byte) (int, error) {
435 size := m.SizeVT()
436 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
437 }
438
439 func (m *Metadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
440 if m == nil {
441 return 0, nil
442 }
443 i := len(dAtA)
444 _ = i
445 var l int
446 _ = l
447 if m.unknownFields != nil {
448 i -= len(m.unknownFields)
449 copy(dAtA[i:], m.unknownFields)
450 }
451 if len(m.TypedFilterMetadata) > 0 {
452 for k := range m.TypedFilterMetadata {
453 v := m.TypedFilterMetadata[k]
454 baseI := i
455 size, err := (*anypb.Any)(v).MarshalToSizedBufferVTStrict(dAtA[:i])
456 if err != nil {
457 return 0, err
458 }
459 i -= size
460 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
461 i--
462 dAtA[i] = 0x12
463 i -= len(k)
464 copy(dAtA[i:], k)
465 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
466 i--
467 dAtA[i] = 0xa
468 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
469 i--
470 dAtA[i] = 0x12
471 }
472 }
473 if len(m.FilterMetadata) > 0 {
474 for k := range m.FilterMetadata {
475 v := m.FilterMetadata[k]
476 baseI := i
477 size, err := (*structpb.Struct)(v).MarshalToSizedBufferVTStrict(dAtA[:i])
478 if err != nil {
479 return 0, err
480 }
481 i -= size
482 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
483 i--
484 dAtA[i] = 0x12
485 i -= len(k)
486 copy(dAtA[i:], k)
487 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
488 i--
489 dAtA[i] = 0xa
490 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
491 i--
492 dAtA[i] = 0xa
493 }
494 }
495 return len(dAtA) - i, nil
496 }
497
498 func (m *RuntimeUInt32) MarshalVTStrict() (dAtA []byte, err error) {
499 if m == nil {
500 return nil, nil
501 }
502 size := m.SizeVT()
503 dAtA = make([]byte, size)
504 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
505 if err != nil {
506 return nil, err
507 }
508 return dAtA[:n], nil
509 }
510
511 func (m *RuntimeUInt32) MarshalToVTStrict(dAtA []byte) (int, error) {
512 size := m.SizeVT()
513 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
514 }
515
516 func (m *RuntimeUInt32) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
517 if m == nil {
518 return 0, nil
519 }
520 i := len(dAtA)
521 _ = i
522 var l int
523 _ = l
524 if m.unknownFields != nil {
525 i -= len(m.unknownFields)
526 copy(dAtA[i:], m.unknownFields)
527 }
528 if len(m.RuntimeKey) > 0 {
529 i -= len(m.RuntimeKey)
530 copy(dAtA[i:], m.RuntimeKey)
531 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RuntimeKey)))
532 i--
533 dAtA[i] = 0x1a
534 }
535 if m.DefaultValue != 0 {
536 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DefaultValue))
537 i--
538 dAtA[i] = 0x10
539 }
540 return len(dAtA) - i, nil
541 }
542
543 func (m *RuntimePercent) MarshalVTStrict() (dAtA []byte, err error) {
544 if m == nil {
545 return nil, nil
546 }
547 size := m.SizeVT()
548 dAtA = make([]byte, size)
549 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
550 if err != nil {
551 return nil, err
552 }
553 return dAtA[:n], nil
554 }
555
556 func (m *RuntimePercent) MarshalToVTStrict(dAtA []byte) (int, error) {
557 size := m.SizeVT()
558 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
559 }
560
561 func (m *RuntimePercent) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
562 if m == nil {
563 return 0, nil
564 }
565 i := len(dAtA)
566 _ = i
567 var l int
568 _ = l
569 if m.unknownFields != nil {
570 i -= len(m.unknownFields)
571 copy(dAtA[i:], m.unknownFields)
572 }
573 if len(m.RuntimeKey) > 0 {
574 i -= len(m.RuntimeKey)
575 copy(dAtA[i:], m.RuntimeKey)
576 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RuntimeKey)))
577 i--
578 dAtA[i] = 0x12
579 }
580 if m.DefaultValue != nil {
581 if vtmsg, ok := interface{}(m.DefaultValue).(interface {
582 MarshalToSizedBufferVTStrict([]byte) (int, error)
583 }); ok {
584 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
585 if err != nil {
586 return 0, err
587 }
588 i -= size
589 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
590 } else {
591 encoded, err := proto.Marshal(m.DefaultValue)
592 if err != nil {
593 return 0, err
594 }
595 i -= len(encoded)
596 copy(dAtA[i:], encoded)
597 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
598 }
599 i--
600 dAtA[i] = 0xa
601 }
602 return len(dAtA) - i, nil
603 }
604
605 func (m *RuntimeDouble) MarshalVTStrict() (dAtA []byte, err error) {
606 if m == nil {
607 return nil, nil
608 }
609 size := m.SizeVT()
610 dAtA = make([]byte, size)
611 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
612 if err != nil {
613 return nil, err
614 }
615 return dAtA[:n], nil
616 }
617
618 func (m *RuntimeDouble) MarshalToVTStrict(dAtA []byte) (int, error) {
619 size := m.SizeVT()
620 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
621 }
622
623 func (m *RuntimeDouble) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
624 if m == nil {
625 return 0, nil
626 }
627 i := len(dAtA)
628 _ = i
629 var l int
630 _ = l
631 if m.unknownFields != nil {
632 i -= len(m.unknownFields)
633 copy(dAtA[i:], m.unknownFields)
634 }
635 if len(m.RuntimeKey) > 0 {
636 i -= len(m.RuntimeKey)
637 copy(dAtA[i:], m.RuntimeKey)
638 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RuntimeKey)))
639 i--
640 dAtA[i] = 0x12
641 }
642 if m.DefaultValue != 0 {
643 i -= 8
644 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DefaultValue))))
645 i--
646 dAtA[i] = 0x9
647 }
648 return len(dAtA) - i, nil
649 }
650
651 func (m *RuntimeFeatureFlag) MarshalVTStrict() (dAtA []byte, err error) {
652 if m == nil {
653 return nil, nil
654 }
655 size := m.SizeVT()
656 dAtA = make([]byte, size)
657 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
658 if err != nil {
659 return nil, err
660 }
661 return dAtA[:n], nil
662 }
663
664 func (m *RuntimeFeatureFlag) MarshalToVTStrict(dAtA []byte) (int, error) {
665 size := m.SizeVT()
666 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
667 }
668
669 func (m *RuntimeFeatureFlag) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
670 if m == nil {
671 return 0, nil
672 }
673 i := len(dAtA)
674 _ = i
675 var l int
676 _ = l
677 if m.unknownFields != nil {
678 i -= len(m.unknownFields)
679 copy(dAtA[i:], m.unknownFields)
680 }
681 if len(m.RuntimeKey) > 0 {
682 i -= len(m.RuntimeKey)
683 copy(dAtA[i:], m.RuntimeKey)
684 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RuntimeKey)))
685 i--
686 dAtA[i] = 0x12
687 }
688 if m.DefaultValue != nil {
689 size, err := (*wrapperspb.BoolValue)(m.DefaultValue).MarshalToSizedBufferVTStrict(dAtA[:i])
690 if err != nil {
691 return 0, err
692 }
693 i -= size
694 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
695 i--
696 dAtA[i] = 0xa
697 }
698 return len(dAtA) - i, nil
699 }
700
701 func (m *KeyValue) MarshalVTStrict() (dAtA []byte, err error) {
702 if m == nil {
703 return nil, nil
704 }
705 size := m.SizeVT()
706 dAtA = make([]byte, size)
707 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
708 if err != nil {
709 return nil, err
710 }
711 return dAtA[:n], nil
712 }
713
714 func (m *KeyValue) MarshalToVTStrict(dAtA []byte) (int, error) {
715 size := m.SizeVT()
716 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
717 }
718
719 func (m *KeyValue) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
720 if m == nil {
721 return 0, nil
722 }
723 i := len(dAtA)
724 _ = i
725 var l int
726 _ = l
727 if m.unknownFields != nil {
728 i -= len(m.unknownFields)
729 copy(dAtA[i:], m.unknownFields)
730 }
731 if len(m.Value) > 0 {
732 i -= len(m.Value)
733 copy(dAtA[i:], m.Value)
734 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))
735 i--
736 dAtA[i] = 0x12
737 }
738 if len(m.Key) > 0 {
739 i -= len(m.Key)
740 copy(dAtA[i:], m.Key)
741 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
742 i--
743 dAtA[i] = 0xa
744 }
745 return len(dAtA) - i, nil
746 }
747
748 func (m *KeyValuePair) MarshalVTStrict() (dAtA []byte, err error) {
749 if m == nil {
750 return nil, nil
751 }
752 size := m.SizeVT()
753 dAtA = make([]byte, size)
754 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
755 if err != nil {
756 return nil, err
757 }
758 return dAtA[:n], nil
759 }
760
761 func (m *KeyValuePair) MarshalToVTStrict(dAtA []byte) (int, error) {
762 size := m.SizeVT()
763 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
764 }
765
766 func (m *KeyValuePair) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
767 if m == nil {
768 return 0, nil
769 }
770 i := len(dAtA)
771 _ = i
772 var l int
773 _ = l
774 if m.unknownFields != nil {
775 i -= len(m.unknownFields)
776 copy(dAtA[i:], m.unknownFields)
777 }
778 if m.Value != nil {
779 size, err := (*structpb.Value)(m.Value).MarshalToSizedBufferVTStrict(dAtA[:i])
780 if err != nil {
781 return 0, err
782 }
783 i -= size
784 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
785 i--
786 dAtA[i] = 0x12
787 }
788 if len(m.Key) > 0 {
789 i -= len(m.Key)
790 copy(dAtA[i:], m.Key)
791 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
792 i--
793 dAtA[i] = 0xa
794 }
795 return len(dAtA) - i, nil
796 }
797
798 func (m *KeyValueAppend) MarshalVTStrict() (dAtA []byte, err error) {
799 if m == nil {
800 return nil, nil
801 }
802 size := m.SizeVT()
803 dAtA = make([]byte, size)
804 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
805 if err != nil {
806 return nil, err
807 }
808 return dAtA[:n], nil
809 }
810
811 func (m *KeyValueAppend) MarshalToVTStrict(dAtA []byte) (int, error) {
812 size := m.SizeVT()
813 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
814 }
815
816 func (m *KeyValueAppend) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
817 if m == nil {
818 return 0, nil
819 }
820 i := len(dAtA)
821 _ = i
822 var l int
823 _ = l
824 if m.unknownFields != nil {
825 i -= len(m.unknownFields)
826 copy(dAtA[i:], m.unknownFields)
827 }
828 if m.Record != nil {
829 size, err := m.Record.MarshalToSizedBufferVTStrict(dAtA[:i])
830 if err != nil {
831 return 0, err
832 }
833 i -= size
834 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
835 i--
836 dAtA[i] = 0x1a
837 }
838 if m.Action != 0 {
839 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Action))
840 i--
841 dAtA[i] = 0x10
842 }
843 if m.Entry != nil {
844 size, err := m.Entry.MarshalToSizedBufferVTStrict(dAtA[:i])
845 if err != nil {
846 return 0, err
847 }
848 i -= size
849 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
850 i--
851 dAtA[i] = 0xa
852 }
853 return len(dAtA) - i, nil
854 }
855
856 func (m *KeyValueMutation) MarshalVTStrict() (dAtA []byte, err error) {
857 if m == nil {
858 return nil, nil
859 }
860 size := m.SizeVT()
861 dAtA = make([]byte, size)
862 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
863 if err != nil {
864 return nil, err
865 }
866 return dAtA[:n], nil
867 }
868
869 func (m *KeyValueMutation) MarshalToVTStrict(dAtA []byte) (int, error) {
870 size := m.SizeVT()
871 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
872 }
873
874 func (m *KeyValueMutation) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
875 if m == nil {
876 return 0, nil
877 }
878 i := len(dAtA)
879 _ = i
880 var l int
881 _ = l
882 if m.unknownFields != nil {
883 i -= len(m.unknownFields)
884 copy(dAtA[i:], m.unknownFields)
885 }
886 if len(m.Remove) > 0 {
887 i -= len(m.Remove)
888 copy(dAtA[i:], m.Remove)
889 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Remove)))
890 i--
891 dAtA[i] = 0x12
892 }
893 if m.Append != nil {
894 size, err := m.Append.MarshalToSizedBufferVTStrict(dAtA[:i])
895 if err != nil {
896 return 0, err
897 }
898 i -= size
899 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
900 i--
901 dAtA[i] = 0xa
902 }
903 return len(dAtA) - i, nil
904 }
905
906 func (m *QueryParameter) MarshalVTStrict() (dAtA []byte, err error) {
907 if m == nil {
908 return nil, nil
909 }
910 size := m.SizeVT()
911 dAtA = make([]byte, size)
912 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
913 if err != nil {
914 return nil, err
915 }
916 return dAtA[:n], nil
917 }
918
919 func (m *QueryParameter) MarshalToVTStrict(dAtA []byte) (int, error) {
920 size := m.SizeVT()
921 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
922 }
923
924 func (m *QueryParameter) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
925 if m == nil {
926 return 0, nil
927 }
928 i := len(dAtA)
929 _ = i
930 var l int
931 _ = l
932 if m.unknownFields != nil {
933 i -= len(m.unknownFields)
934 copy(dAtA[i:], m.unknownFields)
935 }
936 if len(m.Value) > 0 {
937 i -= len(m.Value)
938 copy(dAtA[i:], m.Value)
939 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))
940 i--
941 dAtA[i] = 0x12
942 }
943 if len(m.Key) > 0 {
944 i -= len(m.Key)
945 copy(dAtA[i:], m.Key)
946 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
947 i--
948 dAtA[i] = 0xa
949 }
950 return len(dAtA) - i, nil
951 }
952
953 func (m *HeaderValue) MarshalVTStrict() (dAtA []byte, err error) {
954 if m == nil {
955 return nil, nil
956 }
957 size := m.SizeVT()
958 dAtA = make([]byte, size)
959 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
960 if err != nil {
961 return nil, err
962 }
963 return dAtA[:n], nil
964 }
965
966 func (m *HeaderValue) MarshalToVTStrict(dAtA []byte) (int, error) {
967 size := m.SizeVT()
968 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
969 }
970
971 func (m *HeaderValue) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
972 if m == nil {
973 return 0, nil
974 }
975 i := len(dAtA)
976 _ = i
977 var l int
978 _ = l
979 if m.unknownFields != nil {
980 i -= len(m.unknownFields)
981 copy(dAtA[i:], m.unknownFields)
982 }
983 if len(m.RawValue) > 0 {
984 i -= len(m.RawValue)
985 copy(dAtA[i:], m.RawValue)
986 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RawValue)))
987 i--
988 dAtA[i] = 0x1a
989 }
990 if len(m.Value) > 0 {
991 i -= len(m.Value)
992 copy(dAtA[i:], m.Value)
993 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))
994 i--
995 dAtA[i] = 0x12
996 }
997 if len(m.Key) > 0 {
998 i -= len(m.Key)
999 copy(dAtA[i:], m.Key)
1000 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
1001 i--
1002 dAtA[i] = 0xa
1003 }
1004 return len(dAtA) - i, nil
1005 }
1006
1007 func (m *HeaderValueOption) MarshalVTStrict() (dAtA []byte, err error) {
1008 if m == nil {
1009 return nil, nil
1010 }
1011 size := m.SizeVT()
1012 dAtA = make([]byte, size)
1013 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1014 if err != nil {
1015 return nil, err
1016 }
1017 return dAtA[:n], nil
1018 }
1019
1020 func (m *HeaderValueOption) MarshalToVTStrict(dAtA []byte) (int, error) {
1021 size := m.SizeVT()
1022 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1023 }
1024
1025 func (m *HeaderValueOption) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1026 if m == nil {
1027 return 0, nil
1028 }
1029 i := len(dAtA)
1030 _ = i
1031 var l int
1032 _ = l
1033 if m.unknownFields != nil {
1034 i -= len(m.unknownFields)
1035 copy(dAtA[i:], m.unknownFields)
1036 }
1037 if m.KeepEmptyValue {
1038 i--
1039 if m.KeepEmptyValue {
1040 dAtA[i] = 1
1041 } else {
1042 dAtA[i] = 0
1043 }
1044 i--
1045 dAtA[i] = 0x20
1046 }
1047 if m.AppendAction != 0 {
1048 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.AppendAction))
1049 i--
1050 dAtA[i] = 0x18
1051 }
1052 if m.Append != nil {
1053 size, err := (*wrapperspb.BoolValue)(m.Append).MarshalToSizedBufferVTStrict(dAtA[:i])
1054 if err != nil {
1055 return 0, err
1056 }
1057 i -= size
1058 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1059 i--
1060 dAtA[i] = 0x12
1061 }
1062 if m.Header != nil {
1063 size, err := m.Header.MarshalToSizedBufferVTStrict(dAtA[:i])
1064 if err != nil {
1065 return 0, err
1066 }
1067 i -= size
1068 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1069 i--
1070 dAtA[i] = 0xa
1071 }
1072 return len(dAtA) - i, nil
1073 }
1074
1075 func (m *HeaderMap) MarshalVTStrict() (dAtA []byte, err error) {
1076 if m == nil {
1077 return nil, nil
1078 }
1079 size := m.SizeVT()
1080 dAtA = make([]byte, size)
1081 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1082 if err != nil {
1083 return nil, err
1084 }
1085 return dAtA[:n], nil
1086 }
1087
1088 func (m *HeaderMap) MarshalToVTStrict(dAtA []byte) (int, error) {
1089 size := m.SizeVT()
1090 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1091 }
1092
1093 func (m *HeaderMap) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1094 if m == nil {
1095 return 0, nil
1096 }
1097 i := len(dAtA)
1098 _ = i
1099 var l int
1100 _ = l
1101 if m.unknownFields != nil {
1102 i -= len(m.unknownFields)
1103 copy(dAtA[i:], m.unknownFields)
1104 }
1105 if len(m.Headers) > 0 {
1106 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
1107 size, err := m.Headers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1108 if err != nil {
1109 return 0, err
1110 }
1111 i -= size
1112 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1113 i--
1114 dAtA[i] = 0xa
1115 }
1116 }
1117 return len(dAtA) - i, nil
1118 }
1119
1120 func (m *WatchedDirectory) MarshalVTStrict() (dAtA []byte, err error) {
1121 if m == nil {
1122 return nil, nil
1123 }
1124 size := m.SizeVT()
1125 dAtA = make([]byte, size)
1126 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1127 if err != nil {
1128 return nil, err
1129 }
1130 return dAtA[:n], nil
1131 }
1132
1133 func (m *WatchedDirectory) MarshalToVTStrict(dAtA []byte) (int, error) {
1134 size := m.SizeVT()
1135 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1136 }
1137
1138 func (m *WatchedDirectory) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1139 if m == nil {
1140 return 0, nil
1141 }
1142 i := len(dAtA)
1143 _ = i
1144 var l int
1145 _ = l
1146 if m.unknownFields != nil {
1147 i -= len(m.unknownFields)
1148 copy(dAtA[i:], m.unknownFields)
1149 }
1150 if len(m.Path) > 0 {
1151 i -= len(m.Path)
1152 copy(dAtA[i:], m.Path)
1153 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
1154 i--
1155 dAtA[i] = 0xa
1156 }
1157 return len(dAtA) - i, nil
1158 }
1159
1160 func (m *DataSource) MarshalVTStrict() (dAtA []byte, err error) {
1161 if m == nil {
1162 return nil, nil
1163 }
1164 size := m.SizeVT()
1165 dAtA = make([]byte, size)
1166 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1167 if err != nil {
1168 return nil, err
1169 }
1170 return dAtA[:n], nil
1171 }
1172
1173 func (m *DataSource) MarshalToVTStrict(dAtA []byte) (int, error) {
1174 size := m.SizeVT()
1175 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1176 }
1177
1178 func (m *DataSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1179 if m == nil {
1180 return 0, nil
1181 }
1182 i := len(dAtA)
1183 _ = i
1184 var l int
1185 _ = l
1186 if m.unknownFields != nil {
1187 i -= len(m.unknownFields)
1188 copy(dAtA[i:], m.unknownFields)
1189 }
1190 if m.WatchedDirectory != nil {
1191 size, err := m.WatchedDirectory.MarshalToSizedBufferVTStrict(dAtA[:i])
1192 if err != nil {
1193 return 0, err
1194 }
1195 i -= size
1196 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1197 i--
1198 dAtA[i] = 0x2a
1199 }
1200 if msg, ok := m.Specifier.(*DataSource_EnvironmentVariable); ok {
1201 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1202 if err != nil {
1203 return 0, err
1204 }
1205 i -= size
1206 }
1207 if msg, ok := m.Specifier.(*DataSource_InlineString); ok {
1208 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1209 if err != nil {
1210 return 0, err
1211 }
1212 i -= size
1213 }
1214 if msg, ok := m.Specifier.(*DataSource_InlineBytes); ok {
1215 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1216 if err != nil {
1217 return 0, err
1218 }
1219 i -= size
1220 }
1221 if msg, ok := m.Specifier.(*DataSource_Filename); ok {
1222 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1223 if err != nil {
1224 return 0, err
1225 }
1226 i -= size
1227 }
1228 return len(dAtA) - i, nil
1229 }
1230
1231 func (m *DataSource_Filename) MarshalToVTStrict(dAtA []byte) (int, error) {
1232 size := m.SizeVT()
1233 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1234 }
1235
1236 func (m *DataSource_Filename) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1237 i := len(dAtA)
1238 i -= len(m.Filename)
1239 copy(dAtA[i:], m.Filename)
1240 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Filename)))
1241 i--
1242 dAtA[i] = 0xa
1243 return len(dAtA) - i, nil
1244 }
1245 func (m *DataSource_InlineBytes) MarshalToVTStrict(dAtA []byte) (int, error) {
1246 size := m.SizeVT()
1247 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1248 }
1249
1250 func (m *DataSource_InlineBytes) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1251 i := len(dAtA)
1252 i -= len(m.InlineBytes)
1253 copy(dAtA[i:], m.InlineBytes)
1254 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InlineBytes)))
1255 i--
1256 dAtA[i] = 0x12
1257 return len(dAtA) - i, nil
1258 }
1259 func (m *DataSource_InlineString) MarshalToVTStrict(dAtA []byte) (int, error) {
1260 size := m.SizeVT()
1261 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1262 }
1263
1264 func (m *DataSource_InlineString) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1265 i := len(dAtA)
1266 i -= len(m.InlineString)
1267 copy(dAtA[i:], m.InlineString)
1268 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InlineString)))
1269 i--
1270 dAtA[i] = 0x1a
1271 return len(dAtA) - i, nil
1272 }
1273 func (m *DataSource_EnvironmentVariable) MarshalToVTStrict(dAtA []byte) (int, error) {
1274 size := m.SizeVT()
1275 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1276 }
1277
1278 func (m *DataSource_EnvironmentVariable) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1279 i := len(dAtA)
1280 i -= len(m.EnvironmentVariable)
1281 copy(dAtA[i:], m.EnvironmentVariable)
1282 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EnvironmentVariable)))
1283 i--
1284 dAtA[i] = 0x22
1285 return len(dAtA) - i, nil
1286 }
1287 func (m *RetryPolicy_RetryPriority) MarshalVTStrict() (dAtA []byte, err error) {
1288 if m == nil {
1289 return nil, nil
1290 }
1291 size := m.SizeVT()
1292 dAtA = make([]byte, size)
1293 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1294 if err != nil {
1295 return nil, err
1296 }
1297 return dAtA[:n], nil
1298 }
1299
1300 func (m *RetryPolicy_RetryPriority) MarshalToVTStrict(dAtA []byte) (int, error) {
1301 size := m.SizeVT()
1302 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1303 }
1304
1305 func (m *RetryPolicy_RetryPriority) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1306 if m == nil {
1307 return 0, nil
1308 }
1309 i := len(dAtA)
1310 _ = i
1311 var l int
1312 _ = l
1313 if m.unknownFields != nil {
1314 i -= len(m.unknownFields)
1315 copy(dAtA[i:], m.unknownFields)
1316 }
1317 if msg, ok := m.ConfigType.(*RetryPolicy_RetryPriority_TypedConfig); ok {
1318 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1319 if err != nil {
1320 return 0, err
1321 }
1322 i -= size
1323 }
1324 if len(m.Name) > 0 {
1325 i -= len(m.Name)
1326 copy(dAtA[i:], m.Name)
1327 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1328 i--
1329 dAtA[i] = 0xa
1330 }
1331 return len(dAtA) - i, nil
1332 }
1333
1334 func (m *RetryPolicy_RetryPriority_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
1335 size := m.SizeVT()
1336 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1337 }
1338
1339 func (m *RetryPolicy_RetryPriority_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1340 i := len(dAtA)
1341 if m.TypedConfig != nil {
1342 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
1343 if err != nil {
1344 return 0, err
1345 }
1346 i -= size
1347 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1348 i--
1349 dAtA[i] = 0x12
1350 } else {
1351 i = protohelpers.EncodeVarint(dAtA, i, 0)
1352 i--
1353 dAtA[i] = 0x12
1354 }
1355 return len(dAtA) - i, nil
1356 }
1357 func (m *RetryPolicy_RetryHostPredicate) MarshalVTStrict() (dAtA []byte, err error) {
1358 if m == nil {
1359 return nil, nil
1360 }
1361 size := m.SizeVT()
1362 dAtA = make([]byte, size)
1363 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1364 if err != nil {
1365 return nil, err
1366 }
1367 return dAtA[:n], nil
1368 }
1369
1370 func (m *RetryPolicy_RetryHostPredicate) MarshalToVTStrict(dAtA []byte) (int, error) {
1371 size := m.SizeVT()
1372 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1373 }
1374
1375 func (m *RetryPolicy_RetryHostPredicate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1376 if m == nil {
1377 return 0, nil
1378 }
1379 i := len(dAtA)
1380 _ = i
1381 var l int
1382 _ = l
1383 if m.unknownFields != nil {
1384 i -= len(m.unknownFields)
1385 copy(dAtA[i:], m.unknownFields)
1386 }
1387 if msg, ok := m.ConfigType.(*RetryPolicy_RetryHostPredicate_TypedConfig); ok {
1388 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1389 if err != nil {
1390 return 0, err
1391 }
1392 i -= size
1393 }
1394 if len(m.Name) > 0 {
1395 i -= len(m.Name)
1396 copy(dAtA[i:], m.Name)
1397 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1398 i--
1399 dAtA[i] = 0xa
1400 }
1401 return len(dAtA) - i, nil
1402 }
1403
1404 func (m *RetryPolicy_RetryHostPredicate_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
1405 size := m.SizeVT()
1406 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1407 }
1408
1409 func (m *RetryPolicy_RetryHostPredicate_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1410 i := len(dAtA)
1411 if m.TypedConfig != nil {
1412 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
1413 if err != nil {
1414 return 0, err
1415 }
1416 i -= size
1417 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1418 i--
1419 dAtA[i] = 0x12
1420 } else {
1421 i = protohelpers.EncodeVarint(dAtA, i, 0)
1422 i--
1423 dAtA[i] = 0x12
1424 }
1425 return len(dAtA) - i, nil
1426 }
1427 func (m *RetryPolicy) MarshalVTStrict() (dAtA []byte, err error) {
1428 if m == nil {
1429 return nil, nil
1430 }
1431 size := m.SizeVT()
1432 dAtA = make([]byte, size)
1433 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1434 if err != nil {
1435 return nil, err
1436 }
1437 return dAtA[:n], nil
1438 }
1439
1440 func (m *RetryPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
1441 size := m.SizeVT()
1442 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1443 }
1444
1445 func (m *RetryPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1446 if m == nil {
1447 return 0, nil
1448 }
1449 i := len(dAtA)
1450 _ = i
1451 var l int
1452 _ = l
1453 if m.unknownFields != nil {
1454 i -= len(m.unknownFields)
1455 copy(dAtA[i:], m.unknownFields)
1456 }
1457 if m.HostSelectionRetryMaxAttempts != 0 {
1458 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HostSelectionRetryMaxAttempts))
1459 i--
1460 dAtA[i] = 0x30
1461 }
1462 if len(m.RetryHostPredicate) > 0 {
1463 for iNdEx := len(m.RetryHostPredicate) - 1; iNdEx >= 0; iNdEx-- {
1464 size, err := m.RetryHostPredicate[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1465 if err != nil {
1466 return 0, err
1467 }
1468 i -= size
1469 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1470 i--
1471 dAtA[i] = 0x2a
1472 }
1473 }
1474 if m.RetryPriority != nil {
1475 size, err := m.RetryPriority.MarshalToSizedBufferVTStrict(dAtA[:i])
1476 if err != nil {
1477 return 0, err
1478 }
1479 i -= size
1480 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1481 i--
1482 dAtA[i] = 0x22
1483 }
1484 if len(m.RetryOn) > 0 {
1485 i -= len(m.RetryOn)
1486 copy(dAtA[i:], m.RetryOn)
1487 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RetryOn)))
1488 i--
1489 dAtA[i] = 0x1a
1490 }
1491 if m.NumRetries != nil {
1492 size, err := (*wrapperspb.UInt32Value)(m.NumRetries).MarshalToSizedBufferVTStrict(dAtA[:i])
1493 if err != nil {
1494 return 0, err
1495 }
1496 i -= size
1497 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1498 i--
1499 dAtA[i] = 0x12
1500 }
1501 if m.RetryBackOff != nil {
1502 size, err := m.RetryBackOff.MarshalToSizedBufferVTStrict(dAtA[:i])
1503 if err != nil {
1504 return 0, err
1505 }
1506 i -= size
1507 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1508 i--
1509 dAtA[i] = 0xa
1510 }
1511 return len(dAtA) - i, nil
1512 }
1513
1514 func (m *RemoteDataSource) MarshalVTStrict() (dAtA []byte, err error) {
1515 if m == nil {
1516 return nil, nil
1517 }
1518 size := m.SizeVT()
1519 dAtA = make([]byte, size)
1520 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1521 if err != nil {
1522 return nil, err
1523 }
1524 return dAtA[:n], nil
1525 }
1526
1527 func (m *RemoteDataSource) MarshalToVTStrict(dAtA []byte) (int, error) {
1528 size := m.SizeVT()
1529 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1530 }
1531
1532 func (m *RemoteDataSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1533 if m == nil {
1534 return 0, nil
1535 }
1536 i := len(dAtA)
1537 _ = i
1538 var l int
1539 _ = l
1540 if m.unknownFields != nil {
1541 i -= len(m.unknownFields)
1542 copy(dAtA[i:], m.unknownFields)
1543 }
1544 if m.RetryPolicy != nil {
1545 size, err := m.RetryPolicy.MarshalToSizedBufferVTStrict(dAtA[:i])
1546 if err != nil {
1547 return 0, err
1548 }
1549 i -= size
1550 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1551 i--
1552 dAtA[i] = 0x1a
1553 }
1554 if len(m.Sha256) > 0 {
1555 i -= len(m.Sha256)
1556 copy(dAtA[i:], m.Sha256)
1557 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Sha256)))
1558 i--
1559 dAtA[i] = 0x12
1560 }
1561 if m.HttpUri != nil {
1562 size, err := m.HttpUri.MarshalToSizedBufferVTStrict(dAtA[:i])
1563 if err != nil {
1564 return 0, err
1565 }
1566 i -= size
1567 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1568 i--
1569 dAtA[i] = 0xa
1570 }
1571 return len(dAtA) - i, nil
1572 }
1573
1574 func (m *AsyncDataSource) MarshalVTStrict() (dAtA []byte, err error) {
1575 if m == nil {
1576 return nil, nil
1577 }
1578 size := m.SizeVT()
1579 dAtA = make([]byte, size)
1580 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1581 if err != nil {
1582 return nil, err
1583 }
1584 return dAtA[:n], nil
1585 }
1586
1587 func (m *AsyncDataSource) MarshalToVTStrict(dAtA []byte) (int, error) {
1588 size := m.SizeVT()
1589 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1590 }
1591
1592 func (m *AsyncDataSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1593 if m == nil {
1594 return 0, nil
1595 }
1596 i := len(dAtA)
1597 _ = i
1598 var l int
1599 _ = l
1600 if m.unknownFields != nil {
1601 i -= len(m.unknownFields)
1602 copy(dAtA[i:], m.unknownFields)
1603 }
1604 if msg, ok := m.Specifier.(*AsyncDataSource_Remote); ok {
1605 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1606 if err != nil {
1607 return 0, err
1608 }
1609 i -= size
1610 }
1611 if msg, ok := m.Specifier.(*AsyncDataSource_Local); ok {
1612 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1613 if err != nil {
1614 return 0, err
1615 }
1616 i -= size
1617 }
1618 return len(dAtA) - i, nil
1619 }
1620
1621 func (m *AsyncDataSource_Local) MarshalToVTStrict(dAtA []byte) (int, error) {
1622 size := m.SizeVT()
1623 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1624 }
1625
1626 func (m *AsyncDataSource_Local) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1627 i := len(dAtA)
1628 if m.Local != nil {
1629 size, err := m.Local.MarshalToSizedBufferVTStrict(dAtA[:i])
1630 if err != nil {
1631 return 0, err
1632 }
1633 i -= size
1634 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1635 i--
1636 dAtA[i] = 0xa
1637 } else {
1638 i = protohelpers.EncodeVarint(dAtA, i, 0)
1639 i--
1640 dAtA[i] = 0xa
1641 }
1642 return len(dAtA) - i, nil
1643 }
1644 func (m *AsyncDataSource_Remote) MarshalToVTStrict(dAtA []byte) (int, error) {
1645 size := m.SizeVT()
1646 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1647 }
1648
1649 func (m *AsyncDataSource_Remote) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1650 i := len(dAtA)
1651 if m.Remote != nil {
1652 size, err := m.Remote.MarshalToSizedBufferVTStrict(dAtA[:i])
1653 if err != nil {
1654 return 0, err
1655 }
1656 i -= size
1657 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1658 i--
1659 dAtA[i] = 0x12
1660 } else {
1661 i = protohelpers.EncodeVarint(dAtA, i, 0)
1662 i--
1663 dAtA[i] = 0x12
1664 }
1665 return len(dAtA) - i, nil
1666 }
1667 func (m *TransportSocket) MarshalVTStrict() (dAtA []byte, err error) {
1668 if m == nil {
1669 return nil, nil
1670 }
1671 size := m.SizeVT()
1672 dAtA = make([]byte, size)
1673 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1674 if err != nil {
1675 return nil, err
1676 }
1677 return dAtA[:n], nil
1678 }
1679
1680 func (m *TransportSocket) MarshalToVTStrict(dAtA []byte) (int, error) {
1681 size := m.SizeVT()
1682 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1683 }
1684
1685 func (m *TransportSocket) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1686 if m == nil {
1687 return 0, nil
1688 }
1689 i := len(dAtA)
1690 _ = i
1691 var l int
1692 _ = l
1693 if m.unknownFields != nil {
1694 i -= len(m.unknownFields)
1695 copy(dAtA[i:], m.unknownFields)
1696 }
1697 if msg, ok := m.ConfigType.(*TransportSocket_TypedConfig); ok {
1698 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1699 if err != nil {
1700 return 0, err
1701 }
1702 i -= size
1703 }
1704 if len(m.Name) > 0 {
1705 i -= len(m.Name)
1706 copy(dAtA[i:], m.Name)
1707 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1708 i--
1709 dAtA[i] = 0xa
1710 }
1711 return len(dAtA) - i, nil
1712 }
1713
1714 func (m *TransportSocket_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
1715 size := m.SizeVT()
1716 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1717 }
1718
1719 func (m *TransportSocket_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1720 i := len(dAtA)
1721 if m.TypedConfig != nil {
1722 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
1723 if err != nil {
1724 return 0, err
1725 }
1726 i -= size
1727 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1728 i--
1729 dAtA[i] = 0x1a
1730 } else {
1731 i = protohelpers.EncodeVarint(dAtA, i, 0)
1732 i--
1733 dAtA[i] = 0x1a
1734 }
1735 return len(dAtA) - i, nil
1736 }
1737 func (m *RuntimeFractionalPercent) MarshalVTStrict() (dAtA []byte, err error) {
1738 if m == nil {
1739 return nil, nil
1740 }
1741 size := m.SizeVT()
1742 dAtA = make([]byte, size)
1743 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1744 if err != nil {
1745 return nil, err
1746 }
1747 return dAtA[:n], nil
1748 }
1749
1750 func (m *RuntimeFractionalPercent) MarshalToVTStrict(dAtA []byte) (int, error) {
1751 size := m.SizeVT()
1752 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1753 }
1754
1755 func (m *RuntimeFractionalPercent) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1756 if m == nil {
1757 return 0, nil
1758 }
1759 i := len(dAtA)
1760 _ = i
1761 var l int
1762 _ = l
1763 if m.unknownFields != nil {
1764 i -= len(m.unknownFields)
1765 copy(dAtA[i:], m.unknownFields)
1766 }
1767 if len(m.RuntimeKey) > 0 {
1768 i -= len(m.RuntimeKey)
1769 copy(dAtA[i:], m.RuntimeKey)
1770 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RuntimeKey)))
1771 i--
1772 dAtA[i] = 0x12
1773 }
1774 if m.DefaultValue != nil {
1775 if vtmsg, ok := interface{}(m.DefaultValue).(interface {
1776 MarshalToSizedBufferVTStrict([]byte) (int, error)
1777 }); ok {
1778 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1779 if err != nil {
1780 return 0, err
1781 }
1782 i -= size
1783 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1784 } else {
1785 encoded, err := proto.Marshal(m.DefaultValue)
1786 if err != nil {
1787 return 0, err
1788 }
1789 i -= len(encoded)
1790 copy(dAtA[i:], encoded)
1791 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1792 }
1793 i--
1794 dAtA[i] = 0xa
1795 }
1796 return len(dAtA) - i, nil
1797 }
1798
1799 func (m *ControlPlane) MarshalVTStrict() (dAtA []byte, err error) {
1800 if m == nil {
1801 return nil, nil
1802 }
1803 size := m.SizeVT()
1804 dAtA = make([]byte, size)
1805 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1806 if err != nil {
1807 return nil, err
1808 }
1809 return dAtA[:n], nil
1810 }
1811
1812 func (m *ControlPlane) MarshalToVTStrict(dAtA []byte) (int, error) {
1813 size := m.SizeVT()
1814 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1815 }
1816
1817 func (m *ControlPlane) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1818 if m == nil {
1819 return 0, nil
1820 }
1821 i := len(dAtA)
1822 _ = i
1823 var l int
1824 _ = l
1825 if m.unknownFields != nil {
1826 i -= len(m.unknownFields)
1827 copy(dAtA[i:], m.unknownFields)
1828 }
1829 if len(m.Identifier) > 0 {
1830 i -= len(m.Identifier)
1831 copy(dAtA[i:], m.Identifier)
1832 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Identifier)))
1833 i--
1834 dAtA[i] = 0xa
1835 }
1836 return len(dAtA) - i, nil
1837 }
1838
1839 func (m *Locality) SizeVT() (n int) {
1840 if m == nil {
1841 return 0
1842 }
1843 var l int
1844 _ = l
1845 l = len(m.Region)
1846 if l > 0 {
1847 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1848 }
1849 l = len(m.Zone)
1850 if l > 0 {
1851 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1852 }
1853 l = len(m.SubZone)
1854 if l > 0 {
1855 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1856 }
1857 n += len(m.unknownFields)
1858 return n
1859 }
1860
1861 func (m *BuildVersion) SizeVT() (n int) {
1862 if m == nil {
1863 return 0
1864 }
1865 var l int
1866 _ = l
1867 if m.Version != nil {
1868 if size, ok := interface{}(m.Version).(interface {
1869 SizeVT() int
1870 }); ok {
1871 l = size.SizeVT()
1872 } else {
1873 l = proto.Size(m.Version)
1874 }
1875 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1876 }
1877 if m.Metadata != nil {
1878 l = (*structpb.Struct)(m.Metadata).SizeVT()
1879 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1880 }
1881 n += len(m.unknownFields)
1882 return n
1883 }
1884
1885 func (m *Extension) SizeVT() (n int) {
1886 if m == nil {
1887 return 0
1888 }
1889 var l int
1890 _ = l
1891 l = len(m.Name)
1892 if l > 0 {
1893 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1894 }
1895 l = len(m.Category)
1896 if l > 0 {
1897 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1898 }
1899 l = len(m.TypeDescriptor)
1900 if l > 0 {
1901 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1902 }
1903 if m.Version != nil {
1904 l = m.Version.SizeVT()
1905 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1906 }
1907 if m.Disabled {
1908 n += 2
1909 }
1910 if len(m.TypeUrls) > 0 {
1911 for _, s := range m.TypeUrls {
1912 l = len(s)
1913 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1914 }
1915 }
1916 n += len(m.unknownFields)
1917 return n
1918 }
1919
1920 func (m *Node) SizeVT() (n int) {
1921 if m == nil {
1922 return 0
1923 }
1924 var l int
1925 _ = l
1926 l = len(m.Id)
1927 if l > 0 {
1928 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1929 }
1930 l = len(m.Cluster)
1931 if l > 0 {
1932 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1933 }
1934 if m.Metadata != nil {
1935 l = (*structpb.Struct)(m.Metadata).SizeVT()
1936 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1937 }
1938 if m.Locality != nil {
1939 l = m.Locality.SizeVT()
1940 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1941 }
1942 l = len(m.UserAgentName)
1943 if l > 0 {
1944 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1945 }
1946 if vtmsg, ok := m.UserAgentVersionType.(interface{ SizeVT() int }); ok {
1947 n += vtmsg.SizeVT()
1948 }
1949 if len(m.Extensions) > 0 {
1950 for _, e := range m.Extensions {
1951 l = e.SizeVT()
1952 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1953 }
1954 }
1955 if len(m.ClientFeatures) > 0 {
1956 for _, s := range m.ClientFeatures {
1957 l = len(s)
1958 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1959 }
1960 }
1961 if len(m.ListeningAddresses) > 0 {
1962 for _, e := range m.ListeningAddresses {
1963 l = e.SizeVT()
1964 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1965 }
1966 }
1967 if len(m.DynamicParameters) > 0 {
1968 for k, v := range m.DynamicParameters {
1969 _ = k
1970 _ = v
1971 l = 0
1972 if v != nil {
1973 if size, ok := interface{}(v).(interface {
1974 SizeVT() int
1975 }); ok {
1976 l = size.SizeVT()
1977 } else {
1978 l = proto.Size(v)
1979 }
1980 }
1981 l += 1 + protohelpers.SizeOfVarint(uint64(l))
1982 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
1983 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
1984 }
1985 }
1986 n += len(m.unknownFields)
1987 return n
1988 }
1989
1990 func (m *Node_UserAgentVersion) SizeVT() (n int) {
1991 if m == nil {
1992 return 0
1993 }
1994 var l int
1995 _ = l
1996 l = len(m.UserAgentVersion)
1997 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1998 return n
1999 }
2000 func (m *Node_UserAgentBuildVersion) SizeVT() (n int) {
2001 if m == nil {
2002 return 0
2003 }
2004 var l int
2005 _ = l
2006 if m.UserAgentBuildVersion != nil {
2007 l = m.UserAgentBuildVersion.SizeVT()
2008 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2009 } else {
2010 n += 2
2011 }
2012 return n
2013 }
2014 func (m *Metadata) SizeVT() (n int) {
2015 if m == nil {
2016 return 0
2017 }
2018 var l int
2019 _ = l
2020 if len(m.FilterMetadata) > 0 {
2021 for k, v := range m.FilterMetadata {
2022 _ = k
2023 _ = v
2024 l = 0
2025 if v != nil {
2026 l = (*structpb.Struct)(v).SizeVT()
2027 }
2028 l += 1 + protohelpers.SizeOfVarint(uint64(l))
2029 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
2030 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
2031 }
2032 }
2033 if len(m.TypedFilterMetadata) > 0 {
2034 for k, v := range m.TypedFilterMetadata {
2035 _ = k
2036 _ = v
2037 l = 0
2038 if v != nil {
2039 l = (*anypb.Any)(v).SizeVT()
2040 }
2041 l += 1 + protohelpers.SizeOfVarint(uint64(l))
2042 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
2043 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
2044 }
2045 }
2046 n += len(m.unknownFields)
2047 return n
2048 }
2049
2050 func (m *RuntimeUInt32) SizeVT() (n int) {
2051 if m == nil {
2052 return 0
2053 }
2054 var l int
2055 _ = l
2056 if m.DefaultValue != 0 {
2057 n += 1 + protohelpers.SizeOfVarint(uint64(m.DefaultValue))
2058 }
2059 l = len(m.RuntimeKey)
2060 if l > 0 {
2061 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2062 }
2063 n += len(m.unknownFields)
2064 return n
2065 }
2066
2067 func (m *RuntimePercent) SizeVT() (n int) {
2068 if m == nil {
2069 return 0
2070 }
2071 var l int
2072 _ = l
2073 if m.DefaultValue != nil {
2074 if size, ok := interface{}(m.DefaultValue).(interface {
2075 SizeVT() int
2076 }); ok {
2077 l = size.SizeVT()
2078 } else {
2079 l = proto.Size(m.DefaultValue)
2080 }
2081 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2082 }
2083 l = len(m.RuntimeKey)
2084 if l > 0 {
2085 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2086 }
2087 n += len(m.unknownFields)
2088 return n
2089 }
2090
2091 func (m *RuntimeDouble) SizeVT() (n int) {
2092 if m == nil {
2093 return 0
2094 }
2095 var l int
2096 _ = l
2097 if m.DefaultValue != 0 {
2098 n += 9
2099 }
2100 l = len(m.RuntimeKey)
2101 if l > 0 {
2102 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2103 }
2104 n += len(m.unknownFields)
2105 return n
2106 }
2107
2108 func (m *RuntimeFeatureFlag) SizeVT() (n int) {
2109 if m == nil {
2110 return 0
2111 }
2112 var l int
2113 _ = l
2114 if m.DefaultValue != nil {
2115 l = (*wrapperspb.BoolValue)(m.DefaultValue).SizeVT()
2116 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2117 }
2118 l = len(m.RuntimeKey)
2119 if l > 0 {
2120 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2121 }
2122 n += len(m.unknownFields)
2123 return n
2124 }
2125
2126 func (m *KeyValue) SizeVT() (n int) {
2127 if m == nil {
2128 return 0
2129 }
2130 var l int
2131 _ = l
2132 l = len(m.Key)
2133 if l > 0 {
2134 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2135 }
2136 l = len(m.Value)
2137 if l > 0 {
2138 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2139 }
2140 n += len(m.unknownFields)
2141 return n
2142 }
2143
2144 func (m *KeyValuePair) SizeVT() (n int) {
2145 if m == nil {
2146 return 0
2147 }
2148 var l int
2149 _ = l
2150 l = len(m.Key)
2151 if l > 0 {
2152 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2153 }
2154 if m.Value != nil {
2155 l = (*structpb.Value)(m.Value).SizeVT()
2156 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2157 }
2158 n += len(m.unknownFields)
2159 return n
2160 }
2161
2162 func (m *KeyValueAppend) SizeVT() (n int) {
2163 if m == nil {
2164 return 0
2165 }
2166 var l int
2167 _ = l
2168 if m.Entry != nil {
2169 l = m.Entry.SizeVT()
2170 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2171 }
2172 if m.Action != 0 {
2173 n += 1 + protohelpers.SizeOfVarint(uint64(m.Action))
2174 }
2175 if m.Record != nil {
2176 l = m.Record.SizeVT()
2177 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2178 }
2179 n += len(m.unknownFields)
2180 return n
2181 }
2182
2183 func (m *KeyValueMutation) SizeVT() (n int) {
2184 if m == nil {
2185 return 0
2186 }
2187 var l int
2188 _ = l
2189 if m.Append != nil {
2190 l = m.Append.SizeVT()
2191 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2192 }
2193 l = len(m.Remove)
2194 if l > 0 {
2195 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2196 }
2197 n += len(m.unknownFields)
2198 return n
2199 }
2200
2201 func (m *QueryParameter) SizeVT() (n int) {
2202 if m == nil {
2203 return 0
2204 }
2205 var l int
2206 _ = l
2207 l = len(m.Key)
2208 if l > 0 {
2209 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2210 }
2211 l = len(m.Value)
2212 if l > 0 {
2213 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2214 }
2215 n += len(m.unknownFields)
2216 return n
2217 }
2218
2219 func (m *HeaderValue) SizeVT() (n int) {
2220 if m == nil {
2221 return 0
2222 }
2223 var l int
2224 _ = l
2225 l = len(m.Key)
2226 if l > 0 {
2227 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2228 }
2229 l = len(m.Value)
2230 if l > 0 {
2231 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2232 }
2233 l = len(m.RawValue)
2234 if l > 0 {
2235 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2236 }
2237 n += len(m.unknownFields)
2238 return n
2239 }
2240
2241 func (m *HeaderValueOption) SizeVT() (n int) {
2242 if m == nil {
2243 return 0
2244 }
2245 var l int
2246 _ = l
2247 if m.Header != nil {
2248 l = m.Header.SizeVT()
2249 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2250 }
2251 if m.Append != nil {
2252 l = (*wrapperspb.BoolValue)(m.Append).SizeVT()
2253 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2254 }
2255 if m.AppendAction != 0 {
2256 n += 1 + protohelpers.SizeOfVarint(uint64(m.AppendAction))
2257 }
2258 if m.KeepEmptyValue {
2259 n += 2
2260 }
2261 n += len(m.unknownFields)
2262 return n
2263 }
2264
2265 func (m *HeaderMap) SizeVT() (n int) {
2266 if m == nil {
2267 return 0
2268 }
2269 var l int
2270 _ = l
2271 if len(m.Headers) > 0 {
2272 for _, e := range m.Headers {
2273 l = e.SizeVT()
2274 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2275 }
2276 }
2277 n += len(m.unknownFields)
2278 return n
2279 }
2280
2281 func (m *WatchedDirectory) SizeVT() (n int) {
2282 if m == nil {
2283 return 0
2284 }
2285 var l int
2286 _ = l
2287 l = len(m.Path)
2288 if l > 0 {
2289 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2290 }
2291 n += len(m.unknownFields)
2292 return n
2293 }
2294
2295 func (m *DataSource) SizeVT() (n int) {
2296 if m == nil {
2297 return 0
2298 }
2299 var l int
2300 _ = l
2301 if vtmsg, ok := m.Specifier.(interface{ SizeVT() int }); ok {
2302 n += vtmsg.SizeVT()
2303 }
2304 if m.WatchedDirectory != nil {
2305 l = m.WatchedDirectory.SizeVT()
2306 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2307 }
2308 n += len(m.unknownFields)
2309 return n
2310 }
2311
2312 func (m *DataSource_Filename) SizeVT() (n int) {
2313 if m == nil {
2314 return 0
2315 }
2316 var l int
2317 _ = l
2318 l = len(m.Filename)
2319 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2320 return n
2321 }
2322 func (m *DataSource_InlineBytes) SizeVT() (n int) {
2323 if m == nil {
2324 return 0
2325 }
2326 var l int
2327 _ = l
2328 l = len(m.InlineBytes)
2329 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2330 return n
2331 }
2332 func (m *DataSource_InlineString) SizeVT() (n int) {
2333 if m == nil {
2334 return 0
2335 }
2336 var l int
2337 _ = l
2338 l = len(m.InlineString)
2339 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2340 return n
2341 }
2342 func (m *DataSource_EnvironmentVariable) SizeVT() (n int) {
2343 if m == nil {
2344 return 0
2345 }
2346 var l int
2347 _ = l
2348 l = len(m.EnvironmentVariable)
2349 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2350 return n
2351 }
2352 func (m *RetryPolicy_RetryPriority) SizeVT() (n int) {
2353 if m == nil {
2354 return 0
2355 }
2356 var l int
2357 _ = l
2358 l = len(m.Name)
2359 if l > 0 {
2360 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2361 }
2362 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
2363 n += vtmsg.SizeVT()
2364 }
2365 n += len(m.unknownFields)
2366 return n
2367 }
2368
2369 func (m *RetryPolicy_RetryPriority_TypedConfig) SizeVT() (n int) {
2370 if m == nil {
2371 return 0
2372 }
2373 var l int
2374 _ = l
2375 if m.TypedConfig != nil {
2376 l = (*anypb.Any)(m.TypedConfig).SizeVT()
2377 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2378 } else {
2379 n += 2
2380 }
2381 return n
2382 }
2383 func (m *RetryPolicy_RetryHostPredicate) SizeVT() (n int) {
2384 if m == nil {
2385 return 0
2386 }
2387 var l int
2388 _ = l
2389 l = len(m.Name)
2390 if l > 0 {
2391 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2392 }
2393 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
2394 n += vtmsg.SizeVT()
2395 }
2396 n += len(m.unknownFields)
2397 return n
2398 }
2399
2400 func (m *RetryPolicy_RetryHostPredicate_TypedConfig) SizeVT() (n int) {
2401 if m == nil {
2402 return 0
2403 }
2404 var l int
2405 _ = l
2406 if m.TypedConfig != nil {
2407 l = (*anypb.Any)(m.TypedConfig).SizeVT()
2408 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2409 } else {
2410 n += 2
2411 }
2412 return n
2413 }
2414 func (m *RetryPolicy) SizeVT() (n int) {
2415 if m == nil {
2416 return 0
2417 }
2418 var l int
2419 _ = l
2420 if m.RetryBackOff != nil {
2421 l = m.RetryBackOff.SizeVT()
2422 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2423 }
2424 if m.NumRetries != nil {
2425 l = (*wrapperspb.UInt32Value)(m.NumRetries).SizeVT()
2426 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2427 }
2428 l = len(m.RetryOn)
2429 if l > 0 {
2430 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2431 }
2432 if m.RetryPriority != nil {
2433 l = m.RetryPriority.SizeVT()
2434 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2435 }
2436 if len(m.RetryHostPredicate) > 0 {
2437 for _, e := range m.RetryHostPredicate {
2438 l = e.SizeVT()
2439 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2440 }
2441 }
2442 if m.HostSelectionRetryMaxAttempts != 0 {
2443 n += 1 + protohelpers.SizeOfVarint(uint64(m.HostSelectionRetryMaxAttempts))
2444 }
2445 n += len(m.unknownFields)
2446 return n
2447 }
2448
2449 func (m *RemoteDataSource) SizeVT() (n int) {
2450 if m == nil {
2451 return 0
2452 }
2453 var l int
2454 _ = l
2455 if m.HttpUri != nil {
2456 l = m.HttpUri.SizeVT()
2457 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2458 }
2459 l = len(m.Sha256)
2460 if l > 0 {
2461 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2462 }
2463 if m.RetryPolicy != nil {
2464 l = m.RetryPolicy.SizeVT()
2465 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2466 }
2467 n += len(m.unknownFields)
2468 return n
2469 }
2470
2471 func (m *AsyncDataSource) SizeVT() (n int) {
2472 if m == nil {
2473 return 0
2474 }
2475 var l int
2476 _ = l
2477 if vtmsg, ok := m.Specifier.(interface{ SizeVT() int }); ok {
2478 n += vtmsg.SizeVT()
2479 }
2480 n += len(m.unknownFields)
2481 return n
2482 }
2483
2484 func (m *AsyncDataSource_Local) SizeVT() (n int) {
2485 if m == nil {
2486 return 0
2487 }
2488 var l int
2489 _ = l
2490 if m.Local != nil {
2491 l = m.Local.SizeVT()
2492 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2493 } else {
2494 n += 2
2495 }
2496 return n
2497 }
2498 func (m *AsyncDataSource_Remote) SizeVT() (n int) {
2499 if m == nil {
2500 return 0
2501 }
2502 var l int
2503 _ = l
2504 if m.Remote != nil {
2505 l = m.Remote.SizeVT()
2506 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2507 } else {
2508 n += 2
2509 }
2510 return n
2511 }
2512 func (m *TransportSocket) SizeVT() (n int) {
2513 if m == nil {
2514 return 0
2515 }
2516 var l int
2517 _ = l
2518 l = len(m.Name)
2519 if l > 0 {
2520 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2521 }
2522 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
2523 n += vtmsg.SizeVT()
2524 }
2525 n += len(m.unknownFields)
2526 return n
2527 }
2528
2529 func (m *TransportSocket_TypedConfig) SizeVT() (n int) {
2530 if m == nil {
2531 return 0
2532 }
2533 var l int
2534 _ = l
2535 if m.TypedConfig != nil {
2536 l = (*anypb.Any)(m.TypedConfig).SizeVT()
2537 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2538 } else {
2539 n += 2
2540 }
2541 return n
2542 }
2543 func (m *RuntimeFractionalPercent) SizeVT() (n int) {
2544 if m == nil {
2545 return 0
2546 }
2547 var l int
2548 _ = l
2549 if m.DefaultValue != nil {
2550 if size, ok := interface{}(m.DefaultValue).(interface {
2551 SizeVT() int
2552 }); ok {
2553 l = size.SizeVT()
2554 } else {
2555 l = proto.Size(m.DefaultValue)
2556 }
2557 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2558 }
2559 l = len(m.RuntimeKey)
2560 if l > 0 {
2561 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2562 }
2563 n += len(m.unknownFields)
2564 return n
2565 }
2566
2567 func (m *ControlPlane) SizeVT() (n int) {
2568 if m == nil {
2569 return 0
2570 }
2571 var l int
2572 _ = l
2573 l = len(m.Identifier)
2574 if l > 0 {
2575 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2576 }
2577 n += len(m.unknownFields)
2578 return n
2579 }