Debian Codegraph @

envoy/config/core/v3/health_check_vtproto.pb.go

raw
1 //go:build vtprotobuf
2 // +build vtprotobuf
3
4 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
5 // source: envoy/config/core/v3/health_check.proto
6
7 package corev3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 anypb "github.com/planetscale/vtprotobuf/types/known/anypb"
12 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
13 structpb "github.com/planetscale/vtprotobuf/types/known/structpb"
14 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
15 proto "google.golang.org/protobuf/proto"
16 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
17 )
18
19 const (
20 // Verify that this generated code is sufficiently up-to-date.
21 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
22 // Verify that runtime/protoimpl is sufficiently up-to-date.
23 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
24 )
25
26 func (m *HealthStatusSet) MarshalVTStrict() (dAtA []byte, err error) {
27 if m == nil {
28 return nil, nil
29 }
30 size := m.SizeVT()
31 dAtA = make([]byte, size)
32 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
33 if err != nil {
34 return nil, err
35 }
36 return dAtA[:n], nil
37 }
38
39 func (m *HealthStatusSet) MarshalToVTStrict(dAtA []byte) (int, error) {
40 size := m.SizeVT()
41 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
42 }
43
44 func (m *HealthStatusSet) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
45 if m == nil {
46 return 0, nil
47 }
48 i := len(dAtA)
49 _ = i
50 var l int
51 _ = l
52 if m.unknownFields != nil {
53 i -= len(m.unknownFields)
54 copy(dAtA[i:], m.unknownFields)
55 }
56 if len(m.Statuses) > 0 {
57 var pksize2 int
58 for _, num := range m.Statuses {
59 pksize2 += protohelpers.SizeOfVarint(uint64(num))
60 }
61 i -= pksize2
62 j1 := i
63 for _, num1 := range m.Statuses {
64 num := uint64(num1)
65 for num >= 1<<7 {
66 dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
67 num >>= 7
68 j1++
69 }
70 dAtA[j1] = uint8(num)
71 j1++
72 }
73 i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))
74 i--
75 dAtA[i] = 0xa
76 }
77 return len(dAtA) - i, nil
78 }
79
80 func (m *HealthCheck_Payload) MarshalVTStrict() (dAtA []byte, err error) {
81 if m == nil {
82 return nil, nil
83 }
84 size := m.SizeVT()
85 dAtA = make([]byte, size)
86 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
87 if err != nil {
88 return nil, err
89 }
90 return dAtA[:n], nil
91 }
92
93 func (m *HealthCheck_Payload) MarshalToVTStrict(dAtA []byte) (int, error) {
94 size := m.SizeVT()
95 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
96 }
97
98 func (m *HealthCheck_Payload) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
99 if m == nil {
100 return 0, nil
101 }
102 i := len(dAtA)
103 _ = i
104 var l int
105 _ = l
106 if m.unknownFields != nil {
107 i -= len(m.unknownFields)
108 copy(dAtA[i:], m.unknownFields)
109 }
110 if msg, ok := m.Payload.(*HealthCheck_Payload_Binary); ok {
111 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
112 if err != nil {
113 return 0, err
114 }
115 i -= size
116 }
117 if msg, ok := m.Payload.(*HealthCheck_Payload_Text); ok {
118 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
119 if err != nil {
120 return 0, err
121 }
122 i -= size
123 }
124 return len(dAtA) - i, nil
125 }
126
127 func (m *HealthCheck_Payload_Text) MarshalToVTStrict(dAtA []byte) (int, error) {
128 size := m.SizeVT()
129 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
130 }
131
132 func (m *HealthCheck_Payload_Text) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
133 i := len(dAtA)
134 i -= len(m.Text)
135 copy(dAtA[i:], m.Text)
136 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Text)))
137 i--
138 dAtA[i] = 0xa
139 return len(dAtA) - i, nil
140 }
141 func (m *HealthCheck_Payload_Binary) MarshalToVTStrict(dAtA []byte) (int, error) {
142 size := m.SizeVT()
143 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
144 }
145
146 func (m *HealthCheck_Payload_Binary) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
147 i := len(dAtA)
148 i -= len(m.Binary)
149 copy(dAtA[i:], m.Binary)
150 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Binary)))
151 i--
152 dAtA[i] = 0x12
153 return len(dAtA) - i, nil
154 }
155 func (m *HealthCheck_HttpHealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
156 if m == nil {
157 return nil, nil
158 }
159 size := m.SizeVT()
160 dAtA = make([]byte, size)
161 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
162 if err != nil {
163 return nil, err
164 }
165 return dAtA[:n], nil
166 }
167
168 func (m *HealthCheck_HttpHealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
169 size := m.SizeVT()
170 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
171 }
172
173 func (m *HealthCheck_HttpHealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
174 if m == nil {
175 return 0, nil
176 }
177 i := len(dAtA)
178 _ = i
179 var l int
180 _ = l
181 if m.unknownFields != nil {
182 i -= len(m.unknownFields)
183 copy(dAtA[i:], m.unknownFields)
184 }
185 if m.ResponseBufferSize != nil {
186 size, err := (*wrapperspb.UInt64Value)(m.ResponseBufferSize).MarshalToSizedBufferVTStrict(dAtA[:i])
187 if err != nil {
188 return 0, err
189 }
190 i -= size
191 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
192 i--
193 dAtA[i] = 0x72
194 }
195 if m.Method != 0 {
196 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Method))
197 i--
198 dAtA[i] = 0x68
199 }
200 if len(m.RetriableStatuses) > 0 {
201 for iNdEx := len(m.RetriableStatuses) - 1; iNdEx >= 0; iNdEx-- {
202 if vtmsg, ok := interface{}(m.RetriableStatuses[iNdEx]).(interface {
203 MarshalToSizedBufferVTStrict([]byte) (int, error)
204 }); ok {
205 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
206 if err != nil {
207 return 0, err
208 }
209 i -= size
210 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
211 } else {
212 encoded, err := proto.Marshal(m.RetriableStatuses[iNdEx])
213 if err != nil {
214 return 0, err
215 }
216 i -= len(encoded)
217 copy(dAtA[i:], encoded)
218 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
219 }
220 i--
221 dAtA[i] = 0x62
222 }
223 }
224 if m.ServiceNameMatcher != nil {
225 if vtmsg, ok := interface{}(m.ServiceNameMatcher).(interface {
226 MarshalToSizedBufferVTStrict([]byte) (int, error)
227 }); ok {
228 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
229 if err != nil {
230 return 0, err
231 }
232 i -= size
233 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
234 } else {
235 encoded, err := proto.Marshal(m.ServiceNameMatcher)
236 if err != nil {
237 return 0, err
238 }
239 i -= len(encoded)
240 copy(dAtA[i:], encoded)
241 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
242 }
243 i--
244 dAtA[i] = 0x5a
245 }
246 if m.CodecClientType != 0 {
247 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CodecClientType))
248 i--
249 dAtA[i] = 0x50
250 }
251 if len(m.ExpectedStatuses) > 0 {
252 for iNdEx := len(m.ExpectedStatuses) - 1; iNdEx >= 0; iNdEx-- {
253 if vtmsg, ok := interface{}(m.ExpectedStatuses[iNdEx]).(interface {
254 MarshalToSizedBufferVTStrict([]byte) (int, error)
255 }); ok {
256 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
257 if err != nil {
258 return 0, err
259 }
260 i -= size
261 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
262 } else {
263 encoded, err := proto.Marshal(m.ExpectedStatuses[iNdEx])
264 if err != nil {
265 return 0, err
266 }
267 i -= len(encoded)
268 copy(dAtA[i:], encoded)
269 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
270 }
271 i--
272 dAtA[i] = 0x4a
273 }
274 }
275 if len(m.RequestHeadersToRemove) > 0 {
276 for iNdEx := len(m.RequestHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
277 i -= len(m.RequestHeadersToRemove[iNdEx])
278 copy(dAtA[i:], m.RequestHeadersToRemove[iNdEx])
279 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RequestHeadersToRemove[iNdEx])))
280 i--
281 dAtA[i] = 0x42
282 }
283 }
284 if len(m.RequestHeadersToAdd) > 0 {
285 for iNdEx := len(m.RequestHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
286 size, err := m.RequestHeadersToAdd[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
287 if err != nil {
288 return 0, err
289 }
290 i -= size
291 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
292 i--
293 dAtA[i] = 0x32
294 }
295 }
296 if len(m.Receive) > 0 {
297 for iNdEx := len(m.Receive) - 1; iNdEx >= 0; iNdEx-- {
298 size, err := m.Receive[iNdEx].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] = 0x22
306 }
307 }
308 if m.Send != nil {
309 size, err := m.Send.MarshalToSizedBufferVTStrict(dAtA[:i])
310 if err != nil {
311 return 0, err
312 }
313 i -= size
314 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
315 i--
316 dAtA[i] = 0x1a
317 }
318 if len(m.Path) > 0 {
319 i -= len(m.Path)
320 copy(dAtA[i:], m.Path)
321 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
322 i--
323 dAtA[i] = 0x12
324 }
325 if len(m.Host) > 0 {
326 i -= len(m.Host)
327 copy(dAtA[i:], m.Host)
328 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Host)))
329 i--
330 dAtA[i] = 0xa
331 }
332 return len(dAtA) - i, nil
333 }
334
335 func (m *HealthCheck_TcpHealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
336 if m == nil {
337 return nil, nil
338 }
339 size := m.SizeVT()
340 dAtA = make([]byte, size)
341 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
342 if err != nil {
343 return nil, err
344 }
345 return dAtA[:n], nil
346 }
347
348 func (m *HealthCheck_TcpHealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
349 size := m.SizeVT()
350 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
351 }
352
353 func (m *HealthCheck_TcpHealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
354 if m == nil {
355 return 0, nil
356 }
357 i := len(dAtA)
358 _ = i
359 var l int
360 _ = l
361 if m.unknownFields != nil {
362 i -= len(m.unknownFields)
363 copy(dAtA[i:], m.unknownFields)
364 }
365 if m.ProxyProtocolConfig != nil {
366 size, err := m.ProxyProtocolConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
367 if err != nil {
368 return 0, err
369 }
370 i -= size
371 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
372 i--
373 dAtA[i] = 0x1a
374 }
375 if len(m.Receive) > 0 {
376 for iNdEx := len(m.Receive) - 1; iNdEx >= 0; iNdEx-- {
377 size, err := m.Receive[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
378 if err != nil {
379 return 0, err
380 }
381 i -= size
382 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
383 i--
384 dAtA[i] = 0x12
385 }
386 }
387 if m.Send != nil {
388 size, err := m.Send.MarshalToSizedBufferVTStrict(dAtA[:i])
389 if err != nil {
390 return 0, err
391 }
392 i -= size
393 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
394 i--
395 dAtA[i] = 0xa
396 }
397 return len(dAtA) - i, nil
398 }
399
400 func (m *HealthCheck_RedisHealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
401 if m == nil {
402 return nil, nil
403 }
404 size := m.SizeVT()
405 dAtA = make([]byte, size)
406 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
407 if err != nil {
408 return nil, err
409 }
410 return dAtA[:n], nil
411 }
412
413 func (m *HealthCheck_RedisHealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
414 size := m.SizeVT()
415 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
416 }
417
418 func (m *HealthCheck_RedisHealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
419 if m == nil {
420 return 0, nil
421 }
422 i := len(dAtA)
423 _ = i
424 var l int
425 _ = l
426 if m.unknownFields != nil {
427 i -= len(m.unknownFields)
428 copy(dAtA[i:], m.unknownFields)
429 }
430 if len(m.Key) > 0 {
431 i -= len(m.Key)
432 copy(dAtA[i:], m.Key)
433 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
434 i--
435 dAtA[i] = 0xa
436 }
437 return len(dAtA) - i, nil
438 }
439
440 func (m *HealthCheck_GrpcHealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
441 if m == nil {
442 return nil, nil
443 }
444 size := m.SizeVT()
445 dAtA = make([]byte, size)
446 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
447 if err != nil {
448 return nil, err
449 }
450 return dAtA[:n], nil
451 }
452
453 func (m *HealthCheck_GrpcHealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
454 size := m.SizeVT()
455 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
456 }
457
458 func (m *HealthCheck_GrpcHealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
459 if m == nil {
460 return 0, nil
461 }
462 i := len(dAtA)
463 _ = i
464 var l int
465 _ = l
466 if m.unknownFields != nil {
467 i -= len(m.unknownFields)
468 copy(dAtA[i:], m.unknownFields)
469 }
470 if len(m.InitialMetadata) > 0 {
471 for iNdEx := len(m.InitialMetadata) - 1; iNdEx >= 0; iNdEx-- {
472 size, err := m.InitialMetadata[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
473 if err != nil {
474 return 0, err
475 }
476 i -= size
477 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
478 i--
479 dAtA[i] = 0x1a
480 }
481 }
482 if len(m.Authority) > 0 {
483 i -= len(m.Authority)
484 copy(dAtA[i:], m.Authority)
485 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Authority)))
486 i--
487 dAtA[i] = 0x12
488 }
489 if len(m.ServiceName) > 0 {
490 i -= len(m.ServiceName)
491 copy(dAtA[i:], m.ServiceName)
492 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ServiceName)))
493 i--
494 dAtA[i] = 0xa
495 }
496 return len(dAtA) - i, nil
497 }
498
499 func (m *HealthCheck_CustomHealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
500 if m == nil {
501 return nil, nil
502 }
503 size := m.SizeVT()
504 dAtA = make([]byte, size)
505 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
506 if err != nil {
507 return nil, err
508 }
509 return dAtA[:n], nil
510 }
511
512 func (m *HealthCheck_CustomHealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
513 size := m.SizeVT()
514 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
515 }
516
517 func (m *HealthCheck_CustomHealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
518 if m == nil {
519 return 0, nil
520 }
521 i := len(dAtA)
522 _ = i
523 var l int
524 _ = l
525 if m.unknownFields != nil {
526 i -= len(m.unknownFields)
527 copy(dAtA[i:], m.unknownFields)
528 }
529 if msg, ok := m.ConfigType.(*HealthCheck_CustomHealthCheck_TypedConfig); ok {
530 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
531 if err != nil {
532 return 0, err
533 }
534 i -= size
535 }
536 if len(m.Name) > 0 {
537 i -= len(m.Name)
538 copy(dAtA[i:], m.Name)
539 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
540 i--
541 dAtA[i] = 0xa
542 }
543 return len(dAtA) - i, nil
544 }
545
546 func (m *HealthCheck_CustomHealthCheck_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
547 size := m.SizeVT()
548 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
549 }
550
551 func (m *HealthCheck_CustomHealthCheck_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
552 i := len(dAtA)
553 if m.TypedConfig != nil {
554 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
555 if err != nil {
556 return 0, err
557 }
558 i -= size
559 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
560 i--
561 dAtA[i] = 0x1a
562 } else {
563 i = protohelpers.EncodeVarint(dAtA, i, 0)
564 i--
565 dAtA[i] = 0x1a
566 }
567 return len(dAtA) - i, nil
568 }
569 func (m *HealthCheck_TlsOptions) MarshalVTStrict() (dAtA []byte, err error) {
570 if m == nil {
571 return nil, nil
572 }
573 size := m.SizeVT()
574 dAtA = make([]byte, size)
575 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
576 if err != nil {
577 return nil, err
578 }
579 return dAtA[:n], nil
580 }
581
582 func (m *HealthCheck_TlsOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
583 size := m.SizeVT()
584 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
585 }
586
587 func (m *HealthCheck_TlsOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
588 if m == nil {
589 return 0, nil
590 }
591 i := len(dAtA)
592 _ = i
593 var l int
594 _ = l
595 if m.unknownFields != nil {
596 i -= len(m.unknownFields)
597 copy(dAtA[i:], m.unknownFields)
598 }
599 if len(m.AlpnProtocols) > 0 {
600 for iNdEx := len(m.AlpnProtocols) - 1; iNdEx >= 0; iNdEx-- {
601 i -= len(m.AlpnProtocols[iNdEx])
602 copy(dAtA[i:], m.AlpnProtocols[iNdEx])
603 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AlpnProtocols[iNdEx])))
604 i--
605 dAtA[i] = 0xa
606 }
607 }
608 return len(dAtA) - i, nil
609 }
610
611 func (m *HealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
612 if m == nil {
613 return nil, nil
614 }
615 size := m.SizeVT()
616 dAtA = make([]byte, size)
617 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
618 if err != nil {
619 return nil, err
620 }
621 return dAtA[:n], nil
622 }
623
624 func (m *HealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
625 size := m.SizeVT()
626 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
627 }
628
629 func (m *HealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
630 if m == nil {
631 return 0, nil
632 }
633 i := len(dAtA)
634 _ = i
635 var l int
636 _ = l
637 if m.unknownFields != nil {
638 i -= len(m.unknownFields)
639 copy(dAtA[i:], m.unknownFields)
640 }
641 if m.AlwaysLogHealthCheckSuccess {
642 i--
643 if m.AlwaysLogHealthCheckSuccess {
644 dAtA[i] = 1
645 } else {
646 dAtA[i] = 0
647 }
648 i--
649 dAtA[i] = 0x1
650 i--
651 dAtA[i] = 0xd0
652 }
653 if len(m.EventLogger) > 0 {
654 for iNdEx := len(m.EventLogger) - 1; iNdEx >= 0; iNdEx-- {
655 size, err := m.EventLogger[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
656 if err != nil {
657 return 0, err
658 }
659 i -= size
660 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
661 i--
662 dAtA[i] = 0x1
663 i--
664 dAtA[i] = 0xca
665 }
666 }
667 if m.NoTrafficHealthyInterval != nil {
668 size, err := (*durationpb.Duration)(m.NoTrafficHealthyInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
669 if err != nil {
670 return 0, err
671 }
672 i -= size
673 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
674 i--
675 dAtA[i] = 0x1
676 i--
677 dAtA[i] = 0xc2
678 }
679 if m.TransportSocketMatchCriteria != nil {
680 size, err := (*structpb.Struct)(m.TransportSocketMatchCriteria).MarshalToSizedBufferVTStrict(dAtA[:i])
681 if err != nil {
682 return 0, err
683 }
684 i -= size
685 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
686 i--
687 dAtA[i] = 0x1
688 i--
689 dAtA[i] = 0xba
690 }
691 if m.EventService != nil {
692 size, err := m.EventService.MarshalToSizedBufferVTStrict(dAtA[:i])
693 if err != nil {
694 return 0, err
695 }
696 i -= size
697 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
698 i--
699 dAtA[i] = 0x1
700 i--
701 dAtA[i] = 0xb2
702 }
703 if m.TlsOptions != nil {
704 size, err := m.TlsOptions.MarshalToSizedBufferVTStrict(dAtA[:i])
705 if err != nil {
706 return 0, err
707 }
708 i -= size
709 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
710 i--
711 dAtA[i] = 0x1
712 i--
713 dAtA[i] = 0xaa
714 }
715 if m.InitialJitter != nil {
716 size, err := (*durationpb.Duration)(m.InitialJitter).MarshalToSizedBufferVTStrict(dAtA[:i])
717 if err != nil {
718 return 0, err
719 }
720 i -= size
721 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
722 i--
723 dAtA[i] = 0x1
724 i--
725 dAtA[i] = 0xa2
726 }
727 if m.AlwaysLogHealthCheckFailures {
728 i--
729 if m.AlwaysLogHealthCheckFailures {
730 dAtA[i] = 1
731 } else {
732 dAtA[i] = 0
733 }
734 i--
735 dAtA[i] = 0x1
736 i--
737 dAtA[i] = 0x98
738 }
739 if m.IntervalJitterPercent != 0 {
740 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IntervalJitterPercent))
741 i--
742 dAtA[i] = 0x1
743 i--
744 dAtA[i] = 0x90
745 }
746 if len(m.EventLogPath) > 0 {
747 i -= len(m.EventLogPath)
748 copy(dAtA[i:], m.EventLogPath)
749 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EventLogPath)))
750 i--
751 dAtA[i] = 0x1
752 i--
753 dAtA[i] = 0x8a
754 }
755 if m.HealthyEdgeInterval != nil {
756 size, err := (*durationpb.Duration)(m.HealthyEdgeInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
757 if err != nil {
758 return 0, err
759 }
760 i -= size
761 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
762 i--
763 dAtA[i] = 0x1
764 i--
765 dAtA[i] = 0x82
766 }
767 if m.UnhealthyEdgeInterval != nil {
768 size, err := (*durationpb.Duration)(m.UnhealthyEdgeInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
769 if err != nil {
770 return 0, err
771 }
772 i -= size
773 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
774 i--
775 dAtA[i] = 0x7a
776 }
777 if m.UnhealthyInterval != nil {
778 size, err := (*durationpb.Duration)(m.UnhealthyInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
779 if err != nil {
780 return 0, err
781 }
782 i -= size
783 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
784 i--
785 dAtA[i] = 0x72
786 }
787 if msg, ok := m.HealthChecker.(*HealthCheck_CustomHealthCheck_); ok {
788 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
789 if err != nil {
790 return 0, err
791 }
792 i -= size
793 }
794 if m.NoTrafficInterval != nil {
795 size, err := (*durationpb.Duration)(m.NoTrafficInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
796 if err != nil {
797 return 0, err
798 }
799 i -= size
800 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
801 i--
802 dAtA[i] = 0x62
803 }
804 if msg, ok := m.HealthChecker.(*HealthCheck_GrpcHealthCheck_); ok {
805 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
806 if err != nil {
807 return 0, err
808 }
809 i -= size
810 }
811 if msg, ok := m.HealthChecker.(*HealthCheck_TcpHealthCheck_); ok {
812 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
813 if err != nil {
814 return 0, err
815 }
816 i -= size
817 }
818 if msg, ok := m.HealthChecker.(*HealthCheck_HttpHealthCheck_); ok {
819 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
820 if err != nil {
821 return 0, err
822 }
823 i -= size
824 }
825 if m.ReuseConnection != nil {
826 size, err := (*wrapperspb.BoolValue)(m.ReuseConnection).MarshalToSizedBufferVTStrict(dAtA[:i])
827 if err != nil {
828 return 0, err
829 }
830 i -= size
831 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
832 i--
833 dAtA[i] = 0x3a
834 }
835 if m.AltPort != nil {
836 size, err := (*wrapperspb.UInt32Value)(m.AltPort).MarshalToSizedBufferVTStrict(dAtA[:i])
837 if err != nil {
838 return 0, err
839 }
840 i -= size
841 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
842 i--
843 dAtA[i] = 0x32
844 }
845 if m.HealthyThreshold != nil {
846 size, err := (*wrapperspb.UInt32Value)(m.HealthyThreshold).MarshalToSizedBufferVTStrict(dAtA[:i])
847 if err != nil {
848 return 0, err
849 }
850 i -= size
851 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
852 i--
853 dAtA[i] = 0x2a
854 }
855 if m.UnhealthyThreshold != nil {
856 size, err := (*wrapperspb.UInt32Value)(m.UnhealthyThreshold).MarshalToSizedBufferVTStrict(dAtA[:i])
857 if err != nil {
858 return 0, err
859 }
860 i -= size
861 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
862 i--
863 dAtA[i] = 0x22
864 }
865 if m.IntervalJitter != nil {
866 size, err := (*durationpb.Duration)(m.IntervalJitter).MarshalToSizedBufferVTStrict(dAtA[:i])
867 if err != nil {
868 return 0, err
869 }
870 i -= size
871 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
872 i--
873 dAtA[i] = 0x1a
874 }
875 if m.Interval != nil {
876 size, err := (*durationpb.Duration)(m.Interval).MarshalToSizedBufferVTStrict(dAtA[:i])
877 if err != nil {
878 return 0, err
879 }
880 i -= size
881 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
882 i--
883 dAtA[i] = 0x12
884 }
885 if m.Timeout != nil {
886 size, err := (*durationpb.Duration)(m.Timeout).MarshalToSizedBufferVTStrict(dAtA[:i])
887 if err != nil {
888 return 0, err
889 }
890 i -= size
891 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
892 i--
893 dAtA[i] = 0xa
894 }
895 return len(dAtA) - i, nil
896 }
897
898 func (m *HealthCheck_HttpHealthCheck_) MarshalToVTStrict(dAtA []byte) (int, error) {
899 size := m.SizeVT()
900 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
901 }
902
903 func (m *HealthCheck_HttpHealthCheck_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
904 i := len(dAtA)
905 if m.HttpHealthCheck != nil {
906 size, err := m.HttpHealthCheck.MarshalToSizedBufferVTStrict(dAtA[:i])
907 if err != nil {
908 return 0, err
909 }
910 i -= size
911 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
912 i--
913 dAtA[i] = 0x42
914 } else {
915 i = protohelpers.EncodeVarint(dAtA, i, 0)
916 i--
917 dAtA[i] = 0x42
918 }
919 return len(dAtA) - i, nil
920 }
921 func (m *HealthCheck_TcpHealthCheck_) MarshalToVTStrict(dAtA []byte) (int, error) {
922 size := m.SizeVT()
923 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
924 }
925
926 func (m *HealthCheck_TcpHealthCheck_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
927 i := len(dAtA)
928 if m.TcpHealthCheck != nil {
929 size, err := m.TcpHealthCheck.MarshalToSizedBufferVTStrict(dAtA[:i])
930 if err != nil {
931 return 0, err
932 }
933 i -= size
934 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
935 i--
936 dAtA[i] = 0x4a
937 } else {
938 i = protohelpers.EncodeVarint(dAtA, i, 0)
939 i--
940 dAtA[i] = 0x4a
941 }
942 return len(dAtA) - i, nil
943 }
944 func (m *HealthCheck_GrpcHealthCheck_) MarshalToVTStrict(dAtA []byte) (int, error) {
945 size := m.SizeVT()
946 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
947 }
948
949 func (m *HealthCheck_GrpcHealthCheck_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
950 i := len(dAtA)
951 if m.GrpcHealthCheck != nil {
952 size, err := m.GrpcHealthCheck.MarshalToSizedBufferVTStrict(dAtA[:i])
953 if err != nil {
954 return 0, err
955 }
956 i -= size
957 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
958 i--
959 dAtA[i] = 0x5a
960 } else {
961 i = protohelpers.EncodeVarint(dAtA, i, 0)
962 i--
963 dAtA[i] = 0x5a
964 }
965 return len(dAtA) - i, nil
966 }
967 func (m *HealthCheck_CustomHealthCheck_) MarshalToVTStrict(dAtA []byte) (int, error) {
968 size := m.SizeVT()
969 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
970 }
971
972 func (m *HealthCheck_CustomHealthCheck_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
973 i := len(dAtA)
974 if m.CustomHealthCheck != nil {
975 size, err := m.CustomHealthCheck.MarshalToSizedBufferVTStrict(dAtA[:i])
976 if err != nil {
977 return 0, err
978 }
979 i -= size
980 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
981 i--
982 dAtA[i] = 0x6a
983 } else {
984 i = protohelpers.EncodeVarint(dAtA, i, 0)
985 i--
986 dAtA[i] = 0x6a
987 }
988 return len(dAtA) - i, nil
989 }
990 func (m *HealthStatusSet) SizeVT() (n int) {
991 if m == nil {
992 return 0
993 }
994 var l int
995 _ = l
996 if len(m.Statuses) > 0 {
997 l = 0
998 for _, e := range m.Statuses {
999 l += protohelpers.SizeOfVarint(uint64(e))
1000 }
1001 n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l
1002 }
1003 n += len(m.unknownFields)
1004 return n
1005 }
1006
1007 func (m *HealthCheck_Payload) SizeVT() (n int) {
1008 if m == nil {
1009 return 0
1010 }
1011 var l int
1012 _ = l
1013 if vtmsg, ok := m.Payload.(interface{ SizeVT() int }); ok {
1014 n += vtmsg.SizeVT()
1015 }
1016 n += len(m.unknownFields)
1017 return n
1018 }
1019
1020 func (m *HealthCheck_Payload_Text) SizeVT() (n int) {
1021 if m == nil {
1022 return 0
1023 }
1024 var l int
1025 _ = l
1026 l = len(m.Text)
1027 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1028 return n
1029 }
1030 func (m *HealthCheck_Payload_Binary) SizeVT() (n int) {
1031 if m == nil {
1032 return 0
1033 }
1034 var l int
1035 _ = l
1036 l = len(m.Binary)
1037 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1038 return n
1039 }
1040 func (m *HealthCheck_HttpHealthCheck) SizeVT() (n int) {
1041 if m == nil {
1042 return 0
1043 }
1044 var l int
1045 _ = l
1046 l = len(m.Host)
1047 if l > 0 {
1048 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1049 }
1050 l = len(m.Path)
1051 if l > 0 {
1052 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1053 }
1054 if m.Send != nil {
1055 l = m.Send.SizeVT()
1056 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1057 }
1058 if len(m.Receive) > 0 {
1059 for _, e := range m.Receive {
1060 l = e.SizeVT()
1061 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1062 }
1063 }
1064 if len(m.RequestHeadersToAdd) > 0 {
1065 for _, e := range m.RequestHeadersToAdd {
1066 l = e.SizeVT()
1067 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1068 }
1069 }
1070 if len(m.RequestHeadersToRemove) > 0 {
1071 for _, s := range m.RequestHeadersToRemove {
1072 l = len(s)
1073 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1074 }
1075 }
1076 if len(m.ExpectedStatuses) > 0 {
1077 for _, e := range m.ExpectedStatuses {
1078 if size, ok := interface{}(e).(interface {
1079 SizeVT() int
1080 }); ok {
1081 l = size.SizeVT()
1082 } else {
1083 l = proto.Size(e)
1084 }
1085 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1086 }
1087 }
1088 if m.CodecClientType != 0 {
1089 n += 1 + protohelpers.SizeOfVarint(uint64(m.CodecClientType))
1090 }
1091 if m.ServiceNameMatcher != nil {
1092 if size, ok := interface{}(m.ServiceNameMatcher).(interface {
1093 SizeVT() int
1094 }); ok {
1095 l = size.SizeVT()
1096 } else {
1097 l = proto.Size(m.ServiceNameMatcher)
1098 }
1099 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1100 }
1101 if len(m.RetriableStatuses) > 0 {
1102 for _, e := range m.RetriableStatuses {
1103 if size, ok := interface{}(e).(interface {
1104 SizeVT() int
1105 }); ok {
1106 l = size.SizeVT()
1107 } else {
1108 l = proto.Size(e)
1109 }
1110 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1111 }
1112 }
1113 if m.Method != 0 {
1114 n += 1 + protohelpers.SizeOfVarint(uint64(m.Method))
1115 }
1116 if m.ResponseBufferSize != nil {
1117 l = (*wrapperspb.UInt64Value)(m.ResponseBufferSize).SizeVT()
1118 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1119 }
1120 n += len(m.unknownFields)
1121 return n
1122 }
1123
1124 func (m *HealthCheck_TcpHealthCheck) SizeVT() (n int) {
1125 if m == nil {
1126 return 0
1127 }
1128 var l int
1129 _ = l
1130 if m.Send != nil {
1131 l = m.Send.SizeVT()
1132 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1133 }
1134 if len(m.Receive) > 0 {
1135 for _, e := range m.Receive {
1136 l = e.SizeVT()
1137 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1138 }
1139 }
1140 if m.ProxyProtocolConfig != nil {
1141 l = m.ProxyProtocolConfig.SizeVT()
1142 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1143 }
1144 n += len(m.unknownFields)
1145 return n
1146 }
1147
1148 func (m *HealthCheck_RedisHealthCheck) SizeVT() (n int) {
1149 if m == nil {
1150 return 0
1151 }
1152 var l int
1153 _ = l
1154 l = len(m.Key)
1155 if l > 0 {
1156 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1157 }
1158 n += len(m.unknownFields)
1159 return n
1160 }
1161
1162 func (m *HealthCheck_GrpcHealthCheck) SizeVT() (n int) {
1163 if m == nil {
1164 return 0
1165 }
1166 var l int
1167 _ = l
1168 l = len(m.ServiceName)
1169 if l > 0 {
1170 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1171 }
1172 l = len(m.Authority)
1173 if l > 0 {
1174 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1175 }
1176 if len(m.InitialMetadata) > 0 {
1177 for _, e := range m.InitialMetadata {
1178 l = e.SizeVT()
1179 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1180 }
1181 }
1182 n += len(m.unknownFields)
1183 return n
1184 }
1185
1186 func (m *HealthCheck_CustomHealthCheck) SizeVT() (n int) {
1187 if m == nil {
1188 return 0
1189 }
1190 var l int
1191 _ = l
1192 l = len(m.Name)
1193 if l > 0 {
1194 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1195 }
1196 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
1197 n += vtmsg.SizeVT()
1198 }
1199 n += len(m.unknownFields)
1200 return n
1201 }
1202
1203 func (m *HealthCheck_CustomHealthCheck_TypedConfig) SizeVT() (n int) {
1204 if m == nil {
1205 return 0
1206 }
1207 var l int
1208 _ = l
1209 if m.TypedConfig != nil {
1210 l = (*anypb.Any)(m.TypedConfig).SizeVT()
1211 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1212 } else {
1213 n += 2
1214 }
1215 return n
1216 }
1217 func (m *HealthCheck_TlsOptions) SizeVT() (n int) {
1218 if m == nil {
1219 return 0
1220 }
1221 var l int
1222 _ = l
1223 if len(m.AlpnProtocols) > 0 {
1224 for _, s := range m.AlpnProtocols {
1225 l = len(s)
1226 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1227 }
1228 }
1229 n += len(m.unknownFields)
1230 return n
1231 }
1232
1233 func (m *HealthCheck) SizeVT() (n int) {
1234 if m == nil {
1235 return 0
1236 }
1237 var l int
1238 _ = l
1239 if m.Timeout != nil {
1240 l = (*durationpb.Duration)(m.Timeout).SizeVT()
1241 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1242 }
1243 if m.Interval != nil {
1244 l = (*durationpb.Duration)(m.Interval).SizeVT()
1245 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1246 }
1247 if m.IntervalJitter != nil {
1248 l = (*durationpb.Duration)(m.IntervalJitter).SizeVT()
1249 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1250 }
1251 if m.UnhealthyThreshold != nil {
1252 l = (*wrapperspb.UInt32Value)(m.UnhealthyThreshold).SizeVT()
1253 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1254 }
1255 if m.HealthyThreshold != nil {
1256 l = (*wrapperspb.UInt32Value)(m.HealthyThreshold).SizeVT()
1257 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1258 }
1259 if m.AltPort != nil {
1260 l = (*wrapperspb.UInt32Value)(m.AltPort).SizeVT()
1261 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1262 }
1263 if m.ReuseConnection != nil {
1264 l = (*wrapperspb.BoolValue)(m.ReuseConnection).SizeVT()
1265 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1266 }
1267 if vtmsg, ok := m.HealthChecker.(interface{ SizeVT() int }); ok {
1268 n += vtmsg.SizeVT()
1269 }
1270 if m.NoTrafficInterval != nil {
1271 l = (*durationpb.Duration)(m.NoTrafficInterval).SizeVT()
1272 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1273 }
1274 if m.UnhealthyInterval != nil {
1275 l = (*durationpb.Duration)(m.UnhealthyInterval).SizeVT()
1276 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1277 }
1278 if m.UnhealthyEdgeInterval != nil {
1279 l = (*durationpb.Duration)(m.UnhealthyEdgeInterval).SizeVT()
1280 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1281 }
1282 if m.HealthyEdgeInterval != nil {
1283 l = (*durationpb.Duration)(m.HealthyEdgeInterval).SizeVT()
1284 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1285 }
1286 l = len(m.EventLogPath)
1287 if l > 0 {
1288 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1289 }
1290 if m.IntervalJitterPercent != 0 {
1291 n += 2 + protohelpers.SizeOfVarint(uint64(m.IntervalJitterPercent))
1292 }
1293 if m.AlwaysLogHealthCheckFailures {
1294 n += 3
1295 }
1296 if m.InitialJitter != nil {
1297 l = (*durationpb.Duration)(m.InitialJitter).SizeVT()
1298 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1299 }
1300 if m.TlsOptions != nil {
1301 l = m.TlsOptions.SizeVT()
1302 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1303 }
1304 if m.EventService != nil {
1305 l = m.EventService.SizeVT()
1306 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1307 }
1308 if m.TransportSocketMatchCriteria != nil {
1309 l = (*structpb.Struct)(m.TransportSocketMatchCriteria).SizeVT()
1310 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1311 }
1312 if m.NoTrafficHealthyInterval != nil {
1313 l = (*durationpb.Duration)(m.NoTrafficHealthyInterval).SizeVT()
1314 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1315 }
1316 if len(m.EventLogger) > 0 {
1317 for _, e := range m.EventLogger {
1318 l = e.SizeVT()
1319 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1320 }
1321 }
1322 if m.AlwaysLogHealthCheckSuccess {
1323 n += 3
1324 }
1325 n += len(m.unknownFields)
1326 return n
1327 }
1328
1329 func (m *HealthCheck_HttpHealthCheck_) SizeVT() (n int) {
1330 if m == nil {
1331 return 0
1332 }
1333 var l int
1334 _ = l
1335 if m.HttpHealthCheck != nil {
1336 l = m.HttpHealthCheck.SizeVT()
1337 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1338 } else {
1339 n += 2
1340 }
1341 return n
1342 }
1343 func (m *HealthCheck_TcpHealthCheck_) SizeVT() (n int) {
1344 if m == nil {
1345 return 0
1346 }
1347 var l int
1348 _ = l
1349 if m.TcpHealthCheck != nil {
1350 l = m.TcpHealthCheck.SizeVT()
1351 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1352 } else {
1353 n += 2
1354 }
1355 return n
1356 }
1357 func (m *HealthCheck_GrpcHealthCheck_) SizeVT() (n int) {
1358 if m == nil {
1359 return 0
1360 }
1361 var l int
1362 _ = l
1363 if m.GrpcHealthCheck != nil {
1364 l = m.GrpcHealthCheck.SizeVT()
1365 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1366 } else {
1367 n += 2
1368 }
1369 return n
1370 }
1371 func (m *HealthCheck_CustomHealthCheck_) SizeVT() (n int) {
1372 if m == nil {
1373 return 0
1374 }
1375 var l int
1376 _ = l
1377 if m.CustomHealthCheck != nil {
1378 l = m.CustomHealthCheck.SizeVT()
1379 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1380 } else {
1381 n += 2
1382 }
1383 return n
1384 }