Debian Codegraph @

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