Debian Codegraph @

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