Debian Codegraph @

envoy/config/core/v3/protocol_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/protocol.proto
6
7 package corev3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
12 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
13 proto "google.golang.org/protobuf/proto"
14 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
15 )
16
17 const (
18 // Verify that this generated code is sufficiently up-to-date.
19 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
20 // Verify that runtime/protoimpl is sufficiently up-to-date.
21 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
22 )
23
24 func (m *TcpProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
25 if m == nil {
26 return nil, nil
27 }
28 size := m.SizeVT()
29 dAtA = make([]byte, size)
30 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
31 if err != nil {
32 return nil, err
33 }
34 return dAtA[:n], nil
35 }
36
37 func (m *TcpProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
38 size := m.SizeVT()
39 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
40 }
41
42 func (m *TcpProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
43 if m == nil {
44 return 0, nil
45 }
46 i := len(dAtA)
47 _ = i
48 var l int
49 _ = l
50 if m.unknownFields != nil {
51 i -= len(m.unknownFields)
52 copy(dAtA[i:], m.unknownFields)
53 }
54 return len(dAtA) - i, nil
55 }
56
57 func (m *QuicKeepAliveSettings) MarshalVTStrict() (dAtA []byte, err error) {
58 if m == nil {
59 return nil, nil
60 }
61 size := m.SizeVT()
62 dAtA = make([]byte, size)
63 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
64 if err != nil {
65 return nil, err
66 }
67 return dAtA[:n], nil
68 }
69
70 func (m *QuicKeepAliveSettings) MarshalToVTStrict(dAtA []byte) (int, error) {
71 size := m.SizeVT()
72 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
73 }
74
75 func (m *QuicKeepAliveSettings) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
76 if m == nil {
77 return 0, nil
78 }
79 i := len(dAtA)
80 _ = i
81 var l int
82 _ = l
83 if m.unknownFields != nil {
84 i -= len(m.unknownFields)
85 copy(dAtA[i:], m.unknownFields)
86 }
87 if m.InitialInterval != nil {
88 size, err := (*durationpb.Duration)(m.InitialInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
89 if err != nil {
90 return 0, err
91 }
92 i -= size
93 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
94 i--
95 dAtA[i] = 0x12
96 }
97 if m.MaxInterval != nil {
98 size, err := (*durationpb.Duration)(m.MaxInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
99 if err != nil {
100 return 0, err
101 }
102 i -= size
103 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
104 i--
105 dAtA[i] = 0xa
106 }
107 return len(dAtA) - i, nil
108 }
109
110 func (m *QuicProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
111 if m == nil {
112 return nil, nil
113 }
114 size := m.SizeVT()
115 dAtA = make([]byte, size)
116 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
117 if err != nil {
118 return nil, err
119 }
120 return dAtA[:n], nil
121 }
122
123 func (m *QuicProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
124 size := m.SizeVT()
125 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
126 }
127
128 func (m *QuicProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
129 if m == nil {
130 return 0, nil
131 }
132 i := len(dAtA)
133 _ = i
134 var l int
135 _ = l
136 if m.unknownFields != nil {
137 i -= len(m.unknownFields)
138 copy(dAtA[i:], m.unknownFields)
139 }
140 if m.MaxPacketLength != nil {
141 size, err := (*wrapperspb.UInt64Value)(m.MaxPacketLength).MarshalToSizedBufferVTStrict(dAtA[:i])
142 if err != nil {
143 return 0, err
144 }
145 i -= size
146 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
147 i--
148 dAtA[i] = 0x4a
149 }
150 if m.IdleNetworkTimeout != nil {
151 size, err := (*durationpb.Duration)(m.IdleNetworkTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
152 if err != nil {
153 return 0, err
154 }
155 i -= size
156 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
157 i--
158 dAtA[i] = 0x42
159 }
160 if len(m.ClientConnectionOptions) > 0 {
161 i -= len(m.ClientConnectionOptions)
162 copy(dAtA[i:], m.ClientConnectionOptions)
163 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientConnectionOptions)))
164 i--
165 dAtA[i] = 0x3a
166 }
167 if len(m.ConnectionOptions) > 0 {
168 i -= len(m.ConnectionOptions)
169 copy(dAtA[i:], m.ConnectionOptions)
170 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ConnectionOptions)))
171 i--
172 dAtA[i] = 0x32
173 }
174 if m.ConnectionKeepalive != nil {
175 size, err := m.ConnectionKeepalive.MarshalToSizedBufferVTStrict(dAtA[:i])
176 if err != nil {
177 return 0, err
178 }
179 i -= size
180 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
181 i--
182 dAtA[i] = 0x2a
183 }
184 if m.NumTimeoutsToTriggerPortMigration != nil {
185 size, err := (*wrapperspb.UInt32Value)(m.NumTimeoutsToTriggerPortMigration).MarshalToSizedBufferVTStrict(dAtA[:i])
186 if err != nil {
187 return 0, err
188 }
189 i -= size
190 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
191 i--
192 dAtA[i] = 0x22
193 }
194 if m.InitialConnectionWindowSize != nil {
195 size, err := (*wrapperspb.UInt32Value)(m.InitialConnectionWindowSize).MarshalToSizedBufferVTStrict(dAtA[:i])
196 if err != nil {
197 return 0, err
198 }
199 i -= size
200 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
201 i--
202 dAtA[i] = 0x1a
203 }
204 if m.InitialStreamWindowSize != nil {
205 size, err := (*wrapperspb.UInt32Value)(m.InitialStreamWindowSize).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.MaxConcurrentStreams != nil {
215 size, err := (*wrapperspb.UInt32Value)(m.MaxConcurrentStreams).MarshalToSizedBufferVTStrict(dAtA[:i])
216 if err != nil {
217 return 0, err
218 }
219 i -= size
220 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
221 i--
222 dAtA[i] = 0xa
223 }
224 return len(dAtA) - i, nil
225 }
226
227 func (m *UpstreamHttpProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
228 if m == nil {
229 return nil, nil
230 }
231 size := m.SizeVT()
232 dAtA = make([]byte, size)
233 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
234 if err != nil {
235 return nil, err
236 }
237 return dAtA[:n], nil
238 }
239
240 func (m *UpstreamHttpProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
241 size := m.SizeVT()
242 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
243 }
244
245 func (m *UpstreamHttpProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
246 if m == nil {
247 return 0, nil
248 }
249 i := len(dAtA)
250 _ = i
251 var l int
252 _ = l
253 if m.unknownFields != nil {
254 i -= len(m.unknownFields)
255 copy(dAtA[i:], m.unknownFields)
256 }
257 if len(m.OverrideAutoSniHeader) > 0 {
258 i -= len(m.OverrideAutoSniHeader)
259 copy(dAtA[i:], m.OverrideAutoSniHeader)
260 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OverrideAutoSniHeader)))
261 i--
262 dAtA[i] = 0x1a
263 }
264 if m.AutoSanValidation {
265 i--
266 if m.AutoSanValidation {
267 dAtA[i] = 1
268 } else {
269 dAtA[i] = 0
270 }
271 i--
272 dAtA[i] = 0x10
273 }
274 if m.AutoSni {
275 i--
276 if m.AutoSni {
277 dAtA[i] = 1
278 } else {
279 dAtA[i] = 0
280 }
281 i--
282 dAtA[i] = 0x8
283 }
284 return len(dAtA) - i, nil
285 }
286
287 func (m *AlternateProtocolsCacheOptions_AlternateProtocolsCacheEntry) MarshalVTStrict() (dAtA []byte, err error) {
288 if m == nil {
289 return nil, nil
290 }
291 size := m.SizeVT()
292 dAtA = make([]byte, size)
293 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
294 if err != nil {
295 return nil, err
296 }
297 return dAtA[:n], nil
298 }
299
300 func (m *AlternateProtocolsCacheOptions_AlternateProtocolsCacheEntry) MarshalToVTStrict(dAtA []byte) (int, error) {
301 size := m.SizeVT()
302 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
303 }
304
305 func (m *AlternateProtocolsCacheOptions_AlternateProtocolsCacheEntry) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
306 if m == nil {
307 return 0, nil
308 }
309 i := len(dAtA)
310 _ = i
311 var l int
312 _ = l
313 if m.unknownFields != nil {
314 i -= len(m.unknownFields)
315 copy(dAtA[i:], m.unknownFields)
316 }
317 if m.Port != 0 {
318 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Port))
319 i--
320 dAtA[i] = 0x10
321 }
322 if len(m.Hostname) > 0 {
323 i -= len(m.Hostname)
324 copy(dAtA[i:], m.Hostname)
325 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
326 i--
327 dAtA[i] = 0xa
328 }
329 return len(dAtA) - i, nil
330 }
331
332 func (m *AlternateProtocolsCacheOptions) MarshalVTStrict() (dAtA []byte, err error) {
333 if m == nil {
334 return nil, nil
335 }
336 size := m.SizeVT()
337 dAtA = make([]byte, size)
338 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
339 if err != nil {
340 return nil, err
341 }
342 return dAtA[:n], nil
343 }
344
345 func (m *AlternateProtocolsCacheOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
346 size := m.SizeVT()
347 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
348 }
349
350 func (m *AlternateProtocolsCacheOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
351 if m == nil {
352 return 0, nil
353 }
354 i := len(dAtA)
355 _ = i
356 var l int
357 _ = l
358 if m.unknownFields != nil {
359 i -= len(m.unknownFields)
360 copy(dAtA[i:], m.unknownFields)
361 }
362 if len(m.CanonicalSuffixes) > 0 {
363 for iNdEx := len(m.CanonicalSuffixes) - 1; iNdEx >= 0; iNdEx-- {
364 i -= len(m.CanonicalSuffixes[iNdEx])
365 copy(dAtA[i:], m.CanonicalSuffixes[iNdEx])
366 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CanonicalSuffixes[iNdEx])))
367 i--
368 dAtA[i] = 0x2a
369 }
370 }
371 if len(m.PrepopulatedEntries) > 0 {
372 for iNdEx := len(m.PrepopulatedEntries) - 1; iNdEx >= 0; iNdEx-- {
373 size, err := m.PrepopulatedEntries[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
374 if err != nil {
375 return 0, err
376 }
377 i -= size
378 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
379 i--
380 dAtA[i] = 0x22
381 }
382 }
383 if m.KeyValueStoreConfig != nil {
384 size, err := m.KeyValueStoreConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
385 if err != nil {
386 return 0, err
387 }
388 i -= size
389 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
390 i--
391 dAtA[i] = 0x1a
392 }
393 if m.MaxEntries != nil {
394 size, err := (*wrapperspb.UInt32Value)(m.MaxEntries).MarshalToSizedBufferVTStrict(dAtA[:i])
395 if err != nil {
396 return 0, err
397 }
398 i -= size
399 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
400 i--
401 dAtA[i] = 0x12
402 }
403 if len(m.Name) > 0 {
404 i -= len(m.Name)
405 copy(dAtA[i:], m.Name)
406 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
407 i--
408 dAtA[i] = 0xa
409 }
410 return len(dAtA) - i, nil
411 }
412
413 func (m *HttpProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
414 if m == nil {
415 return nil, nil
416 }
417 size := m.SizeVT()
418 dAtA = make([]byte, size)
419 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
420 if err != nil {
421 return nil, err
422 }
423 return dAtA[:n], nil
424 }
425
426 func (m *HttpProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
427 size := m.SizeVT()
428 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
429 }
430
431 func (m *HttpProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
432 if m == nil {
433 return 0, nil
434 }
435 i := len(dAtA)
436 _ = i
437 var l int
438 _ = l
439 if m.unknownFields != nil {
440 i -= len(m.unknownFields)
441 copy(dAtA[i:], m.unknownFields)
442 }
443 if m.MaxResponseHeadersKb != nil {
444 size, err := (*wrapperspb.UInt32Value)(m.MaxResponseHeadersKb).MarshalToSizedBufferVTStrict(dAtA[:i])
445 if err != nil {
446 return 0, err
447 }
448 i -= size
449 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
450 i--
451 dAtA[i] = 0x3a
452 }
453 if m.MaxRequestsPerConnection != nil {
454 size, err := (*wrapperspb.UInt32Value)(m.MaxRequestsPerConnection).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] = 0x32
462 }
463 if m.HeadersWithUnderscoresAction != 0 {
464 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HeadersWithUnderscoresAction))
465 i--
466 dAtA[i] = 0x28
467 }
468 if m.MaxStreamDuration != nil {
469 size, err := (*durationpb.Duration)(m.MaxStreamDuration).MarshalToSizedBufferVTStrict(dAtA[:i])
470 if err != nil {
471 return 0, err
472 }
473 i -= size
474 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
475 i--
476 dAtA[i] = 0x22
477 }
478 if m.MaxConnectionDuration != nil {
479 size, err := (*durationpb.Duration)(m.MaxConnectionDuration).MarshalToSizedBufferVTStrict(dAtA[:i])
480 if err != nil {
481 return 0, err
482 }
483 i -= size
484 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
485 i--
486 dAtA[i] = 0x1a
487 }
488 if m.MaxHeadersCount != nil {
489 size, err := (*wrapperspb.UInt32Value)(m.MaxHeadersCount).MarshalToSizedBufferVTStrict(dAtA[:i])
490 if err != nil {
491 return 0, err
492 }
493 i -= size
494 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
495 i--
496 dAtA[i] = 0x12
497 }
498 if m.IdleTimeout != nil {
499 size, err := (*durationpb.Duration)(m.IdleTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
500 if err != nil {
501 return 0, err
502 }
503 i -= size
504 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
505 i--
506 dAtA[i] = 0xa
507 }
508 return len(dAtA) - i, nil
509 }
510
511 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords) MarshalVTStrict() (dAtA []byte, err error) {
512 if m == nil {
513 return nil, nil
514 }
515 size := m.SizeVT()
516 dAtA = make([]byte, size)
517 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
518 if err != nil {
519 return nil, err
520 }
521 return dAtA[:n], nil
522 }
523
524 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords) MarshalToVTStrict(dAtA []byte) (int, error) {
525 size := m.SizeVT()
526 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
527 }
528
529 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
530 if m == nil {
531 return 0, nil
532 }
533 i := len(dAtA)
534 _ = i
535 var l int
536 _ = l
537 if m.unknownFields != nil {
538 i -= len(m.unknownFields)
539 copy(dAtA[i:], m.unknownFields)
540 }
541 return len(dAtA) - i, nil
542 }
543
544 func (m *Http1ProtocolOptions_HeaderKeyFormat) MarshalVTStrict() (dAtA []byte, err error) {
545 if m == nil {
546 return nil, nil
547 }
548 size := m.SizeVT()
549 dAtA = make([]byte, size)
550 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
551 if err != nil {
552 return nil, err
553 }
554 return dAtA[:n], nil
555 }
556
557 func (m *Http1ProtocolOptions_HeaderKeyFormat) MarshalToVTStrict(dAtA []byte) (int, error) {
558 size := m.SizeVT()
559 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
560 }
561
562 func (m *Http1ProtocolOptions_HeaderKeyFormat) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
563 if m == nil {
564 return 0, nil
565 }
566 i := len(dAtA)
567 _ = i
568 var l int
569 _ = l
570 if m.unknownFields != nil {
571 i -= len(m.unknownFields)
572 copy(dAtA[i:], m.unknownFields)
573 }
574 if msg, ok := m.HeaderFormat.(*Http1ProtocolOptions_HeaderKeyFormat_StatefulFormatter); ok {
575 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
576 if err != nil {
577 return 0, err
578 }
579 i -= size
580 }
581 if msg, ok := m.HeaderFormat.(*Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords_); ok {
582 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
583 if err != nil {
584 return 0, err
585 }
586 i -= size
587 }
588 return len(dAtA) - i, nil
589 }
590
591 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords_) MarshalToVTStrict(dAtA []byte) (int, error) {
592 size := m.SizeVT()
593 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
594 }
595
596 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
597 i := len(dAtA)
598 if m.ProperCaseWords != nil {
599 size, err := m.ProperCaseWords.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] = 0xa
607 } else {
608 i = protohelpers.EncodeVarint(dAtA, i, 0)
609 i--
610 dAtA[i] = 0xa
611 }
612 return len(dAtA) - i, nil
613 }
614 func (m *Http1ProtocolOptions_HeaderKeyFormat_StatefulFormatter) MarshalToVTStrict(dAtA []byte) (int, error) {
615 size := m.SizeVT()
616 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
617 }
618
619 func (m *Http1ProtocolOptions_HeaderKeyFormat_StatefulFormatter) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
620 i := len(dAtA)
621 if m.StatefulFormatter != nil {
622 size, err := m.StatefulFormatter.MarshalToSizedBufferVTStrict(dAtA[:i])
623 if err != nil {
624 return 0, err
625 }
626 i -= size
627 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
628 i--
629 dAtA[i] = 0x42
630 } else {
631 i = protohelpers.EncodeVarint(dAtA, i, 0)
632 i--
633 dAtA[i] = 0x42
634 }
635 return len(dAtA) - i, nil
636 }
637 func (m *Http1ProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
638 if m == nil {
639 return nil, nil
640 }
641 size := m.SizeVT()
642 dAtA = make([]byte, size)
643 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
644 if err != nil {
645 return nil, err
646 }
647 return dAtA[:n], nil
648 }
649
650 func (m *Http1ProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
651 size := m.SizeVT()
652 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
653 }
654
655 func (m *Http1ProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
656 if m == nil {
657 return 0, nil
658 }
659 i := len(dAtA)
660 _ = i
661 var l int
662 _ = l
663 if m.unknownFields != nil {
664 i -= len(m.unknownFields)
665 copy(dAtA[i:], m.unknownFields)
666 }
667 if m.AllowCustomMethods {
668 i--
669 if m.AllowCustomMethods {
670 dAtA[i] = 1
671 } else {
672 dAtA[i] = 0
673 }
674 i--
675 dAtA[i] = 0x50
676 }
677 if m.UseBalsaParser != nil {
678 size, err := (*wrapperspb.BoolValue)(m.UseBalsaParser).MarshalToSizedBufferVTStrict(dAtA[:i])
679 if err != nil {
680 return 0, err
681 }
682 i -= size
683 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
684 i--
685 dAtA[i] = 0x4a
686 }
687 if m.SendFullyQualifiedUrl {
688 i--
689 if m.SendFullyQualifiedUrl {
690 dAtA[i] = 1
691 } else {
692 dAtA[i] = 0
693 }
694 i--
695 dAtA[i] = 0x40
696 }
697 if m.OverrideStreamErrorOnInvalidHttpMessage != nil {
698 size, err := (*wrapperspb.BoolValue)(m.OverrideStreamErrorOnInvalidHttpMessage).MarshalToSizedBufferVTStrict(dAtA[:i])
699 if err != nil {
700 return 0, err
701 }
702 i -= size
703 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
704 i--
705 dAtA[i] = 0x3a
706 }
707 if m.AllowChunkedLength {
708 i--
709 if m.AllowChunkedLength {
710 dAtA[i] = 1
711 } else {
712 dAtA[i] = 0
713 }
714 i--
715 dAtA[i] = 0x30
716 }
717 if m.EnableTrailers {
718 i--
719 if m.EnableTrailers {
720 dAtA[i] = 1
721 } else {
722 dAtA[i] = 0
723 }
724 i--
725 dAtA[i] = 0x28
726 }
727 if m.HeaderKeyFormat != nil {
728 size, err := m.HeaderKeyFormat.MarshalToSizedBufferVTStrict(dAtA[:i])
729 if err != nil {
730 return 0, err
731 }
732 i -= size
733 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
734 i--
735 dAtA[i] = 0x22
736 }
737 if len(m.DefaultHostForHttp_10) > 0 {
738 i -= len(m.DefaultHostForHttp_10)
739 copy(dAtA[i:], m.DefaultHostForHttp_10)
740 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultHostForHttp_10)))
741 i--
742 dAtA[i] = 0x1a
743 }
744 if m.AcceptHttp_10 {
745 i--
746 if m.AcceptHttp_10 {
747 dAtA[i] = 1
748 } else {
749 dAtA[i] = 0
750 }
751 i--
752 dAtA[i] = 0x10
753 }
754 if m.AllowAbsoluteUrl != nil {
755 size, err := (*wrapperspb.BoolValue)(m.AllowAbsoluteUrl).MarshalToSizedBufferVTStrict(dAtA[:i])
756 if err != nil {
757 return 0, err
758 }
759 i -= size
760 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
761 i--
762 dAtA[i] = 0xa
763 }
764 return len(dAtA) - i, nil
765 }
766
767 func (m *KeepaliveSettings) MarshalVTStrict() (dAtA []byte, err error) {
768 if m == nil {
769 return nil, nil
770 }
771 size := m.SizeVT()
772 dAtA = make([]byte, size)
773 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
774 if err != nil {
775 return nil, err
776 }
777 return dAtA[:n], nil
778 }
779
780 func (m *KeepaliveSettings) MarshalToVTStrict(dAtA []byte) (int, error) {
781 size := m.SizeVT()
782 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
783 }
784
785 func (m *KeepaliveSettings) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
786 if m == nil {
787 return 0, nil
788 }
789 i := len(dAtA)
790 _ = i
791 var l int
792 _ = l
793 if m.unknownFields != nil {
794 i -= len(m.unknownFields)
795 copy(dAtA[i:], m.unknownFields)
796 }
797 if m.ConnectionIdleInterval != nil {
798 size, err := (*durationpb.Duration)(m.ConnectionIdleInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
799 if err != nil {
800 return 0, err
801 }
802 i -= size
803 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
804 i--
805 dAtA[i] = 0x22
806 }
807 if m.IntervalJitter != nil {
808 if vtmsg, ok := interface{}(m.IntervalJitter).(interface {
809 MarshalToSizedBufferVTStrict([]byte) (int, error)
810 }); ok {
811 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
812 if err != nil {
813 return 0, err
814 }
815 i -= size
816 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
817 } else {
818 encoded, err := proto.Marshal(m.IntervalJitter)
819 if err != nil {
820 return 0, err
821 }
822 i -= len(encoded)
823 copy(dAtA[i:], encoded)
824 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
825 }
826 i--
827 dAtA[i] = 0x1a
828 }
829 if m.Timeout != nil {
830 size, err := (*durationpb.Duration)(m.Timeout).MarshalToSizedBufferVTStrict(dAtA[:i])
831 if err != nil {
832 return 0, err
833 }
834 i -= size
835 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
836 i--
837 dAtA[i] = 0x12
838 }
839 if m.Interval != nil {
840 size, err := (*durationpb.Duration)(m.Interval).MarshalToSizedBufferVTStrict(dAtA[:i])
841 if err != nil {
842 return 0, err
843 }
844 i -= size
845 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
846 i--
847 dAtA[i] = 0xa
848 }
849 return len(dAtA) - i, nil
850 }
851
852 func (m *Http2ProtocolOptions_SettingsParameter) MarshalVTStrict() (dAtA []byte, err error) {
853 if m == nil {
854 return nil, nil
855 }
856 size := m.SizeVT()
857 dAtA = make([]byte, size)
858 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
859 if err != nil {
860 return nil, err
861 }
862 return dAtA[:n], nil
863 }
864
865 func (m *Http2ProtocolOptions_SettingsParameter) MarshalToVTStrict(dAtA []byte) (int, error) {
866 size := m.SizeVT()
867 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
868 }
869
870 func (m *Http2ProtocolOptions_SettingsParameter) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
871 if m == nil {
872 return 0, nil
873 }
874 i := len(dAtA)
875 _ = i
876 var l int
877 _ = l
878 if m.unknownFields != nil {
879 i -= len(m.unknownFields)
880 copy(dAtA[i:], m.unknownFields)
881 }
882 if m.Value != nil {
883 size, err := (*wrapperspb.UInt32Value)(m.Value).MarshalToSizedBufferVTStrict(dAtA[:i])
884 if err != nil {
885 return 0, err
886 }
887 i -= size
888 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
889 i--
890 dAtA[i] = 0x12
891 }
892 if m.Identifier != nil {
893 size, err := (*wrapperspb.UInt32Value)(m.Identifier).MarshalToSizedBufferVTStrict(dAtA[:i])
894 if err != nil {
895 return 0, err
896 }
897 i -= size
898 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
899 i--
900 dAtA[i] = 0xa
901 }
902 return len(dAtA) - i, nil
903 }
904
905 func (m *Http2ProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
906 if m == nil {
907 return nil, nil
908 }
909 size := m.SizeVT()
910 dAtA = make([]byte, size)
911 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
912 if err != nil {
913 return nil, err
914 }
915 return dAtA[:n], nil
916 }
917
918 func (m *Http2ProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
919 size := m.SizeVT()
920 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
921 }
922
923 func (m *Http2ProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
924 if m == nil {
925 return 0, nil
926 }
927 i := len(dAtA)
928 _ = i
929 var l int
930 _ = l
931 if m.unknownFields != nil {
932 i -= len(m.unknownFields)
933 copy(dAtA[i:], m.unknownFields)
934 }
935 if m.UseOghttp2Codec != nil {
936 size, err := (*wrapperspb.BoolValue)(m.UseOghttp2Codec).MarshalToSizedBufferVTStrict(dAtA[:i])
937 if err != nil {
938 return 0, err
939 }
940 i -= size
941 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
942 i--
943 dAtA[i] = 0x1
944 i--
945 dAtA[i] = 0x82
946 }
947 if m.ConnectionKeepalive != nil {
948 size, err := m.ConnectionKeepalive.MarshalToSizedBufferVTStrict(dAtA[:i])
949 if err != nil {
950 return 0, err
951 }
952 i -= size
953 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
954 i--
955 dAtA[i] = 0x7a
956 }
957 if m.OverrideStreamErrorOnInvalidHttpMessage != nil {
958 size, err := (*wrapperspb.BoolValue)(m.OverrideStreamErrorOnInvalidHttpMessage).MarshalToSizedBufferVTStrict(dAtA[:i])
959 if err != nil {
960 return 0, err
961 }
962 i -= size
963 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
964 i--
965 dAtA[i] = 0x72
966 }
967 if len(m.CustomSettingsParameters) > 0 {
968 for iNdEx := len(m.CustomSettingsParameters) - 1; iNdEx >= 0; iNdEx-- {
969 size, err := m.CustomSettingsParameters[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
970 if err != nil {
971 return 0, err
972 }
973 i -= size
974 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
975 i--
976 dAtA[i] = 0x6a
977 }
978 }
979 if m.StreamErrorOnInvalidHttpMessaging {
980 i--
981 if m.StreamErrorOnInvalidHttpMessaging {
982 dAtA[i] = 1
983 } else {
984 dAtA[i] = 0
985 }
986 i--
987 dAtA[i] = 0x60
988 }
989 if m.MaxInboundWindowUpdateFramesPerDataFrameSent != nil {
990 size, err := (*wrapperspb.UInt32Value)(m.MaxInboundWindowUpdateFramesPerDataFrameSent).MarshalToSizedBufferVTStrict(dAtA[:i])
991 if err != nil {
992 return 0, err
993 }
994 i -= size
995 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
996 i--
997 dAtA[i] = 0x5a
998 }
999 if m.MaxInboundPriorityFramesPerStream != nil {
1000 size, err := (*wrapperspb.UInt32Value)(m.MaxInboundPriorityFramesPerStream).MarshalToSizedBufferVTStrict(dAtA[:i])
1001 if err != nil {
1002 return 0, err
1003 }
1004 i -= size
1005 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1006 i--
1007 dAtA[i] = 0x52
1008 }
1009 if m.MaxConsecutiveInboundFramesWithEmptyPayload != nil {
1010 size, err := (*wrapperspb.UInt32Value)(m.MaxConsecutiveInboundFramesWithEmptyPayload).MarshalToSizedBufferVTStrict(dAtA[:i])
1011 if err != nil {
1012 return 0, err
1013 }
1014 i -= size
1015 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1016 i--
1017 dAtA[i] = 0x4a
1018 }
1019 if m.MaxOutboundControlFrames != nil {
1020 size, err := (*wrapperspb.UInt32Value)(m.MaxOutboundControlFrames).MarshalToSizedBufferVTStrict(dAtA[:i])
1021 if err != nil {
1022 return 0, err
1023 }
1024 i -= size
1025 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1026 i--
1027 dAtA[i] = 0x42
1028 }
1029 if m.MaxOutboundFrames != nil {
1030 size, err := (*wrapperspb.UInt32Value)(m.MaxOutboundFrames).MarshalToSizedBufferVTStrict(dAtA[:i])
1031 if err != nil {
1032 return 0, err
1033 }
1034 i -= size
1035 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1036 i--
1037 dAtA[i] = 0x3a
1038 }
1039 if m.AllowMetadata {
1040 i--
1041 if m.AllowMetadata {
1042 dAtA[i] = 1
1043 } else {
1044 dAtA[i] = 0
1045 }
1046 i--
1047 dAtA[i] = 0x30
1048 }
1049 if m.AllowConnect {
1050 i--
1051 if m.AllowConnect {
1052 dAtA[i] = 1
1053 } else {
1054 dAtA[i] = 0
1055 }
1056 i--
1057 dAtA[i] = 0x28
1058 }
1059 if m.InitialConnectionWindowSize != nil {
1060 size, err := (*wrapperspb.UInt32Value)(m.InitialConnectionWindowSize).MarshalToSizedBufferVTStrict(dAtA[:i])
1061 if err != nil {
1062 return 0, err
1063 }
1064 i -= size
1065 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1066 i--
1067 dAtA[i] = 0x22
1068 }
1069 if m.InitialStreamWindowSize != nil {
1070 size, err := (*wrapperspb.UInt32Value)(m.InitialStreamWindowSize).MarshalToSizedBufferVTStrict(dAtA[:i])
1071 if err != nil {
1072 return 0, err
1073 }
1074 i -= size
1075 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1076 i--
1077 dAtA[i] = 0x1a
1078 }
1079 if m.MaxConcurrentStreams != nil {
1080 size, err := (*wrapperspb.UInt32Value)(m.MaxConcurrentStreams).MarshalToSizedBufferVTStrict(dAtA[:i])
1081 if err != nil {
1082 return 0, err
1083 }
1084 i -= size
1085 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1086 i--
1087 dAtA[i] = 0x12
1088 }
1089 if m.HpackTableSize != nil {
1090 size, err := (*wrapperspb.UInt32Value)(m.HpackTableSize).MarshalToSizedBufferVTStrict(dAtA[:i])
1091 if err != nil {
1092 return 0, err
1093 }
1094 i -= size
1095 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1096 i--
1097 dAtA[i] = 0xa
1098 }
1099 return len(dAtA) - i, nil
1100 }
1101
1102 func (m *GrpcProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
1103 if m == nil {
1104 return nil, nil
1105 }
1106 size := m.SizeVT()
1107 dAtA = make([]byte, size)
1108 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1109 if err != nil {
1110 return nil, err
1111 }
1112 return dAtA[:n], nil
1113 }
1114
1115 func (m *GrpcProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
1116 size := m.SizeVT()
1117 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1118 }
1119
1120 func (m *GrpcProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1121 if m == nil {
1122 return 0, nil
1123 }
1124 i := len(dAtA)
1125 _ = i
1126 var l int
1127 _ = l
1128 if m.unknownFields != nil {
1129 i -= len(m.unknownFields)
1130 copy(dAtA[i:], m.unknownFields)
1131 }
1132 if m.Http2ProtocolOptions != nil {
1133 size, err := m.Http2ProtocolOptions.MarshalToSizedBufferVTStrict(dAtA[:i])
1134 if err != nil {
1135 return 0, err
1136 }
1137 i -= size
1138 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1139 i--
1140 dAtA[i] = 0xa
1141 }
1142 return len(dAtA) - i, nil
1143 }
1144
1145 func (m *Http3ProtocolOptions) MarshalVTStrict() (dAtA []byte, err error) {
1146 if m == nil {
1147 return nil, nil
1148 }
1149 size := m.SizeVT()
1150 dAtA = make([]byte, size)
1151 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1152 if err != nil {
1153 return nil, err
1154 }
1155 return dAtA[:n], nil
1156 }
1157
1158 func (m *Http3ProtocolOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
1159 size := m.SizeVT()
1160 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1161 }
1162
1163 func (m *Http3ProtocolOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1164 if m == nil {
1165 return 0, nil
1166 }
1167 i := len(dAtA)
1168 _ = i
1169 var l int
1170 _ = l
1171 if m.unknownFields != nil {
1172 i -= len(m.unknownFields)
1173 copy(dAtA[i:], m.unknownFields)
1174 }
1175 if m.AllowMetadata {
1176 i--
1177 if m.AllowMetadata {
1178 dAtA[i] = 1
1179 } else {
1180 dAtA[i] = 0
1181 }
1182 i--
1183 dAtA[i] = 0x30
1184 }
1185 if m.AllowExtendedConnect {
1186 i--
1187 if m.AllowExtendedConnect {
1188 dAtA[i] = 1
1189 } else {
1190 dAtA[i] = 0
1191 }
1192 i--
1193 dAtA[i] = 0x28
1194 }
1195 if m.OverrideStreamErrorOnInvalidHttpMessage != nil {
1196 size, err := (*wrapperspb.BoolValue)(m.OverrideStreamErrorOnInvalidHttpMessage).MarshalToSizedBufferVTStrict(dAtA[:i])
1197 if err != nil {
1198 return 0, err
1199 }
1200 i -= size
1201 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1202 i--
1203 dAtA[i] = 0x12
1204 }
1205 if m.QuicProtocolOptions != nil {
1206 size, err := m.QuicProtocolOptions.MarshalToSizedBufferVTStrict(dAtA[:i])
1207 if err != nil {
1208 return 0, err
1209 }
1210 i -= size
1211 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1212 i--
1213 dAtA[i] = 0xa
1214 }
1215 return len(dAtA) - i, nil
1216 }
1217
1218 func (m *SchemeHeaderTransformation) MarshalVTStrict() (dAtA []byte, err error) {
1219 if m == nil {
1220 return nil, nil
1221 }
1222 size := m.SizeVT()
1223 dAtA = make([]byte, size)
1224 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1225 if err != nil {
1226 return nil, err
1227 }
1228 return dAtA[:n], nil
1229 }
1230
1231 func (m *SchemeHeaderTransformation) MarshalToVTStrict(dAtA []byte) (int, error) {
1232 size := m.SizeVT()
1233 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1234 }
1235
1236 func (m *SchemeHeaderTransformation) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1237 if m == nil {
1238 return 0, nil
1239 }
1240 i := len(dAtA)
1241 _ = i
1242 var l int
1243 _ = l
1244 if m.unknownFields != nil {
1245 i -= len(m.unknownFields)
1246 copy(dAtA[i:], m.unknownFields)
1247 }
1248 if m.MatchUpstream {
1249 i--
1250 if m.MatchUpstream {
1251 dAtA[i] = 1
1252 } else {
1253 dAtA[i] = 0
1254 }
1255 i--
1256 dAtA[i] = 0x10
1257 }
1258 if msg, ok := m.Transformation.(*SchemeHeaderTransformation_SchemeToOverwrite); ok {
1259 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1260 if err != nil {
1261 return 0, err
1262 }
1263 i -= size
1264 }
1265 return len(dAtA) - i, nil
1266 }
1267
1268 func (m *SchemeHeaderTransformation_SchemeToOverwrite) MarshalToVTStrict(dAtA []byte) (int, error) {
1269 size := m.SizeVT()
1270 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1271 }
1272
1273 func (m *SchemeHeaderTransformation_SchemeToOverwrite) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1274 i := len(dAtA)
1275 i -= len(m.SchemeToOverwrite)
1276 copy(dAtA[i:], m.SchemeToOverwrite)
1277 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SchemeToOverwrite)))
1278 i--
1279 dAtA[i] = 0xa
1280 return len(dAtA) - i, nil
1281 }
1282 func (m *TcpProtocolOptions) SizeVT() (n int) {
1283 if m == nil {
1284 return 0
1285 }
1286 var l int
1287 _ = l
1288 n += len(m.unknownFields)
1289 return n
1290 }
1291
1292 func (m *QuicKeepAliveSettings) SizeVT() (n int) {
1293 if m == nil {
1294 return 0
1295 }
1296 var l int
1297 _ = l
1298 if m.MaxInterval != nil {
1299 l = (*durationpb.Duration)(m.MaxInterval).SizeVT()
1300 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1301 }
1302 if m.InitialInterval != nil {
1303 l = (*durationpb.Duration)(m.InitialInterval).SizeVT()
1304 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1305 }
1306 n += len(m.unknownFields)
1307 return n
1308 }
1309
1310 func (m *QuicProtocolOptions) SizeVT() (n int) {
1311 if m == nil {
1312 return 0
1313 }
1314 var l int
1315 _ = l
1316 if m.MaxConcurrentStreams != nil {
1317 l = (*wrapperspb.UInt32Value)(m.MaxConcurrentStreams).SizeVT()
1318 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1319 }
1320 if m.InitialStreamWindowSize != nil {
1321 l = (*wrapperspb.UInt32Value)(m.InitialStreamWindowSize).SizeVT()
1322 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1323 }
1324 if m.InitialConnectionWindowSize != nil {
1325 l = (*wrapperspb.UInt32Value)(m.InitialConnectionWindowSize).SizeVT()
1326 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1327 }
1328 if m.NumTimeoutsToTriggerPortMigration != nil {
1329 l = (*wrapperspb.UInt32Value)(m.NumTimeoutsToTriggerPortMigration).SizeVT()
1330 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1331 }
1332 if m.ConnectionKeepalive != nil {
1333 l = m.ConnectionKeepalive.SizeVT()
1334 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1335 }
1336 l = len(m.ConnectionOptions)
1337 if l > 0 {
1338 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1339 }
1340 l = len(m.ClientConnectionOptions)
1341 if l > 0 {
1342 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1343 }
1344 if m.IdleNetworkTimeout != nil {
1345 l = (*durationpb.Duration)(m.IdleNetworkTimeout).SizeVT()
1346 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1347 }
1348 if m.MaxPacketLength != nil {
1349 l = (*wrapperspb.UInt64Value)(m.MaxPacketLength).SizeVT()
1350 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1351 }
1352 n += len(m.unknownFields)
1353 return n
1354 }
1355
1356 func (m *UpstreamHttpProtocolOptions) SizeVT() (n int) {
1357 if m == nil {
1358 return 0
1359 }
1360 var l int
1361 _ = l
1362 if m.AutoSni {
1363 n += 2
1364 }
1365 if m.AutoSanValidation {
1366 n += 2
1367 }
1368 l = len(m.OverrideAutoSniHeader)
1369 if l > 0 {
1370 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1371 }
1372 n += len(m.unknownFields)
1373 return n
1374 }
1375
1376 func (m *AlternateProtocolsCacheOptions_AlternateProtocolsCacheEntry) SizeVT() (n int) {
1377 if m == nil {
1378 return 0
1379 }
1380 var l int
1381 _ = l
1382 l = len(m.Hostname)
1383 if l > 0 {
1384 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1385 }
1386 if m.Port != 0 {
1387 n += 1 + protohelpers.SizeOfVarint(uint64(m.Port))
1388 }
1389 n += len(m.unknownFields)
1390 return n
1391 }
1392
1393 func (m *AlternateProtocolsCacheOptions) SizeVT() (n int) {
1394 if m == nil {
1395 return 0
1396 }
1397 var l int
1398 _ = l
1399 l = len(m.Name)
1400 if l > 0 {
1401 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1402 }
1403 if m.MaxEntries != nil {
1404 l = (*wrapperspb.UInt32Value)(m.MaxEntries).SizeVT()
1405 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1406 }
1407 if m.KeyValueStoreConfig != nil {
1408 l = m.KeyValueStoreConfig.SizeVT()
1409 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1410 }
1411 if len(m.PrepopulatedEntries) > 0 {
1412 for _, e := range m.PrepopulatedEntries {
1413 l = e.SizeVT()
1414 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1415 }
1416 }
1417 if len(m.CanonicalSuffixes) > 0 {
1418 for _, s := range m.CanonicalSuffixes {
1419 l = len(s)
1420 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1421 }
1422 }
1423 n += len(m.unknownFields)
1424 return n
1425 }
1426
1427 func (m *HttpProtocolOptions) SizeVT() (n int) {
1428 if m == nil {
1429 return 0
1430 }
1431 var l int
1432 _ = l
1433 if m.IdleTimeout != nil {
1434 l = (*durationpb.Duration)(m.IdleTimeout).SizeVT()
1435 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1436 }
1437 if m.MaxHeadersCount != nil {
1438 l = (*wrapperspb.UInt32Value)(m.MaxHeadersCount).SizeVT()
1439 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1440 }
1441 if m.MaxConnectionDuration != nil {
1442 l = (*durationpb.Duration)(m.MaxConnectionDuration).SizeVT()
1443 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1444 }
1445 if m.MaxStreamDuration != nil {
1446 l = (*durationpb.Duration)(m.MaxStreamDuration).SizeVT()
1447 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1448 }
1449 if m.HeadersWithUnderscoresAction != 0 {
1450 n += 1 + protohelpers.SizeOfVarint(uint64(m.HeadersWithUnderscoresAction))
1451 }
1452 if m.MaxRequestsPerConnection != nil {
1453 l = (*wrapperspb.UInt32Value)(m.MaxRequestsPerConnection).SizeVT()
1454 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1455 }
1456 if m.MaxResponseHeadersKb != nil {
1457 l = (*wrapperspb.UInt32Value)(m.MaxResponseHeadersKb).SizeVT()
1458 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1459 }
1460 n += len(m.unknownFields)
1461 return n
1462 }
1463
1464 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords) SizeVT() (n int) {
1465 if m == nil {
1466 return 0
1467 }
1468 var l int
1469 _ = l
1470 n += len(m.unknownFields)
1471 return n
1472 }
1473
1474 func (m *Http1ProtocolOptions_HeaderKeyFormat) SizeVT() (n int) {
1475 if m == nil {
1476 return 0
1477 }
1478 var l int
1479 _ = l
1480 if vtmsg, ok := m.HeaderFormat.(interface{ SizeVT() int }); ok {
1481 n += vtmsg.SizeVT()
1482 }
1483 n += len(m.unknownFields)
1484 return n
1485 }
1486
1487 func (m *Http1ProtocolOptions_HeaderKeyFormat_ProperCaseWords_) SizeVT() (n int) {
1488 if m == nil {
1489 return 0
1490 }
1491 var l int
1492 _ = l
1493 if m.ProperCaseWords != nil {
1494 l = m.ProperCaseWords.SizeVT()
1495 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1496 } else {
1497 n += 2
1498 }
1499 return n
1500 }
1501 func (m *Http1ProtocolOptions_HeaderKeyFormat_StatefulFormatter) SizeVT() (n int) {
1502 if m == nil {
1503 return 0
1504 }
1505 var l int
1506 _ = l
1507 if m.StatefulFormatter != nil {
1508 l = m.StatefulFormatter.SizeVT()
1509 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1510 } else {
1511 n += 2
1512 }
1513 return n
1514 }
1515 func (m *Http1ProtocolOptions) SizeVT() (n int) {
1516 if m == nil {
1517 return 0
1518 }
1519 var l int
1520 _ = l
1521 if m.AllowAbsoluteUrl != nil {
1522 l = (*wrapperspb.BoolValue)(m.AllowAbsoluteUrl).SizeVT()
1523 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1524 }
1525 if m.AcceptHttp_10 {
1526 n += 2
1527 }
1528 l = len(m.DefaultHostForHttp_10)
1529 if l > 0 {
1530 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1531 }
1532 if m.HeaderKeyFormat != nil {
1533 l = m.HeaderKeyFormat.SizeVT()
1534 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1535 }
1536 if m.EnableTrailers {
1537 n += 2
1538 }
1539 if m.AllowChunkedLength {
1540 n += 2
1541 }
1542 if m.OverrideStreamErrorOnInvalidHttpMessage != nil {
1543 l = (*wrapperspb.BoolValue)(m.OverrideStreamErrorOnInvalidHttpMessage).SizeVT()
1544 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1545 }
1546 if m.SendFullyQualifiedUrl {
1547 n += 2
1548 }
1549 if m.UseBalsaParser != nil {
1550 l = (*wrapperspb.BoolValue)(m.UseBalsaParser).SizeVT()
1551 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1552 }
1553 if m.AllowCustomMethods {
1554 n += 2
1555 }
1556 n += len(m.unknownFields)
1557 return n
1558 }
1559
1560 func (m *KeepaliveSettings) SizeVT() (n int) {
1561 if m == nil {
1562 return 0
1563 }
1564 var l int
1565 _ = l
1566 if m.Interval != nil {
1567 l = (*durationpb.Duration)(m.Interval).SizeVT()
1568 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1569 }
1570 if m.Timeout != nil {
1571 l = (*durationpb.Duration)(m.Timeout).SizeVT()
1572 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1573 }
1574 if m.IntervalJitter != nil {
1575 if size, ok := interface{}(m.IntervalJitter).(interface {
1576 SizeVT() int
1577 }); ok {
1578 l = size.SizeVT()
1579 } else {
1580 l = proto.Size(m.IntervalJitter)
1581 }
1582 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1583 }
1584 if m.ConnectionIdleInterval != nil {
1585 l = (*durationpb.Duration)(m.ConnectionIdleInterval).SizeVT()
1586 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1587 }
1588 n += len(m.unknownFields)
1589 return n
1590 }
1591
1592 func (m *Http2ProtocolOptions_SettingsParameter) SizeVT() (n int) {
1593 if m == nil {
1594 return 0
1595 }
1596 var l int
1597 _ = l
1598 if m.Identifier != nil {
1599 l = (*wrapperspb.UInt32Value)(m.Identifier).SizeVT()
1600 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1601 }
1602 if m.Value != nil {
1603 l = (*wrapperspb.UInt32Value)(m.Value).SizeVT()
1604 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1605 }
1606 n += len(m.unknownFields)
1607 return n
1608 }
1609
1610 func (m *Http2ProtocolOptions) SizeVT() (n int) {
1611 if m == nil {
1612 return 0
1613 }
1614 var l int
1615 _ = l
1616 if m.HpackTableSize != nil {
1617 l = (*wrapperspb.UInt32Value)(m.HpackTableSize).SizeVT()
1618 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1619 }
1620 if m.MaxConcurrentStreams != nil {
1621 l = (*wrapperspb.UInt32Value)(m.MaxConcurrentStreams).SizeVT()
1622 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1623 }
1624 if m.InitialStreamWindowSize != nil {
1625 l = (*wrapperspb.UInt32Value)(m.InitialStreamWindowSize).SizeVT()
1626 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1627 }
1628 if m.InitialConnectionWindowSize != nil {
1629 l = (*wrapperspb.UInt32Value)(m.InitialConnectionWindowSize).SizeVT()
1630 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1631 }
1632 if m.AllowConnect {
1633 n += 2
1634 }
1635 if m.AllowMetadata {
1636 n += 2
1637 }
1638 if m.MaxOutboundFrames != nil {
1639 l = (*wrapperspb.UInt32Value)(m.MaxOutboundFrames).SizeVT()
1640 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1641 }
1642 if m.MaxOutboundControlFrames != nil {
1643 l = (*wrapperspb.UInt32Value)(m.MaxOutboundControlFrames).SizeVT()
1644 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1645 }
1646 if m.MaxConsecutiveInboundFramesWithEmptyPayload != nil {
1647 l = (*wrapperspb.UInt32Value)(m.MaxConsecutiveInboundFramesWithEmptyPayload).SizeVT()
1648 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1649 }
1650 if m.MaxInboundPriorityFramesPerStream != nil {
1651 l = (*wrapperspb.UInt32Value)(m.MaxInboundPriorityFramesPerStream).SizeVT()
1652 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1653 }
1654 if m.MaxInboundWindowUpdateFramesPerDataFrameSent != nil {
1655 l = (*wrapperspb.UInt32Value)(m.MaxInboundWindowUpdateFramesPerDataFrameSent).SizeVT()
1656 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1657 }
1658 if m.StreamErrorOnInvalidHttpMessaging {
1659 n += 2
1660 }
1661 if len(m.CustomSettingsParameters) > 0 {
1662 for _, e := range m.CustomSettingsParameters {
1663 l = e.SizeVT()
1664 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1665 }
1666 }
1667 if m.OverrideStreamErrorOnInvalidHttpMessage != nil {
1668 l = (*wrapperspb.BoolValue)(m.OverrideStreamErrorOnInvalidHttpMessage).SizeVT()
1669 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1670 }
1671 if m.ConnectionKeepalive != nil {
1672 l = m.ConnectionKeepalive.SizeVT()
1673 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1674 }
1675 if m.UseOghttp2Codec != nil {
1676 l = (*wrapperspb.BoolValue)(m.UseOghttp2Codec).SizeVT()
1677 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
1678 }
1679 n += len(m.unknownFields)
1680 return n
1681 }
1682
1683 func (m *GrpcProtocolOptions) SizeVT() (n int) {
1684 if m == nil {
1685 return 0
1686 }
1687 var l int
1688 _ = l
1689 if m.Http2ProtocolOptions != nil {
1690 l = m.Http2ProtocolOptions.SizeVT()
1691 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1692 }
1693 n += len(m.unknownFields)
1694 return n
1695 }
1696
1697 func (m *Http3ProtocolOptions) SizeVT() (n int) {
1698 if m == nil {
1699 return 0
1700 }
1701 var l int
1702 _ = l
1703 if m.QuicProtocolOptions != nil {
1704 l = m.QuicProtocolOptions.SizeVT()
1705 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1706 }
1707 if m.OverrideStreamErrorOnInvalidHttpMessage != nil {
1708 l = (*wrapperspb.BoolValue)(m.OverrideStreamErrorOnInvalidHttpMessage).SizeVT()
1709 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1710 }
1711 if m.AllowExtendedConnect {
1712 n += 2
1713 }
1714 if m.AllowMetadata {
1715 n += 2
1716 }
1717 n += len(m.unknownFields)
1718 return n
1719 }
1720
1721 func (m *SchemeHeaderTransformation) SizeVT() (n int) {
1722 if m == nil {
1723 return 0
1724 }
1725 var l int
1726 _ = l
1727 if vtmsg, ok := m.Transformation.(interface{ SizeVT() int }); ok {
1728 n += vtmsg.SizeVT()
1729 }
1730 if m.MatchUpstream {
1731 n += 2
1732 }
1733 n += len(m.unknownFields)
1734 return n
1735 }
1736
1737 func (m *SchemeHeaderTransformation_SchemeToOverwrite) SizeVT() (n int) {
1738 if m == nil {
1739 return 0
1740 }
1741 var l int
1742 _ = l
1743 l = len(m.SchemeToOverwrite)
1744 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1745 return n
1746 }