Debian Codegraph @

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