Debian Codegraph @

envoy/config/bootstrap/v2/bootstrap_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/bootstrap/v2/bootstrap.proto
6
7 package bootstrapv2
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
12 structpb "github.com/planetscale/vtprotobuf/types/known/structpb"
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 *Bootstrap_StaticResources) 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 *Bootstrap_StaticResources) MarshalToVTStrict(dAtA []byte) (int, error) {
39 size := m.SizeVT()
40 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
41 }
42
43 func (m *Bootstrap_StaticResources) 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.Secrets) > 0 {
56 for iNdEx := len(m.Secrets) - 1; iNdEx >= 0; iNdEx-- {
57 if vtmsg, ok := interface{}(m.Secrets[iNdEx]).(interface {
58 MarshalToSizedBufferVTStrict([]byte) (int, error)
59 }); ok {
60 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
61 if err != nil {
62 return 0, err
63 }
64 i -= size
65 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
66 } else {
67 encoded, err := proto.Marshal(m.Secrets[iNdEx])
68 if err != nil {
69 return 0, err
70 }
71 i -= len(encoded)
72 copy(dAtA[i:], encoded)
73 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
74 }
75 i--
76 dAtA[i] = 0x1a
77 }
78 }
79 if len(m.Clusters) > 0 {
80 for iNdEx := len(m.Clusters) - 1; iNdEx >= 0; iNdEx-- {
81 if vtmsg, ok := interface{}(m.Clusters[iNdEx]).(interface {
82 MarshalToSizedBufferVTStrict([]byte) (int, error)
83 }); ok {
84 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
85 if err != nil {
86 return 0, err
87 }
88 i -= size
89 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
90 } else {
91 encoded, err := proto.Marshal(m.Clusters[iNdEx])
92 if err != nil {
93 return 0, err
94 }
95 i -= len(encoded)
96 copy(dAtA[i:], encoded)
97 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
98 }
99 i--
100 dAtA[i] = 0x12
101 }
102 }
103 if len(m.Listeners) > 0 {
104 for iNdEx := len(m.Listeners) - 1; iNdEx >= 0; iNdEx-- {
105 if vtmsg, ok := interface{}(m.Listeners[iNdEx]).(interface {
106 MarshalToSizedBufferVTStrict([]byte) (int, error)
107 }); ok {
108 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
109 if err != nil {
110 return 0, err
111 }
112 i -= size
113 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
114 } else {
115 encoded, err := proto.Marshal(m.Listeners[iNdEx])
116 if err != nil {
117 return 0, err
118 }
119 i -= len(encoded)
120 copy(dAtA[i:], encoded)
121 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
122 }
123 i--
124 dAtA[i] = 0xa
125 }
126 }
127 return len(dAtA) - i, nil
128 }
129
130 func (m *Bootstrap_DynamicResources) MarshalVTStrict() (dAtA []byte, err error) {
131 if m == nil {
132 return nil, nil
133 }
134 size := m.SizeVT()
135 dAtA = make([]byte, size)
136 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
137 if err != nil {
138 return nil, err
139 }
140 return dAtA[:n], nil
141 }
142
143 func (m *Bootstrap_DynamicResources) MarshalToVTStrict(dAtA []byte) (int, error) {
144 size := m.SizeVT()
145 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
146 }
147
148 func (m *Bootstrap_DynamicResources) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
149 if m == nil {
150 return 0, nil
151 }
152 i := len(dAtA)
153 _ = i
154 var l int
155 _ = l
156 if m.unknownFields != nil {
157 i -= len(m.unknownFields)
158 copy(dAtA[i:], m.unknownFields)
159 }
160 if m.AdsConfig != nil {
161 if vtmsg, ok := interface{}(m.AdsConfig).(interface {
162 MarshalToSizedBufferVTStrict([]byte) (int, error)
163 }); ok {
164 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
165 if err != nil {
166 return 0, err
167 }
168 i -= size
169 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
170 } else {
171 encoded, err := proto.Marshal(m.AdsConfig)
172 if err != nil {
173 return 0, err
174 }
175 i -= len(encoded)
176 copy(dAtA[i:], encoded)
177 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
178 }
179 i--
180 dAtA[i] = 0x1a
181 }
182 if m.CdsConfig != nil {
183 if vtmsg, ok := interface{}(m.CdsConfig).(interface {
184 MarshalToSizedBufferVTStrict([]byte) (int, error)
185 }); ok {
186 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
187 if err != nil {
188 return 0, err
189 }
190 i -= size
191 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
192 } else {
193 encoded, err := proto.Marshal(m.CdsConfig)
194 if err != nil {
195 return 0, err
196 }
197 i -= len(encoded)
198 copy(dAtA[i:], encoded)
199 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
200 }
201 i--
202 dAtA[i] = 0x12
203 }
204 if m.LdsConfig != nil {
205 if vtmsg, ok := interface{}(m.LdsConfig).(interface {
206 MarshalToSizedBufferVTStrict([]byte) (int, error)
207 }); ok {
208 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
209 if err != nil {
210 return 0, err
211 }
212 i -= size
213 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
214 } else {
215 encoded, err := proto.Marshal(m.LdsConfig)
216 if err != nil {
217 return 0, err
218 }
219 i -= len(encoded)
220 copy(dAtA[i:], encoded)
221 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
222 }
223 i--
224 dAtA[i] = 0xa
225 }
226 return len(dAtA) - i, nil
227 }
228
229 func (m *Bootstrap) 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 *Bootstrap) MarshalToVTStrict(dAtA []byte) (int, error) {
243 size := m.SizeVT()
244 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
245 }
246
247 func (m *Bootstrap) 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 m.UseTcpForDnsLookups {
260 i--
261 if m.UseTcpForDnsLookups {
262 dAtA[i] = 1
263 } else {
264 dAtA[i] = 0
265 }
266 i--
267 dAtA[i] = 0x1
268 i--
269 dAtA[i] = 0xa0
270 }
271 if m.StatsServerVersionOverride != nil {
272 size, err := (*wrapperspb.UInt64Value)(m.StatsServerVersionOverride).MarshalToSizedBufferVTStrict(dAtA[:i])
273 if err != nil {
274 return 0, err
275 }
276 i -= size
277 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
278 i--
279 dAtA[i] = 0x1
280 i--
281 dAtA[i] = 0x9a
282 }
283 if len(m.HeaderPrefix) > 0 {
284 i -= len(m.HeaderPrefix)
285 copy(dAtA[i:], m.HeaderPrefix)
286 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeaderPrefix)))
287 i--
288 dAtA[i] = 0x1
289 i--
290 dAtA[i] = 0x92
291 }
292 if m.LayeredRuntime != nil {
293 size, err := m.LayeredRuntime.MarshalToSizedBufferVTStrict(dAtA[:i])
294 if err != nil {
295 return 0, err
296 }
297 i -= size
298 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
299 i--
300 dAtA[i] = 0x1
301 i--
302 dAtA[i] = 0x8a
303 }
304 if m.EnableDispatcherStats {
305 i--
306 if m.EnableDispatcherStats {
307 dAtA[i] = 1
308 } else {
309 dAtA[i] = 0
310 }
311 i--
312 dAtA[i] = 0x1
313 i--
314 dAtA[i] = 0x80
315 }
316 if m.OverloadManager != nil {
317 if vtmsg, ok := interface{}(m.OverloadManager).(interface {
318 MarshalToSizedBufferVTStrict([]byte) (int, error)
319 }); ok {
320 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
321 if err != nil {
322 return 0, err
323 }
324 i -= size
325 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
326 } else {
327 encoded, err := proto.Marshal(m.OverloadManager)
328 if err != nil {
329 return 0, err
330 }
331 i -= len(encoded)
332 copy(dAtA[i:], encoded)
333 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
334 }
335 i--
336 dAtA[i] = 0x7a
337 }
338 if m.HdsConfig != nil {
339 if vtmsg, ok := interface{}(m.HdsConfig).(interface {
340 MarshalToSizedBufferVTStrict([]byte) (int, error)
341 }); ok {
342 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
343 if err != nil {
344 return 0, err
345 }
346 i -= size
347 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
348 } else {
349 encoded, err := proto.Marshal(m.HdsConfig)
350 if err != nil {
351 return 0, err
352 }
353 i -= len(encoded)
354 copy(dAtA[i:], encoded)
355 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
356 }
357 i--
358 dAtA[i] = 0x72
359 }
360 if m.StatsConfig != nil {
361 if vtmsg, ok := interface{}(m.StatsConfig).(interface {
362 MarshalToSizedBufferVTStrict([]byte) (int, error)
363 }); ok {
364 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
365 if err != nil {
366 return 0, err
367 }
368 i -= size
369 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
370 } else {
371 encoded, err := proto.Marshal(m.StatsConfig)
372 if err != nil {
373 return 0, err
374 }
375 i -= len(encoded)
376 copy(dAtA[i:], encoded)
377 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
378 }
379 i--
380 dAtA[i] = 0x6a
381 }
382 if m.Admin != nil {
383 size, err := m.Admin.MarshalToSizedBufferVTStrict(dAtA[:i])
384 if err != nil {
385 return 0, err
386 }
387 i -= size
388 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
389 i--
390 dAtA[i] = 0x62
391 }
392 if m.Runtime != nil {
393 size, err := m.Runtime.MarshalToSizedBufferVTStrict(dAtA[:i])
394 if err != nil {
395 return 0, err
396 }
397 i -= size
398 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
399 i--
400 dAtA[i] = 0x5a
401 }
402 if m.Tracing != nil {
403 if vtmsg, ok := interface{}(m.Tracing).(interface {
404 MarshalToSizedBufferVTStrict([]byte) (int, error)
405 }); ok {
406 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
407 if err != nil {
408 return 0, err
409 }
410 i -= size
411 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
412 } else {
413 encoded, err := proto.Marshal(m.Tracing)
414 if err != nil {
415 return 0, err
416 }
417 i -= len(encoded)
418 copy(dAtA[i:], encoded)
419 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
420 }
421 i--
422 dAtA[i] = 0x4a
423 }
424 if m.Watchdog != nil {
425 size, err := m.Watchdog.MarshalToSizedBufferVTStrict(dAtA[:i])
426 if err != nil {
427 return 0, err
428 }
429 i -= size
430 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
431 i--
432 dAtA[i] = 0x42
433 }
434 if m.StatsFlushInterval != nil {
435 size, err := (*durationpb.Duration)(m.StatsFlushInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
436 if err != nil {
437 return 0, err
438 }
439 i -= size
440 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
441 i--
442 dAtA[i] = 0x3a
443 }
444 if len(m.StatsSinks) > 0 {
445 for iNdEx := len(m.StatsSinks) - 1; iNdEx >= 0; iNdEx-- {
446 if vtmsg, ok := interface{}(m.StatsSinks[iNdEx]).(interface {
447 MarshalToSizedBufferVTStrict([]byte) (int, error)
448 }); ok {
449 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
450 if err != nil {
451 return 0, err
452 }
453 i -= size
454 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
455 } else {
456 encoded, err := proto.Marshal(m.StatsSinks[iNdEx])
457 if err != nil {
458 return 0, err
459 }
460 i -= len(encoded)
461 copy(dAtA[i:], encoded)
462 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
463 }
464 i--
465 dAtA[i] = 0x32
466 }
467 }
468 if len(m.FlagsPath) > 0 {
469 i -= len(m.FlagsPath)
470 copy(dAtA[i:], m.FlagsPath)
471 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FlagsPath)))
472 i--
473 dAtA[i] = 0x2a
474 }
475 if m.ClusterManager != nil {
476 size, err := m.ClusterManager.MarshalToSizedBufferVTStrict(dAtA[:i])
477 if err != nil {
478 return 0, err
479 }
480 i -= size
481 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
482 i--
483 dAtA[i] = 0x22
484 }
485 if m.DynamicResources != nil {
486 size, err := m.DynamicResources.MarshalToSizedBufferVTStrict(dAtA[:i])
487 if err != nil {
488 return 0, err
489 }
490 i -= size
491 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
492 i--
493 dAtA[i] = 0x1a
494 }
495 if m.StaticResources != nil {
496 size, err := m.StaticResources.MarshalToSizedBufferVTStrict(dAtA[:i])
497 if err != nil {
498 return 0, err
499 }
500 i -= size
501 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
502 i--
503 dAtA[i] = 0x12
504 }
505 if m.Node != nil {
506 if vtmsg, ok := interface{}(m.Node).(interface {
507 MarshalToSizedBufferVTStrict([]byte) (int, error)
508 }); ok {
509 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
510 if err != nil {
511 return 0, err
512 }
513 i -= size
514 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
515 } else {
516 encoded, err := proto.Marshal(m.Node)
517 if err != nil {
518 return 0, err
519 }
520 i -= len(encoded)
521 copy(dAtA[i:], encoded)
522 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
523 }
524 i--
525 dAtA[i] = 0xa
526 }
527 return len(dAtA) - i, nil
528 }
529
530 func (m *Admin) MarshalVTStrict() (dAtA []byte, err error) {
531 if m == nil {
532 return nil, nil
533 }
534 size := m.SizeVT()
535 dAtA = make([]byte, size)
536 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
537 if err != nil {
538 return nil, err
539 }
540 return dAtA[:n], nil
541 }
542
543 func (m *Admin) MarshalToVTStrict(dAtA []byte) (int, error) {
544 size := m.SizeVT()
545 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
546 }
547
548 func (m *Admin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
549 if m == nil {
550 return 0, nil
551 }
552 i := len(dAtA)
553 _ = i
554 var l int
555 _ = l
556 if m.unknownFields != nil {
557 i -= len(m.unknownFields)
558 copy(dAtA[i:], m.unknownFields)
559 }
560 if len(m.SocketOptions) > 0 {
561 for iNdEx := len(m.SocketOptions) - 1; iNdEx >= 0; iNdEx-- {
562 if vtmsg, ok := interface{}(m.SocketOptions[iNdEx]).(interface {
563 MarshalToSizedBufferVTStrict([]byte) (int, error)
564 }); ok {
565 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
566 if err != nil {
567 return 0, err
568 }
569 i -= size
570 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
571 } else {
572 encoded, err := proto.Marshal(m.SocketOptions[iNdEx])
573 if err != nil {
574 return 0, err
575 }
576 i -= len(encoded)
577 copy(dAtA[i:], encoded)
578 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
579 }
580 i--
581 dAtA[i] = 0x22
582 }
583 }
584 if m.Address != nil {
585 if vtmsg, ok := interface{}(m.Address).(interface {
586 MarshalToSizedBufferVTStrict([]byte) (int, error)
587 }); ok {
588 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
589 if err != nil {
590 return 0, err
591 }
592 i -= size
593 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
594 } else {
595 encoded, err := proto.Marshal(m.Address)
596 if err != nil {
597 return 0, err
598 }
599 i -= len(encoded)
600 copy(dAtA[i:], encoded)
601 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
602 }
603 i--
604 dAtA[i] = 0x1a
605 }
606 if len(m.ProfilePath) > 0 {
607 i -= len(m.ProfilePath)
608 copy(dAtA[i:], m.ProfilePath)
609 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ProfilePath)))
610 i--
611 dAtA[i] = 0x12
612 }
613 if len(m.AccessLogPath) > 0 {
614 i -= len(m.AccessLogPath)
615 copy(dAtA[i:], m.AccessLogPath)
616 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AccessLogPath)))
617 i--
618 dAtA[i] = 0xa
619 }
620 return len(dAtA) - i, nil
621 }
622
623 func (m *ClusterManager_OutlierDetection) MarshalVTStrict() (dAtA []byte, err error) {
624 if m == nil {
625 return nil, nil
626 }
627 size := m.SizeVT()
628 dAtA = make([]byte, size)
629 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
630 if err != nil {
631 return nil, err
632 }
633 return dAtA[:n], nil
634 }
635
636 func (m *ClusterManager_OutlierDetection) MarshalToVTStrict(dAtA []byte) (int, error) {
637 size := m.SizeVT()
638 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
639 }
640
641 func (m *ClusterManager_OutlierDetection) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
642 if m == nil {
643 return 0, nil
644 }
645 i := len(dAtA)
646 _ = i
647 var l int
648 _ = l
649 if m.unknownFields != nil {
650 i -= len(m.unknownFields)
651 copy(dAtA[i:], m.unknownFields)
652 }
653 if m.EventService != nil {
654 if vtmsg, ok := interface{}(m.EventService).(interface {
655 MarshalToSizedBufferVTStrict([]byte) (int, error)
656 }); ok {
657 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
658 if err != nil {
659 return 0, err
660 }
661 i -= size
662 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
663 } else {
664 encoded, err := proto.Marshal(m.EventService)
665 if err != nil {
666 return 0, err
667 }
668 i -= len(encoded)
669 copy(dAtA[i:], encoded)
670 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
671 }
672 i--
673 dAtA[i] = 0x12
674 }
675 if len(m.EventLogPath) > 0 {
676 i -= len(m.EventLogPath)
677 copy(dAtA[i:], m.EventLogPath)
678 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EventLogPath)))
679 i--
680 dAtA[i] = 0xa
681 }
682 return len(dAtA) - i, nil
683 }
684
685 func (m *ClusterManager) MarshalVTStrict() (dAtA []byte, err error) {
686 if m == nil {
687 return nil, nil
688 }
689 size := m.SizeVT()
690 dAtA = make([]byte, size)
691 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
692 if err != nil {
693 return nil, err
694 }
695 return dAtA[:n], nil
696 }
697
698 func (m *ClusterManager) MarshalToVTStrict(dAtA []byte) (int, error) {
699 size := m.SizeVT()
700 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
701 }
702
703 func (m *ClusterManager) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
704 if m == nil {
705 return 0, nil
706 }
707 i := len(dAtA)
708 _ = i
709 var l int
710 _ = l
711 if m.unknownFields != nil {
712 i -= len(m.unknownFields)
713 copy(dAtA[i:], m.unknownFields)
714 }
715 if m.LoadStatsConfig != nil {
716 if vtmsg, ok := interface{}(m.LoadStatsConfig).(interface {
717 MarshalToSizedBufferVTStrict([]byte) (int, error)
718 }); ok {
719 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
720 if err != nil {
721 return 0, err
722 }
723 i -= size
724 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
725 } else {
726 encoded, err := proto.Marshal(m.LoadStatsConfig)
727 if err != nil {
728 return 0, err
729 }
730 i -= len(encoded)
731 copy(dAtA[i:], encoded)
732 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
733 }
734 i--
735 dAtA[i] = 0x22
736 }
737 if m.UpstreamBindConfig != nil {
738 if vtmsg, ok := interface{}(m.UpstreamBindConfig).(interface {
739 MarshalToSizedBufferVTStrict([]byte) (int, error)
740 }); ok {
741 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
742 if err != nil {
743 return 0, err
744 }
745 i -= size
746 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
747 } else {
748 encoded, err := proto.Marshal(m.UpstreamBindConfig)
749 if err != nil {
750 return 0, err
751 }
752 i -= len(encoded)
753 copy(dAtA[i:], encoded)
754 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
755 }
756 i--
757 dAtA[i] = 0x1a
758 }
759 if m.OutlierDetection != nil {
760 size, err := m.OutlierDetection.MarshalToSizedBufferVTStrict(dAtA[:i])
761 if err != nil {
762 return 0, err
763 }
764 i -= size
765 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
766 i--
767 dAtA[i] = 0x12
768 }
769 if len(m.LocalClusterName) > 0 {
770 i -= len(m.LocalClusterName)
771 copy(dAtA[i:], m.LocalClusterName)
772 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LocalClusterName)))
773 i--
774 dAtA[i] = 0xa
775 }
776 return len(dAtA) - i, nil
777 }
778
779 func (m *Watchdog) MarshalVTStrict() (dAtA []byte, err error) {
780 if m == nil {
781 return nil, nil
782 }
783 size := m.SizeVT()
784 dAtA = make([]byte, size)
785 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
786 if err != nil {
787 return nil, err
788 }
789 return dAtA[:n], nil
790 }
791
792 func (m *Watchdog) MarshalToVTStrict(dAtA []byte) (int, error) {
793 size := m.SizeVT()
794 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
795 }
796
797 func (m *Watchdog) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
798 if m == nil {
799 return 0, nil
800 }
801 i := len(dAtA)
802 _ = i
803 var l int
804 _ = l
805 if m.unknownFields != nil {
806 i -= len(m.unknownFields)
807 copy(dAtA[i:], m.unknownFields)
808 }
809 if m.MultikillTimeout != nil {
810 size, err := (*durationpb.Duration)(m.MultikillTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
811 if err != nil {
812 return 0, err
813 }
814 i -= size
815 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
816 i--
817 dAtA[i] = 0x22
818 }
819 if m.KillTimeout != nil {
820 size, err := (*durationpb.Duration)(m.KillTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
821 if err != nil {
822 return 0, err
823 }
824 i -= size
825 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
826 i--
827 dAtA[i] = 0x1a
828 }
829 if m.MegamissTimeout != nil {
830 size, err := (*durationpb.Duration)(m.MegamissTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
831 if err != nil {
832 return 0, err
833 }
834 i -= size
835 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
836 i--
837 dAtA[i] = 0x12
838 }
839 if m.MissTimeout != nil {
840 size, err := (*durationpb.Duration)(m.MissTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
841 if err != nil {
842 return 0, err
843 }
844 i -= size
845 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
846 i--
847 dAtA[i] = 0xa
848 }
849 return len(dAtA) - i, nil
850 }
851
852 func (m *Runtime) MarshalVTStrict() (dAtA []byte, err error) {
853 if m == nil {
854 return nil, nil
855 }
856 size := m.SizeVT()
857 dAtA = make([]byte, size)
858 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
859 if err != nil {
860 return nil, err
861 }
862 return dAtA[:n], nil
863 }
864
865 func (m *Runtime) MarshalToVTStrict(dAtA []byte) (int, error) {
866 size := m.SizeVT()
867 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
868 }
869
870 func (m *Runtime) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
871 if m == nil {
872 return 0, nil
873 }
874 i := len(dAtA)
875 _ = i
876 var l int
877 _ = l
878 if m.unknownFields != nil {
879 i -= len(m.unknownFields)
880 copy(dAtA[i:], m.unknownFields)
881 }
882 if m.Base != nil {
883 size, err := (*structpb.Struct)(m.Base).MarshalToSizedBufferVTStrict(dAtA[:i])
884 if err != nil {
885 return 0, err
886 }
887 i -= size
888 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
889 i--
890 dAtA[i] = 0x22
891 }
892 if len(m.OverrideSubdirectory) > 0 {
893 i -= len(m.OverrideSubdirectory)
894 copy(dAtA[i:], m.OverrideSubdirectory)
895 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OverrideSubdirectory)))
896 i--
897 dAtA[i] = 0x1a
898 }
899 if len(m.Subdirectory) > 0 {
900 i -= len(m.Subdirectory)
901 copy(dAtA[i:], m.Subdirectory)
902 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Subdirectory)))
903 i--
904 dAtA[i] = 0x12
905 }
906 if len(m.SymlinkRoot) > 0 {
907 i -= len(m.SymlinkRoot)
908 copy(dAtA[i:], m.SymlinkRoot)
909 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SymlinkRoot)))
910 i--
911 dAtA[i] = 0xa
912 }
913 return len(dAtA) - i, nil
914 }
915
916 func (m *RuntimeLayer_DiskLayer) MarshalVTStrict() (dAtA []byte, err error) {
917 if m == nil {
918 return nil, nil
919 }
920 size := m.SizeVT()
921 dAtA = make([]byte, size)
922 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
923 if err != nil {
924 return nil, err
925 }
926 return dAtA[:n], nil
927 }
928
929 func (m *RuntimeLayer_DiskLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
930 size := m.SizeVT()
931 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
932 }
933
934 func (m *RuntimeLayer_DiskLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
935 if m == nil {
936 return 0, nil
937 }
938 i := len(dAtA)
939 _ = i
940 var l int
941 _ = l
942 if m.unknownFields != nil {
943 i -= len(m.unknownFields)
944 copy(dAtA[i:], m.unknownFields)
945 }
946 if len(m.Subdirectory) > 0 {
947 i -= len(m.Subdirectory)
948 copy(dAtA[i:], m.Subdirectory)
949 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Subdirectory)))
950 i--
951 dAtA[i] = 0x1a
952 }
953 if m.AppendServiceCluster {
954 i--
955 if m.AppendServiceCluster {
956 dAtA[i] = 1
957 } else {
958 dAtA[i] = 0
959 }
960 i--
961 dAtA[i] = 0x10
962 }
963 if len(m.SymlinkRoot) > 0 {
964 i -= len(m.SymlinkRoot)
965 copy(dAtA[i:], m.SymlinkRoot)
966 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SymlinkRoot)))
967 i--
968 dAtA[i] = 0xa
969 }
970 return len(dAtA) - i, nil
971 }
972
973 func (m *RuntimeLayer_AdminLayer) MarshalVTStrict() (dAtA []byte, err error) {
974 if m == nil {
975 return nil, nil
976 }
977 size := m.SizeVT()
978 dAtA = make([]byte, size)
979 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
980 if err != nil {
981 return nil, err
982 }
983 return dAtA[:n], nil
984 }
985
986 func (m *RuntimeLayer_AdminLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
987 size := m.SizeVT()
988 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
989 }
990
991 func (m *RuntimeLayer_AdminLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
992 if m == nil {
993 return 0, nil
994 }
995 i := len(dAtA)
996 _ = i
997 var l int
998 _ = l
999 if m.unknownFields != nil {
1000 i -= len(m.unknownFields)
1001 copy(dAtA[i:], m.unknownFields)
1002 }
1003 return len(dAtA) - i, nil
1004 }
1005
1006 func (m *RuntimeLayer_RtdsLayer) MarshalVTStrict() (dAtA []byte, err error) {
1007 if m == nil {
1008 return nil, nil
1009 }
1010 size := m.SizeVT()
1011 dAtA = make([]byte, size)
1012 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1013 if err != nil {
1014 return nil, err
1015 }
1016 return dAtA[:n], nil
1017 }
1018
1019 func (m *RuntimeLayer_RtdsLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1020 size := m.SizeVT()
1021 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1022 }
1023
1024 func (m *RuntimeLayer_RtdsLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1025 if m == nil {
1026 return 0, nil
1027 }
1028 i := len(dAtA)
1029 _ = i
1030 var l int
1031 _ = l
1032 if m.unknownFields != nil {
1033 i -= len(m.unknownFields)
1034 copy(dAtA[i:], m.unknownFields)
1035 }
1036 if m.RtdsConfig != nil {
1037 if vtmsg, ok := interface{}(m.RtdsConfig).(interface {
1038 MarshalToSizedBufferVTStrict([]byte) (int, error)
1039 }); ok {
1040 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1041 if err != nil {
1042 return 0, err
1043 }
1044 i -= size
1045 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1046 } else {
1047 encoded, err := proto.Marshal(m.RtdsConfig)
1048 if err != nil {
1049 return 0, err
1050 }
1051 i -= len(encoded)
1052 copy(dAtA[i:], encoded)
1053 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1054 }
1055 i--
1056 dAtA[i] = 0x12
1057 }
1058 if len(m.Name) > 0 {
1059 i -= len(m.Name)
1060 copy(dAtA[i:], m.Name)
1061 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1062 i--
1063 dAtA[i] = 0xa
1064 }
1065 return len(dAtA) - i, nil
1066 }
1067
1068 func (m *RuntimeLayer) MarshalVTStrict() (dAtA []byte, err error) {
1069 if m == nil {
1070 return nil, nil
1071 }
1072 size := m.SizeVT()
1073 dAtA = make([]byte, size)
1074 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1075 if err != nil {
1076 return nil, err
1077 }
1078 return dAtA[:n], nil
1079 }
1080
1081 func (m *RuntimeLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1082 size := m.SizeVT()
1083 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1084 }
1085
1086 func (m *RuntimeLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1087 if m == nil {
1088 return 0, nil
1089 }
1090 i := len(dAtA)
1091 _ = i
1092 var l int
1093 _ = l
1094 if m.unknownFields != nil {
1095 i -= len(m.unknownFields)
1096 copy(dAtA[i:], m.unknownFields)
1097 }
1098 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_RtdsLayer_); ok {
1099 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1100 if err != nil {
1101 return 0, err
1102 }
1103 i -= size
1104 }
1105 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_AdminLayer_); ok {
1106 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1107 if err != nil {
1108 return 0, err
1109 }
1110 i -= size
1111 }
1112 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_DiskLayer_); ok {
1113 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1114 if err != nil {
1115 return 0, err
1116 }
1117 i -= size
1118 }
1119 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_StaticLayer); ok {
1120 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1121 if err != nil {
1122 return 0, err
1123 }
1124 i -= size
1125 }
1126 if len(m.Name) > 0 {
1127 i -= len(m.Name)
1128 copy(dAtA[i:], m.Name)
1129 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1130 i--
1131 dAtA[i] = 0xa
1132 }
1133 return len(dAtA) - i, nil
1134 }
1135
1136 func (m *RuntimeLayer_StaticLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1137 size := m.SizeVT()
1138 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1139 }
1140
1141 func (m *RuntimeLayer_StaticLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1142 i := len(dAtA)
1143 if m.StaticLayer != nil {
1144 size, err := (*structpb.Struct)(m.StaticLayer).MarshalToSizedBufferVTStrict(dAtA[:i])
1145 if err != nil {
1146 return 0, err
1147 }
1148 i -= size
1149 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1150 i--
1151 dAtA[i] = 0x12
1152 } else {
1153 i = protohelpers.EncodeVarint(dAtA, i, 0)
1154 i--
1155 dAtA[i] = 0x12
1156 }
1157 return len(dAtA) - i, nil
1158 }
1159 func (m *RuntimeLayer_DiskLayer_) MarshalToVTStrict(dAtA []byte) (int, error) {
1160 size := m.SizeVT()
1161 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1162 }
1163
1164 func (m *RuntimeLayer_DiskLayer_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1165 i := len(dAtA)
1166 if m.DiskLayer != nil {
1167 size, err := m.DiskLayer.MarshalToSizedBufferVTStrict(dAtA[:i])
1168 if err != nil {
1169 return 0, err
1170 }
1171 i -= size
1172 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1173 i--
1174 dAtA[i] = 0x1a
1175 } else {
1176 i = protohelpers.EncodeVarint(dAtA, i, 0)
1177 i--
1178 dAtA[i] = 0x1a
1179 }
1180 return len(dAtA) - i, nil
1181 }
1182 func (m *RuntimeLayer_AdminLayer_) MarshalToVTStrict(dAtA []byte) (int, error) {
1183 size := m.SizeVT()
1184 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1185 }
1186
1187 func (m *RuntimeLayer_AdminLayer_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1188 i := len(dAtA)
1189 if m.AdminLayer != nil {
1190 size, err := m.AdminLayer.MarshalToSizedBufferVTStrict(dAtA[:i])
1191 if err != nil {
1192 return 0, err
1193 }
1194 i -= size
1195 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1196 i--
1197 dAtA[i] = 0x22
1198 } else {
1199 i = protohelpers.EncodeVarint(dAtA, i, 0)
1200 i--
1201 dAtA[i] = 0x22
1202 }
1203 return len(dAtA) - i, nil
1204 }
1205 func (m *RuntimeLayer_RtdsLayer_) MarshalToVTStrict(dAtA []byte) (int, error) {
1206 size := m.SizeVT()
1207 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1208 }
1209
1210 func (m *RuntimeLayer_RtdsLayer_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1211 i := len(dAtA)
1212 if m.RtdsLayer != nil {
1213 size, err := m.RtdsLayer.MarshalToSizedBufferVTStrict(dAtA[:i])
1214 if err != nil {
1215 return 0, err
1216 }
1217 i -= size
1218 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1219 i--
1220 dAtA[i] = 0x2a
1221 } else {
1222 i = protohelpers.EncodeVarint(dAtA, i, 0)
1223 i--
1224 dAtA[i] = 0x2a
1225 }
1226 return len(dAtA) - i, nil
1227 }
1228 func (m *LayeredRuntime) MarshalVTStrict() (dAtA []byte, err error) {
1229 if m == nil {
1230 return nil, nil
1231 }
1232 size := m.SizeVT()
1233 dAtA = make([]byte, size)
1234 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1235 if err != nil {
1236 return nil, err
1237 }
1238 return dAtA[:n], nil
1239 }
1240
1241 func (m *LayeredRuntime) MarshalToVTStrict(dAtA []byte) (int, error) {
1242 size := m.SizeVT()
1243 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1244 }
1245
1246 func (m *LayeredRuntime) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1247 if m == nil {
1248 return 0, nil
1249 }
1250 i := len(dAtA)
1251 _ = i
1252 var l int
1253 _ = l
1254 if m.unknownFields != nil {
1255 i -= len(m.unknownFields)
1256 copy(dAtA[i:], m.unknownFields)
1257 }
1258 if len(m.Layers) > 0 {
1259 for iNdEx := len(m.Layers) - 1; iNdEx >= 0; iNdEx-- {
1260 size, err := m.Layers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1261 if err != nil {
1262 return 0, err
1263 }
1264 i -= size
1265 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1266 i--
1267 dAtA[i] = 0xa
1268 }
1269 }
1270 return len(dAtA) - i, nil
1271 }
1272
1273 func (m *Bootstrap_StaticResources) SizeVT() (n int) {
1274 if m == nil {
1275 return 0
1276 }
1277 var l int
1278 _ = l
1279 if len(m.Listeners) > 0 {
1280 for _, e := range m.Listeners {
1281 if size, ok := interface{}(e).(interface {
1282 SizeVT() int
1283 }); ok {
1284 l = size.SizeVT()
1285 } else {
1286 l = proto.Size(e)
1287 }
1288 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1289 }
1290 }
1291 if len(m.Clusters) > 0 {
1292 for _, e := range m.Clusters {
1293 if size, ok := interface{}(e).(interface {
1294 SizeVT() int
1295 }); ok {
1296 l = size.SizeVT()
1297 } else {
1298 l = proto.Size(e)
1299 }
1300 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1301 }
1302 }
1303 if len(m.Secrets) > 0 {
1304 for _, e := range m.Secrets {
1305 if size, ok := interface{}(e).(interface {
1306 SizeVT() int
1307 }); ok {
1308 l = size.SizeVT()
1309 } else {
1310 l = proto.Size(e)
1311 }
1312 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1313 }
1314 }
1315 n += len(m.unknownFields)
1316 return n
1317 }
1318
1319 func (m *Bootstrap_DynamicResources) SizeVT() (n int) {
1320 if m == nil {
1321 return 0
1322 }
1323 var l int
1324 _ = l
1325 if m.LdsConfig != nil {
1326 if size, ok := interface{}(m.LdsConfig).(interface {
1327 SizeVT() int
1328 }); ok {
1329 l = size.SizeVT()
1330 } else {
1331 l = proto.Size(m.LdsConfig)
1332 }
1333 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1334 }
1335 if m.CdsConfig != nil {
1336 if size, ok := interface{}(m.CdsConfig).(interface {
1337 SizeVT() int
1338 }); ok {
1339 l = size.SizeVT()
1340 } else {
1341 l = proto.Size(m.CdsConfig)
1342 }
1343 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1344 }
1345 if m.AdsConfig != nil {
1346 if size, ok := interface{}(m.AdsConfig).(interface {
1347 SizeVT() int
1348 }); ok {
1349 l = size.SizeVT()
1350 } else {
1351 l = proto.Size(m.AdsConfig)
1352 }
1353 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1354 }
1355 n += len(m.unknownFields)
1356 return n
1357 }
1358
1359 func (m *Bootstrap) SizeVT() (n int) {
1360 if m == nil {
1361 return 0
1362 }
1363 var l int
1364 _ = l
1365 if m.Node != nil {
1366 if size, ok := interface{}(m.Node).(interface {
1367 SizeVT() int
1368 }); ok {
1369 l = size.SizeVT()
1370 } else {
1371 l = proto.Size(m.Node)
1372 }
1373 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1374 }
1375 if m.StaticResources != nil {
1376 l = m.StaticResources.SizeVT()
1377 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1378 }
1379 if m.DynamicResources != nil {
1380 l = m.DynamicResources.SizeVT()
1381 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1382 }
1383 if m.ClusterManager != nil {
1384 l = m.ClusterManager.SizeVT()
1385 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1386 }
1387 l = len(m.FlagsPath)
1388 if l > 0 {
1389 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1390 }
1391 if len(m.StatsSinks) > 0 {
1392 for _, e := range m.StatsSinks {
1393 if size, ok := interface{}(e).(interface {
1394 SizeVT() int
1395 }); ok {
1396 l = size.SizeVT()
1397 } else {
1398 l = proto.Size(e)
1399 }
1400 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1401 }
1402 }
1403 if m.StatsFlushInterval != nil {
1404 l = (*durationpb.Duration)(m.StatsFlushInterval).SizeVT()
1405 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1406 }
1407 if m.Watchdog != nil {
1408 l = m.Watchdog.SizeVT()
1409 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1410 }
1411 if m.Tracing != nil {
1412 if size, ok := interface{}(m.Tracing).(interface {
1413 SizeVT() int
1414 }); ok {
1415 l = size.SizeVT()
1416 } else {
1417 l = proto.Size(m.Tracing)
1418 }
1419 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1420 }
1421 if m.Runtime != nil {
1422 l = m.Runtime.SizeVT()
1423 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1424 }
1425 if m.Admin != nil {
1426 l = m.Admin.SizeVT()
1427 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1428 }
1429 if m.StatsConfig != nil {
1430 if size, ok := interface{}(m.StatsConfig).(interface {
1431 SizeVT() int
1432 }); ok {
1433 l = size.SizeVT()
1434 } else {
1435 l = proto.Size(m.StatsConfig)
1436 }
1437 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1438 }
1439 if m.HdsConfig != nil {
1440 if size, ok := interface{}(m.HdsConfig).(interface {
1441 SizeVT() int
1442 }); ok {
1443 l = size.SizeVT()
1444 } else {
1445 l = proto.Size(m.HdsConfig)
1446 }
1447 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1448 }
1449 if m.OverloadManager != nil {
1450 if size, ok := interface{}(m.OverloadManager).(interface {
1451 SizeVT() int
1452 }); ok {
1453 l = size.SizeVT()
1454 } else {
1455 l = proto.Size(m.OverloadManager)
1456 }
1457 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1458 }
1459 if m.EnableDispatcherStats {
1460 n += 3
1461 }
1462 if m.LayeredRuntime != nil {
1463 l = m.LayeredRuntime.SizeVT()
1464 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1465 }
1466 l = len(m.HeaderPrefix)
1467 if l > 0 {
1468 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1469 }
1470 if m.StatsServerVersionOverride != nil {
1471 l = (*wrapperspb.UInt64Value)(m.StatsServerVersionOverride).SizeVT()
1472 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1473 }
1474 if m.UseTcpForDnsLookups {
1475 n += 3
1476 }
1477 n += len(m.unknownFields)
1478 return n
1479 }
1480
1481 func (m *Admin) SizeVT() (n int) {
1482 if m == nil {
1483 return 0
1484 }
1485 var l int
1486 _ = l
1487 l = len(m.AccessLogPath)
1488 if l > 0 {
1489 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1490 }
1491 l = len(m.ProfilePath)
1492 if l > 0 {
1493 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1494 }
1495 if m.Address != nil {
1496 if size, ok := interface{}(m.Address).(interface {
1497 SizeVT() int
1498 }); ok {
1499 l = size.SizeVT()
1500 } else {
1501 l = proto.Size(m.Address)
1502 }
1503 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1504 }
1505 if len(m.SocketOptions) > 0 {
1506 for _, e := range m.SocketOptions {
1507 if size, ok := interface{}(e).(interface {
1508 SizeVT() int
1509 }); ok {
1510 l = size.SizeVT()
1511 } else {
1512 l = proto.Size(e)
1513 }
1514 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1515 }
1516 }
1517 n += len(m.unknownFields)
1518 return n
1519 }
1520
1521 func (m *ClusterManager_OutlierDetection) SizeVT() (n int) {
1522 if m == nil {
1523 return 0
1524 }
1525 var l int
1526 _ = l
1527 l = len(m.EventLogPath)
1528 if l > 0 {
1529 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1530 }
1531 if m.EventService != nil {
1532 if size, ok := interface{}(m.EventService).(interface {
1533 SizeVT() int
1534 }); ok {
1535 l = size.SizeVT()
1536 } else {
1537 l = proto.Size(m.EventService)
1538 }
1539 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1540 }
1541 n += len(m.unknownFields)
1542 return n
1543 }
1544
1545 func (m *ClusterManager) SizeVT() (n int) {
1546 if m == nil {
1547 return 0
1548 }
1549 var l int
1550 _ = l
1551 l = len(m.LocalClusterName)
1552 if l > 0 {
1553 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1554 }
1555 if m.OutlierDetection != nil {
1556 l = m.OutlierDetection.SizeVT()
1557 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1558 }
1559 if m.UpstreamBindConfig != nil {
1560 if size, ok := interface{}(m.UpstreamBindConfig).(interface {
1561 SizeVT() int
1562 }); ok {
1563 l = size.SizeVT()
1564 } else {
1565 l = proto.Size(m.UpstreamBindConfig)
1566 }
1567 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1568 }
1569 if m.LoadStatsConfig != nil {
1570 if size, ok := interface{}(m.LoadStatsConfig).(interface {
1571 SizeVT() int
1572 }); ok {
1573 l = size.SizeVT()
1574 } else {
1575 l = proto.Size(m.LoadStatsConfig)
1576 }
1577 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1578 }
1579 n += len(m.unknownFields)
1580 return n
1581 }
1582
1583 func (m *Watchdog) SizeVT() (n int) {
1584 if m == nil {
1585 return 0
1586 }
1587 var l int
1588 _ = l
1589 if m.MissTimeout != nil {
1590 l = (*durationpb.Duration)(m.MissTimeout).SizeVT()
1591 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1592 }
1593 if m.MegamissTimeout != nil {
1594 l = (*durationpb.Duration)(m.MegamissTimeout).SizeVT()
1595 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1596 }
1597 if m.KillTimeout != nil {
1598 l = (*durationpb.Duration)(m.KillTimeout).SizeVT()
1599 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1600 }
1601 if m.MultikillTimeout != nil {
1602 l = (*durationpb.Duration)(m.MultikillTimeout).SizeVT()
1603 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1604 }
1605 n += len(m.unknownFields)
1606 return n
1607 }
1608
1609 func (m *Runtime) SizeVT() (n int) {
1610 if m == nil {
1611 return 0
1612 }
1613 var l int
1614 _ = l
1615 l = len(m.SymlinkRoot)
1616 if l > 0 {
1617 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1618 }
1619 l = len(m.Subdirectory)
1620 if l > 0 {
1621 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1622 }
1623 l = len(m.OverrideSubdirectory)
1624 if l > 0 {
1625 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1626 }
1627 if m.Base != nil {
1628 l = (*structpb.Struct)(m.Base).SizeVT()
1629 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1630 }
1631 n += len(m.unknownFields)
1632 return n
1633 }
1634
1635 func (m *RuntimeLayer_DiskLayer) SizeVT() (n int) {
1636 if m == nil {
1637 return 0
1638 }
1639 var l int
1640 _ = l
1641 l = len(m.SymlinkRoot)
1642 if l > 0 {
1643 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1644 }
1645 if m.AppendServiceCluster {
1646 n += 2
1647 }
1648 l = len(m.Subdirectory)
1649 if l > 0 {
1650 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1651 }
1652 n += len(m.unknownFields)
1653 return n
1654 }
1655
1656 func (m *RuntimeLayer_AdminLayer) SizeVT() (n int) {
1657 if m == nil {
1658 return 0
1659 }
1660 var l int
1661 _ = l
1662 n += len(m.unknownFields)
1663 return n
1664 }
1665
1666 func (m *RuntimeLayer_RtdsLayer) SizeVT() (n int) {
1667 if m == nil {
1668 return 0
1669 }
1670 var l int
1671 _ = l
1672 l = len(m.Name)
1673 if l > 0 {
1674 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1675 }
1676 if m.RtdsConfig != nil {
1677 if size, ok := interface{}(m.RtdsConfig).(interface {
1678 SizeVT() int
1679 }); ok {
1680 l = size.SizeVT()
1681 } else {
1682 l = proto.Size(m.RtdsConfig)
1683 }
1684 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1685 }
1686 n += len(m.unknownFields)
1687 return n
1688 }
1689
1690 func (m *RuntimeLayer) SizeVT() (n int) {
1691 if m == nil {
1692 return 0
1693 }
1694 var l int
1695 _ = l
1696 l = len(m.Name)
1697 if l > 0 {
1698 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1699 }
1700 if vtmsg, ok := m.LayerSpecifier.(interface{ SizeVT() int }); ok {
1701 n += vtmsg.SizeVT()
1702 }
1703 n += len(m.unknownFields)
1704 return n
1705 }
1706
1707 func (m *RuntimeLayer_StaticLayer) SizeVT() (n int) {
1708 if m == nil {
1709 return 0
1710 }
1711 var l int
1712 _ = l
1713 if m.StaticLayer != nil {
1714 l = (*structpb.Struct)(m.StaticLayer).SizeVT()
1715 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1716 } else {
1717 n += 2
1718 }
1719 return n
1720 }
1721 func (m *RuntimeLayer_DiskLayer_) SizeVT() (n int) {
1722 if m == nil {
1723 return 0
1724 }
1725 var l int
1726 _ = l
1727 if m.DiskLayer != nil {
1728 l = m.DiskLayer.SizeVT()
1729 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1730 } else {
1731 n += 2
1732 }
1733 return n
1734 }
1735 func (m *RuntimeLayer_AdminLayer_) SizeVT() (n int) {
1736 if m == nil {
1737 return 0
1738 }
1739 var l int
1740 _ = l
1741 if m.AdminLayer != nil {
1742 l = m.AdminLayer.SizeVT()
1743 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1744 } else {
1745 n += 2
1746 }
1747 return n
1748 }
1749 func (m *RuntimeLayer_RtdsLayer_) SizeVT() (n int) {
1750 if m == nil {
1751 return 0
1752 }
1753 var l int
1754 _ = l
1755 if m.RtdsLayer != nil {
1756 l = m.RtdsLayer.SizeVT()
1757 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1758 } else {
1759 n += 2
1760 }
1761 return n
1762 }
1763 func (m *LayeredRuntime) SizeVT() (n int) {
1764 if m == nil {
1765 return 0
1766 }
1767 var l int
1768 _ = l
1769 if len(m.Layers) > 0 {
1770 for _, e := range m.Layers {
1771 l = e.SizeVT()
1772 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1773 }
1774 }
1775 n += len(m.unknownFields)
1776 return n
1777 }