Debian Codegraph @

envoy/config/bootstrap/v3/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/v3/bootstrap.proto
6
7 package bootstrapv3
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 len(m.CdsResourcesLocator) > 0 {
161 i -= len(m.CdsResourcesLocator)
162 copy(dAtA[i:], m.CdsResourcesLocator)
163 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CdsResourcesLocator)))
164 i--
165 dAtA[i] = 0x32
166 }
167 if len(m.LdsResourcesLocator) > 0 {
168 i -= len(m.LdsResourcesLocator)
169 copy(dAtA[i:], m.LdsResourcesLocator)
170 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LdsResourcesLocator)))
171 i--
172 dAtA[i] = 0x2a
173 }
174 if m.AdsConfig != nil {
175 if vtmsg, ok := interface{}(m.AdsConfig).(interface {
176 MarshalToSizedBufferVTStrict([]byte) (int, error)
177 }); ok {
178 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
179 if err != nil {
180 return 0, err
181 }
182 i -= size
183 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
184 } else {
185 encoded, err := proto.Marshal(m.AdsConfig)
186 if err != nil {
187 return 0, err
188 }
189 i -= len(encoded)
190 copy(dAtA[i:], encoded)
191 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
192 }
193 i--
194 dAtA[i] = 0x1a
195 }
196 if m.CdsConfig != nil {
197 if vtmsg, ok := interface{}(m.CdsConfig).(interface {
198 MarshalToSizedBufferVTStrict([]byte) (int, error)
199 }); ok {
200 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
201 if err != nil {
202 return 0, err
203 }
204 i -= size
205 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
206 } else {
207 encoded, err := proto.Marshal(m.CdsConfig)
208 if err != nil {
209 return 0, err
210 }
211 i -= len(encoded)
212 copy(dAtA[i:], encoded)
213 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
214 }
215 i--
216 dAtA[i] = 0x12
217 }
218 if m.LdsConfig != nil {
219 if vtmsg, ok := interface{}(m.LdsConfig).(interface {
220 MarshalToSizedBufferVTStrict([]byte) (int, error)
221 }); ok {
222 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
223 if err != nil {
224 return 0, err
225 }
226 i -= size
227 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
228 } else {
229 encoded, err := proto.Marshal(m.LdsConfig)
230 if err != nil {
231 return 0, err
232 }
233 i -= len(encoded)
234 copy(dAtA[i:], encoded)
235 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
236 }
237 i--
238 dAtA[i] = 0xa
239 }
240 return len(dAtA) - i, nil
241 }
242
243 func (m *Bootstrap_ApplicationLogConfig_LogFormat) MarshalVTStrict() (dAtA []byte, err error) {
244 if m == nil {
245 return nil, nil
246 }
247 size := m.SizeVT()
248 dAtA = make([]byte, size)
249 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
250 if err != nil {
251 return nil, err
252 }
253 return dAtA[:n], nil
254 }
255
256 func (m *Bootstrap_ApplicationLogConfig_LogFormat) MarshalToVTStrict(dAtA []byte) (int, error) {
257 size := m.SizeVT()
258 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
259 }
260
261 func (m *Bootstrap_ApplicationLogConfig_LogFormat) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
262 if m == nil {
263 return 0, nil
264 }
265 i := len(dAtA)
266 _ = i
267 var l int
268 _ = l
269 if m.unknownFields != nil {
270 i -= len(m.unknownFields)
271 copy(dAtA[i:], m.unknownFields)
272 }
273 if msg, ok := m.LogFormat.(*Bootstrap_ApplicationLogConfig_LogFormat_TextFormat); ok {
274 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
275 if err != nil {
276 return 0, err
277 }
278 i -= size
279 }
280 if msg, ok := m.LogFormat.(*Bootstrap_ApplicationLogConfig_LogFormat_JsonFormat); ok {
281 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
282 if err != nil {
283 return 0, err
284 }
285 i -= size
286 }
287 return len(dAtA) - i, nil
288 }
289
290 func (m *Bootstrap_ApplicationLogConfig_LogFormat_JsonFormat) MarshalToVTStrict(dAtA []byte) (int, error) {
291 size := m.SizeVT()
292 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
293 }
294
295 func (m *Bootstrap_ApplicationLogConfig_LogFormat_JsonFormat) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
296 i := len(dAtA)
297 if m.JsonFormat != nil {
298 size, err := (*structpb.Struct)(m.JsonFormat).MarshalToSizedBufferVTStrict(dAtA[:i])
299 if err != nil {
300 return 0, err
301 }
302 i -= size
303 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
304 i--
305 dAtA[i] = 0xa
306 } else {
307 i = protohelpers.EncodeVarint(dAtA, i, 0)
308 i--
309 dAtA[i] = 0xa
310 }
311 return len(dAtA) - i, nil
312 }
313 func (m *Bootstrap_ApplicationLogConfig_LogFormat_TextFormat) MarshalToVTStrict(dAtA []byte) (int, error) {
314 size := m.SizeVT()
315 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
316 }
317
318 func (m *Bootstrap_ApplicationLogConfig_LogFormat_TextFormat) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
319 i := len(dAtA)
320 i -= len(m.TextFormat)
321 copy(dAtA[i:], m.TextFormat)
322 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TextFormat)))
323 i--
324 dAtA[i] = 0x12
325 return len(dAtA) - i, nil
326 }
327 func (m *Bootstrap_ApplicationLogConfig) MarshalVTStrict() (dAtA []byte, err error) {
328 if m == nil {
329 return nil, nil
330 }
331 size := m.SizeVT()
332 dAtA = make([]byte, size)
333 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
334 if err != nil {
335 return nil, err
336 }
337 return dAtA[:n], nil
338 }
339
340 func (m *Bootstrap_ApplicationLogConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
341 size := m.SizeVT()
342 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
343 }
344
345 func (m *Bootstrap_ApplicationLogConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
346 if m == nil {
347 return 0, nil
348 }
349 i := len(dAtA)
350 _ = i
351 var l int
352 _ = l
353 if m.unknownFields != nil {
354 i -= len(m.unknownFields)
355 copy(dAtA[i:], m.unknownFields)
356 }
357 if m.LogFormat != nil {
358 size, err := m.LogFormat.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] = 0xa
366 }
367 return len(dAtA) - i, nil
368 }
369
370 func (m *Bootstrap_DeferredStatOptions) MarshalVTStrict() (dAtA []byte, err error) {
371 if m == nil {
372 return nil, nil
373 }
374 size := m.SizeVT()
375 dAtA = make([]byte, size)
376 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
377 if err != nil {
378 return nil, err
379 }
380 return dAtA[:n], nil
381 }
382
383 func (m *Bootstrap_DeferredStatOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
384 size := m.SizeVT()
385 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
386 }
387
388 func (m *Bootstrap_DeferredStatOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
389 if m == nil {
390 return 0, nil
391 }
392 i := len(dAtA)
393 _ = i
394 var l int
395 _ = l
396 if m.unknownFields != nil {
397 i -= len(m.unknownFields)
398 copy(dAtA[i:], m.unknownFields)
399 }
400 if m.EnableDeferredCreationStats {
401 i--
402 if m.EnableDeferredCreationStats {
403 dAtA[i] = 1
404 } else {
405 dAtA[i] = 0
406 }
407 i--
408 dAtA[i] = 0x8
409 }
410 return len(dAtA) - i, nil
411 }
412
413 func (m *Bootstrap_GrpcAsyncClientManagerConfig) MarshalVTStrict() (dAtA []byte, err error) {
414 if m == nil {
415 return nil, nil
416 }
417 size := m.SizeVT()
418 dAtA = make([]byte, size)
419 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
420 if err != nil {
421 return nil, err
422 }
423 return dAtA[:n], nil
424 }
425
426 func (m *Bootstrap_GrpcAsyncClientManagerConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
427 size := m.SizeVT()
428 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
429 }
430
431 func (m *Bootstrap_GrpcAsyncClientManagerConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
432 if m == nil {
433 return 0, nil
434 }
435 i := len(dAtA)
436 _ = i
437 var l int
438 _ = l
439 if m.unknownFields != nil {
440 i -= len(m.unknownFields)
441 copy(dAtA[i:], m.unknownFields)
442 }
443 if m.MaxCachedEntryIdleDuration != nil {
444 size, err := (*durationpb.Duration)(m.MaxCachedEntryIdleDuration).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] = 0xa
452 }
453 return len(dAtA) - i, nil
454 }
455
456 func (m *Bootstrap) MarshalVTStrict() (dAtA []byte, err error) {
457 if m == nil {
458 return nil, nil
459 }
460 size := m.SizeVT()
461 dAtA = make([]byte, size)
462 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
463 if err != nil {
464 return nil, err
465 }
466 return dAtA[:n], nil
467 }
468
469 func (m *Bootstrap) MarshalToVTStrict(dAtA []byte) (int, error) {
470 size := m.SizeVT()
471 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
472 }
473
474 func (m *Bootstrap) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
475 if m == nil {
476 return 0, nil
477 }
478 i := len(dAtA)
479 _ = i
480 var l int
481 _ = l
482 if m.unknownFields != nil {
483 i -= len(m.unknownFields)
484 copy(dAtA[i:], m.unknownFields)
485 }
486 if m.MemoryAllocatorManager != nil {
487 size, err := m.MemoryAllocatorManager.MarshalToSizedBufferVTStrict(dAtA[:i])
488 if err != nil {
489 return 0, err
490 }
491 i -= size
492 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
493 i--
494 dAtA[i] = 0x2
495 i--
496 dAtA[i] = 0xca
497 }
498 if m.GrpcAsyncClientManagerConfig != nil {
499 size, err := m.GrpcAsyncClientManagerConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
500 if err != nil {
501 return 0, err
502 }
503 i -= size
504 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
505 i--
506 dAtA[i] = 0x2
507 i--
508 dAtA[i] = 0xc2
509 }
510 if m.DeferredStatOptions != nil {
511 size, err := m.DeferredStatOptions.MarshalToSizedBufferVTStrict(dAtA[:i])
512 if err != nil {
513 return 0, err
514 }
515 i -= size
516 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
517 i--
518 dAtA[i] = 0x2
519 i--
520 dAtA[i] = 0xba
521 }
522 if m.ApplicationLogConfig != nil {
523 size, err := m.ApplicationLogConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
524 if err != nil {
525 return 0, err
526 }
527 i -= size
528 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
529 i--
530 dAtA[i] = 0x2
531 i--
532 dAtA[i] = 0xb2
533 }
534 if m.ListenerManager != nil {
535 if vtmsg, ok := interface{}(m.ListenerManager).(interface {
536 MarshalToSizedBufferVTStrict([]byte) (int, error)
537 }); ok {
538 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
539 if err != nil {
540 return 0, err
541 }
542 i -= size
543 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
544 } else {
545 encoded, err := proto.Marshal(m.ListenerManager)
546 if err != nil {
547 return 0, err
548 }
549 i -= len(encoded)
550 copy(dAtA[i:], encoded)
551 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
552 }
553 i--
554 dAtA[i] = 0x2
555 i--
556 dAtA[i] = 0xaa
557 }
558 if m.XdsConfigTrackerExtension != nil {
559 if vtmsg, ok := interface{}(m.XdsConfigTrackerExtension).(interface {
560 MarshalToSizedBufferVTStrict([]byte) (int, error)
561 }); ok {
562 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
563 if err != nil {
564 return 0, err
565 }
566 i -= size
567 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
568 } else {
569 encoded, err := proto.Marshal(m.XdsConfigTrackerExtension)
570 if err != nil {
571 return 0, err
572 }
573 i -= len(encoded)
574 copy(dAtA[i:], encoded)
575 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
576 }
577 i--
578 dAtA[i] = 0x2
579 i--
580 dAtA[i] = 0xa2
581 }
582 if m.XdsDelegateExtension != nil {
583 if vtmsg, ok := interface{}(m.XdsDelegateExtension).(interface {
584 MarshalToSizedBufferVTStrict([]byte) (int, error)
585 }); ok {
586 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
587 if err != nil {
588 return 0, err
589 }
590 i -= size
591 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
592 } else {
593 encoded, err := proto.Marshal(m.XdsDelegateExtension)
594 if err != nil {
595 return 0, err
596 }
597 i -= len(encoded)
598 copy(dAtA[i:], encoded)
599 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
600 }
601 i--
602 dAtA[i] = 0x2
603 i--
604 dAtA[i] = 0x9a
605 }
606 if m.DefaultRegexEngine != nil {
607 if vtmsg, ok := interface{}(m.DefaultRegexEngine).(interface {
608 MarshalToSizedBufferVTStrict([]byte) (int, error)
609 }); ok {
610 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
611 if err != nil {
612 return 0, err
613 }
614 i -= size
615 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
616 } else {
617 encoded, err := proto.Marshal(m.DefaultRegexEngine)
618 if err != nil {
619 return 0, err
620 }
621 i -= len(encoded)
622 copy(dAtA[i:], encoded)
623 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
624 }
625 i--
626 dAtA[i] = 0x2
627 i--
628 dAtA[i] = 0x92
629 }
630 if len(m.PerfTracingFilePath) > 0 {
631 i -= len(m.PerfTracingFilePath)
632 copy(dAtA[i:], m.PerfTracingFilePath)
633 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PerfTracingFilePath)))
634 i--
635 dAtA[i] = 0x2
636 i--
637 dAtA[i] = 0x8a
638 }
639 if len(m.InlineHeaders) > 0 {
640 for iNdEx := len(m.InlineHeaders) - 1; iNdEx >= 0; iNdEx-- {
641 size, err := m.InlineHeaders[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
642 if err != nil {
643 return 0, err
644 }
645 i -= size
646 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
647 i--
648 dAtA[i] = 0x2
649 i--
650 dAtA[i] = 0x82
651 }
652 }
653 if m.TypedDnsResolverConfig != nil {
654 if vtmsg, ok := interface{}(m.TypedDnsResolverConfig).(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.TypedDnsResolverConfig)
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] = 0x1
674 i--
675 dAtA[i] = 0xfa
676 }
677 if m.DnsResolutionConfig != nil {
678 if vtmsg, ok := interface{}(m.DnsResolutionConfig).(interface {
679 MarshalToSizedBufferVTStrict([]byte) (int, error)
680 }); ok {
681 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
682 if err != nil {
683 return 0, err
684 }
685 i -= size
686 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
687 } else {
688 encoded, err := proto.Marshal(m.DnsResolutionConfig)
689 if err != nil {
690 return 0, err
691 }
692 i -= len(encoded)
693 copy(dAtA[i:], encoded)
694 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
695 }
696 i--
697 dAtA[i] = 0x1
698 i--
699 dAtA[i] = 0xf2
700 }
701 if msg, ok := m.StatsFlush.(*Bootstrap_StatsFlushOnAdmin); ok {
702 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
703 if err != nil {
704 return 0, err
705 }
706 i -= size
707 }
708 if len(m.FatalActions) > 0 {
709 for iNdEx := len(m.FatalActions) - 1; iNdEx >= 0; iNdEx-- {
710 size, err := m.FatalActions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
711 if err != nil {
712 return 0, err
713 }
714 i -= size
715 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
716 i--
717 dAtA[i] = 0x1
718 i--
719 dAtA[i] = 0xe2
720 }
721 }
722 if m.Watchdogs != nil {
723 size, err := m.Watchdogs.MarshalToSizedBufferVTStrict(dAtA[:i])
724 if err != nil {
725 return 0, err
726 }
727 i -= size
728 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
729 i--
730 dAtA[i] = 0x1
731 i--
732 dAtA[i] = 0xda
733 }
734 if len(m.NodeContextParams) > 0 {
735 for iNdEx := len(m.NodeContextParams) - 1; iNdEx >= 0; iNdEx-- {
736 i -= len(m.NodeContextParams[iNdEx])
737 copy(dAtA[i:], m.NodeContextParams[iNdEx])
738 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeContextParams[iNdEx])))
739 i--
740 dAtA[i] = 0x1
741 i--
742 dAtA[i] = 0xd2
743 }
744 }
745 if len(m.CertificateProviderInstances) > 0 {
746 for k := range m.CertificateProviderInstances {
747 v := m.CertificateProviderInstances[k]
748 baseI := i
749 if vtmsg, ok := interface{}(v).(interface {
750 MarshalToSizedBufferVTStrict([]byte) (int, error)
751 }); ok {
752 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
753 if err != nil {
754 return 0, err
755 }
756 i -= size
757 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
758 } else {
759 encoded, err := proto.Marshal(v)
760 if err != nil {
761 return 0, err
762 }
763 i -= len(encoded)
764 copy(dAtA[i:], encoded)
765 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
766 }
767 i--
768 dAtA[i] = 0x12
769 i -= len(k)
770 copy(dAtA[i:], k)
771 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
772 i--
773 dAtA[i] = 0xa
774 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
775 i--
776 dAtA[i] = 0x1
777 i--
778 dAtA[i] = 0xca
779 }
780 }
781 if len(m.DefaultSocketInterface) > 0 {
782 i -= len(m.DefaultSocketInterface)
783 copy(dAtA[i:], m.DefaultSocketInterface)
784 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultSocketInterface)))
785 i--
786 dAtA[i] = 0x1
787 i--
788 dAtA[i] = 0xc2
789 }
790 if m.DefaultConfigSource != nil {
791 if vtmsg, ok := interface{}(m.DefaultConfigSource).(interface {
792 MarshalToSizedBufferVTStrict([]byte) (int, error)
793 }); ok {
794 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
795 if err != nil {
796 return 0, err
797 }
798 i -= size
799 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
800 } else {
801 encoded, err := proto.Marshal(m.DefaultConfigSource)
802 if err != nil {
803 return 0, err
804 }
805 i -= len(encoded)
806 copy(dAtA[i:], encoded)
807 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
808 }
809 i--
810 dAtA[i] = 0x1
811 i--
812 dAtA[i] = 0xba
813 }
814 if len(m.ConfigSources) > 0 {
815 for iNdEx := len(m.ConfigSources) - 1; iNdEx >= 0; iNdEx-- {
816 if vtmsg, ok := interface{}(m.ConfigSources[iNdEx]).(interface {
817 MarshalToSizedBufferVTStrict([]byte) (int, error)
818 }); ok {
819 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
820 if err != nil {
821 return 0, err
822 }
823 i -= size
824 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
825 } else {
826 encoded, err := proto.Marshal(m.ConfigSources[iNdEx])
827 if err != nil {
828 return 0, err
829 }
830 i -= len(encoded)
831 copy(dAtA[i:], encoded)
832 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
833 }
834 i--
835 dAtA[i] = 0x1
836 i--
837 dAtA[i] = 0xb2
838 }
839 }
840 if len(m.BootstrapExtensions) > 0 {
841 for iNdEx := len(m.BootstrapExtensions) - 1; iNdEx >= 0; iNdEx-- {
842 if vtmsg, ok := interface{}(m.BootstrapExtensions[iNdEx]).(interface {
843 MarshalToSizedBufferVTStrict([]byte) (int, error)
844 }); ok {
845 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
846 if err != nil {
847 return 0, err
848 }
849 i -= size
850 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
851 } else {
852 encoded, err := proto.Marshal(m.BootstrapExtensions[iNdEx])
853 if err != nil {
854 return 0, err
855 }
856 i -= len(encoded)
857 copy(dAtA[i:], encoded)
858 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
859 }
860 i--
861 dAtA[i] = 0x1
862 i--
863 dAtA[i] = 0xaa
864 }
865 }
866 if m.UseTcpForDnsLookups {
867 i--
868 if m.UseTcpForDnsLookups {
869 dAtA[i] = 1
870 } else {
871 dAtA[i] = 0
872 }
873 i--
874 dAtA[i] = 0x1
875 i--
876 dAtA[i] = 0xa0
877 }
878 if m.StatsServerVersionOverride != nil {
879 size, err := (*wrapperspb.UInt64Value)(m.StatsServerVersionOverride).MarshalToSizedBufferVTStrict(dAtA[:i])
880 if err != nil {
881 return 0, err
882 }
883 i -= size
884 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
885 i--
886 dAtA[i] = 0x1
887 i--
888 dAtA[i] = 0x9a
889 }
890 if len(m.HeaderPrefix) > 0 {
891 i -= len(m.HeaderPrefix)
892 copy(dAtA[i:], m.HeaderPrefix)
893 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeaderPrefix)))
894 i--
895 dAtA[i] = 0x1
896 i--
897 dAtA[i] = 0x92
898 }
899 if m.LayeredRuntime != nil {
900 size, err := m.LayeredRuntime.MarshalToSizedBufferVTStrict(dAtA[:i])
901 if err != nil {
902 return 0, err
903 }
904 i -= size
905 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
906 i--
907 dAtA[i] = 0x1
908 i--
909 dAtA[i] = 0x8a
910 }
911 if m.EnableDispatcherStats {
912 i--
913 if m.EnableDispatcherStats {
914 dAtA[i] = 1
915 } else {
916 dAtA[i] = 0
917 }
918 i--
919 dAtA[i] = 0x1
920 i--
921 dAtA[i] = 0x80
922 }
923 if m.OverloadManager != nil {
924 if vtmsg, ok := interface{}(m.OverloadManager).(interface {
925 MarshalToSizedBufferVTStrict([]byte) (int, error)
926 }); ok {
927 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
928 if err != nil {
929 return 0, err
930 }
931 i -= size
932 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
933 } else {
934 encoded, err := proto.Marshal(m.OverloadManager)
935 if err != nil {
936 return 0, err
937 }
938 i -= len(encoded)
939 copy(dAtA[i:], encoded)
940 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
941 }
942 i--
943 dAtA[i] = 0x7a
944 }
945 if m.HdsConfig != nil {
946 if vtmsg, ok := interface{}(m.HdsConfig).(interface {
947 MarshalToSizedBufferVTStrict([]byte) (int, error)
948 }); ok {
949 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
950 if err != nil {
951 return 0, err
952 }
953 i -= size
954 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
955 } else {
956 encoded, err := proto.Marshal(m.HdsConfig)
957 if err != nil {
958 return 0, err
959 }
960 i -= len(encoded)
961 copy(dAtA[i:], encoded)
962 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
963 }
964 i--
965 dAtA[i] = 0x72
966 }
967 if m.StatsConfig != nil {
968 if vtmsg, ok := interface{}(m.StatsConfig).(interface {
969 MarshalToSizedBufferVTStrict([]byte) (int, error)
970 }); ok {
971 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
972 if err != nil {
973 return 0, err
974 }
975 i -= size
976 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
977 } else {
978 encoded, err := proto.Marshal(m.StatsConfig)
979 if err != nil {
980 return 0, err
981 }
982 i -= len(encoded)
983 copy(dAtA[i:], encoded)
984 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
985 }
986 i--
987 dAtA[i] = 0x6a
988 }
989 if m.Admin != nil {
990 size, err := m.Admin.MarshalToSizedBufferVTStrict(dAtA[:i])
991 if err != nil {
992 return 0, err
993 }
994 i -= size
995 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
996 i--
997 dAtA[i] = 0x62
998 }
999 if m.Tracing != nil {
1000 if vtmsg, ok := interface{}(m.Tracing).(interface {
1001 MarshalToSizedBufferVTStrict([]byte) (int, error)
1002 }); ok {
1003 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1004 if err != nil {
1005 return 0, err
1006 }
1007 i -= size
1008 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1009 } else {
1010 encoded, err := proto.Marshal(m.Tracing)
1011 if err != nil {
1012 return 0, err
1013 }
1014 i -= len(encoded)
1015 copy(dAtA[i:], encoded)
1016 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1017 }
1018 i--
1019 dAtA[i] = 0x4a
1020 }
1021 if m.Watchdog != nil {
1022 size, err := m.Watchdog.MarshalToSizedBufferVTStrict(dAtA[:i])
1023 if err != nil {
1024 return 0, err
1025 }
1026 i -= size
1027 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1028 i--
1029 dAtA[i] = 0x42
1030 }
1031 if m.StatsFlushInterval != nil {
1032 size, err := (*durationpb.Duration)(m.StatsFlushInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
1033 if err != nil {
1034 return 0, err
1035 }
1036 i -= size
1037 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1038 i--
1039 dAtA[i] = 0x3a
1040 }
1041 if len(m.StatsSinks) > 0 {
1042 for iNdEx := len(m.StatsSinks) - 1; iNdEx >= 0; iNdEx-- {
1043 if vtmsg, ok := interface{}(m.StatsSinks[iNdEx]).(interface {
1044 MarshalToSizedBufferVTStrict([]byte) (int, error)
1045 }); ok {
1046 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1047 if err != nil {
1048 return 0, err
1049 }
1050 i -= size
1051 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1052 } else {
1053 encoded, err := proto.Marshal(m.StatsSinks[iNdEx])
1054 if err != nil {
1055 return 0, err
1056 }
1057 i -= len(encoded)
1058 copy(dAtA[i:], encoded)
1059 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1060 }
1061 i--
1062 dAtA[i] = 0x32
1063 }
1064 }
1065 if len(m.FlagsPath) > 0 {
1066 i -= len(m.FlagsPath)
1067 copy(dAtA[i:], m.FlagsPath)
1068 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FlagsPath)))
1069 i--
1070 dAtA[i] = 0x2a
1071 }
1072 if m.ClusterManager != nil {
1073 size, err := m.ClusterManager.MarshalToSizedBufferVTStrict(dAtA[:i])
1074 if err != nil {
1075 return 0, err
1076 }
1077 i -= size
1078 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1079 i--
1080 dAtA[i] = 0x22
1081 }
1082 if m.DynamicResources != nil {
1083 size, err := m.DynamicResources.MarshalToSizedBufferVTStrict(dAtA[:i])
1084 if err != nil {
1085 return 0, err
1086 }
1087 i -= size
1088 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1089 i--
1090 dAtA[i] = 0x1a
1091 }
1092 if m.StaticResources != nil {
1093 size, err := m.StaticResources.MarshalToSizedBufferVTStrict(dAtA[:i])
1094 if err != nil {
1095 return 0, err
1096 }
1097 i -= size
1098 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1099 i--
1100 dAtA[i] = 0x12
1101 }
1102 if m.Node != nil {
1103 if vtmsg, ok := interface{}(m.Node).(interface {
1104 MarshalToSizedBufferVTStrict([]byte) (int, error)
1105 }); ok {
1106 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1107 if err != nil {
1108 return 0, err
1109 }
1110 i -= size
1111 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1112 } else {
1113 encoded, err := proto.Marshal(m.Node)
1114 if err != nil {
1115 return 0, err
1116 }
1117 i -= len(encoded)
1118 copy(dAtA[i:], encoded)
1119 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1120 }
1121 i--
1122 dAtA[i] = 0xa
1123 }
1124 return len(dAtA) - i, nil
1125 }
1126
1127 func (m *Bootstrap_StatsFlushOnAdmin) MarshalToVTStrict(dAtA []byte) (int, error) {
1128 size := m.SizeVT()
1129 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1130 }
1131
1132 func (m *Bootstrap_StatsFlushOnAdmin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1133 i := len(dAtA)
1134 i--
1135 if m.StatsFlushOnAdmin {
1136 dAtA[i] = 1
1137 } else {
1138 dAtA[i] = 0
1139 }
1140 i--
1141 dAtA[i] = 0x1
1142 i--
1143 dAtA[i] = 0xe8
1144 return len(dAtA) - i, nil
1145 }
1146 func (m *Admin) MarshalVTStrict() (dAtA []byte, err error) {
1147 if m == nil {
1148 return nil, nil
1149 }
1150 size := m.SizeVT()
1151 dAtA = make([]byte, size)
1152 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1153 if err != nil {
1154 return nil, err
1155 }
1156 return dAtA[:n], nil
1157 }
1158
1159 func (m *Admin) MarshalToVTStrict(dAtA []byte) (int, error) {
1160 size := m.SizeVT()
1161 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1162 }
1163
1164 func (m *Admin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1165 if m == nil {
1166 return 0, nil
1167 }
1168 i := len(dAtA)
1169 _ = i
1170 var l int
1171 _ = l
1172 if m.unknownFields != nil {
1173 i -= len(m.unknownFields)
1174 copy(dAtA[i:], m.unknownFields)
1175 }
1176 if m.IgnoreGlobalConnLimit {
1177 i--
1178 if m.IgnoreGlobalConnLimit {
1179 dAtA[i] = 1
1180 } else {
1181 dAtA[i] = 0
1182 }
1183 i--
1184 dAtA[i] = 0x30
1185 }
1186 if len(m.AccessLog) > 0 {
1187 for iNdEx := len(m.AccessLog) - 1; iNdEx >= 0; iNdEx-- {
1188 if vtmsg, ok := interface{}(m.AccessLog[iNdEx]).(interface {
1189 MarshalToSizedBufferVTStrict([]byte) (int, error)
1190 }); ok {
1191 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1192 if err != nil {
1193 return 0, err
1194 }
1195 i -= size
1196 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1197 } else {
1198 encoded, err := proto.Marshal(m.AccessLog[iNdEx])
1199 if err != nil {
1200 return 0, err
1201 }
1202 i -= len(encoded)
1203 copy(dAtA[i:], encoded)
1204 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1205 }
1206 i--
1207 dAtA[i] = 0x2a
1208 }
1209 }
1210 if len(m.SocketOptions) > 0 {
1211 for iNdEx := len(m.SocketOptions) - 1; iNdEx >= 0; iNdEx-- {
1212 if vtmsg, ok := interface{}(m.SocketOptions[iNdEx]).(interface {
1213 MarshalToSizedBufferVTStrict([]byte) (int, error)
1214 }); ok {
1215 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1216 if err != nil {
1217 return 0, err
1218 }
1219 i -= size
1220 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1221 } else {
1222 encoded, err := proto.Marshal(m.SocketOptions[iNdEx])
1223 if err != nil {
1224 return 0, err
1225 }
1226 i -= len(encoded)
1227 copy(dAtA[i:], encoded)
1228 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1229 }
1230 i--
1231 dAtA[i] = 0x22
1232 }
1233 }
1234 if m.Address != nil {
1235 if vtmsg, ok := interface{}(m.Address).(interface {
1236 MarshalToSizedBufferVTStrict([]byte) (int, error)
1237 }); ok {
1238 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1239 if err != nil {
1240 return 0, err
1241 }
1242 i -= size
1243 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1244 } else {
1245 encoded, err := proto.Marshal(m.Address)
1246 if err != nil {
1247 return 0, err
1248 }
1249 i -= len(encoded)
1250 copy(dAtA[i:], encoded)
1251 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1252 }
1253 i--
1254 dAtA[i] = 0x1a
1255 }
1256 if len(m.ProfilePath) > 0 {
1257 i -= len(m.ProfilePath)
1258 copy(dAtA[i:], m.ProfilePath)
1259 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ProfilePath)))
1260 i--
1261 dAtA[i] = 0x12
1262 }
1263 if len(m.AccessLogPath) > 0 {
1264 i -= len(m.AccessLogPath)
1265 copy(dAtA[i:], m.AccessLogPath)
1266 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AccessLogPath)))
1267 i--
1268 dAtA[i] = 0xa
1269 }
1270 return len(dAtA) - i, nil
1271 }
1272
1273 func (m *ClusterManager_OutlierDetection) MarshalVTStrict() (dAtA []byte, err error) {
1274 if m == nil {
1275 return nil, nil
1276 }
1277 size := m.SizeVT()
1278 dAtA = make([]byte, size)
1279 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1280 if err != nil {
1281 return nil, err
1282 }
1283 return dAtA[:n], nil
1284 }
1285
1286 func (m *ClusterManager_OutlierDetection) MarshalToVTStrict(dAtA []byte) (int, error) {
1287 size := m.SizeVT()
1288 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1289 }
1290
1291 func (m *ClusterManager_OutlierDetection) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1292 if m == nil {
1293 return 0, nil
1294 }
1295 i := len(dAtA)
1296 _ = i
1297 var l int
1298 _ = l
1299 if m.unknownFields != nil {
1300 i -= len(m.unknownFields)
1301 copy(dAtA[i:], m.unknownFields)
1302 }
1303 if m.EventService != nil {
1304 if vtmsg, ok := interface{}(m.EventService).(interface {
1305 MarshalToSizedBufferVTStrict([]byte) (int, error)
1306 }); ok {
1307 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1308 if err != nil {
1309 return 0, err
1310 }
1311 i -= size
1312 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1313 } else {
1314 encoded, err := proto.Marshal(m.EventService)
1315 if err != nil {
1316 return 0, err
1317 }
1318 i -= len(encoded)
1319 copy(dAtA[i:], encoded)
1320 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1321 }
1322 i--
1323 dAtA[i] = 0x12
1324 }
1325 if len(m.EventLogPath) > 0 {
1326 i -= len(m.EventLogPath)
1327 copy(dAtA[i:], m.EventLogPath)
1328 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EventLogPath)))
1329 i--
1330 dAtA[i] = 0xa
1331 }
1332 return len(dAtA) - i, nil
1333 }
1334
1335 func (m *ClusterManager) MarshalVTStrict() (dAtA []byte, err error) {
1336 if m == nil {
1337 return nil, nil
1338 }
1339 size := m.SizeVT()
1340 dAtA = make([]byte, size)
1341 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1342 if err != nil {
1343 return nil, err
1344 }
1345 return dAtA[:n], nil
1346 }
1347
1348 func (m *ClusterManager) MarshalToVTStrict(dAtA []byte) (int, error) {
1349 size := m.SizeVT()
1350 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1351 }
1352
1353 func (m *ClusterManager) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1354 if m == nil {
1355 return 0, nil
1356 }
1357 i := len(dAtA)
1358 _ = i
1359 var l int
1360 _ = l
1361 if m.unknownFields != nil {
1362 i -= len(m.unknownFields)
1363 copy(dAtA[i:], m.unknownFields)
1364 }
1365 if m.EnableDeferredClusterCreation {
1366 i--
1367 if m.EnableDeferredClusterCreation {
1368 dAtA[i] = 1
1369 } else {
1370 dAtA[i] = 0
1371 }
1372 i--
1373 dAtA[i] = 0x28
1374 }
1375 if m.LoadStatsConfig != nil {
1376 if vtmsg, ok := interface{}(m.LoadStatsConfig).(interface {
1377 MarshalToSizedBufferVTStrict([]byte) (int, error)
1378 }); ok {
1379 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1380 if err != nil {
1381 return 0, err
1382 }
1383 i -= size
1384 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1385 } else {
1386 encoded, err := proto.Marshal(m.LoadStatsConfig)
1387 if err != nil {
1388 return 0, err
1389 }
1390 i -= len(encoded)
1391 copy(dAtA[i:], encoded)
1392 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1393 }
1394 i--
1395 dAtA[i] = 0x22
1396 }
1397 if m.UpstreamBindConfig != nil {
1398 if vtmsg, ok := interface{}(m.UpstreamBindConfig).(interface {
1399 MarshalToSizedBufferVTStrict([]byte) (int, error)
1400 }); ok {
1401 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1402 if err != nil {
1403 return 0, err
1404 }
1405 i -= size
1406 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1407 } else {
1408 encoded, err := proto.Marshal(m.UpstreamBindConfig)
1409 if err != nil {
1410 return 0, err
1411 }
1412 i -= len(encoded)
1413 copy(dAtA[i:], encoded)
1414 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1415 }
1416 i--
1417 dAtA[i] = 0x1a
1418 }
1419 if m.OutlierDetection != nil {
1420 size, err := m.OutlierDetection.MarshalToSizedBufferVTStrict(dAtA[:i])
1421 if err != nil {
1422 return 0, err
1423 }
1424 i -= size
1425 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1426 i--
1427 dAtA[i] = 0x12
1428 }
1429 if len(m.LocalClusterName) > 0 {
1430 i -= len(m.LocalClusterName)
1431 copy(dAtA[i:], m.LocalClusterName)
1432 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LocalClusterName)))
1433 i--
1434 dAtA[i] = 0xa
1435 }
1436 return len(dAtA) - i, nil
1437 }
1438
1439 func (m *Watchdogs) MarshalVTStrict() (dAtA []byte, err error) {
1440 if m == nil {
1441 return nil, nil
1442 }
1443 size := m.SizeVT()
1444 dAtA = make([]byte, size)
1445 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1446 if err != nil {
1447 return nil, err
1448 }
1449 return dAtA[:n], nil
1450 }
1451
1452 func (m *Watchdogs) MarshalToVTStrict(dAtA []byte) (int, error) {
1453 size := m.SizeVT()
1454 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1455 }
1456
1457 func (m *Watchdogs) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1458 if m == nil {
1459 return 0, nil
1460 }
1461 i := len(dAtA)
1462 _ = i
1463 var l int
1464 _ = l
1465 if m.unknownFields != nil {
1466 i -= len(m.unknownFields)
1467 copy(dAtA[i:], m.unknownFields)
1468 }
1469 if m.WorkerWatchdog != nil {
1470 size, err := m.WorkerWatchdog.MarshalToSizedBufferVTStrict(dAtA[:i])
1471 if err != nil {
1472 return 0, err
1473 }
1474 i -= size
1475 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1476 i--
1477 dAtA[i] = 0x12
1478 }
1479 if m.MainThreadWatchdog != nil {
1480 size, err := m.MainThreadWatchdog.MarshalToSizedBufferVTStrict(dAtA[:i])
1481 if err != nil {
1482 return 0, err
1483 }
1484 i -= size
1485 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1486 i--
1487 dAtA[i] = 0xa
1488 }
1489 return len(dAtA) - i, nil
1490 }
1491
1492 func (m *Watchdog_WatchdogAction) MarshalVTStrict() (dAtA []byte, err error) {
1493 if m == nil {
1494 return nil, nil
1495 }
1496 size := m.SizeVT()
1497 dAtA = make([]byte, size)
1498 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1499 if err != nil {
1500 return nil, err
1501 }
1502 return dAtA[:n], nil
1503 }
1504
1505 func (m *Watchdog_WatchdogAction) MarshalToVTStrict(dAtA []byte) (int, error) {
1506 size := m.SizeVT()
1507 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1508 }
1509
1510 func (m *Watchdog_WatchdogAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1511 if m == nil {
1512 return 0, nil
1513 }
1514 i := len(dAtA)
1515 _ = i
1516 var l int
1517 _ = l
1518 if m.unknownFields != nil {
1519 i -= len(m.unknownFields)
1520 copy(dAtA[i:], m.unknownFields)
1521 }
1522 if m.Event != 0 {
1523 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Event))
1524 i--
1525 dAtA[i] = 0x10
1526 }
1527 if m.Config != nil {
1528 if vtmsg, ok := interface{}(m.Config).(interface {
1529 MarshalToSizedBufferVTStrict([]byte) (int, error)
1530 }); ok {
1531 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1532 if err != nil {
1533 return 0, err
1534 }
1535 i -= size
1536 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1537 } else {
1538 encoded, err := proto.Marshal(m.Config)
1539 if err != nil {
1540 return 0, err
1541 }
1542 i -= len(encoded)
1543 copy(dAtA[i:], encoded)
1544 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1545 }
1546 i--
1547 dAtA[i] = 0xa
1548 }
1549 return len(dAtA) - i, nil
1550 }
1551
1552 func (m *Watchdog) MarshalVTStrict() (dAtA []byte, err error) {
1553 if m == nil {
1554 return nil, nil
1555 }
1556 size := m.SizeVT()
1557 dAtA = make([]byte, size)
1558 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1559 if err != nil {
1560 return nil, err
1561 }
1562 return dAtA[:n], nil
1563 }
1564
1565 func (m *Watchdog) MarshalToVTStrict(dAtA []byte) (int, error) {
1566 size := m.SizeVT()
1567 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1568 }
1569
1570 func (m *Watchdog) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1571 if m == nil {
1572 return 0, nil
1573 }
1574 i := len(dAtA)
1575 _ = i
1576 var l int
1577 _ = l
1578 if m.unknownFields != nil {
1579 i -= len(m.unknownFields)
1580 copy(dAtA[i:], m.unknownFields)
1581 }
1582 if len(m.Actions) > 0 {
1583 for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
1584 size, err := m.Actions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1585 if err != nil {
1586 return 0, err
1587 }
1588 i -= size
1589 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1590 i--
1591 dAtA[i] = 0x3a
1592 }
1593 }
1594 if m.MaxKillTimeoutJitter != nil {
1595 size, err := (*durationpb.Duration)(m.MaxKillTimeoutJitter).MarshalToSizedBufferVTStrict(dAtA[:i])
1596 if err != nil {
1597 return 0, err
1598 }
1599 i -= size
1600 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1601 i--
1602 dAtA[i] = 0x32
1603 }
1604 if m.MultikillThreshold != nil {
1605 if vtmsg, ok := interface{}(m.MultikillThreshold).(interface {
1606 MarshalToSizedBufferVTStrict([]byte) (int, error)
1607 }); ok {
1608 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1609 if err != nil {
1610 return 0, err
1611 }
1612 i -= size
1613 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1614 } else {
1615 encoded, err := proto.Marshal(m.MultikillThreshold)
1616 if err != nil {
1617 return 0, err
1618 }
1619 i -= len(encoded)
1620 copy(dAtA[i:], encoded)
1621 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1622 }
1623 i--
1624 dAtA[i] = 0x2a
1625 }
1626 if m.MultikillTimeout != nil {
1627 size, err := (*durationpb.Duration)(m.MultikillTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
1628 if err != nil {
1629 return 0, err
1630 }
1631 i -= size
1632 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1633 i--
1634 dAtA[i] = 0x22
1635 }
1636 if m.KillTimeout != nil {
1637 size, err := (*durationpb.Duration)(m.KillTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
1638 if err != nil {
1639 return 0, err
1640 }
1641 i -= size
1642 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1643 i--
1644 dAtA[i] = 0x1a
1645 }
1646 if m.MegamissTimeout != nil {
1647 size, err := (*durationpb.Duration)(m.MegamissTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
1648 if err != nil {
1649 return 0, err
1650 }
1651 i -= size
1652 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1653 i--
1654 dAtA[i] = 0x12
1655 }
1656 if m.MissTimeout != nil {
1657 size, err := (*durationpb.Duration)(m.MissTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
1658 if err != nil {
1659 return 0, err
1660 }
1661 i -= size
1662 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1663 i--
1664 dAtA[i] = 0xa
1665 }
1666 return len(dAtA) - i, nil
1667 }
1668
1669 func (m *FatalAction) MarshalVTStrict() (dAtA []byte, err error) {
1670 if m == nil {
1671 return nil, nil
1672 }
1673 size := m.SizeVT()
1674 dAtA = make([]byte, size)
1675 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1676 if err != nil {
1677 return nil, err
1678 }
1679 return dAtA[:n], nil
1680 }
1681
1682 func (m *FatalAction) MarshalToVTStrict(dAtA []byte) (int, error) {
1683 size := m.SizeVT()
1684 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1685 }
1686
1687 func (m *FatalAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1688 if m == nil {
1689 return 0, nil
1690 }
1691 i := len(dAtA)
1692 _ = i
1693 var l int
1694 _ = l
1695 if m.unknownFields != nil {
1696 i -= len(m.unknownFields)
1697 copy(dAtA[i:], m.unknownFields)
1698 }
1699 if m.Config != nil {
1700 if vtmsg, ok := interface{}(m.Config).(interface {
1701 MarshalToSizedBufferVTStrict([]byte) (int, error)
1702 }); ok {
1703 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1704 if err != nil {
1705 return 0, err
1706 }
1707 i -= size
1708 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1709 } else {
1710 encoded, err := proto.Marshal(m.Config)
1711 if err != nil {
1712 return 0, err
1713 }
1714 i -= len(encoded)
1715 copy(dAtA[i:], encoded)
1716 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1717 }
1718 i--
1719 dAtA[i] = 0xa
1720 }
1721 return len(dAtA) - i, nil
1722 }
1723
1724 func (m *Runtime) MarshalVTStrict() (dAtA []byte, err error) {
1725 if m == nil {
1726 return nil, nil
1727 }
1728 size := m.SizeVT()
1729 dAtA = make([]byte, size)
1730 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1731 if err != nil {
1732 return nil, err
1733 }
1734 return dAtA[:n], nil
1735 }
1736
1737 func (m *Runtime) MarshalToVTStrict(dAtA []byte) (int, error) {
1738 size := m.SizeVT()
1739 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1740 }
1741
1742 func (m *Runtime) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1743 if m == nil {
1744 return 0, nil
1745 }
1746 i := len(dAtA)
1747 _ = i
1748 var l int
1749 _ = l
1750 if m.unknownFields != nil {
1751 i -= len(m.unknownFields)
1752 copy(dAtA[i:], m.unknownFields)
1753 }
1754 if m.Base != nil {
1755 size, err := (*structpb.Struct)(m.Base).MarshalToSizedBufferVTStrict(dAtA[:i])
1756 if err != nil {
1757 return 0, err
1758 }
1759 i -= size
1760 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1761 i--
1762 dAtA[i] = 0x22
1763 }
1764 if len(m.OverrideSubdirectory) > 0 {
1765 i -= len(m.OverrideSubdirectory)
1766 copy(dAtA[i:], m.OverrideSubdirectory)
1767 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OverrideSubdirectory)))
1768 i--
1769 dAtA[i] = 0x1a
1770 }
1771 if len(m.Subdirectory) > 0 {
1772 i -= len(m.Subdirectory)
1773 copy(dAtA[i:], m.Subdirectory)
1774 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Subdirectory)))
1775 i--
1776 dAtA[i] = 0x12
1777 }
1778 if len(m.SymlinkRoot) > 0 {
1779 i -= len(m.SymlinkRoot)
1780 copy(dAtA[i:], m.SymlinkRoot)
1781 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SymlinkRoot)))
1782 i--
1783 dAtA[i] = 0xa
1784 }
1785 return len(dAtA) - i, nil
1786 }
1787
1788 func (m *RuntimeLayer_DiskLayer) MarshalVTStrict() (dAtA []byte, err error) {
1789 if m == nil {
1790 return nil, nil
1791 }
1792 size := m.SizeVT()
1793 dAtA = make([]byte, size)
1794 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1795 if err != nil {
1796 return nil, err
1797 }
1798 return dAtA[:n], nil
1799 }
1800
1801 func (m *RuntimeLayer_DiskLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1802 size := m.SizeVT()
1803 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1804 }
1805
1806 func (m *RuntimeLayer_DiskLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1807 if m == nil {
1808 return 0, nil
1809 }
1810 i := len(dAtA)
1811 _ = i
1812 var l int
1813 _ = l
1814 if m.unknownFields != nil {
1815 i -= len(m.unknownFields)
1816 copy(dAtA[i:], m.unknownFields)
1817 }
1818 if len(m.Subdirectory) > 0 {
1819 i -= len(m.Subdirectory)
1820 copy(dAtA[i:], m.Subdirectory)
1821 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Subdirectory)))
1822 i--
1823 dAtA[i] = 0x1a
1824 }
1825 if m.AppendServiceCluster {
1826 i--
1827 if m.AppendServiceCluster {
1828 dAtA[i] = 1
1829 } else {
1830 dAtA[i] = 0
1831 }
1832 i--
1833 dAtA[i] = 0x10
1834 }
1835 if len(m.SymlinkRoot) > 0 {
1836 i -= len(m.SymlinkRoot)
1837 copy(dAtA[i:], m.SymlinkRoot)
1838 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SymlinkRoot)))
1839 i--
1840 dAtA[i] = 0xa
1841 }
1842 return len(dAtA) - i, nil
1843 }
1844
1845 func (m *RuntimeLayer_AdminLayer) MarshalVTStrict() (dAtA []byte, err error) {
1846 if m == nil {
1847 return nil, nil
1848 }
1849 size := m.SizeVT()
1850 dAtA = make([]byte, size)
1851 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1852 if err != nil {
1853 return nil, err
1854 }
1855 return dAtA[:n], nil
1856 }
1857
1858 func (m *RuntimeLayer_AdminLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1859 size := m.SizeVT()
1860 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1861 }
1862
1863 func (m *RuntimeLayer_AdminLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1864 if m == nil {
1865 return 0, nil
1866 }
1867 i := len(dAtA)
1868 _ = i
1869 var l int
1870 _ = l
1871 if m.unknownFields != nil {
1872 i -= len(m.unknownFields)
1873 copy(dAtA[i:], m.unknownFields)
1874 }
1875 return len(dAtA) - i, nil
1876 }
1877
1878 func (m *RuntimeLayer_RtdsLayer) MarshalVTStrict() (dAtA []byte, err error) {
1879 if m == nil {
1880 return nil, nil
1881 }
1882 size := m.SizeVT()
1883 dAtA = make([]byte, size)
1884 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1885 if err != nil {
1886 return nil, err
1887 }
1888 return dAtA[:n], nil
1889 }
1890
1891 func (m *RuntimeLayer_RtdsLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1892 size := m.SizeVT()
1893 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1894 }
1895
1896 func (m *RuntimeLayer_RtdsLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1897 if m == nil {
1898 return 0, nil
1899 }
1900 i := len(dAtA)
1901 _ = i
1902 var l int
1903 _ = l
1904 if m.unknownFields != nil {
1905 i -= len(m.unknownFields)
1906 copy(dAtA[i:], m.unknownFields)
1907 }
1908 if m.RtdsConfig != nil {
1909 if vtmsg, ok := interface{}(m.RtdsConfig).(interface {
1910 MarshalToSizedBufferVTStrict([]byte) (int, error)
1911 }); ok {
1912 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1913 if err != nil {
1914 return 0, err
1915 }
1916 i -= size
1917 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1918 } else {
1919 encoded, err := proto.Marshal(m.RtdsConfig)
1920 if err != nil {
1921 return 0, err
1922 }
1923 i -= len(encoded)
1924 copy(dAtA[i:], encoded)
1925 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1926 }
1927 i--
1928 dAtA[i] = 0x12
1929 }
1930 if len(m.Name) > 0 {
1931 i -= len(m.Name)
1932 copy(dAtA[i:], m.Name)
1933 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1934 i--
1935 dAtA[i] = 0xa
1936 }
1937 return len(dAtA) - i, nil
1938 }
1939
1940 func (m *RuntimeLayer) MarshalVTStrict() (dAtA []byte, err error) {
1941 if m == nil {
1942 return nil, nil
1943 }
1944 size := m.SizeVT()
1945 dAtA = make([]byte, size)
1946 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1947 if err != nil {
1948 return nil, err
1949 }
1950 return dAtA[:n], nil
1951 }
1952
1953 func (m *RuntimeLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
1954 size := m.SizeVT()
1955 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1956 }
1957
1958 func (m *RuntimeLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1959 if m == nil {
1960 return 0, nil
1961 }
1962 i := len(dAtA)
1963 _ = i
1964 var l int
1965 _ = l
1966 if m.unknownFields != nil {
1967 i -= len(m.unknownFields)
1968 copy(dAtA[i:], m.unknownFields)
1969 }
1970 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_RtdsLayer_); ok {
1971 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1972 if err != nil {
1973 return 0, err
1974 }
1975 i -= size
1976 }
1977 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_AdminLayer_); ok {
1978 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1979 if err != nil {
1980 return 0, err
1981 }
1982 i -= size
1983 }
1984 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_DiskLayer_); ok {
1985 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1986 if err != nil {
1987 return 0, err
1988 }
1989 i -= size
1990 }
1991 if msg, ok := m.LayerSpecifier.(*RuntimeLayer_StaticLayer); ok {
1992 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1993 if err != nil {
1994 return 0, err
1995 }
1996 i -= size
1997 }
1998 if len(m.Name) > 0 {
1999 i -= len(m.Name)
2000 copy(dAtA[i:], m.Name)
2001 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
2002 i--
2003 dAtA[i] = 0xa
2004 }
2005 return len(dAtA) - i, nil
2006 }
2007
2008 func (m *RuntimeLayer_StaticLayer) MarshalToVTStrict(dAtA []byte) (int, error) {
2009 size := m.SizeVT()
2010 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2011 }
2012
2013 func (m *RuntimeLayer_StaticLayer) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2014 i := len(dAtA)
2015 if m.StaticLayer != nil {
2016 size, err := (*structpb.Struct)(m.StaticLayer).MarshalToSizedBufferVTStrict(dAtA[:i])
2017 if err != nil {
2018 return 0, err
2019 }
2020 i -= size
2021 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2022 i--
2023 dAtA[i] = 0x12
2024 } else {
2025 i = protohelpers.EncodeVarint(dAtA, i, 0)
2026 i--
2027 dAtA[i] = 0x12
2028 }
2029 return len(dAtA) - i, nil
2030 }
2031 func (m *RuntimeLayer_DiskLayer_) MarshalToVTStrict(dAtA []byte) (int, error) {
2032 size := m.SizeVT()
2033 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2034 }
2035
2036 func (m *RuntimeLayer_DiskLayer_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2037 i := len(dAtA)
2038 if m.DiskLayer != nil {
2039 size, err := m.DiskLayer.MarshalToSizedBufferVTStrict(dAtA[:i])
2040 if err != nil {
2041 return 0, err
2042 }
2043 i -= size
2044 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2045 i--
2046 dAtA[i] = 0x1a
2047 } else {
2048 i = protohelpers.EncodeVarint(dAtA, i, 0)
2049 i--
2050 dAtA[i] = 0x1a
2051 }
2052 return len(dAtA) - i, nil
2053 }
2054 func (m *RuntimeLayer_AdminLayer_) MarshalToVTStrict(dAtA []byte) (int, error) {
2055 size := m.SizeVT()
2056 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2057 }
2058
2059 func (m *RuntimeLayer_AdminLayer_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2060 i := len(dAtA)
2061 if m.AdminLayer != nil {
2062 size, err := m.AdminLayer.MarshalToSizedBufferVTStrict(dAtA[:i])
2063 if err != nil {
2064 return 0, err
2065 }
2066 i -= size
2067 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2068 i--
2069 dAtA[i] = 0x22
2070 } else {
2071 i = protohelpers.EncodeVarint(dAtA, i, 0)
2072 i--
2073 dAtA[i] = 0x22
2074 }
2075 return len(dAtA) - i, nil
2076 }
2077 func (m *RuntimeLayer_RtdsLayer_) MarshalToVTStrict(dAtA []byte) (int, error) {
2078 size := m.SizeVT()
2079 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2080 }
2081
2082 func (m *RuntimeLayer_RtdsLayer_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2083 i := len(dAtA)
2084 if m.RtdsLayer != nil {
2085 size, err := m.RtdsLayer.MarshalToSizedBufferVTStrict(dAtA[:i])
2086 if err != nil {
2087 return 0, err
2088 }
2089 i -= size
2090 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2091 i--
2092 dAtA[i] = 0x2a
2093 } else {
2094 i = protohelpers.EncodeVarint(dAtA, i, 0)
2095 i--
2096 dAtA[i] = 0x2a
2097 }
2098 return len(dAtA) - i, nil
2099 }
2100 func (m *LayeredRuntime) MarshalVTStrict() (dAtA []byte, err error) {
2101 if m == nil {
2102 return nil, nil
2103 }
2104 size := m.SizeVT()
2105 dAtA = make([]byte, size)
2106 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2107 if err != nil {
2108 return nil, err
2109 }
2110 return dAtA[:n], nil
2111 }
2112
2113 func (m *LayeredRuntime) MarshalToVTStrict(dAtA []byte) (int, error) {
2114 size := m.SizeVT()
2115 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2116 }
2117
2118 func (m *LayeredRuntime) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2119 if m == nil {
2120 return 0, nil
2121 }
2122 i := len(dAtA)
2123 _ = i
2124 var l int
2125 _ = l
2126 if m.unknownFields != nil {
2127 i -= len(m.unknownFields)
2128 copy(dAtA[i:], m.unknownFields)
2129 }
2130 if len(m.Layers) > 0 {
2131 for iNdEx := len(m.Layers) - 1; iNdEx >= 0; iNdEx-- {
2132 size, err := m.Layers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
2133 if err != nil {
2134 return 0, err
2135 }
2136 i -= size
2137 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2138 i--
2139 dAtA[i] = 0xa
2140 }
2141 }
2142 return len(dAtA) - i, nil
2143 }
2144
2145 func (m *CustomInlineHeader) MarshalVTStrict() (dAtA []byte, err error) {
2146 if m == nil {
2147 return nil, nil
2148 }
2149 size := m.SizeVT()
2150 dAtA = make([]byte, size)
2151 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2152 if err != nil {
2153 return nil, err
2154 }
2155 return dAtA[:n], nil
2156 }
2157
2158 func (m *CustomInlineHeader) MarshalToVTStrict(dAtA []byte) (int, error) {
2159 size := m.SizeVT()
2160 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2161 }
2162
2163 func (m *CustomInlineHeader) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2164 if m == nil {
2165 return 0, nil
2166 }
2167 i := len(dAtA)
2168 _ = i
2169 var l int
2170 _ = l
2171 if m.unknownFields != nil {
2172 i -= len(m.unknownFields)
2173 copy(dAtA[i:], m.unknownFields)
2174 }
2175 if m.InlineHeaderType != 0 {
2176 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InlineHeaderType))
2177 i--
2178 dAtA[i] = 0x10
2179 }
2180 if len(m.InlineHeaderName) > 0 {
2181 i -= len(m.InlineHeaderName)
2182 copy(dAtA[i:], m.InlineHeaderName)
2183 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InlineHeaderName)))
2184 i--
2185 dAtA[i] = 0xa
2186 }
2187 return len(dAtA) - i, nil
2188 }
2189
2190 func (m *MemoryAllocatorManager) MarshalVTStrict() (dAtA []byte, err error) {
2191 if m == nil {
2192 return nil, nil
2193 }
2194 size := m.SizeVT()
2195 dAtA = make([]byte, size)
2196 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2197 if err != nil {
2198 return nil, err
2199 }
2200 return dAtA[:n], nil
2201 }
2202
2203 func (m *MemoryAllocatorManager) MarshalToVTStrict(dAtA []byte) (int, error) {
2204 size := m.SizeVT()
2205 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2206 }
2207
2208 func (m *MemoryAllocatorManager) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2209 if m == nil {
2210 return 0, nil
2211 }
2212 i := len(dAtA)
2213 _ = i
2214 var l int
2215 _ = l
2216 if m.unknownFields != nil {
2217 i -= len(m.unknownFields)
2218 copy(dAtA[i:], m.unknownFields)
2219 }
2220 if m.MemoryReleaseInterval != nil {
2221 size, err := (*durationpb.Duration)(m.MemoryReleaseInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
2222 if err != nil {
2223 return 0, err
2224 }
2225 i -= size
2226 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2227 i--
2228 dAtA[i] = 0x12
2229 }
2230 if m.BytesToRelease != 0 {
2231 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BytesToRelease))
2232 i--
2233 dAtA[i] = 0x8
2234 }
2235 return len(dAtA) - i, nil
2236 }
2237
2238 func (m *Bootstrap_StaticResources) SizeVT() (n int) {
2239 if m == nil {
2240 return 0
2241 }
2242 var l int
2243 _ = l
2244 if len(m.Listeners) > 0 {
2245 for _, e := range m.Listeners {
2246 if size, ok := interface{}(e).(interface {
2247 SizeVT() int
2248 }); ok {
2249 l = size.SizeVT()
2250 } else {
2251 l = proto.Size(e)
2252 }
2253 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2254 }
2255 }
2256 if len(m.Clusters) > 0 {
2257 for _, e := range m.Clusters {
2258 if size, ok := interface{}(e).(interface {
2259 SizeVT() int
2260 }); ok {
2261 l = size.SizeVT()
2262 } else {
2263 l = proto.Size(e)
2264 }
2265 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2266 }
2267 }
2268 if len(m.Secrets) > 0 {
2269 for _, e := range m.Secrets {
2270 if size, ok := interface{}(e).(interface {
2271 SizeVT() int
2272 }); ok {
2273 l = size.SizeVT()
2274 } else {
2275 l = proto.Size(e)
2276 }
2277 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2278 }
2279 }
2280 n += len(m.unknownFields)
2281 return n
2282 }
2283
2284 func (m *Bootstrap_DynamicResources) SizeVT() (n int) {
2285 if m == nil {
2286 return 0
2287 }
2288 var l int
2289 _ = l
2290 if m.LdsConfig != nil {
2291 if size, ok := interface{}(m.LdsConfig).(interface {
2292 SizeVT() int
2293 }); ok {
2294 l = size.SizeVT()
2295 } else {
2296 l = proto.Size(m.LdsConfig)
2297 }
2298 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2299 }
2300 if m.CdsConfig != nil {
2301 if size, ok := interface{}(m.CdsConfig).(interface {
2302 SizeVT() int
2303 }); ok {
2304 l = size.SizeVT()
2305 } else {
2306 l = proto.Size(m.CdsConfig)
2307 }
2308 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2309 }
2310 if m.AdsConfig != nil {
2311 if size, ok := interface{}(m.AdsConfig).(interface {
2312 SizeVT() int
2313 }); ok {
2314 l = size.SizeVT()
2315 } else {
2316 l = proto.Size(m.AdsConfig)
2317 }
2318 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2319 }
2320 l = len(m.LdsResourcesLocator)
2321 if l > 0 {
2322 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2323 }
2324 l = len(m.CdsResourcesLocator)
2325 if l > 0 {
2326 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2327 }
2328 n += len(m.unknownFields)
2329 return n
2330 }
2331
2332 func (m *Bootstrap_ApplicationLogConfig_LogFormat) SizeVT() (n int) {
2333 if m == nil {
2334 return 0
2335 }
2336 var l int
2337 _ = l
2338 if vtmsg, ok := m.LogFormat.(interface{ SizeVT() int }); ok {
2339 n += vtmsg.SizeVT()
2340 }
2341 n += len(m.unknownFields)
2342 return n
2343 }
2344
2345 func (m *Bootstrap_ApplicationLogConfig_LogFormat_JsonFormat) SizeVT() (n int) {
2346 if m == nil {
2347 return 0
2348 }
2349 var l int
2350 _ = l
2351 if m.JsonFormat != nil {
2352 l = (*structpb.Struct)(m.JsonFormat).SizeVT()
2353 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2354 } else {
2355 n += 2
2356 }
2357 return n
2358 }
2359 func (m *Bootstrap_ApplicationLogConfig_LogFormat_TextFormat) SizeVT() (n int) {
2360 if m == nil {
2361 return 0
2362 }
2363 var l int
2364 _ = l
2365 l = len(m.TextFormat)
2366 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2367 return n
2368 }
2369 func (m *Bootstrap_ApplicationLogConfig) SizeVT() (n int) {
2370 if m == nil {
2371 return 0
2372 }
2373 var l int
2374 _ = l
2375 if m.LogFormat != nil {
2376 l = m.LogFormat.SizeVT()
2377 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2378 }
2379 n += len(m.unknownFields)
2380 return n
2381 }
2382
2383 func (m *Bootstrap_DeferredStatOptions) SizeVT() (n int) {
2384 if m == nil {
2385 return 0
2386 }
2387 var l int
2388 _ = l
2389 if m.EnableDeferredCreationStats {
2390 n += 2
2391 }
2392 n += len(m.unknownFields)
2393 return n
2394 }
2395
2396 func (m *Bootstrap_GrpcAsyncClientManagerConfig) SizeVT() (n int) {
2397 if m == nil {
2398 return 0
2399 }
2400 var l int
2401 _ = l
2402 if m.MaxCachedEntryIdleDuration != nil {
2403 l = (*durationpb.Duration)(m.MaxCachedEntryIdleDuration).SizeVT()
2404 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2405 }
2406 n += len(m.unknownFields)
2407 return n
2408 }
2409
2410 func (m *Bootstrap) SizeVT() (n int) {
2411 if m == nil {
2412 return 0
2413 }
2414 var l int
2415 _ = l
2416 if m.Node != nil {
2417 if size, ok := interface{}(m.Node).(interface {
2418 SizeVT() int
2419 }); ok {
2420 l = size.SizeVT()
2421 } else {
2422 l = proto.Size(m.Node)
2423 }
2424 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2425 }
2426 if m.StaticResources != nil {
2427 l = m.StaticResources.SizeVT()
2428 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2429 }
2430 if m.DynamicResources != nil {
2431 l = m.DynamicResources.SizeVT()
2432 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2433 }
2434 if m.ClusterManager != nil {
2435 l = m.ClusterManager.SizeVT()
2436 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2437 }
2438 l = len(m.FlagsPath)
2439 if l > 0 {
2440 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2441 }
2442 if len(m.StatsSinks) > 0 {
2443 for _, e := range m.StatsSinks {
2444 if size, ok := interface{}(e).(interface {
2445 SizeVT() int
2446 }); ok {
2447 l = size.SizeVT()
2448 } else {
2449 l = proto.Size(e)
2450 }
2451 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2452 }
2453 }
2454 if m.StatsFlushInterval != nil {
2455 l = (*durationpb.Duration)(m.StatsFlushInterval).SizeVT()
2456 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2457 }
2458 if m.Watchdog != nil {
2459 l = m.Watchdog.SizeVT()
2460 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2461 }
2462 if m.Tracing != nil {
2463 if size, ok := interface{}(m.Tracing).(interface {
2464 SizeVT() int
2465 }); ok {
2466 l = size.SizeVT()
2467 } else {
2468 l = proto.Size(m.Tracing)
2469 }
2470 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2471 }
2472 if m.Admin != nil {
2473 l = m.Admin.SizeVT()
2474 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2475 }
2476 if m.StatsConfig != nil {
2477 if size, ok := interface{}(m.StatsConfig).(interface {
2478 SizeVT() int
2479 }); ok {
2480 l = size.SizeVT()
2481 } else {
2482 l = proto.Size(m.StatsConfig)
2483 }
2484 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2485 }
2486 if m.HdsConfig != nil {
2487 if size, ok := interface{}(m.HdsConfig).(interface {
2488 SizeVT() int
2489 }); ok {
2490 l = size.SizeVT()
2491 } else {
2492 l = proto.Size(m.HdsConfig)
2493 }
2494 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2495 }
2496 if m.OverloadManager != nil {
2497 if size, ok := interface{}(m.OverloadManager).(interface {
2498 SizeVT() int
2499 }); ok {
2500 l = size.SizeVT()
2501 } else {
2502 l = proto.Size(m.OverloadManager)
2503 }
2504 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2505 }
2506 if m.EnableDispatcherStats {
2507 n += 3
2508 }
2509 if m.LayeredRuntime != nil {
2510 l = m.LayeredRuntime.SizeVT()
2511 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2512 }
2513 l = len(m.HeaderPrefix)
2514 if l > 0 {
2515 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2516 }
2517 if m.StatsServerVersionOverride != nil {
2518 l = (*wrapperspb.UInt64Value)(m.StatsServerVersionOverride).SizeVT()
2519 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2520 }
2521 if m.UseTcpForDnsLookups {
2522 n += 3
2523 }
2524 if len(m.BootstrapExtensions) > 0 {
2525 for _, e := range m.BootstrapExtensions {
2526 if size, ok := interface{}(e).(interface {
2527 SizeVT() int
2528 }); ok {
2529 l = size.SizeVT()
2530 } else {
2531 l = proto.Size(e)
2532 }
2533 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2534 }
2535 }
2536 if len(m.ConfigSources) > 0 {
2537 for _, e := range m.ConfigSources {
2538 if size, ok := interface{}(e).(interface {
2539 SizeVT() int
2540 }); ok {
2541 l = size.SizeVT()
2542 } else {
2543 l = proto.Size(e)
2544 }
2545 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2546 }
2547 }
2548 if m.DefaultConfigSource != nil {
2549 if size, ok := interface{}(m.DefaultConfigSource).(interface {
2550 SizeVT() int
2551 }); ok {
2552 l = size.SizeVT()
2553 } else {
2554 l = proto.Size(m.DefaultConfigSource)
2555 }
2556 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2557 }
2558 l = len(m.DefaultSocketInterface)
2559 if l > 0 {
2560 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2561 }
2562 if len(m.CertificateProviderInstances) > 0 {
2563 for k, v := range m.CertificateProviderInstances {
2564 _ = k
2565 _ = v
2566 l = 0
2567 if v != nil {
2568 if size, ok := interface{}(v).(interface {
2569 SizeVT() int
2570 }); ok {
2571 l = size.SizeVT()
2572 } else {
2573 l = proto.Size(v)
2574 }
2575 }
2576 l += 1 + protohelpers.SizeOfVarint(uint64(l))
2577 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
2578 n += mapEntrySize + 2 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
2579 }
2580 }
2581 if len(m.NodeContextParams) > 0 {
2582 for _, s := range m.NodeContextParams {
2583 l = len(s)
2584 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2585 }
2586 }
2587 if m.Watchdogs != nil {
2588 l = m.Watchdogs.SizeVT()
2589 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2590 }
2591 if len(m.FatalActions) > 0 {
2592 for _, e := range m.FatalActions {
2593 l = e.SizeVT()
2594 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2595 }
2596 }
2597 if vtmsg, ok := m.StatsFlush.(interface{ SizeVT() int }); ok {
2598 n += vtmsg.SizeVT()
2599 }
2600 if m.DnsResolutionConfig != nil {
2601 if size, ok := interface{}(m.DnsResolutionConfig).(interface {
2602 SizeVT() int
2603 }); ok {
2604 l = size.SizeVT()
2605 } else {
2606 l = proto.Size(m.DnsResolutionConfig)
2607 }
2608 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2609 }
2610 if m.TypedDnsResolverConfig != nil {
2611 if size, ok := interface{}(m.TypedDnsResolverConfig).(interface {
2612 SizeVT() int
2613 }); ok {
2614 l = size.SizeVT()
2615 } else {
2616 l = proto.Size(m.TypedDnsResolverConfig)
2617 }
2618 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2619 }
2620 if len(m.InlineHeaders) > 0 {
2621 for _, e := range m.InlineHeaders {
2622 l = e.SizeVT()
2623 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2624 }
2625 }
2626 l = len(m.PerfTracingFilePath)
2627 if l > 0 {
2628 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2629 }
2630 if m.DefaultRegexEngine != nil {
2631 if size, ok := interface{}(m.DefaultRegexEngine).(interface {
2632 SizeVT() int
2633 }); ok {
2634 l = size.SizeVT()
2635 } else {
2636 l = proto.Size(m.DefaultRegexEngine)
2637 }
2638 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2639 }
2640 if m.XdsDelegateExtension != nil {
2641 if size, ok := interface{}(m.XdsDelegateExtension).(interface {
2642 SizeVT() int
2643 }); ok {
2644 l = size.SizeVT()
2645 } else {
2646 l = proto.Size(m.XdsDelegateExtension)
2647 }
2648 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2649 }
2650 if m.XdsConfigTrackerExtension != nil {
2651 if size, ok := interface{}(m.XdsConfigTrackerExtension).(interface {
2652 SizeVT() int
2653 }); ok {
2654 l = size.SizeVT()
2655 } else {
2656 l = proto.Size(m.XdsConfigTrackerExtension)
2657 }
2658 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2659 }
2660 if m.ListenerManager != nil {
2661 if size, ok := interface{}(m.ListenerManager).(interface {
2662 SizeVT() int
2663 }); ok {
2664 l = size.SizeVT()
2665 } else {
2666 l = proto.Size(m.ListenerManager)
2667 }
2668 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2669 }
2670 if m.ApplicationLogConfig != nil {
2671 l = m.ApplicationLogConfig.SizeVT()
2672 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2673 }
2674 if m.DeferredStatOptions != nil {
2675 l = m.DeferredStatOptions.SizeVT()
2676 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2677 }
2678 if m.GrpcAsyncClientManagerConfig != nil {
2679 l = m.GrpcAsyncClientManagerConfig.SizeVT()
2680 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2681 }
2682 if m.MemoryAllocatorManager != nil {
2683 l = m.MemoryAllocatorManager.SizeVT()
2684 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
2685 }
2686 n += len(m.unknownFields)
2687 return n
2688 }
2689
2690 func (m *Bootstrap_StatsFlushOnAdmin) SizeVT() (n int) {
2691 if m == nil {
2692 return 0
2693 }
2694 var l int
2695 _ = l
2696 n += 3
2697 return n
2698 }
2699 func (m *Admin) SizeVT() (n int) {
2700 if m == nil {
2701 return 0
2702 }
2703 var l int
2704 _ = l
2705 l = len(m.AccessLogPath)
2706 if l > 0 {
2707 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2708 }
2709 l = len(m.ProfilePath)
2710 if l > 0 {
2711 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2712 }
2713 if m.Address != nil {
2714 if size, ok := interface{}(m.Address).(interface {
2715 SizeVT() int
2716 }); ok {
2717 l = size.SizeVT()
2718 } else {
2719 l = proto.Size(m.Address)
2720 }
2721 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2722 }
2723 if len(m.SocketOptions) > 0 {
2724 for _, e := range m.SocketOptions {
2725 if size, ok := interface{}(e).(interface {
2726 SizeVT() int
2727 }); ok {
2728 l = size.SizeVT()
2729 } else {
2730 l = proto.Size(e)
2731 }
2732 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2733 }
2734 }
2735 if len(m.AccessLog) > 0 {
2736 for _, e := range m.AccessLog {
2737 if size, ok := interface{}(e).(interface {
2738 SizeVT() int
2739 }); ok {
2740 l = size.SizeVT()
2741 } else {
2742 l = proto.Size(e)
2743 }
2744 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2745 }
2746 }
2747 if m.IgnoreGlobalConnLimit {
2748 n += 2
2749 }
2750 n += len(m.unknownFields)
2751 return n
2752 }
2753
2754 func (m *ClusterManager_OutlierDetection) SizeVT() (n int) {
2755 if m == nil {
2756 return 0
2757 }
2758 var l int
2759 _ = l
2760 l = len(m.EventLogPath)
2761 if l > 0 {
2762 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2763 }
2764 if m.EventService != nil {
2765 if size, ok := interface{}(m.EventService).(interface {
2766 SizeVT() int
2767 }); ok {
2768 l = size.SizeVT()
2769 } else {
2770 l = proto.Size(m.EventService)
2771 }
2772 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2773 }
2774 n += len(m.unknownFields)
2775 return n
2776 }
2777
2778 func (m *ClusterManager) SizeVT() (n int) {
2779 if m == nil {
2780 return 0
2781 }
2782 var l int
2783 _ = l
2784 l = len(m.LocalClusterName)
2785 if l > 0 {
2786 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2787 }
2788 if m.OutlierDetection != nil {
2789 l = m.OutlierDetection.SizeVT()
2790 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2791 }
2792 if m.UpstreamBindConfig != nil {
2793 if size, ok := interface{}(m.UpstreamBindConfig).(interface {
2794 SizeVT() int
2795 }); ok {
2796 l = size.SizeVT()
2797 } else {
2798 l = proto.Size(m.UpstreamBindConfig)
2799 }
2800 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2801 }
2802 if m.LoadStatsConfig != nil {
2803 if size, ok := interface{}(m.LoadStatsConfig).(interface {
2804 SizeVT() int
2805 }); ok {
2806 l = size.SizeVT()
2807 } else {
2808 l = proto.Size(m.LoadStatsConfig)
2809 }
2810 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2811 }
2812 if m.EnableDeferredClusterCreation {
2813 n += 2
2814 }
2815 n += len(m.unknownFields)
2816 return n
2817 }
2818
2819 func (m *Watchdogs) SizeVT() (n int) {
2820 if m == nil {
2821 return 0
2822 }
2823 var l int
2824 _ = l
2825 if m.MainThreadWatchdog != nil {
2826 l = m.MainThreadWatchdog.SizeVT()
2827 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2828 }
2829 if m.WorkerWatchdog != nil {
2830 l = m.WorkerWatchdog.SizeVT()
2831 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2832 }
2833 n += len(m.unknownFields)
2834 return n
2835 }
2836
2837 func (m *Watchdog_WatchdogAction) SizeVT() (n int) {
2838 if m == nil {
2839 return 0
2840 }
2841 var l int
2842 _ = l
2843 if m.Config != nil {
2844 if size, ok := interface{}(m.Config).(interface {
2845 SizeVT() int
2846 }); ok {
2847 l = size.SizeVT()
2848 } else {
2849 l = proto.Size(m.Config)
2850 }
2851 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2852 }
2853 if m.Event != 0 {
2854 n += 1 + protohelpers.SizeOfVarint(uint64(m.Event))
2855 }
2856 n += len(m.unknownFields)
2857 return n
2858 }
2859
2860 func (m *Watchdog) SizeVT() (n int) {
2861 if m == nil {
2862 return 0
2863 }
2864 var l int
2865 _ = l
2866 if m.MissTimeout != nil {
2867 l = (*durationpb.Duration)(m.MissTimeout).SizeVT()
2868 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2869 }
2870 if m.MegamissTimeout != nil {
2871 l = (*durationpb.Duration)(m.MegamissTimeout).SizeVT()
2872 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2873 }
2874 if m.KillTimeout != nil {
2875 l = (*durationpb.Duration)(m.KillTimeout).SizeVT()
2876 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2877 }
2878 if m.MultikillTimeout != nil {
2879 l = (*durationpb.Duration)(m.MultikillTimeout).SizeVT()
2880 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2881 }
2882 if m.MultikillThreshold != nil {
2883 if size, ok := interface{}(m.MultikillThreshold).(interface {
2884 SizeVT() int
2885 }); ok {
2886 l = size.SizeVT()
2887 } else {
2888 l = proto.Size(m.MultikillThreshold)
2889 }
2890 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2891 }
2892 if m.MaxKillTimeoutJitter != nil {
2893 l = (*durationpb.Duration)(m.MaxKillTimeoutJitter).SizeVT()
2894 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2895 }
2896 if len(m.Actions) > 0 {
2897 for _, e := range m.Actions {
2898 l = e.SizeVT()
2899 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2900 }
2901 }
2902 n += len(m.unknownFields)
2903 return n
2904 }
2905
2906 func (m *FatalAction) SizeVT() (n int) {
2907 if m == nil {
2908 return 0
2909 }
2910 var l int
2911 _ = l
2912 if m.Config != nil {
2913 if size, ok := interface{}(m.Config).(interface {
2914 SizeVT() int
2915 }); ok {
2916 l = size.SizeVT()
2917 } else {
2918 l = proto.Size(m.Config)
2919 }
2920 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2921 }
2922 n += len(m.unknownFields)
2923 return n
2924 }
2925
2926 func (m *Runtime) SizeVT() (n int) {
2927 if m == nil {
2928 return 0
2929 }
2930 var l int
2931 _ = l
2932 l = len(m.SymlinkRoot)
2933 if l > 0 {
2934 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2935 }
2936 l = len(m.Subdirectory)
2937 if l > 0 {
2938 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2939 }
2940 l = len(m.OverrideSubdirectory)
2941 if l > 0 {
2942 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2943 }
2944 if m.Base != nil {
2945 l = (*structpb.Struct)(m.Base).SizeVT()
2946 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2947 }
2948 n += len(m.unknownFields)
2949 return n
2950 }
2951
2952 func (m *RuntimeLayer_DiskLayer) SizeVT() (n int) {
2953 if m == nil {
2954 return 0
2955 }
2956 var l int
2957 _ = l
2958 l = len(m.SymlinkRoot)
2959 if l > 0 {
2960 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2961 }
2962 if m.AppendServiceCluster {
2963 n += 2
2964 }
2965 l = len(m.Subdirectory)
2966 if l > 0 {
2967 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2968 }
2969 n += len(m.unknownFields)
2970 return n
2971 }
2972
2973 func (m *RuntimeLayer_AdminLayer) SizeVT() (n int) {
2974 if m == nil {
2975 return 0
2976 }
2977 var l int
2978 _ = l
2979 n += len(m.unknownFields)
2980 return n
2981 }
2982
2983 func (m *RuntimeLayer_RtdsLayer) SizeVT() (n int) {
2984 if m == nil {
2985 return 0
2986 }
2987 var l int
2988 _ = l
2989 l = len(m.Name)
2990 if l > 0 {
2991 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2992 }
2993 if m.RtdsConfig != nil {
2994 if size, ok := interface{}(m.RtdsConfig).(interface {
2995 SizeVT() int
2996 }); ok {
2997 l = size.SizeVT()
2998 } else {
2999 l = proto.Size(m.RtdsConfig)
3000 }
3001 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3002 }
3003 n += len(m.unknownFields)
3004 return n
3005 }
3006
3007 func (m *RuntimeLayer) SizeVT() (n int) {
3008 if m == nil {
3009 return 0
3010 }
3011 var l int
3012 _ = l
3013 l = len(m.Name)
3014 if l > 0 {
3015 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3016 }
3017 if vtmsg, ok := m.LayerSpecifier.(interface{ SizeVT() int }); ok {
3018 n += vtmsg.SizeVT()
3019 }
3020 n += len(m.unknownFields)
3021 return n
3022 }
3023
3024 func (m *RuntimeLayer_StaticLayer) SizeVT() (n int) {
3025 if m == nil {
3026 return 0
3027 }
3028 var l int
3029 _ = l
3030 if m.StaticLayer != nil {
3031 l = (*structpb.Struct)(m.StaticLayer).SizeVT()
3032 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3033 } else {
3034 n += 2
3035 }
3036 return n
3037 }
3038 func (m *RuntimeLayer_DiskLayer_) SizeVT() (n int) {
3039 if m == nil {
3040 return 0
3041 }
3042 var l int
3043 _ = l
3044 if m.DiskLayer != nil {
3045 l = m.DiskLayer.SizeVT()
3046 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3047 } else {
3048 n += 2
3049 }
3050 return n
3051 }
3052 func (m *RuntimeLayer_AdminLayer_) SizeVT() (n int) {
3053 if m == nil {
3054 return 0
3055 }
3056 var l int
3057 _ = l
3058 if m.AdminLayer != nil {
3059 l = m.AdminLayer.SizeVT()
3060 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3061 } else {
3062 n += 2
3063 }
3064 return n
3065 }
3066 func (m *RuntimeLayer_RtdsLayer_) SizeVT() (n int) {
3067 if m == nil {
3068 return 0
3069 }
3070 var l int
3071 _ = l
3072 if m.RtdsLayer != nil {
3073 l = m.RtdsLayer.SizeVT()
3074 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3075 } else {
3076 n += 2
3077 }
3078 return n
3079 }
3080 func (m *LayeredRuntime) SizeVT() (n int) {
3081 if m == nil {
3082 return 0
3083 }
3084 var l int
3085 _ = l
3086 if len(m.Layers) > 0 {
3087 for _, e := range m.Layers {
3088 l = e.SizeVT()
3089 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3090 }
3091 }
3092 n += len(m.unknownFields)
3093 return n
3094 }
3095
3096 func (m *CustomInlineHeader) SizeVT() (n int) {
3097 if m == nil {
3098 return 0
3099 }
3100 var l int
3101 _ = l
3102 l = len(m.InlineHeaderName)
3103 if l > 0 {
3104 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3105 }
3106 if m.InlineHeaderType != 0 {
3107 n += 1 + protohelpers.SizeOfVarint(uint64(m.InlineHeaderType))
3108 }
3109 n += len(m.unknownFields)
3110 return n
3111 }
3112
3113 func (m *MemoryAllocatorManager) SizeVT() (n int) {
3114 if m == nil {
3115 return 0
3116 }
3117 var l int
3118 _ = l
3119 if m.BytesToRelease != 0 {
3120 n += 1 + protohelpers.SizeOfVarint(uint64(m.BytesToRelease))
3121 }
3122 if m.MemoryReleaseInterval != nil {
3123 l = (*durationpb.Duration)(m.MemoryReleaseInterval).SizeVT()
3124 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
3125 }
3126 n += len(m.unknownFields)
3127 return n
3128 }