Debian Codegraph @

envoy/config/endpoint/v3/endpoint_components_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/endpoint/v3/endpoint_components.proto
6
7 package endpointv3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
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 *Endpoint_HealthCheckConfig) 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 *Endpoint_HealthCheckConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
37 size := m.SizeVT()
38 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
39 }
40
41 func (m *Endpoint_HealthCheckConfig) 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 m.DisableActiveHealthCheck {
54 i--
55 if m.DisableActiveHealthCheck {
56 dAtA[i] = 1
57 } else {
58 dAtA[i] = 0
59 }
60 i--
61 dAtA[i] = 0x20
62 }
63 if m.Address != nil {
64 if vtmsg, ok := interface{}(m.Address).(interface {
65 MarshalToSizedBufferVTStrict([]byte) (int, error)
66 }); ok {
67 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
68 if err != nil {
69 return 0, err
70 }
71 i -= size
72 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
73 } else {
74 encoded, err := proto.Marshal(m.Address)
75 if err != nil {
76 return 0, err
77 }
78 i -= len(encoded)
79 copy(dAtA[i:], encoded)
80 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
81 }
82 i--
83 dAtA[i] = 0x1a
84 }
85 if len(m.Hostname) > 0 {
86 i -= len(m.Hostname)
87 copy(dAtA[i:], m.Hostname)
88 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
89 i--
90 dAtA[i] = 0x12
91 }
92 if m.PortValue != 0 {
93 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PortValue))
94 i--
95 dAtA[i] = 0x8
96 }
97 return len(dAtA) - i, nil
98 }
99
100 func (m *Endpoint_AdditionalAddress) MarshalVTStrict() (dAtA []byte, err error) {
101 if m == nil {
102 return nil, nil
103 }
104 size := m.SizeVT()
105 dAtA = make([]byte, size)
106 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
107 if err != nil {
108 return nil, err
109 }
110 return dAtA[:n], nil
111 }
112
113 func (m *Endpoint_AdditionalAddress) MarshalToVTStrict(dAtA []byte) (int, error) {
114 size := m.SizeVT()
115 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
116 }
117
118 func (m *Endpoint_AdditionalAddress) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
119 if m == nil {
120 return 0, nil
121 }
122 i := len(dAtA)
123 _ = i
124 var l int
125 _ = l
126 if m.unknownFields != nil {
127 i -= len(m.unknownFields)
128 copy(dAtA[i:], m.unknownFields)
129 }
130 if m.Address != nil {
131 if vtmsg, ok := interface{}(m.Address).(interface {
132 MarshalToSizedBufferVTStrict([]byte) (int, error)
133 }); ok {
134 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
135 if err != nil {
136 return 0, err
137 }
138 i -= size
139 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
140 } else {
141 encoded, err := proto.Marshal(m.Address)
142 if err != nil {
143 return 0, err
144 }
145 i -= len(encoded)
146 copy(dAtA[i:], encoded)
147 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
148 }
149 i--
150 dAtA[i] = 0xa
151 }
152 return len(dAtA) - i, nil
153 }
154
155 func (m *Endpoint) 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 *Endpoint) MarshalToVTStrict(dAtA []byte) (int, error) {
169 size := m.SizeVT()
170 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
171 }
172
173 func (m *Endpoint) 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 len(m.AdditionalAddresses) > 0 {
186 for iNdEx := len(m.AdditionalAddresses) - 1; iNdEx >= 0; iNdEx-- {
187 size, err := m.AdditionalAddresses[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
188 if err != nil {
189 return 0, err
190 }
191 i -= size
192 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
193 i--
194 dAtA[i] = 0x22
195 }
196 }
197 if len(m.Hostname) > 0 {
198 i -= len(m.Hostname)
199 copy(dAtA[i:], m.Hostname)
200 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
201 i--
202 dAtA[i] = 0x1a
203 }
204 if m.HealthCheckConfig != nil {
205 size, err := m.HealthCheckConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
206 if err != nil {
207 return 0, err
208 }
209 i -= size
210 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
211 i--
212 dAtA[i] = 0x12
213 }
214 if m.Address != nil {
215 if vtmsg, ok := interface{}(m.Address).(interface {
216 MarshalToSizedBufferVTStrict([]byte) (int, error)
217 }); ok {
218 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
219 if err != nil {
220 return 0, err
221 }
222 i -= size
223 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
224 } else {
225 encoded, err := proto.Marshal(m.Address)
226 if err != nil {
227 return 0, err
228 }
229 i -= len(encoded)
230 copy(dAtA[i:], encoded)
231 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
232 }
233 i--
234 dAtA[i] = 0xa
235 }
236 return len(dAtA) - i, nil
237 }
238
239 func (m *LbEndpoint) MarshalVTStrict() (dAtA []byte, err error) {
240 if m == nil {
241 return nil, nil
242 }
243 size := m.SizeVT()
244 dAtA = make([]byte, size)
245 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
246 if err != nil {
247 return nil, err
248 }
249 return dAtA[:n], nil
250 }
251
252 func (m *LbEndpoint) MarshalToVTStrict(dAtA []byte) (int, error) {
253 size := m.SizeVT()
254 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
255 }
256
257 func (m *LbEndpoint) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
258 if m == nil {
259 return 0, nil
260 }
261 i := len(dAtA)
262 _ = i
263 var l int
264 _ = l
265 if m.unknownFields != nil {
266 i -= len(m.unknownFields)
267 copy(dAtA[i:], m.unknownFields)
268 }
269 if msg, ok := m.HostIdentifier.(*LbEndpoint_EndpointName); ok {
270 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
271 if err != nil {
272 return 0, err
273 }
274 i -= size
275 }
276 if m.LoadBalancingWeight != nil {
277 size, err := (*wrapperspb.UInt32Value)(m.LoadBalancingWeight).MarshalToSizedBufferVTStrict(dAtA[:i])
278 if err != nil {
279 return 0, err
280 }
281 i -= size
282 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
283 i--
284 dAtA[i] = 0x22
285 }
286 if m.Metadata != nil {
287 if vtmsg, ok := interface{}(m.Metadata).(interface {
288 MarshalToSizedBufferVTStrict([]byte) (int, error)
289 }); ok {
290 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
291 if err != nil {
292 return 0, err
293 }
294 i -= size
295 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
296 } else {
297 encoded, err := proto.Marshal(m.Metadata)
298 if err != nil {
299 return 0, err
300 }
301 i -= len(encoded)
302 copy(dAtA[i:], encoded)
303 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
304 }
305 i--
306 dAtA[i] = 0x1a
307 }
308 if m.HealthStatus != 0 {
309 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HealthStatus))
310 i--
311 dAtA[i] = 0x10
312 }
313 if msg, ok := m.HostIdentifier.(*LbEndpoint_Endpoint); ok {
314 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
315 if err != nil {
316 return 0, err
317 }
318 i -= size
319 }
320 return len(dAtA) - i, nil
321 }
322
323 func (m *LbEndpoint_Endpoint) MarshalToVTStrict(dAtA []byte) (int, error) {
324 size := m.SizeVT()
325 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
326 }
327
328 func (m *LbEndpoint_Endpoint) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
329 i := len(dAtA)
330 if m.Endpoint != nil {
331 size, err := m.Endpoint.MarshalToSizedBufferVTStrict(dAtA[:i])
332 if err != nil {
333 return 0, err
334 }
335 i -= size
336 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
337 i--
338 dAtA[i] = 0xa
339 } else {
340 i = protohelpers.EncodeVarint(dAtA, i, 0)
341 i--
342 dAtA[i] = 0xa
343 }
344 return len(dAtA) - i, nil
345 }
346 func (m *LbEndpoint_EndpointName) MarshalToVTStrict(dAtA []byte) (int, error) {
347 size := m.SizeVT()
348 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
349 }
350
351 func (m *LbEndpoint_EndpointName) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
352 i := len(dAtA)
353 i -= len(m.EndpointName)
354 copy(dAtA[i:], m.EndpointName)
355 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EndpointName)))
356 i--
357 dAtA[i] = 0x2a
358 return len(dAtA) - i, nil
359 }
360 func (m *LedsClusterLocalityConfig) MarshalVTStrict() (dAtA []byte, err error) {
361 if m == nil {
362 return nil, nil
363 }
364 size := m.SizeVT()
365 dAtA = make([]byte, size)
366 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
367 if err != nil {
368 return nil, err
369 }
370 return dAtA[:n], nil
371 }
372
373 func (m *LedsClusterLocalityConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
374 size := m.SizeVT()
375 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
376 }
377
378 func (m *LedsClusterLocalityConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
379 if m == nil {
380 return 0, nil
381 }
382 i := len(dAtA)
383 _ = i
384 var l int
385 _ = l
386 if m.unknownFields != nil {
387 i -= len(m.unknownFields)
388 copy(dAtA[i:], m.unknownFields)
389 }
390 if len(m.LedsCollectionName) > 0 {
391 i -= len(m.LedsCollectionName)
392 copy(dAtA[i:], m.LedsCollectionName)
393 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LedsCollectionName)))
394 i--
395 dAtA[i] = 0x12
396 }
397 if m.LedsConfig != nil {
398 if vtmsg, ok := interface{}(m.LedsConfig).(interface {
399 MarshalToSizedBufferVTStrict([]byte) (int, error)
400 }); ok {
401 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
402 if err != nil {
403 return 0, err
404 }
405 i -= size
406 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
407 } else {
408 encoded, err := proto.Marshal(m.LedsConfig)
409 if err != nil {
410 return 0, err
411 }
412 i -= len(encoded)
413 copy(dAtA[i:], encoded)
414 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
415 }
416 i--
417 dAtA[i] = 0xa
418 }
419 return len(dAtA) - i, nil
420 }
421
422 func (m *LocalityLbEndpoints_LbEndpointList) MarshalVTStrict() (dAtA []byte, err error) {
423 if m == nil {
424 return nil, nil
425 }
426 size := m.SizeVT()
427 dAtA = make([]byte, size)
428 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
429 if err != nil {
430 return nil, err
431 }
432 return dAtA[:n], nil
433 }
434
435 func (m *LocalityLbEndpoints_LbEndpointList) MarshalToVTStrict(dAtA []byte) (int, error) {
436 size := m.SizeVT()
437 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
438 }
439
440 func (m *LocalityLbEndpoints_LbEndpointList) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
441 if m == nil {
442 return 0, nil
443 }
444 i := len(dAtA)
445 _ = i
446 var l int
447 _ = l
448 if m.unknownFields != nil {
449 i -= len(m.unknownFields)
450 copy(dAtA[i:], m.unknownFields)
451 }
452 if len(m.LbEndpoints) > 0 {
453 for iNdEx := len(m.LbEndpoints) - 1; iNdEx >= 0; iNdEx-- {
454 size, err := m.LbEndpoints[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
455 if err != nil {
456 return 0, err
457 }
458 i -= size
459 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
460 i--
461 dAtA[i] = 0xa
462 }
463 }
464 return len(dAtA) - i, nil
465 }
466
467 func (m *LocalityLbEndpoints) MarshalVTStrict() (dAtA []byte, err error) {
468 if m == nil {
469 return nil, nil
470 }
471 size := m.SizeVT()
472 dAtA = make([]byte, size)
473 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
474 if err != nil {
475 return nil, err
476 }
477 return dAtA[:n], nil
478 }
479
480 func (m *LocalityLbEndpoints) MarshalToVTStrict(dAtA []byte) (int, error) {
481 size := m.SizeVT()
482 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
483 }
484
485 func (m *LocalityLbEndpoints) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
486 if m == nil {
487 return 0, nil
488 }
489 i := len(dAtA)
490 _ = i
491 var l int
492 _ = l
493 if m.unknownFields != nil {
494 i -= len(m.unknownFields)
495 copy(dAtA[i:], m.unknownFields)
496 }
497 if m.Metadata != nil {
498 if vtmsg, ok := interface{}(m.Metadata).(interface {
499 MarshalToSizedBufferVTStrict([]byte) (int, error)
500 }); ok {
501 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
502 if err != nil {
503 return 0, err
504 }
505 i -= size
506 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
507 } else {
508 encoded, err := proto.Marshal(m.Metadata)
509 if err != nil {
510 return 0, err
511 }
512 i -= len(encoded)
513 copy(dAtA[i:], encoded)
514 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
515 }
516 i--
517 dAtA[i] = 0x4a
518 }
519 if msg, ok := m.LbConfig.(*LocalityLbEndpoints_LedsClusterLocalityConfig); ok {
520 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
521 if err != nil {
522 return 0, err
523 }
524 i -= size
525 }
526 if msg, ok := m.LbConfig.(*LocalityLbEndpoints_LoadBalancerEndpoints); ok {
527 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
528 if err != nil {
529 return 0, err
530 }
531 i -= size
532 }
533 if m.Proximity != nil {
534 size, err := (*wrapperspb.UInt32Value)(m.Proximity).MarshalToSizedBufferVTStrict(dAtA[:i])
535 if err != nil {
536 return 0, err
537 }
538 i -= size
539 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
540 i--
541 dAtA[i] = 0x32
542 }
543 if m.Priority != 0 {
544 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Priority))
545 i--
546 dAtA[i] = 0x28
547 }
548 if m.LoadBalancingWeight != nil {
549 size, err := (*wrapperspb.UInt32Value)(m.LoadBalancingWeight).MarshalToSizedBufferVTStrict(dAtA[:i])
550 if err != nil {
551 return 0, err
552 }
553 i -= size
554 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
555 i--
556 dAtA[i] = 0x1a
557 }
558 if len(m.LbEndpoints) > 0 {
559 for iNdEx := len(m.LbEndpoints) - 1; iNdEx >= 0; iNdEx-- {
560 size, err := m.LbEndpoints[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
561 if err != nil {
562 return 0, err
563 }
564 i -= size
565 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
566 i--
567 dAtA[i] = 0x12
568 }
569 }
570 if m.Locality != nil {
571 if vtmsg, ok := interface{}(m.Locality).(interface {
572 MarshalToSizedBufferVTStrict([]byte) (int, error)
573 }); ok {
574 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
575 if err != nil {
576 return 0, err
577 }
578 i -= size
579 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
580 } else {
581 encoded, err := proto.Marshal(m.Locality)
582 if err != nil {
583 return 0, err
584 }
585 i -= len(encoded)
586 copy(dAtA[i:], encoded)
587 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
588 }
589 i--
590 dAtA[i] = 0xa
591 }
592 return len(dAtA) - i, nil
593 }
594
595 func (m *LocalityLbEndpoints_LoadBalancerEndpoints) MarshalToVTStrict(dAtA []byte) (int, error) {
596 size := m.SizeVT()
597 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
598 }
599
600 func (m *LocalityLbEndpoints_LoadBalancerEndpoints) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
601 i := len(dAtA)
602 if m.LoadBalancerEndpoints != nil {
603 size, err := m.LoadBalancerEndpoints.MarshalToSizedBufferVTStrict(dAtA[:i])
604 if err != nil {
605 return 0, err
606 }
607 i -= size
608 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
609 i--
610 dAtA[i] = 0x3a
611 } else {
612 i = protohelpers.EncodeVarint(dAtA, i, 0)
613 i--
614 dAtA[i] = 0x3a
615 }
616 return len(dAtA) - i, nil
617 }
618 func (m *LocalityLbEndpoints_LedsClusterLocalityConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
619 size := m.SizeVT()
620 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
621 }
622
623 func (m *LocalityLbEndpoints_LedsClusterLocalityConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
624 i := len(dAtA)
625 if m.LedsClusterLocalityConfig != nil {
626 size, err := m.LedsClusterLocalityConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
627 if err != nil {
628 return 0, err
629 }
630 i -= size
631 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
632 i--
633 dAtA[i] = 0x42
634 } else {
635 i = protohelpers.EncodeVarint(dAtA, i, 0)
636 i--
637 dAtA[i] = 0x42
638 }
639 return len(dAtA) - i, nil
640 }
641 func (m *Endpoint_HealthCheckConfig) SizeVT() (n int) {
642 if m == nil {
643 return 0
644 }
645 var l int
646 _ = l
647 if m.PortValue != 0 {
648 n += 1 + protohelpers.SizeOfVarint(uint64(m.PortValue))
649 }
650 l = len(m.Hostname)
651 if l > 0 {
652 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
653 }
654 if m.Address != nil {
655 if size, ok := interface{}(m.Address).(interface {
656 SizeVT() int
657 }); ok {
658 l = size.SizeVT()
659 } else {
660 l = proto.Size(m.Address)
661 }
662 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
663 }
664 if m.DisableActiveHealthCheck {
665 n += 2
666 }
667 n += len(m.unknownFields)
668 return n
669 }
670
671 func (m *Endpoint_AdditionalAddress) SizeVT() (n int) {
672 if m == nil {
673 return 0
674 }
675 var l int
676 _ = l
677 if m.Address != nil {
678 if size, ok := interface{}(m.Address).(interface {
679 SizeVT() int
680 }); ok {
681 l = size.SizeVT()
682 } else {
683 l = proto.Size(m.Address)
684 }
685 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
686 }
687 n += len(m.unknownFields)
688 return n
689 }
690
691 func (m *Endpoint) SizeVT() (n int) {
692 if m == nil {
693 return 0
694 }
695 var l int
696 _ = l
697 if m.Address != nil {
698 if size, ok := interface{}(m.Address).(interface {
699 SizeVT() int
700 }); ok {
701 l = size.SizeVT()
702 } else {
703 l = proto.Size(m.Address)
704 }
705 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
706 }
707 if m.HealthCheckConfig != nil {
708 l = m.HealthCheckConfig.SizeVT()
709 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
710 }
711 l = len(m.Hostname)
712 if l > 0 {
713 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
714 }
715 if len(m.AdditionalAddresses) > 0 {
716 for _, e := range m.AdditionalAddresses {
717 l = e.SizeVT()
718 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
719 }
720 }
721 n += len(m.unknownFields)
722 return n
723 }
724
725 func (m *LbEndpoint) SizeVT() (n int) {
726 if m == nil {
727 return 0
728 }
729 var l int
730 _ = l
731 if vtmsg, ok := m.HostIdentifier.(interface{ SizeVT() int }); ok {
732 n += vtmsg.SizeVT()
733 }
734 if m.HealthStatus != 0 {
735 n += 1 + protohelpers.SizeOfVarint(uint64(m.HealthStatus))
736 }
737 if m.Metadata != nil {
738 if size, ok := interface{}(m.Metadata).(interface {
739 SizeVT() int
740 }); ok {
741 l = size.SizeVT()
742 } else {
743 l = proto.Size(m.Metadata)
744 }
745 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
746 }
747 if m.LoadBalancingWeight != nil {
748 l = (*wrapperspb.UInt32Value)(m.LoadBalancingWeight).SizeVT()
749 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
750 }
751 n += len(m.unknownFields)
752 return n
753 }
754
755 func (m *LbEndpoint_Endpoint) SizeVT() (n int) {
756 if m == nil {
757 return 0
758 }
759 var l int
760 _ = l
761 if m.Endpoint != nil {
762 l = m.Endpoint.SizeVT()
763 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
764 } else {
765 n += 2
766 }
767 return n
768 }
769 func (m *LbEndpoint_EndpointName) SizeVT() (n int) {
770 if m == nil {
771 return 0
772 }
773 var l int
774 _ = l
775 l = len(m.EndpointName)
776 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
777 return n
778 }
779 func (m *LedsClusterLocalityConfig) SizeVT() (n int) {
780 if m == nil {
781 return 0
782 }
783 var l int
784 _ = l
785 if m.LedsConfig != nil {
786 if size, ok := interface{}(m.LedsConfig).(interface {
787 SizeVT() int
788 }); ok {
789 l = size.SizeVT()
790 } else {
791 l = proto.Size(m.LedsConfig)
792 }
793 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
794 }
795 l = len(m.LedsCollectionName)
796 if l > 0 {
797 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
798 }
799 n += len(m.unknownFields)
800 return n
801 }
802
803 func (m *LocalityLbEndpoints_LbEndpointList) SizeVT() (n int) {
804 if m == nil {
805 return 0
806 }
807 var l int
808 _ = l
809 if len(m.LbEndpoints) > 0 {
810 for _, e := range m.LbEndpoints {
811 l = e.SizeVT()
812 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
813 }
814 }
815 n += len(m.unknownFields)
816 return n
817 }
818
819 func (m *LocalityLbEndpoints) SizeVT() (n int) {
820 if m == nil {
821 return 0
822 }
823 var l int
824 _ = l
825 if m.Locality != nil {
826 if size, ok := interface{}(m.Locality).(interface {
827 SizeVT() int
828 }); ok {
829 l = size.SizeVT()
830 } else {
831 l = proto.Size(m.Locality)
832 }
833 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
834 }
835 if len(m.LbEndpoints) > 0 {
836 for _, e := range m.LbEndpoints {
837 l = e.SizeVT()
838 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
839 }
840 }
841 if m.LoadBalancingWeight != nil {
842 l = (*wrapperspb.UInt32Value)(m.LoadBalancingWeight).SizeVT()
843 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
844 }
845 if m.Priority != 0 {
846 n += 1 + protohelpers.SizeOfVarint(uint64(m.Priority))
847 }
848 if m.Proximity != nil {
849 l = (*wrapperspb.UInt32Value)(m.Proximity).SizeVT()
850 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
851 }
852 if vtmsg, ok := m.LbConfig.(interface{ SizeVT() int }); ok {
853 n += vtmsg.SizeVT()
854 }
855 if m.Metadata != nil {
856 if size, ok := interface{}(m.Metadata).(interface {
857 SizeVT() int
858 }); ok {
859 l = size.SizeVT()
860 } else {
861 l = proto.Size(m.Metadata)
862 }
863 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
864 }
865 n += len(m.unknownFields)
866 return n
867 }
868
869 func (m *LocalityLbEndpoints_LoadBalancerEndpoints) SizeVT() (n int) {
870 if m == nil {
871 return 0
872 }
873 var l int
874 _ = l
875 if m.LoadBalancerEndpoints != nil {
876 l = m.LoadBalancerEndpoints.SizeVT()
877 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
878 } else {
879 n += 2
880 }
881 return n
882 }
883 func (m *LocalityLbEndpoints_LedsClusterLocalityConfig) SizeVT() (n int) {
884 if m == nil {
885 return 0
886 }
887 var l int
888 _ = l
889 if m.LedsClusterLocalityConfig != nil {
890 l = m.LedsClusterLocalityConfig.SizeVT()
891 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
892 } else {
893 n += 2
894 }
895 return n
896 }