Debian Codegraph @

envoy/config/route/v3/route_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/route/v3/route_components.proto
6
7 package routev3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 anypb "github.com/planetscale/vtprotobuf/types/known/anypb"
12 durationpb "github.com/planetscale/vtprotobuf/types/known/durationpb"
13 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
14 proto "google.golang.org/protobuf/proto"
15 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
16 )
17
18 const (
19 // Verify that this generated code is sufficiently up-to-date.
20 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
21 // Verify that runtime/protoimpl is sufficiently up-to-date.
22 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
23 )
24
25 func (m *VirtualHost) MarshalVTStrict() (dAtA []byte, err error) {
26 if m == nil {
27 return nil, nil
28 }
29 size := m.SizeVT()
30 dAtA = make([]byte, size)
31 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
32 if err != nil {
33 return nil, err
34 }
35 return dAtA[:n], nil
36 }
37
38 func (m *VirtualHost) MarshalToVTStrict(dAtA []byte) (int, error) {
39 size := m.SizeVT()
40 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
41 }
42
43 func (m *VirtualHost) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
44 if m == nil {
45 return 0, nil
46 }
47 i := len(dAtA)
48 _ = i
49 var l int
50 _ = l
51 if m.unknownFields != nil {
52 i -= len(m.unknownFields)
53 copy(dAtA[i:], m.unknownFields)
54 }
55 if m.Metadata != nil {
56 if vtmsg, ok := interface{}(m.Metadata).(interface {
57 MarshalToSizedBufferVTStrict([]byte) (int, error)
58 }); ok {
59 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
60 if err != nil {
61 return 0, err
62 }
63 i -= size
64 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
65 } else {
66 encoded, err := proto.Marshal(m.Metadata)
67 if err != nil {
68 return 0, err
69 }
70 i -= len(encoded)
71 copy(dAtA[i:], encoded)
72 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
73 }
74 i--
75 dAtA[i] = 0x1
76 i--
77 dAtA[i] = 0xc2
78 }
79 if m.IncludeIsTimeoutRetryHeader {
80 i--
81 if m.IncludeIsTimeoutRetryHeader {
82 dAtA[i] = 1
83 } else {
84 dAtA[i] = 0
85 }
86 i--
87 dAtA[i] = 0x1
88 i--
89 dAtA[i] = 0xb8
90 }
91 if len(m.RequestMirrorPolicies) > 0 {
92 for iNdEx := len(m.RequestMirrorPolicies) - 1; iNdEx >= 0; iNdEx-- {
93 size, err := m.RequestMirrorPolicies[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
94 if err != nil {
95 return 0, err
96 }
97 i -= size
98 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
99 i--
100 dAtA[i] = 0x1
101 i--
102 dAtA[i] = 0xb2
103 }
104 }
105 if m.Matcher != nil {
106 if vtmsg, ok := interface{}(m.Matcher).(interface {
107 MarshalToSizedBufferVTStrict([]byte) (int, error)
108 }); ok {
109 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
110 if err != nil {
111 return 0, err
112 }
113 i -= size
114 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
115 } else {
116 encoded, err := proto.Marshal(m.Matcher)
117 if err != nil {
118 return 0, err
119 }
120 i -= len(encoded)
121 copy(dAtA[i:], encoded)
122 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
123 }
124 i--
125 dAtA[i] = 0x1
126 i--
127 dAtA[i] = 0xaa
128 }
129 if m.RetryPolicyTypedConfig != nil {
130 size, err := (*anypb.Any)(m.RetryPolicyTypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
131 if err != nil {
132 return 0, err
133 }
134 i -= size
135 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
136 i--
137 dAtA[i] = 0x1
138 i--
139 dAtA[i] = 0xa2
140 }
141 if m.IncludeAttemptCountInResponse {
142 i--
143 if m.IncludeAttemptCountInResponse {
144 dAtA[i] = 1
145 } else {
146 dAtA[i] = 0
147 }
148 i--
149 dAtA[i] = 0x1
150 i--
151 dAtA[i] = 0x98
152 }
153 if m.PerRequestBufferLimitBytes != nil {
154 size, err := (*wrapperspb.UInt32Value)(m.PerRequestBufferLimitBytes).MarshalToSizedBufferVTStrict(dAtA[:i])
155 if err != nil {
156 return 0, err
157 }
158 i -= size
159 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
160 i--
161 dAtA[i] = 0x1
162 i--
163 dAtA[i] = 0x92
164 }
165 if m.HedgePolicy != nil {
166 size, err := m.HedgePolicy.MarshalToSizedBufferVTStrict(dAtA[:i])
167 if err != nil {
168 return 0, err
169 }
170 i -= size
171 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
172 i--
173 dAtA[i] = 0x1
174 i--
175 dAtA[i] = 0x8a
176 }
177 if m.RetryPolicy != nil {
178 size, err := m.RetryPolicy.MarshalToSizedBufferVTStrict(dAtA[:i])
179 if err != nil {
180 return 0, err
181 }
182 i -= size
183 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
184 i--
185 dAtA[i] = 0x1
186 i--
187 dAtA[i] = 0x82
188 }
189 if len(m.TypedPerFilterConfig) > 0 {
190 for k := range m.TypedPerFilterConfig {
191 v := m.TypedPerFilterConfig[k]
192 baseI := i
193 size, err := (*anypb.Any)(v).MarshalToSizedBufferVTStrict(dAtA[:i])
194 if err != nil {
195 return 0, err
196 }
197 i -= size
198 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
199 i--
200 dAtA[i] = 0x12
201 i -= len(k)
202 copy(dAtA[i:], k)
203 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
204 i--
205 dAtA[i] = 0xa
206 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
207 i--
208 dAtA[i] = 0x7a
209 }
210 }
211 if m.IncludeRequestAttemptCount {
212 i--
213 if m.IncludeRequestAttemptCount {
214 dAtA[i] = 1
215 } else {
216 dAtA[i] = 0
217 }
218 i--
219 dAtA[i] = 0x70
220 }
221 if len(m.RequestHeadersToRemove) > 0 {
222 for iNdEx := len(m.RequestHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
223 i -= len(m.RequestHeadersToRemove[iNdEx])
224 copy(dAtA[i:], m.RequestHeadersToRemove[iNdEx])
225 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RequestHeadersToRemove[iNdEx])))
226 i--
227 dAtA[i] = 0x6a
228 }
229 }
230 if len(m.ResponseHeadersToRemove) > 0 {
231 for iNdEx := len(m.ResponseHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
232 i -= len(m.ResponseHeadersToRemove[iNdEx])
233 copy(dAtA[i:], m.ResponseHeadersToRemove[iNdEx])
234 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResponseHeadersToRemove[iNdEx])))
235 i--
236 dAtA[i] = 0x5a
237 }
238 }
239 if len(m.ResponseHeadersToAdd) > 0 {
240 for iNdEx := len(m.ResponseHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
241 if vtmsg, ok := interface{}(m.ResponseHeadersToAdd[iNdEx]).(interface {
242 MarshalToSizedBufferVTStrict([]byte) (int, error)
243 }); ok {
244 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
245 if err != nil {
246 return 0, err
247 }
248 i -= size
249 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
250 } else {
251 encoded, err := proto.Marshal(m.ResponseHeadersToAdd[iNdEx])
252 if err != nil {
253 return 0, err
254 }
255 i -= len(encoded)
256 copy(dAtA[i:], encoded)
257 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
258 }
259 i--
260 dAtA[i] = 0x52
261 }
262 }
263 if m.Cors != nil {
264 size, err := m.Cors.MarshalToSizedBufferVTStrict(dAtA[:i])
265 if err != nil {
266 return 0, err
267 }
268 i -= size
269 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
270 i--
271 dAtA[i] = 0x42
272 }
273 if len(m.RequestHeadersToAdd) > 0 {
274 for iNdEx := len(m.RequestHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
275 if vtmsg, ok := interface{}(m.RequestHeadersToAdd[iNdEx]).(interface {
276 MarshalToSizedBufferVTStrict([]byte) (int, error)
277 }); ok {
278 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
279 if err != nil {
280 return 0, err
281 }
282 i -= size
283 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
284 } else {
285 encoded, err := proto.Marshal(m.RequestHeadersToAdd[iNdEx])
286 if err != nil {
287 return 0, err
288 }
289 i -= len(encoded)
290 copy(dAtA[i:], encoded)
291 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
292 }
293 i--
294 dAtA[i] = 0x3a
295 }
296 }
297 if len(m.RateLimits) > 0 {
298 for iNdEx := len(m.RateLimits) - 1; iNdEx >= 0; iNdEx-- {
299 size, err := m.RateLimits[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
300 if err != nil {
301 return 0, err
302 }
303 i -= size
304 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
305 i--
306 dAtA[i] = 0x32
307 }
308 }
309 if len(m.VirtualClusters) > 0 {
310 for iNdEx := len(m.VirtualClusters) - 1; iNdEx >= 0; iNdEx-- {
311 size, err := m.VirtualClusters[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
312 if err != nil {
313 return 0, err
314 }
315 i -= size
316 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
317 i--
318 dAtA[i] = 0x2a
319 }
320 }
321 if m.RequireTls != 0 {
322 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequireTls))
323 i--
324 dAtA[i] = 0x20
325 }
326 if len(m.Routes) > 0 {
327 for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
328 size, err := m.Routes[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
329 if err != nil {
330 return 0, err
331 }
332 i -= size
333 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
334 i--
335 dAtA[i] = 0x1a
336 }
337 }
338 if len(m.Domains) > 0 {
339 for iNdEx := len(m.Domains) - 1; iNdEx >= 0; iNdEx-- {
340 i -= len(m.Domains[iNdEx])
341 copy(dAtA[i:], m.Domains[iNdEx])
342 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Domains[iNdEx])))
343 i--
344 dAtA[i] = 0x12
345 }
346 }
347 if len(m.Name) > 0 {
348 i -= len(m.Name)
349 copy(dAtA[i:], m.Name)
350 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
351 i--
352 dAtA[i] = 0xa
353 }
354 return len(dAtA) - i, nil
355 }
356
357 func (m *FilterAction) MarshalVTStrict() (dAtA []byte, err error) {
358 if m == nil {
359 return nil, nil
360 }
361 size := m.SizeVT()
362 dAtA = make([]byte, size)
363 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
364 if err != nil {
365 return nil, err
366 }
367 return dAtA[:n], nil
368 }
369
370 func (m *FilterAction) MarshalToVTStrict(dAtA []byte) (int, error) {
371 size := m.SizeVT()
372 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
373 }
374
375 func (m *FilterAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
376 if m == nil {
377 return 0, nil
378 }
379 i := len(dAtA)
380 _ = i
381 var l int
382 _ = l
383 if m.unknownFields != nil {
384 i -= len(m.unknownFields)
385 copy(dAtA[i:], m.unknownFields)
386 }
387 if m.Action != nil {
388 size, err := (*anypb.Any)(m.Action).MarshalToSizedBufferVTStrict(dAtA[:i])
389 if err != nil {
390 return 0, err
391 }
392 i -= size
393 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
394 i--
395 dAtA[i] = 0xa
396 }
397 return len(dAtA) - i, nil
398 }
399
400 func (m *RouteList) MarshalVTStrict() (dAtA []byte, err error) {
401 if m == nil {
402 return nil, nil
403 }
404 size := m.SizeVT()
405 dAtA = make([]byte, size)
406 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
407 if err != nil {
408 return nil, err
409 }
410 return dAtA[:n], nil
411 }
412
413 func (m *RouteList) MarshalToVTStrict(dAtA []byte) (int, error) {
414 size := m.SizeVT()
415 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
416 }
417
418 func (m *RouteList) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
419 if m == nil {
420 return 0, nil
421 }
422 i := len(dAtA)
423 _ = i
424 var l int
425 _ = l
426 if m.unknownFields != nil {
427 i -= len(m.unknownFields)
428 copy(dAtA[i:], m.unknownFields)
429 }
430 if len(m.Routes) > 0 {
431 for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
432 size, err := m.Routes[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
433 if err != nil {
434 return 0, err
435 }
436 i -= size
437 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
438 i--
439 dAtA[i] = 0xa
440 }
441 }
442 return len(dAtA) - i, nil
443 }
444
445 func (m *Route) 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 *Route) MarshalToVTStrict(dAtA []byte) (int, error) {
459 size := m.SizeVT()
460 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
461 }
462
463 func (m *Route) 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 len(m.StatPrefix) > 0 {
476 i -= len(m.StatPrefix)
477 copy(dAtA[i:], m.StatPrefix)
478 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StatPrefix)))
479 i--
480 dAtA[i] = 0x1
481 i--
482 dAtA[i] = 0x9a
483 }
484 if msg, ok := m.Action.(*Route_NonForwardingAction); ok {
485 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
486 if err != nil {
487 return 0, err
488 }
489 i -= size
490 }
491 if msg, ok := m.Action.(*Route_FilterAction); ok {
492 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
493 if err != nil {
494 return 0, err
495 }
496 i -= size
497 }
498 if m.PerRequestBufferLimitBytes != nil {
499 size, err := (*wrapperspb.UInt32Value)(m.PerRequestBufferLimitBytes).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] = 0x1
507 i--
508 dAtA[i] = 0x82
509 }
510 if m.Tracing != nil {
511 size, err := m.Tracing.MarshalToSizedBufferVTStrict(dAtA[:i])
512 if err != nil {
513 return 0, err
514 }
515 i -= size
516 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
517 i--
518 dAtA[i] = 0x7a
519 }
520 if len(m.Name) > 0 {
521 i -= len(m.Name)
522 copy(dAtA[i:], m.Name)
523 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
524 i--
525 dAtA[i] = 0x72
526 }
527 if len(m.TypedPerFilterConfig) > 0 {
528 for k := range m.TypedPerFilterConfig {
529 v := m.TypedPerFilterConfig[k]
530 baseI := i
531 size, err := (*anypb.Any)(v).MarshalToSizedBufferVTStrict(dAtA[:i])
532 if err != nil {
533 return 0, err
534 }
535 i -= size
536 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
537 i--
538 dAtA[i] = 0x12
539 i -= len(k)
540 copy(dAtA[i:], k)
541 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
542 i--
543 dAtA[i] = 0xa
544 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
545 i--
546 dAtA[i] = 0x6a
547 }
548 }
549 if len(m.RequestHeadersToRemove) > 0 {
550 for iNdEx := len(m.RequestHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
551 i -= len(m.RequestHeadersToRemove[iNdEx])
552 copy(dAtA[i:], m.RequestHeadersToRemove[iNdEx])
553 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RequestHeadersToRemove[iNdEx])))
554 i--
555 dAtA[i] = 0x62
556 }
557 }
558 if len(m.ResponseHeadersToRemove) > 0 {
559 for iNdEx := len(m.ResponseHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
560 i -= len(m.ResponseHeadersToRemove[iNdEx])
561 copy(dAtA[i:], m.ResponseHeadersToRemove[iNdEx])
562 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResponseHeadersToRemove[iNdEx])))
563 i--
564 dAtA[i] = 0x5a
565 }
566 }
567 if len(m.ResponseHeadersToAdd) > 0 {
568 for iNdEx := len(m.ResponseHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
569 if vtmsg, ok := interface{}(m.ResponseHeadersToAdd[iNdEx]).(interface {
570 MarshalToSizedBufferVTStrict([]byte) (int, error)
571 }); ok {
572 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
573 if err != nil {
574 return 0, err
575 }
576 i -= size
577 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
578 } else {
579 encoded, err := proto.Marshal(m.ResponseHeadersToAdd[iNdEx])
580 if err != nil {
581 return 0, err
582 }
583 i -= len(encoded)
584 copy(dAtA[i:], encoded)
585 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
586 }
587 i--
588 dAtA[i] = 0x52
589 }
590 }
591 if len(m.RequestHeadersToAdd) > 0 {
592 for iNdEx := len(m.RequestHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
593 if vtmsg, ok := interface{}(m.RequestHeadersToAdd[iNdEx]).(interface {
594 MarshalToSizedBufferVTStrict([]byte) (int, error)
595 }); ok {
596 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
597 if err != nil {
598 return 0, err
599 }
600 i -= size
601 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
602 } else {
603 encoded, err := proto.Marshal(m.RequestHeadersToAdd[iNdEx])
604 if err != nil {
605 return 0, err
606 }
607 i -= len(encoded)
608 copy(dAtA[i:], encoded)
609 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
610 }
611 i--
612 dAtA[i] = 0x4a
613 }
614 }
615 if msg, ok := m.Action.(*Route_DirectResponse); ok {
616 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
617 if err != nil {
618 return 0, err
619 }
620 i -= size
621 }
622 if m.Decorator != nil {
623 size, err := m.Decorator.MarshalToSizedBufferVTStrict(dAtA[:i])
624 if err != nil {
625 return 0, err
626 }
627 i -= size
628 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
629 i--
630 dAtA[i] = 0x2a
631 }
632 if m.Metadata != nil {
633 if vtmsg, ok := interface{}(m.Metadata).(interface {
634 MarshalToSizedBufferVTStrict([]byte) (int, error)
635 }); ok {
636 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
637 if err != nil {
638 return 0, err
639 }
640 i -= size
641 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
642 } else {
643 encoded, err := proto.Marshal(m.Metadata)
644 if err != nil {
645 return 0, err
646 }
647 i -= len(encoded)
648 copy(dAtA[i:], encoded)
649 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
650 }
651 i--
652 dAtA[i] = 0x22
653 }
654 if msg, ok := m.Action.(*Route_Redirect); ok {
655 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
656 if err != nil {
657 return 0, err
658 }
659 i -= size
660 }
661 if msg, ok := m.Action.(*Route_Route); ok {
662 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
663 if err != nil {
664 return 0, err
665 }
666 i -= size
667 }
668 if m.Match != nil {
669 size, err := m.Match.MarshalToSizedBufferVTStrict(dAtA[:i])
670 if err != nil {
671 return 0, err
672 }
673 i -= size
674 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
675 i--
676 dAtA[i] = 0xa
677 }
678 return len(dAtA) - i, nil
679 }
680
681 func (m *Route_Route) MarshalToVTStrict(dAtA []byte) (int, error) {
682 size := m.SizeVT()
683 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
684 }
685
686 func (m *Route_Route) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
687 i := len(dAtA)
688 if m.Route != nil {
689 size, err := m.Route.MarshalToSizedBufferVTStrict(dAtA[:i])
690 if err != nil {
691 return 0, err
692 }
693 i -= size
694 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
695 i--
696 dAtA[i] = 0x12
697 } else {
698 i = protohelpers.EncodeVarint(dAtA, i, 0)
699 i--
700 dAtA[i] = 0x12
701 }
702 return len(dAtA) - i, nil
703 }
704 func (m *Route_Redirect) MarshalToVTStrict(dAtA []byte) (int, error) {
705 size := m.SizeVT()
706 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
707 }
708
709 func (m *Route_Redirect) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
710 i := len(dAtA)
711 if m.Redirect != nil {
712 size, err := m.Redirect.MarshalToSizedBufferVTStrict(dAtA[:i])
713 if err != nil {
714 return 0, err
715 }
716 i -= size
717 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
718 i--
719 dAtA[i] = 0x1a
720 } else {
721 i = protohelpers.EncodeVarint(dAtA, i, 0)
722 i--
723 dAtA[i] = 0x1a
724 }
725 return len(dAtA) - i, nil
726 }
727 func (m *Route_DirectResponse) MarshalToVTStrict(dAtA []byte) (int, error) {
728 size := m.SizeVT()
729 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
730 }
731
732 func (m *Route_DirectResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
733 i := len(dAtA)
734 if m.DirectResponse != nil {
735 size, err := m.DirectResponse.MarshalToSizedBufferVTStrict(dAtA[:i])
736 if err != nil {
737 return 0, err
738 }
739 i -= size
740 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
741 i--
742 dAtA[i] = 0x3a
743 } else {
744 i = protohelpers.EncodeVarint(dAtA, i, 0)
745 i--
746 dAtA[i] = 0x3a
747 }
748 return len(dAtA) - i, nil
749 }
750 func (m *Route_FilterAction) MarshalToVTStrict(dAtA []byte) (int, error) {
751 size := m.SizeVT()
752 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
753 }
754
755 func (m *Route_FilterAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
756 i := len(dAtA)
757 if m.FilterAction != nil {
758 size, err := m.FilterAction.MarshalToSizedBufferVTStrict(dAtA[:i])
759 if err != nil {
760 return 0, err
761 }
762 i -= size
763 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
764 i--
765 dAtA[i] = 0x1
766 i--
767 dAtA[i] = 0x8a
768 } else {
769 i = protohelpers.EncodeVarint(dAtA, i, 0)
770 i--
771 dAtA[i] = 0x1
772 i--
773 dAtA[i] = 0x8a
774 }
775 return len(dAtA) - i, nil
776 }
777 func (m *Route_NonForwardingAction) MarshalToVTStrict(dAtA []byte) (int, error) {
778 size := m.SizeVT()
779 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
780 }
781
782 func (m *Route_NonForwardingAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
783 i := len(dAtA)
784 if m.NonForwardingAction != nil {
785 size, err := m.NonForwardingAction.MarshalToSizedBufferVTStrict(dAtA[:i])
786 if err != nil {
787 return 0, err
788 }
789 i -= size
790 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
791 i--
792 dAtA[i] = 0x1
793 i--
794 dAtA[i] = 0x92
795 } else {
796 i = protohelpers.EncodeVarint(dAtA, i, 0)
797 i--
798 dAtA[i] = 0x1
799 i--
800 dAtA[i] = 0x92
801 }
802 return len(dAtA) - i, nil
803 }
804 func (m *WeightedCluster_ClusterWeight) MarshalVTStrict() (dAtA []byte, err error) {
805 if m == nil {
806 return nil, nil
807 }
808 size := m.SizeVT()
809 dAtA = make([]byte, size)
810 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
811 if err != nil {
812 return nil, err
813 }
814 return dAtA[:n], nil
815 }
816
817 func (m *WeightedCluster_ClusterWeight) MarshalToVTStrict(dAtA []byte) (int, error) {
818 size := m.SizeVT()
819 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
820 }
821
822 func (m *WeightedCluster_ClusterWeight) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
823 if m == nil {
824 return 0, nil
825 }
826 i := len(dAtA)
827 _ = i
828 var l int
829 _ = l
830 if m.unknownFields != nil {
831 i -= len(m.unknownFields)
832 copy(dAtA[i:], m.unknownFields)
833 }
834 if len(m.ClusterHeader) > 0 {
835 i -= len(m.ClusterHeader)
836 copy(dAtA[i:], m.ClusterHeader)
837 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterHeader)))
838 i--
839 dAtA[i] = 0x62
840 }
841 if msg, ok := m.HostRewriteSpecifier.(*WeightedCluster_ClusterWeight_HostRewriteLiteral); ok {
842 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
843 if err != nil {
844 return 0, err
845 }
846 i -= size
847 }
848 if len(m.TypedPerFilterConfig) > 0 {
849 for k := range m.TypedPerFilterConfig {
850 v := m.TypedPerFilterConfig[k]
851 baseI := i
852 size, err := (*anypb.Any)(v).MarshalToSizedBufferVTStrict(dAtA[:i])
853 if err != nil {
854 return 0, err
855 }
856 i -= size
857 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
858 i--
859 dAtA[i] = 0x12
860 i -= len(k)
861 copy(dAtA[i:], k)
862 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
863 i--
864 dAtA[i] = 0xa
865 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
866 i--
867 dAtA[i] = 0x52
868 }
869 }
870 if len(m.RequestHeadersToRemove) > 0 {
871 for iNdEx := len(m.RequestHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
872 i -= len(m.RequestHeadersToRemove[iNdEx])
873 copy(dAtA[i:], m.RequestHeadersToRemove[iNdEx])
874 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RequestHeadersToRemove[iNdEx])))
875 i--
876 dAtA[i] = 0x4a
877 }
878 }
879 if len(m.ResponseHeadersToRemove) > 0 {
880 for iNdEx := len(m.ResponseHeadersToRemove) - 1; iNdEx >= 0; iNdEx-- {
881 i -= len(m.ResponseHeadersToRemove[iNdEx])
882 copy(dAtA[i:], m.ResponseHeadersToRemove[iNdEx])
883 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResponseHeadersToRemove[iNdEx])))
884 i--
885 dAtA[i] = 0x32
886 }
887 }
888 if len(m.ResponseHeadersToAdd) > 0 {
889 for iNdEx := len(m.ResponseHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
890 if vtmsg, ok := interface{}(m.ResponseHeadersToAdd[iNdEx]).(interface {
891 MarshalToSizedBufferVTStrict([]byte) (int, error)
892 }); ok {
893 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
894 if err != nil {
895 return 0, err
896 }
897 i -= size
898 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
899 } else {
900 encoded, err := proto.Marshal(m.ResponseHeadersToAdd[iNdEx])
901 if err != nil {
902 return 0, err
903 }
904 i -= len(encoded)
905 copy(dAtA[i:], encoded)
906 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
907 }
908 i--
909 dAtA[i] = 0x2a
910 }
911 }
912 if len(m.RequestHeadersToAdd) > 0 {
913 for iNdEx := len(m.RequestHeadersToAdd) - 1; iNdEx >= 0; iNdEx-- {
914 if vtmsg, ok := interface{}(m.RequestHeadersToAdd[iNdEx]).(interface {
915 MarshalToSizedBufferVTStrict([]byte) (int, error)
916 }); ok {
917 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
918 if err != nil {
919 return 0, err
920 }
921 i -= size
922 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
923 } else {
924 encoded, err := proto.Marshal(m.RequestHeadersToAdd[iNdEx])
925 if err != nil {
926 return 0, err
927 }
928 i -= len(encoded)
929 copy(dAtA[i:], encoded)
930 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
931 }
932 i--
933 dAtA[i] = 0x22
934 }
935 }
936 if m.MetadataMatch != nil {
937 if vtmsg, ok := interface{}(m.MetadataMatch).(interface {
938 MarshalToSizedBufferVTStrict([]byte) (int, error)
939 }); ok {
940 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
941 if err != nil {
942 return 0, err
943 }
944 i -= size
945 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
946 } else {
947 encoded, err := proto.Marshal(m.MetadataMatch)
948 if err != nil {
949 return 0, err
950 }
951 i -= len(encoded)
952 copy(dAtA[i:], encoded)
953 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
954 }
955 i--
956 dAtA[i] = 0x1a
957 }
958 if m.Weight != nil {
959 size, err := (*wrapperspb.UInt32Value)(m.Weight).MarshalToSizedBufferVTStrict(dAtA[:i])
960 if err != nil {
961 return 0, err
962 }
963 i -= size
964 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
965 i--
966 dAtA[i] = 0x12
967 }
968 if len(m.Name) > 0 {
969 i -= len(m.Name)
970 copy(dAtA[i:], m.Name)
971 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
972 i--
973 dAtA[i] = 0xa
974 }
975 return len(dAtA) - i, nil
976 }
977
978 func (m *WeightedCluster_ClusterWeight_HostRewriteLiteral) MarshalToVTStrict(dAtA []byte) (int, error) {
979 size := m.SizeVT()
980 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
981 }
982
983 func (m *WeightedCluster_ClusterWeight_HostRewriteLiteral) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
984 i := len(dAtA)
985 i -= len(m.HostRewriteLiteral)
986 copy(dAtA[i:], m.HostRewriteLiteral)
987 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HostRewriteLiteral)))
988 i--
989 dAtA[i] = 0x5a
990 return len(dAtA) - i, nil
991 }
992 func (m *WeightedCluster) MarshalVTStrict() (dAtA []byte, err error) {
993 if m == nil {
994 return nil, nil
995 }
996 size := m.SizeVT()
997 dAtA = make([]byte, size)
998 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
999 if err != nil {
1000 return nil, err
1001 }
1002 return dAtA[:n], nil
1003 }
1004
1005 func (m *WeightedCluster) MarshalToVTStrict(dAtA []byte) (int, error) {
1006 size := m.SizeVT()
1007 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1008 }
1009
1010 func (m *WeightedCluster) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1011 if m == nil {
1012 return 0, nil
1013 }
1014 i := len(dAtA)
1015 _ = i
1016 var l int
1017 _ = l
1018 if m.unknownFields != nil {
1019 i -= len(m.unknownFields)
1020 copy(dAtA[i:], m.unknownFields)
1021 }
1022 if msg, ok := m.RandomValueSpecifier.(*WeightedCluster_HeaderName); ok {
1023 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1024 if err != nil {
1025 return 0, err
1026 }
1027 i -= size
1028 }
1029 if m.TotalWeight != nil {
1030 size, err := (*wrapperspb.UInt32Value)(m.TotalWeight).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] = 0x1a
1038 }
1039 if len(m.RuntimeKeyPrefix) > 0 {
1040 i -= len(m.RuntimeKeyPrefix)
1041 copy(dAtA[i:], m.RuntimeKeyPrefix)
1042 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RuntimeKeyPrefix)))
1043 i--
1044 dAtA[i] = 0x12
1045 }
1046 if len(m.Clusters) > 0 {
1047 for iNdEx := len(m.Clusters) - 1; iNdEx >= 0; iNdEx-- {
1048 size, err := m.Clusters[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1049 if err != nil {
1050 return 0, err
1051 }
1052 i -= size
1053 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1054 i--
1055 dAtA[i] = 0xa
1056 }
1057 }
1058 return len(dAtA) - i, nil
1059 }
1060
1061 func (m *WeightedCluster_HeaderName) MarshalToVTStrict(dAtA []byte) (int, error) {
1062 size := m.SizeVT()
1063 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1064 }
1065
1066 func (m *WeightedCluster_HeaderName) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1067 i := len(dAtA)
1068 i -= len(m.HeaderName)
1069 copy(dAtA[i:], m.HeaderName)
1070 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeaderName)))
1071 i--
1072 dAtA[i] = 0x22
1073 return len(dAtA) - i, nil
1074 }
1075 func (m *ClusterSpecifierPlugin) MarshalVTStrict() (dAtA []byte, err error) {
1076 if m == nil {
1077 return nil, nil
1078 }
1079 size := m.SizeVT()
1080 dAtA = make([]byte, size)
1081 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1082 if err != nil {
1083 return nil, err
1084 }
1085 return dAtA[:n], nil
1086 }
1087
1088 func (m *ClusterSpecifierPlugin) MarshalToVTStrict(dAtA []byte) (int, error) {
1089 size := m.SizeVT()
1090 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1091 }
1092
1093 func (m *ClusterSpecifierPlugin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1094 if m == nil {
1095 return 0, nil
1096 }
1097 i := len(dAtA)
1098 _ = i
1099 var l int
1100 _ = l
1101 if m.unknownFields != nil {
1102 i -= len(m.unknownFields)
1103 copy(dAtA[i:], m.unknownFields)
1104 }
1105 if m.IsOptional {
1106 i--
1107 if m.IsOptional {
1108 dAtA[i] = 1
1109 } else {
1110 dAtA[i] = 0
1111 }
1112 i--
1113 dAtA[i] = 0x10
1114 }
1115 if m.Extension != nil {
1116 if vtmsg, ok := interface{}(m.Extension).(interface {
1117 MarshalToSizedBufferVTStrict([]byte) (int, error)
1118 }); ok {
1119 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1120 if err != nil {
1121 return 0, err
1122 }
1123 i -= size
1124 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1125 } else {
1126 encoded, err := proto.Marshal(m.Extension)
1127 if err != nil {
1128 return 0, err
1129 }
1130 i -= len(encoded)
1131 copy(dAtA[i:], encoded)
1132 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1133 }
1134 i--
1135 dAtA[i] = 0xa
1136 }
1137 return len(dAtA) - i, nil
1138 }
1139
1140 func (m *RouteMatch_GrpcRouteMatchOptions) MarshalVTStrict() (dAtA []byte, err error) {
1141 if m == nil {
1142 return nil, nil
1143 }
1144 size := m.SizeVT()
1145 dAtA = make([]byte, size)
1146 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1147 if err != nil {
1148 return nil, err
1149 }
1150 return dAtA[:n], nil
1151 }
1152
1153 func (m *RouteMatch_GrpcRouteMatchOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
1154 size := m.SizeVT()
1155 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1156 }
1157
1158 func (m *RouteMatch_GrpcRouteMatchOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1159 if m == nil {
1160 return 0, nil
1161 }
1162 i := len(dAtA)
1163 _ = i
1164 var l int
1165 _ = l
1166 if m.unknownFields != nil {
1167 i -= len(m.unknownFields)
1168 copy(dAtA[i:], m.unknownFields)
1169 }
1170 return len(dAtA) - i, nil
1171 }
1172
1173 func (m *RouteMatch_TlsContextMatchOptions) MarshalVTStrict() (dAtA []byte, err error) {
1174 if m == nil {
1175 return nil, nil
1176 }
1177 size := m.SizeVT()
1178 dAtA = make([]byte, size)
1179 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1180 if err != nil {
1181 return nil, err
1182 }
1183 return dAtA[:n], nil
1184 }
1185
1186 func (m *RouteMatch_TlsContextMatchOptions) MarshalToVTStrict(dAtA []byte) (int, error) {
1187 size := m.SizeVT()
1188 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1189 }
1190
1191 func (m *RouteMatch_TlsContextMatchOptions) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1192 if m == nil {
1193 return 0, nil
1194 }
1195 i := len(dAtA)
1196 _ = i
1197 var l int
1198 _ = l
1199 if m.unknownFields != nil {
1200 i -= len(m.unknownFields)
1201 copy(dAtA[i:], m.unknownFields)
1202 }
1203 if m.Validated != nil {
1204 size, err := (*wrapperspb.BoolValue)(m.Validated).MarshalToSizedBufferVTStrict(dAtA[:i])
1205 if err != nil {
1206 return 0, err
1207 }
1208 i -= size
1209 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1210 i--
1211 dAtA[i] = 0x12
1212 }
1213 if m.Presented != nil {
1214 size, err := (*wrapperspb.BoolValue)(m.Presented).MarshalToSizedBufferVTStrict(dAtA[:i])
1215 if err != nil {
1216 return 0, err
1217 }
1218 i -= size
1219 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1220 i--
1221 dAtA[i] = 0xa
1222 }
1223 return len(dAtA) - i, nil
1224 }
1225
1226 func (m *RouteMatch_ConnectMatcher) MarshalVTStrict() (dAtA []byte, err error) {
1227 if m == nil {
1228 return nil, nil
1229 }
1230 size := m.SizeVT()
1231 dAtA = make([]byte, size)
1232 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1233 if err != nil {
1234 return nil, err
1235 }
1236 return dAtA[:n], nil
1237 }
1238
1239 func (m *RouteMatch_ConnectMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
1240 size := m.SizeVT()
1241 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1242 }
1243
1244 func (m *RouteMatch_ConnectMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1245 if m == nil {
1246 return 0, nil
1247 }
1248 i := len(dAtA)
1249 _ = i
1250 var l int
1251 _ = l
1252 if m.unknownFields != nil {
1253 i -= len(m.unknownFields)
1254 copy(dAtA[i:], m.unknownFields)
1255 }
1256 return len(dAtA) - i, nil
1257 }
1258
1259 func (m *RouteMatch) MarshalVTStrict() (dAtA []byte, err error) {
1260 if m == nil {
1261 return nil, nil
1262 }
1263 size := m.SizeVT()
1264 dAtA = make([]byte, size)
1265 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1266 if err != nil {
1267 return nil, err
1268 }
1269 return dAtA[:n], nil
1270 }
1271
1272 func (m *RouteMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1273 size := m.SizeVT()
1274 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1275 }
1276
1277 func (m *RouteMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1278 if m == nil {
1279 return 0, nil
1280 }
1281 i := len(dAtA)
1282 _ = i
1283 var l int
1284 _ = l
1285 if m.unknownFields != nil {
1286 i -= len(m.unknownFields)
1287 copy(dAtA[i:], m.unknownFields)
1288 }
1289 if msg, ok := m.PathSpecifier.(*RouteMatch_PathMatchPolicy); ok {
1290 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1291 if err != nil {
1292 return 0, err
1293 }
1294 i -= size
1295 }
1296 if msg, ok := m.PathSpecifier.(*RouteMatch_PathSeparatedPrefix); ok {
1297 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1298 if err != nil {
1299 return 0, err
1300 }
1301 i -= size
1302 }
1303 if len(m.DynamicMetadata) > 0 {
1304 for iNdEx := len(m.DynamicMetadata) - 1; iNdEx >= 0; iNdEx-- {
1305 if vtmsg, ok := interface{}(m.DynamicMetadata[iNdEx]).(interface {
1306 MarshalToSizedBufferVTStrict([]byte) (int, error)
1307 }); ok {
1308 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1309 if err != nil {
1310 return 0, err
1311 }
1312 i -= size
1313 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1314 } else {
1315 encoded, err := proto.Marshal(m.DynamicMetadata[iNdEx])
1316 if err != nil {
1317 return 0, err
1318 }
1319 i -= len(encoded)
1320 copy(dAtA[i:], encoded)
1321 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1322 }
1323 i--
1324 dAtA[i] = 0x6a
1325 }
1326 }
1327 if msg, ok := m.PathSpecifier.(*RouteMatch_ConnectMatcher_); ok {
1328 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1329 if err != nil {
1330 return 0, err
1331 }
1332 i -= size
1333 }
1334 if m.TlsContext != nil {
1335 size, err := m.TlsContext.MarshalToSizedBufferVTStrict(dAtA[:i])
1336 if err != nil {
1337 return 0, err
1338 }
1339 i -= size
1340 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1341 i--
1342 dAtA[i] = 0x5a
1343 }
1344 if msg, ok := m.PathSpecifier.(*RouteMatch_SafeRegex); ok {
1345 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1346 if err != nil {
1347 return 0, err
1348 }
1349 i -= size
1350 }
1351 if m.RuntimeFraction != nil {
1352 if vtmsg, ok := interface{}(m.RuntimeFraction).(interface {
1353 MarshalToSizedBufferVTStrict([]byte) (int, error)
1354 }); ok {
1355 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1356 if err != nil {
1357 return 0, err
1358 }
1359 i -= size
1360 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1361 } else {
1362 encoded, err := proto.Marshal(m.RuntimeFraction)
1363 if err != nil {
1364 return 0, err
1365 }
1366 i -= len(encoded)
1367 copy(dAtA[i:], encoded)
1368 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1369 }
1370 i--
1371 dAtA[i] = 0x4a
1372 }
1373 if m.Grpc != nil {
1374 size, err := m.Grpc.MarshalToSizedBufferVTStrict(dAtA[:i])
1375 if err != nil {
1376 return 0, err
1377 }
1378 i -= size
1379 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1380 i--
1381 dAtA[i] = 0x42
1382 }
1383 if len(m.QueryParameters) > 0 {
1384 for iNdEx := len(m.QueryParameters) - 1; iNdEx >= 0; iNdEx-- {
1385 size, err := m.QueryParameters[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1386 if err != nil {
1387 return 0, err
1388 }
1389 i -= size
1390 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1391 i--
1392 dAtA[i] = 0x3a
1393 }
1394 }
1395 if len(m.Headers) > 0 {
1396 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
1397 size, err := m.Headers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1398 if err != nil {
1399 return 0, err
1400 }
1401 i -= size
1402 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1403 i--
1404 dAtA[i] = 0x32
1405 }
1406 }
1407 if m.CaseSensitive != nil {
1408 size, err := (*wrapperspb.BoolValue)(m.CaseSensitive).MarshalToSizedBufferVTStrict(dAtA[:i])
1409 if err != nil {
1410 return 0, err
1411 }
1412 i -= size
1413 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1414 i--
1415 dAtA[i] = 0x22
1416 }
1417 if msg, ok := m.PathSpecifier.(*RouteMatch_Path); ok {
1418 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1419 if err != nil {
1420 return 0, err
1421 }
1422 i -= size
1423 }
1424 if msg, ok := m.PathSpecifier.(*RouteMatch_Prefix); ok {
1425 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1426 if err != nil {
1427 return 0, err
1428 }
1429 i -= size
1430 }
1431 return len(dAtA) - i, nil
1432 }
1433
1434 func (m *RouteMatch_Prefix) MarshalToVTStrict(dAtA []byte) (int, error) {
1435 size := m.SizeVT()
1436 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1437 }
1438
1439 func (m *RouteMatch_Prefix) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1440 i := len(dAtA)
1441 i -= len(m.Prefix)
1442 copy(dAtA[i:], m.Prefix)
1443 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Prefix)))
1444 i--
1445 dAtA[i] = 0xa
1446 return len(dAtA) - i, nil
1447 }
1448 func (m *RouteMatch_Path) MarshalToVTStrict(dAtA []byte) (int, error) {
1449 size := m.SizeVT()
1450 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1451 }
1452
1453 func (m *RouteMatch_Path) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1454 i := len(dAtA)
1455 i -= len(m.Path)
1456 copy(dAtA[i:], m.Path)
1457 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
1458 i--
1459 dAtA[i] = 0x12
1460 return len(dAtA) - i, nil
1461 }
1462 func (m *RouteMatch_SafeRegex) MarshalToVTStrict(dAtA []byte) (int, error) {
1463 size := m.SizeVT()
1464 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1465 }
1466
1467 func (m *RouteMatch_SafeRegex) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1468 i := len(dAtA)
1469 if m.SafeRegex != nil {
1470 if vtmsg, ok := interface{}(m.SafeRegex).(interface {
1471 MarshalToSizedBufferVTStrict([]byte) (int, error)
1472 }); ok {
1473 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1474 if err != nil {
1475 return 0, err
1476 }
1477 i -= size
1478 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1479 } else {
1480 encoded, err := proto.Marshal(m.SafeRegex)
1481 if err != nil {
1482 return 0, err
1483 }
1484 i -= len(encoded)
1485 copy(dAtA[i:], encoded)
1486 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1487 }
1488 i--
1489 dAtA[i] = 0x52
1490 } else {
1491 i = protohelpers.EncodeVarint(dAtA, i, 0)
1492 i--
1493 dAtA[i] = 0x52
1494 }
1495 return len(dAtA) - i, nil
1496 }
1497 func (m *RouteMatch_ConnectMatcher_) MarshalToVTStrict(dAtA []byte) (int, error) {
1498 size := m.SizeVT()
1499 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1500 }
1501
1502 func (m *RouteMatch_ConnectMatcher_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1503 i := len(dAtA)
1504 if m.ConnectMatcher != nil {
1505 size, err := m.ConnectMatcher.MarshalToSizedBufferVTStrict(dAtA[:i])
1506 if err != nil {
1507 return 0, err
1508 }
1509 i -= size
1510 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1511 i--
1512 dAtA[i] = 0x62
1513 } else {
1514 i = protohelpers.EncodeVarint(dAtA, i, 0)
1515 i--
1516 dAtA[i] = 0x62
1517 }
1518 return len(dAtA) - i, nil
1519 }
1520 func (m *RouteMatch_PathSeparatedPrefix) MarshalToVTStrict(dAtA []byte) (int, error) {
1521 size := m.SizeVT()
1522 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1523 }
1524
1525 func (m *RouteMatch_PathSeparatedPrefix) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1526 i := len(dAtA)
1527 i -= len(m.PathSeparatedPrefix)
1528 copy(dAtA[i:], m.PathSeparatedPrefix)
1529 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PathSeparatedPrefix)))
1530 i--
1531 dAtA[i] = 0x72
1532 return len(dAtA) - i, nil
1533 }
1534 func (m *RouteMatch_PathMatchPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
1535 size := m.SizeVT()
1536 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1537 }
1538
1539 func (m *RouteMatch_PathMatchPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1540 i := len(dAtA)
1541 if m.PathMatchPolicy != nil {
1542 if vtmsg, ok := interface{}(m.PathMatchPolicy).(interface {
1543 MarshalToSizedBufferVTStrict([]byte) (int, error)
1544 }); ok {
1545 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1546 if err != nil {
1547 return 0, err
1548 }
1549 i -= size
1550 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1551 } else {
1552 encoded, err := proto.Marshal(m.PathMatchPolicy)
1553 if err != nil {
1554 return 0, err
1555 }
1556 i -= len(encoded)
1557 copy(dAtA[i:], encoded)
1558 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1559 }
1560 i--
1561 dAtA[i] = 0x7a
1562 } else {
1563 i = protohelpers.EncodeVarint(dAtA, i, 0)
1564 i--
1565 dAtA[i] = 0x7a
1566 }
1567 return len(dAtA) - i, nil
1568 }
1569 func (m *CorsPolicy) MarshalVTStrict() (dAtA []byte, err error) {
1570 if m == nil {
1571 return nil, nil
1572 }
1573 size := m.SizeVT()
1574 dAtA = make([]byte, size)
1575 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1576 if err != nil {
1577 return nil, err
1578 }
1579 return dAtA[:n], nil
1580 }
1581
1582 func (m *CorsPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
1583 size := m.SizeVT()
1584 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1585 }
1586
1587 func (m *CorsPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1588 if m == nil {
1589 return 0, nil
1590 }
1591 i := len(dAtA)
1592 _ = i
1593 var l int
1594 _ = l
1595 if m.unknownFields != nil {
1596 i -= len(m.unknownFields)
1597 copy(dAtA[i:], m.unknownFields)
1598 }
1599 if m.ForwardNotMatchingPreflights != nil {
1600 size, err := (*wrapperspb.BoolValue)(m.ForwardNotMatchingPreflights).MarshalToSizedBufferVTStrict(dAtA[:i])
1601 if err != nil {
1602 return 0, err
1603 }
1604 i -= size
1605 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1606 i--
1607 dAtA[i] = 0x6a
1608 }
1609 if m.AllowPrivateNetworkAccess != nil {
1610 size, err := (*wrapperspb.BoolValue)(m.AllowPrivateNetworkAccess).MarshalToSizedBufferVTStrict(dAtA[:i])
1611 if err != nil {
1612 return 0, err
1613 }
1614 i -= size
1615 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1616 i--
1617 dAtA[i] = 0x62
1618 }
1619 if len(m.AllowOriginStringMatch) > 0 {
1620 for iNdEx := len(m.AllowOriginStringMatch) - 1; iNdEx >= 0; iNdEx-- {
1621 if vtmsg, ok := interface{}(m.AllowOriginStringMatch[iNdEx]).(interface {
1622 MarshalToSizedBufferVTStrict([]byte) (int, error)
1623 }); ok {
1624 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1625 if err != nil {
1626 return 0, err
1627 }
1628 i -= size
1629 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1630 } else {
1631 encoded, err := proto.Marshal(m.AllowOriginStringMatch[iNdEx])
1632 if err != nil {
1633 return 0, err
1634 }
1635 i -= len(encoded)
1636 copy(dAtA[i:], encoded)
1637 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1638 }
1639 i--
1640 dAtA[i] = 0x5a
1641 }
1642 }
1643 if m.ShadowEnabled != nil {
1644 if vtmsg, ok := interface{}(m.ShadowEnabled).(interface {
1645 MarshalToSizedBufferVTStrict([]byte) (int, error)
1646 }); ok {
1647 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1648 if err != nil {
1649 return 0, err
1650 }
1651 i -= size
1652 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1653 } else {
1654 encoded, err := proto.Marshal(m.ShadowEnabled)
1655 if err != nil {
1656 return 0, err
1657 }
1658 i -= len(encoded)
1659 copy(dAtA[i:], encoded)
1660 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1661 }
1662 i--
1663 dAtA[i] = 0x52
1664 }
1665 if msg, ok := m.EnabledSpecifier.(*CorsPolicy_FilterEnabled); ok {
1666 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1667 if err != nil {
1668 return 0, err
1669 }
1670 i -= size
1671 }
1672 if m.AllowCredentials != nil {
1673 size, err := (*wrapperspb.BoolValue)(m.AllowCredentials).MarshalToSizedBufferVTStrict(dAtA[:i])
1674 if err != nil {
1675 return 0, err
1676 }
1677 i -= size
1678 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1679 i--
1680 dAtA[i] = 0x32
1681 }
1682 if len(m.MaxAge) > 0 {
1683 i -= len(m.MaxAge)
1684 copy(dAtA[i:], m.MaxAge)
1685 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MaxAge)))
1686 i--
1687 dAtA[i] = 0x2a
1688 }
1689 if len(m.ExposeHeaders) > 0 {
1690 i -= len(m.ExposeHeaders)
1691 copy(dAtA[i:], m.ExposeHeaders)
1692 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExposeHeaders)))
1693 i--
1694 dAtA[i] = 0x22
1695 }
1696 if len(m.AllowHeaders) > 0 {
1697 i -= len(m.AllowHeaders)
1698 copy(dAtA[i:], m.AllowHeaders)
1699 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AllowHeaders)))
1700 i--
1701 dAtA[i] = 0x1a
1702 }
1703 if len(m.AllowMethods) > 0 {
1704 i -= len(m.AllowMethods)
1705 copy(dAtA[i:], m.AllowMethods)
1706 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AllowMethods)))
1707 i--
1708 dAtA[i] = 0x12
1709 }
1710 return len(dAtA) - i, nil
1711 }
1712
1713 func (m *CorsPolicy_FilterEnabled) MarshalToVTStrict(dAtA []byte) (int, error) {
1714 size := m.SizeVT()
1715 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1716 }
1717
1718 func (m *CorsPolicy_FilterEnabled) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1719 i := len(dAtA)
1720 if m.FilterEnabled != nil {
1721 if vtmsg, ok := interface{}(m.FilterEnabled).(interface {
1722 MarshalToSizedBufferVTStrict([]byte) (int, error)
1723 }); ok {
1724 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1725 if err != nil {
1726 return 0, err
1727 }
1728 i -= size
1729 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1730 } else {
1731 encoded, err := proto.Marshal(m.FilterEnabled)
1732 if err != nil {
1733 return 0, err
1734 }
1735 i -= len(encoded)
1736 copy(dAtA[i:], encoded)
1737 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1738 }
1739 i--
1740 dAtA[i] = 0x4a
1741 } else {
1742 i = protohelpers.EncodeVarint(dAtA, i, 0)
1743 i--
1744 dAtA[i] = 0x4a
1745 }
1746 return len(dAtA) - i, nil
1747 }
1748 func (m *RouteAction_RequestMirrorPolicy) MarshalVTStrict() (dAtA []byte, err error) {
1749 if m == nil {
1750 return nil, nil
1751 }
1752 size := m.SizeVT()
1753 dAtA = make([]byte, size)
1754 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1755 if err != nil {
1756 return nil, err
1757 }
1758 return dAtA[:n], nil
1759 }
1760
1761 func (m *RouteAction_RequestMirrorPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
1762 size := m.SizeVT()
1763 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1764 }
1765
1766 func (m *RouteAction_RequestMirrorPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1767 if m == nil {
1768 return 0, nil
1769 }
1770 i := len(dAtA)
1771 _ = i
1772 var l int
1773 _ = l
1774 if m.unknownFields != nil {
1775 i -= len(m.unknownFields)
1776 copy(dAtA[i:], m.unknownFields)
1777 }
1778 if m.DisableShadowHostSuffixAppend {
1779 i--
1780 if m.DisableShadowHostSuffixAppend {
1781 dAtA[i] = 1
1782 } else {
1783 dAtA[i] = 0
1784 }
1785 i--
1786 dAtA[i] = 0x30
1787 }
1788 if len(m.ClusterHeader) > 0 {
1789 i -= len(m.ClusterHeader)
1790 copy(dAtA[i:], m.ClusterHeader)
1791 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterHeader)))
1792 i--
1793 dAtA[i] = 0x2a
1794 }
1795 if m.TraceSampled != nil {
1796 size, err := (*wrapperspb.BoolValue)(m.TraceSampled).MarshalToSizedBufferVTStrict(dAtA[:i])
1797 if err != nil {
1798 return 0, err
1799 }
1800 i -= size
1801 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1802 i--
1803 dAtA[i] = 0x22
1804 }
1805 if m.RuntimeFraction != nil {
1806 if vtmsg, ok := interface{}(m.RuntimeFraction).(interface {
1807 MarshalToSizedBufferVTStrict([]byte) (int, error)
1808 }); ok {
1809 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1810 if err != nil {
1811 return 0, err
1812 }
1813 i -= size
1814 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1815 } else {
1816 encoded, err := proto.Marshal(m.RuntimeFraction)
1817 if err != nil {
1818 return 0, err
1819 }
1820 i -= len(encoded)
1821 copy(dAtA[i:], encoded)
1822 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1823 }
1824 i--
1825 dAtA[i] = 0x1a
1826 }
1827 if len(m.Cluster) > 0 {
1828 i -= len(m.Cluster)
1829 copy(dAtA[i:], m.Cluster)
1830 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Cluster)))
1831 i--
1832 dAtA[i] = 0xa
1833 }
1834 return len(dAtA) - i, nil
1835 }
1836
1837 func (m *RouteAction_HashPolicy_Header) MarshalVTStrict() (dAtA []byte, err error) {
1838 if m == nil {
1839 return nil, nil
1840 }
1841 size := m.SizeVT()
1842 dAtA = make([]byte, size)
1843 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1844 if err != nil {
1845 return nil, err
1846 }
1847 return dAtA[:n], nil
1848 }
1849
1850 func (m *RouteAction_HashPolicy_Header) MarshalToVTStrict(dAtA []byte) (int, error) {
1851 size := m.SizeVT()
1852 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1853 }
1854
1855 func (m *RouteAction_HashPolicy_Header) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1856 if m == nil {
1857 return 0, nil
1858 }
1859 i := len(dAtA)
1860 _ = i
1861 var l int
1862 _ = l
1863 if m.unknownFields != nil {
1864 i -= len(m.unknownFields)
1865 copy(dAtA[i:], m.unknownFields)
1866 }
1867 if m.RegexRewrite != nil {
1868 if vtmsg, ok := interface{}(m.RegexRewrite).(interface {
1869 MarshalToSizedBufferVTStrict([]byte) (int, error)
1870 }); ok {
1871 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1872 if err != nil {
1873 return 0, err
1874 }
1875 i -= size
1876 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1877 } else {
1878 encoded, err := proto.Marshal(m.RegexRewrite)
1879 if err != nil {
1880 return 0, err
1881 }
1882 i -= len(encoded)
1883 copy(dAtA[i:], encoded)
1884 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1885 }
1886 i--
1887 dAtA[i] = 0x12
1888 }
1889 if len(m.HeaderName) > 0 {
1890 i -= len(m.HeaderName)
1891 copy(dAtA[i:], m.HeaderName)
1892 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeaderName)))
1893 i--
1894 dAtA[i] = 0xa
1895 }
1896 return len(dAtA) - i, nil
1897 }
1898
1899 func (m *RouteAction_HashPolicy_CookieAttribute) MarshalVTStrict() (dAtA []byte, err error) {
1900 if m == nil {
1901 return nil, nil
1902 }
1903 size := m.SizeVT()
1904 dAtA = make([]byte, size)
1905 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1906 if err != nil {
1907 return nil, err
1908 }
1909 return dAtA[:n], nil
1910 }
1911
1912 func (m *RouteAction_HashPolicy_CookieAttribute) MarshalToVTStrict(dAtA []byte) (int, error) {
1913 size := m.SizeVT()
1914 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1915 }
1916
1917 func (m *RouteAction_HashPolicy_CookieAttribute) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1918 if m == nil {
1919 return 0, nil
1920 }
1921 i := len(dAtA)
1922 _ = i
1923 var l int
1924 _ = l
1925 if m.unknownFields != nil {
1926 i -= len(m.unknownFields)
1927 copy(dAtA[i:], m.unknownFields)
1928 }
1929 if len(m.Value) > 0 {
1930 i -= len(m.Value)
1931 copy(dAtA[i:], m.Value)
1932 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))
1933 i--
1934 dAtA[i] = 0x12
1935 }
1936 if len(m.Name) > 0 {
1937 i -= len(m.Name)
1938 copy(dAtA[i:], m.Name)
1939 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1940 i--
1941 dAtA[i] = 0xa
1942 }
1943 return len(dAtA) - i, nil
1944 }
1945
1946 func (m *RouteAction_HashPolicy_Cookie) MarshalVTStrict() (dAtA []byte, err error) {
1947 if m == nil {
1948 return nil, nil
1949 }
1950 size := m.SizeVT()
1951 dAtA = make([]byte, size)
1952 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1953 if err != nil {
1954 return nil, err
1955 }
1956 return dAtA[:n], nil
1957 }
1958
1959 func (m *RouteAction_HashPolicy_Cookie) MarshalToVTStrict(dAtA []byte) (int, error) {
1960 size := m.SizeVT()
1961 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1962 }
1963
1964 func (m *RouteAction_HashPolicy_Cookie) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1965 if m == nil {
1966 return 0, nil
1967 }
1968 i := len(dAtA)
1969 _ = i
1970 var l int
1971 _ = l
1972 if m.unknownFields != nil {
1973 i -= len(m.unknownFields)
1974 copy(dAtA[i:], m.unknownFields)
1975 }
1976 if len(m.Attributes) > 0 {
1977 for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
1978 size, err := m.Attributes[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1979 if err != nil {
1980 return 0, err
1981 }
1982 i -= size
1983 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1984 i--
1985 dAtA[i] = 0x22
1986 }
1987 }
1988 if len(m.Path) > 0 {
1989 i -= len(m.Path)
1990 copy(dAtA[i:], m.Path)
1991 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
1992 i--
1993 dAtA[i] = 0x1a
1994 }
1995 if m.Ttl != nil {
1996 size, err := (*durationpb.Duration)(m.Ttl).MarshalToSizedBufferVTStrict(dAtA[:i])
1997 if err != nil {
1998 return 0, err
1999 }
2000 i -= size
2001 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2002 i--
2003 dAtA[i] = 0x12
2004 }
2005 if len(m.Name) > 0 {
2006 i -= len(m.Name)
2007 copy(dAtA[i:], m.Name)
2008 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
2009 i--
2010 dAtA[i] = 0xa
2011 }
2012 return len(dAtA) - i, nil
2013 }
2014
2015 func (m *RouteAction_HashPolicy_ConnectionProperties) MarshalVTStrict() (dAtA []byte, err error) {
2016 if m == nil {
2017 return nil, nil
2018 }
2019 size := m.SizeVT()
2020 dAtA = make([]byte, size)
2021 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2022 if err != nil {
2023 return nil, err
2024 }
2025 return dAtA[:n], nil
2026 }
2027
2028 func (m *RouteAction_HashPolicy_ConnectionProperties) MarshalToVTStrict(dAtA []byte) (int, error) {
2029 size := m.SizeVT()
2030 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2031 }
2032
2033 func (m *RouteAction_HashPolicy_ConnectionProperties) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2034 if m == nil {
2035 return 0, nil
2036 }
2037 i := len(dAtA)
2038 _ = i
2039 var l int
2040 _ = l
2041 if m.unknownFields != nil {
2042 i -= len(m.unknownFields)
2043 copy(dAtA[i:], m.unknownFields)
2044 }
2045 if m.SourceIp {
2046 i--
2047 if m.SourceIp {
2048 dAtA[i] = 1
2049 } else {
2050 dAtA[i] = 0
2051 }
2052 i--
2053 dAtA[i] = 0x8
2054 }
2055 return len(dAtA) - i, nil
2056 }
2057
2058 func (m *RouteAction_HashPolicy_QueryParameter) MarshalVTStrict() (dAtA []byte, err error) {
2059 if m == nil {
2060 return nil, nil
2061 }
2062 size := m.SizeVT()
2063 dAtA = make([]byte, size)
2064 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2065 if err != nil {
2066 return nil, err
2067 }
2068 return dAtA[:n], nil
2069 }
2070
2071 func (m *RouteAction_HashPolicy_QueryParameter) MarshalToVTStrict(dAtA []byte) (int, error) {
2072 size := m.SizeVT()
2073 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2074 }
2075
2076 func (m *RouteAction_HashPolicy_QueryParameter) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2077 if m == nil {
2078 return 0, nil
2079 }
2080 i := len(dAtA)
2081 _ = i
2082 var l int
2083 _ = l
2084 if m.unknownFields != nil {
2085 i -= len(m.unknownFields)
2086 copy(dAtA[i:], m.unknownFields)
2087 }
2088 if len(m.Name) > 0 {
2089 i -= len(m.Name)
2090 copy(dAtA[i:], m.Name)
2091 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
2092 i--
2093 dAtA[i] = 0xa
2094 }
2095 return len(dAtA) - i, nil
2096 }
2097
2098 func (m *RouteAction_HashPolicy_FilterState) MarshalVTStrict() (dAtA []byte, err error) {
2099 if m == nil {
2100 return nil, nil
2101 }
2102 size := m.SizeVT()
2103 dAtA = make([]byte, size)
2104 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2105 if err != nil {
2106 return nil, err
2107 }
2108 return dAtA[:n], nil
2109 }
2110
2111 func (m *RouteAction_HashPolicy_FilterState) MarshalToVTStrict(dAtA []byte) (int, error) {
2112 size := m.SizeVT()
2113 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2114 }
2115
2116 func (m *RouteAction_HashPolicy_FilterState) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2117 if m == nil {
2118 return 0, nil
2119 }
2120 i := len(dAtA)
2121 _ = i
2122 var l int
2123 _ = l
2124 if m.unknownFields != nil {
2125 i -= len(m.unknownFields)
2126 copy(dAtA[i:], m.unknownFields)
2127 }
2128 if len(m.Key) > 0 {
2129 i -= len(m.Key)
2130 copy(dAtA[i:], m.Key)
2131 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))
2132 i--
2133 dAtA[i] = 0xa
2134 }
2135 return len(dAtA) - i, nil
2136 }
2137
2138 func (m *RouteAction_HashPolicy) MarshalVTStrict() (dAtA []byte, err error) {
2139 if m == nil {
2140 return nil, nil
2141 }
2142 size := m.SizeVT()
2143 dAtA = make([]byte, size)
2144 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2145 if err != nil {
2146 return nil, err
2147 }
2148 return dAtA[:n], nil
2149 }
2150
2151 func (m *RouteAction_HashPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
2152 size := m.SizeVT()
2153 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2154 }
2155
2156 func (m *RouteAction_HashPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2157 if m == nil {
2158 return 0, nil
2159 }
2160 i := len(dAtA)
2161 _ = i
2162 var l int
2163 _ = l
2164 if m.unknownFields != nil {
2165 i -= len(m.unknownFields)
2166 copy(dAtA[i:], m.unknownFields)
2167 }
2168 if msg, ok := m.PolicySpecifier.(*RouteAction_HashPolicy_FilterState_); ok {
2169 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2170 if err != nil {
2171 return 0, err
2172 }
2173 i -= size
2174 }
2175 if msg, ok := m.PolicySpecifier.(*RouteAction_HashPolicy_QueryParameter_); ok {
2176 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2177 if err != nil {
2178 return 0, err
2179 }
2180 i -= size
2181 }
2182 if m.Terminal {
2183 i--
2184 if m.Terminal {
2185 dAtA[i] = 1
2186 } else {
2187 dAtA[i] = 0
2188 }
2189 i--
2190 dAtA[i] = 0x20
2191 }
2192 if msg, ok := m.PolicySpecifier.(*RouteAction_HashPolicy_ConnectionProperties_); ok {
2193 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2194 if err != nil {
2195 return 0, err
2196 }
2197 i -= size
2198 }
2199 if msg, ok := m.PolicySpecifier.(*RouteAction_HashPolicy_Cookie_); ok {
2200 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2201 if err != nil {
2202 return 0, err
2203 }
2204 i -= size
2205 }
2206 if msg, ok := m.PolicySpecifier.(*RouteAction_HashPolicy_Header_); ok {
2207 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2208 if err != nil {
2209 return 0, err
2210 }
2211 i -= size
2212 }
2213 return len(dAtA) - i, nil
2214 }
2215
2216 func (m *RouteAction_HashPolicy_Header_) MarshalToVTStrict(dAtA []byte) (int, error) {
2217 size := m.SizeVT()
2218 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2219 }
2220
2221 func (m *RouteAction_HashPolicy_Header_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2222 i := len(dAtA)
2223 if m.Header != nil {
2224 size, err := m.Header.MarshalToSizedBufferVTStrict(dAtA[:i])
2225 if err != nil {
2226 return 0, err
2227 }
2228 i -= size
2229 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2230 i--
2231 dAtA[i] = 0xa
2232 } else {
2233 i = protohelpers.EncodeVarint(dAtA, i, 0)
2234 i--
2235 dAtA[i] = 0xa
2236 }
2237 return len(dAtA) - i, nil
2238 }
2239 func (m *RouteAction_HashPolicy_Cookie_) MarshalToVTStrict(dAtA []byte) (int, error) {
2240 size := m.SizeVT()
2241 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2242 }
2243
2244 func (m *RouteAction_HashPolicy_Cookie_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2245 i := len(dAtA)
2246 if m.Cookie != nil {
2247 size, err := m.Cookie.MarshalToSizedBufferVTStrict(dAtA[:i])
2248 if err != nil {
2249 return 0, err
2250 }
2251 i -= size
2252 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2253 i--
2254 dAtA[i] = 0x12
2255 } else {
2256 i = protohelpers.EncodeVarint(dAtA, i, 0)
2257 i--
2258 dAtA[i] = 0x12
2259 }
2260 return len(dAtA) - i, nil
2261 }
2262 func (m *RouteAction_HashPolicy_ConnectionProperties_) MarshalToVTStrict(dAtA []byte) (int, error) {
2263 size := m.SizeVT()
2264 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2265 }
2266
2267 func (m *RouteAction_HashPolicy_ConnectionProperties_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2268 i := len(dAtA)
2269 if m.ConnectionProperties != nil {
2270 size, err := m.ConnectionProperties.MarshalToSizedBufferVTStrict(dAtA[:i])
2271 if err != nil {
2272 return 0, err
2273 }
2274 i -= size
2275 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2276 i--
2277 dAtA[i] = 0x1a
2278 } else {
2279 i = protohelpers.EncodeVarint(dAtA, i, 0)
2280 i--
2281 dAtA[i] = 0x1a
2282 }
2283 return len(dAtA) - i, nil
2284 }
2285 func (m *RouteAction_HashPolicy_QueryParameter_) MarshalToVTStrict(dAtA []byte) (int, error) {
2286 size := m.SizeVT()
2287 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2288 }
2289
2290 func (m *RouteAction_HashPolicy_QueryParameter_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2291 i := len(dAtA)
2292 if m.QueryParameter != nil {
2293 size, err := m.QueryParameter.MarshalToSizedBufferVTStrict(dAtA[:i])
2294 if err != nil {
2295 return 0, err
2296 }
2297 i -= size
2298 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2299 i--
2300 dAtA[i] = 0x2a
2301 } else {
2302 i = protohelpers.EncodeVarint(dAtA, i, 0)
2303 i--
2304 dAtA[i] = 0x2a
2305 }
2306 return len(dAtA) - i, nil
2307 }
2308 func (m *RouteAction_HashPolicy_FilterState_) MarshalToVTStrict(dAtA []byte) (int, error) {
2309 size := m.SizeVT()
2310 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2311 }
2312
2313 func (m *RouteAction_HashPolicy_FilterState_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2314 i := len(dAtA)
2315 if m.FilterState != nil {
2316 size, err := m.FilterState.MarshalToSizedBufferVTStrict(dAtA[:i])
2317 if err != nil {
2318 return 0, err
2319 }
2320 i -= size
2321 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2322 i--
2323 dAtA[i] = 0x32
2324 } else {
2325 i = protohelpers.EncodeVarint(dAtA, i, 0)
2326 i--
2327 dAtA[i] = 0x32
2328 }
2329 return len(dAtA) - i, nil
2330 }
2331 func (m *RouteAction_UpgradeConfig_ConnectConfig) MarshalVTStrict() (dAtA []byte, err error) {
2332 if m == nil {
2333 return nil, nil
2334 }
2335 size := m.SizeVT()
2336 dAtA = make([]byte, size)
2337 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2338 if err != nil {
2339 return nil, err
2340 }
2341 return dAtA[:n], nil
2342 }
2343
2344 func (m *RouteAction_UpgradeConfig_ConnectConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
2345 size := m.SizeVT()
2346 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2347 }
2348
2349 func (m *RouteAction_UpgradeConfig_ConnectConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2350 if m == nil {
2351 return 0, nil
2352 }
2353 i := len(dAtA)
2354 _ = i
2355 var l int
2356 _ = l
2357 if m.unknownFields != nil {
2358 i -= len(m.unknownFields)
2359 copy(dAtA[i:], m.unknownFields)
2360 }
2361 if m.AllowPost {
2362 i--
2363 if m.AllowPost {
2364 dAtA[i] = 1
2365 } else {
2366 dAtA[i] = 0
2367 }
2368 i--
2369 dAtA[i] = 0x10
2370 }
2371 if m.ProxyProtocolConfig != nil {
2372 if vtmsg, ok := interface{}(m.ProxyProtocolConfig).(interface {
2373 MarshalToSizedBufferVTStrict([]byte) (int, error)
2374 }); ok {
2375 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
2376 if err != nil {
2377 return 0, err
2378 }
2379 i -= size
2380 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2381 } else {
2382 encoded, err := proto.Marshal(m.ProxyProtocolConfig)
2383 if err != nil {
2384 return 0, err
2385 }
2386 i -= len(encoded)
2387 copy(dAtA[i:], encoded)
2388 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
2389 }
2390 i--
2391 dAtA[i] = 0xa
2392 }
2393 return len(dAtA) - i, nil
2394 }
2395
2396 func (m *RouteAction_UpgradeConfig) MarshalVTStrict() (dAtA []byte, err error) {
2397 if m == nil {
2398 return nil, nil
2399 }
2400 size := m.SizeVT()
2401 dAtA = make([]byte, size)
2402 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2403 if err != nil {
2404 return nil, err
2405 }
2406 return dAtA[:n], nil
2407 }
2408
2409 func (m *RouteAction_UpgradeConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
2410 size := m.SizeVT()
2411 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2412 }
2413
2414 func (m *RouteAction_UpgradeConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2415 if m == nil {
2416 return 0, nil
2417 }
2418 i := len(dAtA)
2419 _ = i
2420 var l int
2421 _ = l
2422 if m.unknownFields != nil {
2423 i -= len(m.unknownFields)
2424 copy(dAtA[i:], m.unknownFields)
2425 }
2426 if m.ConnectConfig != nil {
2427 size, err := m.ConnectConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
2428 if err != nil {
2429 return 0, err
2430 }
2431 i -= size
2432 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2433 i--
2434 dAtA[i] = 0x1a
2435 }
2436 if m.Enabled != nil {
2437 size, err := (*wrapperspb.BoolValue)(m.Enabled).MarshalToSizedBufferVTStrict(dAtA[:i])
2438 if err != nil {
2439 return 0, err
2440 }
2441 i -= size
2442 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2443 i--
2444 dAtA[i] = 0x12
2445 }
2446 if len(m.UpgradeType) > 0 {
2447 i -= len(m.UpgradeType)
2448 copy(dAtA[i:], m.UpgradeType)
2449 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.UpgradeType)))
2450 i--
2451 dAtA[i] = 0xa
2452 }
2453 return len(dAtA) - i, nil
2454 }
2455
2456 func (m *RouteAction_MaxStreamDuration) MarshalVTStrict() (dAtA []byte, err error) {
2457 if m == nil {
2458 return nil, nil
2459 }
2460 size := m.SizeVT()
2461 dAtA = make([]byte, size)
2462 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2463 if err != nil {
2464 return nil, err
2465 }
2466 return dAtA[:n], nil
2467 }
2468
2469 func (m *RouteAction_MaxStreamDuration) MarshalToVTStrict(dAtA []byte) (int, error) {
2470 size := m.SizeVT()
2471 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2472 }
2473
2474 func (m *RouteAction_MaxStreamDuration) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2475 if m == nil {
2476 return 0, nil
2477 }
2478 i := len(dAtA)
2479 _ = i
2480 var l int
2481 _ = l
2482 if m.unknownFields != nil {
2483 i -= len(m.unknownFields)
2484 copy(dAtA[i:], m.unknownFields)
2485 }
2486 if m.GrpcTimeoutHeaderOffset != nil {
2487 size, err := (*durationpb.Duration)(m.GrpcTimeoutHeaderOffset).MarshalToSizedBufferVTStrict(dAtA[:i])
2488 if err != nil {
2489 return 0, err
2490 }
2491 i -= size
2492 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2493 i--
2494 dAtA[i] = 0x1a
2495 }
2496 if m.GrpcTimeoutHeaderMax != nil {
2497 size, err := (*durationpb.Duration)(m.GrpcTimeoutHeaderMax).MarshalToSizedBufferVTStrict(dAtA[:i])
2498 if err != nil {
2499 return 0, err
2500 }
2501 i -= size
2502 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2503 i--
2504 dAtA[i] = 0x12
2505 }
2506 if m.MaxStreamDuration != nil {
2507 size, err := (*durationpb.Duration)(m.MaxStreamDuration).MarshalToSizedBufferVTStrict(dAtA[:i])
2508 if err != nil {
2509 return 0, err
2510 }
2511 i -= size
2512 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2513 i--
2514 dAtA[i] = 0xa
2515 }
2516 return len(dAtA) - i, nil
2517 }
2518
2519 func (m *RouteAction) MarshalVTStrict() (dAtA []byte, err error) {
2520 if m == nil {
2521 return nil, nil
2522 }
2523 size := m.SizeVT()
2524 dAtA = make([]byte, size)
2525 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
2526 if err != nil {
2527 return nil, err
2528 }
2529 return dAtA[:n], nil
2530 }
2531
2532 func (m *RouteAction) MarshalToVTStrict(dAtA []byte) (int, error) {
2533 size := m.SizeVT()
2534 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2535 }
2536
2537 func (m *RouteAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2538 if m == nil {
2539 return 0, nil
2540 }
2541 i := len(dAtA)
2542 _ = i
2543 var l int
2544 _ = l
2545 if m.unknownFields != nil {
2546 i -= len(m.unknownFields)
2547 copy(dAtA[i:], m.unknownFields)
2548 }
2549 if m.PathRewritePolicy != nil {
2550 if vtmsg, ok := interface{}(m.PathRewritePolicy).(interface {
2551 MarshalToSizedBufferVTStrict([]byte) (int, error)
2552 }); ok {
2553 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
2554 if err != nil {
2555 return 0, err
2556 }
2557 i -= size
2558 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2559 } else {
2560 encoded, err := proto.Marshal(m.PathRewritePolicy)
2561 if err != nil {
2562 return 0, err
2563 }
2564 i -= len(encoded)
2565 copy(dAtA[i:], encoded)
2566 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
2567 }
2568 i--
2569 dAtA[i] = 0x2
2570 i--
2571 dAtA[i] = 0xca
2572 }
2573 if m.EarlyDataPolicy != nil {
2574 if vtmsg, ok := interface{}(m.EarlyDataPolicy).(interface {
2575 MarshalToSizedBufferVTStrict([]byte) (int, error)
2576 }); ok {
2577 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
2578 if err != nil {
2579 return 0, err
2580 }
2581 i -= size
2582 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2583 } else {
2584 encoded, err := proto.Marshal(m.EarlyDataPolicy)
2585 if err != nil {
2586 return 0, err
2587 }
2588 i -= len(encoded)
2589 copy(dAtA[i:], encoded)
2590 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
2591 }
2592 i--
2593 dAtA[i] = 0x2
2594 i--
2595 dAtA[i] = 0xc2
2596 }
2597 if msg, ok := m.ClusterSpecifier.(*RouteAction_InlineClusterSpecifierPlugin); ok {
2598 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2599 if err != nil {
2600 return 0, err
2601 }
2602 i -= size
2603 }
2604 if m.AppendXForwardedHost {
2605 i--
2606 if m.AppendXForwardedHost {
2607 dAtA[i] = 1
2608 } else {
2609 dAtA[i] = 0
2610 }
2611 i--
2612 dAtA[i] = 0x2
2613 i--
2614 dAtA[i] = 0xb0
2615 }
2616 if msg, ok := m.ClusterSpecifier.(*RouteAction_ClusterSpecifierPlugin); ok {
2617 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2618 if err != nil {
2619 return 0, err
2620 }
2621 i -= size
2622 }
2623 if m.MaxStreamDuration != nil {
2624 size, err := m.MaxStreamDuration.MarshalToSizedBufferVTStrict(dAtA[:i])
2625 if err != nil {
2626 return 0, err
2627 }
2628 i -= size
2629 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2630 i--
2631 dAtA[i] = 0x2
2632 i--
2633 dAtA[i] = 0xa2
2634 }
2635 if msg, ok := m.HostRewriteSpecifier.(*RouteAction_HostRewritePathRegex); ok {
2636 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2637 if err != nil {
2638 return 0, err
2639 }
2640 i -= size
2641 }
2642 if m.InternalRedirectPolicy != nil {
2643 size, err := m.InternalRedirectPolicy.MarshalToSizedBufferVTStrict(dAtA[:i])
2644 if err != nil {
2645 return 0, err
2646 }
2647 i -= size
2648 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2649 i--
2650 dAtA[i] = 0x2
2651 i--
2652 dAtA[i] = 0x92
2653 }
2654 if m.RetryPolicyTypedConfig != nil {
2655 size, err := (*anypb.Any)(m.RetryPolicyTypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
2656 if err != nil {
2657 return 0, err
2658 }
2659 i -= size
2660 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2661 i--
2662 dAtA[i] = 0x2
2663 i--
2664 dAtA[i] = 0x8a
2665 }
2666 if m.RegexRewrite != nil {
2667 if vtmsg, ok := interface{}(m.RegexRewrite).(interface {
2668 MarshalToSizedBufferVTStrict([]byte) (int, error)
2669 }); ok {
2670 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
2671 if err != nil {
2672 return 0, err
2673 }
2674 i -= size
2675 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2676 } else {
2677 encoded, err := proto.Marshal(m.RegexRewrite)
2678 if err != nil {
2679 return 0, err
2680 }
2681 i -= len(encoded)
2682 copy(dAtA[i:], encoded)
2683 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
2684 }
2685 i--
2686 dAtA[i] = 0x2
2687 i--
2688 dAtA[i] = 0x82
2689 }
2690 if m.MaxInternalRedirects != nil {
2691 size, err := (*wrapperspb.UInt32Value)(m.MaxInternalRedirects).MarshalToSizedBufferVTStrict(dAtA[:i])
2692 if err != nil {
2693 return 0, err
2694 }
2695 i -= size
2696 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2697 i--
2698 dAtA[i] = 0x1
2699 i--
2700 dAtA[i] = 0xfa
2701 }
2702 if len(m.RequestMirrorPolicies) > 0 {
2703 for iNdEx := len(m.RequestMirrorPolicies) - 1; iNdEx >= 0; iNdEx-- {
2704 size, err := m.RequestMirrorPolicies[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
2705 if err != nil {
2706 return 0, err
2707 }
2708 i -= size
2709 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2710 i--
2711 dAtA[i] = 0x1
2712 i--
2713 dAtA[i] = 0xf2
2714 }
2715 }
2716 if msg, ok := m.HostRewriteSpecifier.(*RouteAction_HostRewriteHeader); ok {
2717 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2718 if err != nil {
2719 return 0, err
2720 }
2721 i -= size
2722 }
2723 if m.GrpcTimeoutOffset != nil {
2724 size, err := (*durationpb.Duration)(m.GrpcTimeoutOffset).MarshalToSizedBufferVTStrict(dAtA[:i])
2725 if err != nil {
2726 return 0, err
2727 }
2728 i -= size
2729 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2730 i--
2731 dAtA[i] = 0x1
2732 i--
2733 dAtA[i] = 0xe2
2734 }
2735 if m.HedgePolicy != nil {
2736 size, err := m.HedgePolicy.MarshalToSizedBufferVTStrict(dAtA[:i])
2737 if err != nil {
2738 return 0, err
2739 }
2740 i -= size
2741 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2742 i--
2743 dAtA[i] = 0x1
2744 i--
2745 dAtA[i] = 0xda
2746 }
2747 if m.InternalRedirectAction != 0 {
2748 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InternalRedirectAction))
2749 i--
2750 dAtA[i] = 0x1
2751 i--
2752 dAtA[i] = 0xd0
2753 }
2754 if len(m.UpgradeConfigs) > 0 {
2755 for iNdEx := len(m.UpgradeConfigs) - 1; iNdEx >= 0; iNdEx-- {
2756 size, err := m.UpgradeConfigs[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
2757 if err != nil {
2758 return 0, err
2759 }
2760 i -= size
2761 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2762 i--
2763 dAtA[i] = 0x1
2764 i--
2765 dAtA[i] = 0xca
2766 }
2767 }
2768 if m.IdleTimeout != nil {
2769 size, err := (*durationpb.Duration)(m.IdleTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
2770 if err != nil {
2771 return 0, err
2772 }
2773 i -= size
2774 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2775 i--
2776 dAtA[i] = 0x1
2777 i--
2778 dAtA[i] = 0xc2
2779 }
2780 if m.MaxGrpcTimeout != nil {
2781 size, err := (*durationpb.Duration)(m.MaxGrpcTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
2782 if err != nil {
2783 return 0, err
2784 }
2785 i -= size
2786 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2787 i--
2788 dAtA[i] = 0x1
2789 i--
2790 dAtA[i] = 0xba
2791 }
2792 if m.ClusterNotFoundResponseCode != 0 {
2793 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClusterNotFoundResponseCode))
2794 i--
2795 dAtA[i] = 0x1
2796 i--
2797 dAtA[i] = 0xa0
2798 }
2799 if m.Cors != nil {
2800 size, err := m.Cors.MarshalToSizedBufferVTStrict(dAtA[:i])
2801 if err != nil {
2802 return 0, err
2803 }
2804 i -= size
2805 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2806 i--
2807 dAtA[i] = 0x1
2808 i--
2809 dAtA[i] = 0x8a
2810 }
2811 if len(m.HashPolicy) > 0 {
2812 for iNdEx := len(m.HashPolicy) - 1; iNdEx >= 0; iNdEx-- {
2813 size, err := m.HashPolicy[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
2814 if err != nil {
2815 return 0, err
2816 }
2817 i -= size
2818 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2819 i--
2820 dAtA[i] = 0x7a
2821 }
2822 }
2823 if m.IncludeVhRateLimits != nil {
2824 size, err := (*wrapperspb.BoolValue)(m.IncludeVhRateLimits).MarshalToSizedBufferVTStrict(dAtA[:i])
2825 if err != nil {
2826 return 0, err
2827 }
2828 i -= size
2829 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2830 i--
2831 dAtA[i] = 0x72
2832 }
2833 if len(m.RateLimits) > 0 {
2834 for iNdEx := len(m.RateLimits) - 1; iNdEx >= 0; iNdEx-- {
2835 size, err := m.RateLimits[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
2836 if err != nil {
2837 return 0, err
2838 }
2839 i -= size
2840 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2841 i--
2842 dAtA[i] = 0x6a
2843 }
2844 }
2845 if m.Priority != 0 {
2846 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Priority))
2847 i--
2848 dAtA[i] = 0x58
2849 }
2850 if m.RetryPolicy != nil {
2851 size, err := m.RetryPolicy.MarshalToSizedBufferVTStrict(dAtA[:i])
2852 if err != nil {
2853 return 0, err
2854 }
2855 i -= size
2856 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2857 i--
2858 dAtA[i] = 0x4a
2859 }
2860 if m.Timeout != nil {
2861 size, err := (*durationpb.Duration)(m.Timeout).MarshalToSizedBufferVTStrict(dAtA[:i])
2862 if err != nil {
2863 return 0, err
2864 }
2865 i -= size
2866 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2867 i--
2868 dAtA[i] = 0x42
2869 }
2870 if msg, ok := m.HostRewriteSpecifier.(*RouteAction_AutoHostRewrite); ok {
2871 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2872 if err != nil {
2873 return 0, err
2874 }
2875 i -= size
2876 }
2877 if msg, ok := m.HostRewriteSpecifier.(*RouteAction_HostRewriteLiteral); ok {
2878 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2879 if err != nil {
2880 return 0, err
2881 }
2882 i -= size
2883 }
2884 if len(m.PrefixRewrite) > 0 {
2885 i -= len(m.PrefixRewrite)
2886 copy(dAtA[i:], m.PrefixRewrite)
2887 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrefixRewrite)))
2888 i--
2889 dAtA[i] = 0x2a
2890 }
2891 if m.MetadataMatch != nil {
2892 if vtmsg, ok := interface{}(m.MetadataMatch).(interface {
2893 MarshalToSizedBufferVTStrict([]byte) (int, error)
2894 }); ok {
2895 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
2896 if err != nil {
2897 return 0, err
2898 }
2899 i -= size
2900 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2901 } else {
2902 encoded, err := proto.Marshal(m.MetadataMatch)
2903 if err != nil {
2904 return 0, err
2905 }
2906 i -= len(encoded)
2907 copy(dAtA[i:], encoded)
2908 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
2909 }
2910 i--
2911 dAtA[i] = 0x22
2912 }
2913 if msg, ok := m.ClusterSpecifier.(*RouteAction_WeightedClusters); ok {
2914 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2915 if err != nil {
2916 return 0, err
2917 }
2918 i -= size
2919 }
2920 if msg, ok := m.ClusterSpecifier.(*RouteAction_ClusterHeader); ok {
2921 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2922 if err != nil {
2923 return 0, err
2924 }
2925 i -= size
2926 }
2927 if msg, ok := m.ClusterSpecifier.(*RouteAction_Cluster); ok {
2928 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
2929 if err != nil {
2930 return 0, err
2931 }
2932 i -= size
2933 }
2934 return len(dAtA) - i, nil
2935 }
2936
2937 func (m *RouteAction_Cluster) MarshalToVTStrict(dAtA []byte) (int, error) {
2938 size := m.SizeVT()
2939 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2940 }
2941
2942 func (m *RouteAction_Cluster) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2943 i := len(dAtA)
2944 i -= len(m.Cluster)
2945 copy(dAtA[i:], m.Cluster)
2946 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Cluster)))
2947 i--
2948 dAtA[i] = 0xa
2949 return len(dAtA) - i, nil
2950 }
2951 func (m *RouteAction_ClusterHeader) MarshalToVTStrict(dAtA []byte) (int, error) {
2952 size := m.SizeVT()
2953 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2954 }
2955
2956 func (m *RouteAction_ClusterHeader) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2957 i := len(dAtA)
2958 i -= len(m.ClusterHeader)
2959 copy(dAtA[i:], m.ClusterHeader)
2960 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterHeader)))
2961 i--
2962 dAtA[i] = 0x12
2963 return len(dAtA) - i, nil
2964 }
2965 func (m *RouteAction_WeightedClusters) MarshalToVTStrict(dAtA []byte) (int, error) {
2966 size := m.SizeVT()
2967 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2968 }
2969
2970 func (m *RouteAction_WeightedClusters) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2971 i := len(dAtA)
2972 if m.WeightedClusters != nil {
2973 size, err := m.WeightedClusters.MarshalToSizedBufferVTStrict(dAtA[:i])
2974 if err != nil {
2975 return 0, err
2976 }
2977 i -= size
2978 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2979 i--
2980 dAtA[i] = 0x1a
2981 } else {
2982 i = protohelpers.EncodeVarint(dAtA, i, 0)
2983 i--
2984 dAtA[i] = 0x1a
2985 }
2986 return len(dAtA) - i, nil
2987 }
2988 func (m *RouteAction_HostRewriteLiteral) MarshalToVTStrict(dAtA []byte) (int, error) {
2989 size := m.SizeVT()
2990 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
2991 }
2992
2993 func (m *RouteAction_HostRewriteLiteral) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
2994 i := len(dAtA)
2995 i -= len(m.HostRewriteLiteral)
2996 copy(dAtA[i:], m.HostRewriteLiteral)
2997 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HostRewriteLiteral)))
2998 i--
2999 dAtA[i] = 0x32
3000 return len(dAtA) - i, nil
3001 }
3002 func (m *RouteAction_AutoHostRewrite) MarshalToVTStrict(dAtA []byte) (int, error) {
3003 size := m.SizeVT()
3004 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3005 }
3006
3007 func (m *RouteAction_AutoHostRewrite) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3008 i := len(dAtA)
3009 if m.AutoHostRewrite != nil {
3010 size, err := (*wrapperspb.BoolValue)(m.AutoHostRewrite).MarshalToSizedBufferVTStrict(dAtA[:i])
3011 if err != nil {
3012 return 0, err
3013 }
3014 i -= size
3015 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3016 i--
3017 dAtA[i] = 0x3a
3018 } else {
3019 i = protohelpers.EncodeVarint(dAtA, i, 0)
3020 i--
3021 dAtA[i] = 0x3a
3022 }
3023 return len(dAtA) - i, nil
3024 }
3025 func (m *RouteAction_HostRewriteHeader) MarshalToVTStrict(dAtA []byte) (int, error) {
3026 size := m.SizeVT()
3027 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3028 }
3029
3030 func (m *RouteAction_HostRewriteHeader) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3031 i := len(dAtA)
3032 i -= len(m.HostRewriteHeader)
3033 copy(dAtA[i:], m.HostRewriteHeader)
3034 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HostRewriteHeader)))
3035 i--
3036 dAtA[i] = 0x1
3037 i--
3038 dAtA[i] = 0xea
3039 return len(dAtA) - i, nil
3040 }
3041 func (m *RouteAction_HostRewritePathRegex) MarshalToVTStrict(dAtA []byte) (int, error) {
3042 size := m.SizeVT()
3043 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3044 }
3045
3046 func (m *RouteAction_HostRewritePathRegex) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3047 i := len(dAtA)
3048 if m.HostRewritePathRegex != nil {
3049 if vtmsg, ok := interface{}(m.HostRewritePathRegex).(interface {
3050 MarshalToSizedBufferVTStrict([]byte) (int, error)
3051 }); ok {
3052 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
3053 if err != nil {
3054 return 0, err
3055 }
3056 i -= size
3057 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3058 } else {
3059 encoded, err := proto.Marshal(m.HostRewritePathRegex)
3060 if err != nil {
3061 return 0, err
3062 }
3063 i -= len(encoded)
3064 copy(dAtA[i:], encoded)
3065 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
3066 }
3067 i--
3068 dAtA[i] = 0x2
3069 i--
3070 dAtA[i] = 0x9a
3071 } else {
3072 i = protohelpers.EncodeVarint(dAtA, i, 0)
3073 i--
3074 dAtA[i] = 0x2
3075 i--
3076 dAtA[i] = 0x9a
3077 }
3078 return len(dAtA) - i, nil
3079 }
3080 func (m *RouteAction_ClusterSpecifierPlugin) MarshalToVTStrict(dAtA []byte) (int, error) {
3081 size := m.SizeVT()
3082 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3083 }
3084
3085 func (m *RouteAction_ClusterSpecifierPlugin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3086 i := len(dAtA)
3087 i -= len(m.ClusterSpecifierPlugin)
3088 copy(dAtA[i:], m.ClusterSpecifierPlugin)
3089 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterSpecifierPlugin)))
3090 i--
3091 dAtA[i] = 0x2
3092 i--
3093 dAtA[i] = 0xaa
3094 return len(dAtA) - i, nil
3095 }
3096 func (m *RouteAction_InlineClusterSpecifierPlugin) MarshalToVTStrict(dAtA []byte) (int, error) {
3097 size := m.SizeVT()
3098 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3099 }
3100
3101 func (m *RouteAction_InlineClusterSpecifierPlugin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3102 i := len(dAtA)
3103 if m.InlineClusterSpecifierPlugin != nil {
3104 size, err := m.InlineClusterSpecifierPlugin.MarshalToSizedBufferVTStrict(dAtA[:i])
3105 if err != nil {
3106 return 0, err
3107 }
3108 i -= size
3109 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3110 i--
3111 dAtA[i] = 0x2
3112 i--
3113 dAtA[i] = 0xba
3114 } else {
3115 i = protohelpers.EncodeVarint(dAtA, i, 0)
3116 i--
3117 dAtA[i] = 0x2
3118 i--
3119 dAtA[i] = 0xba
3120 }
3121 return len(dAtA) - i, nil
3122 }
3123 func (m *RetryPolicy_RetryPriority) MarshalVTStrict() (dAtA []byte, err error) {
3124 if m == nil {
3125 return nil, nil
3126 }
3127 size := m.SizeVT()
3128 dAtA = make([]byte, size)
3129 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3130 if err != nil {
3131 return nil, err
3132 }
3133 return dAtA[:n], nil
3134 }
3135
3136 func (m *RetryPolicy_RetryPriority) MarshalToVTStrict(dAtA []byte) (int, error) {
3137 size := m.SizeVT()
3138 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3139 }
3140
3141 func (m *RetryPolicy_RetryPriority) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3142 if m == nil {
3143 return 0, nil
3144 }
3145 i := len(dAtA)
3146 _ = i
3147 var l int
3148 _ = l
3149 if m.unknownFields != nil {
3150 i -= len(m.unknownFields)
3151 copy(dAtA[i:], m.unknownFields)
3152 }
3153 if msg, ok := m.ConfigType.(*RetryPolicy_RetryPriority_TypedConfig); ok {
3154 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3155 if err != nil {
3156 return 0, err
3157 }
3158 i -= size
3159 }
3160 if len(m.Name) > 0 {
3161 i -= len(m.Name)
3162 copy(dAtA[i:], m.Name)
3163 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
3164 i--
3165 dAtA[i] = 0xa
3166 }
3167 return len(dAtA) - i, nil
3168 }
3169
3170 func (m *RetryPolicy_RetryPriority_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
3171 size := m.SizeVT()
3172 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3173 }
3174
3175 func (m *RetryPolicy_RetryPriority_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3176 i := len(dAtA)
3177 if m.TypedConfig != nil {
3178 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
3179 if err != nil {
3180 return 0, err
3181 }
3182 i -= size
3183 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3184 i--
3185 dAtA[i] = 0x1a
3186 } else {
3187 i = protohelpers.EncodeVarint(dAtA, i, 0)
3188 i--
3189 dAtA[i] = 0x1a
3190 }
3191 return len(dAtA) - i, nil
3192 }
3193 func (m *RetryPolicy_RetryHostPredicate) MarshalVTStrict() (dAtA []byte, err error) {
3194 if m == nil {
3195 return nil, nil
3196 }
3197 size := m.SizeVT()
3198 dAtA = make([]byte, size)
3199 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3200 if err != nil {
3201 return nil, err
3202 }
3203 return dAtA[:n], nil
3204 }
3205
3206 func (m *RetryPolicy_RetryHostPredicate) MarshalToVTStrict(dAtA []byte) (int, error) {
3207 size := m.SizeVT()
3208 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3209 }
3210
3211 func (m *RetryPolicy_RetryHostPredicate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3212 if m == nil {
3213 return 0, nil
3214 }
3215 i := len(dAtA)
3216 _ = i
3217 var l int
3218 _ = l
3219 if m.unknownFields != nil {
3220 i -= len(m.unknownFields)
3221 copy(dAtA[i:], m.unknownFields)
3222 }
3223 if msg, ok := m.ConfigType.(*RetryPolicy_RetryHostPredicate_TypedConfig); ok {
3224 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3225 if err != nil {
3226 return 0, err
3227 }
3228 i -= size
3229 }
3230 if len(m.Name) > 0 {
3231 i -= len(m.Name)
3232 copy(dAtA[i:], m.Name)
3233 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
3234 i--
3235 dAtA[i] = 0xa
3236 }
3237 return len(dAtA) - i, nil
3238 }
3239
3240 func (m *RetryPolicy_RetryHostPredicate_TypedConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
3241 size := m.SizeVT()
3242 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3243 }
3244
3245 func (m *RetryPolicy_RetryHostPredicate_TypedConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3246 i := len(dAtA)
3247 if m.TypedConfig != nil {
3248 size, err := (*anypb.Any)(m.TypedConfig).MarshalToSizedBufferVTStrict(dAtA[:i])
3249 if err != nil {
3250 return 0, err
3251 }
3252 i -= size
3253 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3254 i--
3255 dAtA[i] = 0x1a
3256 } else {
3257 i = protohelpers.EncodeVarint(dAtA, i, 0)
3258 i--
3259 dAtA[i] = 0x1a
3260 }
3261 return len(dAtA) - i, nil
3262 }
3263 func (m *RetryPolicy_RetryBackOff) MarshalVTStrict() (dAtA []byte, err error) {
3264 if m == nil {
3265 return nil, nil
3266 }
3267 size := m.SizeVT()
3268 dAtA = make([]byte, size)
3269 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3270 if err != nil {
3271 return nil, err
3272 }
3273 return dAtA[:n], nil
3274 }
3275
3276 func (m *RetryPolicy_RetryBackOff) MarshalToVTStrict(dAtA []byte) (int, error) {
3277 size := m.SizeVT()
3278 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3279 }
3280
3281 func (m *RetryPolicy_RetryBackOff) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3282 if m == nil {
3283 return 0, nil
3284 }
3285 i := len(dAtA)
3286 _ = i
3287 var l int
3288 _ = l
3289 if m.unknownFields != nil {
3290 i -= len(m.unknownFields)
3291 copy(dAtA[i:], m.unknownFields)
3292 }
3293 if m.MaxInterval != nil {
3294 size, err := (*durationpb.Duration)(m.MaxInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
3295 if err != nil {
3296 return 0, err
3297 }
3298 i -= size
3299 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3300 i--
3301 dAtA[i] = 0x12
3302 }
3303 if m.BaseInterval != nil {
3304 size, err := (*durationpb.Duration)(m.BaseInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
3305 if err != nil {
3306 return 0, err
3307 }
3308 i -= size
3309 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3310 i--
3311 dAtA[i] = 0xa
3312 }
3313 return len(dAtA) - i, nil
3314 }
3315
3316 func (m *RetryPolicy_ResetHeader) MarshalVTStrict() (dAtA []byte, err error) {
3317 if m == nil {
3318 return nil, nil
3319 }
3320 size := m.SizeVT()
3321 dAtA = make([]byte, size)
3322 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3323 if err != nil {
3324 return nil, err
3325 }
3326 return dAtA[:n], nil
3327 }
3328
3329 func (m *RetryPolicy_ResetHeader) MarshalToVTStrict(dAtA []byte) (int, error) {
3330 size := m.SizeVT()
3331 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3332 }
3333
3334 func (m *RetryPolicy_ResetHeader) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3335 if m == nil {
3336 return 0, nil
3337 }
3338 i := len(dAtA)
3339 _ = i
3340 var l int
3341 _ = l
3342 if m.unknownFields != nil {
3343 i -= len(m.unknownFields)
3344 copy(dAtA[i:], m.unknownFields)
3345 }
3346 if m.Format != 0 {
3347 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Format))
3348 i--
3349 dAtA[i] = 0x10
3350 }
3351 if len(m.Name) > 0 {
3352 i -= len(m.Name)
3353 copy(dAtA[i:], m.Name)
3354 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
3355 i--
3356 dAtA[i] = 0xa
3357 }
3358 return len(dAtA) - i, nil
3359 }
3360
3361 func (m *RetryPolicy_RateLimitedRetryBackOff) MarshalVTStrict() (dAtA []byte, err error) {
3362 if m == nil {
3363 return nil, nil
3364 }
3365 size := m.SizeVT()
3366 dAtA = make([]byte, size)
3367 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3368 if err != nil {
3369 return nil, err
3370 }
3371 return dAtA[:n], nil
3372 }
3373
3374 func (m *RetryPolicy_RateLimitedRetryBackOff) MarshalToVTStrict(dAtA []byte) (int, error) {
3375 size := m.SizeVT()
3376 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3377 }
3378
3379 func (m *RetryPolicy_RateLimitedRetryBackOff) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3380 if m == nil {
3381 return 0, nil
3382 }
3383 i := len(dAtA)
3384 _ = i
3385 var l int
3386 _ = l
3387 if m.unknownFields != nil {
3388 i -= len(m.unknownFields)
3389 copy(dAtA[i:], m.unknownFields)
3390 }
3391 if m.MaxInterval != nil {
3392 size, err := (*durationpb.Duration)(m.MaxInterval).MarshalToSizedBufferVTStrict(dAtA[:i])
3393 if err != nil {
3394 return 0, err
3395 }
3396 i -= size
3397 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3398 i--
3399 dAtA[i] = 0x12
3400 }
3401 if len(m.ResetHeaders) > 0 {
3402 for iNdEx := len(m.ResetHeaders) - 1; iNdEx >= 0; iNdEx-- {
3403 size, err := m.ResetHeaders[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
3404 if err != nil {
3405 return 0, err
3406 }
3407 i -= size
3408 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3409 i--
3410 dAtA[i] = 0xa
3411 }
3412 }
3413 return len(dAtA) - i, nil
3414 }
3415
3416 func (m *RetryPolicy) MarshalVTStrict() (dAtA []byte, err error) {
3417 if m == nil {
3418 return nil, nil
3419 }
3420 size := m.SizeVT()
3421 dAtA = make([]byte, size)
3422 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3423 if err != nil {
3424 return nil, err
3425 }
3426 return dAtA[:n], nil
3427 }
3428
3429 func (m *RetryPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
3430 size := m.SizeVT()
3431 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3432 }
3433
3434 func (m *RetryPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3435 if m == nil {
3436 return 0, nil
3437 }
3438 i := len(dAtA)
3439 _ = i
3440 var l int
3441 _ = l
3442 if m.unknownFields != nil {
3443 i -= len(m.unknownFields)
3444 copy(dAtA[i:], m.unknownFields)
3445 }
3446 if m.PerTryIdleTimeout != nil {
3447 size, err := (*durationpb.Duration)(m.PerTryIdleTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
3448 if err != nil {
3449 return 0, err
3450 }
3451 i -= size
3452 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3453 i--
3454 dAtA[i] = 0x6a
3455 }
3456 if len(m.RetryOptionsPredicates) > 0 {
3457 for iNdEx := len(m.RetryOptionsPredicates) - 1; iNdEx >= 0; iNdEx-- {
3458 if vtmsg, ok := interface{}(m.RetryOptionsPredicates[iNdEx]).(interface {
3459 MarshalToSizedBufferVTStrict([]byte) (int, error)
3460 }); ok {
3461 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
3462 if err != nil {
3463 return 0, err
3464 }
3465 i -= size
3466 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3467 } else {
3468 encoded, err := proto.Marshal(m.RetryOptionsPredicates[iNdEx])
3469 if err != nil {
3470 return 0, err
3471 }
3472 i -= len(encoded)
3473 copy(dAtA[i:], encoded)
3474 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
3475 }
3476 i--
3477 dAtA[i] = 0x62
3478 }
3479 }
3480 if m.RateLimitedRetryBackOff != nil {
3481 size, err := m.RateLimitedRetryBackOff.MarshalToSizedBufferVTStrict(dAtA[:i])
3482 if err != nil {
3483 return 0, err
3484 }
3485 i -= size
3486 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3487 i--
3488 dAtA[i] = 0x5a
3489 }
3490 if len(m.RetriableRequestHeaders) > 0 {
3491 for iNdEx := len(m.RetriableRequestHeaders) - 1; iNdEx >= 0; iNdEx-- {
3492 size, err := m.RetriableRequestHeaders[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
3493 if err != nil {
3494 return 0, err
3495 }
3496 i -= size
3497 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3498 i--
3499 dAtA[i] = 0x52
3500 }
3501 }
3502 if len(m.RetriableHeaders) > 0 {
3503 for iNdEx := len(m.RetriableHeaders) - 1; iNdEx >= 0; iNdEx-- {
3504 size, err := m.RetriableHeaders[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
3505 if err != nil {
3506 return 0, err
3507 }
3508 i -= size
3509 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3510 i--
3511 dAtA[i] = 0x4a
3512 }
3513 }
3514 if m.RetryBackOff != nil {
3515 size, err := m.RetryBackOff.MarshalToSizedBufferVTStrict(dAtA[:i])
3516 if err != nil {
3517 return 0, err
3518 }
3519 i -= size
3520 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3521 i--
3522 dAtA[i] = 0x42
3523 }
3524 if len(m.RetriableStatusCodes) > 0 {
3525 var pksize2 int
3526 for _, num := range m.RetriableStatusCodes {
3527 pksize2 += protohelpers.SizeOfVarint(uint64(num))
3528 }
3529 i -= pksize2
3530 j1 := i
3531 for _, num := range m.RetriableStatusCodes {
3532 for num >= 1<<7 {
3533 dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
3534 num >>= 7
3535 j1++
3536 }
3537 dAtA[j1] = uint8(num)
3538 j1++
3539 }
3540 i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))
3541 i--
3542 dAtA[i] = 0x3a
3543 }
3544 if m.HostSelectionRetryMaxAttempts != 0 {
3545 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HostSelectionRetryMaxAttempts))
3546 i--
3547 dAtA[i] = 0x30
3548 }
3549 if len(m.RetryHostPredicate) > 0 {
3550 for iNdEx := len(m.RetryHostPredicate) - 1; iNdEx >= 0; iNdEx-- {
3551 size, err := m.RetryHostPredicate[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
3552 if err != nil {
3553 return 0, err
3554 }
3555 i -= size
3556 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3557 i--
3558 dAtA[i] = 0x2a
3559 }
3560 }
3561 if m.RetryPriority != nil {
3562 size, err := m.RetryPriority.MarshalToSizedBufferVTStrict(dAtA[:i])
3563 if err != nil {
3564 return 0, err
3565 }
3566 i -= size
3567 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3568 i--
3569 dAtA[i] = 0x22
3570 }
3571 if m.PerTryTimeout != nil {
3572 size, err := (*durationpb.Duration)(m.PerTryTimeout).MarshalToSizedBufferVTStrict(dAtA[:i])
3573 if err != nil {
3574 return 0, err
3575 }
3576 i -= size
3577 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3578 i--
3579 dAtA[i] = 0x1a
3580 }
3581 if m.NumRetries != nil {
3582 size, err := (*wrapperspb.UInt32Value)(m.NumRetries).MarshalToSizedBufferVTStrict(dAtA[:i])
3583 if err != nil {
3584 return 0, err
3585 }
3586 i -= size
3587 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3588 i--
3589 dAtA[i] = 0x12
3590 }
3591 if len(m.RetryOn) > 0 {
3592 i -= len(m.RetryOn)
3593 copy(dAtA[i:], m.RetryOn)
3594 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RetryOn)))
3595 i--
3596 dAtA[i] = 0xa
3597 }
3598 return len(dAtA) - i, nil
3599 }
3600
3601 func (m *HedgePolicy) MarshalVTStrict() (dAtA []byte, err error) {
3602 if m == nil {
3603 return nil, nil
3604 }
3605 size := m.SizeVT()
3606 dAtA = make([]byte, size)
3607 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3608 if err != nil {
3609 return nil, err
3610 }
3611 return dAtA[:n], nil
3612 }
3613
3614 func (m *HedgePolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
3615 size := m.SizeVT()
3616 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3617 }
3618
3619 func (m *HedgePolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3620 if m == nil {
3621 return 0, nil
3622 }
3623 i := len(dAtA)
3624 _ = i
3625 var l int
3626 _ = l
3627 if m.unknownFields != nil {
3628 i -= len(m.unknownFields)
3629 copy(dAtA[i:], m.unknownFields)
3630 }
3631 if m.HedgeOnPerTryTimeout {
3632 i--
3633 if m.HedgeOnPerTryTimeout {
3634 dAtA[i] = 1
3635 } else {
3636 dAtA[i] = 0
3637 }
3638 i--
3639 dAtA[i] = 0x18
3640 }
3641 if m.AdditionalRequestChance != nil {
3642 if vtmsg, ok := interface{}(m.AdditionalRequestChance).(interface {
3643 MarshalToSizedBufferVTStrict([]byte) (int, error)
3644 }); ok {
3645 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
3646 if err != nil {
3647 return 0, err
3648 }
3649 i -= size
3650 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3651 } else {
3652 encoded, err := proto.Marshal(m.AdditionalRequestChance)
3653 if err != nil {
3654 return 0, err
3655 }
3656 i -= len(encoded)
3657 copy(dAtA[i:], encoded)
3658 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
3659 }
3660 i--
3661 dAtA[i] = 0x12
3662 }
3663 if m.InitialRequests != nil {
3664 size, err := (*wrapperspb.UInt32Value)(m.InitialRequests).MarshalToSizedBufferVTStrict(dAtA[:i])
3665 if err != nil {
3666 return 0, err
3667 }
3668 i -= size
3669 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3670 i--
3671 dAtA[i] = 0xa
3672 }
3673 return len(dAtA) - i, nil
3674 }
3675
3676 func (m *RedirectAction) MarshalVTStrict() (dAtA []byte, err error) {
3677 if m == nil {
3678 return nil, nil
3679 }
3680 size := m.SizeVT()
3681 dAtA = make([]byte, size)
3682 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3683 if err != nil {
3684 return nil, err
3685 }
3686 return dAtA[:n], nil
3687 }
3688
3689 func (m *RedirectAction) MarshalToVTStrict(dAtA []byte) (int, error) {
3690 size := m.SizeVT()
3691 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3692 }
3693
3694 func (m *RedirectAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3695 if m == nil {
3696 return 0, nil
3697 }
3698 i := len(dAtA)
3699 _ = i
3700 var l int
3701 _ = l
3702 if m.unknownFields != nil {
3703 i -= len(m.unknownFields)
3704 copy(dAtA[i:], m.unknownFields)
3705 }
3706 if msg, ok := m.PathRewriteSpecifier.(*RedirectAction_RegexRewrite); ok {
3707 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3708 if err != nil {
3709 return 0, err
3710 }
3711 i -= size
3712 }
3713 if m.PortRedirect != 0 {
3714 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PortRedirect))
3715 i--
3716 dAtA[i] = 0x40
3717 }
3718 if msg, ok := m.SchemeRewriteSpecifier.(*RedirectAction_SchemeRedirect); ok {
3719 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3720 if err != nil {
3721 return 0, err
3722 }
3723 i -= size
3724 }
3725 if m.StripQuery {
3726 i--
3727 if m.StripQuery {
3728 dAtA[i] = 1
3729 } else {
3730 dAtA[i] = 0
3731 }
3732 i--
3733 dAtA[i] = 0x30
3734 }
3735 if msg, ok := m.PathRewriteSpecifier.(*RedirectAction_PrefixRewrite); ok {
3736 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3737 if err != nil {
3738 return 0, err
3739 }
3740 i -= size
3741 }
3742 if msg, ok := m.SchemeRewriteSpecifier.(*RedirectAction_HttpsRedirect); ok {
3743 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3744 if err != nil {
3745 return 0, err
3746 }
3747 i -= size
3748 }
3749 if m.ResponseCode != 0 {
3750 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ResponseCode))
3751 i--
3752 dAtA[i] = 0x18
3753 }
3754 if msg, ok := m.PathRewriteSpecifier.(*RedirectAction_PathRedirect); ok {
3755 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
3756 if err != nil {
3757 return 0, err
3758 }
3759 i -= size
3760 }
3761 if len(m.HostRedirect) > 0 {
3762 i -= len(m.HostRedirect)
3763 copy(dAtA[i:], m.HostRedirect)
3764 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HostRedirect)))
3765 i--
3766 dAtA[i] = 0xa
3767 }
3768 return len(dAtA) - i, nil
3769 }
3770
3771 func (m *RedirectAction_PathRedirect) MarshalToVTStrict(dAtA []byte) (int, error) {
3772 size := m.SizeVT()
3773 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3774 }
3775
3776 func (m *RedirectAction_PathRedirect) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3777 i := len(dAtA)
3778 i -= len(m.PathRedirect)
3779 copy(dAtA[i:], m.PathRedirect)
3780 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PathRedirect)))
3781 i--
3782 dAtA[i] = 0x12
3783 return len(dAtA) - i, nil
3784 }
3785 func (m *RedirectAction_HttpsRedirect) MarshalToVTStrict(dAtA []byte) (int, error) {
3786 size := m.SizeVT()
3787 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3788 }
3789
3790 func (m *RedirectAction_HttpsRedirect) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3791 i := len(dAtA)
3792 i--
3793 if m.HttpsRedirect {
3794 dAtA[i] = 1
3795 } else {
3796 dAtA[i] = 0
3797 }
3798 i--
3799 dAtA[i] = 0x20
3800 return len(dAtA) - i, nil
3801 }
3802 func (m *RedirectAction_PrefixRewrite) MarshalToVTStrict(dAtA []byte) (int, error) {
3803 size := m.SizeVT()
3804 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3805 }
3806
3807 func (m *RedirectAction_PrefixRewrite) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3808 i := len(dAtA)
3809 i -= len(m.PrefixRewrite)
3810 copy(dAtA[i:], m.PrefixRewrite)
3811 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrefixRewrite)))
3812 i--
3813 dAtA[i] = 0x2a
3814 return len(dAtA) - i, nil
3815 }
3816 func (m *RedirectAction_SchemeRedirect) MarshalToVTStrict(dAtA []byte) (int, error) {
3817 size := m.SizeVT()
3818 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3819 }
3820
3821 func (m *RedirectAction_SchemeRedirect) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3822 i := len(dAtA)
3823 i -= len(m.SchemeRedirect)
3824 copy(dAtA[i:], m.SchemeRedirect)
3825 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SchemeRedirect)))
3826 i--
3827 dAtA[i] = 0x3a
3828 return len(dAtA) - i, nil
3829 }
3830 func (m *RedirectAction_RegexRewrite) MarshalToVTStrict(dAtA []byte) (int, error) {
3831 size := m.SizeVT()
3832 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3833 }
3834
3835 func (m *RedirectAction_RegexRewrite) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3836 i := len(dAtA)
3837 if m.RegexRewrite != nil {
3838 if vtmsg, ok := interface{}(m.RegexRewrite).(interface {
3839 MarshalToSizedBufferVTStrict([]byte) (int, error)
3840 }); ok {
3841 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
3842 if err != nil {
3843 return 0, err
3844 }
3845 i -= size
3846 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3847 } else {
3848 encoded, err := proto.Marshal(m.RegexRewrite)
3849 if err != nil {
3850 return 0, err
3851 }
3852 i -= len(encoded)
3853 copy(dAtA[i:], encoded)
3854 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
3855 }
3856 i--
3857 dAtA[i] = 0x4a
3858 } else {
3859 i = protohelpers.EncodeVarint(dAtA, i, 0)
3860 i--
3861 dAtA[i] = 0x4a
3862 }
3863 return len(dAtA) - i, nil
3864 }
3865 func (m *DirectResponseAction) MarshalVTStrict() (dAtA []byte, err error) {
3866 if m == nil {
3867 return nil, nil
3868 }
3869 size := m.SizeVT()
3870 dAtA = make([]byte, size)
3871 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3872 if err != nil {
3873 return nil, err
3874 }
3875 return dAtA[:n], nil
3876 }
3877
3878 func (m *DirectResponseAction) MarshalToVTStrict(dAtA []byte) (int, error) {
3879 size := m.SizeVT()
3880 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3881 }
3882
3883 func (m *DirectResponseAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3884 if m == nil {
3885 return 0, nil
3886 }
3887 i := len(dAtA)
3888 _ = i
3889 var l int
3890 _ = l
3891 if m.unknownFields != nil {
3892 i -= len(m.unknownFields)
3893 copy(dAtA[i:], m.unknownFields)
3894 }
3895 if m.Body != nil {
3896 if vtmsg, ok := interface{}(m.Body).(interface {
3897 MarshalToSizedBufferVTStrict([]byte) (int, error)
3898 }); ok {
3899 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
3900 if err != nil {
3901 return 0, err
3902 }
3903 i -= size
3904 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3905 } else {
3906 encoded, err := proto.Marshal(m.Body)
3907 if err != nil {
3908 return 0, err
3909 }
3910 i -= len(encoded)
3911 copy(dAtA[i:], encoded)
3912 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
3913 }
3914 i--
3915 dAtA[i] = 0x12
3916 }
3917 if m.Status != 0 {
3918 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status))
3919 i--
3920 dAtA[i] = 0x8
3921 }
3922 return len(dAtA) - i, nil
3923 }
3924
3925 func (m *NonForwardingAction) MarshalVTStrict() (dAtA []byte, err error) {
3926 if m == nil {
3927 return nil, nil
3928 }
3929 size := m.SizeVT()
3930 dAtA = make([]byte, size)
3931 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3932 if err != nil {
3933 return nil, err
3934 }
3935 return dAtA[:n], nil
3936 }
3937
3938 func (m *NonForwardingAction) MarshalToVTStrict(dAtA []byte) (int, error) {
3939 size := m.SizeVT()
3940 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3941 }
3942
3943 func (m *NonForwardingAction) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3944 if m == nil {
3945 return 0, nil
3946 }
3947 i := len(dAtA)
3948 _ = i
3949 var l int
3950 _ = l
3951 if m.unknownFields != nil {
3952 i -= len(m.unknownFields)
3953 copy(dAtA[i:], m.unknownFields)
3954 }
3955 return len(dAtA) - i, nil
3956 }
3957
3958 func (m *Decorator) MarshalVTStrict() (dAtA []byte, err error) {
3959 if m == nil {
3960 return nil, nil
3961 }
3962 size := m.SizeVT()
3963 dAtA = make([]byte, size)
3964 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
3965 if err != nil {
3966 return nil, err
3967 }
3968 return dAtA[:n], nil
3969 }
3970
3971 func (m *Decorator) MarshalToVTStrict(dAtA []byte) (int, error) {
3972 size := m.SizeVT()
3973 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
3974 }
3975
3976 func (m *Decorator) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
3977 if m == nil {
3978 return 0, nil
3979 }
3980 i := len(dAtA)
3981 _ = i
3982 var l int
3983 _ = l
3984 if m.unknownFields != nil {
3985 i -= len(m.unknownFields)
3986 copy(dAtA[i:], m.unknownFields)
3987 }
3988 if m.Propagate != nil {
3989 size, err := (*wrapperspb.BoolValue)(m.Propagate).MarshalToSizedBufferVTStrict(dAtA[:i])
3990 if err != nil {
3991 return 0, err
3992 }
3993 i -= size
3994 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3995 i--
3996 dAtA[i] = 0x12
3997 }
3998 if len(m.Operation) > 0 {
3999 i -= len(m.Operation)
4000 copy(dAtA[i:], m.Operation)
4001 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Operation)))
4002 i--
4003 dAtA[i] = 0xa
4004 }
4005 return len(dAtA) - i, nil
4006 }
4007
4008 func (m *Tracing) MarshalVTStrict() (dAtA []byte, err error) {
4009 if m == nil {
4010 return nil, nil
4011 }
4012 size := m.SizeVT()
4013 dAtA = make([]byte, size)
4014 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4015 if err != nil {
4016 return nil, err
4017 }
4018 return dAtA[:n], nil
4019 }
4020
4021 func (m *Tracing) MarshalToVTStrict(dAtA []byte) (int, error) {
4022 size := m.SizeVT()
4023 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4024 }
4025
4026 func (m *Tracing) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4027 if m == nil {
4028 return 0, nil
4029 }
4030 i := len(dAtA)
4031 _ = i
4032 var l int
4033 _ = l
4034 if m.unknownFields != nil {
4035 i -= len(m.unknownFields)
4036 copy(dAtA[i:], m.unknownFields)
4037 }
4038 if len(m.CustomTags) > 0 {
4039 for iNdEx := len(m.CustomTags) - 1; iNdEx >= 0; iNdEx-- {
4040 if vtmsg, ok := interface{}(m.CustomTags[iNdEx]).(interface {
4041 MarshalToSizedBufferVTStrict([]byte) (int, error)
4042 }); ok {
4043 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
4044 if err != nil {
4045 return 0, err
4046 }
4047 i -= size
4048 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4049 } else {
4050 encoded, err := proto.Marshal(m.CustomTags[iNdEx])
4051 if err != nil {
4052 return 0, err
4053 }
4054 i -= len(encoded)
4055 copy(dAtA[i:], encoded)
4056 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4057 }
4058 i--
4059 dAtA[i] = 0x22
4060 }
4061 }
4062 if m.OverallSampling != nil {
4063 if vtmsg, ok := interface{}(m.OverallSampling).(interface {
4064 MarshalToSizedBufferVTStrict([]byte) (int, error)
4065 }); ok {
4066 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
4067 if err != nil {
4068 return 0, err
4069 }
4070 i -= size
4071 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4072 } else {
4073 encoded, err := proto.Marshal(m.OverallSampling)
4074 if err != nil {
4075 return 0, err
4076 }
4077 i -= len(encoded)
4078 copy(dAtA[i:], encoded)
4079 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4080 }
4081 i--
4082 dAtA[i] = 0x1a
4083 }
4084 if m.RandomSampling != nil {
4085 if vtmsg, ok := interface{}(m.RandomSampling).(interface {
4086 MarshalToSizedBufferVTStrict([]byte) (int, error)
4087 }); ok {
4088 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
4089 if err != nil {
4090 return 0, err
4091 }
4092 i -= size
4093 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4094 } else {
4095 encoded, err := proto.Marshal(m.RandomSampling)
4096 if err != nil {
4097 return 0, err
4098 }
4099 i -= len(encoded)
4100 copy(dAtA[i:], encoded)
4101 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4102 }
4103 i--
4104 dAtA[i] = 0x12
4105 }
4106 if m.ClientSampling != nil {
4107 if vtmsg, ok := interface{}(m.ClientSampling).(interface {
4108 MarshalToSizedBufferVTStrict([]byte) (int, error)
4109 }); ok {
4110 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
4111 if err != nil {
4112 return 0, err
4113 }
4114 i -= size
4115 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4116 } else {
4117 encoded, err := proto.Marshal(m.ClientSampling)
4118 if err != nil {
4119 return 0, err
4120 }
4121 i -= len(encoded)
4122 copy(dAtA[i:], encoded)
4123 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4124 }
4125 i--
4126 dAtA[i] = 0xa
4127 }
4128 return len(dAtA) - i, nil
4129 }
4130
4131 func (m *VirtualCluster) MarshalVTStrict() (dAtA []byte, err error) {
4132 if m == nil {
4133 return nil, nil
4134 }
4135 size := m.SizeVT()
4136 dAtA = make([]byte, size)
4137 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4138 if err != nil {
4139 return nil, err
4140 }
4141 return dAtA[:n], nil
4142 }
4143
4144 func (m *VirtualCluster) MarshalToVTStrict(dAtA []byte) (int, error) {
4145 size := m.SizeVT()
4146 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4147 }
4148
4149 func (m *VirtualCluster) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4150 if m == nil {
4151 return 0, nil
4152 }
4153 i := len(dAtA)
4154 _ = i
4155 var l int
4156 _ = l
4157 if m.unknownFields != nil {
4158 i -= len(m.unknownFields)
4159 copy(dAtA[i:], m.unknownFields)
4160 }
4161 if len(m.Headers) > 0 {
4162 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
4163 size, err := m.Headers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
4164 if err != nil {
4165 return 0, err
4166 }
4167 i -= size
4168 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4169 i--
4170 dAtA[i] = 0x22
4171 }
4172 }
4173 if len(m.Name) > 0 {
4174 i -= len(m.Name)
4175 copy(dAtA[i:], m.Name)
4176 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
4177 i--
4178 dAtA[i] = 0x12
4179 }
4180 return len(dAtA) - i, nil
4181 }
4182
4183 func (m *RateLimit_Action_SourceCluster) MarshalVTStrict() (dAtA []byte, err error) {
4184 if m == nil {
4185 return nil, nil
4186 }
4187 size := m.SizeVT()
4188 dAtA = make([]byte, size)
4189 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4190 if err != nil {
4191 return nil, err
4192 }
4193 return dAtA[:n], nil
4194 }
4195
4196 func (m *RateLimit_Action_SourceCluster) MarshalToVTStrict(dAtA []byte) (int, error) {
4197 size := m.SizeVT()
4198 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4199 }
4200
4201 func (m *RateLimit_Action_SourceCluster) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4202 if m == nil {
4203 return 0, nil
4204 }
4205 i := len(dAtA)
4206 _ = i
4207 var l int
4208 _ = l
4209 if m.unknownFields != nil {
4210 i -= len(m.unknownFields)
4211 copy(dAtA[i:], m.unknownFields)
4212 }
4213 return len(dAtA) - i, nil
4214 }
4215
4216 func (m *RateLimit_Action_DestinationCluster) MarshalVTStrict() (dAtA []byte, err error) {
4217 if m == nil {
4218 return nil, nil
4219 }
4220 size := m.SizeVT()
4221 dAtA = make([]byte, size)
4222 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4223 if err != nil {
4224 return nil, err
4225 }
4226 return dAtA[:n], nil
4227 }
4228
4229 func (m *RateLimit_Action_DestinationCluster) MarshalToVTStrict(dAtA []byte) (int, error) {
4230 size := m.SizeVT()
4231 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4232 }
4233
4234 func (m *RateLimit_Action_DestinationCluster) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4235 if m == nil {
4236 return 0, nil
4237 }
4238 i := len(dAtA)
4239 _ = i
4240 var l int
4241 _ = l
4242 if m.unknownFields != nil {
4243 i -= len(m.unknownFields)
4244 copy(dAtA[i:], m.unknownFields)
4245 }
4246 return len(dAtA) - i, nil
4247 }
4248
4249 func (m *RateLimit_Action_RequestHeaders) MarshalVTStrict() (dAtA []byte, err error) {
4250 if m == nil {
4251 return nil, nil
4252 }
4253 size := m.SizeVT()
4254 dAtA = make([]byte, size)
4255 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4256 if err != nil {
4257 return nil, err
4258 }
4259 return dAtA[:n], nil
4260 }
4261
4262 func (m *RateLimit_Action_RequestHeaders) MarshalToVTStrict(dAtA []byte) (int, error) {
4263 size := m.SizeVT()
4264 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4265 }
4266
4267 func (m *RateLimit_Action_RequestHeaders) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4268 if m == nil {
4269 return 0, nil
4270 }
4271 i := len(dAtA)
4272 _ = i
4273 var l int
4274 _ = l
4275 if m.unknownFields != nil {
4276 i -= len(m.unknownFields)
4277 copy(dAtA[i:], m.unknownFields)
4278 }
4279 if m.SkipIfAbsent {
4280 i--
4281 if m.SkipIfAbsent {
4282 dAtA[i] = 1
4283 } else {
4284 dAtA[i] = 0
4285 }
4286 i--
4287 dAtA[i] = 0x18
4288 }
4289 if len(m.DescriptorKey) > 0 {
4290 i -= len(m.DescriptorKey)
4291 copy(dAtA[i:], m.DescriptorKey)
4292 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorKey)))
4293 i--
4294 dAtA[i] = 0x12
4295 }
4296 if len(m.HeaderName) > 0 {
4297 i -= len(m.HeaderName)
4298 copy(dAtA[i:], m.HeaderName)
4299 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeaderName)))
4300 i--
4301 dAtA[i] = 0xa
4302 }
4303 return len(dAtA) - i, nil
4304 }
4305
4306 func (m *RateLimit_Action_RemoteAddress) MarshalVTStrict() (dAtA []byte, err error) {
4307 if m == nil {
4308 return nil, nil
4309 }
4310 size := m.SizeVT()
4311 dAtA = make([]byte, size)
4312 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4313 if err != nil {
4314 return nil, err
4315 }
4316 return dAtA[:n], nil
4317 }
4318
4319 func (m *RateLimit_Action_RemoteAddress) MarshalToVTStrict(dAtA []byte) (int, error) {
4320 size := m.SizeVT()
4321 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4322 }
4323
4324 func (m *RateLimit_Action_RemoteAddress) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4325 if m == nil {
4326 return 0, nil
4327 }
4328 i := len(dAtA)
4329 _ = i
4330 var l int
4331 _ = l
4332 if m.unknownFields != nil {
4333 i -= len(m.unknownFields)
4334 copy(dAtA[i:], m.unknownFields)
4335 }
4336 return len(dAtA) - i, nil
4337 }
4338
4339 func (m *RateLimit_Action_MaskedRemoteAddress) MarshalVTStrict() (dAtA []byte, err error) {
4340 if m == nil {
4341 return nil, nil
4342 }
4343 size := m.SizeVT()
4344 dAtA = make([]byte, size)
4345 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4346 if err != nil {
4347 return nil, err
4348 }
4349 return dAtA[:n], nil
4350 }
4351
4352 func (m *RateLimit_Action_MaskedRemoteAddress) MarshalToVTStrict(dAtA []byte) (int, error) {
4353 size := m.SizeVT()
4354 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4355 }
4356
4357 func (m *RateLimit_Action_MaskedRemoteAddress) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4358 if m == nil {
4359 return 0, nil
4360 }
4361 i := len(dAtA)
4362 _ = i
4363 var l int
4364 _ = l
4365 if m.unknownFields != nil {
4366 i -= len(m.unknownFields)
4367 copy(dAtA[i:], m.unknownFields)
4368 }
4369 if m.V6PrefixMaskLen != nil {
4370 size, err := (*wrapperspb.UInt32Value)(m.V6PrefixMaskLen).MarshalToSizedBufferVTStrict(dAtA[:i])
4371 if err != nil {
4372 return 0, err
4373 }
4374 i -= size
4375 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4376 i--
4377 dAtA[i] = 0x12
4378 }
4379 if m.V4PrefixMaskLen != nil {
4380 size, err := (*wrapperspb.UInt32Value)(m.V4PrefixMaskLen).MarshalToSizedBufferVTStrict(dAtA[:i])
4381 if err != nil {
4382 return 0, err
4383 }
4384 i -= size
4385 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4386 i--
4387 dAtA[i] = 0xa
4388 }
4389 return len(dAtA) - i, nil
4390 }
4391
4392 func (m *RateLimit_Action_GenericKey) MarshalVTStrict() (dAtA []byte, err error) {
4393 if m == nil {
4394 return nil, nil
4395 }
4396 size := m.SizeVT()
4397 dAtA = make([]byte, size)
4398 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4399 if err != nil {
4400 return nil, err
4401 }
4402 return dAtA[:n], nil
4403 }
4404
4405 func (m *RateLimit_Action_GenericKey) MarshalToVTStrict(dAtA []byte) (int, error) {
4406 size := m.SizeVT()
4407 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4408 }
4409
4410 func (m *RateLimit_Action_GenericKey) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4411 if m == nil {
4412 return 0, nil
4413 }
4414 i := len(dAtA)
4415 _ = i
4416 var l int
4417 _ = l
4418 if m.unknownFields != nil {
4419 i -= len(m.unknownFields)
4420 copy(dAtA[i:], m.unknownFields)
4421 }
4422 if len(m.DescriptorKey) > 0 {
4423 i -= len(m.DescriptorKey)
4424 copy(dAtA[i:], m.DescriptorKey)
4425 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorKey)))
4426 i--
4427 dAtA[i] = 0x12
4428 }
4429 if len(m.DescriptorValue) > 0 {
4430 i -= len(m.DescriptorValue)
4431 copy(dAtA[i:], m.DescriptorValue)
4432 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorValue)))
4433 i--
4434 dAtA[i] = 0xa
4435 }
4436 return len(dAtA) - i, nil
4437 }
4438
4439 func (m *RateLimit_Action_HeaderValueMatch) MarshalVTStrict() (dAtA []byte, err error) {
4440 if m == nil {
4441 return nil, nil
4442 }
4443 size := m.SizeVT()
4444 dAtA = make([]byte, size)
4445 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4446 if err != nil {
4447 return nil, err
4448 }
4449 return dAtA[:n], nil
4450 }
4451
4452 func (m *RateLimit_Action_HeaderValueMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
4453 size := m.SizeVT()
4454 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4455 }
4456
4457 func (m *RateLimit_Action_HeaderValueMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4458 if m == nil {
4459 return 0, nil
4460 }
4461 i := len(dAtA)
4462 _ = i
4463 var l int
4464 _ = l
4465 if m.unknownFields != nil {
4466 i -= len(m.unknownFields)
4467 copy(dAtA[i:], m.unknownFields)
4468 }
4469 if len(m.DescriptorKey) > 0 {
4470 i -= len(m.DescriptorKey)
4471 copy(dAtA[i:], m.DescriptorKey)
4472 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorKey)))
4473 i--
4474 dAtA[i] = 0x22
4475 }
4476 if len(m.Headers) > 0 {
4477 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
4478 size, err := m.Headers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
4479 if err != nil {
4480 return 0, err
4481 }
4482 i -= size
4483 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4484 i--
4485 dAtA[i] = 0x1a
4486 }
4487 }
4488 if m.ExpectMatch != nil {
4489 size, err := (*wrapperspb.BoolValue)(m.ExpectMatch).MarshalToSizedBufferVTStrict(dAtA[:i])
4490 if err != nil {
4491 return 0, err
4492 }
4493 i -= size
4494 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4495 i--
4496 dAtA[i] = 0x12
4497 }
4498 if len(m.DescriptorValue) > 0 {
4499 i -= len(m.DescriptorValue)
4500 copy(dAtA[i:], m.DescriptorValue)
4501 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorValue)))
4502 i--
4503 dAtA[i] = 0xa
4504 }
4505 return len(dAtA) - i, nil
4506 }
4507
4508 func (m *RateLimit_Action_DynamicMetaData) MarshalVTStrict() (dAtA []byte, err error) {
4509 if m == nil {
4510 return nil, nil
4511 }
4512 size := m.SizeVT()
4513 dAtA = make([]byte, size)
4514 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4515 if err != nil {
4516 return nil, err
4517 }
4518 return dAtA[:n], nil
4519 }
4520
4521 func (m *RateLimit_Action_DynamicMetaData) MarshalToVTStrict(dAtA []byte) (int, error) {
4522 size := m.SizeVT()
4523 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4524 }
4525
4526 func (m *RateLimit_Action_DynamicMetaData) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4527 if m == nil {
4528 return 0, nil
4529 }
4530 i := len(dAtA)
4531 _ = i
4532 var l int
4533 _ = l
4534 if m.unknownFields != nil {
4535 i -= len(m.unknownFields)
4536 copy(dAtA[i:], m.unknownFields)
4537 }
4538 if len(m.DefaultValue) > 0 {
4539 i -= len(m.DefaultValue)
4540 copy(dAtA[i:], m.DefaultValue)
4541 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultValue)))
4542 i--
4543 dAtA[i] = 0x1a
4544 }
4545 if m.MetadataKey != nil {
4546 if vtmsg, ok := interface{}(m.MetadataKey).(interface {
4547 MarshalToSizedBufferVTStrict([]byte) (int, error)
4548 }); ok {
4549 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
4550 if err != nil {
4551 return 0, err
4552 }
4553 i -= size
4554 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4555 } else {
4556 encoded, err := proto.Marshal(m.MetadataKey)
4557 if err != nil {
4558 return 0, err
4559 }
4560 i -= len(encoded)
4561 copy(dAtA[i:], encoded)
4562 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4563 }
4564 i--
4565 dAtA[i] = 0x12
4566 }
4567 if len(m.DescriptorKey) > 0 {
4568 i -= len(m.DescriptorKey)
4569 copy(dAtA[i:], m.DescriptorKey)
4570 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorKey)))
4571 i--
4572 dAtA[i] = 0xa
4573 }
4574 return len(dAtA) - i, nil
4575 }
4576
4577 func (m *RateLimit_Action_MetaData) MarshalVTStrict() (dAtA []byte, err error) {
4578 if m == nil {
4579 return nil, nil
4580 }
4581 size := m.SizeVT()
4582 dAtA = make([]byte, size)
4583 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4584 if err != nil {
4585 return nil, err
4586 }
4587 return dAtA[:n], nil
4588 }
4589
4590 func (m *RateLimit_Action_MetaData) MarshalToVTStrict(dAtA []byte) (int, error) {
4591 size := m.SizeVT()
4592 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4593 }
4594
4595 func (m *RateLimit_Action_MetaData) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4596 if m == nil {
4597 return 0, nil
4598 }
4599 i := len(dAtA)
4600 _ = i
4601 var l int
4602 _ = l
4603 if m.unknownFields != nil {
4604 i -= len(m.unknownFields)
4605 copy(dAtA[i:], m.unknownFields)
4606 }
4607 if m.SkipIfAbsent {
4608 i--
4609 if m.SkipIfAbsent {
4610 dAtA[i] = 1
4611 } else {
4612 dAtA[i] = 0
4613 }
4614 i--
4615 dAtA[i] = 0x28
4616 }
4617 if m.Source != 0 {
4618 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Source))
4619 i--
4620 dAtA[i] = 0x20
4621 }
4622 if len(m.DefaultValue) > 0 {
4623 i -= len(m.DefaultValue)
4624 copy(dAtA[i:], m.DefaultValue)
4625 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultValue)))
4626 i--
4627 dAtA[i] = 0x1a
4628 }
4629 if m.MetadataKey != nil {
4630 if vtmsg, ok := interface{}(m.MetadataKey).(interface {
4631 MarshalToSizedBufferVTStrict([]byte) (int, error)
4632 }); ok {
4633 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
4634 if err != nil {
4635 return 0, err
4636 }
4637 i -= size
4638 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4639 } else {
4640 encoded, err := proto.Marshal(m.MetadataKey)
4641 if err != nil {
4642 return 0, err
4643 }
4644 i -= len(encoded)
4645 copy(dAtA[i:], encoded)
4646 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4647 }
4648 i--
4649 dAtA[i] = 0x12
4650 }
4651 if len(m.DescriptorKey) > 0 {
4652 i -= len(m.DescriptorKey)
4653 copy(dAtA[i:], m.DescriptorKey)
4654 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorKey)))
4655 i--
4656 dAtA[i] = 0xa
4657 }
4658 return len(dAtA) - i, nil
4659 }
4660
4661 func (m *RateLimit_Action_QueryParameterValueMatch) MarshalVTStrict() (dAtA []byte, err error) {
4662 if m == nil {
4663 return nil, nil
4664 }
4665 size := m.SizeVT()
4666 dAtA = make([]byte, size)
4667 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4668 if err != nil {
4669 return nil, err
4670 }
4671 return dAtA[:n], nil
4672 }
4673
4674 func (m *RateLimit_Action_QueryParameterValueMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
4675 size := m.SizeVT()
4676 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4677 }
4678
4679 func (m *RateLimit_Action_QueryParameterValueMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4680 if m == nil {
4681 return 0, nil
4682 }
4683 i := len(dAtA)
4684 _ = i
4685 var l int
4686 _ = l
4687 if m.unknownFields != nil {
4688 i -= len(m.unknownFields)
4689 copy(dAtA[i:], m.unknownFields)
4690 }
4691 if len(m.DescriptorKey) > 0 {
4692 i -= len(m.DescriptorKey)
4693 copy(dAtA[i:], m.DescriptorKey)
4694 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorKey)))
4695 i--
4696 dAtA[i] = 0x22
4697 }
4698 if len(m.QueryParameters) > 0 {
4699 for iNdEx := len(m.QueryParameters) - 1; iNdEx >= 0; iNdEx-- {
4700 size, err := m.QueryParameters[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
4701 if err != nil {
4702 return 0, err
4703 }
4704 i -= size
4705 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4706 i--
4707 dAtA[i] = 0x1a
4708 }
4709 }
4710 if m.ExpectMatch != nil {
4711 size, err := (*wrapperspb.BoolValue)(m.ExpectMatch).MarshalToSizedBufferVTStrict(dAtA[:i])
4712 if err != nil {
4713 return 0, err
4714 }
4715 i -= size
4716 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4717 i--
4718 dAtA[i] = 0x12
4719 }
4720 if len(m.DescriptorValue) > 0 {
4721 i -= len(m.DescriptorValue)
4722 copy(dAtA[i:], m.DescriptorValue)
4723 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DescriptorValue)))
4724 i--
4725 dAtA[i] = 0xa
4726 }
4727 return len(dAtA) - i, nil
4728 }
4729
4730 func (m *RateLimit_Action) MarshalVTStrict() (dAtA []byte, err error) {
4731 if m == nil {
4732 return nil, nil
4733 }
4734 size := m.SizeVT()
4735 dAtA = make([]byte, size)
4736 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
4737 if err != nil {
4738 return nil, err
4739 }
4740 return dAtA[:n], nil
4741 }
4742
4743 func (m *RateLimit_Action) MarshalToVTStrict(dAtA []byte) (int, error) {
4744 size := m.SizeVT()
4745 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4746 }
4747
4748 func (m *RateLimit_Action) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4749 if m == nil {
4750 return 0, nil
4751 }
4752 i := len(dAtA)
4753 _ = i
4754 var l int
4755 _ = l
4756 if m.unknownFields != nil {
4757 i -= len(m.unknownFields)
4758 copy(dAtA[i:], m.unknownFields)
4759 }
4760 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_QueryParameterValueMatch_); ok {
4761 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4762 if err != nil {
4763 return 0, err
4764 }
4765 i -= size
4766 }
4767 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_MaskedRemoteAddress_); ok {
4768 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4769 if err != nil {
4770 return 0, err
4771 }
4772 i -= size
4773 }
4774 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_Extension); ok {
4775 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4776 if err != nil {
4777 return 0, err
4778 }
4779 i -= size
4780 }
4781 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_Metadata); ok {
4782 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4783 if err != nil {
4784 return 0, err
4785 }
4786 i -= size
4787 }
4788 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_DynamicMetadata); ok {
4789 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4790 if err != nil {
4791 return 0, err
4792 }
4793 i -= size
4794 }
4795 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_HeaderValueMatch_); ok {
4796 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4797 if err != nil {
4798 return 0, err
4799 }
4800 i -= size
4801 }
4802 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_GenericKey_); ok {
4803 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4804 if err != nil {
4805 return 0, err
4806 }
4807 i -= size
4808 }
4809 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_RemoteAddress_); ok {
4810 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4811 if err != nil {
4812 return 0, err
4813 }
4814 i -= size
4815 }
4816 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_RequestHeaders_); ok {
4817 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4818 if err != nil {
4819 return 0, err
4820 }
4821 i -= size
4822 }
4823 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_DestinationCluster_); ok {
4824 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4825 if err != nil {
4826 return 0, err
4827 }
4828 i -= size
4829 }
4830 if msg, ok := m.ActionSpecifier.(*RateLimit_Action_SourceCluster_); ok {
4831 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
4832 if err != nil {
4833 return 0, err
4834 }
4835 i -= size
4836 }
4837 return len(dAtA) - i, nil
4838 }
4839
4840 func (m *RateLimit_Action_SourceCluster_) MarshalToVTStrict(dAtA []byte) (int, error) {
4841 size := m.SizeVT()
4842 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4843 }
4844
4845 func (m *RateLimit_Action_SourceCluster_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4846 i := len(dAtA)
4847 if m.SourceCluster != nil {
4848 size, err := m.SourceCluster.MarshalToSizedBufferVTStrict(dAtA[:i])
4849 if err != nil {
4850 return 0, err
4851 }
4852 i -= size
4853 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4854 i--
4855 dAtA[i] = 0xa
4856 } else {
4857 i = protohelpers.EncodeVarint(dAtA, i, 0)
4858 i--
4859 dAtA[i] = 0xa
4860 }
4861 return len(dAtA) - i, nil
4862 }
4863 func (m *RateLimit_Action_DestinationCluster_) MarshalToVTStrict(dAtA []byte) (int, error) {
4864 size := m.SizeVT()
4865 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4866 }
4867
4868 func (m *RateLimit_Action_DestinationCluster_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4869 i := len(dAtA)
4870 if m.DestinationCluster != nil {
4871 size, err := m.DestinationCluster.MarshalToSizedBufferVTStrict(dAtA[:i])
4872 if err != nil {
4873 return 0, err
4874 }
4875 i -= size
4876 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4877 i--
4878 dAtA[i] = 0x12
4879 } else {
4880 i = protohelpers.EncodeVarint(dAtA, i, 0)
4881 i--
4882 dAtA[i] = 0x12
4883 }
4884 return len(dAtA) - i, nil
4885 }
4886 func (m *RateLimit_Action_RequestHeaders_) MarshalToVTStrict(dAtA []byte) (int, error) {
4887 size := m.SizeVT()
4888 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4889 }
4890
4891 func (m *RateLimit_Action_RequestHeaders_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4892 i := len(dAtA)
4893 if m.RequestHeaders != nil {
4894 size, err := m.RequestHeaders.MarshalToSizedBufferVTStrict(dAtA[:i])
4895 if err != nil {
4896 return 0, err
4897 }
4898 i -= size
4899 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4900 i--
4901 dAtA[i] = 0x1a
4902 } else {
4903 i = protohelpers.EncodeVarint(dAtA, i, 0)
4904 i--
4905 dAtA[i] = 0x1a
4906 }
4907 return len(dAtA) - i, nil
4908 }
4909 func (m *RateLimit_Action_RemoteAddress_) MarshalToVTStrict(dAtA []byte) (int, error) {
4910 size := m.SizeVT()
4911 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4912 }
4913
4914 func (m *RateLimit_Action_RemoteAddress_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4915 i := len(dAtA)
4916 if m.RemoteAddress != nil {
4917 size, err := m.RemoteAddress.MarshalToSizedBufferVTStrict(dAtA[:i])
4918 if err != nil {
4919 return 0, err
4920 }
4921 i -= size
4922 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4923 i--
4924 dAtA[i] = 0x22
4925 } else {
4926 i = protohelpers.EncodeVarint(dAtA, i, 0)
4927 i--
4928 dAtA[i] = 0x22
4929 }
4930 return len(dAtA) - i, nil
4931 }
4932 func (m *RateLimit_Action_GenericKey_) MarshalToVTStrict(dAtA []byte) (int, error) {
4933 size := m.SizeVT()
4934 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4935 }
4936
4937 func (m *RateLimit_Action_GenericKey_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4938 i := len(dAtA)
4939 if m.GenericKey != nil {
4940 size, err := m.GenericKey.MarshalToSizedBufferVTStrict(dAtA[:i])
4941 if err != nil {
4942 return 0, err
4943 }
4944 i -= size
4945 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4946 i--
4947 dAtA[i] = 0x2a
4948 } else {
4949 i = protohelpers.EncodeVarint(dAtA, i, 0)
4950 i--
4951 dAtA[i] = 0x2a
4952 }
4953 return len(dAtA) - i, nil
4954 }
4955 func (m *RateLimit_Action_HeaderValueMatch_) MarshalToVTStrict(dAtA []byte) (int, error) {
4956 size := m.SizeVT()
4957 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4958 }
4959
4960 func (m *RateLimit_Action_HeaderValueMatch_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4961 i := len(dAtA)
4962 if m.HeaderValueMatch != nil {
4963 size, err := m.HeaderValueMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
4964 if err != nil {
4965 return 0, err
4966 }
4967 i -= size
4968 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4969 i--
4970 dAtA[i] = 0x32
4971 } else {
4972 i = protohelpers.EncodeVarint(dAtA, i, 0)
4973 i--
4974 dAtA[i] = 0x32
4975 }
4976 return len(dAtA) - i, nil
4977 }
4978 func (m *RateLimit_Action_DynamicMetadata) MarshalToVTStrict(dAtA []byte) (int, error) {
4979 size := m.SizeVT()
4980 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
4981 }
4982
4983 func (m *RateLimit_Action_DynamicMetadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
4984 i := len(dAtA)
4985 if m.DynamicMetadata != nil {
4986 size, err := m.DynamicMetadata.MarshalToSizedBufferVTStrict(dAtA[:i])
4987 if err != nil {
4988 return 0, err
4989 }
4990 i -= size
4991 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4992 i--
4993 dAtA[i] = 0x3a
4994 } else {
4995 i = protohelpers.EncodeVarint(dAtA, i, 0)
4996 i--
4997 dAtA[i] = 0x3a
4998 }
4999 return len(dAtA) - i, nil
5000 }
5001 func (m *RateLimit_Action_Metadata) MarshalToVTStrict(dAtA []byte) (int, error) {
5002 size := m.SizeVT()
5003 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5004 }
5005
5006 func (m *RateLimit_Action_Metadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5007 i := len(dAtA)
5008 if m.Metadata != nil {
5009 size, err := m.Metadata.MarshalToSizedBufferVTStrict(dAtA[:i])
5010 if err != nil {
5011 return 0, err
5012 }
5013 i -= size
5014 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5015 i--
5016 dAtA[i] = 0x42
5017 } else {
5018 i = protohelpers.EncodeVarint(dAtA, i, 0)
5019 i--
5020 dAtA[i] = 0x42
5021 }
5022 return len(dAtA) - i, nil
5023 }
5024 func (m *RateLimit_Action_Extension) MarshalToVTStrict(dAtA []byte) (int, error) {
5025 size := m.SizeVT()
5026 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5027 }
5028
5029 func (m *RateLimit_Action_Extension) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5030 i := len(dAtA)
5031 if m.Extension != nil {
5032 if vtmsg, ok := interface{}(m.Extension).(interface {
5033 MarshalToSizedBufferVTStrict([]byte) (int, error)
5034 }); ok {
5035 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5036 if err != nil {
5037 return 0, err
5038 }
5039 i -= size
5040 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5041 } else {
5042 encoded, err := proto.Marshal(m.Extension)
5043 if err != nil {
5044 return 0, err
5045 }
5046 i -= len(encoded)
5047 copy(dAtA[i:], encoded)
5048 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5049 }
5050 i--
5051 dAtA[i] = 0x4a
5052 } else {
5053 i = protohelpers.EncodeVarint(dAtA, i, 0)
5054 i--
5055 dAtA[i] = 0x4a
5056 }
5057 return len(dAtA) - i, nil
5058 }
5059 func (m *RateLimit_Action_MaskedRemoteAddress_) MarshalToVTStrict(dAtA []byte) (int, error) {
5060 size := m.SizeVT()
5061 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5062 }
5063
5064 func (m *RateLimit_Action_MaskedRemoteAddress_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5065 i := len(dAtA)
5066 if m.MaskedRemoteAddress != nil {
5067 size, err := m.MaskedRemoteAddress.MarshalToSizedBufferVTStrict(dAtA[:i])
5068 if err != nil {
5069 return 0, err
5070 }
5071 i -= size
5072 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5073 i--
5074 dAtA[i] = 0x52
5075 } else {
5076 i = protohelpers.EncodeVarint(dAtA, i, 0)
5077 i--
5078 dAtA[i] = 0x52
5079 }
5080 return len(dAtA) - i, nil
5081 }
5082 func (m *RateLimit_Action_QueryParameterValueMatch_) MarshalToVTStrict(dAtA []byte) (int, error) {
5083 size := m.SizeVT()
5084 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5085 }
5086
5087 func (m *RateLimit_Action_QueryParameterValueMatch_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5088 i := len(dAtA)
5089 if m.QueryParameterValueMatch != nil {
5090 size, err := m.QueryParameterValueMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
5091 if err != nil {
5092 return 0, err
5093 }
5094 i -= size
5095 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5096 i--
5097 dAtA[i] = 0x5a
5098 } else {
5099 i = protohelpers.EncodeVarint(dAtA, i, 0)
5100 i--
5101 dAtA[i] = 0x5a
5102 }
5103 return len(dAtA) - i, nil
5104 }
5105 func (m *RateLimit_Override_DynamicMetadata) MarshalVTStrict() (dAtA []byte, err error) {
5106 if m == nil {
5107 return nil, nil
5108 }
5109 size := m.SizeVT()
5110 dAtA = make([]byte, size)
5111 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5112 if err != nil {
5113 return nil, err
5114 }
5115 return dAtA[:n], nil
5116 }
5117
5118 func (m *RateLimit_Override_DynamicMetadata) MarshalToVTStrict(dAtA []byte) (int, error) {
5119 size := m.SizeVT()
5120 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5121 }
5122
5123 func (m *RateLimit_Override_DynamicMetadata) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5124 if m == nil {
5125 return 0, nil
5126 }
5127 i := len(dAtA)
5128 _ = i
5129 var l int
5130 _ = l
5131 if m.unknownFields != nil {
5132 i -= len(m.unknownFields)
5133 copy(dAtA[i:], m.unknownFields)
5134 }
5135 if m.MetadataKey != nil {
5136 if vtmsg, ok := interface{}(m.MetadataKey).(interface {
5137 MarshalToSizedBufferVTStrict([]byte) (int, error)
5138 }); ok {
5139 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5140 if err != nil {
5141 return 0, err
5142 }
5143 i -= size
5144 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5145 } else {
5146 encoded, err := proto.Marshal(m.MetadataKey)
5147 if err != nil {
5148 return 0, err
5149 }
5150 i -= len(encoded)
5151 copy(dAtA[i:], encoded)
5152 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5153 }
5154 i--
5155 dAtA[i] = 0xa
5156 }
5157 return len(dAtA) - i, nil
5158 }
5159
5160 func (m *RateLimit_Override) MarshalVTStrict() (dAtA []byte, err error) {
5161 if m == nil {
5162 return nil, nil
5163 }
5164 size := m.SizeVT()
5165 dAtA = make([]byte, size)
5166 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5167 if err != nil {
5168 return nil, err
5169 }
5170 return dAtA[:n], nil
5171 }
5172
5173 func (m *RateLimit_Override) MarshalToVTStrict(dAtA []byte) (int, error) {
5174 size := m.SizeVT()
5175 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5176 }
5177
5178 func (m *RateLimit_Override) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5179 if m == nil {
5180 return 0, nil
5181 }
5182 i := len(dAtA)
5183 _ = i
5184 var l int
5185 _ = l
5186 if m.unknownFields != nil {
5187 i -= len(m.unknownFields)
5188 copy(dAtA[i:], m.unknownFields)
5189 }
5190 if msg, ok := m.OverrideSpecifier.(*RateLimit_Override_DynamicMetadata_); ok {
5191 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5192 if err != nil {
5193 return 0, err
5194 }
5195 i -= size
5196 }
5197 return len(dAtA) - i, nil
5198 }
5199
5200 func (m *RateLimit_Override_DynamicMetadata_) MarshalToVTStrict(dAtA []byte) (int, error) {
5201 size := m.SizeVT()
5202 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5203 }
5204
5205 func (m *RateLimit_Override_DynamicMetadata_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5206 i := len(dAtA)
5207 if m.DynamicMetadata != nil {
5208 size, err := m.DynamicMetadata.MarshalToSizedBufferVTStrict(dAtA[:i])
5209 if err != nil {
5210 return 0, err
5211 }
5212 i -= size
5213 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5214 i--
5215 dAtA[i] = 0xa
5216 } else {
5217 i = protohelpers.EncodeVarint(dAtA, i, 0)
5218 i--
5219 dAtA[i] = 0xa
5220 }
5221 return len(dAtA) - i, nil
5222 }
5223 func (m *RateLimit_HitsAddend) MarshalVTStrict() (dAtA []byte, err error) {
5224 if m == nil {
5225 return nil, nil
5226 }
5227 size := m.SizeVT()
5228 dAtA = make([]byte, size)
5229 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5230 if err != nil {
5231 return nil, err
5232 }
5233 return dAtA[:n], nil
5234 }
5235
5236 func (m *RateLimit_HitsAddend) MarshalToVTStrict(dAtA []byte) (int, error) {
5237 size := m.SizeVT()
5238 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5239 }
5240
5241 func (m *RateLimit_HitsAddend) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5242 if m == nil {
5243 return 0, nil
5244 }
5245 i := len(dAtA)
5246 _ = i
5247 var l int
5248 _ = l
5249 if m.unknownFields != nil {
5250 i -= len(m.unknownFields)
5251 copy(dAtA[i:], m.unknownFields)
5252 }
5253 if len(m.Format) > 0 {
5254 i -= len(m.Format)
5255 copy(dAtA[i:], m.Format)
5256 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Format)))
5257 i--
5258 dAtA[i] = 0x12
5259 }
5260 if m.Number != nil {
5261 size, err := (*wrapperspb.UInt64Value)(m.Number).MarshalToSizedBufferVTStrict(dAtA[:i])
5262 if err != nil {
5263 return 0, err
5264 }
5265 i -= size
5266 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5267 i--
5268 dAtA[i] = 0xa
5269 }
5270 return len(dAtA) - i, nil
5271 }
5272
5273 func (m *RateLimit) MarshalVTStrict() (dAtA []byte, err error) {
5274 if m == nil {
5275 return nil, nil
5276 }
5277 size := m.SizeVT()
5278 dAtA = make([]byte, size)
5279 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5280 if err != nil {
5281 return nil, err
5282 }
5283 return dAtA[:n], nil
5284 }
5285
5286 func (m *RateLimit) MarshalToVTStrict(dAtA []byte) (int, error) {
5287 size := m.SizeVT()
5288 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5289 }
5290
5291 func (m *RateLimit) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5292 if m == nil {
5293 return 0, nil
5294 }
5295 i := len(dAtA)
5296 _ = i
5297 var l int
5298 _ = l
5299 if m.unknownFields != nil {
5300 i -= len(m.unknownFields)
5301 copy(dAtA[i:], m.unknownFields)
5302 }
5303 if m.ApplyOnStreamDone {
5304 i--
5305 if m.ApplyOnStreamDone {
5306 dAtA[i] = 1
5307 } else {
5308 dAtA[i] = 0
5309 }
5310 i--
5311 dAtA[i] = 0x30
5312 }
5313 if m.HitsAddend != nil {
5314 size, err := m.HitsAddend.MarshalToSizedBufferVTStrict(dAtA[:i])
5315 if err != nil {
5316 return 0, err
5317 }
5318 i -= size
5319 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5320 i--
5321 dAtA[i] = 0x2a
5322 }
5323 if m.Limit != nil {
5324 size, err := m.Limit.MarshalToSizedBufferVTStrict(dAtA[:i])
5325 if err != nil {
5326 return 0, err
5327 }
5328 i -= size
5329 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5330 i--
5331 dAtA[i] = 0x22
5332 }
5333 if len(m.Actions) > 0 {
5334 for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
5335 size, err := m.Actions[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
5336 if err != nil {
5337 return 0, err
5338 }
5339 i -= size
5340 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5341 i--
5342 dAtA[i] = 0x1a
5343 }
5344 }
5345 if len(m.DisableKey) > 0 {
5346 i -= len(m.DisableKey)
5347 copy(dAtA[i:], m.DisableKey)
5348 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DisableKey)))
5349 i--
5350 dAtA[i] = 0x12
5351 }
5352 if m.Stage != nil {
5353 size, err := (*wrapperspb.UInt32Value)(m.Stage).MarshalToSizedBufferVTStrict(dAtA[:i])
5354 if err != nil {
5355 return 0, err
5356 }
5357 i -= size
5358 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5359 i--
5360 dAtA[i] = 0xa
5361 }
5362 return len(dAtA) - i, nil
5363 }
5364
5365 func (m *HeaderMatcher) MarshalVTStrict() (dAtA []byte, err error) {
5366 if m == nil {
5367 return nil, nil
5368 }
5369 size := m.SizeVT()
5370 dAtA = make([]byte, size)
5371 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5372 if err != nil {
5373 return nil, err
5374 }
5375 return dAtA[:n], nil
5376 }
5377
5378 func (m *HeaderMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
5379 size := m.SizeVT()
5380 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5381 }
5382
5383 func (m *HeaderMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5384 if m == nil {
5385 return 0, nil
5386 }
5387 i := len(dAtA)
5388 _ = i
5389 var l int
5390 _ = l
5391 if m.unknownFields != nil {
5392 i -= len(m.unknownFields)
5393 copy(dAtA[i:], m.unknownFields)
5394 }
5395 if m.TreatMissingHeaderAsEmpty {
5396 i--
5397 if m.TreatMissingHeaderAsEmpty {
5398 dAtA[i] = 1
5399 } else {
5400 dAtA[i] = 0
5401 }
5402 i--
5403 dAtA[i] = 0x70
5404 }
5405 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_StringMatch); ok {
5406 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5407 if err != nil {
5408 return 0, err
5409 }
5410 i -= size
5411 }
5412 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_ContainsMatch); ok {
5413 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5414 if err != nil {
5415 return 0, err
5416 }
5417 i -= size
5418 }
5419 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_SafeRegexMatch); ok {
5420 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5421 if err != nil {
5422 return 0, err
5423 }
5424 i -= size
5425 }
5426 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_SuffixMatch); ok {
5427 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5428 if err != nil {
5429 return 0, err
5430 }
5431 i -= size
5432 }
5433 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_PrefixMatch); ok {
5434 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5435 if err != nil {
5436 return 0, err
5437 }
5438 i -= size
5439 }
5440 if m.InvertMatch {
5441 i--
5442 if m.InvertMatch {
5443 dAtA[i] = 1
5444 } else {
5445 dAtA[i] = 0
5446 }
5447 i--
5448 dAtA[i] = 0x40
5449 }
5450 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_PresentMatch); ok {
5451 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5452 if err != nil {
5453 return 0, err
5454 }
5455 i -= size
5456 }
5457 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_RangeMatch); ok {
5458 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5459 if err != nil {
5460 return 0, err
5461 }
5462 i -= size
5463 }
5464 if msg, ok := m.HeaderMatchSpecifier.(*HeaderMatcher_ExactMatch); ok {
5465 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5466 if err != nil {
5467 return 0, err
5468 }
5469 i -= size
5470 }
5471 if len(m.Name) > 0 {
5472 i -= len(m.Name)
5473 copy(dAtA[i:], m.Name)
5474 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
5475 i--
5476 dAtA[i] = 0xa
5477 }
5478 return len(dAtA) - i, nil
5479 }
5480
5481 func (m *HeaderMatcher_ExactMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5482 size := m.SizeVT()
5483 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5484 }
5485
5486 func (m *HeaderMatcher_ExactMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5487 i := len(dAtA)
5488 i -= len(m.ExactMatch)
5489 copy(dAtA[i:], m.ExactMatch)
5490 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExactMatch)))
5491 i--
5492 dAtA[i] = 0x22
5493 return len(dAtA) - i, nil
5494 }
5495 func (m *HeaderMatcher_RangeMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5496 size := m.SizeVT()
5497 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5498 }
5499
5500 func (m *HeaderMatcher_RangeMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5501 i := len(dAtA)
5502 if m.RangeMatch != nil {
5503 if vtmsg, ok := interface{}(m.RangeMatch).(interface {
5504 MarshalToSizedBufferVTStrict([]byte) (int, error)
5505 }); ok {
5506 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5507 if err != nil {
5508 return 0, err
5509 }
5510 i -= size
5511 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5512 } else {
5513 encoded, err := proto.Marshal(m.RangeMatch)
5514 if err != nil {
5515 return 0, err
5516 }
5517 i -= len(encoded)
5518 copy(dAtA[i:], encoded)
5519 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5520 }
5521 i--
5522 dAtA[i] = 0x32
5523 } else {
5524 i = protohelpers.EncodeVarint(dAtA, i, 0)
5525 i--
5526 dAtA[i] = 0x32
5527 }
5528 return len(dAtA) - i, nil
5529 }
5530 func (m *HeaderMatcher_PresentMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5531 size := m.SizeVT()
5532 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5533 }
5534
5535 func (m *HeaderMatcher_PresentMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5536 i := len(dAtA)
5537 i--
5538 if m.PresentMatch {
5539 dAtA[i] = 1
5540 } else {
5541 dAtA[i] = 0
5542 }
5543 i--
5544 dAtA[i] = 0x38
5545 return len(dAtA) - i, nil
5546 }
5547 func (m *HeaderMatcher_PrefixMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5548 size := m.SizeVT()
5549 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5550 }
5551
5552 func (m *HeaderMatcher_PrefixMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5553 i := len(dAtA)
5554 i -= len(m.PrefixMatch)
5555 copy(dAtA[i:], m.PrefixMatch)
5556 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrefixMatch)))
5557 i--
5558 dAtA[i] = 0x4a
5559 return len(dAtA) - i, nil
5560 }
5561 func (m *HeaderMatcher_SuffixMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5562 size := m.SizeVT()
5563 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5564 }
5565
5566 func (m *HeaderMatcher_SuffixMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5567 i := len(dAtA)
5568 i -= len(m.SuffixMatch)
5569 copy(dAtA[i:], m.SuffixMatch)
5570 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SuffixMatch)))
5571 i--
5572 dAtA[i] = 0x52
5573 return len(dAtA) - i, nil
5574 }
5575 func (m *HeaderMatcher_SafeRegexMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5576 size := m.SizeVT()
5577 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5578 }
5579
5580 func (m *HeaderMatcher_SafeRegexMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5581 i := len(dAtA)
5582 if m.SafeRegexMatch != nil {
5583 if vtmsg, ok := interface{}(m.SafeRegexMatch).(interface {
5584 MarshalToSizedBufferVTStrict([]byte) (int, error)
5585 }); ok {
5586 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5587 if err != nil {
5588 return 0, err
5589 }
5590 i -= size
5591 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5592 } else {
5593 encoded, err := proto.Marshal(m.SafeRegexMatch)
5594 if err != nil {
5595 return 0, err
5596 }
5597 i -= len(encoded)
5598 copy(dAtA[i:], encoded)
5599 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5600 }
5601 i--
5602 dAtA[i] = 0x5a
5603 } else {
5604 i = protohelpers.EncodeVarint(dAtA, i, 0)
5605 i--
5606 dAtA[i] = 0x5a
5607 }
5608 return len(dAtA) - i, nil
5609 }
5610 func (m *HeaderMatcher_ContainsMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5611 size := m.SizeVT()
5612 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5613 }
5614
5615 func (m *HeaderMatcher_ContainsMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5616 i := len(dAtA)
5617 i -= len(m.ContainsMatch)
5618 copy(dAtA[i:], m.ContainsMatch)
5619 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainsMatch)))
5620 i--
5621 dAtA[i] = 0x62
5622 return len(dAtA) - i, nil
5623 }
5624 func (m *HeaderMatcher_StringMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5625 size := m.SizeVT()
5626 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5627 }
5628
5629 func (m *HeaderMatcher_StringMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5630 i := len(dAtA)
5631 if m.StringMatch != nil {
5632 if vtmsg, ok := interface{}(m.StringMatch).(interface {
5633 MarshalToSizedBufferVTStrict([]byte) (int, error)
5634 }); ok {
5635 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5636 if err != nil {
5637 return 0, err
5638 }
5639 i -= size
5640 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5641 } else {
5642 encoded, err := proto.Marshal(m.StringMatch)
5643 if err != nil {
5644 return 0, err
5645 }
5646 i -= len(encoded)
5647 copy(dAtA[i:], encoded)
5648 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5649 }
5650 i--
5651 dAtA[i] = 0x6a
5652 } else {
5653 i = protohelpers.EncodeVarint(dAtA, i, 0)
5654 i--
5655 dAtA[i] = 0x6a
5656 }
5657 return len(dAtA) - i, nil
5658 }
5659 func (m *QueryParameterMatcher) MarshalVTStrict() (dAtA []byte, err error) {
5660 if m == nil {
5661 return nil, nil
5662 }
5663 size := m.SizeVT()
5664 dAtA = make([]byte, size)
5665 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5666 if err != nil {
5667 return nil, err
5668 }
5669 return dAtA[:n], nil
5670 }
5671
5672 func (m *QueryParameterMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
5673 size := m.SizeVT()
5674 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5675 }
5676
5677 func (m *QueryParameterMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5678 if m == nil {
5679 return 0, nil
5680 }
5681 i := len(dAtA)
5682 _ = i
5683 var l int
5684 _ = l
5685 if m.unknownFields != nil {
5686 i -= len(m.unknownFields)
5687 copy(dAtA[i:], m.unknownFields)
5688 }
5689 if msg, ok := m.QueryParameterMatchSpecifier.(*QueryParameterMatcher_PresentMatch); ok {
5690 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5691 if err != nil {
5692 return 0, err
5693 }
5694 i -= size
5695 }
5696 if msg, ok := m.QueryParameterMatchSpecifier.(*QueryParameterMatcher_StringMatch); ok {
5697 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
5698 if err != nil {
5699 return 0, err
5700 }
5701 i -= size
5702 }
5703 if len(m.Name) > 0 {
5704 i -= len(m.Name)
5705 copy(dAtA[i:], m.Name)
5706 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
5707 i--
5708 dAtA[i] = 0xa
5709 }
5710 return len(dAtA) - i, nil
5711 }
5712
5713 func (m *QueryParameterMatcher_StringMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5714 size := m.SizeVT()
5715 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5716 }
5717
5718 func (m *QueryParameterMatcher_StringMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5719 i := len(dAtA)
5720 if m.StringMatch != nil {
5721 if vtmsg, ok := interface{}(m.StringMatch).(interface {
5722 MarshalToSizedBufferVTStrict([]byte) (int, error)
5723 }); ok {
5724 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5725 if err != nil {
5726 return 0, err
5727 }
5728 i -= size
5729 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5730 } else {
5731 encoded, err := proto.Marshal(m.StringMatch)
5732 if err != nil {
5733 return 0, err
5734 }
5735 i -= len(encoded)
5736 copy(dAtA[i:], encoded)
5737 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5738 }
5739 i--
5740 dAtA[i] = 0x2a
5741 } else {
5742 i = protohelpers.EncodeVarint(dAtA, i, 0)
5743 i--
5744 dAtA[i] = 0x2a
5745 }
5746 return len(dAtA) - i, nil
5747 }
5748 func (m *QueryParameterMatcher_PresentMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
5749 size := m.SizeVT()
5750 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5751 }
5752
5753 func (m *QueryParameterMatcher_PresentMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5754 i := len(dAtA)
5755 i--
5756 if m.PresentMatch {
5757 dAtA[i] = 1
5758 } else {
5759 dAtA[i] = 0
5760 }
5761 i--
5762 dAtA[i] = 0x30
5763 return len(dAtA) - i, nil
5764 }
5765 func (m *InternalRedirectPolicy) MarshalVTStrict() (dAtA []byte, err error) {
5766 if m == nil {
5767 return nil, nil
5768 }
5769 size := m.SizeVT()
5770 dAtA = make([]byte, size)
5771 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5772 if err != nil {
5773 return nil, err
5774 }
5775 return dAtA[:n], nil
5776 }
5777
5778 func (m *InternalRedirectPolicy) MarshalToVTStrict(dAtA []byte) (int, error) {
5779 size := m.SizeVT()
5780 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5781 }
5782
5783 func (m *InternalRedirectPolicy) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5784 if m == nil {
5785 return 0, nil
5786 }
5787 i := len(dAtA)
5788 _ = i
5789 var l int
5790 _ = l
5791 if m.unknownFields != nil {
5792 i -= len(m.unknownFields)
5793 copy(dAtA[i:], m.unknownFields)
5794 }
5795 if len(m.ResponseHeadersToCopy) > 0 {
5796 for iNdEx := len(m.ResponseHeadersToCopy) - 1; iNdEx >= 0; iNdEx-- {
5797 i -= len(m.ResponseHeadersToCopy[iNdEx])
5798 copy(dAtA[i:], m.ResponseHeadersToCopy[iNdEx])
5799 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResponseHeadersToCopy[iNdEx])))
5800 i--
5801 dAtA[i] = 0x2a
5802 }
5803 }
5804 if m.AllowCrossSchemeRedirect {
5805 i--
5806 if m.AllowCrossSchemeRedirect {
5807 dAtA[i] = 1
5808 } else {
5809 dAtA[i] = 0
5810 }
5811 i--
5812 dAtA[i] = 0x20
5813 }
5814 if len(m.Predicates) > 0 {
5815 for iNdEx := len(m.Predicates) - 1; iNdEx >= 0; iNdEx-- {
5816 if vtmsg, ok := interface{}(m.Predicates[iNdEx]).(interface {
5817 MarshalToSizedBufferVTStrict([]byte) (int, error)
5818 }); ok {
5819 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
5820 if err != nil {
5821 return 0, err
5822 }
5823 i -= size
5824 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5825 } else {
5826 encoded, err := proto.Marshal(m.Predicates[iNdEx])
5827 if err != nil {
5828 return 0, err
5829 }
5830 i -= len(encoded)
5831 copy(dAtA[i:], encoded)
5832 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5833 }
5834 i--
5835 dAtA[i] = 0x1a
5836 }
5837 }
5838 if len(m.RedirectResponseCodes) > 0 {
5839 var pksize2 int
5840 for _, num := range m.RedirectResponseCodes {
5841 pksize2 += protohelpers.SizeOfVarint(uint64(num))
5842 }
5843 i -= pksize2
5844 j1 := i
5845 for _, num := range m.RedirectResponseCodes {
5846 for num >= 1<<7 {
5847 dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
5848 num >>= 7
5849 j1++
5850 }
5851 dAtA[j1] = uint8(num)
5852 j1++
5853 }
5854 i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))
5855 i--
5856 dAtA[i] = 0x12
5857 }
5858 if m.MaxInternalRedirects != nil {
5859 size, err := (*wrapperspb.UInt32Value)(m.MaxInternalRedirects).MarshalToSizedBufferVTStrict(dAtA[:i])
5860 if err != nil {
5861 return 0, err
5862 }
5863 i -= size
5864 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5865 i--
5866 dAtA[i] = 0xa
5867 }
5868 return len(dAtA) - i, nil
5869 }
5870
5871 func (m *FilterConfig) MarshalVTStrict() (dAtA []byte, err error) {
5872 if m == nil {
5873 return nil, nil
5874 }
5875 size := m.SizeVT()
5876 dAtA = make([]byte, size)
5877 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
5878 if err != nil {
5879 return nil, err
5880 }
5881 return dAtA[:n], nil
5882 }
5883
5884 func (m *FilterConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
5885 size := m.SizeVT()
5886 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
5887 }
5888
5889 func (m *FilterConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
5890 if m == nil {
5891 return 0, nil
5892 }
5893 i := len(dAtA)
5894 _ = i
5895 var l int
5896 _ = l
5897 if m.unknownFields != nil {
5898 i -= len(m.unknownFields)
5899 copy(dAtA[i:], m.unknownFields)
5900 }
5901 if m.Disabled {
5902 i--
5903 if m.Disabled {
5904 dAtA[i] = 1
5905 } else {
5906 dAtA[i] = 0
5907 }
5908 i--
5909 dAtA[i] = 0x18
5910 }
5911 if m.IsOptional {
5912 i--
5913 if m.IsOptional {
5914 dAtA[i] = 1
5915 } else {
5916 dAtA[i] = 0
5917 }
5918 i--
5919 dAtA[i] = 0x10
5920 }
5921 if m.Config != nil {
5922 size, err := (*anypb.Any)(m.Config).MarshalToSizedBufferVTStrict(dAtA[:i])
5923 if err != nil {
5924 return 0, err
5925 }
5926 i -= size
5927 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5928 i--
5929 dAtA[i] = 0xa
5930 }
5931 return len(dAtA) - i, nil
5932 }
5933
5934 func (m *VirtualHost) SizeVT() (n int) {
5935 if m == nil {
5936 return 0
5937 }
5938 var l int
5939 _ = l
5940 l = len(m.Name)
5941 if l > 0 {
5942 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5943 }
5944 if len(m.Domains) > 0 {
5945 for _, s := range m.Domains {
5946 l = len(s)
5947 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5948 }
5949 }
5950 if len(m.Routes) > 0 {
5951 for _, e := range m.Routes {
5952 l = e.SizeVT()
5953 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5954 }
5955 }
5956 if m.RequireTls != 0 {
5957 n += 1 + protohelpers.SizeOfVarint(uint64(m.RequireTls))
5958 }
5959 if len(m.VirtualClusters) > 0 {
5960 for _, e := range m.VirtualClusters {
5961 l = e.SizeVT()
5962 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5963 }
5964 }
5965 if len(m.RateLimits) > 0 {
5966 for _, e := range m.RateLimits {
5967 l = e.SizeVT()
5968 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5969 }
5970 }
5971 if len(m.RequestHeadersToAdd) > 0 {
5972 for _, e := range m.RequestHeadersToAdd {
5973 if size, ok := interface{}(e).(interface {
5974 SizeVT() int
5975 }); ok {
5976 l = size.SizeVT()
5977 } else {
5978 l = proto.Size(e)
5979 }
5980 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5981 }
5982 }
5983 if m.Cors != nil {
5984 l = m.Cors.SizeVT()
5985 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5986 }
5987 if len(m.ResponseHeadersToAdd) > 0 {
5988 for _, e := range m.ResponseHeadersToAdd {
5989 if size, ok := interface{}(e).(interface {
5990 SizeVT() int
5991 }); ok {
5992 l = size.SizeVT()
5993 } else {
5994 l = proto.Size(e)
5995 }
5996 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5997 }
5998 }
5999 if len(m.ResponseHeadersToRemove) > 0 {
6000 for _, s := range m.ResponseHeadersToRemove {
6001 l = len(s)
6002 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6003 }
6004 }
6005 if len(m.RequestHeadersToRemove) > 0 {
6006 for _, s := range m.RequestHeadersToRemove {
6007 l = len(s)
6008 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6009 }
6010 }
6011 if m.IncludeRequestAttemptCount {
6012 n += 2
6013 }
6014 if len(m.TypedPerFilterConfig) > 0 {
6015 for k, v := range m.TypedPerFilterConfig {
6016 _ = k
6017 _ = v
6018 l = 0
6019 if v != nil {
6020 l = (*anypb.Any)(v).SizeVT()
6021 }
6022 l += 1 + protohelpers.SizeOfVarint(uint64(l))
6023 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
6024 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
6025 }
6026 }
6027 if m.RetryPolicy != nil {
6028 l = m.RetryPolicy.SizeVT()
6029 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6030 }
6031 if m.HedgePolicy != nil {
6032 l = m.HedgePolicy.SizeVT()
6033 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6034 }
6035 if m.PerRequestBufferLimitBytes != nil {
6036 l = (*wrapperspb.UInt32Value)(m.PerRequestBufferLimitBytes).SizeVT()
6037 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6038 }
6039 if m.IncludeAttemptCountInResponse {
6040 n += 3
6041 }
6042 if m.RetryPolicyTypedConfig != nil {
6043 l = (*anypb.Any)(m.RetryPolicyTypedConfig).SizeVT()
6044 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6045 }
6046 if m.Matcher != nil {
6047 if size, ok := interface{}(m.Matcher).(interface {
6048 SizeVT() int
6049 }); ok {
6050 l = size.SizeVT()
6051 } else {
6052 l = proto.Size(m.Matcher)
6053 }
6054 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6055 }
6056 if len(m.RequestMirrorPolicies) > 0 {
6057 for _, e := range m.RequestMirrorPolicies {
6058 l = e.SizeVT()
6059 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6060 }
6061 }
6062 if m.IncludeIsTimeoutRetryHeader {
6063 n += 3
6064 }
6065 if m.Metadata != nil {
6066 if size, ok := interface{}(m.Metadata).(interface {
6067 SizeVT() int
6068 }); ok {
6069 l = size.SizeVT()
6070 } else {
6071 l = proto.Size(m.Metadata)
6072 }
6073 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6074 }
6075 n += len(m.unknownFields)
6076 return n
6077 }
6078
6079 func (m *FilterAction) SizeVT() (n int) {
6080 if m == nil {
6081 return 0
6082 }
6083 var l int
6084 _ = l
6085 if m.Action != nil {
6086 l = (*anypb.Any)(m.Action).SizeVT()
6087 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6088 }
6089 n += len(m.unknownFields)
6090 return n
6091 }
6092
6093 func (m *RouteList) SizeVT() (n int) {
6094 if m == nil {
6095 return 0
6096 }
6097 var l int
6098 _ = l
6099 if len(m.Routes) > 0 {
6100 for _, e := range m.Routes {
6101 l = e.SizeVT()
6102 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6103 }
6104 }
6105 n += len(m.unknownFields)
6106 return n
6107 }
6108
6109 func (m *Route) SizeVT() (n int) {
6110 if m == nil {
6111 return 0
6112 }
6113 var l int
6114 _ = l
6115 if m.Match != nil {
6116 l = m.Match.SizeVT()
6117 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6118 }
6119 if vtmsg, ok := m.Action.(interface{ SizeVT() int }); ok {
6120 n += vtmsg.SizeVT()
6121 }
6122 if m.Metadata != nil {
6123 if size, ok := interface{}(m.Metadata).(interface {
6124 SizeVT() int
6125 }); ok {
6126 l = size.SizeVT()
6127 } else {
6128 l = proto.Size(m.Metadata)
6129 }
6130 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6131 }
6132 if m.Decorator != nil {
6133 l = m.Decorator.SizeVT()
6134 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6135 }
6136 if len(m.RequestHeadersToAdd) > 0 {
6137 for _, e := range m.RequestHeadersToAdd {
6138 if size, ok := interface{}(e).(interface {
6139 SizeVT() int
6140 }); ok {
6141 l = size.SizeVT()
6142 } else {
6143 l = proto.Size(e)
6144 }
6145 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6146 }
6147 }
6148 if len(m.ResponseHeadersToAdd) > 0 {
6149 for _, e := range m.ResponseHeadersToAdd {
6150 if size, ok := interface{}(e).(interface {
6151 SizeVT() int
6152 }); ok {
6153 l = size.SizeVT()
6154 } else {
6155 l = proto.Size(e)
6156 }
6157 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6158 }
6159 }
6160 if len(m.ResponseHeadersToRemove) > 0 {
6161 for _, s := range m.ResponseHeadersToRemove {
6162 l = len(s)
6163 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6164 }
6165 }
6166 if len(m.RequestHeadersToRemove) > 0 {
6167 for _, s := range m.RequestHeadersToRemove {
6168 l = len(s)
6169 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6170 }
6171 }
6172 if len(m.TypedPerFilterConfig) > 0 {
6173 for k, v := range m.TypedPerFilterConfig {
6174 _ = k
6175 _ = v
6176 l = 0
6177 if v != nil {
6178 l = (*anypb.Any)(v).SizeVT()
6179 }
6180 l += 1 + protohelpers.SizeOfVarint(uint64(l))
6181 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
6182 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
6183 }
6184 }
6185 l = len(m.Name)
6186 if l > 0 {
6187 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6188 }
6189 if m.Tracing != nil {
6190 l = m.Tracing.SizeVT()
6191 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6192 }
6193 if m.PerRequestBufferLimitBytes != nil {
6194 l = (*wrapperspb.UInt32Value)(m.PerRequestBufferLimitBytes).SizeVT()
6195 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6196 }
6197 l = len(m.StatPrefix)
6198 if l > 0 {
6199 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6200 }
6201 n += len(m.unknownFields)
6202 return n
6203 }
6204
6205 func (m *Route_Route) SizeVT() (n int) {
6206 if m == nil {
6207 return 0
6208 }
6209 var l int
6210 _ = l
6211 if m.Route != nil {
6212 l = m.Route.SizeVT()
6213 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6214 } else {
6215 n += 2
6216 }
6217 return n
6218 }
6219 func (m *Route_Redirect) SizeVT() (n int) {
6220 if m == nil {
6221 return 0
6222 }
6223 var l int
6224 _ = l
6225 if m.Redirect != nil {
6226 l = m.Redirect.SizeVT()
6227 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6228 } else {
6229 n += 2
6230 }
6231 return n
6232 }
6233 func (m *Route_DirectResponse) SizeVT() (n int) {
6234 if m == nil {
6235 return 0
6236 }
6237 var l int
6238 _ = l
6239 if m.DirectResponse != nil {
6240 l = m.DirectResponse.SizeVT()
6241 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6242 } else {
6243 n += 2
6244 }
6245 return n
6246 }
6247 func (m *Route_FilterAction) SizeVT() (n int) {
6248 if m == nil {
6249 return 0
6250 }
6251 var l int
6252 _ = l
6253 if m.FilterAction != nil {
6254 l = m.FilterAction.SizeVT()
6255 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6256 } else {
6257 n += 3
6258 }
6259 return n
6260 }
6261 func (m *Route_NonForwardingAction) SizeVT() (n int) {
6262 if m == nil {
6263 return 0
6264 }
6265 var l int
6266 _ = l
6267 if m.NonForwardingAction != nil {
6268 l = m.NonForwardingAction.SizeVT()
6269 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
6270 } else {
6271 n += 3
6272 }
6273 return n
6274 }
6275 func (m *WeightedCluster_ClusterWeight) SizeVT() (n int) {
6276 if m == nil {
6277 return 0
6278 }
6279 var l int
6280 _ = l
6281 l = len(m.Name)
6282 if l > 0 {
6283 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6284 }
6285 if m.Weight != nil {
6286 l = (*wrapperspb.UInt32Value)(m.Weight).SizeVT()
6287 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6288 }
6289 if m.MetadataMatch != nil {
6290 if size, ok := interface{}(m.MetadataMatch).(interface {
6291 SizeVT() int
6292 }); ok {
6293 l = size.SizeVT()
6294 } else {
6295 l = proto.Size(m.MetadataMatch)
6296 }
6297 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6298 }
6299 if len(m.RequestHeadersToAdd) > 0 {
6300 for _, e := range m.RequestHeadersToAdd {
6301 if size, ok := interface{}(e).(interface {
6302 SizeVT() int
6303 }); ok {
6304 l = size.SizeVT()
6305 } else {
6306 l = proto.Size(e)
6307 }
6308 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6309 }
6310 }
6311 if len(m.ResponseHeadersToAdd) > 0 {
6312 for _, e := range m.ResponseHeadersToAdd {
6313 if size, ok := interface{}(e).(interface {
6314 SizeVT() int
6315 }); ok {
6316 l = size.SizeVT()
6317 } else {
6318 l = proto.Size(e)
6319 }
6320 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6321 }
6322 }
6323 if len(m.ResponseHeadersToRemove) > 0 {
6324 for _, s := range m.ResponseHeadersToRemove {
6325 l = len(s)
6326 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6327 }
6328 }
6329 if len(m.RequestHeadersToRemove) > 0 {
6330 for _, s := range m.RequestHeadersToRemove {
6331 l = len(s)
6332 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6333 }
6334 }
6335 if len(m.TypedPerFilterConfig) > 0 {
6336 for k, v := range m.TypedPerFilterConfig {
6337 _ = k
6338 _ = v
6339 l = 0
6340 if v != nil {
6341 l = (*anypb.Any)(v).SizeVT()
6342 }
6343 l += 1 + protohelpers.SizeOfVarint(uint64(l))
6344 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
6345 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
6346 }
6347 }
6348 if vtmsg, ok := m.HostRewriteSpecifier.(interface{ SizeVT() int }); ok {
6349 n += vtmsg.SizeVT()
6350 }
6351 l = len(m.ClusterHeader)
6352 if l > 0 {
6353 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6354 }
6355 n += len(m.unknownFields)
6356 return n
6357 }
6358
6359 func (m *WeightedCluster_ClusterWeight_HostRewriteLiteral) SizeVT() (n int) {
6360 if m == nil {
6361 return 0
6362 }
6363 var l int
6364 _ = l
6365 l = len(m.HostRewriteLiteral)
6366 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6367 return n
6368 }
6369 func (m *WeightedCluster) SizeVT() (n int) {
6370 if m == nil {
6371 return 0
6372 }
6373 var l int
6374 _ = l
6375 if len(m.Clusters) > 0 {
6376 for _, e := range m.Clusters {
6377 l = e.SizeVT()
6378 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6379 }
6380 }
6381 l = len(m.RuntimeKeyPrefix)
6382 if l > 0 {
6383 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6384 }
6385 if m.TotalWeight != nil {
6386 l = (*wrapperspb.UInt32Value)(m.TotalWeight).SizeVT()
6387 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6388 }
6389 if vtmsg, ok := m.RandomValueSpecifier.(interface{ SizeVT() int }); ok {
6390 n += vtmsg.SizeVT()
6391 }
6392 n += len(m.unknownFields)
6393 return n
6394 }
6395
6396 func (m *WeightedCluster_HeaderName) SizeVT() (n int) {
6397 if m == nil {
6398 return 0
6399 }
6400 var l int
6401 _ = l
6402 l = len(m.HeaderName)
6403 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6404 return n
6405 }
6406 func (m *ClusterSpecifierPlugin) SizeVT() (n int) {
6407 if m == nil {
6408 return 0
6409 }
6410 var l int
6411 _ = l
6412 if m.Extension != nil {
6413 if size, ok := interface{}(m.Extension).(interface {
6414 SizeVT() int
6415 }); ok {
6416 l = size.SizeVT()
6417 } else {
6418 l = proto.Size(m.Extension)
6419 }
6420 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6421 }
6422 if m.IsOptional {
6423 n += 2
6424 }
6425 n += len(m.unknownFields)
6426 return n
6427 }
6428
6429 func (m *RouteMatch_GrpcRouteMatchOptions) SizeVT() (n int) {
6430 if m == nil {
6431 return 0
6432 }
6433 var l int
6434 _ = l
6435 n += len(m.unknownFields)
6436 return n
6437 }
6438
6439 func (m *RouteMatch_TlsContextMatchOptions) SizeVT() (n int) {
6440 if m == nil {
6441 return 0
6442 }
6443 var l int
6444 _ = l
6445 if m.Presented != nil {
6446 l = (*wrapperspb.BoolValue)(m.Presented).SizeVT()
6447 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6448 }
6449 if m.Validated != nil {
6450 l = (*wrapperspb.BoolValue)(m.Validated).SizeVT()
6451 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6452 }
6453 n += len(m.unknownFields)
6454 return n
6455 }
6456
6457 func (m *RouteMatch_ConnectMatcher) SizeVT() (n int) {
6458 if m == nil {
6459 return 0
6460 }
6461 var l int
6462 _ = l
6463 n += len(m.unknownFields)
6464 return n
6465 }
6466
6467 func (m *RouteMatch) SizeVT() (n int) {
6468 if m == nil {
6469 return 0
6470 }
6471 var l int
6472 _ = l
6473 if vtmsg, ok := m.PathSpecifier.(interface{ SizeVT() int }); ok {
6474 n += vtmsg.SizeVT()
6475 }
6476 if m.CaseSensitive != nil {
6477 l = (*wrapperspb.BoolValue)(m.CaseSensitive).SizeVT()
6478 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6479 }
6480 if len(m.Headers) > 0 {
6481 for _, e := range m.Headers {
6482 l = e.SizeVT()
6483 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6484 }
6485 }
6486 if len(m.QueryParameters) > 0 {
6487 for _, e := range m.QueryParameters {
6488 l = e.SizeVT()
6489 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6490 }
6491 }
6492 if m.Grpc != nil {
6493 l = m.Grpc.SizeVT()
6494 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6495 }
6496 if m.RuntimeFraction != nil {
6497 if size, ok := interface{}(m.RuntimeFraction).(interface {
6498 SizeVT() int
6499 }); ok {
6500 l = size.SizeVT()
6501 } else {
6502 l = proto.Size(m.RuntimeFraction)
6503 }
6504 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6505 }
6506 if m.TlsContext != nil {
6507 l = m.TlsContext.SizeVT()
6508 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6509 }
6510 if len(m.DynamicMetadata) > 0 {
6511 for _, e := range m.DynamicMetadata {
6512 if size, ok := interface{}(e).(interface {
6513 SizeVT() int
6514 }); ok {
6515 l = size.SizeVT()
6516 } else {
6517 l = proto.Size(e)
6518 }
6519 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6520 }
6521 }
6522 n += len(m.unknownFields)
6523 return n
6524 }
6525
6526 func (m *RouteMatch_Prefix) SizeVT() (n int) {
6527 if m == nil {
6528 return 0
6529 }
6530 var l int
6531 _ = l
6532 l = len(m.Prefix)
6533 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6534 return n
6535 }
6536 func (m *RouteMatch_Path) SizeVT() (n int) {
6537 if m == nil {
6538 return 0
6539 }
6540 var l int
6541 _ = l
6542 l = len(m.Path)
6543 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6544 return n
6545 }
6546 func (m *RouteMatch_SafeRegex) SizeVT() (n int) {
6547 if m == nil {
6548 return 0
6549 }
6550 var l int
6551 _ = l
6552 if m.SafeRegex != nil {
6553 if size, ok := interface{}(m.SafeRegex).(interface {
6554 SizeVT() int
6555 }); ok {
6556 l = size.SizeVT()
6557 } else {
6558 l = proto.Size(m.SafeRegex)
6559 }
6560 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6561 } else {
6562 n += 2
6563 }
6564 return n
6565 }
6566 func (m *RouteMatch_ConnectMatcher_) SizeVT() (n int) {
6567 if m == nil {
6568 return 0
6569 }
6570 var l int
6571 _ = l
6572 if m.ConnectMatcher != nil {
6573 l = m.ConnectMatcher.SizeVT()
6574 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6575 } else {
6576 n += 2
6577 }
6578 return n
6579 }
6580 func (m *RouteMatch_PathSeparatedPrefix) SizeVT() (n int) {
6581 if m == nil {
6582 return 0
6583 }
6584 var l int
6585 _ = l
6586 l = len(m.PathSeparatedPrefix)
6587 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6588 return n
6589 }
6590 func (m *RouteMatch_PathMatchPolicy) SizeVT() (n int) {
6591 if m == nil {
6592 return 0
6593 }
6594 var l int
6595 _ = l
6596 if m.PathMatchPolicy != nil {
6597 if size, ok := interface{}(m.PathMatchPolicy).(interface {
6598 SizeVT() int
6599 }); ok {
6600 l = size.SizeVT()
6601 } else {
6602 l = proto.Size(m.PathMatchPolicy)
6603 }
6604 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6605 } else {
6606 n += 2
6607 }
6608 return n
6609 }
6610 func (m *CorsPolicy) SizeVT() (n int) {
6611 if m == nil {
6612 return 0
6613 }
6614 var l int
6615 _ = l
6616 l = len(m.AllowMethods)
6617 if l > 0 {
6618 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6619 }
6620 l = len(m.AllowHeaders)
6621 if l > 0 {
6622 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6623 }
6624 l = len(m.ExposeHeaders)
6625 if l > 0 {
6626 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6627 }
6628 l = len(m.MaxAge)
6629 if l > 0 {
6630 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6631 }
6632 if m.AllowCredentials != nil {
6633 l = (*wrapperspb.BoolValue)(m.AllowCredentials).SizeVT()
6634 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6635 }
6636 if vtmsg, ok := m.EnabledSpecifier.(interface{ SizeVT() int }); ok {
6637 n += vtmsg.SizeVT()
6638 }
6639 if m.ShadowEnabled != nil {
6640 if size, ok := interface{}(m.ShadowEnabled).(interface {
6641 SizeVT() int
6642 }); ok {
6643 l = size.SizeVT()
6644 } else {
6645 l = proto.Size(m.ShadowEnabled)
6646 }
6647 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6648 }
6649 if len(m.AllowOriginStringMatch) > 0 {
6650 for _, e := range m.AllowOriginStringMatch {
6651 if size, ok := interface{}(e).(interface {
6652 SizeVT() int
6653 }); ok {
6654 l = size.SizeVT()
6655 } else {
6656 l = proto.Size(e)
6657 }
6658 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6659 }
6660 }
6661 if m.AllowPrivateNetworkAccess != nil {
6662 l = (*wrapperspb.BoolValue)(m.AllowPrivateNetworkAccess).SizeVT()
6663 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6664 }
6665 if m.ForwardNotMatchingPreflights != nil {
6666 l = (*wrapperspb.BoolValue)(m.ForwardNotMatchingPreflights).SizeVT()
6667 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6668 }
6669 n += len(m.unknownFields)
6670 return n
6671 }
6672
6673 func (m *CorsPolicy_FilterEnabled) SizeVT() (n int) {
6674 if m == nil {
6675 return 0
6676 }
6677 var l int
6678 _ = l
6679 if m.FilterEnabled != nil {
6680 if size, ok := interface{}(m.FilterEnabled).(interface {
6681 SizeVT() int
6682 }); ok {
6683 l = size.SizeVT()
6684 } else {
6685 l = proto.Size(m.FilterEnabled)
6686 }
6687 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6688 } else {
6689 n += 2
6690 }
6691 return n
6692 }
6693 func (m *RouteAction_RequestMirrorPolicy) SizeVT() (n int) {
6694 if m == nil {
6695 return 0
6696 }
6697 var l int
6698 _ = l
6699 l = len(m.Cluster)
6700 if l > 0 {
6701 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6702 }
6703 if m.RuntimeFraction != nil {
6704 if size, ok := interface{}(m.RuntimeFraction).(interface {
6705 SizeVT() int
6706 }); ok {
6707 l = size.SizeVT()
6708 } else {
6709 l = proto.Size(m.RuntimeFraction)
6710 }
6711 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6712 }
6713 if m.TraceSampled != nil {
6714 l = (*wrapperspb.BoolValue)(m.TraceSampled).SizeVT()
6715 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6716 }
6717 l = len(m.ClusterHeader)
6718 if l > 0 {
6719 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6720 }
6721 if m.DisableShadowHostSuffixAppend {
6722 n += 2
6723 }
6724 n += len(m.unknownFields)
6725 return n
6726 }
6727
6728 func (m *RouteAction_HashPolicy_Header) SizeVT() (n int) {
6729 if m == nil {
6730 return 0
6731 }
6732 var l int
6733 _ = l
6734 l = len(m.HeaderName)
6735 if l > 0 {
6736 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6737 }
6738 if m.RegexRewrite != nil {
6739 if size, ok := interface{}(m.RegexRewrite).(interface {
6740 SizeVT() int
6741 }); ok {
6742 l = size.SizeVT()
6743 } else {
6744 l = proto.Size(m.RegexRewrite)
6745 }
6746 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6747 }
6748 n += len(m.unknownFields)
6749 return n
6750 }
6751
6752 func (m *RouteAction_HashPolicy_CookieAttribute) SizeVT() (n int) {
6753 if m == nil {
6754 return 0
6755 }
6756 var l int
6757 _ = l
6758 l = len(m.Name)
6759 if l > 0 {
6760 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6761 }
6762 l = len(m.Value)
6763 if l > 0 {
6764 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6765 }
6766 n += len(m.unknownFields)
6767 return n
6768 }
6769
6770 func (m *RouteAction_HashPolicy_Cookie) SizeVT() (n int) {
6771 if m == nil {
6772 return 0
6773 }
6774 var l int
6775 _ = l
6776 l = len(m.Name)
6777 if l > 0 {
6778 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6779 }
6780 if m.Ttl != nil {
6781 l = (*durationpb.Duration)(m.Ttl).SizeVT()
6782 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6783 }
6784 l = len(m.Path)
6785 if l > 0 {
6786 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6787 }
6788 if len(m.Attributes) > 0 {
6789 for _, e := range m.Attributes {
6790 l = e.SizeVT()
6791 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6792 }
6793 }
6794 n += len(m.unknownFields)
6795 return n
6796 }
6797
6798 func (m *RouteAction_HashPolicy_ConnectionProperties) SizeVT() (n int) {
6799 if m == nil {
6800 return 0
6801 }
6802 var l int
6803 _ = l
6804 if m.SourceIp {
6805 n += 2
6806 }
6807 n += len(m.unknownFields)
6808 return n
6809 }
6810
6811 func (m *RouteAction_HashPolicy_QueryParameter) SizeVT() (n int) {
6812 if m == nil {
6813 return 0
6814 }
6815 var l int
6816 _ = l
6817 l = len(m.Name)
6818 if l > 0 {
6819 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6820 }
6821 n += len(m.unknownFields)
6822 return n
6823 }
6824
6825 func (m *RouteAction_HashPolicy_FilterState) SizeVT() (n int) {
6826 if m == nil {
6827 return 0
6828 }
6829 var l int
6830 _ = l
6831 l = len(m.Key)
6832 if l > 0 {
6833 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6834 }
6835 n += len(m.unknownFields)
6836 return n
6837 }
6838
6839 func (m *RouteAction_HashPolicy) SizeVT() (n int) {
6840 if m == nil {
6841 return 0
6842 }
6843 var l int
6844 _ = l
6845 if vtmsg, ok := m.PolicySpecifier.(interface{ SizeVT() int }); ok {
6846 n += vtmsg.SizeVT()
6847 }
6848 if m.Terminal {
6849 n += 2
6850 }
6851 n += len(m.unknownFields)
6852 return n
6853 }
6854
6855 func (m *RouteAction_HashPolicy_Header_) SizeVT() (n int) {
6856 if m == nil {
6857 return 0
6858 }
6859 var l int
6860 _ = l
6861 if m.Header != nil {
6862 l = m.Header.SizeVT()
6863 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6864 } else {
6865 n += 2
6866 }
6867 return n
6868 }
6869 func (m *RouteAction_HashPolicy_Cookie_) SizeVT() (n int) {
6870 if m == nil {
6871 return 0
6872 }
6873 var l int
6874 _ = l
6875 if m.Cookie != nil {
6876 l = m.Cookie.SizeVT()
6877 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6878 } else {
6879 n += 2
6880 }
6881 return n
6882 }
6883 func (m *RouteAction_HashPolicy_ConnectionProperties_) SizeVT() (n int) {
6884 if m == nil {
6885 return 0
6886 }
6887 var l int
6888 _ = l
6889 if m.ConnectionProperties != nil {
6890 l = m.ConnectionProperties.SizeVT()
6891 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6892 } else {
6893 n += 2
6894 }
6895 return n
6896 }
6897 func (m *RouteAction_HashPolicy_QueryParameter_) SizeVT() (n int) {
6898 if m == nil {
6899 return 0
6900 }
6901 var l int
6902 _ = l
6903 if m.QueryParameter != nil {
6904 l = m.QueryParameter.SizeVT()
6905 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6906 } else {
6907 n += 2
6908 }
6909 return n
6910 }
6911 func (m *RouteAction_HashPolicy_FilterState_) SizeVT() (n int) {
6912 if m == nil {
6913 return 0
6914 }
6915 var l int
6916 _ = l
6917 if m.FilterState != nil {
6918 l = m.FilterState.SizeVT()
6919 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6920 } else {
6921 n += 2
6922 }
6923 return n
6924 }
6925 func (m *RouteAction_UpgradeConfig_ConnectConfig) SizeVT() (n int) {
6926 if m == nil {
6927 return 0
6928 }
6929 var l int
6930 _ = l
6931 if m.ProxyProtocolConfig != nil {
6932 if size, ok := interface{}(m.ProxyProtocolConfig).(interface {
6933 SizeVT() int
6934 }); ok {
6935 l = size.SizeVT()
6936 } else {
6937 l = proto.Size(m.ProxyProtocolConfig)
6938 }
6939 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6940 }
6941 if m.AllowPost {
6942 n += 2
6943 }
6944 n += len(m.unknownFields)
6945 return n
6946 }
6947
6948 func (m *RouteAction_UpgradeConfig) SizeVT() (n int) {
6949 if m == nil {
6950 return 0
6951 }
6952 var l int
6953 _ = l
6954 l = len(m.UpgradeType)
6955 if l > 0 {
6956 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6957 }
6958 if m.Enabled != nil {
6959 l = (*wrapperspb.BoolValue)(m.Enabled).SizeVT()
6960 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6961 }
6962 if m.ConnectConfig != nil {
6963 l = m.ConnectConfig.SizeVT()
6964 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6965 }
6966 n += len(m.unknownFields)
6967 return n
6968 }
6969
6970 func (m *RouteAction_MaxStreamDuration) SizeVT() (n int) {
6971 if m == nil {
6972 return 0
6973 }
6974 var l int
6975 _ = l
6976 if m.MaxStreamDuration != nil {
6977 l = (*durationpb.Duration)(m.MaxStreamDuration).SizeVT()
6978 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6979 }
6980 if m.GrpcTimeoutHeaderMax != nil {
6981 l = (*durationpb.Duration)(m.GrpcTimeoutHeaderMax).SizeVT()
6982 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6983 }
6984 if m.GrpcTimeoutHeaderOffset != nil {
6985 l = (*durationpb.Duration)(m.GrpcTimeoutHeaderOffset).SizeVT()
6986 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6987 }
6988 n += len(m.unknownFields)
6989 return n
6990 }
6991
6992 func (m *RouteAction) SizeVT() (n int) {
6993 if m == nil {
6994 return 0
6995 }
6996 var l int
6997 _ = l
6998 if vtmsg, ok := m.ClusterSpecifier.(interface{ SizeVT() int }); ok {
6999 n += vtmsg.SizeVT()
7000 }
7001 if m.MetadataMatch != nil {
7002 if size, ok := interface{}(m.MetadataMatch).(interface {
7003 SizeVT() int
7004 }); ok {
7005 l = size.SizeVT()
7006 } else {
7007 l = proto.Size(m.MetadataMatch)
7008 }
7009 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7010 }
7011 l = len(m.PrefixRewrite)
7012 if l > 0 {
7013 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7014 }
7015 if vtmsg, ok := m.HostRewriteSpecifier.(interface{ SizeVT() int }); ok {
7016 n += vtmsg.SizeVT()
7017 }
7018 if m.Timeout != nil {
7019 l = (*durationpb.Duration)(m.Timeout).SizeVT()
7020 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7021 }
7022 if m.RetryPolicy != nil {
7023 l = m.RetryPolicy.SizeVT()
7024 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7025 }
7026 if m.Priority != 0 {
7027 n += 1 + protohelpers.SizeOfVarint(uint64(m.Priority))
7028 }
7029 if len(m.RateLimits) > 0 {
7030 for _, e := range m.RateLimits {
7031 l = e.SizeVT()
7032 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7033 }
7034 }
7035 if m.IncludeVhRateLimits != nil {
7036 l = (*wrapperspb.BoolValue)(m.IncludeVhRateLimits).SizeVT()
7037 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7038 }
7039 if len(m.HashPolicy) > 0 {
7040 for _, e := range m.HashPolicy {
7041 l = e.SizeVT()
7042 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7043 }
7044 }
7045 if m.Cors != nil {
7046 l = m.Cors.SizeVT()
7047 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7048 }
7049 if m.ClusterNotFoundResponseCode != 0 {
7050 n += 2 + protohelpers.SizeOfVarint(uint64(m.ClusterNotFoundResponseCode))
7051 }
7052 if m.MaxGrpcTimeout != nil {
7053 l = (*durationpb.Duration)(m.MaxGrpcTimeout).SizeVT()
7054 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7055 }
7056 if m.IdleTimeout != nil {
7057 l = (*durationpb.Duration)(m.IdleTimeout).SizeVT()
7058 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7059 }
7060 if len(m.UpgradeConfigs) > 0 {
7061 for _, e := range m.UpgradeConfigs {
7062 l = e.SizeVT()
7063 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7064 }
7065 }
7066 if m.InternalRedirectAction != 0 {
7067 n += 2 + protohelpers.SizeOfVarint(uint64(m.InternalRedirectAction))
7068 }
7069 if m.HedgePolicy != nil {
7070 l = m.HedgePolicy.SizeVT()
7071 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7072 }
7073 if m.GrpcTimeoutOffset != nil {
7074 l = (*durationpb.Duration)(m.GrpcTimeoutOffset).SizeVT()
7075 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7076 }
7077 if len(m.RequestMirrorPolicies) > 0 {
7078 for _, e := range m.RequestMirrorPolicies {
7079 l = e.SizeVT()
7080 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7081 }
7082 }
7083 if m.MaxInternalRedirects != nil {
7084 l = (*wrapperspb.UInt32Value)(m.MaxInternalRedirects).SizeVT()
7085 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7086 }
7087 if m.RegexRewrite != nil {
7088 if size, ok := interface{}(m.RegexRewrite).(interface {
7089 SizeVT() int
7090 }); ok {
7091 l = size.SizeVT()
7092 } else {
7093 l = proto.Size(m.RegexRewrite)
7094 }
7095 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7096 }
7097 if m.RetryPolicyTypedConfig != nil {
7098 l = (*anypb.Any)(m.RetryPolicyTypedConfig).SizeVT()
7099 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7100 }
7101 if m.InternalRedirectPolicy != nil {
7102 l = m.InternalRedirectPolicy.SizeVT()
7103 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7104 }
7105 if m.MaxStreamDuration != nil {
7106 l = m.MaxStreamDuration.SizeVT()
7107 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7108 }
7109 if m.AppendXForwardedHost {
7110 n += 3
7111 }
7112 if m.EarlyDataPolicy != nil {
7113 if size, ok := interface{}(m.EarlyDataPolicy).(interface {
7114 SizeVT() int
7115 }); ok {
7116 l = size.SizeVT()
7117 } else {
7118 l = proto.Size(m.EarlyDataPolicy)
7119 }
7120 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7121 }
7122 if m.PathRewritePolicy != nil {
7123 if size, ok := interface{}(m.PathRewritePolicy).(interface {
7124 SizeVT() int
7125 }); ok {
7126 l = size.SizeVT()
7127 } else {
7128 l = proto.Size(m.PathRewritePolicy)
7129 }
7130 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7131 }
7132 n += len(m.unknownFields)
7133 return n
7134 }
7135
7136 func (m *RouteAction_Cluster) SizeVT() (n int) {
7137 if m == nil {
7138 return 0
7139 }
7140 var l int
7141 _ = l
7142 l = len(m.Cluster)
7143 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7144 return n
7145 }
7146 func (m *RouteAction_ClusterHeader) SizeVT() (n int) {
7147 if m == nil {
7148 return 0
7149 }
7150 var l int
7151 _ = l
7152 l = len(m.ClusterHeader)
7153 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7154 return n
7155 }
7156 func (m *RouteAction_WeightedClusters) SizeVT() (n int) {
7157 if m == nil {
7158 return 0
7159 }
7160 var l int
7161 _ = l
7162 if m.WeightedClusters != nil {
7163 l = m.WeightedClusters.SizeVT()
7164 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7165 } else {
7166 n += 2
7167 }
7168 return n
7169 }
7170 func (m *RouteAction_HostRewriteLiteral) SizeVT() (n int) {
7171 if m == nil {
7172 return 0
7173 }
7174 var l int
7175 _ = l
7176 l = len(m.HostRewriteLiteral)
7177 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7178 return n
7179 }
7180 func (m *RouteAction_AutoHostRewrite) SizeVT() (n int) {
7181 if m == nil {
7182 return 0
7183 }
7184 var l int
7185 _ = l
7186 if m.AutoHostRewrite != nil {
7187 l = (*wrapperspb.BoolValue)(m.AutoHostRewrite).SizeVT()
7188 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7189 } else {
7190 n += 2
7191 }
7192 return n
7193 }
7194 func (m *RouteAction_HostRewriteHeader) SizeVT() (n int) {
7195 if m == nil {
7196 return 0
7197 }
7198 var l int
7199 _ = l
7200 l = len(m.HostRewriteHeader)
7201 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7202 return n
7203 }
7204 func (m *RouteAction_HostRewritePathRegex) SizeVT() (n int) {
7205 if m == nil {
7206 return 0
7207 }
7208 var l int
7209 _ = l
7210 if m.HostRewritePathRegex != nil {
7211 if size, ok := interface{}(m.HostRewritePathRegex).(interface {
7212 SizeVT() int
7213 }); ok {
7214 l = size.SizeVT()
7215 } else {
7216 l = proto.Size(m.HostRewritePathRegex)
7217 }
7218 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7219 } else {
7220 n += 3
7221 }
7222 return n
7223 }
7224 func (m *RouteAction_ClusterSpecifierPlugin) SizeVT() (n int) {
7225 if m == nil {
7226 return 0
7227 }
7228 var l int
7229 _ = l
7230 l = len(m.ClusterSpecifierPlugin)
7231 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7232 return n
7233 }
7234 func (m *RouteAction_InlineClusterSpecifierPlugin) SizeVT() (n int) {
7235 if m == nil {
7236 return 0
7237 }
7238 var l int
7239 _ = l
7240 if m.InlineClusterSpecifierPlugin != nil {
7241 l = m.InlineClusterSpecifierPlugin.SizeVT()
7242 n += 2 + l + protohelpers.SizeOfVarint(uint64(l))
7243 } else {
7244 n += 3
7245 }
7246 return n
7247 }
7248 func (m *RetryPolicy_RetryPriority) SizeVT() (n int) {
7249 if m == nil {
7250 return 0
7251 }
7252 var l int
7253 _ = l
7254 l = len(m.Name)
7255 if l > 0 {
7256 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7257 }
7258 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
7259 n += vtmsg.SizeVT()
7260 }
7261 n += len(m.unknownFields)
7262 return n
7263 }
7264
7265 func (m *RetryPolicy_RetryPriority_TypedConfig) SizeVT() (n int) {
7266 if m == nil {
7267 return 0
7268 }
7269 var l int
7270 _ = l
7271 if m.TypedConfig != nil {
7272 l = (*anypb.Any)(m.TypedConfig).SizeVT()
7273 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7274 } else {
7275 n += 2
7276 }
7277 return n
7278 }
7279 func (m *RetryPolicy_RetryHostPredicate) SizeVT() (n int) {
7280 if m == nil {
7281 return 0
7282 }
7283 var l int
7284 _ = l
7285 l = len(m.Name)
7286 if l > 0 {
7287 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7288 }
7289 if vtmsg, ok := m.ConfigType.(interface{ SizeVT() int }); ok {
7290 n += vtmsg.SizeVT()
7291 }
7292 n += len(m.unknownFields)
7293 return n
7294 }
7295
7296 func (m *RetryPolicy_RetryHostPredicate_TypedConfig) SizeVT() (n int) {
7297 if m == nil {
7298 return 0
7299 }
7300 var l int
7301 _ = l
7302 if m.TypedConfig != nil {
7303 l = (*anypb.Any)(m.TypedConfig).SizeVT()
7304 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7305 } else {
7306 n += 2
7307 }
7308 return n
7309 }
7310 func (m *RetryPolicy_RetryBackOff) SizeVT() (n int) {
7311 if m == nil {
7312 return 0
7313 }
7314 var l int
7315 _ = l
7316 if m.BaseInterval != nil {
7317 l = (*durationpb.Duration)(m.BaseInterval).SizeVT()
7318 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7319 }
7320 if m.MaxInterval != nil {
7321 l = (*durationpb.Duration)(m.MaxInterval).SizeVT()
7322 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7323 }
7324 n += len(m.unknownFields)
7325 return n
7326 }
7327
7328 func (m *RetryPolicy_ResetHeader) SizeVT() (n int) {
7329 if m == nil {
7330 return 0
7331 }
7332 var l int
7333 _ = l
7334 l = len(m.Name)
7335 if l > 0 {
7336 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7337 }
7338 if m.Format != 0 {
7339 n += 1 + protohelpers.SizeOfVarint(uint64(m.Format))
7340 }
7341 n += len(m.unknownFields)
7342 return n
7343 }
7344
7345 func (m *RetryPolicy_RateLimitedRetryBackOff) SizeVT() (n int) {
7346 if m == nil {
7347 return 0
7348 }
7349 var l int
7350 _ = l
7351 if len(m.ResetHeaders) > 0 {
7352 for _, e := range m.ResetHeaders {
7353 l = e.SizeVT()
7354 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7355 }
7356 }
7357 if m.MaxInterval != nil {
7358 l = (*durationpb.Duration)(m.MaxInterval).SizeVT()
7359 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7360 }
7361 n += len(m.unknownFields)
7362 return n
7363 }
7364
7365 func (m *RetryPolicy) SizeVT() (n int) {
7366 if m == nil {
7367 return 0
7368 }
7369 var l int
7370 _ = l
7371 l = len(m.RetryOn)
7372 if l > 0 {
7373 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7374 }
7375 if m.NumRetries != nil {
7376 l = (*wrapperspb.UInt32Value)(m.NumRetries).SizeVT()
7377 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7378 }
7379 if m.PerTryTimeout != nil {
7380 l = (*durationpb.Duration)(m.PerTryTimeout).SizeVT()
7381 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7382 }
7383 if m.RetryPriority != nil {
7384 l = m.RetryPriority.SizeVT()
7385 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7386 }
7387 if len(m.RetryHostPredicate) > 0 {
7388 for _, e := range m.RetryHostPredicate {
7389 l = e.SizeVT()
7390 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7391 }
7392 }
7393 if m.HostSelectionRetryMaxAttempts != 0 {
7394 n += 1 + protohelpers.SizeOfVarint(uint64(m.HostSelectionRetryMaxAttempts))
7395 }
7396 if len(m.RetriableStatusCodes) > 0 {
7397 l = 0
7398 for _, e := range m.RetriableStatusCodes {
7399 l += protohelpers.SizeOfVarint(uint64(e))
7400 }
7401 n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l
7402 }
7403 if m.RetryBackOff != nil {
7404 l = m.RetryBackOff.SizeVT()
7405 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7406 }
7407 if len(m.RetriableHeaders) > 0 {
7408 for _, e := range m.RetriableHeaders {
7409 l = e.SizeVT()
7410 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7411 }
7412 }
7413 if len(m.RetriableRequestHeaders) > 0 {
7414 for _, e := range m.RetriableRequestHeaders {
7415 l = e.SizeVT()
7416 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7417 }
7418 }
7419 if m.RateLimitedRetryBackOff != nil {
7420 l = m.RateLimitedRetryBackOff.SizeVT()
7421 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7422 }
7423 if len(m.RetryOptionsPredicates) > 0 {
7424 for _, e := range m.RetryOptionsPredicates {
7425 if size, ok := interface{}(e).(interface {
7426 SizeVT() int
7427 }); ok {
7428 l = size.SizeVT()
7429 } else {
7430 l = proto.Size(e)
7431 }
7432 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7433 }
7434 }
7435 if m.PerTryIdleTimeout != nil {
7436 l = (*durationpb.Duration)(m.PerTryIdleTimeout).SizeVT()
7437 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7438 }
7439 n += len(m.unknownFields)
7440 return n
7441 }
7442
7443 func (m *HedgePolicy) SizeVT() (n int) {
7444 if m == nil {
7445 return 0
7446 }
7447 var l int
7448 _ = l
7449 if m.InitialRequests != nil {
7450 l = (*wrapperspb.UInt32Value)(m.InitialRequests).SizeVT()
7451 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7452 }
7453 if m.AdditionalRequestChance != nil {
7454 if size, ok := interface{}(m.AdditionalRequestChance).(interface {
7455 SizeVT() int
7456 }); ok {
7457 l = size.SizeVT()
7458 } else {
7459 l = proto.Size(m.AdditionalRequestChance)
7460 }
7461 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7462 }
7463 if m.HedgeOnPerTryTimeout {
7464 n += 2
7465 }
7466 n += len(m.unknownFields)
7467 return n
7468 }
7469
7470 func (m *RedirectAction) SizeVT() (n int) {
7471 if m == nil {
7472 return 0
7473 }
7474 var l int
7475 _ = l
7476 l = len(m.HostRedirect)
7477 if l > 0 {
7478 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7479 }
7480 if vtmsg, ok := m.PathRewriteSpecifier.(interface{ SizeVT() int }); ok {
7481 n += vtmsg.SizeVT()
7482 }
7483 if m.ResponseCode != 0 {
7484 n += 1 + protohelpers.SizeOfVarint(uint64(m.ResponseCode))
7485 }
7486 if vtmsg, ok := m.SchemeRewriteSpecifier.(interface{ SizeVT() int }); ok {
7487 n += vtmsg.SizeVT()
7488 }
7489 if m.StripQuery {
7490 n += 2
7491 }
7492 if m.PortRedirect != 0 {
7493 n += 1 + protohelpers.SizeOfVarint(uint64(m.PortRedirect))
7494 }
7495 n += len(m.unknownFields)
7496 return n
7497 }
7498
7499 func (m *RedirectAction_PathRedirect) SizeVT() (n int) {
7500 if m == nil {
7501 return 0
7502 }
7503 var l int
7504 _ = l
7505 l = len(m.PathRedirect)
7506 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7507 return n
7508 }
7509 func (m *RedirectAction_HttpsRedirect) SizeVT() (n int) {
7510 if m == nil {
7511 return 0
7512 }
7513 var l int
7514 _ = l
7515 n += 2
7516 return n
7517 }
7518 func (m *RedirectAction_PrefixRewrite) SizeVT() (n int) {
7519 if m == nil {
7520 return 0
7521 }
7522 var l int
7523 _ = l
7524 l = len(m.PrefixRewrite)
7525 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7526 return n
7527 }
7528 func (m *RedirectAction_SchemeRedirect) SizeVT() (n int) {
7529 if m == nil {
7530 return 0
7531 }
7532 var l int
7533 _ = l
7534 l = len(m.SchemeRedirect)
7535 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7536 return n
7537 }
7538 func (m *RedirectAction_RegexRewrite) SizeVT() (n int) {
7539 if m == nil {
7540 return 0
7541 }
7542 var l int
7543 _ = l
7544 if m.RegexRewrite != nil {
7545 if size, ok := interface{}(m.RegexRewrite).(interface {
7546 SizeVT() int
7547 }); ok {
7548 l = size.SizeVT()
7549 } else {
7550 l = proto.Size(m.RegexRewrite)
7551 }
7552 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7553 } else {
7554 n += 2
7555 }
7556 return n
7557 }
7558 func (m *DirectResponseAction) SizeVT() (n int) {
7559 if m == nil {
7560 return 0
7561 }
7562 var l int
7563 _ = l
7564 if m.Status != 0 {
7565 n += 1 + protohelpers.SizeOfVarint(uint64(m.Status))
7566 }
7567 if m.Body != nil {
7568 if size, ok := interface{}(m.Body).(interface {
7569 SizeVT() int
7570 }); ok {
7571 l = size.SizeVT()
7572 } else {
7573 l = proto.Size(m.Body)
7574 }
7575 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7576 }
7577 n += len(m.unknownFields)
7578 return n
7579 }
7580
7581 func (m *NonForwardingAction) SizeVT() (n int) {
7582 if m == nil {
7583 return 0
7584 }
7585 var l int
7586 _ = l
7587 n += len(m.unknownFields)
7588 return n
7589 }
7590
7591 func (m *Decorator) SizeVT() (n int) {
7592 if m == nil {
7593 return 0
7594 }
7595 var l int
7596 _ = l
7597 l = len(m.Operation)
7598 if l > 0 {
7599 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7600 }
7601 if m.Propagate != nil {
7602 l = (*wrapperspb.BoolValue)(m.Propagate).SizeVT()
7603 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7604 }
7605 n += len(m.unknownFields)
7606 return n
7607 }
7608
7609 func (m *Tracing) SizeVT() (n int) {
7610 if m == nil {
7611 return 0
7612 }
7613 var l int
7614 _ = l
7615 if m.ClientSampling != nil {
7616 if size, ok := interface{}(m.ClientSampling).(interface {
7617 SizeVT() int
7618 }); ok {
7619 l = size.SizeVT()
7620 } else {
7621 l = proto.Size(m.ClientSampling)
7622 }
7623 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7624 }
7625 if m.RandomSampling != nil {
7626 if size, ok := interface{}(m.RandomSampling).(interface {
7627 SizeVT() int
7628 }); ok {
7629 l = size.SizeVT()
7630 } else {
7631 l = proto.Size(m.RandomSampling)
7632 }
7633 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7634 }
7635 if m.OverallSampling != nil {
7636 if size, ok := interface{}(m.OverallSampling).(interface {
7637 SizeVT() int
7638 }); ok {
7639 l = size.SizeVT()
7640 } else {
7641 l = proto.Size(m.OverallSampling)
7642 }
7643 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7644 }
7645 if len(m.CustomTags) > 0 {
7646 for _, e := range m.CustomTags {
7647 if size, ok := interface{}(e).(interface {
7648 SizeVT() int
7649 }); ok {
7650 l = size.SizeVT()
7651 } else {
7652 l = proto.Size(e)
7653 }
7654 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7655 }
7656 }
7657 n += len(m.unknownFields)
7658 return n
7659 }
7660
7661 func (m *VirtualCluster) SizeVT() (n int) {
7662 if m == nil {
7663 return 0
7664 }
7665 var l int
7666 _ = l
7667 l = len(m.Name)
7668 if l > 0 {
7669 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7670 }
7671 if len(m.Headers) > 0 {
7672 for _, e := range m.Headers {
7673 l = e.SizeVT()
7674 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7675 }
7676 }
7677 n += len(m.unknownFields)
7678 return n
7679 }
7680
7681 func (m *RateLimit_Action_SourceCluster) SizeVT() (n int) {
7682 if m == nil {
7683 return 0
7684 }
7685 var l int
7686 _ = l
7687 n += len(m.unknownFields)
7688 return n
7689 }
7690
7691 func (m *RateLimit_Action_DestinationCluster) SizeVT() (n int) {
7692 if m == nil {
7693 return 0
7694 }
7695 var l int
7696 _ = l
7697 n += len(m.unknownFields)
7698 return n
7699 }
7700
7701 func (m *RateLimit_Action_RequestHeaders) SizeVT() (n int) {
7702 if m == nil {
7703 return 0
7704 }
7705 var l int
7706 _ = l
7707 l = len(m.HeaderName)
7708 if l > 0 {
7709 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7710 }
7711 l = len(m.DescriptorKey)
7712 if l > 0 {
7713 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7714 }
7715 if m.SkipIfAbsent {
7716 n += 2
7717 }
7718 n += len(m.unknownFields)
7719 return n
7720 }
7721
7722 func (m *RateLimit_Action_RemoteAddress) SizeVT() (n int) {
7723 if m == nil {
7724 return 0
7725 }
7726 var l int
7727 _ = l
7728 n += len(m.unknownFields)
7729 return n
7730 }
7731
7732 func (m *RateLimit_Action_MaskedRemoteAddress) SizeVT() (n int) {
7733 if m == nil {
7734 return 0
7735 }
7736 var l int
7737 _ = l
7738 if m.V4PrefixMaskLen != nil {
7739 l = (*wrapperspb.UInt32Value)(m.V4PrefixMaskLen).SizeVT()
7740 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7741 }
7742 if m.V6PrefixMaskLen != nil {
7743 l = (*wrapperspb.UInt32Value)(m.V6PrefixMaskLen).SizeVT()
7744 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7745 }
7746 n += len(m.unknownFields)
7747 return n
7748 }
7749
7750 func (m *RateLimit_Action_GenericKey) SizeVT() (n int) {
7751 if m == nil {
7752 return 0
7753 }
7754 var l int
7755 _ = l
7756 l = len(m.DescriptorValue)
7757 if l > 0 {
7758 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7759 }
7760 l = len(m.DescriptorKey)
7761 if l > 0 {
7762 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7763 }
7764 n += len(m.unknownFields)
7765 return n
7766 }
7767
7768 func (m *RateLimit_Action_HeaderValueMatch) SizeVT() (n int) {
7769 if m == nil {
7770 return 0
7771 }
7772 var l int
7773 _ = l
7774 l = len(m.DescriptorValue)
7775 if l > 0 {
7776 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7777 }
7778 if m.ExpectMatch != nil {
7779 l = (*wrapperspb.BoolValue)(m.ExpectMatch).SizeVT()
7780 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7781 }
7782 if len(m.Headers) > 0 {
7783 for _, e := range m.Headers {
7784 l = e.SizeVT()
7785 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7786 }
7787 }
7788 l = len(m.DescriptorKey)
7789 if l > 0 {
7790 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7791 }
7792 n += len(m.unknownFields)
7793 return n
7794 }
7795
7796 func (m *RateLimit_Action_DynamicMetaData) SizeVT() (n int) {
7797 if m == nil {
7798 return 0
7799 }
7800 var l int
7801 _ = l
7802 l = len(m.DescriptorKey)
7803 if l > 0 {
7804 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7805 }
7806 if m.MetadataKey != nil {
7807 if size, ok := interface{}(m.MetadataKey).(interface {
7808 SizeVT() int
7809 }); ok {
7810 l = size.SizeVT()
7811 } else {
7812 l = proto.Size(m.MetadataKey)
7813 }
7814 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7815 }
7816 l = len(m.DefaultValue)
7817 if l > 0 {
7818 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7819 }
7820 n += len(m.unknownFields)
7821 return n
7822 }
7823
7824 func (m *RateLimit_Action_MetaData) SizeVT() (n int) {
7825 if m == nil {
7826 return 0
7827 }
7828 var l int
7829 _ = l
7830 l = len(m.DescriptorKey)
7831 if l > 0 {
7832 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7833 }
7834 if m.MetadataKey != nil {
7835 if size, ok := interface{}(m.MetadataKey).(interface {
7836 SizeVT() int
7837 }); ok {
7838 l = size.SizeVT()
7839 } else {
7840 l = proto.Size(m.MetadataKey)
7841 }
7842 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7843 }
7844 l = len(m.DefaultValue)
7845 if l > 0 {
7846 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7847 }
7848 if m.Source != 0 {
7849 n += 1 + protohelpers.SizeOfVarint(uint64(m.Source))
7850 }
7851 if m.SkipIfAbsent {
7852 n += 2
7853 }
7854 n += len(m.unknownFields)
7855 return n
7856 }
7857
7858 func (m *RateLimit_Action_QueryParameterValueMatch) SizeVT() (n int) {
7859 if m == nil {
7860 return 0
7861 }
7862 var l int
7863 _ = l
7864 l = len(m.DescriptorValue)
7865 if l > 0 {
7866 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7867 }
7868 if m.ExpectMatch != nil {
7869 l = (*wrapperspb.BoolValue)(m.ExpectMatch).SizeVT()
7870 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7871 }
7872 if len(m.QueryParameters) > 0 {
7873 for _, e := range m.QueryParameters {
7874 l = e.SizeVT()
7875 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7876 }
7877 }
7878 l = len(m.DescriptorKey)
7879 if l > 0 {
7880 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7881 }
7882 n += len(m.unknownFields)
7883 return n
7884 }
7885
7886 func (m *RateLimit_Action) SizeVT() (n int) {
7887 if m == nil {
7888 return 0
7889 }
7890 var l int
7891 _ = l
7892 if vtmsg, ok := m.ActionSpecifier.(interface{ SizeVT() int }); ok {
7893 n += vtmsg.SizeVT()
7894 }
7895 n += len(m.unknownFields)
7896 return n
7897 }
7898
7899 func (m *RateLimit_Action_SourceCluster_) SizeVT() (n int) {
7900 if m == nil {
7901 return 0
7902 }
7903 var l int
7904 _ = l
7905 if m.SourceCluster != nil {
7906 l = m.SourceCluster.SizeVT()
7907 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7908 } else {
7909 n += 2
7910 }
7911 return n
7912 }
7913 func (m *RateLimit_Action_DestinationCluster_) SizeVT() (n int) {
7914 if m == nil {
7915 return 0
7916 }
7917 var l int
7918 _ = l
7919 if m.DestinationCluster != nil {
7920 l = m.DestinationCluster.SizeVT()
7921 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7922 } else {
7923 n += 2
7924 }
7925 return n
7926 }
7927 func (m *RateLimit_Action_RequestHeaders_) SizeVT() (n int) {
7928 if m == nil {
7929 return 0
7930 }
7931 var l int
7932 _ = l
7933 if m.RequestHeaders != nil {
7934 l = m.RequestHeaders.SizeVT()
7935 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7936 } else {
7937 n += 2
7938 }
7939 return n
7940 }
7941 func (m *RateLimit_Action_RemoteAddress_) SizeVT() (n int) {
7942 if m == nil {
7943 return 0
7944 }
7945 var l int
7946 _ = l
7947 if m.RemoteAddress != nil {
7948 l = m.RemoteAddress.SizeVT()
7949 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7950 } else {
7951 n += 2
7952 }
7953 return n
7954 }
7955 func (m *RateLimit_Action_GenericKey_) SizeVT() (n int) {
7956 if m == nil {
7957 return 0
7958 }
7959 var l int
7960 _ = l
7961 if m.GenericKey != nil {
7962 l = m.GenericKey.SizeVT()
7963 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7964 } else {
7965 n += 2
7966 }
7967 return n
7968 }
7969 func (m *RateLimit_Action_HeaderValueMatch_) SizeVT() (n int) {
7970 if m == nil {
7971 return 0
7972 }
7973 var l int
7974 _ = l
7975 if m.HeaderValueMatch != nil {
7976 l = m.HeaderValueMatch.SizeVT()
7977 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7978 } else {
7979 n += 2
7980 }
7981 return n
7982 }
7983 func (m *RateLimit_Action_DynamicMetadata) SizeVT() (n int) {
7984 if m == nil {
7985 return 0
7986 }
7987 var l int
7988 _ = l
7989 if m.DynamicMetadata != nil {
7990 l = m.DynamicMetadata.SizeVT()
7991 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
7992 } else {
7993 n += 2
7994 }
7995 return n
7996 }
7997 func (m *RateLimit_Action_Metadata) SizeVT() (n int) {
7998 if m == nil {
7999 return 0
8000 }
8001 var l int
8002 _ = l
8003 if m.Metadata != nil {
8004 l = m.Metadata.SizeVT()
8005 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8006 } else {
8007 n += 2
8008 }
8009 return n
8010 }
8011 func (m *RateLimit_Action_Extension) SizeVT() (n int) {
8012 if m == nil {
8013 return 0
8014 }
8015 var l int
8016 _ = l
8017 if m.Extension != nil {
8018 if size, ok := interface{}(m.Extension).(interface {
8019 SizeVT() int
8020 }); ok {
8021 l = size.SizeVT()
8022 } else {
8023 l = proto.Size(m.Extension)
8024 }
8025 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8026 } else {
8027 n += 2
8028 }
8029 return n
8030 }
8031 func (m *RateLimit_Action_MaskedRemoteAddress_) SizeVT() (n int) {
8032 if m == nil {
8033 return 0
8034 }
8035 var l int
8036 _ = l
8037 if m.MaskedRemoteAddress != nil {
8038 l = m.MaskedRemoteAddress.SizeVT()
8039 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8040 } else {
8041 n += 2
8042 }
8043 return n
8044 }
8045 func (m *RateLimit_Action_QueryParameterValueMatch_) SizeVT() (n int) {
8046 if m == nil {
8047 return 0
8048 }
8049 var l int
8050 _ = l
8051 if m.QueryParameterValueMatch != nil {
8052 l = m.QueryParameterValueMatch.SizeVT()
8053 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8054 } else {
8055 n += 2
8056 }
8057 return n
8058 }
8059 func (m *RateLimit_Override_DynamicMetadata) SizeVT() (n int) {
8060 if m == nil {
8061 return 0
8062 }
8063 var l int
8064 _ = l
8065 if m.MetadataKey != nil {
8066 if size, ok := interface{}(m.MetadataKey).(interface {
8067 SizeVT() int
8068 }); ok {
8069 l = size.SizeVT()
8070 } else {
8071 l = proto.Size(m.MetadataKey)
8072 }
8073 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8074 }
8075 n += len(m.unknownFields)
8076 return n
8077 }
8078
8079 func (m *RateLimit_Override) SizeVT() (n int) {
8080 if m == nil {
8081 return 0
8082 }
8083 var l int
8084 _ = l
8085 if vtmsg, ok := m.OverrideSpecifier.(interface{ SizeVT() int }); ok {
8086 n += vtmsg.SizeVT()
8087 }
8088 n += len(m.unknownFields)
8089 return n
8090 }
8091
8092 func (m *RateLimit_Override_DynamicMetadata_) SizeVT() (n int) {
8093 if m == nil {
8094 return 0
8095 }
8096 var l int
8097 _ = l
8098 if m.DynamicMetadata != nil {
8099 l = m.DynamicMetadata.SizeVT()
8100 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8101 } else {
8102 n += 2
8103 }
8104 return n
8105 }
8106 func (m *RateLimit_HitsAddend) SizeVT() (n int) {
8107 if m == nil {
8108 return 0
8109 }
8110 var l int
8111 _ = l
8112 if m.Number != nil {
8113 l = (*wrapperspb.UInt64Value)(m.Number).SizeVT()
8114 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8115 }
8116 l = len(m.Format)
8117 if l > 0 {
8118 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8119 }
8120 n += len(m.unknownFields)
8121 return n
8122 }
8123
8124 func (m *RateLimit) SizeVT() (n int) {
8125 if m == nil {
8126 return 0
8127 }
8128 var l int
8129 _ = l
8130 if m.Stage != nil {
8131 l = (*wrapperspb.UInt32Value)(m.Stage).SizeVT()
8132 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8133 }
8134 l = len(m.DisableKey)
8135 if l > 0 {
8136 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8137 }
8138 if len(m.Actions) > 0 {
8139 for _, e := range m.Actions {
8140 l = e.SizeVT()
8141 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8142 }
8143 }
8144 if m.Limit != nil {
8145 l = m.Limit.SizeVT()
8146 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8147 }
8148 if m.HitsAddend != nil {
8149 l = m.HitsAddend.SizeVT()
8150 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8151 }
8152 if m.ApplyOnStreamDone {
8153 n += 2
8154 }
8155 n += len(m.unknownFields)
8156 return n
8157 }
8158
8159 func (m *HeaderMatcher) SizeVT() (n int) {
8160 if m == nil {
8161 return 0
8162 }
8163 var l int
8164 _ = l
8165 l = len(m.Name)
8166 if l > 0 {
8167 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8168 }
8169 if vtmsg, ok := m.HeaderMatchSpecifier.(interface{ SizeVT() int }); ok {
8170 n += vtmsg.SizeVT()
8171 }
8172 if m.InvertMatch {
8173 n += 2
8174 }
8175 if m.TreatMissingHeaderAsEmpty {
8176 n += 2
8177 }
8178 n += len(m.unknownFields)
8179 return n
8180 }
8181
8182 func (m *HeaderMatcher_ExactMatch) SizeVT() (n int) {
8183 if m == nil {
8184 return 0
8185 }
8186 var l int
8187 _ = l
8188 l = len(m.ExactMatch)
8189 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8190 return n
8191 }
8192 func (m *HeaderMatcher_RangeMatch) SizeVT() (n int) {
8193 if m == nil {
8194 return 0
8195 }
8196 var l int
8197 _ = l
8198 if m.RangeMatch != nil {
8199 if size, ok := interface{}(m.RangeMatch).(interface {
8200 SizeVT() int
8201 }); ok {
8202 l = size.SizeVT()
8203 } else {
8204 l = proto.Size(m.RangeMatch)
8205 }
8206 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8207 } else {
8208 n += 2
8209 }
8210 return n
8211 }
8212 func (m *HeaderMatcher_PresentMatch) SizeVT() (n int) {
8213 if m == nil {
8214 return 0
8215 }
8216 var l int
8217 _ = l
8218 n += 2
8219 return n
8220 }
8221 func (m *HeaderMatcher_PrefixMatch) SizeVT() (n int) {
8222 if m == nil {
8223 return 0
8224 }
8225 var l int
8226 _ = l
8227 l = len(m.PrefixMatch)
8228 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8229 return n
8230 }
8231 func (m *HeaderMatcher_SuffixMatch) SizeVT() (n int) {
8232 if m == nil {
8233 return 0
8234 }
8235 var l int
8236 _ = l
8237 l = len(m.SuffixMatch)
8238 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8239 return n
8240 }
8241 func (m *HeaderMatcher_SafeRegexMatch) SizeVT() (n int) {
8242 if m == nil {
8243 return 0
8244 }
8245 var l int
8246 _ = l
8247 if m.SafeRegexMatch != nil {
8248 if size, ok := interface{}(m.SafeRegexMatch).(interface {
8249 SizeVT() int
8250 }); ok {
8251 l = size.SizeVT()
8252 } else {
8253 l = proto.Size(m.SafeRegexMatch)
8254 }
8255 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8256 } else {
8257 n += 2
8258 }
8259 return n
8260 }
8261 func (m *HeaderMatcher_ContainsMatch) SizeVT() (n int) {
8262 if m == nil {
8263 return 0
8264 }
8265 var l int
8266 _ = l
8267 l = len(m.ContainsMatch)
8268 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8269 return n
8270 }
8271 func (m *HeaderMatcher_StringMatch) SizeVT() (n int) {
8272 if m == nil {
8273 return 0
8274 }
8275 var l int
8276 _ = l
8277 if m.StringMatch != nil {
8278 if size, ok := interface{}(m.StringMatch).(interface {
8279 SizeVT() int
8280 }); ok {
8281 l = size.SizeVT()
8282 } else {
8283 l = proto.Size(m.StringMatch)
8284 }
8285 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8286 } else {
8287 n += 2
8288 }
8289 return n
8290 }
8291 func (m *QueryParameterMatcher) SizeVT() (n int) {
8292 if m == nil {
8293 return 0
8294 }
8295 var l int
8296 _ = l
8297 l = len(m.Name)
8298 if l > 0 {
8299 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8300 }
8301 if vtmsg, ok := m.QueryParameterMatchSpecifier.(interface{ SizeVT() int }); ok {
8302 n += vtmsg.SizeVT()
8303 }
8304 n += len(m.unknownFields)
8305 return n
8306 }
8307
8308 func (m *QueryParameterMatcher_StringMatch) SizeVT() (n int) {
8309 if m == nil {
8310 return 0
8311 }
8312 var l int
8313 _ = l
8314 if m.StringMatch != nil {
8315 if size, ok := interface{}(m.StringMatch).(interface {
8316 SizeVT() int
8317 }); ok {
8318 l = size.SizeVT()
8319 } else {
8320 l = proto.Size(m.StringMatch)
8321 }
8322 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8323 } else {
8324 n += 2
8325 }
8326 return n
8327 }
8328 func (m *QueryParameterMatcher_PresentMatch) SizeVT() (n int) {
8329 if m == nil {
8330 return 0
8331 }
8332 var l int
8333 _ = l
8334 n += 2
8335 return n
8336 }
8337 func (m *InternalRedirectPolicy) SizeVT() (n int) {
8338 if m == nil {
8339 return 0
8340 }
8341 var l int
8342 _ = l
8343 if m.MaxInternalRedirects != nil {
8344 l = (*wrapperspb.UInt32Value)(m.MaxInternalRedirects).SizeVT()
8345 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8346 }
8347 if len(m.RedirectResponseCodes) > 0 {
8348 l = 0
8349 for _, e := range m.RedirectResponseCodes {
8350 l += protohelpers.SizeOfVarint(uint64(e))
8351 }
8352 n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l
8353 }
8354 if len(m.Predicates) > 0 {
8355 for _, e := range m.Predicates {
8356 if size, ok := interface{}(e).(interface {
8357 SizeVT() int
8358 }); ok {
8359 l = size.SizeVT()
8360 } else {
8361 l = proto.Size(e)
8362 }
8363 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8364 }
8365 }
8366 if m.AllowCrossSchemeRedirect {
8367 n += 2
8368 }
8369 if len(m.ResponseHeadersToCopy) > 0 {
8370 for _, s := range m.ResponseHeadersToCopy {
8371 l = len(s)
8372 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8373 }
8374 }
8375 n += len(m.unknownFields)
8376 return n
8377 }
8378
8379 func (m *FilterConfig) SizeVT() (n int) {
8380 if m == nil {
8381 return 0
8382 }
8383 var l int
8384 _ = l
8385 if m.Config != nil {
8386 l = (*anypb.Any)(m.Config).SizeVT()
8387 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
8388 }
8389 if m.IsOptional {
8390 n += 2
8391 }
8392 if m.Disabled {
8393 n += 2
8394 }
8395 n += len(m.unknownFields)
8396 return n
8397 }