Debian Codegraph @

envoy/service/tap/v2alpha/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/service/tap/v2alpha/common.proto
6
7 package v2alpha
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb"
12 proto "google.golang.org/protobuf/proto"
13 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
14 )
15
16 const (
17 // Verify that this generated code is sufficiently up-to-date.
18 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
19 // Verify that runtime/protoimpl is sufficiently up-to-date.
20 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
21 )
22
23 func (m *TapConfig) MarshalVTStrict() (dAtA []byte, err error) {
24 if m == nil {
25 return nil, nil
26 }
27 size := m.SizeVT()
28 dAtA = make([]byte, size)
29 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
30 if err != nil {
31 return nil, err
32 }
33 return dAtA[:n], nil
34 }
35
36 func (m *TapConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
37 size := m.SizeVT()
38 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
39 }
40
41 func (m *TapConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
42 if m == nil {
43 return 0, nil
44 }
45 i := len(dAtA)
46 _ = i
47 var l int
48 _ = l
49 if m.unknownFields != nil {
50 i -= len(m.unknownFields)
51 copy(dAtA[i:], m.unknownFields)
52 }
53 if m.TapEnabled != nil {
54 if vtmsg, ok := interface{}(m.TapEnabled).(interface {
55 MarshalToSizedBufferVTStrict([]byte) (int, error)
56 }); ok {
57 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
58 if err != nil {
59 return 0, err
60 }
61 i -= size
62 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
63 } else {
64 encoded, err := proto.Marshal(m.TapEnabled)
65 if err != nil {
66 return 0, err
67 }
68 i -= len(encoded)
69 copy(dAtA[i:], encoded)
70 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
71 }
72 i--
73 dAtA[i] = 0x1a
74 }
75 if m.OutputConfig != nil {
76 size, err := m.OutputConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
77 if err != nil {
78 return 0, err
79 }
80 i -= size
81 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
82 i--
83 dAtA[i] = 0x12
84 }
85 if m.MatchConfig != nil {
86 size, err := m.MatchConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
87 if err != nil {
88 return 0, err
89 }
90 i -= size
91 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
92 i--
93 dAtA[i] = 0xa
94 }
95 return len(dAtA) - i, nil
96 }
97
98 func (m *MatchPredicate_MatchSet) MarshalVTStrict() (dAtA []byte, err error) {
99 if m == nil {
100 return nil, nil
101 }
102 size := m.SizeVT()
103 dAtA = make([]byte, size)
104 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
105 if err != nil {
106 return nil, err
107 }
108 return dAtA[:n], nil
109 }
110
111 func (m *MatchPredicate_MatchSet) MarshalToVTStrict(dAtA []byte) (int, error) {
112 size := m.SizeVT()
113 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
114 }
115
116 func (m *MatchPredicate_MatchSet) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
117 if m == nil {
118 return 0, nil
119 }
120 i := len(dAtA)
121 _ = i
122 var l int
123 _ = l
124 if m.unknownFields != nil {
125 i -= len(m.unknownFields)
126 copy(dAtA[i:], m.unknownFields)
127 }
128 if len(m.Rules) > 0 {
129 for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
130 size, err := m.Rules[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
131 if err != nil {
132 return 0, err
133 }
134 i -= size
135 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
136 i--
137 dAtA[i] = 0xa
138 }
139 }
140 return len(dAtA) - i, nil
141 }
142
143 func (m *MatchPredicate) MarshalVTStrict() (dAtA []byte, err error) {
144 if m == nil {
145 return nil, nil
146 }
147 size := m.SizeVT()
148 dAtA = make([]byte, size)
149 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
150 if err != nil {
151 return nil, err
152 }
153 return dAtA[:n], nil
154 }
155
156 func (m *MatchPredicate) MarshalToVTStrict(dAtA []byte) (int, error) {
157 size := m.SizeVT()
158 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
159 }
160
161 func (m *MatchPredicate) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
162 if m == nil {
163 return 0, nil
164 }
165 i := len(dAtA)
166 _ = i
167 var l int
168 _ = l
169 if m.unknownFields != nil {
170 i -= len(m.unknownFields)
171 copy(dAtA[i:], m.unknownFields)
172 }
173 if msg, ok := m.Rule.(*MatchPredicate_HttpResponseTrailersMatch); ok {
174 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
175 if err != nil {
176 return 0, err
177 }
178 i -= size
179 }
180 if msg, ok := m.Rule.(*MatchPredicate_HttpResponseHeadersMatch); ok {
181 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
182 if err != nil {
183 return 0, err
184 }
185 i -= size
186 }
187 if msg, ok := m.Rule.(*MatchPredicate_HttpRequestTrailersMatch); ok {
188 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
189 if err != nil {
190 return 0, err
191 }
192 i -= size
193 }
194 if msg, ok := m.Rule.(*MatchPredicate_HttpRequestHeadersMatch); ok {
195 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
196 if err != nil {
197 return 0, err
198 }
199 i -= size
200 }
201 if msg, ok := m.Rule.(*MatchPredicate_AnyMatch); ok {
202 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
203 if err != nil {
204 return 0, err
205 }
206 i -= size
207 }
208 if msg, ok := m.Rule.(*MatchPredicate_NotMatch); ok {
209 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
210 if err != nil {
211 return 0, err
212 }
213 i -= size
214 }
215 if msg, ok := m.Rule.(*MatchPredicate_AndMatch); ok {
216 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
217 if err != nil {
218 return 0, err
219 }
220 i -= size
221 }
222 if msg, ok := m.Rule.(*MatchPredicate_OrMatch); ok {
223 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
224 if err != nil {
225 return 0, err
226 }
227 i -= size
228 }
229 return len(dAtA) - i, nil
230 }
231
232 func (m *MatchPredicate_OrMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
233 size := m.SizeVT()
234 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
235 }
236
237 func (m *MatchPredicate_OrMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
238 i := len(dAtA)
239 if m.OrMatch != nil {
240 size, err := m.OrMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
241 if err != nil {
242 return 0, err
243 }
244 i -= size
245 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
246 i--
247 dAtA[i] = 0xa
248 } else {
249 i = protohelpers.EncodeVarint(dAtA, i, 0)
250 i--
251 dAtA[i] = 0xa
252 }
253 return len(dAtA) - i, nil
254 }
255 func (m *MatchPredicate_AndMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
256 size := m.SizeVT()
257 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
258 }
259
260 func (m *MatchPredicate_AndMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
261 i := len(dAtA)
262 if m.AndMatch != nil {
263 size, err := m.AndMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
264 if err != nil {
265 return 0, err
266 }
267 i -= size
268 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
269 i--
270 dAtA[i] = 0x12
271 } else {
272 i = protohelpers.EncodeVarint(dAtA, i, 0)
273 i--
274 dAtA[i] = 0x12
275 }
276 return len(dAtA) - i, nil
277 }
278 func (m *MatchPredicate_NotMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
279 size := m.SizeVT()
280 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
281 }
282
283 func (m *MatchPredicate_NotMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
284 i := len(dAtA)
285 if m.NotMatch != nil {
286 size, err := m.NotMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
287 if err != nil {
288 return 0, err
289 }
290 i -= size
291 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
292 i--
293 dAtA[i] = 0x1a
294 } else {
295 i = protohelpers.EncodeVarint(dAtA, i, 0)
296 i--
297 dAtA[i] = 0x1a
298 }
299 return len(dAtA) - i, nil
300 }
301 func (m *MatchPredicate_AnyMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
302 size := m.SizeVT()
303 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
304 }
305
306 func (m *MatchPredicate_AnyMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
307 i := len(dAtA)
308 i--
309 if m.AnyMatch {
310 dAtA[i] = 1
311 } else {
312 dAtA[i] = 0
313 }
314 i--
315 dAtA[i] = 0x20
316 return len(dAtA) - i, nil
317 }
318 func (m *MatchPredicate_HttpRequestHeadersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
319 size := m.SizeVT()
320 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
321 }
322
323 func (m *MatchPredicate_HttpRequestHeadersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
324 i := len(dAtA)
325 if m.HttpRequestHeadersMatch != nil {
326 size, err := m.HttpRequestHeadersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
327 if err != nil {
328 return 0, err
329 }
330 i -= size
331 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
332 i--
333 dAtA[i] = 0x2a
334 } else {
335 i = protohelpers.EncodeVarint(dAtA, i, 0)
336 i--
337 dAtA[i] = 0x2a
338 }
339 return len(dAtA) - i, nil
340 }
341 func (m *MatchPredicate_HttpRequestTrailersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
342 size := m.SizeVT()
343 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
344 }
345
346 func (m *MatchPredicate_HttpRequestTrailersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
347 i := len(dAtA)
348 if m.HttpRequestTrailersMatch != nil {
349 size, err := m.HttpRequestTrailersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
350 if err != nil {
351 return 0, err
352 }
353 i -= size
354 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
355 i--
356 dAtA[i] = 0x32
357 } else {
358 i = protohelpers.EncodeVarint(dAtA, i, 0)
359 i--
360 dAtA[i] = 0x32
361 }
362 return len(dAtA) - i, nil
363 }
364 func (m *MatchPredicate_HttpResponseHeadersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
365 size := m.SizeVT()
366 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
367 }
368
369 func (m *MatchPredicate_HttpResponseHeadersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
370 i := len(dAtA)
371 if m.HttpResponseHeadersMatch != nil {
372 size, err := m.HttpResponseHeadersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
373 if err != nil {
374 return 0, err
375 }
376 i -= size
377 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
378 i--
379 dAtA[i] = 0x3a
380 } else {
381 i = protohelpers.EncodeVarint(dAtA, i, 0)
382 i--
383 dAtA[i] = 0x3a
384 }
385 return len(dAtA) - i, nil
386 }
387 func (m *MatchPredicate_HttpResponseTrailersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
388 size := m.SizeVT()
389 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
390 }
391
392 func (m *MatchPredicate_HttpResponseTrailersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
393 i := len(dAtA)
394 if m.HttpResponseTrailersMatch != nil {
395 size, err := m.HttpResponseTrailersMatch.MarshalToSizedBufferVTStrict(dAtA[:i])
396 if err != nil {
397 return 0, err
398 }
399 i -= size
400 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
401 i--
402 dAtA[i] = 0x42
403 } else {
404 i = protohelpers.EncodeVarint(dAtA, i, 0)
405 i--
406 dAtA[i] = 0x42
407 }
408 return len(dAtA) - i, nil
409 }
410 func (m *HttpHeadersMatch) MarshalVTStrict() (dAtA []byte, err error) {
411 if m == nil {
412 return nil, nil
413 }
414 size := m.SizeVT()
415 dAtA = make([]byte, size)
416 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
417 if err != nil {
418 return nil, err
419 }
420 return dAtA[:n], nil
421 }
422
423 func (m *HttpHeadersMatch) MarshalToVTStrict(dAtA []byte) (int, error) {
424 size := m.SizeVT()
425 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
426 }
427
428 func (m *HttpHeadersMatch) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
429 if m == nil {
430 return 0, nil
431 }
432 i := len(dAtA)
433 _ = i
434 var l int
435 _ = l
436 if m.unknownFields != nil {
437 i -= len(m.unknownFields)
438 copy(dAtA[i:], m.unknownFields)
439 }
440 if len(m.Headers) > 0 {
441 for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
442 if vtmsg, ok := interface{}(m.Headers[iNdEx]).(interface {
443 MarshalToSizedBufferVTStrict([]byte) (int, error)
444 }); ok {
445 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
446 if err != nil {
447 return 0, err
448 }
449 i -= size
450 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
451 } else {
452 encoded, err := proto.Marshal(m.Headers[iNdEx])
453 if err != nil {
454 return 0, err
455 }
456 i -= len(encoded)
457 copy(dAtA[i:], encoded)
458 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
459 }
460 i--
461 dAtA[i] = 0xa
462 }
463 }
464 return len(dAtA) - i, nil
465 }
466
467 func (m *OutputConfig) MarshalVTStrict() (dAtA []byte, err error) {
468 if m == nil {
469 return nil, nil
470 }
471 size := m.SizeVT()
472 dAtA = make([]byte, size)
473 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
474 if err != nil {
475 return nil, err
476 }
477 return dAtA[:n], nil
478 }
479
480 func (m *OutputConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
481 size := m.SizeVT()
482 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
483 }
484
485 func (m *OutputConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
486 if m == nil {
487 return 0, nil
488 }
489 i := len(dAtA)
490 _ = i
491 var l int
492 _ = l
493 if m.unknownFields != nil {
494 i -= len(m.unknownFields)
495 copy(dAtA[i:], m.unknownFields)
496 }
497 if m.Streaming {
498 i--
499 if m.Streaming {
500 dAtA[i] = 1
501 } else {
502 dAtA[i] = 0
503 }
504 i--
505 dAtA[i] = 0x20
506 }
507 if m.MaxBufferedTxBytes != nil {
508 size, err := (*wrapperspb.UInt32Value)(m.MaxBufferedTxBytes).MarshalToSizedBufferVTStrict(dAtA[:i])
509 if err != nil {
510 return 0, err
511 }
512 i -= size
513 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
514 i--
515 dAtA[i] = 0x1a
516 }
517 if m.MaxBufferedRxBytes != nil {
518 size, err := (*wrapperspb.UInt32Value)(m.MaxBufferedRxBytes).MarshalToSizedBufferVTStrict(dAtA[:i])
519 if err != nil {
520 return 0, err
521 }
522 i -= size
523 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
524 i--
525 dAtA[i] = 0x12
526 }
527 if len(m.Sinks) > 0 {
528 for iNdEx := len(m.Sinks) - 1; iNdEx >= 0; iNdEx-- {
529 size, err := m.Sinks[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i])
530 if err != nil {
531 return 0, err
532 }
533 i -= size
534 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
535 i--
536 dAtA[i] = 0xa
537 }
538 }
539 return len(dAtA) - i, nil
540 }
541
542 func (m *OutputSink) MarshalVTStrict() (dAtA []byte, err error) {
543 if m == nil {
544 return nil, nil
545 }
546 size := m.SizeVT()
547 dAtA = make([]byte, size)
548 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
549 if err != nil {
550 return nil, err
551 }
552 return dAtA[:n], nil
553 }
554
555 func (m *OutputSink) MarshalToVTStrict(dAtA []byte) (int, error) {
556 size := m.SizeVT()
557 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
558 }
559
560 func (m *OutputSink) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
561 if m == nil {
562 return 0, nil
563 }
564 i := len(dAtA)
565 _ = i
566 var l int
567 _ = l
568 if m.unknownFields != nil {
569 i -= len(m.unknownFields)
570 copy(dAtA[i:], m.unknownFields)
571 }
572 if msg, ok := m.OutputSinkType.(*OutputSink_StreamingGrpc); ok {
573 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
574 if err != nil {
575 return 0, err
576 }
577 i -= size
578 }
579 if msg, ok := m.OutputSinkType.(*OutputSink_FilePerTap); ok {
580 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
581 if err != nil {
582 return 0, err
583 }
584 i -= size
585 }
586 if msg, ok := m.OutputSinkType.(*OutputSink_StreamingAdmin); ok {
587 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
588 if err != nil {
589 return 0, err
590 }
591 i -= size
592 }
593 if m.Format != 0 {
594 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Format))
595 i--
596 dAtA[i] = 0x8
597 }
598 return len(dAtA) - i, nil
599 }
600
601 func (m *OutputSink_StreamingAdmin) MarshalToVTStrict(dAtA []byte) (int, error) {
602 size := m.SizeVT()
603 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
604 }
605
606 func (m *OutputSink_StreamingAdmin) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
607 i := len(dAtA)
608 if m.StreamingAdmin != nil {
609 size, err := m.StreamingAdmin.MarshalToSizedBufferVTStrict(dAtA[:i])
610 if err != nil {
611 return 0, err
612 }
613 i -= size
614 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
615 i--
616 dAtA[i] = 0x12
617 } else {
618 i = protohelpers.EncodeVarint(dAtA, i, 0)
619 i--
620 dAtA[i] = 0x12
621 }
622 return len(dAtA) - i, nil
623 }
624 func (m *OutputSink_FilePerTap) MarshalToVTStrict(dAtA []byte) (int, error) {
625 size := m.SizeVT()
626 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
627 }
628
629 func (m *OutputSink_FilePerTap) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
630 i := len(dAtA)
631 if m.FilePerTap != nil {
632 size, err := m.FilePerTap.MarshalToSizedBufferVTStrict(dAtA[:i])
633 if err != nil {
634 return 0, err
635 }
636 i -= size
637 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
638 i--
639 dAtA[i] = 0x1a
640 } else {
641 i = protohelpers.EncodeVarint(dAtA, i, 0)
642 i--
643 dAtA[i] = 0x1a
644 }
645 return len(dAtA) - i, nil
646 }
647 func (m *OutputSink_StreamingGrpc) MarshalToVTStrict(dAtA []byte) (int, error) {
648 size := m.SizeVT()
649 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
650 }
651
652 func (m *OutputSink_StreamingGrpc) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
653 i := len(dAtA)
654 if m.StreamingGrpc != nil {
655 size, err := m.StreamingGrpc.MarshalToSizedBufferVTStrict(dAtA[:i])
656 if err != nil {
657 return 0, err
658 }
659 i -= size
660 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
661 i--
662 dAtA[i] = 0x22
663 } else {
664 i = protohelpers.EncodeVarint(dAtA, i, 0)
665 i--
666 dAtA[i] = 0x22
667 }
668 return len(dAtA) - i, nil
669 }
670 func (m *StreamingAdminSink) MarshalVTStrict() (dAtA []byte, err error) {
671 if m == nil {
672 return nil, nil
673 }
674 size := m.SizeVT()
675 dAtA = make([]byte, size)
676 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
677 if err != nil {
678 return nil, err
679 }
680 return dAtA[:n], nil
681 }
682
683 func (m *StreamingAdminSink) MarshalToVTStrict(dAtA []byte) (int, error) {
684 size := m.SizeVT()
685 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
686 }
687
688 func (m *StreamingAdminSink) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
689 if m == nil {
690 return 0, nil
691 }
692 i := len(dAtA)
693 _ = i
694 var l int
695 _ = l
696 if m.unknownFields != nil {
697 i -= len(m.unknownFields)
698 copy(dAtA[i:], m.unknownFields)
699 }
700 return len(dAtA) - i, nil
701 }
702
703 func (m *FilePerTapSink) MarshalVTStrict() (dAtA []byte, err error) {
704 if m == nil {
705 return nil, nil
706 }
707 size := m.SizeVT()
708 dAtA = make([]byte, size)
709 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
710 if err != nil {
711 return nil, err
712 }
713 return dAtA[:n], nil
714 }
715
716 func (m *FilePerTapSink) MarshalToVTStrict(dAtA []byte) (int, error) {
717 size := m.SizeVT()
718 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
719 }
720
721 func (m *FilePerTapSink) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
722 if m == nil {
723 return 0, nil
724 }
725 i := len(dAtA)
726 _ = i
727 var l int
728 _ = l
729 if m.unknownFields != nil {
730 i -= len(m.unknownFields)
731 copy(dAtA[i:], m.unknownFields)
732 }
733 if len(m.PathPrefix) > 0 {
734 i -= len(m.PathPrefix)
735 copy(dAtA[i:], m.PathPrefix)
736 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PathPrefix)))
737 i--
738 dAtA[i] = 0xa
739 }
740 return len(dAtA) - i, nil
741 }
742
743 func (m *StreamingGrpcSink) MarshalVTStrict() (dAtA []byte, err error) {
744 if m == nil {
745 return nil, nil
746 }
747 size := m.SizeVT()
748 dAtA = make([]byte, size)
749 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
750 if err != nil {
751 return nil, err
752 }
753 return dAtA[:n], nil
754 }
755
756 func (m *StreamingGrpcSink) MarshalToVTStrict(dAtA []byte) (int, error) {
757 size := m.SizeVT()
758 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
759 }
760
761 func (m *StreamingGrpcSink) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
762 if m == nil {
763 return 0, nil
764 }
765 i := len(dAtA)
766 _ = i
767 var l int
768 _ = l
769 if m.unknownFields != nil {
770 i -= len(m.unknownFields)
771 copy(dAtA[i:], m.unknownFields)
772 }
773 if m.GrpcService != nil {
774 if vtmsg, ok := interface{}(m.GrpcService).(interface {
775 MarshalToSizedBufferVTStrict([]byte) (int, error)
776 }); ok {
777 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
778 if err != nil {
779 return 0, err
780 }
781 i -= size
782 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
783 } else {
784 encoded, err := proto.Marshal(m.GrpcService)
785 if err != nil {
786 return 0, err
787 }
788 i -= len(encoded)
789 copy(dAtA[i:], encoded)
790 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
791 }
792 i--
793 dAtA[i] = 0x12
794 }
795 if len(m.TapId) > 0 {
796 i -= len(m.TapId)
797 copy(dAtA[i:], m.TapId)
798 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TapId)))
799 i--
800 dAtA[i] = 0xa
801 }
802 return len(dAtA) - i, nil
803 }
804
805 func (m *TapConfig) SizeVT() (n int) {
806 if m == nil {
807 return 0
808 }
809 var l int
810 _ = l
811 if m.MatchConfig != nil {
812 l = m.MatchConfig.SizeVT()
813 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
814 }
815 if m.OutputConfig != nil {
816 l = m.OutputConfig.SizeVT()
817 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
818 }
819 if m.TapEnabled != nil {
820 if size, ok := interface{}(m.TapEnabled).(interface {
821 SizeVT() int
822 }); ok {
823 l = size.SizeVT()
824 } else {
825 l = proto.Size(m.TapEnabled)
826 }
827 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
828 }
829 n += len(m.unknownFields)
830 return n
831 }
832
833 func (m *MatchPredicate_MatchSet) SizeVT() (n int) {
834 if m == nil {
835 return 0
836 }
837 var l int
838 _ = l
839 if len(m.Rules) > 0 {
840 for _, e := range m.Rules {
841 l = e.SizeVT()
842 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
843 }
844 }
845 n += len(m.unknownFields)
846 return n
847 }
848
849 func (m *MatchPredicate) SizeVT() (n int) {
850 if m == nil {
851 return 0
852 }
853 var l int
854 _ = l
855 if vtmsg, ok := m.Rule.(interface{ SizeVT() int }); ok {
856 n += vtmsg.SizeVT()
857 }
858 n += len(m.unknownFields)
859 return n
860 }
861
862 func (m *MatchPredicate_OrMatch) SizeVT() (n int) {
863 if m == nil {
864 return 0
865 }
866 var l int
867 _ = l
868 if m.OrMatch != nil {
869 l = m.OrMatch.SizeVT()
870 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
871 } else {
872 n += 2
873 }
874 return n
875 }
876 func (m *MatchPredicate_AndMatch) SizeVT() (n int) {
877 if m == nil {
878 return 0
879 }
880 var l int
881 _ = l
882 if m.AndMatch != nil {
883 l = m.AndMatch.SizeVT()
884 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
885 } else {
886 n += 2
887 }
888 return n
889 }
890 func (m *MatchPredicate_NotMatch) SizeVT() (n int) {
891 if m == nil {
892 return 0
893 }
894 var l int
895 _ = l
896 if m.NotMatch != nil {
897 l = m.NotMatch.SizeVT()
898 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
899 } else {
900 n += 2
901 }
902 return n
903 }
904 func (m *MatchPredicate_AnyMatch) SizeVT() (n int) {
905 if m == nil {
906 return 0
907 }
908 var l int
909 _ = l
910 n += 2
911 return n
912 }
913 func (m *MatchPredicate_HttpRequestHeadersMatch) SizeVT() (n int) {
914 if m == nil {
915 return 0
916 }
917 var l int
918 _ = l
919 if m.HttpRequestHeadersMatch != nil {
920 l = m.HttpRequestHeadersMatch.SizeVT()
921 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
922 } else {
923 n += 2
924 }
925 return n
926 }
927 func (m *MatchPredicate_HttpRequestTrailersMatch) SizeVT() (n int) {
928 if m == nil {
929 return 0
930 }
931 var l int
932 _ = l
933 if m.HttpRequestTrailersMatch != nil {
934 l = m.HttpRequestTrailersMatch.SizeVT()
935 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
936 } else {
937 n += 2
938 }
939 return n
940 }
941 func (m *MatchPredicate_HttpResponseHeadersMatch) SizeVT() (n int) {
942 if m == nil {
943 return 0
944 }
945 var l int
946 _ = l
947 if m.HttpResponseHeadersMatch != nil {
948 l = m.HttpResponseHeadersMatch.SizeVT()
949 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
950 } else {
951 n += 2
952 }
953 return n
954 }
955 func (m *MatchPredicate_HttpResponseTrailersMatch) SizeVT() (n int) {
956 if m == nil {
957 return 0
958 }
959 var l int
960 _ = l
961 if m.HttpResponseTrailersMatch != nil {
962 l = m.HttpResponseTrailersMatch.SizeVT()
963 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
964 } else {
965 n += 2
966 }
967 return n
968 }
969 func (m *HttpHeadersMatch) SizeVT() (n int) {
970 if m == nil {
971 return 0
972 }
973 var l int
974 _ = l
975 if len(m.Headers) > 0 {
976 for _, e := range m.Headers {
977 if size, ok := interface{}(e).(interface {
978 SizeVT() int
979 }); ok {
980 l = size.SizeVT()
981 } else {
982 l = proto.Size(e)
983 }
984 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
985 }
986 }
987 n += len(m.unknownFields)
988 return n
989 }
990
991 func (m *OutputConfig) SizeVT() (n int) {
992 if m == nil {
993 return 0
994 }
995 var l int
996 _ = l
997 if len(m.Sinks) > 0 {
998 for _, e := range m.Sinks {
999 l = e.SizeVT()
1000 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1001 }
1002 }
1003 if m.MaxBufferedRxBytes != nil {
1004 l = (*wrapperspb.UInt32Value)(m.MaxBufferedRxBytes).SizeVT()
1005 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1006 }
1007 if m.MaxBufferedTxBytes != nil {
1008 l = (*wrapperspb.UInt32Value)(m.MaxBufferedTxBytes).SizeVT()
1009 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1010 }
1011 if m.Streaming {
1012 n += 2
1013 }
1014 n += len(m.unknownFields)
1015 return n
1016 }
1017
1018 func (m *OutputSink) SizeVT() (n int) {
1019 if m == nil {
1020 return 0
1021 }
1022 var l int
1023 _ = l
1024 if m.Format != 0 {
1025 n += 1 + protohelpers.SizeOfVarint(uint64(m.Format))
1026 }
1027 if vtmsg, ok := m.OutputSinkType.(interface{ SizeVT() int }); ok {
1028 n += vtmsg.SizeVT()
1029 }
1030 n += len(m.unknownFields)
1031 return n
1032 }
1033
1034 func (m *OutputSink_StreamingAdmin) SizeVT() (n int) {
1035 if m == nil {
1036 return 0
1037 }
1038 var l int
1039 _ = l
1040 if m.StreamingAdmin != nil {
1041 l = m.StreamingAdmin.SizeVT()
1042 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1043 } else {
1044 n += 2
1045 }
1046 return n
1047 }
1048 func (m *OutputSink_FilePerTap) SizeVT() (n int) {
1049 if m == nil {
1050 return 0
1051 }
1052 var l int
1053 _ = l
1054 if m.FilePerTap != nil {
1055 l = m.FilePerTap.SizeVT()
1056 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1057 } else {
1058 n += 2
1059 }
1060 return n
1061 }
1062 func (m *OutputSink_StreamingGrpc) SizeVT() (n int) {
1063 if m == nil {
1064 return 0
1065 }
1066 var l int
1067 _ = l
1068 if m.StreamingGrpc != nil {
1069 l = m.StreamingGrpc.SizeVT()
1070 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1071 } else {
1072 n += 2
1073 }
1074 return n
1075 }
1076 func (m *StreamingAdminSink) SizeVT() (n int) {
1077 if m == nil {
1078 return 0
1079 }
1080 var l int
1081 _ = l
1082 n += len(m.unknownFields)
1083 return n
1084 }
1085
1086 func (m *FilePerTapSink) SizeVT() (n int) {
1087 if m == nil {
1088 return 0
1089 }
1090 var l int
1091 _ = l
1092 l = len(m.PathPrefix)
1093 if l > 0 {
1094 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1095 }
1096 n += len(m.unknownFields)
1097 return n
1098 }
1099
1100 func (m *StreamingGrpcSink) SizeVT() (n int) {
1101 if m == nil {
1102 return 0
1103 }
1104 var l int
1105 _ = l
1106 l = len(m.TapId)
1107 if l > 0 {
1108 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1109 }
1110 if m.GrpcService != nil {
1111 if size, ok := interface{}(m.GrpcService).(interface {
1112 SizeVT() int
1113 }); ok {
1114 l = size.SizeVT()
1115 } else {
1116 l = proto.Size(m.GrpcService)
1117 }
1118 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1119 }
1120 n += len(m.unknownFields)
1121 return n
1122 }