Debian Codegraph @

envoy/extensions/wasm/v3/wasm_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/extensions/wasm/v3/wasm.proto
6
7 package wasmv3
8
9 import (
10 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
11 anypb "github.com/planetscale/vtprotobuf/types/known/anypb"
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 *ReloadConfig) 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 *ReloadConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
37 size := m.SizeVT()
38 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
39 }
40
41 func (m *ReloadConfig) 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.Backoff != nil {
54 if vtmsg, ok := interface{}(m.Backoff).(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.Backoff)
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] = 0xa
74 }
75 return len(dAtA) - i, nil
76 }
77
78 func (m *CapabilityRestrictionConfig) MarshalVTStrict() (dAtA []byte, err error) {
79 if m == nil {
80 return nil, nil
81 }
82 size := m.SizeVT()
83 dAtA = make([]byte, size)
84 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
85 if err != nil {
86 return nil, err
87 }
88 return dAtA[:n], nil
89 }
90
91 func (m *CapabilityRestrictionConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
92 size := m.SizeVT()
93 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
94 }
95
96 func (m *CapabilityRestrictionConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
97 if m == nil {
98 return 0, nil
99 }
100 i := len(dAtA)
101 _ = i
102 var l int
103 _ = l
104 if m.unknownFields != nil {
105 i -= len(m.unknownFields)
106 copy(dAtA[i:], m.unknownFields)
107 }
108 if len(m.AllowedCapabilities) > 0 {
109 for k := range m.AllowedCapabilities {
110 v := m.AllowedCapabilities[k]
111 baseI := i
112 size, err := v.MarshalToSizedBufferVTStrict(dAtA[:i])
113 if err != nil {
114 return 0, err
115 }
116 i -= size
117 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
118 i--
119 dAtA[i] = 0x12
120 i -= len(k)
121 copy(dAtA[i:], k)
122 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
123 i--
124 dAtA[i] = 0xa
125 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
126 i--
127 dAtA[i] = 0xa
128 }
129 }
130 return len(dAtA) - i, nil
131 }
132
133 func (m *SanitizationConfig) MarshalVTStrict() (dAtA []byte, err error) {
134 if m == nil {
135 return nil, nil
136 }
137 size := m.SizeVT()
138 dAtA = make([]byte, size)
139 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
140 if err != nil {
141 return nil, err
142 }
143 return dAtA[:n], nil
144 }
145
146 func (m *SanitizationConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
147 size := m.SizeVT()
148 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
149 }
150
151 func (m *SanitizationConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
152 if m == nil {
153 return 0, nil
154 }
155 i := len(dAtA)
156 _ = i
157 var l int
158 _ = l
159 if m.unknownFields != nil {
160 i -= len(m.unknownFields)
161 copy(dAtA[i:], m.unknownFields)
162 }
163 return len(dAtA) - i, nil
164 }
165
166 func (m *VmConfig) 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 *VmConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
180 size := m.SizeVT()
181 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
182 }
183
184 func (m *VmConfig) 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 m.EnvironmentVariables != nil {
197 size, err := m.EnvironmentVariables.MarshalToSizedBufferVTStrict(dAtA[:i])
198 if err != nil {
199 return 0, err
200 }
201 i -= size
202 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
203 i--
204 dAtA[i] = 0x3a
205 }
206 if m.NackOnCodeCacheMiss {
207 i--
208 if m.NackOnCodeCacheMiss {
209 dAtA[i] = 1
210 } else {
211 dAtA[i] = 0
212 }
213 i--
214 dAtA[i] = 0x30
215 }
216 if m.AllowPrecompiled {
217 i--
218 if m.AllowPrecompiled {
219 dAtA[i] = 1
220 } else {
221 dAtA[i] = 0
222 }
223 i--
224 dAtA[i] = 0x28
225 }
226 if m.Configuration != nil {
227 size, err := (*anypb.Any)(m.Configuration).MarshalToSizedBufferVTStrict(dAtA[:i])
228 if err != nil {
229 return 0, err
230 }
231 i -= size
232 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
233 i--
234 dAtA[i] = 0x22
235 }
236 if m.Code != nil {
237 if vtmsg, ok := interface{}(m.Code).(interface {
238 MarshalToSizedBufferVTStrict([]byte) (int, error)
239 }); ok {
240 size, err := vtmsg.MarshalToSizedBufferVTStrict(dAtA[:i])
241 if err != nil {
242 return 0, err
243 }
244 i -= size
245 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
246 } else {
247 encoded, err := proto.Marshal(m.Code)
248 if err != nil {
249 return 0, err
250 }
251 i -= len(encoded)
252 copy(dAtA[i:], encoded)
253 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
254 }
255 i--
256 dAtA[i] = 0x1a
257 }
258 if len(m.Runtime) > 0 {
259 i -= len(m.Runtime)
260 copy(dAtA[i:], m.Runtime)
261 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Runtime)))
262 i--
263 dAtA[i] = 0x12
264 }
265 if len(m.VmId) > 0 {
266 i -= len(m.VmId)
267 copy(dAtA[i:], m.VmId)
268 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VmId)))
269 i--
270 dAtA[i] = 0xa
271 }
272 return len(dAtA) - i, nil
273 }
274
275 func (m *EnvironmentVariables) MarshalVTStrict() (dAtA []byte, err error) {
276 if m == nil {
277 return nil, nil
278 }
279 size := m.SizeVT()
280 dAtA = make([]byte, size)
281 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
282 if err != nil {
283 return nil, err
284 }
285 return dAtA[:n], nil
286 }
287
288 func (m *EnvironmentVariables) MarshalToVTStrict(dAtA []byte) (int, error) {
289 size := m.SizeVT()
290 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
291 }
292
293 func (m *EnvironmentVariables) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
294 if m == nil {
295 return 0, nil
296 }
297 i := len(dAtA)
298 _ = i
299 var l int
300 _ = l
301 if m.unknownFields != nil {
302 i -= len(m.unknownFields)
303 copy(dAtA[i:], m.unknownFields)
304 }
305 if len(m.KeyValues) > 0 {
306 for k := range m.KeyValues {
307 v := m.KeyValues[k]
308 baseI := i
309 i -= len(v)
310 copy(dAtA[i:], v)
311 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
312 i--
313 dAtA[i] = 0x12
314 i -= len(k)
315 copy(dAtA[i:], k)
316 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
317 i--
318 dAtA[i] = 0xa
319 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
320 i--
321 dAtA[i] = 0x12
322 }
323 }
324 if len(m.HostEnvKeys) > 0 {
325 for iNdEx := len(m.HostEnvKeys) - 1; iNdEx >= 0; iNdEx-- {
326 i -= len(m.HostEnvKeys[iNdEx])
327 copy(dAtA[i:], m.HostEnvKeys[iNdEx])
328 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HostEnvKeys[iNdEx])))
329 i--
330 dAtA[i] = 0xa
331 }
332 }
333 return len(dAtA) - i, nil
334 }
335
336 func (m *PluginConfig) MarshalVTStrict() (dAtA []byte, err error) {
337 if m == nil {
338 return nil, nil
339 }
340 size := m.SizeVT()
341 dAtA = make([]byte, size)
342 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
343 if err != nil {
344 return nil, err
345 }
346 return dAtA[:n], nil
347 }
348
349 func (m *PluginConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
350 size := m.SizeVT()
351 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
352 }
353
354 func (m *PluginConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
355 if m == nil {
356 return 0, nil
357 }
358 i := len(dAtA)
359 _ = i
360 var l int
361 _ = l
362 if m.unknownFields != nil {
363 i -= len(m.unknownFields)
364 copy(dAtA[i:], m.unknownFields)
365 }
366 if m.ReloadConfig != nil {
367 size, err := m.ReloadConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
368 if err != nil {
369 return 0, err
370 }
371 i -= size
372 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
373 i--
374 dAtA[i] = 0x42
375 }
376 if m.FailurePolicy != 0 {
377 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FailurePolicy))
378 i--
379 dAtA[i] = 0x38
380 }
381 if m.CapabilityRestrictionConfig != nil {
382 size, err := m.CapabilityRestrictionConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
383 if err != nil {
384 return 0, err
385 }
386 i -= size
387 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
388 i--
389 dAtA[i] = 0x32
390 }
391 if m.FailOpen {
392 i--
393 if m.FailOpen {
394 dAtA[i] = 1
395 } else {
396 dAtA[i] = 0
397 }
398 i--
399 dAtA[i] = 0x28
400 }
401 if m.Configuration != nil {
402 size, err := (*anypb.Any)(m.Configuration).MarshalToSizedBufferVTStrict(dAtA[:i])
403 if err != nil {
404 return 0, err
405 }
406 i -= size
407 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
408 i--
409 dAtA[i] = 0x22
410 }
411 if msg, ok := m.Vm.(*PluginConfig_VmConfig); ok {
412 size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
413 if err != nil {
414 return 0, err
415 }
416 i -= size
417 }
418 if len(m.RootId) > 0 {
419 i -= len(m.RootId)
420 copy(dAtA[i:], m.RootId)
421 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RootId)))
422 i--
423 dAtA[i] = 0x12
424 }
425 if len(m.Name) > 0 {
426 i -= len(m.Name)
427 copy(dAtA[i:], m.Name)
428 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
429 i--
430 dAtA[i] = 0xa
431 }
432 return len(dAtA) - i, nil
433 }
434
435 func (m *PluginConfig_VmConfig) MarshalToVTStrict(dAtA []byte) (int, error) {
436 size := m.SizeVT()
437 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
438 }
439
440 func (m *PluginConfig_VmConfig) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
441 i := len(dAtA)
442 if m.VmConfig != nil {
443 size, err := m.VmConfig.MarshalToSizedBufferVTStrict(dAtA[:i])
444 if err != nil {
445 return 0, err
446 }
447 i -= size
448 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
449 i--
450 dAtA[i] = 0x1a
451 } else {
452 i = protohelpers.EncodeVarint(dAtA, i, 0)
453 i--
454 dAtA[i] = 0x1a
455 }
456 return len(dAtA) - i, nil
457 }
458 func (m *WasmService) MarshalVTStrict() (dAtA []byte, err error) {
459 if m == nil {
460 return nil, nil
461 }
462 size := m.SizeVT()
463 dAtA = make([]byte, size)
464 n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
465 if err != nil {
466 return nil, err
467 }
468 return dAtA[:n], nil
469 }
470
471 func (m *WasmService) MarshalToVTStrict(dAtA []byte) (int, error) {
472 size := m.SizeVT()
473 return m.MarshalToSizedBufferVTStrict(dAtA[:size])
474 }
475
476 func (m *WasmService) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
477 if m == nil {
478 return 0, nil
479 }
480 i := len(dAtA)
481 _ = i
482 var l int
483 _ = l
484 if m.unknownFields != nil {
485 i -= len(m.unknownFields)
486 copy(dAtA[i:], m.unknownFields)
487 }
488 if m.Singleton {
489 i--
490 if m.Singleton {
491 dAtA[i] = 1
492 } else {
493 dAtA[i] = 0
494 }
495 i--
496 dAtA[i] = 0x10
497 }
498 if m.Config != nil {
499 size, err := m.Config.MarshalToSizedBufferVTStrict(dAtA[:i])
500 if err != nil {
501 return 0, err
502 }
503 i -= size
504 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
505 i--
506 dAtA[i] = 0xa
507 }
508 return len(dAtA) - i, nil
509 }
510
511 func (m *ReloadConfig) SizeVT() (n int) {
512 if m == nil {
513 return 0
514 }
515 var l int
516 _ = l
517 if m.Backoff != nil {
518 if size, ok := interface{}(m.Backoff).(interface {
519 SizeVT() int
520 }); ok {
521 l = size.SizeVT()
522 } else {
523 l = proto.Size(m.Backoff)
524 }
525 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
526 }
527 n += len(m.unknownFields)
528 return n
529 }
530
531 func (m *CapabilityRestrictionConfig) SizeVT() (n int) {
532 if m == nil {
533 return 0
534 }
535 var l int
536 _ = l
537 if len(m.AllowedCapabilities) > 0 {
538 for k, v := range m.AllowedCapabilities {
539 _ = k
540 _ = v
541 l = 0
542 if v != nil {
543 l = v.SizeVT()
544 }
545 l += 1 + protohelpers.SizeOfVarint(uint64(l))
546 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
547 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
548 }
549 }
550 n += len(m.unknownFields)
551 return n
552 }
553
554 func (m *SanitizationConfig) SizeVT() (n int) {
555 if m == nil {
556 return 0
557 }
558 var l int
559 _ = l
560 n += len(m.unknownFields)
561 return n
562 }
563
564 func (m *VmConfig) SizeVT() (n int) {
565 if m == nil {
566 return 0
567 }
568 var l int
569 _ = l
570 l = len(m.VmId)
571 if l > 0 {
572 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
573 }
574 l = len(m.Runtime)
575 if l > 0 {
576 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
577 }
578 if m.Code != nil {
579 if size, ok := interface{}(m.Code).(interface {
580 SizeVT() int
581 }); ok {
582 l = size.SizeVT()
583 } else {
584 l = proto.Size(m.Code)
585 }
586 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
587 }
588 if m.Configuration != nil {
589 l = (*anypb.Any)(m.Configuration).SizeVT()
590 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
591 }
592 if m.AllowPrecompiled {
593 n += 2
594 }
595 if m.NackOnCodeCacheMiss {
596 n += 2
597 }
598 if m.EnvironmentVariables != nil {
599 l = m.EnvironmentVariables.SizeVT()
600 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
601 }
602 n += len(m.unknownFields)
603 return n
604 }
605
606 func (m *EnvironmentVariables) SizeVT() (n int) {
607 if m == nil {
608 return 0
609 }
610 var l int
611 _ = l
612 if len(m.HostEnvKeys) > 0 {
613 for _, s := range m.HostEnvKeys {
614 l = len(s)
615 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
616 }
617 }
618 if len(m.KeyValues) > 0 {
619 for k, v := range m.KeyValues {
620 _ = k
621 _ = v
622 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))
623 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
624 }
625 }
626 n += len(m.unknownFields)
627 return n
628 }
629
630 func (m *PluginConfig) SizeVT() (n int) {
631 if m == nil {
632 return 0
633 }
634 var l int
635 _ = l
636 l = len(m.Name)
637 if l > 0 {
638 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
639 }
640 l = len(m.RootId)
641 if l > 0 {
642 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
643 }
644 if vtmsg, ok := m.Vm.(interface{ SizeVT() int }); ok {
645 n += vtmsg.SizeVT()
646 }
647 if m.Configuration != nil {
648 l = (*anypb.Any)(m.Configuration).SizeVT()
649 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
650 }
651 if m.FailOpen {
652 n += 2
653 }
654 if m.CapabilityRestrictionConfig != nil {
655 l = m.CapabilityRestrictionConfig.SizeVT()
656 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
657 }
658 if m.FailurePolicy != 0 {
659 n += 1 + protohelpers.SizeOfVarint(uint64(m.FailurePolicy))
660 }
661 if m.ReloadConfig != nil {
662 l = m.ReloadConfig.SizeVT()
663 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
664 }
665 n += len(m.unknownFields)
666 return n
667 }
668
669 func (m *PluginConfig_VmConfig) SizeVT() (n int) {
670 if m == nil {
671 return 0
672 }
673 var l int
674 _ = l
675 if m.VmConfig != nil {
676 l = m.VmConfig.SizeVT()
677 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
678 } else {
679 n += 2
680 }
681 return n
682 }
683 func (m *WasmService) SizeVT() (n int) {
684 if m == nil {
685 return 0
686 }
687 var l int
688 _ = l
689 if m.Config != nil {
690 l = m.Config.SizeVT()
691 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
692 }
693 if m.Singleton {
694 n += 2
695 }
696 n += len(m.unknownFields)
697 return n
698 }