Debian Codegraph @

envoy/config/common/matcher/v3/matcher_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/common/matcher/v3/matcher.proto
6
7 package matcherv3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 proto "google.golang.org/protobuf/proto"
12 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
13 )
14
15 const (
16 // Verify that this generated code is sufficiently up-to-date.
17 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
18 // Verify that runtime/protoimpl is sufficiently up-to-date.
19 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
20 )
21
22 func (m *Matcher_OnMatch) MarshalVTStrict() (dAtA []byte, err error) {
23 if m == nil {
24 return nil, nil
25 }
26 size := m.SizeVT()
27 dAtA = make([]byte, size)
28 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
29 if err != nil {
30 return nil, err
31 }
32 return dAtA[:n], nil
33 }
34
35 func (m *Matcher_OnMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
36 size := m.SizeVT()
37 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
38 }
39
40 func (m *Matcher_OnMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
41 if m == nil {
42 return 0, nil
43 }
44 i := len(dAtA)
45 _ = i
46 var l int
47 _ = l
48 if m.unknownFields != nil {
49 i -= len(m.unknownFields)
50 copy(dAtA[i:], m.unknownFields)
51 }
52 if msg, ok := m.OnMatch.(*Matcher_OnMatch_Action); ok {
53 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
54 if err != nil {
55 return 0, err
56 }
57 i -= size
58 }
59 if msg, ok := m.OnMatch.(*Matcher_OnMatch_Matcher); ok {
60 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
61 if err != nil {
62 return 0, err
63 }
64 i -= size
65 }
66 return len(dAtA) - i, nil
67 }
68
69 func (m *Matcher_OnMatch_Matcher) MarshalToVTStrict(dAtA []byte) (int, error) {
70 size := m.SizeVT()
71 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
72 }
73
74 func (m *Matcher_OnMatch_Matcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
75 i := len(dAtA)
76 if m.Matcher != nil {
77 size, err := m.Matcher.MarshalToSizedBufferVTStrict(dAtA[:i])
78 if err != nil {
79 return 0, err
80 }
81 i -= size
82 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
83 i--
84 dAtA[i] = 0xa
85 } else {
86 i = protohelpers.EncodeVarint(dAtA, i, 0)
87 i--
88 dAtA[i] = 0xa
89 }
90 return len(dAtA) - i, nil
91 }
92 func (m *Matcher_OnMatch_Action) MarshalToVTStrict(dAtA []byte) (int, error) {
93 size := m.SizeVT()
94 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
95 }
96
97 func (m *Matcher_OnMatch_Action) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
98 i := len(dAtA)
99 if m.Action != nil {
100 if vtmsg, ok := interface{}(m.Action).(interface {
101 MarshalToSizedBufferVTStrict([]byte) (int, error)
102 }); ok {
103 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
104 if err != nil {
105 return 0, err
106 }
107 i -= size
108 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
109 } else {
110 encoded, err := proto.Marshal(m.Action)
111 if err != nil {
112 return 0, err
113 }
114 i -= len(encoded)
115 copy(dAtA[i:], encoded)
116 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
117 }
118 i--
119 dAtA[i] = 0x12
120 } else {
121 i = protohelpers.EncodeVarint(dAtA, i, 0)
122 i--
123 dAtA[i] = 0x12
124 }
125 return len(dAtA) - i, nil
126 }
127 func (m *Matcher_MatcherList_Predicate_SinglePredicate) MarshalVTStrict() (dAtA []byte, err error) {
128 if m == nil {
129 return nil, nil
130 }
131 size := m.SizeVT()
132 dAtA = make([]byte, size)
133 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
134 if err != nil {
135 return nil, err
136 }
137 return dAtA[:n], nil
138 }
139
140 func (m *Matcher_MatcherList_Predicate_SinglePredicate) MarshalToVTStrict(dAtA []byte) (int, error) {
141 size := m.SizeVT()
142 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
143 }
144
145 func (m *Matcher_MatcherList_Predicate_SinglePredicate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
146 if m == nil {
147 return 0, nil
148 }
149 i := len(dAtA)
150 _ = i
151 var l int
152 _ = l
153 if m.unknownFields != nil {
154 i -= len(m.unknownFields)
155 copy(dAtA[i:], m.unknownFields)
156 }
157 if msg, ok := m.Matcher.(*Matcher_MatcherList_Predicate_SinglePredicate_CustomMatch); ok {
158 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
159 if err != nil {
160 return 0, err
161 }
162 i -= size
163 }
164 if msg, ok := m.Matcher.(*Matcher_MatcherList_Predicate_SinglePredicate_ValueMatch); ok {
165 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
166 if err != nil {
167 return 0, err
168 }
169 i -= size
170 }
171 if m.Input != nil {
172 if vtmsg, ok := interface{}(m.Input).(interface {
173 MarshalToSizedBufferVTStrict([]byte) (int, error)
174 }); ok {
175 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
176 if err != nil {
177 return 0, err
178 }
179 i -= size
180 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
181 } else {
182 encoded, err := proto.Marshal(m.Input)
183 if err != nil {
184 return 0, err
185 }
186 i -= len(encoded)
187 copy(dAtA[i:], encoded)
188 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
189 }
190 i--
191 dAtA[i] = 0xa
192 }
193 return len(dAtA) - i, nil
194 }
195
196 func (m *Matcher_MatcherList_Predicate_SinglePredicate_ValueMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
197 size := m.SizeVT()
198 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
199 }
200
201 func (m *Matcher_MatcherList_Predicate_SinglePredicate_ValueMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
202 i := len(dAtA)
203 if m.ValueMatch != nil {
204 if vtmsg, ok := interface{}(m.ValueMatch).(interface {
205 MarshalToSizedBufferVTStrict([]byte) (int, error)
206 }); ok {
207 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
208 if err != nil {
209 return 0, err
210 }
211 i -= size
212 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
213 } else {
214 encoded, err := proto.Marshal(m.ValueMatch)
215 if err != nil {
216 return 0, err
217 }
218 i -= len(encoded)
219 copy(dAtA[i:], encoded)
220 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
221 }
222 i--
223 dAtA[i] = 0x12
224 } else {
225 i = protohelpers.EncodeVarint(dAtA, i, 0)
226 i--
227 dAtA[i] = 0x12
228 }
229 return len(dAtA) - i, nil
230 }
231 func (m *Matcher_MatcherList_Predicate_SinglePredicate_CustomMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
232 size := m.SizeVT()
233 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
234 }
235
236 func (m *Matcher_MatcherList_Predicate_SinglePredicate_CustomMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
237 i := len(dAtA)
238 if m.CustomMatch != nil {
239 if vtmsg, ok := interface{}(m.CustomMatch).(interface {
240 MarshalToSizedBufferVTStrict([]byte) (int, error)
241 }); ok {
242 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
243 if err != nil {
244 return 0, err
245 }
246 i -= size
247 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
248 } else {
249 encoded, err := proto.Marshal(m.CustomMatch)
250 if err != nil {
251 return 0, err
252 }
253 i -= len(encoded)
254 copy(dAtA[i:], encoded)
255 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
256 }
257 i--
258 dAtA[i] = 0x1a
259 } else {
260 i = protohelpers.EncodeVarint(dAtA, i, 0)
261 i--
262 dAtA[i] = 0x1a
263 }
264 return len(dAtA) - i, nil
265 }
266 func (m *Matcher_MatcherList_Predicate_PredicateList) MarshalVTStrict() (dAtA []byte, err error) {
267 if m == nil {
268 return nil, nil
269 }
270 size := m.SizeVT()
271 dAtA = make([]byte, size)
272 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
273 if err != nil {
274 return nil, err
275 }
276 return dAtA[:n], nil
277 }
278
279 func (m *Matcher_MatcherList_Predicate_PredicateList) MarshalToVTStrict(dAtA []byte) (int, error) {
280 size := m.SizeVT()
281 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
282 }
283
284 func (m *Matcher_MatcherList_Predicate_PredicateList) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
285 if m == nil {
286 return 0, nil
287 }
288 i := len(dAtA)
289 _ = i
290 var l int
291 _ = l
292 if m.unknownFields != nil {
293 i -= len(m.unknownFields)
294 copy(dAtA[i:], m.unknownFields)
295 }
296 if len(m.Predicate) > 0 {
297 for iNdEx := len(m.Predicate) - 1; iNdEx >= 0; iNdEx-- {
298 size, err := m.Predicate[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
299 if err != nil {
300 return 0, err
301 }
302 i -= size
303 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
304 i--
305 dAtA[i] = 0xa
306 }
307 }
308 return len(dAtA) - i, nil
309 }
310
311 func (m *Matcher_MatcherList_Predicate) MarshalVTStrict() (dAtA []byte, err error) {
312 if m == nil {
313 return nil, nil
314 }
315 size := m.SizeVT()
316 dAtA = make([]byte, size)
317 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
318 if err != nil {
319 return nil, err
320 }
321 return dAtA[:n], nil
322 }
323
324 func (m *Matcher_MatcherList_Predicate) MarshalToVTStrict(dAtA []byte) (int, error) {
325 size := m.SizeVT()
326 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
327 }
328
329 func (m *Matcher_MatcherList_Predicate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
330 if m == nil {
331 return 0, nil
332 }
333 i := len(dAtA)
334 _ = i
335 var l int
336 _ = l
337 if m.unknownFields != nil {
338 i -= len(m.unknownFields)
339 copy(dAtA[i:], m.unknownFields)
340 }
341 if msg, ok := m.MatchType.(*Matcher_MatcherList_Predicate_NotMatcher); ok {
342 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
343 if err != nil {
344 return 0, err
345 }
346 i -= size
347 }
348 if msg, ok := m.MatchType.(*Matcher_MatcherList_Predicate_AndMatcher); ok {
349 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
350 if err != nil {
351 return 0, err
352 }
353 i -= size
354 }
355 if msg, ok := m.MatchType.(*Matcher_MatcherList_Predicate_OrMatcher); ok {
356 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
357 if err != nil {
358 return 0, err
359 }
360 i -= size
361 }
362 if msg, ok := m.MatchType.(*Matcher_MatcherList_Predicate_SinglePredicate_); ok {
363 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
364 if err != nil {
365 return 0, err
366 }
367 i -= size
368 }
369 return len(dAtA) - i, nil
370 }
371
372 func (m *Matcher_MatcherList_Predicate_SinglePredicate_) MarshalToVTStrict(dAtA []byte) (int, error) {
373 size := m.SizeVT()
374 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
375 }
376
377 func (m *Matcher_MatcherList_Predicate_SinglePredicate_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
378 i := len(dAtA)
379 if m.SinglePredicate != nil {
380 size, err := m.SinglePredicate.MarshalToSizedBufferVTStrict(dAtA[:i])
381 if err != nil {
382 return 0, err
383 }
384 i -= size
385 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
386 i--
387 dAtA[i] = 0xa
388 } else {
389 i = protohelpers.EncodeVarint(dAtA, i, 0)
390 i--
391 dAtA[i] = 0xa
392 }
393 return len(dAtA) - i, nil
394 }
395 func (m *Matcher_MatcherList_Predicate_OrMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
396 size := m.SizeVT()
397 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
398 }
399
400 func (m *Matcher_MatcherList_Predicate_OrMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
401 i := len(dAtA)
402 if m.OrMatcher != nil {
403 size, err := m.OrMatcher.MarshalToSizedBufferVTStrict(dAtA[:i])
404 if err != nil {
405 return 0, err
406 }
407 i -= size
408 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
409 i--
410 dAtA[i] = 0x12
411 } else {
412 i = protohelpers.EncodeVarint(dAtA, i, 0)
413 i--
414 dAtA[i] = 0x12
415 }
416 return len(dAtA) - i, nil
417 }
418 func (m *Matcher_MatcherList_Predicate_AndMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
419 size := m.SizeVT()
420 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
421 }
422
423 func (m *Matcher_MatcherList_Predicate_AndMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
424 i := len(dAtA)
425 if m.AndMatcher != nil {
426 size, err := m.AndMatcher.MarshalToSizedBufferVTStrict(dAtA[:i])
427 if err != nil {
428 return 0, err
429 }
430 i -= size
431 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
432 i--
433 dAtA[i] = 0x1a
434 } else {
435 i = protohelpers.EncodeVarint(dAtA, i, 0)
436 i--
437 dAtA[i] = 0x1a
438 }
439 return len(dAtA) - i, nil
440 }
441 func (m *Matcher_MatcherList_Predicate_NotMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
442 size := m.SizeVT()
443 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
444 }
445
446 func (m *Matcher_MatcherList_Predicate_NotMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
447 i := len(dAtA)
448 if m.NotMatcher != nil {
449 size, err := m.NotMatcher.MarshalToSizedBufferVTStrict(dAtA[:i])
450 if err != nil {
451 return 0, err
452 }
453 i -= size
454 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
455 i--
456 dAtA[i] = 0x22
457 } else {
458 i = protohelpers.EncodeVarint(dAtA, i, 0)
459 i--
460 dAtA[i] = 0x22
461 }
462 return len(dAtA) - i, nil
463 }
464 func (m *Matcher_MatcherList_FieldMatcher) MarshalVTStrict() (dAtA []byte, err error) {
465 if m == nil {
466 return nil, nil
467 }
468 size := m.SizeVT()
469 dAtA = make([]byte, size)
470 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
471 if err != nil {
472 return nil, err
473 }
474 return dAtA[:n], nil
475 }
476
477 func (m *Matcher_MatcherList_FieldMatcher) MarshalToVTStrict(dAtA []byte) (int, error) {
478 size := m.SizeVT()
479 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
480 }
481
482 func (m *Matcher_MatcherList_FieldMatcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
483 if m == nil {
484 return 0, nil
485 }
486 i := len(dAtA)
487 _ = i
488 var l int
489 _ = l
490 if m.unknownFields != nil {
491 i -= len(m.unknownFields)
492 copy(dAtA[i:], m.unknownFields)
493 }
494 if m.OnMatch != nil {
495 size, err := m.OnMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
496 if err != nil {
497 return 0, err
498 }
499 i -= size
500 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
501 i--
502 dAtA[i] = 0x12
503 }
504 if m.Predicate != nil {
505 size, err := m.Predicate.MarshalToSizedBufferVTStrict(dAtA[:i])
506 if err != nil {
507 return 0, err
508 }
509 i -= size
510 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
511 i--
512 dAtA[i] = 0xa
513 }
514 return len(dAtA) - i, nil
515 }
516
517 func (m *Matcher_MatcherList) MarshalVTStrict() (dAtA []byte, err error) {
518 if m == nil {
519 return nil, nil
520 }
521 size := m.SizeVT()
522 dAtA = make([]byte, size)
523 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
524 if err != nil {
525 return nil, err
526 }
527 return dAtA[:n], nil
528 }
529
530 func (m *Matcher_MatcherList) MarshalToVTStrict(dAtA []byte) (int, error) {
531 size := m.SizeVT()
532 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
533 }
534
535 func (m *Matcher_MatcherList) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
536 if m == nil {
537 return 0, nil
538 }
539 i := len(dAtA)
540 _ = i
541 var l int
542 _ = l
543 if m.unknownFields != nil {
544 i -= len(m.unknownFields)
545 copy(dAtA[i:], m.unknownFields)
546 }
547 if len(m.Matchers) > 0 {
548 for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- {
549 size, err := m.Matchers[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
550 if err != nil {
551 return 0, err
552 }
553 i -= size
554 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
555 i--
556 dAtA[i] = 0xa
557 }
558 }
559 return len(dAtA) - i, nil
560 }
561
562 func (m *Matcher_MatcherTree_MatchMap) MarshalVTStrict() (dAtA []byte, err error) {
563 if m == nil {
564 return nil, nil
565 }
566 size := m.SizeVT()
567 dAtA = make([]byte, size)
568 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
569 if err != nil {
570 return nil, err
571 }
572 return dAtA[:n], nil
573 }
574
575 func (m *Matcher_MatcherTree_MatchMap) MarshalToVTStrict(dAtA []byte) (int, error) {
576 size := m.SizeVT()
577 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
578 }
579
580 func (m *Matcher_MatcherTree_MatchMap) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
581 if m == nil {
582 return 0, nil
583 }
584 i := len(dAtA)
585 _ = i
586 var l int
587 _ = l
588 if m.unknownFields != nil {
589 i -= len(m.unknownFields)
590 copy(dAtA[i:], m.unknownFields)
591 }
592 if len(m.Map) > 0 {
593 for k := range m.Map {
594 v := m.Map[k]
595 baseI := i
596 size, err := v.MarshalToSizedBufferVTStrict(dAtA[:i])
597 if err != nil {
598 return 0, err
599 }
600 i -= size
601 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
602 i--
603 dAtA[i] = 0x12
604 i -= len(k)
605 copy(dAtA[i:], k)
606 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
607 i--
608 dAtA[i] = 0xa
609 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
610 i--
611 dAtA[i] = 0xa
612 }
613 }
614 return len(dAtA) - i, nil
615 }
616
617 func (m *Matcher_MatcherTree) MarshalVTStrict() (dAtA []byte, err error) {
618 if m == nil {
619 return nil, nil
620 }
621 size := m.SizeVT()
622 dAtA = make([]byte, size)
623 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
624 if err != nil {
625 return nil, err
626 }
627 return dAtA[:n], nil
628 }
629
630 func (m *Matcher_MatcherTree) MarshalToVTStrict(dAtA []byte) (int, error) {
631 size := m.SizeVT()
632 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
633 }
634
635 func (m *Matcher_MatcherTree) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
636 if m == nil {
637 return 0, nil
638 }
639 i := len(dAtA)
640 _ = i
641 var l int
642 _ = l
643 if m.unknownFields != nil {
644 i -= len(m.unknownFields)
645 copy(dAtA[i:], m.unknownFields)
646 }
647 if msg, ok := m.TreeType.(*Matcher_MatcherTree_CustomMatch); ok {
648 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
649 if err != nil {
650 return 0, err
651 }
652 i -= size
653 }
654 if msg, ok := m.TreeType.(*Matcher_MatcherTree_PrefixMatchMap); 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.TreeType.(*Matcher_MatcherTree_ExactMatchMap); ok {
662 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
663 if err != nil {
664 return 0, err
665 }
666 i -= size
667 }
668 if m.Input != nil {
669 if vtmsg, ok := interface{}(m.Input).(interface {
670 MarshalToSizedBufferVTStrict([]byte) (int, error)
671 }); ok {
672 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
673 if err != nil {
674 return 0, err
675 }
676 i -= size
677 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
678 } else {
679 encoded, err := proto.Marshal(m.Input)
680 if err != nil {
681 return 0, err
682 }
683 i -= len(encoded)
684 copy(dAtA[i:], encoded)
685 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
686 }
687 i--
688 dAtA[i] = 0xa
689 }
690 return len(dAtA) - i, nil
691 }
692
693 func (m *Matcher_MatcherTree_ExactMatchMap) MarshalToVTStrict(dAtA []byte) (int, error) {
694 size := m.SizeVT()
695 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
696 }
697
698 func (m *Matcher_MatcherTree_ExactMatchMap) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
699 i := len(dAtA)
700 if m.ExactMatchMap != nil {
701 size, err := m.ExactMatchMap.MarshalToSizedBufferVTStrict(dAtA[:i])
702 if err != nil {
703 return 0, err
704 }
705 i -= size
706 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
707 i--
708 dAtA[i] = 0x12
709 } else {
710 i = protohelpers.EncodeVarint(dAtA, i, 0)
711 i--
712 dAtA[i] = 0x12
713 }
714 return len(dAtA) - i, nil
715 }
716 func (m *Matcher_MatcherTree_PrefixMatchMap) MarshalToVTStrict(dAtA []byte) (int, error) {
717 size := m.SizeVT()
718 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
719 }
720
721 func (m *Matcher_MatcherTree_PrefixMatchMap) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
722 i := len(dAtA)
723 if m.PrefixMatchMap != nil {
724 size, err := m.PrefixMatchMap.MarshalToSizedBufferVTStrict(dAtA[:i])
725 if err != nil {
726 return 0, err
727 }
728 i -= size
729 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
730 i--
731 dAtA[i] = 0x1a
732 } else {
733 i = protohelpers.EncodeVarint(dAtA, i, 0)
734 i--
735 dAtA[i] = 0x1a
736 }
737 return len(dAtA) - i, nil
738 }
739 func (m *Matcher_MatcherTree_CustomMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
740 size := m.SizeVT()
741 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
742 }
743
744 func (m *Matcher_MatcherTree_CustomMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
745 i := len(dAtA)
746 if m.CustomMatch != nil {
747 if vtmsg, ok := interface{}(m.CustomMatch).(interface {
748 MarshalToSizedBufferVTStrict([]byte) (int, error)
749 }); ok {
750 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
751 if err != nil {
752 return 0, err
753 }
754 i -= size
755 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
756 } else {
757 encoded, err := proto.Marshal(m.CustomMatch)
758 if err != nil {
759 return 0, err
760 }
761 i -= len(encoded)
762 copy(dAtA[i:], encoded)
763 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
764 }
765 i--
766 dAtA[i] = 0x22
767 } else {
768 i = protohelpers.EncodeVarint(dAtA, i, 0)
769 i--
770 dAtA[i] = 0x22
771 }
772 return len(dAtA) - i, nil
773 }
774 func (m *Matcher) MarshalVTStrict() (dAtA []byte, err error) {
775 if m == nil {
776 return nil, nil
777 }
778 size := m.SizeVT()
779 dAtA = make([]byte, size)
780 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
781 if err != nil {
782 return nil, err
783 }
784 return dAtA[:n], nil
785 }
786
787 func (m *Matcher) MarshalToVTStrict(dAtA []byte) (int, error) {
788 size := m.SizeVT()
789 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
790 }
791
792 func (m *Matcher) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
793 if m == nil {
794 return 0, nil
795 }
796 i := len(dAtA)
797 _ = i
798 var l int
799 _ = l
800 if m.unknownFields != nil {
801 i -= len(m.unknownFields)
802 copy(dAtA[i:], m.unknownFields)
803 }
804 if m.OnNoMatch != nil {
805 size, err := m.OnNoMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
806 if err != nil {
807 return 0, err
808 }
809 i -= size
810 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
811 i--
812 dAtA[i] = 0x1a
813 }
814 if msg, ok := m.MatcherType.(*Matcher_MatcherTree_); ok {
815 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
816 if err != nil {
817 return 0, err
818 }
819 i -= size
820 }
821 if msg, ok := m.MatcherType.(*Matcher_MatcherList_); ok {
822 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
823 if err != nil {
824 return 0, err
825 }
826 i -= size
827 }
828 return len(dAtA) - i, nil
829 }
830
831 func (m *Matcher_MatcherList_) MarshalToVTStrict(dAtA []byte) (int, error) {
832 size := m.SizeVT()
833 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
834 }
835
836 func (m *Matcher_MatcherList_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
837 i := len(dAtA)
838 if m.MatcherList != nil {
839 size, err := m.MatcherList.MarshalToSizedBufferVTStrict(dAtA[:i])
840 if err != nil {
841 return 0, err
842 }
843 i -= size
844 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
845 i--
846 dAtA[i] = 0xa
847 } else {
848 i = protohelpers.EncodeVarint(dAtA, i, 0)
849 i--
850 dAtA[i] = 0xa
851 }
852 return len(dAtA) - i, nil
853 }
854 func (m *Matcher_MatcherTree_) MarshalToVTStrict(dAtA []byte) (int, error) {
855 size := m.SizeVT()
856 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
857 }
858
859 func (m *Matcher_MatcherTree_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
860 i := len(dAtA)
861 if m.MatcherTree != nil {
862 size, err := m.MatcherTree.MarshalToSizedBufferVTStrict(dAtA[:i])
863 if err != nil {
864 return 0, err
865 }
866 i -= size
867 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
868 i--
869 dAtA[i] = 0x12
870 } else {
871 i = protohelpers.EncodeVarint(dAtA, i, 0)
872 i--
873 dAtA[i] = 0x12
874 }
875 return len(dAtA) - i, nil
876 }
877 func (m *MatchPredicate_MatchSet) MarshalVTStrict() (dAtA []byte, err error) {
878 if m == nil {
879 return nil, nil
880 }
881 size := m.SizeVT()
882 dAtA = make([]byte, size)
883 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
884 if err != nil {
885 return nil, err
886 }
887 return dAtA[:n], nil
888 }
889
890 func (m *MatchPredicate_MatchSet) MarshalToVTStrict(dAtA []byte) (int, error) {
891 size := m.SizeVT()
892 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
893 }
894
895 func (m *MatchPredicate_MatchSet) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
896 if m == nil {
897 return 0, nil
898 }
899 i := len(dAtA)
900 _ = i
901 var l int
902 _ = l
903 if m.unknownFields != nil {
904 i -= len(m.unknownFields)
905 copy(dAtA[i:], m.unknownFields)
906 }
907 if len(m.Rules) > 0 {
908 for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
909 size, err := m.Rules[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
910 if err != nil {
911 return 0, err
912 }
913 i -= size
914 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
915 i--
916 dAtA[i] = 0xa
917 }
918 }
919 return len(dAtA) - i, nil
920 }
921
922 func (m *MatchPredicate) MarshalVTStrict() (dAtA []byte, err error) {
923 if m == nil {
924 return nil, nil
925 }
926 size := m.SizeVT()
927 dAtA = make([]byte, size)
928 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
929 if err != nil {
930 return nil, err
931 }
932 return dAtA[:n], nil
933 }
934
935 func (m *MatchPredicate) MarshalToVTStrict(dAtA []byte) (int, error) {
936 size := m.SizeVT()
937 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
938 }
939
940 func (m *MatchPredicate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
941 if m == nil {
942 return 0, nil
943 }
944 i := len(dAtA)
945 _ = i
946 var l int
947 _ = l
948 if m.unknownFields != nil {
949 i -= len(m.unknownFields)
950 copy(dAtA[i:], m.unknownFields)
951 }
952 if msg, ok := m.Rule.(*MatchPredicate_HttpResponseGenericBodyMatch); ok {
953 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
954 if err != nil {
955 return 0, err
956 }
957 i -= size
958 }
959 if msg, ok := m.Rule.(*MatchPredicate_HttpRequestGenericBodyMatch); ok {
960 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
961 if err != nil {
962 return 0, err
963 }
964 i -= size
965 }
966 if msg, ok := m.Rule.(*MatchPredicate_HttpResponseTrailersMatch); ok {
967 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
968 if err != nil {
969 return 0, err
970 }
971 i -= size
972 }
973 if msg, ok := m.Rule.(*MatchPredicate_HttpResponseHeadersMatch); ok {
974 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
975 if err != nil {
976 return 0, err
977 }
978 i -= size
979 }
980 if msg, ok := m.Rule.(*MatchPredicate_HttpRequestTrailersMatch); ok {
981 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
982 if err != nil {
983 return 0, err
984 }
985 i -= size
986 }
987 if msg, ok := m.Rule.(*MatchPredicate_HttpRequestHeadersMatch); ok {
988 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
989 if err != nil {
990 return 0, err
991 }
992 i -= size
993 }
994 if msg, ok := m.Rule.(*MatchPredicate_AnyMatch); ok {
995 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
996 if err != nil {
997 return 0, err
998 }
999 i -= size
1000 }
1001 if msg, ok := m.Rule.(*MatchPredicate_NotMatch); ok {
1002 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1003 if err != nil {
1004 return 0, err
1005 }
1006 i -= size
1007 }
1008 if msg, ok := m.Rule.(*MatchPredicate_AndMatch); ok {
1009 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1010 if err != nil {
1011 return 0, err
1012 }
1013 i -= size
1014 }
1015 if msg, ok := m.Rule.(*MatchPredicate_OrMatch); ok {
1016 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1017 if err != nil {
1018 return 0, err
1019 }
1020 i -= size
1021 }
1022 return len(dAtA) - i, nil
1023 }
1024
1025 func (m *MatchPredicate_OrMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1026 size := m.SizeVT()
1027 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1028 }
1029
1030 func (m *MatchPredicate_OrMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1031 i := len(dAtA)
1032 if m.OrMatch != nil {
1033 size, err := m.OrMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1034 if err != nil {
1035 return 0, err
1036 }
1037 i -= size
1038 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1039 i--
1040 dAtA[i] = 0xa
1041 } else {
1042 i = protohelpers.EncodeVarint(dAtA, i, 0)
1043 i--
1044 dAtA[i] = 0xa
1045 }
1046 return len(dAtA) - i, nil
1047 }
1048 func (m *MatchPredicate_AndMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1049 size := m.SizeVT()
1050 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1051 }
1052
1053 func (m *MatchPredicate_AndMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1054 i := len(dAtA)
1055 if m.AndMatch != nil {
1056 size, err := m.AndMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1057 if err != nil {
1058 return 0, err
1059 }
1060 i -= size
1061 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1062 i--
1063 dAtA[i] = 0x12
1064 } else {
1065 i = protohelpers.EncodeVarint(dAtA, i, 0)
1066 i--
1067 dAtA[i] = 0x12
1068 }
1069 return len(dAtA) - i, nil
1070 }
1071 func (m *MatchPredicate_NotMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1072 size := m.SizeVT()
1073 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1074 }
1075
1076 func (m *MatchPredicate_NotMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1077 i := len(dAtA)
1078 if m.NotMatch != nil {
1079 size, err := m.NotMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1080 if err != nil {
1081 return 0, err
1082 }
1083 i -= size
1084 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1085 i--
1086 dAtA[i] = 0x1a
1087 } else {
1088 i = protohelpers.EncodeVarint(dAtA, i, 0)
1089 i--
1090 dAtA[i] = 0x1a
1091 }
1092 return len(dAtA) - i, nil
1093 }
1094 func (m *MatchPredicate_AnyMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1095 size := m.SizeVT()
1096 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1097 }
1098
1099 func (m *MatchPredicate_AnyMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1100 i := len(dAtA)
1101 i--
1102 if m.AnyMatch {
1103 dAtA[i] = 1
1104 } else {
1105 dAtA[i] = 0
1106 }
1107 i--
1108 dAtA[i] = 0x20
1109 return len(dAtA) - i, nil
1110 }
1111 func (m *MatchPredicate_HttpRequestHeadersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1112 size := m.SizeVT()
1113 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1114 }
1115
1116 func (m *MatchPredicate_HttpRequestHeadersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1117 i := len(dAtA)
1118 if m.HttpRequestHeadersMatch != nil {
1119 size, err := m.HttpRequestHeadersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1120 if err != nil {
1121 return 0, err
1122 }
1123 i -= size
1124 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1125 i--
1126 dAtA[i] = 0x2a
1127 } else {
1128 i = protohelpers.EncodeVarint(dAtA, i, 0)
1129 i--
1130 dAtA[i] = 0x2a
1131 }
1132 return len(dAtA) - i, nil
1133 }
1134 func (m *MatchPredicate_HttpRequestTrailersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1135 size := m.SizeVT()
1136 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1137 }
1138
1139 func (m *MatchPredicate_HttpRequestTrailersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1140 i := len(dAtA)
1141 if m.HttpRequestTrailersMatch != nil {
1142 size, err := m.HttpRequestTrailersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1143 if err != nil {
1144 return 0, err
1145 }
1146 i -= size
1147 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1148 i--
1149 dAtA[i] = 0x32
1150 } else {
1151 i = protohelpers.EncodeVarint(dAtA, i, 0)
1152 i--
1153 dAtA[i] = 0x32
1154 }
1155 return len(dAtA) - i, nil
1156 }
1157 func (m *MatchPredicate_HttpResponseHeadersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1158 size := m.SizeVT()
1159 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1160 }
1161
1162 func (m *MatchPredicate_HttpResponseHeadersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1163 i := len(dAtA)
1164 if m.HttpResponseHeadersMatch != nil {
1165 size, err := m.HttpResponseHeadersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1166 if err != nil {
1167 return 0, err
1168 }
1169 i -= size
1170 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1171 i--
1172 dAtA[i] = 0x3a
1173 } else {
1174 i = protohelpers.EncodeVarint(dAtA, i, 0)
1175 i--
1176 dAtA[i] = 0x3a
1177 }
1178 return len(dAtA) - i, nil
1179 }
1180 func (m *MatchPredicate_HttpResponseTrailersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1181 size := m.SizeVT()
1182 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1183 }
1184
1185 func (m *MatchPredicate_HttpResponseTrailersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1186 i := len(dAtA)
1187 if m.HttpResponseTrailersMatch != nil {
1188 size, err := m.HttpResponseTrailersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1189 if err != nil {
1190 return 0, err
1191 }
1192 i -= size
1193 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1194 i--
1195 dAtA[i] = 0x42
1196 } else {
1197 i = protohelpers.EncodeVarint(dAtA, i, 0)
1198 i--
1199 dAtA[i] = 0x42
1200 }
1201 return len(dAtA) - i, nil
1202 }
1203 func (m *MatchPredicate_HttpRequestGenericBodyMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1204 size := m.SizeVT()
1205 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1206 }
1207
1208 func (m *MatchPredicate_HttpRequestGenericBodyMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1209 i := len(dAtA)
1210 if m.HttpRequestGenericBodyMatch != nil {
1211 size, err := m.HttpRequestGenericBodyMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1212 if err != nil {
1213 return 0, err
1214 }
1215 i -= size
1216 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1217 i--
1218 dAtA[i] = 0x4a
1219 } else {
1220 i = protohelpers.EncodeVarint(dAtA, i, 0)
1221 i--
1222 dAtA[i] = 0x4a
1223 }
1224 return len(dAtA) - i, nil
1225 }
1226 func (m *MatchPredicate_HttpResponseGenericBodyMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1227 size := m.SizeVT()
1228 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1229 }
1230
1231 func (m *MatchPredicate_HttpResponseGenericBodyMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1232 i := len(dAtA)
1233 if m.HttpResponseGenericBodyMatch != nil {
1234 size, err := m.HttpResponseGenericBodyMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
1235 if err != nil {
1236 return 0, err
1237 }
1238 i -= size
1239 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1240 i--
1241 dAtA[i] = 0x52
1242 } else {
1243 i = protohelpers.EncodeVarint(dAtA, i, 0)
1244 i--
1245 dAtA[i] = 0x52
1246 }
1247 return len(dAtA) - i, nil
1248 }
1249 func (m *HttpHeadersMatch) MarshalVTStrict() (dAtA []byte, err error) {
1250 if m == nil {
1251 return nil, nil
1252 }
1253 size := m.SizeVT()
1254 dAtA = make([]byte, size)
1255 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1256 if err != nil {
1257 return nil, err
1258 }
1259 return dAtA[:n], nil
1260 }
1261
1262 func (m *HttpHeadersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1263 size := m.SizeVT()
1264 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1265 }
1266
1267 func (m *HttpHeadersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1268 if m == nil {
1269 return 0, nil
1270 }
1271 i := len(dAtA)
1272 _ = i
1273 var l int
1274 _ = l
1275 if m.unknownFields != nil {
1276 i -= len(m.unknownFields)
1277 copy(dAtA[i:], m.unknownFields)
1278 }
1279 if len(m.Headers) > 0 {
1280 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
1281 if vtmsg, ok := interface{}(m.Headers[iNdEx]).(interface {
1282 MarshalToSizedBufferVTStrict([]byte) (int, error)
1283 }); ok {
1284 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
1285 if err != nil {
1286 return 0, err
1287 }
1288 i -= size
1289 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1290 } else {
1291 encoded, err := proto.Marshal(m.Headers[iNdEx])
1292 if err != nil {
1293 return 0, err
1294 }
1295 i -= len(encoded)
1296 copy(dAtA[i:], encoded)
1297 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
1298 }
1299 i--
1300 dAtA[i] = 0xa
1301 }
1302 }
1303 return len(dAtA) - i, nil
1304 }
1305
1306 func (m *HttpGenericBodyMatch_GenericTextMatch) MarshalVTStrict() (dAtA []byte, err error) {
1307 if m == nil {
1308 return nil, nil
1309 }
1310 size := m.SizeVT()
1311 dAtA = make([]byte, size)
1312 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1313 if err != nil {
1314 return nil, err
1315 }
1316 return dAtA[:n], nil
1317 }
1318
1319 func (m *HttpGenericBodyMatch_GenericTextMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1320 size := m.SizeVT()
1321 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1322 }
1323
1324 func (m *HttpGenericBodyMatch_GenericTextMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1325 if m == nil {
1326 return 0, nil
1327 }
1328 i := len(dAtA)
1329 _ = i
1330 var l int
1331 _ = l
1332 if m.unknownFields != nil {
1333 i -= len(m.unknownFields)
1334 copy(dAtA[i:], m.unknownFields)
1335 }
1336 if msg, ok := m.Rule.(*HttpGenericBodyMatch_GenericTextMatch_BinaryMatch); ok {
1337 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1338 if err != nil {
1339 return 0, err
1340 }
1341 i -= size
1342 }
1343 if msg, ok := m.Rule.(*HttpGenericBodyMatch_GenericTextMatch_StringMatch); ok {
1344 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
1345 if err != nil {
1346 return 0, err
1347 }
1348 i -= size
1349 }
1350 return len(dAtA) - i, nil
1351 }
1352
1353 func (m *HttpGenericBodyMatch_GenericTextMatch_StringMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1354 size := m.SizeVT()
1355 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1356 }
1357
1358 func (m *HttpGenericBodyMatch_GenericTextMatch_StringMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1359 i := len(dAtA)
1360 i -= len(m.StringMatch)
1361 copy(dAtA[i:], m.StringMatch)
1362 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StringMatch)))
1363 i--
1364 dAtA[i] = 0xa
1365 return len(dAtA) - i, nil
1366 }
1367 func (m *HttpGenericBodyMatch_GenericTextMatch_BinaryMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1368 size := m.SizeVT()
1369 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1370 }
1371
1372 func (m *HttpGenericBodyMatch_GenericTextMatch_BinaryMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1373 i := len(dAtA)
1374 i -= len(m.BinaryMatch)
1375 copy(dAtA[i:], m.BinaryMatch)
1376 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BinaryMatch)))
1377 i--
1378 dAtA[i] = 0x12
1379 return len(dAtA) - i, nil
1380 }
1381 func (m *HttpGenericBodyMatch) MarshalVTStrict() (dAtA []byte, err error) {
1382 if m == nil {
1383 return nil, nil
1384 }
1385 size := m.SizeVT()
1386 dAtA = make([]byte, size)
1387 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
1388 if err != nil {
1389 return nil, err
1390 }
1391 return dAtA[:n], nil
1392 }
1393
1394 func (m *HttpGenericBodyMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
1395 size := m.SizeVT()
1396 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
1397 }
1398
1399 func (m *HttpGenericBodyMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
1400 if m == nil {
1401 return 0, nil
1402 }
1403 i := len(dAtA)
1404 _ = i
1405 var l int
1406 _ = l
1407 if m.unknownFields != nil {
1408 i -= len(m.unknownFields)
1409 copy(dAtA[i:], m.unknownFields)
1410 }
1411 if len(m.Patterns) > 0 {
1412 for iNdEx := len(m.Patterns) - 1; iNdEx >= 0; iNdEx-- {
1413 size, err := m.Patterns[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
1414 if err != nil {
1415 return 0, err
1416 }
1417 i -= size
1418 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1419 i--
1420 dAtA[i] = 0x12
1421 }
1422 }
1423 if m.BytesLimit != 0 {
1424 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BytesLimit))
1425 i--
1426 dAtA[i] = 0x8
1427 }
1428 return len(dAtA) - i, nil
1429 }
1430
1431 func (m *Matcher_OnMatch) SizeVT() (n int) {
1432 if m == nil {
1433 return 0
1434 }
1435 var l int
1436 _ = l
1437 if vtmsg, ok := m.OnMatch.(interface{ SizeVT() int }); ok {
1438 n += vtmsg.SizeVT()
1439 }
1440 n += len(m.unknownFields)
1441 return n
1442 }
1443
1444 func (m *Matcher_OnMatch_Matcher) SizeVT() (n int) {
1445 if m == nil {
1446 return 0
1447 }
1448 var l int
1449 _ = l
1450 if m.Matcher != nil {
1451 l = m.Matcher.SizeVT()
1452 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1453 } else {
1454 n += 2
1455 }
1456 return n
1457 }
1458 func (m *Matcher_OnMatch_Action) SizeVT() (n int) {
1459 if m == nil {
1460 return 0
1461 }
1462 var l int
1463 _ = l
1464 if m.Action != nil {
1465 if size, ok := interface{}(m.Action).(interface {
1466 SizeVT() int
1467 }); ok {
1468 l = size.SizeVT()
1469 } else {
1470 l = proto.Size(m.Action)
1471 }
1472 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1473 } else {
1474 n += 2
1475 }
1476 return n
1477 }
1478 func (m *Matcher_MatcherList_Predicate_SinglePredicate) SizeVT() (n int) {
1479 if m == nil {
1480 return 0
1481 }
1482 var l int
1483 _ = l
1484 if m.Input != nil {
1485 if size, ok := interface{}(m.Input).(interface {
1486 SizeVT() int
1487 }); ok {
1488 l = size.SizeVT()
1489 } else {
1490 l = proto.Size(m.Input)
1491 }
1492 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1493 }
1494 if vtmsg, ok := m.Matcher.(interface{ SizeVT() int }); ok {
1495 n += vtmsg.SizeVT()
1496 }
1497 n += len(m.unknownFields)
1498 return n
1499 }
1500
1501 func (m *Matcher_MatcherList_Predicate_SinglePredicate_ValueMatch) SizeVT() (n int) {
1502 if m == nil {
1503 return 0
1504 }
1505 var l int
1506 _ = l
1507 if m.ValueMatch != nil {
1508 if size, ok := interface{}(m.ValueMatch).(interface {
1509 SizeVT() int
1510 }); ok {
1511 l = size.SizeVT()
1512 } else {
1513 l = proto.Size(m.ValueMatch)
1514 }
1515 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1516 } else {
1517 n += 2
1518 }
1519 return n
1520 }
1521 func (m *Matcher_MatcherList_Predicate_SinglePredicate_CustomMatch) SizeVT() (n int) {
1522 if m == nil {
1523 return 0
1524 }
1525 var l int
1526 _ = l
1527 if m.CustomMatch != nil {
1528 if size, ok := interface{}(m.CustomMatch).(interface {
1529 SizeVT() int
1530 }); ok {
1531 l = size.SizeVT()
1532 } else {
1533 l = proto.Size(m.CustomMatch)
1534 }
1535 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1536 } else {
1537 n += 2
1538 }
1539 return n
1540 }
1541 func (m *Matcher_MatcherList_Predicate_PredicateList) SizeVT() (n int) {
1542 if m == nil {
1543 return 0
1544 }
1545 var l int
1546 _ = l
1547 if len(m.Predicate) > 0 {
1548 for _, e := range m.Predicate {
1549 l = e.SizeVT()
1550 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1551 }
1552 }
1553 n += len(m.unknownFields)
1554 return n
1555 }
1556
1557 func (m *Matcher_MatcherList_Predicate) SizeVT() (n int) {
1558 if m == nil {
1559 return 0
1560 }
1561 var l int
1562 _ = l
1563 if vtmsg, ok := m.MatchType.(interface{ SizeVT() int }); ok {
1564 n += vtmsg.SizeVT()
1565 }
1566 n += len(m.unknownFields)
1567 return n
1568 }
1569
1570 func (m *Matcher_MatcherList_Predicate_SinglePredicate_) SizeVT() (n int) {
1571 if m == nil {
1572 return 0
1573 }
1574 var l int
1575 _ = l
1576 if m.SinglePredicate != nil {
1577 l = m.SinglePredicate.SizeVT()
1578 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1579 } else {
1580 n += 2
1581 }
1582 return n
1583 }
1584 func (m *Matcher_MatcherList_Predicate_OrMatcher) SizeVT() (n int) {
1585 if m == nil {
1586 return 0
1587 }
1588 var l int
1589 _ = l
1590 if m.OrMatcher != nil {
1591 l = m.OrMatcher.SizeVT()
1592 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1593 } else {
1594 n += 2
1595 }
1596 return n
1597 }
1598 func (m *Matcher_MatcherList_Predicate_AndMatcher) SizeVT() (n int) {
1599 if m == nil {
1600 return 0
1601 }
1602 var l int
1603 _ = l
1604 if m.AndMatcher != nil {
1605 l = m.AndMatcher.SizeVT()
1606 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1607 } else {
1608 n += 2
1609 }
1610 return n
1611 }
1612 func (m *Matcher_MatcherList_Predicate_NotMatcher) SizeVT() (n int) {
1613 if m == nil {
1614 return 0
1615 }
1616 var l int
1617 _ = l
1618 if m.NotMatcher != nil {
1619 l = m.NotMatcher.SizeVT()
1620 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1621 } else {
1622 n += 2
1623 }
1624 return n
1625 }
1626 func (m *Matcher_MatcherList_FieldMatcher) SizeVT() (n int) {
1627 if m == nil {
1628 return 0
1629 }
1630 var l int
1631 _ = l
1632 if m.Predicate != nil {
1633 l = m.Predicate.SizeVT()
1634 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1635 }
1636 if m.OnMatch != nil {
1637 l = m.OnMatch.SizeVT()
1638 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1639 }
1640 n += len(m.unknownFields)
1641 return n
1642 }
1643
1644 func (m *Matcher_MatcherList) SizeVT() (n int) {
1645 if m == nil {
1646 return 0
1647 }
1648 var l int
1649 _ = l
1650 if len(m.Matchers) > 0 {
1651 for _, e := range m.Matchers {
1652 l = e.SizeVT()
1653 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1654 }
1655 }
1656 n += len(m.unknownFields)
1657 return n
1658 }
1659
1660 func (m *Matcher_MatcherTree_MatchMap) SizeVT() (n int) {
1661 if m == nil {
1662 return 0
1663 }
1664 var l int
1665 _ = l
1666 if len(m.Map) > 0 {
1667 for k, v := range m.Map {
1668 _ = k
1669 _ = v
1670 l = 0
1671 if v != nil {
1672 l = v.SizeVT()
1673 }
1674 l += 1 + protohelpers.SizeOfVarint(uint64(l))
1675 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
1676 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
1677 }
1678 }
1679 n += len(m.unknownFields)
1680 return n
1681 }
1682
1683 func (m *Matcher_MatcherTree) SizeVT() (n int) {
1684 if m == nil {
1685 return 0
1686 }
1687 var l int
1688 _ = l
1689 if m.Input != nil {
1690 if size, ok := interface{}(m.Input).(interface {
1691 SizeVT() int
1692 }); ok {
1693 l = size.SizeVT()
1694 } else {
1695 l = proto.Size(m.Input)
1696 }
1697 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1698 }
1699 if vtmsg, ok := m.TreeType.(interface{ SizeVT() int }); ok {
1700 n += vtmsg.SizeVT()
1701 }
1702 n += len(m.unknownFields)
1703 return n
1704 }
1705
1706 func (m *Matcher_MatcherTree_ExactMatchMap) SizeVT() (n int) {
1707 if m == nil {
1708 return 0
1709 }
1710 var l int
1711 _ = l
1712 if m.ExactMatchMap != nil {
1713 l = m.ExactMatchMap.SizeVT()
1714 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1715 } else {
1716 n += 2
1717 }
1718 return n
1719 }
1720 func (m *Matcher_MatcherTree_PrefixMatchMap) SizeVT() (n int) {
1721 if m == nil {
1722 return 0
1723 }
1724 var l int
1725 _ = l
1726 if m.PrefixMatchMap != nil {
1727 l = m.PrefixMatchMap.SizeVT()
1728 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1729 } else {
1730 n += 2
1731 }
1732 return n
1733 }
1734 func (m *Matcher_MatcherTree_CustomMatch) SizeVT() (n int) {
1735 if m == nil {
1736 return 0
1737 }
1738 var l int
1739 _ = l
1740 if m.CustomMatch != nil {
1741 if size, ok := interface{}(m.CustomMatch).(interface {
1742 SizeVT() int
1743 }); ok {
1744 l = size.SizeVT()
1745 } else {
1746 l = proto.Size(m.CustomMatch)
1747 }
1748 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1749 } else {
1750 n += 2
1751 }
1752 return n
1753 }
1754 func (m *Matcher) SizeVT() (n int) {
1755 if m == nil {
1756 return 0
1757 }
1758 var l int
1759 _ = l
1760 if vtmsg, ok := m.MatcherType.(interface{ SizeVT() int }); ok {
1761 n += vtmsg.SizeVT()
1762 }
1763 if m.OnNoMatch != nil {
1764 l = m.OnNoMatch.SizeVT()
1765 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1766 }
1767 n += len(m.unknownFields)
1768 return n
1769 }
1770
1771 func (m *Matcher_MatcherList_) SizeVT() (n int) {
1772 if m == nil {
1773 return 0
1774 }
1775 var l int
1776 _ = l
1777 if m.MatcherList != nil {
1778 l = m.MatcherList.SizeVT()
1779 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1780 } else {
1781 n += 2
1782 }
1783 return n
1784 }
1785 func (m *Matcher_MatcherTree_) SizeVT() (n int) {
1786 if m == nil {
1787 return 0
1788 }
1789 var l int
1790 _ = l
1791 if m.MatcherTree != nil {
1792 l = m.MatcherTree.SizeVT()
1793 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1794 } else {
1795 n += 2
1796 }
1797 return n
1798 }
1799 func (m *MatchPredicate_MatchSet) SizeVT() (n int) {
1800 if m == nil {
1801 return 0
1802 }
1803 var l int
1804 _ = l
1805 if len(m.Rules) > 0 {
1806 for _, e := range m.Rules {
1807 l = e.SizeVT()
1808 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1809 }
1810 }
1811 n += len(m.unknownFields)
1812 return n
1813 }
1814
1815 func (m *MatchPredicate) SizeVT() (n int) {
1816 if m == nil {
1817 return 0
1818 }
1819 var l int
1820 _ = l
1821 if vtmsg, ok := m.Rule.(interface{ SizeVT() int }); ok {
1822 n += vtmsg.SizeVT()
1823 }
1824 n += len(m.unknownFields)
1825 return n
1826 }
1827
1828 func (m *MatchPredicate_OrMatch) SizeVT() (n int) {
1829 if m == nil {
1830 return 0
1831 }
1832 var l int
1833 _ = l
1834 if m.OrMatch != nil {
1835 l = m.OrMatch.SizeVT()
1836 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1837 } else {
1838 n += 2
1839 }
1840 return n
1841 }
1842 func (m *MatchPredicate_AndMatch) SizeVT() (n int) {
1843 if m == nil {
1844 return 0
1845 }
1846 var l int
1847 _ = l
1848 if m.AndMatch != nil {
1849 l = m.AndMatch.SizeVT()
1850 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1851 } else {
1852 n += 2
1853 }
1854 return n
1855 }
1856 func (m *MatchPredicate_NotMatch) SizeVT() (n int) {
1857 if m == nil {
1858 return 0
1859 }
1860 var l int
1861 _ = l
1862 if m.NotMatch != nil {
1863 l = m.NotMatch.SizeVT()
1864 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1865 } else {
1866 n += 2
1867 }
1868 return n
1869 }
1870 func (m *MatchPredicate_AnyMatch) SizeVT() (n int) {
1871 if m == nil {
1872 return 0
1873 }
1874 var l int
1875 _ = l
1876 n += 2
1877 return n
1878 }
1879 func (m *MatchPredicate_HttpRequestHeadersMatch) SizeVT() (n int) {
1880 if m == nil {
1881 return 0
1882 }
1883 var l int
1884 _ = l
1885 if m.HttpRequestHeadersMatch != nil {
1886 l = m.HttpRequestHeadersMatch.SizeVT()
1887 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1888 } else {
1889 n += 2
1890 }
1891 return n
1892 }
1893 func (m *MatchPredicate_HttpRequestTrailersMatch) SizeVT() (n int) {
1894 if m == nil {
1895 return 0
1896 }
1897 var l int
1898 _ = l
1899 if m.HttpRequestTrailersMatch != nil {
1900 l = m.HttpRequestTrailersMatch.SizeVT()
1901 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1902 } else {
1903 n += 2
1904 }
1905 return n
1906 }
1907 func (m *MatchPredicate_HttpResponseHeadersMatch) SizeVT() (n int) {
1908 if m == nil {
1909 return 0
1910 }
1911 var l int
1912 _ = l
1913 if m.HttpResponseHeadersMatch != nil {
1914 l = m.HttpResponseHeadersMatch.SizeVT()
1915 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1916 } else {
1917 n += 2
1918 }
1919 return n
1920 }
1921 func (m *MatchPredicate_HttpResponseTrailersMatch) SizeVT() (n int) {
1922 if m == nil {
1923 return 0
1924 }
1925 var l int
1926 _ = l
1927 if m.HttpResponseTrailersMatch != nil {
1928 l = m.HttpResponseTrailersMatch.SizeVT()
1929 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1930 } else {
1931 n += 2
1932 }
1933 return n
1934 }
1935 func (m *MatchPredicate_HttpRequestGenericBodyMatch) SizeVT() (n int) {
1936 if m == nil {
1937 return 0
1938 }
1939 var l int
1940 _ = l
1941 if m.HttpRequestGenericBodyMatch != nil {
1942 l = m.HttpRequestGenericBodyMatch.SizeVT()
1943 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1944 } else {
1945 n += 2
1946 }
1947 return n
1948 }
1949 func (m *MatchPredicate_HttpResponseGenericBodyMatch) SizeVT() (n int) {
1950 if m == nil {
1951 return 0
1952 }
1953 var l int
1954 _ = l
1955 if m.HttpResponseGenericBodyMatch != nil {
1956 l = m.HttpResponseGenericBodyMatch.SizeVT()
1957 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1958 } else {
1959 n += 2
1960 }
1961 return n
1962 }
1963 func (m *HttpHeadersMatch) SizeVT() (n int) {
1964 if m == nil {
1965 return 0
1966 }
1967 var l int
1968 _ = l
1969 if len(m.Headers) > 0 {
1970 for _, e := range m.Headers {
1971 if size, ok := interface{}(e).(interface {
1972 SizeVT() int
1973 }); ok {
1974 l = size.SizeVT()
1975 } else {
1976 l = proto.Size(e)
1977 }
1978 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1979 }
1980 }
1981 n += len(m.unknownFields)
1982 return n
1983 }
1984
1985 func (m *HttpGenericBodyMatch_GenericTextMatch) SizeVT() (n int) {
1986 if m == nil {
1987 return 0
1988 }
1989 var l int
1990 _ = l
1991 if vtmsg, ok := m.Rule.(interface{ SizeVT() int }); ok {
1992 n += vtmsg.SizeVT()
1993 }
1994 n += len(m.unknownFields)
1995 return n
1996 }
1997
1998 func (m *HttpGenericBodyMatch_GenericTextMatch_StringMatch) SizeVT() (n int) {
1999 if m == nil {
2000 return 0
2001 }
2002 var l int
2003 _ = l
2004 l = len(m.StringMatch)
2005 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2006 return n
2007 }
2008 func (m *HttpGenericBodyMatch_GenericTextMatch_BinaryMatch) SizeVT() (n int) {
2009 if m == nil {
2010 return 0
2011 }
2012 var l int
2013 _ = l
2014 l = len(m.BinaryMatch)
2015 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2016 return n
2017 }
2018 func (m *HttpGenericBodyMatch) SizeVT() (n int) {
2019 if m == nil {
2020 return 0
2021 }
2022 var l int
2023 _ = l
2024 if m.BytesLimit != 0 {
2025 n += 1 + protohelpers.SizeOfVarint(uint64(m.BytesLimit))
2026 }
2027 if len(m.Patterns) > 0 {
2028 for _, e := range m.Patterns {
2029 l = e.SizeVT()
2030 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2031 }
2032 }
2033 n += len(m.unknownFields)
2034 return n
2035 }