Debian Codegraph @

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