Debian Codegraph @

envoy/service/health/v3/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/health/v3/hds.proto
6
7 package healthv3
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 *LocalityEndpointsHealth) 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 *LocalityEndpointsHealth) MarshalToVTStrict(dAtA []byte) (int, error) {
216 size := m.SizeVT()
217 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
218 }
219
220 func (m *LocalityEndpointsHealth) 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] = 0x12
242 }
243 }
244 if m.Locality != nil {
245 if vtmsg, ok := interface{}(m.Locality).(interface {
246 MarshalToSizedBufferVTStrict([]byte) (int, error)
247 }); ok {
248 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
249 if err != nil {
250 return 0, err
251 }
252 i -= size
253 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
254 } else {
255 encoded, err := proto.Marshal(m.Locality)
256 if err != nil {
257 return 0, err
258 }
259 i -= len(encoded)
260 copy(dAtA[i:], encoded)
261 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
262 }
263 i--
264 dAtA[i] = 0xa
265 }
266 return len(dAtA) - i, nil
267 }
268
269 func (m *ClusterEndpointsHealth) MarshalVTStrict() (dAtA []byte, err error) {
270 if m == nil {
271 return nil, nil
272 }
273 size := m.SizeVT()
274 dAtA = make([]byte, size)
275 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
276 if err != nil {
277 return nil, err
278 }
279 return dAtA[:n], nil
280 }
281
282 func (m *ClusterEndpointsHealth) MarshalToVTStrict(dAtA []byte) (int, error) {
283 size := m.SizeVT()
284 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
285 }
286
287 func (m *ClusterEndpointsHealth) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
288 if m == nil {
289 return 0, nil
290 }
291 i := len(dAtA)
292 _ = i
293 var l int
294 _ = l
295 if m.unknownFields != nil {
296 i -= len(m.unknownFields)
297 copy(dAtA[i:], m.unknownFields)
298 }
299 if len(m.LocalityEndpointsHealth) > 0 {
300 for iNdEx := len(m.LocalityEndpointsHealth) - 1; iNdEx >= 0; iNdEx-- {
301 size, err := m.LocalityEndpointsHealth[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
302 if err != nil {
303 return 0, err
304 }
305 i -= size
306 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
307 i--
308 dAtA[i] = 0x12
309 }
310 }
311 if len(m.ClusterName) > 0 {
312 i -= len(m.ClusterName)
313 copy(dAtA[i:], m.ClusterName)
314 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterName)))
315 i--
316 dAtA[i] = 0xa
317 }
318 return len(dAtA) - i, nil
319 }
320
321 func (m *EndpointHealthResponse) MarshalVTStrict() (dAtA []byte, err error) {
322 if m == nil {
323 return nil, nil
324 }
325 size := m.SizeVT()
326 dAtA = make([]byte, size)
327 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
328 if err != nil {
329 return nil, err
330 }
331 return dAtA[:n], nil
332 }
333
334 func (m *EndpointHealthResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
335 size := m.SizeVT()
336 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
337 }
338
339 func (m *EndpointHealthResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
340 if m == nil {
341 return 0, nil
342 }
343 i := len(dAtA)
344 _ = i
345 var l int
346 _ = l
347 if m.unknownFields != nil {
348 i -= len(m.unknownFields)
349 copy(dAtA[i:], m.unknownFields)
350 }
351 if len(m.ClusterEndpointsHealth) > 0 {
352 for iNdEx := len(m.ClusterEndpointsHealth) - 1; iNdEx >= 0; iNdEx-- {
353 size, err := m.ClusterEndpointsHealth[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
354 if err != nil {
355 return 0, err
356 }
357 i -= size
358 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
359 i--
360 dAtA[i] = 0x12
361 }
362 }
363 if len(m.EndpointsHealth) > 0 {
364 for iNdEx := len(m.EndpointsHealth) - 1; iNdEx >= 0; iNdEx-- {
365 size, err := m.EndpointsHealth[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
366 if err != nil {
367 return 0, err
368 }
369 i -= size
370 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
371 i--
372 dAtA[i] = 0xa
373 }
374 }
375 return len(dAtA) - i, nil
376 }
377
378 func (m *HealthCheckRequestOrEndpointHealthResponse) MarshalVTStrict() (dAtA []byte, err error) {
379 if m == nil {
380 return nil, nil
381 }
382 size := m.SizeVT()
383 dAtA = make([]byte, size)
384 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
385 if err != nil {
386 return nil, err
387 }
388 return dAtA[:n], nil
389 }
390
391 func (m *HealthCheckRequestOrEndpointHealthResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
392 size := m.SizeVT()
393 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
394 }
395
396 func (m *HealthCheckRequestOrEndpointHealthResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
397 if m == nil {
398 return 0, nil
399 }
400 i := len(dAtA)
401 _ = i
402 var l int
403 _ = l
404 if m.unknownFields != nil {
405 i -= len(m.unknownFields)
406 copy(dAtA[i:], m.unknownFields)
407 }
408 if msg, ok := m.RequestType.(*HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse); ok {
409 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
410 if err != nil {
411 return 0, err
412 }
413 i -= size
414 }
415 if msg, ok := m.RequestType.(*HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest); ok {
416 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
417 if err != nil {
418 return 0, err
419 }
420 i -= size
421 }
422 return len(dAtA) - i, nil
423 }
424
425 func (m *HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest) MarshalToVTStrict(dAtA []byte) (int, error) {
426 size := m.SizeVT()
427 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
428 }
429
430 func (m *HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
431 i := len(dAtA)
432 if m.HealthCheckRequest != nil {
433 size, err := m.HealthCheckRequest.MarshalToSizedBufferVTStrict(dAtA[:i])
434 if err != nil {
435 return 0, err
436 }
437 i -= size
438 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
439 i--
440 dAtA[i] = 0xa
441 } else {
442 i = protohelpers.EncodeVarint(dAtA, i, 0)
443 i--
444 dAtA[i] = 0xa
445 }
446 return len(dAtA) - i, nil
447 }
448 func (m *HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
449 size := m.SizeVT()
450 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
451 }
452
453 func (m *HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
454 i := len(dAtA)
455 if m.EndpointHealthResponse != nil {
456 size, err := m.EndpointHealthResponse.MarshalToSizedBufferVTStrict(dAtA[:i])
457 if err != nil {
458 return 0, err
459 }
460 i -= size
461 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
462 i--
463 dAtA[i] = 0x12
464 } else {
465 i = protohelpers.EncodeVarint(dAtA, i, 0)
466 i--
467 dAtA[i] = 0x12
468 }
469 return len(dAtA) - i, nil
470 }
471 func (m *LocalityEndpoints) MarshalVTStrict() (dAtA []byte, err error) {
472 if m == nil {
473 return nil, nil
474 }
475 size := m.SizeVT()
476 dAtA = make([]byte, size)
477 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
478 if err != nil {
479 return nil, err
480 }
481 return dAtA[:n], nil
482 }
483
484 func (m *LocalityEndpoints) MarshalToVTStrict(dAtA []byte) (int, error) {
485 size := m.SizeVT()
486 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
487 }
488
489 func (m *LocalityEndpoints) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
490 if m == nil {
491 return 0, nil
492 }
493 i := len(dAtA)
494 _ = i
495 var l int
496 _ = l
497 if m.unknownFields != nil {
498 i -= len(m.unknownFields)
499 copy(dAtA[i:], m.unknownFields)
500 }
501 if len(m.Endpoints) > 0 {
502 for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- {
503 if vtmsg, ok := interface{}(m.Endpoints[iNdEx]).(interface {
504 MarshalToSizedBufferVTStrict([]byte) (int, error)
505 }); ok {
506 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
507 if err != nil {
508 return 0, err
509 }
510 i -= size
511 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
512 } else {
513 encoded, err := proto.Marshal(m.Endpoints[iNdEx])
514 if err != nil {
515 return 0, err
516 }
517 i -= len(encoded)
518 copy(dAtA[i:], encoded)
519 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
520 }
521 i--
522 dAtA[i] = 0x12
523 }
524 }
525 if m.Locality != nil {
526 if vtmsg, ok := interface{}(m.Locality).(interface {
527 MarshalToSizedBufferVTStrict([]byte) (int, error)
528 }); ok {
529 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
530 if err != nil {
531 return 0, err
532 }
533 i -= size
534 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
535 } else {
536 encoded, err := proto.Marshal(m.Locality)
537 if err != nil {
538 return 0, err
539 }
540 i -= len(encoded)
541 copy(dAtA[i:], encoded)
542 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
543 }
544 i--
545 dAtA[i] = 0xa
546 }
547 return len(dAtA) - i, nil
548 }
549
550 func (m *ClusterHealthCheck) MarshalVTStrict() (dAtA []byte, err error) {
551 if m == nil {
552 return nil, nil
553 }
554 size := m.SizeVT()
555 dAtA = make([]byte, size)
556 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
557 if err != nil {
558 return nil, err
559 }
560 return dAtA[:n], nil
561 }
562
563 func (m *ClusterHealthCheck) MarshalToVTStrict(dAtA []byte) (int, error) {
564 size := m.SizeVT()
565 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
566 }
567
568 func (m *ClusterHealthCheck) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
569 if m == nil {
570 return 0, nil
571 }
572 i := len(dAtA)
573 _ = i
574 var l int
575 _ = l
576 if m.unknownFields != nil {
577 i -= len(m.unknownFields)
578 copy(dAtA[i:], m.unknownFields)
579 }
580 if m.UpstreamBindConfig != nil {
581 if vtmsg, ok := interface{}(m.UpstreamBindConfig).(interface {
582 MarshalToSizedBufferVTStrict([]byte) (int, error)
583 }); ok {
584 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
585 if err != nil {
586 return 0, err
587 }
588 i -= size
589 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
590 } else {
591 encoded, err := proto.Marshal(m.UpstreamBindConfig)
592 if err != nil {
593 return 0, err
594 }
595 i -= len(encoded)
596 copy(dAtA[i:], encoded)
597 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
598 }
599 i--
600 dAtA[i] = 0x2a
601 }
602 if len(m.TransportSocketMatches) > 0 {
603 for iNdEx := len(m.TransportSocketMatches) - 1; iNdEx >= 0; iNdEx-- {
604 if vtmsg, ok := interface{}(m.TransportSocketMatches[iNdEx]).(interface {
605 MarshalToSizedBufferVTStrict([]byte) (int, error)
606 }); ok {
607 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
608 if err != nil {
609 return 0, err
610 }
611 i -= size
612 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
613 } else {
614 encoded, err := proto.Marshal(m.TransportSocketMatches[iNdEx])
615 if err != nil {
616 return 0, err
617 }
618 i -= len(encoded)
619 copy(dAtA[i:], encoded)
620 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
621 }
622 i--
623 dAtA[i] = 0x22
624 }
625 }
626 if len(m.LocalityEndpoints) > 0 {
627 for iNdEx := len(m.LocalityEndpoints) - 1; iNdEx >= 0; iNdEx-- {
628 size, err := m.LocalityEndpoints[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
629 if err != nil {
630 return 0, err
631 }
632 i -= size
633 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
634 i--
635 dAtA[i] = 0x1a
636 }
637 }
638 if len(m.HealthChecks) > 0 {
639 for iNdEx := len(m.HealthChecks) - 1; iNdEx >= 0; iNdEx-- {
640 if vtmsg, ok := interface{}(m.HealthChecks[iNdEx]).(interface {
641 MarshalToSizedBufferVTStrict([]byte) (int, error)
642 }); ok {
643 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
644 if err != nil {
645 return 0, err
646 }
647 i -= size
648 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
649 } else {
650 encoded, err := proto.Marshal(m.HealthChecks[iNdEx])
651 if err != nil {
652 return 0, err
653 }
654 i -= len(encoded)
655 copy(dAtA[i:], encoded)
656 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
657 }
658 i--
659 dAtA[i] = 0x12
660 }
661 }
662 if len(m.ClusterName) > 0 {
663 i -= len(m.ClusterName)
664 copy(dAtA[i:], m.ClusterName)
665 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterName)))
666 i--
667 dAtA[i] = 0xa
668 }
669 return len(dAtA) - i, nil
670 }
671
672 func (m *HealthCheckSpecifier) MarshalVTStrict() (dAtA []byte, err error) {
673 if m == nil {
674 return nil, nil
675 }
676 size := m.SizeVT()
677 dAtA = make([]byte, size)
678 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
679 if err != nil {
680 return nil, err
681 }
682 return dAtA[:n], nil
683 }
684
685 func (m *HealthCheckSpecifier) MarshalToVTStrict(dAtA []byte) (int, error) {
686 size := m.SizeVT()
687 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
688 }
689
690 func (m *HealthCheckSpecifier) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
691 if m == nil {
692 return 0, nil
693 }
694 i := len(dAtA)
695 _ = i
696 var l int
697 _ = l
698 if m.unknownFields != nil {
699 i -= len(m.unknownFields)
700 copy(dAtA[i:], m.unknownFields)
701 }
702 if m.Interval != nil {
703 size, err := (*durationpb.Duration)(m.Interval).MarshalToSizedBufferVTStrict(dAtA[:i])
704 if err != nil {
705 return 0, err
706 }
707 i -= size
708 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
709 i--
710 dAtA[i] = 0x12
711 }
712 if len(m.ClusterHealthChecks) > 0 {
713 for iNdEx := len(m.ClusterHealthChecks) - 1; iNdEx >= 0; iNdEx-- {
714 size, err := m.ClusterHealthChecks[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
715 if err != nil {
716 return 0, err
717 }
718 i -= size
719 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
720 i--
721 dAtA[i] = 0xa
722 }
723 }
724 return len(dAtA) - i, nil
725 }
726
727 func (m *HdsDummy) MarshalVTStrict() (dAtA []byte, err error) {
728 if m == nil {
729 return nil, nil
730 }
731 size := m.SizeVT()
732 dAtA = make([]byte, size)
733 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
734 if err != nil {
735 return nil, err
736 }
737 return dAtA[:n], nil
738 }
739
740 func (m *HdsDummy) MarshalToVTStrict(dAtA []byte) (int, error) {
741 size := m.SizeVT()
742 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
743 }
744
745 func (m *HdsDummy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
746 if m == nil {
747 return 0, nil
748 }
749 i := len(dAtA)
750 _ = i
751 var l int
752 _ = l
753 if m.unknownFields != nil {
754 i -= len(m.unknownFields)
755 copy(dAtA[i:], m.unknownFields)
756 }
757 return len(dAtA) - i, nil
758 }
759
760 func (m *Capability) SizeVT() (n int) {
761 if m == nil {
762 return 0
763 }
764 var l int
765 _ = l
766 if len(m.HealthCheckProtocols) > 0 {
767 l = 0
768 for _, e := range m.HealthCheckProtocols {
769 l += protohelpers.SizeOfVarint(uint64(e))
770 }
771 n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l
772 }
773 n += len(m.unknownFields)
774 return n
775 }
776
777 func (m *HealthCheckRequest) SizeVT() (n int) {
778 if m == nil {
779 return 0
780 }
781 var l int
782 _ = l
783 if m.Node != nil {
784 if size, ok := interface{}(m.Node).(interface {
785 SizeVT() int
786 }); ok {
787 l = size.SizeVT()
788 } else {
789 l = proto.Size(m.Node)
790 }
791 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
792 }
793 if m.Capability != nil {
794 l = m.Capability.SizeVT()
795 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
796 }
797 n += len(m.unknownFields)
798 return n
799 }
800
801 func (m *EndpointHealth) SizeVT() (n int) {
802 if m == nil {
803 return 0
804 }
805 var l int
806 _ = l
807 if m.Endpoint != nil {
808 if size, ok := interface{}(m.Endpoint).(interface {
809 SizeVT() int
810 }); ok {
811 l = size.SizeVT()
812 } else {
813 l = proto.Size(m.Endpoint)
814 }
815 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
816 }
817 if m.HealthStatus != 0 {
818 n += 1 + protohelpers.SizeOfVarint(uint64(m.HealthStatus))
819 }
820 n += len(m.unknownFields)
821 return n
822 }
823
824 func (m *LocalityEndpointsHealth) SizeVT() (n int) {
825 if m == nil {
826 return 0
827 }
828 var l int
829 _ = l
830 if m.Locality != nil {
831 if size, ok := interface{}(m.Locality).(interface {
832 SizeVT() int
833 }); ok {
834 l = size.SizeVT()
835 } else {
836 l = proto.Size(m.Locality)
837 }
838 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
839 }
840 if len(m.EndpointsHealth) > 0 {
841 for _, e := range m.EndpointsHealth {
842 l = e.SizeVT()
843 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
844 }
845 }
846 n += len(m.unknownFields)
847 return n
848 }
849
850 func (m *ClusterEndpointsHealth) SizeVT() (n int) {
851 if m == nil {
852 return 0
853 }
854 var l int
855 _ = l
856 l = len(m.ClusterName)
857 if l > 0 {
858 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
859 }
860 if len(m.LocalityEndpointsHealth) > 0 {
861 for _, e := range m.LocalityEndpointsHealth {
862 l = e.SizeVT()
863 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
864 }
865 }
866 n += len(m.unknownFields)
867 return n
868 }
869
870 func (m *EndpointHealthResponse) SizeVT() (n int) {
871 if m == nil {
872 return 0
873 }
874 var l int
875 _ = l
876 if len(m.EndpointsHealth) > 0 {
877 for _, e := range m.EndpointsHealth {
878 l = e.SizeVT()
879 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
880 }
881 }
882 if len(m.ClusterEndpointsHealth) > 0 {
883 for _, e := range m.ClusterEndpointsHealth {
884 l = e.SizeVT()
885 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
886 }
887 }
888 n += len(m.unknownFields)
889 return n
890 }
891
892 func (m *HealthCheckRequestOrEndpointHealthResponse) SizeVT() (n int) {
893 if m == nil {
894 return 0
895 }
896 var l int
897 _ = l
898 if vtmsg, ok := m.RequestType.(interface{ SizeVT() int }); ok {
899 n += vtmsg.SizeVT()
900 }
901 n += len(m.unknownFields)
902 return n
903 }
904
905 func (m *HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest) SizeVT() (n int) {
906 if m == nil {
907 return 0
908 }
909 var l int
910 _ = l
911 if m.HealthCheckRequest != nil {
912 l = m.HealthCheckRequest.SizeVT()
913 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
914 } else {
915 n += 2
916 }
917 return n
918 }
919 func (m *HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse) SizeVT() (n int) {
920 if m == nil {
921 return 0
922 }
923 var l int
924 _ = l
925 if m.EndpointHealthResponse != nil {
926 l = m.EndpointHealthResponse.SizeVT()
927 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
928 } else {
929 n += 2
930 }
931 return n
932 }
933 func (m *LocalityEndpoints) SizeVT() (n int) {
934 if m == nil {
935 return 0
936 }
937 var l int
938 _ = l
939 if m.Locality != nil {
940 if size, ok := interface{}(m.Locality).(interface {
941 SizeVT() int
942 }); ok {
943 l = size.SizeVT()
944 } else {
945 l = proto.Size(m.Locality)
946 }
947 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
948 }
949 if len(m.Endpoints) > 0 {
950 for _, e := range m.Endpoints {
951 if size, ok := interface{}(e).(interface {
952 SizeVT() int
953 }); ok {
954 l = size.SizeVT()
955 } else {
956 l = proto.Size(e)
957 }
958 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
959 }
960 }
961 n += len(m.unknownFields)
962 return n
963 }
964
965 func (m *ClusterHealthCheck) SizeVT() (n int) {
966 if m == nil {
967 return 0
968 }
969 var l int
970 _ = l
971 l = len(m.ClusterName)
972 if l > 0 {
973 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
974 }
975 if len(m.HealthChecks) > 0 {
976 for _, e := range m.HealthChecks {
977 if size, ok := interface{}(e).(interface {
978 SizeVT() int
979 }); ok {
980 l = size.SizeVT()
981 } else {
982 l = proto.Size(e)
983 }
984 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
985 }
986 }
987 if len(m.LocalityEndpoints) > 0 {
988 for _, e := range m.LocalityEndpoints {
989 l = e.SizeVT()
990 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
991 }
992 }
993 if len(m.TransportSocketMatches) > 0 {
994 for _, e := range m.TransportSocketMatches {
995 if size, ok := interface{}(e).(interface {
996 SizeVT() int
997 }); ok {
998 l = size.SizeVT()
999 } else {
1000 l = proto.Size(e)
1001 }
1002 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1003 }
1004 }
1005 if m.UpstreamBindConfig != nil {
1006 if size, ok := interface{}(m.UpstreamBindConfig).(interface {
1007 SizeVT() int
1008 }); ok {
1009 l = size.SizeVT()
1010 } else {
1011 l = proto.Size(m.UpstreamBindConfig)
1012 }
1013 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1014 }
1015 n += len(m.unknownFields)
1016 return n
1017 }
1018
1019 func (m *HealthCheckSpecifier) SizeVT() (n int) {
1020 if m == nil {
1021 return 0
1022 }
1023 var l int
1024 _ = l
1025 if len(m.ClusterHealthChecks) > 0 {
1026 for _, e := range m.ClusterHealthChecks {
1027 l = e.SizeVT()
1028 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1029 }
1030 }
1031 if m.Interval != nil {
1032 l = (*durationpb.Duration)(m.Interval).SizeVT()
1033 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1034 }
1035 n += len(m.unknownFields)
1036 return n
1037 }
1038
1039 func (m *HdsDummy) SizeVT() (n int) {
1040 if m == nil {
1041 return 0
1042 }
1043 var l int
1044 _ = l
1045 n += len(m.unknownFields)
1046 return n
1047 }