Debian Codegraph @

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