Debian Codegraph @

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