Debian Codegraph @

envoy/config/core/v3/config_source_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/config_source.proto
6
7 package corev3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 anypb "github.com/planetscale/vtprotobuf/types/known/anypb"
12 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
13 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
14 proto "google.golang.org/protobuf/proto"
15 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
16 )
17
18 const (
19 // Verify that this generated code is sufficiently up-to-date.
20 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
21 // Verify that runtime/protoimpl is sufficiently up-to-date.
22 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
23 )
24
25 func (m *ApiConfigSource) MarshalVTStrict() (dAtA []byte, err error) {
26 if m == nil {
27 return nil, nil
28 }
29 size := m.SizeVT()
30 dAtA = make([]byte, size)
31 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
32 if err != nil {
33 return nil, err
34 }
35 return dAtA[:n], nil
36 }
37
38 func (m *ApiConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
39 size := m.SizeVT()
40 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
41 }
42
43 func (m *ApiConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
44 if m == nil {
45 return 0, nil
46 }
47 i := len(dAtA)
48 _ = i
49 var l int
50 _ = l
51 if m.unknownFields != nil {
52 i -= len(m.unknownFields)
53 copy(dAtA[i:], m.unknownFields)
54 }
55 if len(m.ConfigValidators) > 0 {
56 for iNdEx := len(m.ConfigValidators) - 1; iNdEx >= 0; iNdEx-- {
57 size, err := m.ConfigValidators[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
58 if err != nil {
59 return 0, err
60 }
61 i -= size
62 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
63 i--
64 dAtA[i] = 0x4a
65 }
66 }
67 if m.TransportApiVersion != 0 {
68 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TransportApiVersion))
69 i--
70 dAtA[i] = 0x40
71 }
72 if m.SetNodeOnFirstMessageOnly {
73 i--
74 if m.SetNodeOnFirstMessageOnly {
75 dAtA[i] = 1
76 } else {
77 dAtA[i] = 0
78 }
79 i--
80 dAtA[i] = 0x38
81 }
82 if m.RateLimitSettings != nil {
83 size, err := m.RateLimitSettings.MarshalToSizedBufferVTStrict(dAtA[:i])
84 if err != nil {
85 return 0, err
86 }
87 i -= size
88 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
89 i--
90 dAtA[i] = 0x32
91 }
92 if m.RequestTimeout != nil {
93 size, err := (*durationpb.Duration)(m.RequestTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
94 if err != nil {
95 return 0, err
96 }
97 i -= size
98 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
99 i--
100 dAtA[i] = 0x2a
101 }
102 if len(m.GrpcServices) > 0 {
103 for iNdEx := len(m.GrpcServices) - 1; iNdEx >= 0; iNdEx-- {
104 size, err := m.GrpcServices[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
105 if err != nil {
106 return 0, err
107 }
108 i -= size
109 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
110 i--
111 dAtA[i] = 0x22
112 }
113 }
114 if m.RefreshDelay != nil {
115 size, err := (*durationpb.Duration)(m.RefreshDelay).MarshalToSizedBufferVTStrict(dAtA[:i])
116 if err != nil {
117 return 0, err
118 }
119 i -= size
120 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
121 i--
122 dAtA[i] = 0x1a
123 }
124 if len(m.ClusterNames) > 0 {
125 for iNdEx := len(m.ClusterNames) - 1; iNdEx >= 0; iNdEx-- {
126 i -= len(m.ClusterNames[iNdEx])
127 copy(dAtA[i:], m.ClusterNames[iNdEx])
128 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterNames[iNdEx])))
129 i--
130 dAtA[i] = 0x12
131 }
132 }
133 if m.ApiType != 0 {
134 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ApiType))
135 i--
136 dAtA[i] = 0x8
137 }
138 return len(dAtA) - i, nil
139 }
140
141 func (m *AggregatedConfigSource) MarshalVTStrict() (dAtA []byte, err error) {
142 if m == nil {
143 return nil, nil
144 }
145 size := m.SizeVT()
146 dAtA = make([]byte, size)
147 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
148 if err != nil {
149 return nil, err
150 }
151 return dAtA[:n], nil
152 }
153
154 func (m *AggregatedConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
155 size := m.SizeVT()
156 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
157 }
158
159 func (m *AggregatedConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
160 if m == nil {
161 return 0, nil
162 }
163 i := len(dAtA)
164 _ = i
165 var l int
166 _ = l
167 if m.unknownFields != nil {
168 i -= len(m.unknownFields)
169 copy(dAtA[i:], m.unknownFields)
170 }
171 return len(dAtA) - i, nil
172 }
173
174 func (m *SelfConfigSource) MarshalVTStrict() (dAtA []byte, err error) {
175 if m == nil {
176 return nil, nil
177 }
178 size := m.SizeVT()
179 dAtA = make([]byte, size)
180 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
181 if err != nil {
182 return nil, err
183 }
184 return dAtA[:n], nil
185 }
186
187 func (m *SelfConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
188 size := m.SizeVT()
189 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
190 }
191
192 func (m *SelfConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
193 if m == nil {
194 return 0, nil
195 }
196 i := len(dAtA)
197 _ = i
198 var l int
199 _ = l
200 if m.unknownFields != nil {
201 i -= len(m.unknownFields)
202 copy(dAtA[i:], m.unknownFields)
203 }
204 if m.TransportApiVersion != 0 {
205 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TransportApiVersion))
206 i--
207 dAtA[i] = 0x8
208 }
209 return len(dAtA) - i, nil
210 }
211
212 func (m *RateLimitSettings) MarshalVTStrict() (dAtA []byte, err error) {
213 if m == nil {
214 return nil, nil
215 }
216 size := m.SizeVT()
217 dAtA = make([]byte, size)
218 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
219 if err != nil {
220 return nil, err
221 }
222 return dAtA[:n], nil
223 }
224
225 func (m *RateLimitSettings) MarshalToVTStrict(dAtA []byte) (int, error) {
226 size := m.SizeVT()
227 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
228 }
229
230 func (m *RateLimitSettings) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
231 if m == nil {
232 return 0, nil
233 }
234 i := len(dAtA)
235 _ = i
236 var l int
237 _ = l
238 if m.unknownFields != nil {
239 i -= len(m.unknownFields)
240 copy(dAtA[i:], m.unknownFields)
241 }
242 if m.FillRate != nil {
243 size, err := (*wrapperspb.DoubleValue)(m.FillRate).MarshalToSizedBufferVTStrict(dAtA[:i])
244 if err != nil {
245 return 0, err
246 }
247 i -= size
248 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
249 i--
250 dAtA[i] = 0x12
251 }
252 if m.MaxTokens != nil {
253 size, err := (*wrapperspb.UInt32Value)(m.MaxTokens).MarshalToSizedBufferVTStrict(dAtA[:i])
254 if err != nil {
255 return 0, err
256 }
257 i -= size
258 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
259 i--
260 dAtA[i] = 0xa
261 }
262 return len(dAtA) - i, nil
263 }
264
265 func (m *PathConfigSource) MarshalVTStrict() (dAtA []byte, err error) {
266 if m == nil {
267 return nil, nil
268 }
269 size := m.SizeVT()
270 dAtA = make([]byte, size)
271 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
272 if err != nil {
273 return nil, err
274 }
275 return dAtA[:n], nil
276 }
277
278 func (m *PathConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
279 size := m.SizeVT()
280 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
281 }
282
283 func (m *PathConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
284 if m == nil {
285 return 0, nil
286 }
287 i := len(dAtA)
288 _ = i
289 var l int
290 _ = l
291 if m.unknownFields != nil {
292 i -= len(m.unknownFields)
293 copy(dAtA[i:], m.unknownFields)
294 }
295 if m.WatchedDirectory != nil {
296 size, err := m.WatchedDirectory.MarshalToSizedBufferVTStrict(dAtA[:i])
297 if err != nil {
298 return 0, err
299 }
300 i -= size
301 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
302 i--
303 dAtA[i] = 0x12
304 }
305 if len(m.Path) > 0 {
306 i -= len(m.Path)
307 copy(dAtA[i:], m.Path)
308 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
309 i--
310 dAtA[i] = 0xa
311 }
312 return len(dAtA) - i, nil
313 }
314
315 func (m *ConfigSource) MarshalVTStrict() (dAtA []byte, err error) {
316 if m == nil {
317 return nil, nil
318 }
319 size := m.SizeVT()
320 dAtA = make([]byte, size)
321 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
322 if err != nil {
323 return nil, err
324 }
325 return dAtA[:n], nil
326 }
327
328 func (m *ConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
329 size := m.SizeVT()
330 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
331 }
332
333 func (m *ConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
334 if m == nil {
335 return 0, nil
336 }
337 i := len(dAtA)
338 _ = i
339 var l int
340 _ = l
341 if m.unknownFields != nil {
342 i -= len(m.unknownFields)
343 copy(dAtA[i:], m.unknownFields)
344 }
345 if msg, ok := m.ConfigSourceSpecifier.(*ConfigSource_PathConfigSource); ok {
346 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
347 if err != nil {
348 return 0, err
349 }
350 i -= size
351 }
352 if len(m.Authorities) > 0 {
353 for iNdEx := len(m.Authorities) - 1; iNdEx >= 0; iNdEx-- {
354 if vtmsg, ok := interface{}(m.Authorities[iNdEx]).(interface {
355 MarshalToSizedBufferVTStrict([]byte) (int, error)
356 }); ok {
357 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
358 if err != nil {
359 return 0, err
360 }
361 i -= size
362 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
363 } else {
364 encoded, err := proto.Marshal(m.Authorities[iNdEx])
365 if err != nil {
366 return 0, err
367 }
368 i -= len(encoded)
369 copy(dAtA[i:], encoded)
370 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
371 }
372 i--
373 dAtA[i] = 0x3a
374 }
375 }
376 if m.ResourceApiVersion != 0 {
377 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ResourceApiVersion))
378 i--
379 dAtA[i] = 0x30
380 }
381 if msg, ok := m.ConfigSourceSpecifier.(*ConfigSource_Self); ok {
382 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
383 if err != nil {
384 return 0, err
385 }
386 i -= size
387 }
388 if m.InitialFetchTimeout != nil {
389 size, err := (*durationpb.Duration)(m.InitialFetchTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
390 if err != nil {
391 return 0, err
392 }
393 i -= size
394 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
395 i--
396 dAtA[i] = 0x22
397 }
398 if msg, ok := m.ConfigSourceSpecifier.(*ConfigSource_Ads); ok {
399 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
400 if err != nil {
401 return 0, err
402 }
403 i -= size
404 }
405 if msg, ok := m.ConfigSourceSpecifier.(*ConfigSource_ApiConfigSource); ok {
406 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
407 if err != nil {
408 return 0, err
409 }
410 i -= size
411 }
412 if msg, ok := m.ConfigSourceSpecifier.(*ConfigSource_Path); ok {
413 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
414 if err != nil {
415 return 0, err
416 }
417 i -= size
418 }
419 return len(dAtA) - i, nil
420 }
421
422 func (m *ConfigSource_Path) MarshalToVTStrict(dAtA []byte) (int, error) {
423 size := m.SizeVT()
424 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
425 }
426
427 func (m *ConfigSource_Path) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
428 i := len(dAtA)
429 i -= len(m.Path)
430 copy(dAtA[i:], m.Path)
431 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
432 i--
433 dAtA[i] = 0xa
434 return len(dAtA) - i, nil
435 }
436 func (m *ConfigSource_ApiConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
437 size := m.SizeVT()
438 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
439 }
440
441 func (m *ConfigSource_ApiConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
442 i := len(dAtA)
443 if m.ApiConfigSource != nil {
444 size, err := m.ApiConfigSource.MarshalToSizedBufferVTStrict(dAtA[:i])
445 if err != nil {
446 return 0, err
447 }
448 i -= size
449 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
450 i--
451 dAtA[i] = 0x12
452 } else {
453 i = protohelpers.EncodeVarint(dAtA, i, 0)
454 i--
455 dAtA[i] = 0x12
456 }
457 return len(dAtA) - i, nil
458 }
459 func (m *ConfigSource_Ads) MarshalToVTStrict(dAtA []byte) (int, error) {
460 size := m.SizeVT()
461 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
462 }
463
464 func (m *ConfigSource_Ads) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
465 i := len(dAtA)
466 if m.Ads != nil {
467 size, err := m.Ads.MarshalToSizedBufferVTStrict(dAtA[:i])
468 if err != nil {
469 return 0, err
470 }
471 i -= size
472 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
473 i--
474 dAtA[i] = 0x1a
475 } else {
476 i = protohelpers.EncodeVarint(dAtA, i, 0)
477 i--
478 dAtA[i] = 0x1a
479 }
480 return len(dAtA) - i, nil
481 }
482 func (m *ConfigSource_Self) MarshalToVTStrict(dAtA []byte) (int, error) {
483 size := m.SizeVT()
484 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
485 }
486
487 func (m *ConfigSource_Self) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
488 i := len(dAtA)
489 if m.Self != nil {
490 size, err := m.Self.MarshalToSizedBufferVTStrict(dAtA[:i])
491 if err != nil {
492 return 0, err
493 }
494 i -= size
495 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
496 i--
497 dAtA[i] = 0x2a
498 } else {
499 i = protohelpers.EncodeVarint(dAtA, i, 0)
500 i--
501 dAtA[i] = 0x2a
502 }
503 return len(dAtA) - i, nil
504 }
505 func (m *ConfigSource_PathConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
506 size := m.SizeVT()
507 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
508 }
509
510 func (m *ConfigSource_PathConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
511 i := len(dAtA)
512 if m.PathConfigSource != nil {
513 size, err := m.PathConfigSource.MarshalToSizedBufferVTStrict(dAtA[:i])
514 if err != nil {
515 return 0, err
516 }
517 i -= size
518 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
519 i--
520 dAtA[i] = 0x42
521 } else {
522 i = protohelpers.EncodeVarint(dAtA, i, 0)
523 i--
524 dAtA[i] = 0x42
525 }
526 return len(dAtA) - i, nil
527 }
528 func (m *ExtensionConfigSource) MarshalVTStrict() (dAtA []byte, err error) {
529 if m == nil {
530 return nil, nil
531 }
532 size := m.SizeVT()
533 dAtA = make([]byte, size)
534 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
535 if err != nil {
536 return nil, err
537 }
538 return dAtA[:n], nil
539 }
540
541 func (m *ExtensionConfigSource) MarshalToVTStrict(dAtA []byte) (int, error) {
542 size := m.SizeVT()
543 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
544 }
545
546 func (m *ExtensionConfigSource) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
547 if m == nil {
548 return 0, nil
549 }
550 i := len(dAtA)
551 _ = i
552 var l int
553 _ = l
554 if m.unknownFields != nil {
555 i -= len(m.unknownFields)
556 copy(dAtA[i:], m.unknownFields)
557 }
558 if len(m.TypeUrls) > 0 {
559 for iNdEx := len(m.TypeUrls) - 1; iNdEx >= 0; iNdEx-- {
560 i -= len(m.TypeUrls[iNdEx])
561 copy(dAtA[i:], m.TypeUrls[iNdEx])
562 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TypeUrls[iNdEx])))
563 i--
564 dAtA[i] = 0x22
565 }
566 }
567 if m.ApplyDefaultConfigWithoutWarming {
568 i--
569 if m.ApplyDefaultConfigWithoutWarming {
570 dAtA[i] = 1
571 } else {
572 dAtA[i] = 0
573 }
574 i--
575 dAtA[i] = 0x18
576 }
577 if m.DefaultConfig != nil {
578 size, err := (*anypb.Any)(m.DefaultConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
579 if err != nil {
580 return 0, err
581 }
582 i -= size
583 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
584 i--
585 dAtA[i] = 0x12
586 }
587 if m.ConfigSource != nil {
588 size, err := m.ConfigSource.MarshalToSizedBufferVTStrict(dAtA[:i])
589 if err != nil {
590 return 0, err
591 }
592 i -= size
593 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
594 i--
595 dAtA[i] = 0xa
596 }
597 return len(dAtA) - i, nil
598 }
599
600 func (m *ApiConfigSource) SizeVT() (n int) {
601 if m == nil {
602 return 0
603 }
604 var l int
605 _ = l
606 if m.ApiType != 0 {
607 n += 1 + protohelpers.SizeOfVarint(uint64(m.ApiType))
608 }
609 if len(m.ClusterNames) > 0 {
610 for _, s := range m.ClusterNames {
611 l = len(s)
612 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
613 }
614 }
615 if m.RefreshDelay != nil {
616 l = (*durationpb.Duration)(m.RefreshDelay).SizeVT()
617 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
618 }
619 if len(m.GrpcServices) > 0 {
620 for _, e := range m.GrpcServices {
621 l = e.SizeVT()
622 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
623 }
624 }
625 if m.RequestTimeout != nil {
626 l = (*durationpb.Duration)(m.RequestTimeout).SizeVT()
627 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
628 }
629 if m.RateLimitSettings != nil {
630 l = m.RateLimitSettings.SizeVT()
631 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
632 }
633 if m.SetNodeOnFirstMessageOnly {
634 n += 2
635 }
636 if m.TransportApiVersion != 0 {
637 n += 1 + protohelpers.SizeOfVarint(uint64(m.TransportApiVersion))
638 }
639 if len(m.ConfigValidators) > 0 {
640 for _, e := range m.ConfigValidators {
641 l = e.SizeVT()
642 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
643 }
644 }
645 n += len(m.unknownFields)
646 return n
647 }
648
649 func (m *AggregatedConfigSource) SizeVT() (n int) {
650 if m == nil {
651 return 0
652 }
653 var l int
654 _ = l
655 n += len(m.unknownFields)
656 return n
657 }
658
659 func (m *SelfConfigSource) SizeVT() (n int) {
660 if m == nil {
661 return 0
662 }
663 var l int
664 _ = l
665 if m.TransportApiVersion != 0 {
666 n += 1 + protohelpers.SizeOfVarint(uint64(m.TransportApiVersion))
667 }
668 n += len(m.unknownFields)
669 return n
670 }
671
672 func (m *RateLimitSettings) SizeVT() (n int) {
673 if m == nil {
674 return 0
675 }
676 var l int
677 _ = l
678 if m.MaxTokens != nil {
679 l = (*wrapperspb.UInt32Value)(m.MaxTokens).SizeVT()
680 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
681 }
682 if m.FillRate != nil {
683 l = (*wrapperspb.DoubleValue)(m.FillRate).SizeVT()
684 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
685 }
686 n += len(m.unknownFields)
687 return n
688 }
689
690 func (m *PathConfigSource) SizeVT() (n int) {
691 if m == nil {
692 return 0
693 }
694 var l int
695 _ = l
696 l = len(m.Path)
697 if l > 0 {
698 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
699 }
700 if m.WatchedDirectory != nil {
701 l = m.WatchedDirectory.SizeVT()
702 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
703 }
704 n += len(m.unknownFields)
705 return n
706 }
707
708 func (m *ConfigSource) SizeVT() (n int) {
709 if m == nil {
710 return 0
711 }
712 var l int
713 _ = l
714 if vtmsg, ok := m.ConfigSourceSpecifier.(interface{ SizeVT() int }); ok {
715 n += vtmsg.SizeVT()
716 }
717 if m.InitialFetchTimeout != nil {
718 l = (*durationpb.Duration)(m.InitialFetchTimeout).SizeVT()
719 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
720 }
721 if m.ResourceApiVersion != 0 {
722 n += 1 + protohelpers.SizeOfVarint(uint64(m.ResourceApiVersion))
723 }
724 if len(m.Authorities) > 0 {
725 for _, e := range m.Authorities {
726 if size, ok := interface{}(e).(interface {
727 SizeVT() int
728 }); ok {
729 l = size.SizeVT()
730 } else {
731 l = proto.Size(e)
732 }
733 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
734 }
735 }
736 n += len(m.unknownFields)
737 return n
738 }
739
740 func (m *ConfigSource_Path) SizeVT() (n int) {
741 if m == nil {
742 return 0
743 }
744 var l int
745 _ = l
746 l = len(m.Path)
747 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
748 return n
749 }
750 func (m *ConfigSource_ApiConfigSource) SizeVT() (n int) {
751 if m == nil {
752 return 0
753 }
754 var l int
755 _ = l
756 if m.ApiConfigSource != nil {
757 l = m.ApiConfigSource.SizeVT()
758 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
759 } else {
760 n += 2
761 }
762 return n
763 }
764 func (m *ConfigSource_Ads) SizeVT() (n int) {
765 if m == nil {
766 return 0
767 }
768 var l int
769 _ = l
770 if m.Ads != nil {
771 l = m.Ads.SizeVT()
772 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
773 } else {
774 n += 2
775 }
776 return n
777 }
778 func (m *ConfigSource_Self) SizeVT() (n int) {
779 if m == nil {
780 return 0
781 }
782 var l int
783 _ = l
784 if m.Self != nil {
785 l = m.Self.SizeVT()
786 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
787 } else {
788 n += 2
789 }
790 return n
791 }
792 func (m *ConfigSource_PathConfigSource) SizeVT() (n int) {
793 if m == nil {
794 return 0
795 }
796 var l int
797 _ = l
798 if m.PathConfigSource != nil {
799 l = m.PathConfigSource.SizeVT()
800 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
801 } else {
802 n += 2
803 }
804 return n
805 }
806 func (m *ExtensionConfigSource) SizeVT() (n int) {
807 if m == nil {
808 return 0
809 }
810 var l int
811 _ = l
812 if m.ConfigSource != nil {
813 l = m.ConfigSource.SizeVT()
814 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
815 }
816 if m.DefaultConfig != nil {
817 l = (*anypb.Any)(m.DefaultConfig).SizeVT()
818 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
819 }
820 if m.ApplyDefaultConfigWithoutWarming {
821 n += 2
822 }
823 if len(m.TypeUrls) > 0 {
824 for _, s := range m.TypeUrls {
825 l = len(s)
826 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
827 }
828 }
829 n += len(m.unknownFields)
830 return n
831 }