Debian Codegraph @

buildkit/frontend/gateway/pb/gateway_vtproto.pb.go

raw
1 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
2 // protoc-gen-go-vtproto version: v0.6.1-0.20240319094008-0393e58bdf10
3 // source: github.com/moby/buildkit/frontend/gateway/pb/gateway.proto
4
5 package moby_buildkit_v1_frontend
6
7 import (
8 fmt "fmt"
9 types1 "github.com/moby/buildkit/api/types"
10 pb "github.com/moby/buildkit/solver/pb"
11 pb1 "github.com/moby/buildkit/sourcepolicy/pb"
12 pb2 "github.com/moby/buildkit/util/apicaps/pb"
13 protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
14 types "github.com/tonistiigi/fsutil/types"
15 status "google.golang.org/genproto/googleapis/rpc/status"
16 proto "google.golang.org/protobuf/proto"
17 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
18 io "io"
19 )
20
21 const (
22 // Verify that this generated code is sufficiently up-to-date.
23 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
24 // Verify that runtime/protoimpl is sufficiently up-to-date.
25 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
26 )
27
28 func (m *Result) CloneVT() *Result {
29 if m == nil {
30 return (*Result)(nil)
31 }
32 r := new(Result)
33 if m.Result != nil {
34 r.Result = m.Result.(interface{ CloneVT() isResult_Result }).CloneVT()
35 }
36 if rhs := m.Metadata; rhs != nil {
37 tmpContainer := make(map[string][]byte, len(rhs))
38 for k, v := range rhs {
39 tmpBytes := make([]byte, len(v))
40 copy(tmpBytes, v)
41 tmpContainer[k] = tmpBytes
42 }
43 r.Metadata = tmpContainer
44 }
45 if rhs := m.Attestations; rhs != nil {
46 tmpContainer := make(map[string]*Attestations, len(rhs))
47 for k, v := range rhs {
48 tmpContainer[k] = v.CloneVT()
49 }
50 r.Attestations = tmpContainer
51 }
52 if len(m.unknownFields) > 0 {
53 r.unknownFields = make([]byte, len(m.unknownFields))
54 copy(r.unknownFields, m.unknownFields)
55 }
56 return r
57 }
58
59 func (m *Result) CloneMessageVT() proto.Message {
60 return m.CloneVT()
61 }
62
63 func (m *Result_RefDeprecated) CloneVT() isResult_Result {
64 if m == nil {
65 return (*Result_RefDeprecated)(nil)
66 }
67 r := new(Result_RefDeprecated)
68 r.RefDeprecated = m.RefDeprecated
69 return r
70 }
71
72 func (m *Result_RefsDeprecated) CloneVT() isResult_Result {
73 if m == nil {
74 return (*Result_RefsDeprecated)(nil)
75 }
76 r := new(Result_RefsDeprecated)
77 r.RefsDeprecated = m.RefsDeprecated.CloneVT()
78 return r
79 }
80
81 func (m *Result_Ref) CloneVT() isResult_Result {
82 if m == nil {
83 return (*Result_Ref)(nil)
84 }
85 r := new(Result_Ref)
86 r.Ref = m.Ref.CloneVT()
87 return r
88 }
89
90 func (m *Result_Refs) CloneVT() isResult_Result {
91 if m == nil {
92 return (*Result_Refs)(nil)
93 }
94 r := new(Result_Refs)
95 r.Refs = m.Refs.CloneVT()
96 return r
97 }
98
99 func (m *RefMapDeprecated) CloneVT() *RefMapDeprecated {
100 if m == nil {
101 return (*RefMapDeprecated)(nil)
102 }
103 r := new(RefMapDeprecated)
104 if rhs := m.Refs; rhs != nil {
105 tmpContainer := make(map[string]string, len(rhs))
106 for k, v := range rhs {
107 tmpContainer[k] = v
108 }
109 r.Refs = tmpContainer
110 }
111 if len(m.unknownFields) > 0 {
112 r.unknownFields = make([]byte, len(m.unknownFields))
113 copy(r.unknownFields, m.unknownFields)
114 }
115 return r
116 }
117
118 func (m *RefMapDeprecated) CloneMessageVT() proto.Message {
119 return m.CloneVT()
120 }
121
122 func (m *Ref) CloneVT() *Ref {
123 if m == nil {
124 return (*Ref)(nil)
125 }
126 r := new(Ref)
127 r.Id = m.Id
128 r.Def = m.Def.CloneVT()
129 if len(m.unknownFields) > 0 {
130 r.unknownFields = make([]byte, len(m.unknownFields))
131 copy(r.unknownFields, m.unknownFields)
132 }
133 return r
134 }
135
136 func (m *Ref) CloneMessageVT() proto.Message {
137 return m.CloneVT()
138 }
139
140 func (m *RefMap) CloneVT() *RefMap {
141 if m == nil {
142 return (*RefMap)(nil)
143 }
144 r := new(RefMap)
145 if rhs := m.Refs; rhs != nil {
146 tmpContainer := make(map[string]*Ref, len(rhs))
147 for k, v := range rhs {
148 tmpContainer[k] = v.CloneVT()
149 }
150 r.Refs = tmpContainer
151 }
152 if len(m.unknownFields) > 0 {
153 r.unknownFields = make([]byte, len(m.unknownFields))
154 copy(r.unknownFields, m.unknownFields)
155 }
156 return r
157 }
158
159 func (m *RefMap) CloneMessageVT() proto.Message {
160 return m.CloneVT()
161 }
162
163 func (m *Attestations) CloneVT() *Attestations {
164 if m == nil {
165 return (*Attestations)(nil)
166 }
167 r := new(Attestations)
168 if rhs := m.Attestation; rhs != nil {
169 tmpContainer := make([]*Attestation, len(rhs))
170 for k, v := range rhs {
171 tmpContainer[k] = v.CloneVT()
172 }
173 r.Attestation = tmpContainer
174 }
175 if len(m.unknownFields) > 0 {
176 r.unknownFields = make([]byte, len(m.unknownFields))
177 copy(r.unknownFields, m.unknownFields)
178 }
179 return r
180 }
181
182 func (m *Attestations) CloneMessageVT() proto.Message {
183 return m.CloneVT()
184 }
185
186 func (m *Attestation) CloneVT() *Attestation {
187 if m == nil {
188 return (*Attestation)(nil)
189 }
190 r := new(Attestation)
191 r.Kind = m.Kind
192 r.Ref = m.Ref.CloneVT()
193 r.Path = m.Path
194 r.InTotoPredicateType = m.InTotoPredicateType
195 if rhs := m.Metadata; rhs != nil {
196 tmpContainer := make(map[string][]byte, len(rhs))
197 for k, v := range rhs {
198 tmpBytes := make([]byte, len(v))
199 copy(tmpBytes, v)
200 tmpContainer[k] = tmpBytes
201 }
202 r.Metadata = tmpContainer
203 }
204 if rhs := m.InTotoSubjects; rhs != nil {
205 tmpContainer := make([]*InTotoSubject, len(rhs))
206 for k, v := range rhs {
207 tmpContainer[k] = v.CloneVT()
208 }
209 r.InTotoSubjects = tmpContainer
210 }
211 if len(m.unknownFields) > 0 {
212 r.unknownFields = make([]byte, len(m.unknownFields))
213 copy(r.unknownFields, m.unknownFields)
214 }
215 return r
216 }
217
218 func (m *Attestation) CloneMessageVT() proto.Message {
219 return m.CloneVT()
220 }
221
222 func (m *InTotoSubject) CloneVT() *InTotoSubject {
223 if m == nil {
224 return (*InTotoSubject)(nil)
225 }
226 r := new(InTotoSubject)
227 r.Kind = m.Kind
228 r.Name = m.Name
229 if rhs := m.Digest; rhs != nil {
230 tmpContainer := make([]string, len(rhs))
231 copy(tmpContainer, rhs)
232 r.Digest = tmpContainer
233 }
234 if len(m.unknownFields) > 0 {
235 r.unknownFields = make([]byte, len(m.unknownFields))
236 copy(r.unknownFields, m.unknownFields)
237 }
238 return r
239 }
240
241 func (m *InTotoSubject) CloneMessageVT() proto.Message {
242 return m.CloneVT()
243 }
244
245 func (m *ReturnRequest) CloneVT() *ReturnRequest {
246 if m == nil {
247 return (*ReturnRequest)(nil)
248 }
249 r := new(ReturnRequest)
250 r.Result = m.Result.CloneVT()
251 if rhs := m.Error; rhs != nil {
252 if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *status.Status }); ok {
253 r.Error = vtpb.CloneVT()
254 } else {
255 r.Error = proto.Clone(rhs).(*status.Status)
256 }
257 }
258 if len(m.unknownFields) > 0 {
259 r.unknownFields = make([]byte, len(m.unknownFields))
260 copy(r.unknownFields, m.unknownFields)
261 }
262 return r
263 }
264
265 func (m *ReturnRequest) CloneMessageVT() proto.Message {
266 return m.CloneVT()
267 }
268
269 func (m *ReturnResponse) CloneVT() *ReturnResponse {
270 if m == nil {
271 return (*ReturnResponse)(nil)
272 }
273 r := new(ReturnResponse)
274 if len(m.unknownFields) > 0 {
275 r.unknownFields = make([]byte, len(m.unknownFields))
276 copy(r.unknownFields, m.unknownFields)
277 }
278 return r
279 }
280
281 func (m *ReturnResponse) CloneMessageVT() proto.Message {
282 return m.CloneVT()
283 }
284
285 func (m *InputsRequest) CloneVT() *InputsRequest {
286 if m == nil {
287 return (*InputsRequest)(nil)
288 }
289 r := new(InputsRequest)
290 if len(m.unknownFields) > 0 {
291 r.unknownFields = make([]byte, len(m.unknownFields))
292 copy(r.unknownFields, m.unknownFields)
293 }
294 return r
295 }
296
297 func (m *InputsRequest) CloneMessageVT() proto.Message {
298 return m.CloneVT()
299 }
300
301 func (m *InputsResponse) CloneVT() *InputsResponse {
302 if m == nil {
303 return (*InputsResponse)(nil)
304 }
305 r := new(InputsResponse)
306 if rhs := m.Definitions; rhs != nil {
307 tmpContainer := make(map[string]*pb.Definition, len(rhs))
308 for k, v := range rhs {
309 tmpContainer[k] = v.CloneVT()
310 }
311 r.Definitions = tmpContainer
312 }
313 if len(m.unknownFields) > 0 {
314 r.unknownFields = make([]byte, len(m.unknownFields))
315 copy(r.unknownFields, m.unknownFields)
316 }
317 return r
318 }
319
320 func (m *InputsResponse) CloneMessageVT() proto.Message {
321 return m.CloneVT()
322 }
323
324 func (m *ResolveImageConfigRequest) CloneVT() *ResolveImageConfigRequest {
325 if m == nil {
326 return (*ResolveImageConfigRequest)(nil)
327 }
328 r := new(ResolveImageConfigRequest)
329 r.Ref = m.Ref
330 r.Platform = m.Platform.CloneVT()
331 r.ResolveMode = m.ResolveMode
332 r.LogName = m.LogName
333 r.ResolverType = m.ResolverType
334 r.SessionID = m.SessionID
335 r.StoreID = m.StoreID
336 if rhs := m.SourcePolicies; rhs != nil {
337 tmpContainer := make([]*pb1.Policy, len(rhs))
338 for k, v := range rhs {
339 tmpContainer[k] = v.CloneVT()
340 }
341 r.SourcePolicies = tmpContainer
342 }
343 if len(m.unknownFields) > 0 {
344 r.unknownFields = make([]byte, len(m.unknownFields))
345 copy(r.unknownFields, m.unknownFields)
346 }
347 return r
348 }
349
350 func (m *ResolveImageConfigRequest) CloneMessageVT() proto.Message {
351 return m.CloneVT()
352 }
353
354 func (m *ResolveImageConfigResponse) CloneVT() *ResolveImageConfigResponse {
355 if m == nil {
356 return (*ResolveImageConfigResponse)(nil)
357 }
358 r := new(ResolveImageConfigResponse)
359 r.Digest = m.Digest
360 r.Ref = m.Ref
361 if rhs := m.Config; rhs != nil {
362 tmpBytes := make([]byte, len(rhs))
363 copy(tmpBytes, rhs)
364 r.Config = tmpBytes
365 }
366 if len(m.unknownFields) > 0 {
367 r.unknownFields = make([]byte, len(m.unknownFields))
368 copy(r.unknownFields, m.unknownFields)
369 }
370 return r
371 }
372
373 func (m *ResolveImageConfigResponse) CloneMessageVT() proto.Message {
374 return m.CloneVT()
375 }
376
377 func (m *ResolveSourceMetaRequest) CloneVT() *ResolveSourceMetaRequest {
378 if m == nil {
379 return (*ResolveSourceMetaRequest)(nil)
380 }
381 r := new(ResolveSourceMetaRequest)
382 r.Source = m.Source.CloneVT()
383 r.Platform = m.Platform.CloneVT()
384 r.LogName = m.LogName
385 r.ResolveMode = m.ResolveMode
386 if rhs := m.SourcePolicies; rhs != nil {
387 tmpContainer := make([]*pb1.Policy, len(rhs))
388 for k, v := range rhs {
389 tmpContainer[k] = v.CloneVT()
390 }
391 r.SourcePolicies = tmpContainer
392 }
393 if len(m.unknownFields) > 0 {
394 r.unknownFields = make([]byte, len(m.unknownFields))
395 copy(r.unknownFields, m.unknownFields)
396 }
397 return r
398 }
399
400 func (m *ResolveSourceMetaRequest) CloneMessageVT() proto.Message {
401 return m.CloneVT()
402 }
403
404 func (m *ResolveSourceMetaResponse) CloneVT() *ResolveSourceMetaResponse {
405 if m == nil {
406 return (*ResolveSourceMetaResponse)(nil)
407 }
408 r := new(ResolveSourceMetaResponse)
409 r.Source = m.Source.CloneVT()
410 r.Image = m.Image.CloneVT()
411 if len(m.unknownFields) > 0 {
412 r.unknownFields = make([]byte, len(m.unknownFields))
413 copy(r.unknownFields, m.unknownFields)
414 }
415 return r
416 }
417
418 func (m *ResolveSourceMetaResponse) CloneMessageVT() proto.Message {
419 return m.CloneVT()
420 }
421
422 func (m *ResolveSourceImageResponse) CloneVT() *ResolveSourceImageResponse {
423 if m == nil {
424 return (*ResolveSourceImageResponse)(nil)
425 }
426 r := new(ResolveSourceImageResponse)
427 r.Digest = m.Digest
428 if rhs := m.Config; rhs != nil {
429 tmpBytes := make([]byte, len(rhs))
430 copy(tmpBytes, rhs)
431 r.Config = tmpBytes
432 }
433 if len(m.unknownFields) > 0 {
434 r.unknownFields = make([]byte, len(m.unknownFields))
435 copy(r.unknownFields, m.unknownFields)
436 }
437 return r
438 }
439
440 func (m *ResolveSourceImageResponse) CloneMessageVT() proto.Message {
441 return m.CloneVT()
442 }
443
444 func (m *SolveRequest) CloneVT() *SolveRequest {
445 if m == nil {
446 return (*SolveRequest)(nil)
447 }
448 r := new(SolveRequest)
449 r.Definition = m.Definition.CloneVT()
450 r.Frontend = m.Frontend
451 r.AllowResultReturn = m.AllowResultReturn
452 r.AllowResultArrayRef = m.AllowResultArrayRef
453 r.Final = m.Final
454 r.Evaluate = m.Evaluate
455 if rhs := m.FrontendOpt; rhs != nil {
456 tmpContainer := make(map[string]string, len(rhs))
457 for k, v := range rhs {
458 tmpContainer[k] = v
459 }
460 r.FrontendOpt = tmpContainer
461 }
462 if rhs := m.ExporterAttr; rhs != nil {
463 tmpBytes := make([]byte, len(rhs))
464 copy(tmpBytes, rhs)
465 r.ExporterAttr = tmpBytes
466 }
467 if rhs := m.CacheImports; rhs != nil {
468 tmpContainer := make([]*CacheOptionsEntry, len(rhs))
469 for k, v := range rhs {
470 tmpContainer[k] = v.CloneVT()
471 }
472 r.CacheImports = tmpContainer
473 }
474 if rhs := m.FrontendInputs; rhs != nil {
475 tmpContainer := make(map[string]*pb.Definition, len(rhs))
476 for k, v := range rhs {
477 tmpContainer[k] = v.CloneVT()
478 }
479 r.FrontendInputs = tmpContainer
480 }
481 if rhs := m.SourcePolicies; rhs != nil {
482 tmpContainer := make([]*pb1.Policy, len(rhs))
483 for k, v := range rhs {
484 tmpContainer[k] = v.CloneVT()
485 }
486 r.SourcePolicies = tmpContainer
487 }
488 if len(m.unknownFields) > 0 {
489 r.unknownFields = make([]byte, len(m.unknownFields))
490 copy(r.unknownFields, m.unknownFields)
491 }
492 return r
493 }
494
495 func (m *SolveRequest) CloneMessageVT() proto.Message {
496 return m.CloneVT()
497 }
498
499 func (m *CacheOptionsEntry) CloneVT() *CacheOptionsEntry {
500 if m == nil {
501 return (*CacheOptionsEntry)(nil)
502 }
503 r := new(CacheOptionsEntry)
504 r.Type = m.Type
505 if rhs := m.Attrs; rhs != nil {
506 tmpContainer := make(map[string]string, len(rhs))
507 for k, v := range rhs {
508 tmpContainer[k] = v
509 }
510 r.Attrs = tmpContainer
511 }
512 if len(m.unknownFields) > 0 {
513 r.unknownFields = make([]byte, len(m.unknownFields))
514 copy(r.unknownFields, m.unknownFields)
515 }
516 return r
517 }
518
519 func (m *CacheOptionsEntry) CloneMessageVT() proto.Message {
520 return m.CloneVT()
521 }
522
523 func (m *SolveResponse) CloneVT() *SolveResponse {
524 if m == nil {
525 return (*SolveResponse)(nil)
526 }
527 r := new(SolveResponse)
528 r.Ref = m.Ref
529 r.Result = m.Result.CloneVT()
530 if len(m.unknownFields) > 0 {
531 r.unknownFields = make([]byte, len(m.unknownFields))
532 copy(r.unknownFields, m.unknownFields)
533 }
534 return r
535 }
536
537 func (m *SolveResponse) CloneMessageVT() proto.Message {
538 return m.CloneVT()
539 }
540
541 func (m *ReadFileRequest) CloneVT() *ReadFileRequest {
542 if m == nil {
543 return (*ReadFileRequest)(nil)
544 }
545 r := new(ReadFileRequest)
546 r.Ref = m.Ref
547 r.FilePath = m.FilePath
548 r.Range = m.Range.CloneVT()
549 if len(m.unknownFields) > 0 {
550 r.unknownFields = make([]byte, len(m.unknownFields))
551 copy(r.unknownFields, m.unknownFields)
552 }
553 return r
554 }
555
556 func (m *ReadFileRequest) CloneMessageVT() proto.Message {
557 return m.CloneVT()
558 }
559
560 func (m *FileRange) CloneVT() *FileRange {
561 if m == nil {
562 return (*FileRange)(nil)
563 }
564 r := new(FileRange)
565 r.Offset = m.Offset
566 r.Length = m.Length
567 if len(m.unknownFields) > 0 {
568 r.unknownFields = make([]byte, len(m.unknownFields))
569 copy(r.unknownFields, m.unknownFields)
570 }
571 return r
572 }
573
574 func (m *FileRange) CloneMessageVT() proto.Message {
575 return m.CloneVT()
576 }
577
578 func (m *ReadFileResponse) CloneVT() *ReadFileResponse {
579 if m == nil {
580 return (*ReadFileResponse)(nil)
581 }
582 r := new(ReadFileResponse)
583 if rhs := m.Data; rhs != nil {
584 tmpBytes := make([]byte, len(rhs))
585 copy(tmpBytes, rhs)
586 r.Data = tmpBytes
587 }
588 if len(m.unknownFields) > 0 {
589 r.unknownFields = make([]byte, len(m.unknownFields))
590 copy(r.unknownFields, m.unknownFields)
591 }
592 return r
593 }
594
595 func (m *ReadFileResponse) CloneMessageVT() proto.Message {
596 return m.CloneVT()
597 }
598
599 func (m *ReadDirRequest) CloneVT() *ReadDirRequest {
600 if m == nil {
601 return (*ReadDirRequest)(nil)
602 }
603 r := new(ReadDirRequest)
604 r.Ref = m.Ref
605 r.DirPath = m.DirPath
606 r.IncludePattern = m.IncludePattern
607 if len(m.unknownFields) > 0 {
608 r.unknownFields = make([]byte, len(m.unknownFields))
609 copy(r.unknownFields, m.unknownFields)
610 }
611 return r
612 }
613
614 func (m *ReadDirRequest) CloneMessageVT() proto.Message {
615 return m.CloneVT()
616 }
617
618 func (m *ReadDirResponse) CloneVT() *ReadDirResponse {
619 if m == nil {
620 return (*ReadDirResponse)(nil)
621 }
622 r := new(ReadDirResponse)
623 if rhs := m.Entries; rhs != nil {
624 tmpContainer := make([]*types.Stat, len(rhs))
625 for k, v := range rhs {
626 if vtpb, ok := interface{}(v).(interface{ CloneVT() *types.Stat }); ok {
627 tmpContainer[k] = vtpb.CloneVT()
628 } else {
629 tmpContainer[k] = proto.Clone(v).(*types.Stat)
630 }
631 }
632 r.Entries = tmpContainer
633 }
634 if len(m.unknownFields) > 0 {
635 r.unknownFields = make([]byte, len(m.unknownFields))
636 copy(r.unknownFields, m.unknownFields)
637 }
638 return r
639 }
640
641 func (m *ReadDirResponse) CloneMessageVT() proto.Message {
642 return m.CloneVT()
643 }
644
645 func (m *StatFileRequest) CloneVT() *StatFileRequest {
646 if m == nil {
647 return (*StatFileRequest)(nil)
648 }
649 r := new(StatFileRequest)
650 r.Ref = m.Ref
651 r.Path = m.Path
652 if len(m.unknownFields) > 0 {
653 r.unknownFields = make([]byte, len(m.unknownFields))
654 copy(r.unknownFields, m.unknownFields)
655 }
656 return r
657 }
658
659 func (m *StatFileRequest) CloneMessageVT() proto.Message {
660 return m.CloneVT()
661 }
662
663 func (m *StatFileResponse) CloneVT() *StatFileResponse {
664 if m == nil {
665 return (*StatFileResponse)(nil)
666 }
667 r := new(StatFileResponse)
668 if rhs := m.Stat; rhs != nil {
669 if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *types.Stat }); ok {
670 r.Stat = vtpb.CloneVT()
671 } else {
672 r.Stat = proto.Clone(rhs).(*types.Stat)
673 }
674 }
675 if len(m.unknownFields) > 0 {
676 r.unknownFields = make([]byte, len(m.unknownFields))
677 copy(r.unknownFields, m.unknownFields)
678 }
679 return r
680 }
681
682 func (m *StatFileResponse) CloneMessageVT() proto.Message {
683 return m.CloneVT()
684 }
685
686 func (m *EvaluateRequest) CloneVT() *EvaluateRequest {
687 if m == nil {
688 return (*EvaluateRequest)(nil)
689 }
690 r := new(EvaluateRequest)
691 r.Ref = m.Ref
692 if len(m.unknownFields) > 0 {
693 r.unknownFields = make([]byte, len(m.unknownFields))
694 copy(r.unknownFields, m.unknownFields)
695 }
696 return r
697 }
698
699 func (m *EvaluateRequest) CloneMessageVT() proto.Message {
700 return m.CloneVT()
701 }
702
703 func (m *EvaluateResponse) CloneVT() *EvaluateResponse {
704 if m == nil {
705 return (*EvaluateResponse)(nil)
706 }
707 r := new(EvaluateResponse)
708 if len(m.unknownFields) > 0 {
709 r.unknownFields = make([]byte, len(m.unknownFields))
710 copy(r.unknownFields, m.unknownFields)
711 }
712 return r
713 }
714
715 func (m *EvaluateResponse) CloneMessageVT() proto.Message {
716 return m.CloneVT()
717 }
718
719 func (m *PingRequest) CloneVT() *PingRequest {
720 if m == nil {
721 return (*PingRequest)(nil)
722 }
723 r := new(PingRequest)
724 if len(m.unknownFields) > 0 {
725 r.unknownFields = make([]byte, len(m.unknownFields))
726 copy(r.unknownFields, m.unknownFields)
727 }
728 return r
729 }
730
731 func (m *PingRequest) CloneMessageVT() proto.Message {
732 return m.CloneVT()
733 }
734
735 func (m *PongResponse) CloneVT() *PongResponse {
736 if m == nil {
737 return (*PongResponse)(nil)
738 }
739 r := new(PongResponse)
740 if rhs := m.FrontendAPICaps; rhs != nil {
741 tmpContainer := make([]*pb2.APICap, len(rhs))
742 for k, v := range rhs {
743 tmpContainer[k] = v.CloneVT()
744 }
745 r.FrontendAPICaps = tmpContainer
746 }
747 if rhs := m.LLBCaps; rhs != nil {
748 tmpContainer := make([]*pb2.APICap, len(rhs))
749 for k, v := range rhs {
750 tmpContainer[k] = v.CloneVT()
751 }
752 r.LLBCaps = tmpContainer
753 }
754 if rhs := m.Workers; rhs != nil {
755 tmpContainer := make([]*types1.WorkerRecord, len(rhs))
756 for k, v := range rhs {
757 tmpContainer[k] = v.CloneVT()
758 }
759 r.Workers = tmpContainer
760 }
761 if len(m.unknownFields) > 0 {
762 r.unknownFields = make([]byte, len(m.unknownFields))
763 copy(r.unknownFields, m.unknownFields)
764 }
765 return r
766 }
767
768 func (m *PongResponse) CloneMessageVT() proto.Message {
769 return m.CloneVT()
770 }
771
772 func (m *WarnRequest) CloneVT() *WarnRequest {
773 if m == nil {
774 return (*WarnRequest)(nil)
775 }
776 r := new(WarnRequest)
777 r.Digest = m.Digest
778 r.Level = m.Level
779 r.Url = m.Url
780 r.Info = m.Info.CloneVT()
781 if rhs := m.Short; rhs != nil {
782 tmpBytes := make([]byte, len(rhs))
783 copy(tmpBytes, rhs)
784 r.Short = tmpBytes
785 }
786 if rhs := m.Detail; rhs != nil {
787 tmpContainer := make([][]byte, len(rhs))
788 for k, v := range rhs {
789 tmpBytes := make([]byte, len(v))
790 copy(tmpBytes, v)
791 tmpContainer[k] = tmpBytes
792 }
793 r.Detail = tmpContainer
794 }
795 if rhs := m.Ranges; rhs != nil {
796 tmpContainer := make([]*pb.Range, len(rhs))
797 for k, v := range rhs {
798 tmpContainer[k] = v.CloneVT()
799 }
800 r.Ranges = tmpContainer
801 }
802 if len(m.unknownFields) > 0 {
803 r.unknownFields = make([]byte, len(m.unknownFields))
804 copy(r.unknownFields, m.unknownFields)
805 }
806 return r
807 }
808
809 func (m *WarnRequest) CloneMessageVT() proto.Message {
810 return m.CloneVT()
811 }
812
813 func (m *WarnResponse) CloneVT() *WarnResponse {
814 if m == nil {
815 return (*WarnResponse)(nil)
816 }
817 r := new(WarnResponse)
818 if len(m.unknownFields) > 0 {
819 r.unknownFields = make([]byte, len(m.unknownFields))
820 copy(r.unknownFields, m.unknownFields)
821 }
822 return r
823 }
824
825 func (m *WarnResponse) CloneMessageVT() proto.Message {
826 return m.CloneVT()
827 }
828
829 func (m *NewContainerRequest) CloneVT() *NewContainerRequest {
830 if m == nil {
831 return (*NewContainerRequest)(nil)
832 }
833 r := new(NewContainerRequest)
834 r.ContainerID = m.ContainerID
835 r.Network = m.Network
836 r.Platform = m.Platform.CloneVT()
837 r.Constraints = m.Constraints.CloneVT()
838 r.Hostname = m.Hostname
839 if rhs := m.Mounts; rhs != nil {
840 tmpContainer := make([]*pb.Mount, len(rhs))
841 for k, v := range rhs {
842 tmpContainer[k] = v.CloneVT()
843 }
844 r.Mounts = tmpContainer
845 }
846 if rhs := m.ExtraHosts; rhs != nil {
847 tmpContainer := make([]*pb.HostIP, len(rhs))
848 for k, v := range rhs {
849 tmpContainer[k] = v.CloneVT()
850 }
851 r.ExtraHosts = tmpContainer
852 }
853 if len(m.unknownFields) > 0 {
854 r.unknownFields = make([]byte, len(m.unknownFields))
855 copy(r.unknownFields, m.unknownFields)
856 }
857 return r
858 }
859
860 func (m *NewContainerRequest) CloneMessageVT() proto.Message {
861 return m.CloneVT()
862 }
863
864 func (m *NewContainerResponse) CloneVT() *NewContainerResponse {
865 if m == nil {
866 return (*NewContainerResponse)(nil)
867 }
868 r := new(NewContainerResponse)
869 if len(m.unknownFields) > 0 {
870 r.unknownFields = make([]byte, len(m.unknownFields))
871 copy(r.unknownFields, m.unknownFields)
872 }
873 return r
874 }
875
876 func (m *NewContainerResponse) CloneMessageVT() proto.Message {
877 return m.CloneVT()
878 }
879
880 func (m *ReleaseContainerRequest) CloneVT() *ReleaseContainerRequest {
881 if m == nil {
882 return (*ReleaseContainerRequest)(nil)
883 }
884 r := new(ReleaseContainerRequest)
885 r.ContainerID = m.ContainerID
886 if len(m.unknownFields) > 0 {
887 r.unknownFields = make([]byte, len(m.unknownFields))
888 copy(r.unknownFields, m.unknownFields)
889 }
890 return r
891 }
892
893 func (m *ReleaseContainerRequest) CloneMessageVT() proto.Message {
894 return m.CloneVT()
895 }
896
897 func (m *ReleaseContainerResponse) CloneVT() *ReleaseContainerResponse {
898 if m == nil {
899 return (*ReleaseContainerResponse)(nil)
900 }
901 r := new(ReleaseContainerResponse)
902 if len(m.unknownFields) > 0 {
903 r.unknownFields = make([]byte, len(m.unknownFields))
904 copy(r.unknownFields, m.unknownFields)
905 }
906 return r
907 }
908
909 func (m *ReleaseContainerResponse) CloneMessageVT() proto.Message {
910 return m.CloneVT()
911 }
912
913 func (m *ExecMessage) CloneVT() *ExecMessage {
914 if m == nil {
915 return (*ExecMessage)(nil)
916 }
917 r := new(ExecMessage)
918 r.ProcessID = m.ProcessID
919 if m.Input != nil {
920 r.Input = m.Input.(interface{ CloneVT() isExecMessage_Input }).CloneVT()
921 }
922 if len(m.unknownFields) > 0 {
923 r.unknownFields = make([]byte, len(m.unknownFields))
924 copy(r.unknownFields, m.unknownFields)
925 }
926 return r
927 }
928
929 func (m *ExecMessage) CloneMessageVT() proto.Message {
930 return m.CloneVT()
931 }
932
933 func (m *ExecMessage_Init) CloneVT() isExecMessage_Input {
934 if m == nil {
935 return (*ExecMessage_Init)(nil)
936 }
937 r := new(ExecMessage_Init)
938 r.Init = m.Init.CloneVT()
939 return r
940 }
941
942 func (m *ExecMessage_File) CloneVT() isExecMessage_Input {
943 if m == nil {
944 return (*ExecMessage_File)(nil)
945 }
946 r := new(ExecMessage_File)
947 r.File = m.File.CloneVT()
948 return r
949 }
950
951 func (m *ExecMessage_Resize) CloneVT() isExecMessage_Input {
952 if m == nil {
953 return (*ExecMessage_Resize)(nil)
954 }
955 r := new(ExecMessage_Resize)
956 r.Resize = m.Resize.CloneVT()
957 return r
958 }
959
960 func (m *ExecMessage_Started) CloneVT() isExecMessage_Input {
961 if m == nil {
962 return (*ExecMessage_Started)(nil)
963 }
964 r := new(ExecMessage_Started)
965 r.Started = m.Started.CloneVT()
966 return r
967 }
968
969 func (m *ExecMessage_Exit) CloneVT() isExecMessage_Input {
970 if m == nil {
971 return (*ExecMessage_Exit)(nil)
972 }
973 r := new(ExecMessage_Exit)
974 r.Exit = m.Exit.CloneVT()
975 return r
976 }
977
978 func (m *ExecMessage_Done) CloneVT() isExecMessage_Input {
979 if m == nil {
980 return (*ExecMessage_Done)(nil)
981 }
982 r := new(ExecMessage_Done)
983 r.Done = m.Done.CloneVT()
984 return r
985 }
986
987 func (m *ExecMessage_Signal) CloneVT() isExecMessage_Input {
988 if m == nil {
989 return (*ExecMessage_Signal)(nil)
990 }
991 r := new(ExecMessage_Signal)
992 r.Signal = m.Signal.CloneVT()
993 return r
994 }
995
996 func (m *InitMessage) CloneVT() *InitMessage {
997 if m == nil {
998 return (*InitMessage)(nil)
999 }
1000 r := new(InitMessage)
1001 r.ContainerID = m.ContainerID
1002 r.Meta = m.Meta.CloneVT()
1003 r.Tty = m.Tty
1004 r.Security = m.Security
1005 if rhs := m.Fds; rhs != nil {
1006 tmpContainer := make([]uint32, len(rhs))
1007 copy(tmpContainer, rhs)
1008 r.Fds = tmpContainer
1009 }
1010 if rhs := m.Secretenv; rhs != nil {
1011 tmpContainer := make([]*pb.SecretEnv, len(rhs))
1012 for k, v := range rhs {
1013 tmpContainer[k] = v.CloneVT()
1014 }
1015 r.Secretenv = tmpContainer
1016 }
1017 if len(m.unknownFields) > 0 {
1018 r.unknownFields = make([]byte, len(m.unknownFields))
1019 copy(r.unknownFields, m.unknownFields)
1020 }
1021 return r
1022 }
1023
1024 func (m *InitMessage) CloneMessageVT() proto.Message {
1025 return m.CloneVT()
1026 }
1027
1028 func (m *ExitMessage) CloneVT() *ExitMessage {
1029 if m == nil {
1030 return (*ExitMessage)(nil)
1031 }
1032 r := new(ExitMessage)
1033 r.Code = m.Code
1034 if rhs := m.Error; rhs != nil {
1035 if vtpb, ok := interface{}(rhs).(interface{ CloneVT() *status.Status }); ok {
1036 r.Error = vtpb.CloneVT()
1037 } else {
1038 r.Error = proto.Clone(rhs).(*status.Status)
1039 }
1040 }
1041 if len(m.unknownFields) > 0 {
1042 r.unknownFields = make([]byte, len(m.unknownFields))
1043 copy(r.unknownFields, m.unknownFields)
1044 }
1045 return r
1046 }
1047
1048 func (m *ExitMessage) CloneMessageVT() proto.Message {
1049 return m.CloneVT()
1050 }
1051
1052 func (m *StartedMessage) CloneVT() *StartedMessage {
1053 if m == nil {
1054 return (*StartedMessage)(nil)
1055 }
1056 r := new(StartedMessage)
1057 if len(m.unknownFields) > 0 {
1058 r.unknownFields = make([]byte, len(m.unknownFields))
1059 copy(r.unknownFields, m.unknownFields)
1060 }
1061 return r
1062 }
1063
1064 func (m *StartedMessage) CloneMessageVT() proto.Message {
1065 return m.CloneVT()
1066 }
1067
1068 func (m *DoneMessage) CloneVT() *DoneMessage {
1069 if m == nil {
1070 return (*DoneMessage)(nil)
1071 }
1072 r := new(DoneMessage)
1073 if len(m.unknownFields) > 0 {
1074 r.unknownFields = make([]byte, len(m.unknownFields))
1075 copy(r.unknownFields, m.unknownFields)
1076 }
1077 return r
1078 }
1079
1080 func (m *DoneMessage) CloneMessageVT() proto.Message {
1081 return m.CloneVT()
1082 }
1083
1084 func (m *FdMessage) CloneVT() *FdMessage {
1085 if m == nil {
1086 return (*FdMessage)(nil)
1087 }
1088 r := new(FdMessage)
1089 r.Fd = m.Fd
1090 r.EOF = m.EOF
1091 if rhs := m.Data; rhs != nil {
1092 tmpBytes := make([]byte, len(rhs))
1093 copy(tmpBytes, rhs)
1094 r.Data = tmpBytes
1095 }
1096 if len(m.unknownFields) > 0 {
1097 r.unknownFields = make([]byte, len(m.unknownFields))
1098 copy(r.unknownFields, m.unknownFields)
1099 }
1100 return r
1101 }
1102
1103 func (m *FdMessage) CloneMessageVT() proto.Message {
1104 return m.CloneVT()
1105 }
1106
1107 func (m *ResizeMessage) CloneVT() *ResizeMessage {
1108 if m == nil {
1109 return (*ResizeMessage)(nil)
1110 }
1111 r := new(ResizeMessage)
1112 r.Rows = m.Rows
1113 r.Cols = m.Cols
1114 if len(m.unknownFields) > 0 {
1115 r.unknownFields = make([]byte, len(m.unknownFields))
1116 copy(r.unknownFields, m.unknownFields)
1117 }
1118 return r
1119 }
1120
1121 func (m *ResizeMessage) CloneMessageVT() proto.Message {
1122 return m.CloneVT()
1123 }
1124
1125 func (m *SignalMessage) CloneVT() *SignalMessage {
1126 if m == nil {
1127 return (*SignalMessage)(nil)
1128 }
1129 r := new(SignalMessage)
1130 r.Name = m.Name
1131 if len(m.unknownFields) > 0 {
1132 r.unknownFields = make([]byte, len(m.unknownFields))
1133 copy(r.unknownFields, m.unknownFields)
1134 }
1135 return r
1136 }
1137
1138 func (m *SignalMessage) CloneMessageVT() proto.Message {
1139 return m.CloneVT()
1140 }
1141
1142 func (this *Result) EqualVT(that *Result) bool {
1143 if this == that {
1144 return true
1145 } else if this == nil || that == nil {
1146 return false
1147 }
1148 if this.Result == nil && that.Result != nil {
1149 return false
1150 } else if this.Result != nil {
1151 if that.Result == nil {
1152 return false
1153 }
1154 if !this.Result.(interface{ EqualVT(isResult_Result) bool }).EqualVT(that.Result) {
1155 return false
1156 }
1157 }
1158 if len(this.Metadata) != len(that.Metadata) {
1159 return false
1160 }
1161 for i, vx := range this.Metadata {
1162 vy, ok := that.Metadata[i]
1163 if !ok {
1164 return false
1165 }
1166 if string(vx) != string(vy) {
1167 return false
1168 }
1169 }
1170 if len(this.Attestations) != len(that.Attestations) {
1171 return false
1172 }
1173 for i, vx := range this.Attestations {
1174 vy, ok := that.Attestations[i]
1175 if !ok {
1176 return false
1177 }
1178 if p, q := vx, vy; p != q {
1179 if p == nil {
1180 p = &Attestations{}
1181 }
1182 if q == nil {
1183 q = &Attestations{}
1184 }
1185 if !p.EqualVT(q) {
1186 return false
1187 }
1188 }
1189 }
1190 return string(this.unknownFields) == string(that.unknownFields)
1191 }
1192
1193 func (this *Result) EqualMessageVT(thatMsg proto.Message) bool {
1194 that, ok := thatMsg.(*Result)
1195 if !ok {
1196 return false
1197 }
1198 return this.EqualVT(that)
1199 }
1200 func (this *Result_RefDeprecated) EqualVT(thatIface isResult_Result) bool {
1201 that, ok := thatIface.(*Result_RefDeprecated)
1202 if !ok {
1203 return false
1204 }
1205 if this == that {
1206 return true
1207 }
1208 if this == nil && that != nil || this != nil && that == nil {
1209 return false
1210 }
1211 if this.RefDeprecated != that.RefDeprecated {
1212 return false
1213 }
1214 return true
1215 }
1216
1217 func (this *Result_RefsDeprecated) EqualVT(thatIface isResult_Result) bool {
1218 that, ok := thatIface.(*Result_RefsDeprecated)
1219 if !ok {
1220 return false
1221 }
1222 if this == that {
1223 return true
1224 }
1225 if this == nil && that != nil || this != nil && that == nil {
1226 return false
1227 }
1228 if p, q := this.RefsDeprecated, that.RefsDeprecated; p != q {
1229 if p == nil {
1230 p = &RefMapDeprecated{}
1231 }
1232 if q == nil {
1233 q = &RefMapDeprecated{}
1234 }
1235 if !p.EqualVT(q) {
1236 return false
1237 }
1238 }
1239 return true
1240 }
1241
1242 func (this *Result_Ref) EqualVT(thatIface isResult_Result) bool {
1243 that, ok := thatIface.(*Result_Ref)
1244 if !ok {
1245 return false
1246 }
1247 if this == that {
1248 return true
1249 }
1250 if this == nil && that != nil || this != nil && that == nil {
1251 return false
1252 }
1253 if p, q := this.Ref, that.Ref; p != q {
1254 if p == nil {
1255 p = &Ref{}
1256 }
1257 if q == nil {
1258 q = &Ref{}
1259 }
1260 if !p.EqualVT(q) {
1261 return false
1262 }
1263 }
1264 return true
1265 }
1266
1267 func (this *Result_Refs) EqualVT(thatIface isResult_Result) bool {
1268 that, ok := thatIface.(*Result_Refs)
1269 if !ok {
1270 return false
1271 }
1272 if this == that {
1273 return true
1274 }
1275 if this == nil && that != nil || this != nil && that == nil {
1276 return false
1277 }
1278 if p, q := this.Refs, that.Refs; p != q {
1279 if p == nil {
1280 p = &RefMap{}
1281 }
1282 if q == nil {
1283 q = &RefMap{}
1284 }
1285 if !p.EqualVT(q) {
1286 return false
1287 }
1288 }
1289 return true
1290 }
1291
1292 func (this *RefMapDeprecated) EqualVT(that *RefMapDeprecated) bool {
1293 if this == that {
1294 return true
1295 } else if this == nil || that == nil {
1296 return false
1297 }
1298 if len(this.Refs) != len(that.Refs) {
1299 return false
1300 }
1301 for i, vx := range this.Refs {
1302 vy, ok := that.Refs[i]
1303 if !ok {
1304 return false
1305 }
1306 if vx != vy {
1307 return false
1308 }
1309 }
1310 return string(this.unknownFields) == string(that.unknownFields)
1311 }
1312
1313 func (this *RefMapDeprecated) EqualMessageVT(thatMsg proto.Message) bool {
1314 that, ok := thatMsg.(*RefMapDeprecated)
1315 if !ok {
1316 return false
1317 }
1318 return this.EqualVT(that)
1319 }
1320 func (this *Ref) EqualVT(that *Ref) bool {
1321 if this == that {
1322 return true
1323 } else if this == nil || that == nil {
1324 return false
1325 }
1326 if this.Id != that.Id {
1327 return false
1328 }
1329 if !this.Def.EqualVT(that.Def) {
1330 return false
1331 }
1332 return string(this.unknownFields) == string(that.unknownFields)
1333 }
1334
1335 func (this *Ref) EqualMessageVT(thatMsg proto.Message) bool {
1336 that, ok := thatMsg.(*Ref)
1337 if !ok {
1338 return false
1339 }
1340 return this.EqualVT(that)
1341 }
1342 func (this *RefMap) EqualVT(that *RefMap) bool {
1343 if this == that {
1344 return true
1345 } else if this == nil || that == nil {
1346 return false
1347 }
1348 if len(this.Refs) != len(that.Refs) {
1349 return false
1350 }
1351 for i, vx := range this.Refs {
1352 vy, ok := that.Refs[i]
1353 if !ok {
1354 return false
1355 }
1356 if p, q := vx, vy; p != q {
1357 if p == nil {
1358 p = &Ref{}
1359 }
1360 if q == nil {
1361 q = &Ref{}
1362 }
1363 if !p.EqualVT(q) {
1364 return false
1365 }
1366 }
1367 }
1368 return string(this.unknownFields) == string(that.unknownFields)
1369 }
1370
1371 func (this *RefMap) EqualMessageVT(thatMsg proto.Message) bool {
1372 that, ok := thatMsg.(*RefMap)
1373 if !ok {
1374 return false
1375 }
1376 return this.EqualVT(that)
1377 }
1378 func (this *Attestations) EqualVT(that *Attestations) bool {
1379 if this == that {
1380 return true
1381 } else if this == nil || that == nil {
1382 return false
1383 }
1384 if len(this.Attestation) != len(that.Attestation) {
1385 return false
1386 }
1387 for i, vx := range this.Attestation {
1388 vy := that.Attestation[i]
1389 if p, q := vx, vy; p != q {
1390 if p == nil {
1391 p = &Attestation{}
1392 }
1393 if q == nil {
1394 q = &Attestation{}
1395 }
1396 if !p.EqualVT(q) {
1397 return false
1398 }
1399 }
1400 }
1401 return string(this.unknownFields) == string(that.unknownFields)
1402 }
1403
1404 func (this *Attestations) EqualMessageVT(thatMsg proto.Message) bool {
1405 that, ok := thatMsg.(*Attestations)
1406 if !ok {
1407 return false
1408 }
1409 return this.EqualVT(that)
1410 }
1411 func (this *Attestation) EqualVT(that *Attestation) bool {
1412 if this == that {
1413 return true
1414 } else if this == nil || that == nil {
1415 return false
1416 }
1417 if this.Kind != that.Kind {
1418 return false
1419 }
1420 if len(this.Metadata) != len(that.Metadata) {
1421 return false
1422 }
1423 for i, vx := range this.Metadata {
1424 vy, ok := that.Metadata[i]
1425 if !ok {
1426 return false
1427 }
1428 if string(vx) != string(vy) {
1429 return false
1430 }
1431 }
1432 if !this.Ref.EqualVT(that.Ref) {
1433 return false
1434 }
1435 if this.Path != that.Path {
1436 return false
1437 }
1438 if this.InTotoPredicateType != that.InTotoPredicateType {
1439 return false
1440 }
1441 if len(this.InTotoSubjects) != len(that.InTotoSubjects) {
1442 return false
1443 }
1444 for i, vx := range this.InTotoSubjects {
1445 vy := that.InTotoSubjects[i]
1446 if p, q := vx, vy; p != q {
1447 if p == nil {
1448 p = &InTotoSubject{}
1449 }
1450 if q == nil {
1451 q = &InTotoSubject{}
1452 }
1453 if !p.EqualVT(q) {
1454 return false
1455 }
1456 }
1457 }
1458 return string(this.unknownFields) == string(that.unknownFields)
1459 }
1460
1461 func (this *Attestation) EqualMessageVT(thatMsg proto.Message) bool {
1462 that, ok := thatMsg.(*Attestation)
1463 if !ok {
1464 return false
1465 }
1466 return this.EqualVT(that)
1467 }
1468 func (this *InTotoSubject) EqualVT(that *InTotoSubject) bool {
1469 if this == that {
1470 return true
1471 } else if this == nil || that == nil {
1472 return false
1473 }
1474 if this.Kind != that.Kind {
1475 return false
1476 }
1477 if len(this.Digest) != len(that.Digest) {
1478 return false
1479 }
1480 for i, vx := range this.Digest {
1481 vy := that.Digest[i]
1482 if vx != vy {
1483 return false
1484 }
1485 }
1486 if this.Name != that.Name {
1487 return false
1488 }
1489 return string(this.unknownFields) == string(that.unknownFields)
1490 }
1491
1492 func (this *InTotoSubject) EqualMessageVT(thatMsg proto.Message) bool {
1493 that, ok := thatMsg.(*InTotoSubject)
1494 if !ok {
1495 return false
1496 }
1497 return this.EqualVT(that)
1498 }
1499 func (this *ReturnRequest) EqualVT(that *ReturnRequest) bool {
1500 if this == that {
1501 return true
1502 } else if this == nil || that == nil {
1503 return false
1504 }
1505 if !this.Result.EqualVT(that.Result) {
1506 return false
1507 }
1508 if equal, ok := interface{}(this.Error).(interface{ EqualVT(*status.Status) bool }); ok {
1509 if !equal.EqualVT(that.Error) {
1510 return false
1511 }
1512 } else if !proto.Equal(this.Error, that.Error) {
1513 return false
1514 }
1515 return string(this.unknownFields) == string(that.unknownFields)
1516 }
1517
1518 func (this *ReturnRequest) EqualMessageVT(thatMsg proto.Message) bool {
1519 that, ok := thatMsg.(*ReturnRequest)
1520 if !ok {
1521 return false
1522 }
1523 return this.EqualVT(that)
1524 }
1525 func (this *ReturnResponse) EqualVT(that *ReturnResponse) bool {
1526 if this == that {
1527 return true
1528 } else if this == nil || that == nil {
1529 return false
1530 }
1531 return string(this.unknownFields) == string(that.unknownFields)
1532 }
1533
1534 func (this *ReturnResponse) EqualMessageVT(thatMsg proto.Message) bool {
1535 that, ok := thatMsg.(*ReturnResponse)
1536 if !ok {
1537 return false
1538 }
1539 return this.EqualVT(that)
1540 }
1541 func (this *InputsRequest) EqualVT(that *InputsRequest) bool {
1542 if this == that {
1543 return true
1544 } else if this == nil || that == nil {
1545 return false
1546 }
1547 return string(this.unknownFields) == string(that.unknownFields)
1548 }
1549
1550 func (this *InputsRequest) EqualMessageVT(thatMsg proto.Message) bool {
1551 that, ok := thatMsg.(*InputsRequest)
1552 if !ok {
1553 return false
1554 }
1555 return this.EqualVT(that)
1556 }
1557 func (this *InputsResponse) EqualVT(that *InputsResponse) bool {
1558 if this == that {
1559 return true
1560 } else if this == nil || that == nil {
1561 return false
1562 }
1563 if len(this.Definitions) != len(that.Definitions) {
1564 return false
1565 }
1566 for i, vx := range this.Definitions {
1567 vy, ok := that.Definitions[i]
1568 if !ok {
1569 return false
1570 }
1571 if p, q := vx, vy; p != q {
1572 if p == nil {
1573 p = &pb.Definition{}
1574 }
1575 if q == nil {
1576 q = &pb.Definition{}
1577 }
1578 if !p.EqualVT(q) {
1579 return false
1580 }
1581 }
1582 }
1583 return string(this.unknownFields) == string(that.unknownFields)
1584 }
1585
1586 func (this *InputsResponse) EqualMessageVT(thatMsg proto.Message) bool {
1587 that, ok := thatMsg.(*InputsResponse)
1588 if !ok {
1589 return false
1590 }
1591 return this.EqualVT(that)
1592 }
1593 func (this *ResolveImageConfigRequest) EqualVT(that *ResolveImageConfigRequest) bool {
1594 if this == that {
1595 return true
1596 } else if this == nil || that == nil {
1597 return false
1598 }
1599 if this.Ref != that.Ref {
1600 return false
1601 }
1602 if !this.Platform.EqualVT(that.Platform) {
1603 return false
1604 }
1605 if this.ResolveMode != that.ResolveMode {
1606 return false
1607 }
1608 if this.LogName != that.LogName {
1609 return false
1610 }
1611 if this.ResolverType != that.ResolverType {
1612 return false
1613 }
1614 if this.SessionID != that.SessionID {
1615 return false
1616 }
1617 if this.StoreID != that.StoreID {
1618 return false
1619 }
1620 if len(this.SourcePolicies) != len(that.SourcePolicies) {
1621 return false
1622 }
1623 for i, vx := range this.SourcePolicies {
1624 vy := that.SourcePolicies[i]
1625 if p, q := vx, vy; p != q {
1626 if p == nil {
1627 p = &pb1.Policy{}
1628 }
1629 if q == nil {
1630 q = &pb1.Policy{}
1631 }
1632 if !p.EqualVT(q) {
1633 return false
1634 }
1635 }
1636 }
1637 return string(this.unknownFields) == string(that.unknownFields)
1638 }
1639
1640 func (this *ResolveImageConfigRequest) EqualMessageVT(thatMsg proto.Message) bool {
1641 that, ok := thatMsg.(*ResolveImageConfigRequest)
1642 if !ok {
1643 return false
1644 }
1645 return this.EqualVT(that)
1646 }
1647 func (this *ResolveImageConfigResponse) EqualVT(that *ResolveImageConfigResponse) bool {
1648 if this == that {
1649 return true
1650 } else if this == nil || that == nil {
1651 return false
1652 }
1653 if this.Digest != that.Digest {
1654 return false
1655 }
1656 if string(this.Config) != string(that.Config) {
1657 return false
1658 }
1659 if this.Ref != that.Ref {
1660 return false
1661 }
1662 return string(this.unknownFields) == string(that.unknownFields)
1663 }
1664
1665 func (this *ResolveImageConfigResponse) EqualMessageVT(thatMsg proto.Message) bool {
1666 that, ok := thatMsg.(*ResolveImageConfigResponse)
1667 if !ok {
1668 return false
1669 }
1670 return this.EqualVT(that)
1671 }
1672 func (this *ResolveSourceMetaRequest) EqualVT(that *ResolveSourceMetaRequest) bool {
1673 if this == that {
1674 return true
1675 } else if this == nil || that == nil {
1676 return false
1677 }
1678 if !this.Source.EqualVT(that.Source) {
1679 return false
1680 }
1681 if !this.Platform.EqualVT(that.Platform) {
1682 return false
1683 }
1684 if this.LogName != that.LogName {
1685 return false
1686 }
1687 if this.ResolveMode != that.ResolveMode {
1688 return false
1689 }
1690 if len(this.SourcePolicies) != len(that.SourcePolicies) {
1691 return false
1692 }
1693 for i, vx := range this.SourcePolicies {
1694 vy := that.SourcePolicies[i]
1695 if p, q := vx, vy; p != q {
1696 if p == nil {
1697 p = &pb1.Policy{}
1698 }
1699 if q == nil {
1700 q = &pb1.Policy{}
1701 }
1702 if !p.EqualVT(q) {
1703 return false
1704 }
1705 }
1706 }
1707 return string(this.unknownFields) == string(that.unknownFields)
1708 }
1709
1710 func (this *ResolveSourceMetaRequest) EqualMessageVT(thatMsg proto.Message) bool {
1711 that, ok := thatMsg.(*ResolveSourceMetaRequest)
1712 if !ok {
1713 return false
1714 }
1715 return this.EqualVT(that)
1716 }
1717 func (this *ResolveSourceMetaResponse) EqualVT(that *ResolveSourceMetaResponse) bool {
1718 if this == that {
1719 return true
1720 } else if this == nil || that == nil {
1721 return false
1722 }
1723 if !this.Source.EqualVT(that.Source) {
1724 return false
1725 }
1726 if !this.Image.EqualVT(that.Image) {
1727 return false
1728 }
1729 return string(this.unknownFields) == string(that.unknownFields)
1730 }
1731
1732 func (this *ResolveSourceMetaResponse) EqualMessageVT(thatMsg proto.Message) bool {
1733 that, ok := thatMsg.(*ResolveSourceMetaResponse)
1734 if !ok {
1735 return false
1736 }
1737 return this.EqualVT(that)
1738 }
1739 func (this *ResolveSourceImageResponse) EqualVT(that *ResolveSourceImageResponse) bool {
1740 if this == that {
1741 return true
1742 } else if this == nil || that == nil {
1743 return false
1744 }
1745 if this.Digest != that.Digest {
1746 return false
1747 }
1748 if string(this.Config) != string(that.Config) {
1749 return false
1750 }
1751 return string(this.unknownFields) == string(that.unknownFields)
1752 }
1753
1754 func (this *ResolveSourceImageResponse) EqualMessageVT(thatMsg proto.Message) bool {
1755 that, ok := thatMsg.(*ResolveSourceImageResponse)
1756 if !ok {
1757 return false
1758 }
1759 return this.EqualVT(that)
1760 }
1761 func (this *SolveRequest) EqualVT(that *SolveRequest) bool {
1762 if this == that {
1763 return true
1764 } else if this == nil || that == nil {
1765 return false
1766 }
1767 if !this.Definition.EqualVT(that.Definition) {
1768 return false
1769 }
1770 if this.Frontend != that.Frontend {
1771 return false
1772 }
1773 if len(this.FrontendOpt) != len(that.FrontendOpt) {
1774 return false
1775 }
1776 for i, vx := range this.FrontendOpt {
1777 vy, ok := that.FrontendOpt[i]
1778 if !ok {
1779 return false
1780 }
1781 if vx != vy {
1782 return false
1783 }
1784 }
1785 if this.AllowResultReturn != that.AllowResultReturn {
1786 return false
1787 }
1788 if this.AllowResultArrayRef != that.AllowResultArrayRef {
1789 return false
1790 }
1791 if this.Final != that.Final {
1792 return false
1793 }
1794 if string(this.ExporterAttr) != string(that.ExporterAttr) {
1795 return false
1796 }
1797 if len(this.CacheImports) != len(that.CacheImports) {
1798 return false
1799 }
1800 for i, vx := range this.CacheImports {
1801 vy := that.CacheImports[i]
1802 if p, q := vx, vy; p != q {
1803 if p == nil {
1804 p = &CacheOptionsEntry{}
1805 }
1806 if q == nil {
1807 q = &CacheOptionsEntry{}
1808 }
1809 if !p.EqualVT(q) {
1810 return false
1811 }
1812 }
1813 }
1814 if len(this.FrontendInputs) != len(that.FrontendInputs) {
1815 return false
1816 }
1817 for i, vx := range this.FrontendInputs {
1818 vy, ok := that.FrontendInputs[i]
1819 if !ok {
1820 return false
1821 }
1822 if p, q := vx, vy; p != q {
1823 if p == nil {
1824 p = &pb.Definition{}
1825 }
1826 if q == nil {
1827 q = &pb.Definition{}
1828 }
1829 if !p.EqualVT(q) {
1830 return false
1831 }
1832 }
1833 }
1834 if this.Evaluate != that.Evaluate {
1835 return false
1836 }
1837 if len(this.SourcePolicies) != len(that.SourcePolicies) {
1838 return false
1839 }
1840 for i, vx := range this.SourcePolicies {
1841 vy := that.SourcePolicies[i]
1842 if p, q := vx, vy; p != q {
1843 if p == nil {
1844 p = &pb1.Policy{}
1845 }
1846 if q == nil {
1847 q = &pb1.Policy{}
1848 }
1849 if !p.EqualVT(q) {
1850 return false
1851 }
1852 }
1853 }
1854 return string(this.unknownFields) == string(that.unknownFields)
1855 }
1856
1857 func (this *SolveRequest) EqualMessageVT(thatMsg proto.Message) bool {
1858 that, ok := thatMsg.(*SolveRequest)
1859 if !ok {
1860 return false
1861 }
1862 return this.EqualVT(that)
1863 }
1864 func (this *CacheOptionsEntry) EqualVT(that *CacheOptionsEntry) bool {
1865 if this == that {
1866 return true
1867 } else if this == nil || that == nil {
1868 return false
1869 }
1870 if this.Type != that.Type {
1871 return false
1872 }
1873 if len(this.Attrs) != len(that.Attrs) {
1874 return false
1875 }
1876 for i, vx := range this.Attrs {
1877 vy, ok := that.Attrs[i]
1878 if !ok {
1879 return false
1880 }
1881 if vx != vy {
1882 return false
1883 }
1884 }
1885 return string(this.unknownFields) == string(that.unknownFields)
1886 }
1887
1888 func (this *CacheOptionsEntry) EqualMessageVT(thatMsg proto.Message) bool {
1889 that, ok := thatMsg.(*CacheOptionsEntry)
1890 if !ok {
1891 return false
1892 }
1893 return this.EqualVT(that)
1894 }
1895 func (this *SolveResponse) EqualVT(that *SolveResponse) bool {
1896 if this == that {
1897 return true
1898 } else if this == nil || that == nil {
1899 return false
1900 }
1901 if this.Ref != that.Ref {
1902 return false
1903 }
1904 if !this.Result.EqualVT(that.Result) {
1905 return false
1906 }
1907 return string(this.unknownFields) == string(that.unknownFields)
1908 }
1909
1910 func (this *SolveResponse) EqualMessageVT(thatMsg proto.Message) bool {
1911 that, ok := thatMsg.(*SolveResponse)
1912 if !ok {
1913 return false
1914 }
1915 return this.EqualVT(that)
1916 }
1917 func (this *ReadFileRequest) EqualVT(that *ReadFileRequest) bool {
1918 if this == that {
1919 return true
1920 } else if this == nil || that == nil {
1921 return false
1922 }
1923 if this.Ref != that.Ref {
1924 return false
1925 }
1926 if this.FilePath != that.FilePath {
1927 return false
1928 }
1929 if !this.Range.EqualVT(that.Range) {
1930 return false
1931 }
1932 return string(this.unknownFields) == string(that.unknownFields)
1933 }
1934
1935 func (this *ReadFileRequest) EqualMessageVT(thatMsg proto.Message) bool {
1936 that, ok := thatMsg.(*ReadFileRequest)
1937 if !ok {
1938 return false
1939 }
1940 return this.EqualVT(that)
1941 }
1942 func (this *FileRange) EqualVT(that *FileRange) bool {
1943 if this == that {
1944 return true
1945 } else if this == nil || that == nil {
1946 return false
1947 }
1948 if this.Offset != that.Offset {
1949 return false
1950 }
1951 if this.Length != that.Length {
1952 return false
1953 }
1954 return string(this.unknownFields) == string(that.unknownFields)
1955 }
1956
1957 func (this *FileRange) EqualMessageVT(thatMsg proto.Message) bool {
1958 that, ok := thatMsg.(*FileRange)
1959 if !ok {
1960 return false
1961 }
1962 return this.EqualVT(that)
1963 }
1964 func (this *ReadFileResponse) EqualVT(that *ReadFileResponse) bool {
1965 if this == that {
1966 return true
1967 } else if this == nil || that == nil {
1968 return false
1969 }
1970 if string(this.Data) != string(that.Data) {
1971 return false
1972 }
1973 return string(this.unknownFields) == string(that.unknownFields)
1974 }
1975
1976 func (this *ReadFileResponse) EqualMessageVT(thatMsg proto.Message) bool {
1977 that, ok := thatMsg.(*ReadFileResponse)
1978 if !ok {
1979 return false
1980 }
1981 return this.EqualVT(that)
1982 }
1983 func (this *ReadDirRequest) EqualVT(that *ReadDirRequest) bool {
1984 if this == that {
1985 return true
1986 } else if this == nil || that == nil {
1987 return false
1988 }
1989 if this.Ref != that.Ref {
1990 return false
1991 }
1992 if this.DirPath != that.DirPath {
1993 return false
1994 }
1995 if this.IncludePattern != that.IncludePattern {
1996 return false
1997 }
1998 return string(this.unknownFields) == string(that.unknownFields)
1999 }
2000
2001 func (this *ReadDirRequest) EqualMessageVT(thatMsg proto.Message) bool {
2002 that, ok := thatMsg.(*ReadDirRequest)
2003 if !ok {
2004 return false
2005 }
2006 return this.EqualVT(that)
2007 }
2008 func (this *ReadDirResponse) EqualVT(that *ReadDirResponse) bool {
2009 if this == that {
2010 return true
2011 } else if this == nil || that == nil {
2012 return false
2013 }
2014 if len(this.Entries) != len(that.Entries) {
2015 return false
2016 }
2017 for i, vx := range this.Entries {
2018 vy := that.Entries[i]
2019 if p, q := vx, vy; p != q {
2020 if p == nil {
2021 p = &types.Stat{}
2022 }
2023 if q == nil {
2024 q = &types.Stat{}
2025 }
2026 if equal, ok := interface{}(p).(interface{ EqualVT(*types.Stat) bool }); ok {
2027 if !equal.EqualVT(q) {
2028 return false
2029 }
2030 } else if !proto.Equal(p, q) {
2031 return false
2032 }
2033 }
2034 }
2035 return string(this.unknownFields) == string(that.unknownFields)
2036 }
2037
2038 func (this *ReadDirResponse) EqualMessageVT(thatMsg proto.Message) bool {
2039 that, ok := thatMsg.(*ReadDirResponse)
2040 if !ok {
2041 return false
2042 }
2043 return this.EqualVT(that)
2044 }
2045 func (this *StatFileRequest) EqualVT(that *StatFileRequest) bool {
2046 if this == that {
2047 return true
2048 } else if this == nil || that == nil {
2049 return false
2050 }
2051 if this.Ref != that.Ref {
2052 return false
2053 }
2054 if this.Path != that.Path {
2055 return false
2056 }
2057 return string(this.unknownFields) == string(that.unknownFields)
2058 }
2059
2060 func (this *StatFileRequest) EqualMessageVT(thatMsg proto.Message) bool {
2061 that, ok := thatMsg.(*StatFileRequest)
2062 if !ok {
2063 return false
2064 }
2065 return this.EqualVT(that)
2066 }
2067 func (this *StatFileResponse) EqualVT(that *StatFileResponse) bool {
2068 if this == that {
2069 return true
2070 } else if this == nil || that == nil {
2071 return false
2072 }
2073 if equal, ok := interface{}(this.Stat).(interface{ EqualVT(*types.Stat) bool }); ok {
2074 if !equal.EqualVT(that.Stat) {
2075 return false
2076 }
2077 } else if !proto.Equal(this.Stat, that.Stat) {
2078 return false
2079 }
2080 return string(this.unknownFields) == string(that.unknownFields)
2081 }
2082
2083 func (this *StatFileResponse) EqualMessageVT(thatMsg proto.Message) bool {
2084 that, ok := thatMsg.(*StatFileResponse)
2085 if !ok {
2086 return false
2087 }
2088 return this.EqualVT(that)
2089 }
2090 func (this *EvaluateRequest) EqualVT(that *EvaluateRequest) bool {
2091 if this == that {
2092 return true
2093 } else if this == nil || that == nil {
2094 return false
2095 }
2096 if this.Ref != that.Ref {
2097 return false
2098 }
2099 return string(this.unknownFields) == string(that.unknownFields)
2100 }
2101
2102 func (this *EvaluateRequest) EqualMessageVT(thatMsg proto.Message) bool {
2103 that, ok := thatMsg.(*EvaluateRequest)
2104 if !ok {
2105 return false
2106 }
2107 return this.EqualVT(that)
2108 }
2109 func (this *EvaluateResponse) EqualVT(that *EvaluateResponse) bool {
2110 if this == that {
2111 return true
2112 } else if this == nil || that == nil {
2113 return false
2114 }
2115 return string(this.unknownFields) == string(that.unknownFields)
2116 }
2117
2118 func (this *EvaluateResponse) EqualMessageVT(thatMsg proto.Message) bool {
2119 that, ok := thatMsg.(*EvaluateResponse)
2120 if !ok {
2121 return false
2122 }
2123 return this.EqualVT(that)
2124 }
2125 func (this *PingRequest) EqualVT(that *PingRequest) bool {
2126 if this == that {
2127 return true
2128 } else if this == nil || that == nil {
2129 return false
2130 }
2131 return string(this.unknownFields) == string(that.unknownFields)
2132 }
2133
2134 func (this *PingRequest) EqualMessageVT(thatMsg proto.Message) bool {
2135 that, ok := thatMsg.(*PingRequest)
2136 if !ok {
2137 return false
2138 }
2139 return this.EqualVT(that)
2140 }
2141 func (this *PongResponse) EqualVT(that *PongResponse) bool {
2142 if this == that {
2143 return true
2144 } else if this == nil || that == nil {
2145 return false
2146 }
2147 if len(this.FrontendAPICaps) != len(that.FrontendAPICaps) {
2148 return false
2149 }
2150 for i, vx := range this.FrontendAPICaps {
2151 vy := that.FrontendAPICaps[i]
2152 if p, q := vx, vy; p != q {
2153 if p == nil {
2154 p = &pb2.APICap{}
2155 }
2156 if q == nil {
2157 q = &pb2.APICap{}
2158 }
2159 if !p.EqualVT(q) {
2160 return false
2161 }
2162 }
2163 }
2164 if len(this.LLBCaps) != len(that.LLBCaps) {
2165 return false
2166 }
2167 for i, vx := range this.LLBCaps {
2168 vy := that.LLBCaps[i]
2169 if p, q := vx, vy; p != q {
2170 if p == nil {
2171 p = &pb2.APICap{}
2172 }
2173 if q == nil {
2174 q = &pb2.APICap{}
2175 }
2176 if !p.EqualVT(q) {
2177 return false
2178 }
2179 }
2180 }
2181 if len(this.Workers) != len(that.Workers) {
2182 return false
2183 }
2184 for i, vx := range this.Workers {
2185 vy := that.Workers[i]
2186 if p, q := vx, vy; p != q {
2187 if p == nil {
2188 p = &types1.WorkerRecord{}
2189 }
2190 if q == nil {
2191 q = &types1.WorkerRecord{}
2192 }
2193 if !p.EqualVT(q) {
2194 return false
2195 }
2196 }
2197 }
2198 return string(this.unknownFields) == string(that.unknownFields)
2199 }
2200
2201 func (this *PongResponse) EqualMessageVT(thatMsg proto.Message) bool {
2202 that, ok := thatMsg.(*PongResponse)
2203 if !ok {
2204 return false
2205 }
2206 return this.EqualVT(that)
2207 }
2208 func (this *WarnRequest) EqualVT(that *WarnRequest) bool {
2209 if this == that {
2210 return true
2211 } else if this == nil || that == nil {
2212 return false
2213 }
2214 if this.Digest != that.Digest {
2215 return false
2216 }
2217 if this.Level != that.Level {
2218 return false
2219 }
2220 if string(this.Short) != string(that.Short) {
2221 return false
2222 }
2223 if len(this.Detail) != len(that.Detail) {
2224 return false
2225 }
2226 for i, vx := range this.Detail {
2227 vy := that.Detail[i]
2228 if string(vx) != string(vy) {
2229 return false
2230 }
2231 }
2232 if this.Url != that.Url {
2233 return false
2234 }
2235 if !this.Info.EqualVT(that.Info) {
2236 return false
2237 }
2238 if len(this.Ranges) != len(that.Ranges) {
2239 return false
2240 }
2241 for i, vx := range this.Ranges {
2242 vy := that.Ranges[i]
2243 if p, q := vx, vy; p != q {
2244 if p == nil {
2245 p = &pb.Range{}
2246 }
2247 if q == nil {
2248 q = &pb.Range{}
2249 }
2250 if !p.EqualVT(q) {
2251 return false
2252 }
2253 }
2254 }
2255 return string(this.unknownFields) == string(that.unknownFields)
2256 }
2257
2258 func (this *WarnRequest) EqualMessageVT(thatMsg proto.Message) bool {
2259 that, ok := thatMsg.(*WarnRequest)
2260 if !ok {
2261 return false
2262 }
2263 return this.EqualVT(that)
2264 }
2265 func (this *WarnResponse) EqualVT(that *WarnResponse) bool {
2266 if this == that {
2267 return true
2268 } else if this == nil || that == nil {
2269 return false
2270 }
2271 return string(this.unknownFields) == string(that.unknownFields)
2272 }
2273
2274 func (this *WarnResponse) EqualMessageVT(thatMsg proto.Message) bool {
2275 that, ok := thatMsg.(*WarnResponse)
2276 if !ok {
2277 return false
2278 }
2279 return this.EqualVT(that)
2280 }
2281 func (this *NewContainerRequest) EqualVT(that *NewContainerRequest) bool {
2282 if this == that {
2283 return true
2284 } else if this == nil || that == nil {
2285 return false
2286 }
2287 if this.ContainerID != that.ContainerID {
2288 return false
2289 }
2290 if len(this.Mounts) != len(that.Mounts) {
2291 return false
2292 }
2293 for i, vx := range this.Mounts {
2294 vy := that.Mounts[i]
2295 if p, q := vx, vy; p != q {
2296 if p == nil {
2297 p = &pb.Mount{}
2298 }
2299 if q == nil {
2300 q = &pb.Mount{}
2301 }
2302 if !p.EqualVT(q) {
2303 return false
2304 }
2305 }
2306 }
2307 if this.Network != that.Network {
2308 return false
2309 }
2310 if !this.Platform.EqualVT(that.Platform) {
2311 return false
2312 }
2313 if !this.Constraints.EqualVT(that.Constraints) {
2314 return false
2315 }
2316 if len(this.ExtraHosts) != len(that.ExtraHosts) {
2317 return false
2318 }
2319 for i, vx := range this.ExtraHosts {
2320 vy := that.ExtraHosts[i]
2321 if p, q := vx, vy; p != q {
2322 if p == nil {
2323 p = &pb.HostIP{}
2324 }
2325 if q == nil {
2326 q = &pb.HostIP{}
2327 }
2328 if !p.EqualVT(q) {
2329 return false
2330 }
2331 }
2332 }
2333 if this.Hostname != that.Hostname {
2334 return false
2335 }
2336 return string(this.unknownFields) == string(that.unknownFields)
2337 }
2338
2339 func (this *NewContainerRequest) EqualMessageVT(thatMsg proto.Message) bool {
2340 that, ok := thatMsg.(*NewContainerRequest)
2341 if !ok {
2342 return false
2343 }
2344 return this.EqualVT(that)
2345 }
2346 func (this *NewContainerResponse) EqualVT(that *NewContainerResponse) bool {
2347 if this == that {
2348 return true
2349 } else if this == nil || that == nil {
2350 return false
2351 }
2352 return string(this.unknownFields) == string(that.unknownFields)
2353 }
2354
2355 func (this *NewContainerResponse) EqualMessageVT(thatMsg proto.Message) bool {
2356 that, ok := thatMsg.(*NewContainerResponse)
2357 if !ok {
2358 return false
2359 }
2360 return this.EqualVT(that)
2361 }
2362 func (this *ReleaseContainerRequest) EqualVT(that *ReleaseContainerRequest) bool {
2363 if this == that {
2364 return true
2365 } else if this == nil || that == nil {
2366 return false
2367 }
2368 if this.ContainerID != that.ContainerID {
2369 return false
2370 }
2371 return string(this.unknownFields) == string(that.unknownFields)
2372 }
2373
2374 func (this *ReleaseContainerRequest) EqualMessageVT(thatMsg proto.Message) bool {
2375 that, ok := thatMsg.(*ReleaseContainerRequest)
2376 if !ok {
2377 return false
2378 }
2379 return this.EqualVT(that)
2380 }
2381 func (this *ReleaseContainerResponse) EqualVT(that *ReleaseContainerResponse) bool {
2382 if this == that {
2383 return true
2384 } else if this == nil || that == nil {
2385 return false
2386 }
2387 return string(this.unknownFields) == string(that.unknownFields)
2388 }
2389
2390 func (this *ReleaseContainerResponse) EqualMessageVT(thatMsg proto.Message) bool {
2391 that, ok := thatMsg.(*ReleaseContainerResponse)
2392 if !ok {
2393 return false
2394 }
2395 return this.EqualVT(that)
2396 }
2397 func (this *ExecMessage) EqualVT(that *ExecMessage) bool {
2398 if this == that {
2399 return true
2400 } else if this == nil || that == nil {
2401 return false
2402 }
2403 if this.Input == nil && that.Input != nil {
2404 return false
2405 } else if this.Input != nil {
2406 if that.Input == nil {
2407 return false
2408 }
2409 if !this.Input.(interface {
2410 EqualVT(isExecMessage_Input) bool
2411 }).EqualVT(that.Input) {
2412 return false
2413 }
2414 }
2415 if this.ProcessID != that.ProcessID {
2416 return false
2417 }
2418 return string(this.unknownFields) == string(that.unknownFields)
2419 }
2420
2421 func (this *ExecMessage) EqualMessageVT(thatMsg proto.Message) bool {
2422 that, ok := thatMsg.(*ExecMessage)
2423 if !ok {
2424 return false
2425 }
2426 return this.EqualVT(that)
2427 }
2428 func (this *ExecMessage_Init) EqualVT(thatIface isExecMessage_Input) bool {
2429 that, ok := thatIface.(*ExecMessage_Init)
2430 if !ok {
2431 return false
2432 }
2433 if this == that {
2434 return true
2435 }
2436 if this == nil && that != nil || this != nil && that == nil {
2437 return false
2438 }
2439 if p, q := this.Init, that.Init; p != q {
2440 if p == nil {
2441 p = &InitMessage{}
2442 }
2443 if q == nil {
2444 q = &InitMessage{}
2445 }
2446 if !p.EqualVT(q) {
2447 return false
2448 }
2449 }
2450 return true
2451 }
2452
2453 func (this *ExecMessage_File) EqualVT(thatIface isExecMessage_Input) bool {
2454 that, ok := thatIface.(*ExecMessage_File)
2455 if !ok {
2456 return false
2457 }
2458 if this == that {
2459 return true
2460 }
2461 if this == nil && that != nil || this != nil && that == nil {
2462 return false
2463 }
2464 if p, q := this.File, that.File; p != q {
2465 if p == nil {
2466 p = &FdMessage{}
2467 }
2468 if q == nil {
2469 q = &FdMessage{}
2470 }
2471 if !p.EqualVT(q) {
2472 return false
2473 }
2474 }
2475 return true
2476 }
2477
2478 func (this *ExecMessage_Resize) EqualVT(thatIface isExecMessage_Input) bool {
2479 that, ok := thatIface.(*ExecMessage_Resize)
2480 if !ok {
2481 return false
2482 }
2483 if this == that {
2484 return true
2485 }
2486 if this == nil && that != nil || this != nil && that == nil {
2487 return false
2488 }
2489 if p, q := this.Resize, that.Resize; p != q {
2490 if p == nil {
2491 p = &ResizeMessage{}
2492 }
2493 if q == nil {
2494 q = &ResizeMessage{}
2495 }
2496 if !p.EqualVT(q) {
2497 return false
2498 }
2499 }
2500 return true
2501 }
2502
2503 func (this *ExecMessage_Started) EqualVT(thatIface isExecMessage_Input) bool {
2504 that, ok := thatIface.(*ExecMessage_Started)
2505 if !ok {
2506 return false
2507 }
2508 if this == that {
2509 return true
2510 }
2511 if this == nil && that != nil || this != nil && that == nil {
2512 return false
2513 }
2514 if p, q := this.Started, that.Started; p != q {
2515 if p == nil {
2516 p = &StartedMessage{}
2517 }
2518 if q == nil {
2519 q = &StartedMessage{}
2520 }
2521 if !p.EqualVT(q) {
2522 return false
2523 }
2524 }
2525 return true
2526 }
2527
2528 func (this *ExecMessage_Exit) EqualVT(thatIface isExecMessage_Input) bool {
2529 that, ok := thatIface.(*ExecMessage_Exit)
2530 if !ok {
2531 return false
2532 }
2533 if this == that {
2534 return true
2535 }
2536 if this == nil && that != nil || this != nil && that == nil {
2537 return false
2538 }
2539 if p, q := this.Exit, that.Exit; p != q {
2540 if p == nil {
2541 p = &ExitMessage{}
2542 }
2543 if q == nil {
2544 q = &ExitMessage{}
2545 }
2546 if !p.EqualVT(q) {
2547 return false
2548 }
2549 }
2550 return true
2551 }
2552
2553 func (this *ExecMessage_Done) EqualVT(thatIface isExecMessage_Input) bool {
2554 that, ok := thatIface.(*ExecMessage_Done)
2555 if !ok {
2556 return false
2557 }
2558 if this == that {
2559 return true
2560 }
2561 if this == nil && that != nil || this != nil && that == nil {
2562 return false
2563 }
2564 if p, q := this.Done, that.Done; p != q {
2565 if p == nil {
2566 p = &DoneMessage{}
2567 }
2568 if q == nil {
2569 q = &DoneMessage{}
2570 }
2571 if !p.EqualVT(q) {
2572 return false
2573 }
2574 }
2575 return true
2576 }
2577
2578 func (this *ExecMessage_Signal) EqualVT(thatIface isExecMessage_Input) bool {
2579 that, ok := thatIface.(*ExecMessage_Signal)
2580 if !ok {
2581 return false
2582 }
2583 if this == that {
2584 return true
2585 }
2586 if this == nil && that != nil || this != nil && that == nil {
2587 return false
2588 }
2589 if p, q := this.Signal, that.Signal; p != q {
2590 if p == nil {
2591 p = &SignalMessage{}
2592 }
2593 if q == nil {
2594 q = &SignalMessage{}
2595 }
2596 if !p.EqualVT(q) {
2597 return false
2598 }
2599 }
2600 return true
2601 }
2602
2603 func (this *InitMessage) EqualVT(that *InitMessage) bool {
2604 if this == that {
2605 return true
2606 } else if this == nil || that == nil {
2607 return false
2608 }
2609 if this.ContainerID != that.ContainerID {
2610 return false
2611 }
2612 if !this.Meta.EqualVT(that.Meta) {
2613 return false
2614 }
2615 if len(this.Fds) != len(that.Fds) {
2616 return false
2617 }
2618 for i, vx := range this.Fds {
2619 vy := that.Fds[i]
2620 if vx != vy {
2621 return false
2622 }
2623 }
2624 if this.Tty != that.Tty {
2625 return false
2626 }
2627 if this.Security != that.Security {
2628 return false
2629 }
2630 if len(this.Secretenv) != len(that.Secretenv) {
2631 return false
2632 }
2633 for i, vx := range this.Secretenv {
2634 vy := that.Secretenv[i]
2635 if p, q := vx, vy; p != q {
2636 if p == nil {
2637 p = &pb.SecretEnv{}
2638 }
2639 if q == nil {
2640 q = &pb.SecretEnv{}
2641 }
2642 if !p.EqualVT(q) {
2643 return false
2644 }
2645 }
2646 }
2647 return string(this.unknownFields) == string(that.unknownFields)
2648 }
2649
2650 func (this *InitMessage) EqualMessageVT(thatMsg proto.Message) bool {
2651 that, ok := thatMsg.(*InitMessage)
2652 if !ok {
2653 return false
2654 }
2655 return this.EqualVT(that)
2656 }
2657 func (this *ExitMessage) EqualVT(that *ExitMessage) bool {
2658 if this == that {
2659 return true
2660 } else if this == nil || that == nil {
2661 return false
2662 }
2663 if this.Code != that.Code {
2664 return false
2665 }
2666 if equal, ok := interface{}(this.Error).(interface{ EqualVT(*status.Status) bool }); ok {
2667 if !equal.EqualVT(that.Error) {
2668 return false
2669 }
2670 } else if !proto.Equal(this.Error, that.Error) {
2671 return false
2672 }
2673 return string(this.unknownFields) == string(that.unknownFields)
2674 }
2675
2676 func (this *ExitMessage) EqualMessageVT(thatMsg proto.Message) bool {
2677 that, ok := thatMsg.(*ExitMessage)
2678 if !ok {
2679 return false
2680 }
2681 return this.EqualVT(that)
2682 }
2683 func (this *StartedMessage) EqualVT(that *StartedMessage) bool {
2684 if this == that {
2685 return true
2686 } else if this == nil || that == nil {
2687 return false
2688 }
2689 return string(this.unknownFields) == string(that.unknownFields)
2690 }
2691
2692 func (this *StartedMessage) EqualMessageVT(thatMsg proto.Message) bool {
2693 that, ok := thatMsg.(*StartedMessage)
2694 if !ok {
2695 return false
2696 }
2697 return this.EqualVT(that)
2698 }
2699 func (this *DoneMessage) EqualVT(that *DoneMessage) bool {
2700 if this == that {
2701 return true
2702 } else if this == nil || that == nil {
2703 return false
2704 }
2705 return string(this.unknownFields) == string(that.unknownFields)
2706 }
2707
2708 func (this *DoneMessage) EqualMessageVT(thatMsg proto.Message) bool {
2709 that, ok := thatMsg.(*DoneMessage)
2710 if !ok {
2711 return false
2712 }
2713 return this.EqualVT(that)
2714 }
2715 func (this *FdMessage) EqualVT(that *FdMessage) bool {
2716 if this == that {
2717 return true
2718 } else if this == nil || that == nil {
2719 return false
2720 }
2721 if this.Fd != that.Fd {
2722 return false
2723 }
2724 if this.EOF != that.EOF {
2725 return false
2726 }
2727 if string(this.Data) != string(that.Data) {
2728 return false
2729 }
2730 return string(this.unknownFields) == string(that.unknownFields)
2731 }
2732
2733 func (this *FdMessage) EqualMessageVT(thatMsg proto.Message) bool {
2734 that, ok := thatMsg.(*FdMessage)
2735 if !ok {
2736 return false
2737 }
2738 return this.EqualVT(that)
2739 }
2740 func (this *ResizeMessage) EqualVT(that *ResizeMessage) bool {
2741 if this == that {
2742 return true
2743 } else if this == nil || that == nil {
2744 return false
2745 }
2746 if this.Rows != that.Rows {
2747 return false
2748 }
2749 if this.Cols != that.Cols {
2750 return false
2751 }
2752 return string(this.unknownFields) == string(that.unknownFields)
2753 }
2754
2755 func (this *ResizeMessage) EqualMessageVT(thatMsg proto.Message) bool {
2756 that, ok := thatMsg.(*ResizeMessage)
2757 if !ok {
2758 return false
2759 }
2760 return this.EqualVT(that)
2761 }
2762 func (this *SignalMessage) EqualVT(that *SignalMessage) bool {
2763 if this == that {
2764 return true
2765 } else if this == nil || that == nil {
2766 return false
2767 }
2768 if this.Name != that.Name {
2769 return false
2770 }
2771 return string(this.unknownFields) == string(that.unknownFields)
2772 }
2773
2774 func (this *SignalMessage) EqualMessageVT(thatMsg proto.Message) bool {
2775 that, ok := thatMsg.(*SignalMessage)
2776 if !ok {
2777 return false
2778 }
2779 return this.EqualVT(that)
2780 }
2781 func (m *Result) MarshalVT() (dAtA []byte, err error) {
2782 if m == nil {
2783 return nil, nil
2784 }
2785 size := m.SizeVT()
2786 dAtA = make([]byte, size)
2787 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
2788 if err != nil {
2789 return nil, err
2790 }
2791 return dAtA[:n], nil
2792 }
2793
2794 func (m *Result) MarshalToVT(dAtA []byte) (int, error) {
2795 size := m.SizeVT()
2796 return m.MarshalToSizedBufferVT(dAtA[:size])
2797 }
2798
2799 func (m *Result) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
2800 if m == nil {
2801 return 0, nil
2802 }
2803 i := len(dAtA)
2804 _ = i
2805 var l int
2806 _ = l
2807 if m.unknownFields != nil {
2808 i -= len(m.unknownFields)
2809 copy(dAtA[i:], m.unknownFields)
2810 }
2811 if vtmsg, ok := m.Result.(interface {
2812 MarshalToSizedBufferVT([]byte) (int, error)
2813 }); ok {
2814 size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
2815 if err != nil {
2816 return 0, err
2817 }
2818 i -= size
2819 }
2820 if len(m.Attestations) > 0 {
2821 for k := range m.Attestations {
2822 v := m.Attestations[k]
2823 baseI := i
2824 size, err := v.MarshalToSizedBufferVT(dAtA[:i])
2825 if err != nil {
2826 return 0, err
2827 }
2828 i -= size
2829 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2830 i--
2831 dAtA[i] = 0x12
2832 i -= len(k)
2833 copy(dAtA[i:], k)
2834 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
2835 i--
2836 dAtA[i] = 0xa
2837 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
2838 i--
2839 dAtA[i] = 0x62
2840 }
2841 }
2842 if len(m.Metadata) > 0 {
2843 for k := range m.Metadata {
2844 v := m.Metadata[k]
2845 baseI := i
2846 i -= len(v)
2847 copy(dAtA[i:], v)
2848 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
2849 i--
2850 dAtA[i] = 0x12
2851 i -= len(k)
2852 copy(dAtA[i:], k)
2853 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
2854 i--
2855 dAtA[i] = 0xa
2856 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
2857 i--
2858 dAtA[i] = 0x52
2859 }
2860 }
2861 return len(dAtA) - i, nil
2862 }
2863
2864 func (m *Result_RefDeprecated) MarshalToVT(dAtA []byte) (int, error) {
2865 size := m.SizeVT()
2866 return m.MarshalToSizedBufferVT(dAtA[:size])
2867 }
2868
2869 func (m *Result_RefDeprecated) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
2870 i := len(dAtA)
2871 i -= len(m.RefDeprecated)
2872 copy(dAtA[i:], m.RefDeprecated)
2873 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RefDeprecated)))
2874 i--
2875 dAtA[i] = 0xa
2876 return len(dAtA) - i, nil
2877 }
2878 func (m *Result_RefsDeprecated) MarshalToVT(dAtA []byte) (int, error) {
2879 size := m.SizeVT()
2880 return m.MarshalToSizedBufferVT(dAtA[:size])
2881 }
2882
2883 func (m *Result_RefsDeprecated) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
2884 i := len(dAtA)
2885 if m.RefsDeprecated != nil {
2886 size, err := m.RefsDeprecated.MarshalToSizedBufferVT(dAtA[:i])
2887 if err != nil {
2888 return 0, err
2889 }
2890 i -= size
2891 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2892 i--
2893 dAtA[i] = 0x12
2894 } else {
2895 i = protohelpers.EncodeVarint(dAtA, i, 0)
2896 i--
2897 dAtA[i] = 0x12
2898 }
2899 return len(dAtA) - i, nil
2900 }
2901 func (m *Result_Ref) MarshalToVT(dAtA []byte) (int, error) {
2902 size := m.SizeVT()
2903 return m.MarshalToSizedBufferVT(dAtA[:size])
2904 }
2905
2906 func (m *Result_Ref) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
2907 i := len(dAtA)
2908 if m.Ref != nil {
2909 size, err := m.Ref.MarshalToSizedBufferVT(dAtA[:i])
2910 if err != nil {
2911 return 0, err
2912 }
2913 i -= size
2914 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2915 i--
2916 dAtA[i] = 0x1a
2917 } else {
2918 i = protohelpers.EncodeVarint(dAtA, i, 0)
2919 i--
2920 dAtA[i] = 0x1a
2921 }
2922 return len(dAtA) - i, nil
2923 }
2924 func (m *Result_Refs) MarshalToVT(dAtA []byte) (int, error) {
2925 size := m.SizeVT()
2926 return m.MarshalToSizedBufferVT(dAtA[:size])
2927 }
2928
2929 func (m *Result_Refs) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
2930 i := len(dAtA)
2931 if m.Refs != nil {
2932 size, err := m.Refs.MarshalToSizedBufferVT(dAtA[:i])
2933 if err != nil {
2934 return 0, err
2935 }
2936 i -= size
2937 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
2938 i--
2939 dAtA[i] = 0x22
2940 } else {
2941 i = protohelpers.EncodeVarint(dAtA, i, 0)
2942 i--
2943 dAtA[i] = 0x22
2944 }
2945 return len(dAtA) - i, nil
2946 }
2947 func (m *RefMapDeprecated) MarshalVT() (dAtA []byte, err error) {
2948 if m == nil {
2949 return nil, nil
2950 }
2951 size := m.SizeVT()
2952 dAtA = make([]byte, size)
2953 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
2954 if err != nil {
2955 return nil, err
2956 }
2957 return dAtA[:n], nil
2958 }
2959
2960 func (m *RefMapDeprecated) MarshalToVT(dAtA []byte) (int, error) {
2961 size := m.SizeVT()
2962 return m.MarshalToSizedBufferVT(dAtA[:size])
2963 }
2964
2965 func (m *RefMapDeprecated) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
2966 if m == nil {
2967 return 0, nil
2968 }
2969 i := len(dAtA)
2970 _ = i
2971 var l int
2972 _ = l
2973 if m.unknownFields != nil {
2974 i -= len(m.unknownFields)
2975 copy(dAtA[i:], m.unknownFields)
2976 }
2977 if len(m.Refs) > 0 {
2978 for k := range m.Refs {
2979 v := m.Refs[k]
2980 baseI := i
2981 i -= len(v)
2982 copy(dAtA[i:], v)
2983 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
2984 i--
2985 dAtA[i] = 0x12
2986 i -= len(k)
2987 copy(dAtA[i:], k)
2988 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
2989 i--
2990 dAtA[i] = 0xa
2991 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
2992 i--
2993 dAtA[i] = 0xa
2994 }
2995 }
2996 return len(dAtA) - i, nil
2997 }
2998
2999 func (m *Ref) MarshalVT() (dAtA []byte, err error) {
3000 if m == nil {
3001 return nil, nil
3002 }
3003 size := m.SizeVT()
3004 dAtA = make([]byte, size)
3005 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3006 if err != nil {
3007 return nil, err
3008 }
3009 return dAtA[:n], nil
3010 }
3011
3012 func (m *Ref) MarshalToVT(dAtA []byte) (int, error) {
3013 size := m.SizeVT()
3014 return m.MarshalToSizedBufferVT(dAtA[:size])
3015 }
3016
3017 func (m *Ref) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3018 if m == nil {
3019 return 0, nil
3020 }
3021 i := len(dAtA)
3022 _ = i
3023 var l int
3024 _ = l
3025 if m.unknownFields != nil {
3026 i -= len(m.unknownFields)
3027 copy(dAtA[i:], m.unknownFields)
3028 }
3029 if m.Def != nil {
3030 size, err := m.Def.MarshalToSizedBufferVT(dAtA[:i])
3031 if err != nil {
3032 return 0, err
3033 }
3034 i -= size
3035 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3036 i--
3037 dAtA[i] = 0x12
3038 }
3039 if len(m.Id) > 0 {
3040 i -= len(m.Id)
3041 copy(dAtA[i:], m.Id)
3042 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id)))
3043 i--
3044 dAtA[i] = 0xa
3045 }
3046 return len(dAtA) - i, nil
3047 }
3048
3049 func (m *RefMap) MarshalVT() (dAtA []byte, err error) {
3050 if m == nil {
3051 return nil, nil
3052 }
3053 size := m.SizeVT()
3054 dAtA = make([]byte, size)
3055 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3056 if err != nil {
3057 return nil, err
3058 }
3059 return dAtA[:n], nil
3060 }
3061
3062 func (m *RefMap) MarshalToVT(dAtA []byte) (int, error) {
3063 size := m.SizeVT()
3064 return m.MarshalToSizedBufferVT(dAtA[:size])
3065 }
3066
3067 func (m *RefMap) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3068 if m == nil {
3069 return 0, nil
3070 }
3071 i := len(dAtA)
3072 _ = i
3073 var l int
3074 _ = l
3075 if m.unknownFields != nil {
3076 i -= len(m.unknownFields)
3077 copy(dAtA[i:], m.unknownFields)
3078 }
3079 if len(m.Refs) > 0 {
3080 for k := range m.Refs {
3081 v := m.Refs[k]
3082 baseI := i
3083 size, err := v.MarshalToSizedBufferVT(dAtA[:i])
3084 if err != nil {
3085 return 0, err
3086 }
3087 i -= size
3088 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3089 i--
3090 dAtA[i] = 0x12
3091 i -= len(k)
3092 copy(dAtA[i:], k)
3093 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
3094 i--
3095 dAtA[i] = 0xa
3096 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
3097 i--
3098 dAtA[i] = 0xa
3099 }
3100 }
3101 return len(dAtA) - i, nil
3102 }
3103
3104 func (m *Attestations) MarshalVT() (dAtA []byte, err error) {
3105 if m == nil {
3106 return nil, nil
3107 }
3108 size := m.SizeVT()
3109 dAtA = make([]byte, size)
3110 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3111 if err != nil {
3112 return nil, err
3113 }
3114 return dAtA[:n], nil
3115 }
3116
3117 func (m *Attestations) MarshalToVT(dAtA []byte) (int, error) {
3118 size := m.SizeVT()
3119 return m.MarshalToSizedBufferVT(dAtA[:size])
3120 }
3121
3122 func (m *Attestations) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3123 if m == nil {
3124 return 0, nil
3125 }
3126 i := len(dAtA)
3127 _ = i
3128 var l int
3129 _ = l
3130 if m.unknownFields != nil {
3131 i -= len(m.unknownFields)
3132 copy(dAtA[i:], m.unknownFields)
3133 }
3134 if len(m.Attestation) > 0 {
3135 for iNdEx := len(m.Attestation) - 1; iNdEx >= 0; iNdEx-- {
3136 size, err := m.Attestation[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
3137 if err != nil {
3138 return 0, err
3139 }
3140 i -= size
3141 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3142 i--
3143 dAtA[i] = 0xa
3144 }
3145 }
3146 return len(dAtA) - i, nil
3147 }
3148
3149 func (m *Attestation) MarshalVT() (dAtA []byte, err error) {
3150 if m == nil {
3151 return nil, nil
3152 }
3153 size := m.SizeVT()
3154 dAtA = make([]byte, size)
3155 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3156 if err != nil {
3157 return nil, err
3158 }
3159 return dAtA[:n], nil
3160 }
3161
3162 func (m *Attestation) MarshalToVT(dAtA []byte) (int, error) {
3163 size := m.SizeVT()
3164 return m.MarshalToSizedBufferVT(dAtA[:size])
3165 }
3166
3167 func (m *Attestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3168 if m == nil {
3169 return 0, nil
3170 }
3171 i := len(dAtA)
3172 _ = i
3173 var l int
3174 _ = l
3175 if m.unknownFields != nil {
3176 i -= len(m.unknownFields)
3177 copy(dAtA[i:], m.unknownFields)
3178 }
3179 if len(m.InTotoSubjects) > 0 {
3180 for iNdEx := len(m.InTotoSubjects) - 1; iNdEx >= 0; iNdEx-- {
3181 size, err := m.InTotoSubjects[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
3182 if err != nil {
3183 return 0, err
3184 }
3185 i -= size
3186 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3187 i--
3188 dAtA[i] = 0x32
3189 }
3190 }
3191 if len(m.InTotoPredicateType) > 0 {
3192 i -= len(m.InTotoPredicateType)
3193 copy(dAtA[i:], m.InTotoPredicateType)
3194 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InTotoPredicateType)))
3195 i--
3196 dAtA[i] = 0x2a
3197 }
3198 if len(m.Path) > 0 {
3199 i -= len(m.Path)
3200 copy(dAtA[i:], m.Path)
3201 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
3202 i--
3203 dAtA[i] = 0x22
3204 }
3205 if m.Ref != nil {
3206 size, err := m.Ref.MarshalToSizedBufferVT(dAtA[:i])
3207 if err != nil {
3208 return 0, err
3209 }
3210 i -= size
3211 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3212 i--
3213 dAtA[i] = 0x1a
3214 }
3215 if len(m.Metadata) > 0 {
3216 for k := range m.Metadata {
3217 v := m.Metadata[k]
3218 baseI := i
3219 i -= len(v)
3220 copy(dAtA[i:], v)
3221 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
3222 i--
3223 dAtA[i] = 0x12
3224 i -= len(k)
3225 copy(dAtA[i:], k)
3226 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
3227 i--
3228 dAtA[i] = 0xa
3229 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
3230 i--
3231 dAtA[i] = 0x12
3232 }
3233 }
3234 if m.Kind != 0 {
3235 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Kind))
3236 i--
3237 dAtA[i] = 0x8
3238 }
3239 return len(dAtA) - i, nil
3240 }
3241
3242 func (m *InTotoSubject) MarshalVT() (dAtA []byte, err error) {
3243 if m == nil {
3244 return nil, nil
3245 }
3246 size := m.SizeVT()
3247 dAtA = make([]byte, size)
3248 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3249 if err != nil {
3250 return nil, err
3251 }
3252 return dAtA[:n], nil
3253 }
3254
3255 func (m *InTotoSubject) MarshalToVT(dAtA []byte) (int, error) {
3256 size := m.SizeVT()
3257 return m.MarshalToSizedBufferVT(dAtA[:size])
3258 }
3259
3260 func (m *InTotoSubject) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3261 if m == nil {
3262 return 0, nil
3263 }
3264 i := len(dAtA)
3265 _ = i
3266 var l int
3267 _ = l
3268 if m.unknownFields != nil {
3269 i -= len(m.unknownFields)
3270 copy(dAtA[i:], m.unknownFields)
3271 }
3272 if len(m.Name) > 0 {
3273 i -= len(m.Name)
3274 copy(dAtA[i:], m.Name)
3275 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
3276 i--
3277 dAtA[i] = 0x1a
3278 }
3279 if len(m.Digest) > 0 {
3280 for iNdEx := len(m.Digest) - 1; iNdEx >= 0; iNdEx-- {
3281 i -= len(m.Digest[iNdEx])
3282 copy(dAtA[i:], m.Digest[iNdEx])
3283 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest[iNdEx])))
3284 i--
3285 dAtA[i] = 0x12
3286 }
3287 }
3288 if m.Kind != 0 {
3289 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Kind))
3290 i--
3291 dAtA[i] = 0x8
3292 }
3293 return len(dAtA) - i, nil
3294 }
3295
3296 func (m *ReturnRequest) MarshalVT() (dAtA []byte, err error) {
3297 if m == nil {
3298 return nil, nil
3299 }
3300 size := m.SizeVT()
3301 dAtA = make([]byte, size)
3302 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3303 if err != nil {
3304 return nil, err
3305 }
3306 return dAtA[:n], nil
3307 }
3308
3309 func (m *ReturnRequest) MarshalToVT(dAtA []byte) (int, error) {
3310 size := m.SizeVT()
3311 return m.MarshalToSizedBufferVT(dAtA[:size])
3312 }
3313
3314 func (m *ReturnRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3315 if m == nil {
3316 return 0, nil
3317 }
3318 i := len(dAtA)
3319 _ = i
3320 var l int
3321 _ = l
3322 if m.unknownFields != nil {
3323 i -= len(m.unknownFields)
3324 copy(dAtA[i:], m.unknownFields)
3325 }
3326 if m.Error != nil {
3327 if vtmsg, ok := interface{}(m.Error).(interface {
3328 MarshalToSizedBufferVT([]byte) (int, error)
3329 }); ok {
3330 size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
3331 if err != nil {
3332 return 0, err
3333 }
3334 i -= size
3335 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3336 } else {
3337 encoded, err := proto.Marshal(m.Error)
3338 if err != nil {
3339 return 0, err
3340 }
3341 i -= len(encoded)
3342 copy(dAtA[i:], encoded)
3343 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
3344 }
3345 i--
3346 dAtA[i] = 0x12
3347 }
3348 if m.Result != nil {
3349 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
3350 if err != nil {
3351 return 0, err
3352 }
3353 i -= size
3354 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3355 i--
3356 dAtA[i] = 0xa
3357 }
3358 return len(dAtA) - i, nil
3359 }
3360
3361 func (m *ReturnResponse) MarshalVT() (dAtA []byte, err error) {
3362 if m == nil {
3363 return nil, nil
3364 }
3365 size := m.SizeVT()
3366 dAtA = make([]byte, size)
3367 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3368 if err != nil {
3369 return nil, err
3370 }
3371 return dAtA[:n], nil
3372 }
3373
3374 func (m *ReturnResponse) MarshalToVT(dAtA []byte) (int, error) {
3375 size := m.SizeVT()
3376 return m.MarshalToSizedBufferVT(dAtA[:size])
3377 }
3378
3379 func (m *ReturnResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3380 if m == nil {
3381 return 0, nil
3382 }
3383 i := len(dAtA)
3384 _ = i
3385 var l int
3386 _ = l
3387 if m.unknownFields != nil {
3388 i -= len(m.unknownFields)
3389 copy(dAtA[i:], m.unknownFields)
3390 }
3391 return len(dAtA) - i, nil
3392 }
3393
3394 func (m *InputsRequest) MarshalVT() (dAtA []byte, err error) {
3395 if m == nil {
3396 return nil, nil
3397 }
3398 size := m.SizeVT()
3399 dAtA = make([]byte, size)
3400 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3401 if err != nil {
3402 return nil, err
3403 }
3404 return dAtA[:n], nil
3405 }
3406
3407 func (m *InputsRequest) MarshalToVT(dAtA []byte) (int, error) {
3408 size := m.SizeVT()
3409 return m.MarshalToSizedBufferVT(dAtA[:size])
3410 }
3411
3412 func (m *InputsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3413 if m == nil {
3414 return 0, nil
3415 }
3416 i := len(dAtA)
3417 _ = i
3418 var l int
3419 _ = l
3420 if m.unknownFields != nil {
3421 i -= len(m.unknownFields)
3422 copy(dAtA[i:], m.unknownFields)
3423 }
3424 return len(dAtA) - i, nil
3425 }
3426
3427 func (m *InputsResponse) MarshalVT() (dAtA []byte, err error) {
3428 if m == nil {
3429 return nil, nil
3430 }
3431 size := m.SizeVT()
3432 dAtA = make([]byte, size)
3433 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3434 if err != nil {
3435 return nil, err
3436 }
3437 return dAtA[:n], nil
3438 }
3439
3440 func (m *InputsResponse) MarshalToVT(dAtA []byte) (int, error) {
3441 size := m.SizeVT()
3442 return m.MarshalToSizedBufferVT(dAtA[:size])
3443 }
3444
3445 func (m *InputsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3446 if m == nil {
3447 return 0, nil
3448 }
3449 i := len(dAtA)
3450 _ = i
3451 var l int
3452 _ = l
3453 if m.unknownFields != nil {
3454 i -= len(m.unknownFields)
3455 copy(dAtA[i:], m.unknownFields)
3456 }
3457 if len(m.Definitions) > 0 {
3458 for k := range m.Definitions {
3459 v := m.Definitions[k]
3460 baseI := i
3461 size, err := v.MarshalToSizedBufferVT(dAtA[:i])
3462 if err != nil {
3463 return 0, err
3464 }
3465 i -= size
3466 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3467 i--
3468 dAtA[i] = 0x12
3469 i -= len(k)
3470 copy(dAtA[i:], k)
3471 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
3472 i--
3473 dAtA[i] = 0xa
3474 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
3475 i--
3476 dAtA[i] = 0xa
3477 }
3478 }
3479 return len(dAtA) - i, nil
3480 }
3481
3482 func (m *ResolveImageConfigRequest) MarshalVT() (dAtA []byte, err error) {
3483 if m == nil {
3484 return nil, nil
3485 }
3486 size := m.SizeVT()
3487 dAtA = make([]byte, size)
3488 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3489 if err != nil {
3490 return nil, err
3491 }
3492 return dAtA[:n], nil
3493 }
3494
3495 func (m *ResolveImageConfigRequest) MarshalToVT(dAtA []byte) (int, error) {
3496 size := m.SizeVT()
3497 return m.MarshalToSizedBufferVT(dAtA[:size])
3498 }
3499
3500 func (m *ResolveImageConfigRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3501 if m == nil {
3502 return 0, nil
3503 }
3504 i := len(dAtA)
3505 _ = i
3506 var l int
3507 _ = l
3508 if m.unknownFields != nil {
3509 i -= len(m.unknownFields)
3510 copy(dAtA[i:], m.unknownFields)
3511 }
3512 if len(m.SourcePolicies) > 0 {
3513 for iNdEx := len(m.SourcePolicies) - 1; iNdEx >= 0; iNdEx-- {
3514 size, err := m.SourcePolicies[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
3515 if err != nil {
3516 return 0, err
3517 }
3518 i -= size
3519 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3520 i--
3521 dAtA[i] = 0x42
3522 }
3523 }
3524 if len(m.StoreID) > 0 {
3525 i -= len(m.StoreID)
3526 copy(dAtA[i:], m.StoreID)
3527 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StoreID)))
3528 i--
3529 dAtA[i] = 0x3a
3530 }
3531 if len(m.SessionID) > 0 {
3532 i -= len(m.SessionID)
3533 copy(dAtA[i:], m.SessionID)
3534 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SessionID)))
3535 i--
3536 dAtA[i] = 0x32
3537 }
3538 if m.ResolverType != 0 {
3539 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ResolverType))
3540 i--
3541 dAtA[i] = 0x28
3542 }
3543 if len(m.LogName) > 0 {
3544 i -= len(m.LogName)
3545 copy(dAtA[i:], m.LogName)
3546 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogName)))
3547 i--
3548 dAtA[i] = 0x22
3549 }
3550 if len(m.ResolveMode) > 0 {
3551 i -= len(m.ResolveMode)
3552 copy(dAtA[i:], m.ResolveMode)
3553 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResolveMode)))
3554 i--
3555 dAtA[i] = 0x1a
3556 }
3557 if m.Platform != nil {
3558 size, err := m.Platform.MarshalToSizedBufferVT(dAtA[:i])
3559 if err != nil {
3560 return 0, err
3561 }
3562 i -= size
3563 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3564 i--
3565 dAtA[i] = 0x12
3566 }
3567 if len(m.Ref) > 0 {
3568 i -= len(m.Ref)
3569 copy(dAtA[i:], m.Ref)
3570 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
3571 i--
3572 dAtA[i] = 0xa
3573 }
3574 return len(dAtA) - i, nil
3575 }
3576
3577 func (m *ResolveImageConfigResponse) MarshalVT() (dAtA []byte, err error) {
3578 if m == nil {
3579 return nil, nil
3580 }
3581 size := m.SizeVT()
3582 dAtA = make([]byte, size)
3583 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3584 if err != nil {
3585 return nil, err
3586 }
3587 return dAtA[:n], nil
3588 }
3589
3590 func (m *ResolveImageConfigResponse) MarshalToVT(dAtA []byte) (int, error) {
3591 size := m.SizeVT()
3592 return m.MarshalToSizedBufferVT(dAtA[:size])
3593 }
3594
3595 func (m *ResolveImageConfigResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3596 if m == nil {
3597 return 0, nil
3598 }
3599 i := len(dAtA)
3600 _ = i
3601 var l int
3602 _ = l
3603 if m.unknownFields != nil {
3604 i -= len(m.unknownFields)
3605 copy(dAtA[i:], m.unknownFields)
3606 }
3607 if len(m.Ref) > 0 {
3608 i -= len(m.Ref)
3609 copy(dAtA[i:], m.Ref)
3610 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
3611 i--
3612 dAtA[i] = 0x1a
3613 }
3614 if len(m.Config) > 0 {
3615 i -= len(m.Config)
3616 copy(dAtA[i:], m.Config)
3617 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Config)))
3618 i--
3619 dAtA[i] = 0x12
3620 }
3621 if len(m.Digest) > 0 {
3622 i -= len(m.Digest)
3623 copy(dAtA[i:], m.Digest)
3624 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest)))
3625 i--
3626 dAtA[i] = 0xa
3627 }
3628 return len(dAtA) - i, nil
3629 }
3630
3631 func (m *ResolveSourceMetaRequest) MarshalVT() (dAtA []byte, err error) {
3632 if m == nil {
3633 return nil, nil
3634 }
3635 size := m.SizeVT()
3636 dAtA = make([]byte, size)
3637 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3638 if err != nil {
3639 return nil, err
3640 }
3641 return dAtA[:n], nil
3642 }
3643
3644 func (m *ResolveSourceMetaRequest) MarshalToVT(dAtA []byte) (int, error) {
3645 size := m.SizeVT()
3646 return m.MarshalToSizedBufferVT(dAtA[:size])
3647 }
3648
3649 func (m *ResolveSourceMetaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3650 if m == nil {
3651 return 0, nil
3652 }
3653 i := len(dAtA)
3654 _ = i
3655 var l int
3656 _ = l
3657 if m.unknownFields != nil {
3658 i -= len(m.unknownFields)
3659 copy(dAtA[i:], m.unknownFields)
3660 }
3661 if len(m.SourcePolicies) > 0 {
3662 for iNdEx := len(m.SourcePolicies) - 1; iNdEx >= 0; iNdEx-- {
3663 size, err := m.SourcePolicies[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
3664 if err != nil {
3665 return 0, err
3666 }
3667 i -= size
3668 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3669 i--
3670 dAtA[i] = 0x42
3671 }
3672 }
3673 if len(m.ResolveMode) > 0 {
3674 i -= len(m.ResolveMode)
3675 copy(dAtA[i:], m.ResolveMode)
3676 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ResolveMode)))
3677 i--
3678 dAtA[i] = 0x22
3679 }
3680 if len(m.LogName) > 0 {
3681 i -= len(m.LogName)
3682 copy(dAtA[i:], m.LogName)
3683 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogName)))
3684 i--
3685 dAtA[i] = 0x1a
3686 }
3687 if m.Platform != nil {
3688 size, err := m.Platform.MarshalToSizedBufferVT(dAtA[:i])
3689 if err != nil {
3690 return 0, err
3691 }
3692 i -= size
3693 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3694 i--
3695 dAtA[i] = 0x12
3696 }
3697 if m.Source != nil {
3698 size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i])
3699 if err != nil {
3700 return 0, err
3701 }
3702 i -= size
3703 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3704 i--
3705 dAtA[i] = 0xa
3706 }
3707 return len(dAtA) - i, nil
3708 }
3709
3710 func (m *ResolveSourceMetaResponse) MarshalVT() (dAtA []byte, err error) {
3711 if m == nil {
3712 return nil, nil
3713 }
3714 size := m.SizeVT()
3715 dAtA = make([]byte, size)
3716 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3717 if err != nil {
3718 return nil, err
3719 }
3720 return dAtA[:n], nil
3721 }
3722
3723 func (m *ResolveSourceMetaResponse) MarshalToVT(dAtA []byte) (int, error) {
3724 size := m.SizeVT()
3725 return m.MarshalToSizedBufferVT(dAtA[:size])
3726 }
3727
3728 func (m *ResolveSourceMetaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3729 if m == nil {
3730 return 0, nil
3731 }
3732 i := len(dAtA)
3733 _ = i
3734 var l int
3735 _ = l
3736 if m.unknownFields != nil {
3737 i -= len(m.unknownFields)
3738 copy(dAtA[i:], m.unknownFields)
3739 }
3740 if m.Image != nil {
3741 size, err := m.Image.MarshalToSizedBufferVT(dAtA[:i])
3742 if err != nil {
3743 return 0, err
3744 }
3745 i -= size
3746 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3747 i--
3748 dAtA[i] = 0x12
3749 }
3750 if m.Source != nil {
3751 size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i])
3752 if err != nil {
3753 return 0, err
3754 }
3755 i -= size
3756 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3757 i--
3758 dAtA[i] = 0xa
3759 }
3760 return len(dAtA) - i, nil
3761 }
3762
3763 func (m *ResolveSourceImageResponse) MarshalVT() (dAtA []byte, err error) {
3764 if m == nil {
3765 return nil, nil
3766 }
3767 size := m.SizeVT()
3768 dAtA = make([]byte, size)
3769 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3770 if err != nil {
3771 return nil, err
3772 }
3773 return dAtA[:n], nil
3774 }
3775
3776 func (m *ResolveSourceImageResponse) MarshalToVT(dAtA []byte) (int, error) {
3777 size := m.SizeVT()
3778 return m.MarshalToSizedBufferVT(dAtA[:size])
3779 }
3780
3781 func (m *ResolveSourceImageResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3782 if m == nil {
3783 return 0, nil
3784 }
3785 i := len(dAtA)
3786 _ = i
3787 var l int
3788 _ = l
3789 if m.unknownFields != nil {
3790 i -= len(m.unknownFields)
3791 copy(dAtA[i:], m.unknownFields)
3792 }
3793 if len(m.Config) > 0 {
3794 i -= len(m.Config)
3795 copy(dAtA[i:], m.Config)
3796 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Config)))
3797 i--
3798 dAtA[i] = 0x12
3799 }
3800 if len(m.Digest) > 0 {
3801 i -= len(m.Digest)
3802 copy(dAtA[i:], m.Digest)
3803 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest)))
3804 i--
3805 dAtA[i] = 0xa
3806 }
3807 return len(dAtA) - i, nil
3808 }
3809
3810 func (m *SolveRequest) MarshalVT() (dAtA []byte, err error) {
3811 if m == nil {
3812 return nil, nil
3813 }
3814 size := m.SizeVT()
3815 dAtA = make([]byte, size)
3816 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3817 if err != nil {
3818 return nil, err
3819 }
3820 return dAtA[:n], nil
3821 }
3822
3823 func (m *SolveRequest) MarshalToVT(dAtA []byte) (int, error) {
3824 size := m.SizeVT()
3825 return m.MarshalToSizedBufferVT(dAtA[:size])
3826 }
3827
3828 func (m *SolveRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3829 if m == nil {
3830 return 0, nil
3831 }
3832 i := len(dAtA)
3833 _ = i
3834 var l int
3835 _ = l
3836 if m.unknownFields != nil {
3837 i -= len(m.unknownFields)
3838 copy(dAtA[i:], m.unknownFields)
3839 }
3840 if len(m.SourcePolicies) > 0 {
3841 for iNdEx := len(m.SourcePolicies) - 1; iNdEx >= 0; iNdEx-- {
3842 size, err := m.SourcePolicies[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
3843 if err != nil {
3844 return 0, err
3845 }
3846 i -= size
3847 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3848 i--
3849 dAtA[i] = 0x7a
3850 }
3851 }
3852 if m.Evaluate {
3853 i--
3854 if m.Evaluate {
3855 dAtA[i] = 1
3856 } else {
3857 dAtA[i] = 0
3858 }
3859 i--
3860 dAtA[i] = 0x70
3861 }
3862 if len(m.FrontendInputs) > 0 {
3863 for k := range m.FrontendInputs {
3864 v := m.FrontendInputs[k]
3865 baseI := i
3866 size, err := v.MarshalToSizedBufferVT(dAtA[:i])
3867 if err != nil {
3868 return 0, err
3869 }
3870 i -= size
3871 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3872 i--
3873 dAtA[i] = 0x12
3874 i -= len(k)
3875 copy(dAtA[i:], k)
3876 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
3877 i--
3878 dAtA[i] = 0xa
3879 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
3880 i--
3881 dAtA[i] = 0x6a
3882 }
3883 }
3884 if len(m.CacheImports) > 0 {
3885 for iNdEx := len(m.CacheImports) - 1; iNdEx >= 0; iNdEx-- {
3886 size, err := m.CacheImports[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
3887 if err != nil {
3888 return 0, err
3889 }
3890 i -= size
3891 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3892 i--
3893 dAtA[i] = 0x62
3894 }
3895 }
3896 if len(m.ExporterAttr) > 0 {
3897 i -= len(m.ExporterAttr)
3898 copy(dAtA[i:], m.ExporterAttr)
3899 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExporterAttr)))
3900 i--
3901 dAtA[i] = 0x5a
3902 }
3903 if m.Final {
3904 i--
3905 if m.Final {
3906 dAtA[i] = 1
3907 } else {
3908 dAtA[i] = 0
3909 }
3910 i--
3911 dAtA[i] = 0x50
3912 }
3913 if m.AllowResultArrayRef {
3914 i--
3915 if m.AllowResultArrayRef {
3916 dAtA[i] = 1
3917 } else {
3918 dAtA[i] = 0
3919 }
3920 i--
3921 dAtA[i] = 0x30
3922 }
3923 if m.AllowResultReturn {
3924 i--
3925 if m.AllowResultReturn {
3926 dAtA[i] = 1
3927 } else {
3928 dAtA[i] = 0
3929 }
3930 i--
3931 dAtA[i] = 0x28
3932 }
3933 if len(m.FrontendOpt) > 0 {
3934 for k := range m.FrontendOpt {
3935 v := m.FrontendOpt[k]
3936 baseI := i
3937 i -= len(v)
3938 copy(dAtA[i:], v)
3939 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
3940 i--
3941 dAtA[i] = 0x12
3942 i -= len(k)
3943 copy(dAtA[i:], k)
3944 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
3945 i--
3946 dAtA[i] = 0xa
3947 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
3948 i--
3949 dAtA[i] = 0x1a
3950 }
3951 }
3952 if len(m.Frontend) > 0 {
3953 i -= len(m.Frontend)
3954 copy(dAtA[i:], m.Frontend)
3955 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Frontend)))
3956 i--
3957 dAtA[i] = 0x12
3958 }
3959 if m.Definition != nil {
3960 size, err := m.Definition.MarshalToSizedBufferVT(dAtA[:i])
3961 if err != nil {
3962 return 0, err
3963 }
3964 i -= size
3965 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
3966 i--
3967 dAtA[i] = 0xa
3968 }
3969 return len(dAtA) - i, nil
3970 }
3971
3972 func (m *CacheOptionsEntry) MarshalVT() (dAtA []byte, err error) {
3973 if m == nil {
3974 return nil, nil
3975 }
3976 size := m.SizeVT()
3977 dAtA = make([]byte, size)
3978 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
3979 if err != nil {
3980 return nil, err
3981 }
3982 return dAtA[:n], nil
3983 }
3984
3985 func (m *CacheOptionsEntry) MarshalToVT(dAtA []byte) (int, error) {
3986 size := m.SizeVT()
3987 return m.MarshalToSizedBufferVT(dAtA[:size])
3988 }
3989
3990 func (m *CacheOptionsEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
3991 if m == nil {
3992 return 0, nil
3993 }
3994 i := len(dAtA)
3995 _ = i
3996 var l int
3997 _ = l
3998 if m.unknownFields != nil {
3999 i -= len(m.unknownFields)
4000 copy(dAtA[i:], m.unknownFields)
4001 }
4002 if len(m.Attrs) > 0 {
4003 for k := range m.Attrs {
4004 v := m.Attrs[k]
4005 baseI := i
4006 i -= len(v)
4007 copy(dAtA[i:], v)
4008 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
4009 i--
4010 dAtA[i] = 0x12
4011 i -= len(k)
4012 copy(dAtA[i:], k)
4013 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
4014 i--
4015 dAtA[i] = 0xa
4016 i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
4017 i--
4018 dAtA[i] = 0x12
4019 }
4020 }
4021 if len(m.Type) > 0 {
4022 i -= len(m.Type)
4023 copy(dAtA[i:], m.Type)
4024 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Type)))
4025 i--
4026 dAtA[i] = 0xa
4027 }
4028 return len(dAtA) - i, nil
4029 }
4030
4031 func (m *SolveResponse) MarshalVT() (dAtA []byte, err error) {
4032 if m == nil {
4033 return nil, nil
4034 }
4035 size := m.SizeVT()
4036 dAtA = make([]byte, size)
4037 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4038 if err != nil {
4039 return nil, err
4040 }
4041 return dAtA[:n], nil
4042 }
4043
4044 func (m *SolveResponse) MarshalToVT(dAtA []byte) (int, error) {
4045 size := m.SizeVT()
4046 return m.MarshalToSizedBufferVT(dAtA[:size])
4047 }
4048
4049 func (m *SolveResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4050 if m == nil {
4051 return 0, nil
4052 }
4053 i := len(dAtA)
4054 _ = i
4055 var l int
4056 _ = l
4057 if m.unknownFields != nil {
4058 i -= len(m.unknownFields)
4059 copy(dAtA[i:], m.unknownFields)
4060 }
4061 if m.Result != nil {
4062 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
4063 if err != nil {
4064 return 0, err
4065 }
4066 i -= size
4067 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4068 i--
4069 dAtA[i] = 0x1a
4070 }
4071 if len(m.Ref) > 0 {
4072 i -= len(m.Ref)
4073 copy(dAtA[i:], m.Ref)
4074 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
4075 i--
4076 dAtA[i] = 0xa
4077 }
4078 return len(dAtA) - i, nil
4079 }
4080
4081 func (m *ReadFileRequest) MarshalVT() (dAtA []byte, err error) {
4082 if m == nil {
4083 return nil, nil
4084 }
4085 size := m.SizeVT()
4086 dAtA = make([]byte, size)
4087 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4088 if err != nil {
4089 return nil, err
4090 }
4091 return dAtA[:n], nil
4092 }
4093
4094 func (m *ReadFileRequest) MarshalToVT(dAtA []byte) (int, error) {
4095 size := m.SizeVT()
4096 return m.MarshalToSizedBufferVT(dAtA[:size])
4097 }
4098
4099 func (m *ReadFileRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4100 if m == nil {
4101 return 0, nil
4102 }
4103 i := len(dAtA)
4104 _ = i
4105 var l int
4106 _ = l
4107 if m.unknownFields != nil {
4108 i -= len(m.unknownFields)
4109 copy(dAtA[i:], m.unknownFields)
4110 }
4111 if m.Range != nil {
4112 size, err := m.Range.MarshalToSizedBufferVT(dAtA[:i])
4113 if err != nil {
4114 return 0, err
4115 }
4116 i -= size
4117 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4118 i--
4119 dAtA[i] = 0x1a
4120 }
4121 if len(m.FilePath) > 0 {
4122 i -= len(m.FilePath)
4123 copy(dAtA[i:], m.FilePath)
4124 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FilePath)))
4125 i--
4126 dAtA[i] = 0x12
4127 }
4128 if len(m.Ref) > 0 {
4129 i -= len(m.Ref)
4130 copy(dAtA[i:], m.Ref)
4131 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
4132 i--
4133 dAtA[i] = 0xa
4134 }
4135 return len(dAtA) - i, nil
4136 }
4137
4138 func (m *FileRange) MarshalVT() (dAtA []byte, err error) {
4139 if m == nil {
4140 return nil, nil
4141 }
4142 size := m.SizeVT()
4143 dAtA = make([]byte, size)
4144 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4145 if err != nil {
4146 return nil, err
4147 }
4148 return dAtA[:n], nil
4149 }
4150
4151 func (m *FileRange) MarshalToVT(dAtA []byte) (int, error) {
4152 size := m.SizeVT()
4153 return m.MarshalToSizedBufferVT(dAtA[:size])
4154 }
4155
4156 func (m *FileRange) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4157 if m == nil {
4158 return 0, nil
4159 }
4160 i := len(dAtA)
4161 _ = i
4162 var l int
4163 _ = l
4164 if m.unknownFields != nil {
4165 i -= len(m.unknownFields)
4166 copy(dAtA[i:], m.unknownFields)
4167 }
4168 if m.Length != 0 {
4169 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Length))
4170 i--
4171 dAtA[i] = 0x10
4172 }
4173 if m.Offset != 0 {
4174 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Offset))
4175 i--
4176 dAtA[i] = 0x8
4177 }
4178 return len(dAtA) - i, nil
4179 }
4180
4181 func (m *ReadFileResponse) MarshalVT() (dAtA []byte, err error) {
4182 if m == nil {
4183 return nil, nil
4184 }
4185 size := m.SizeVT()
4186 dAtA = make([]byte, size)
4187 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4188 if err != nil {
4189 return nil, err
4190 }
4191 return dAtA[:n], nil
4192 }
4193
4194 func (m *ReadFileResponse) MarshalToVT(dAtA []byte) (int, error) {
4195 size := m.SizeVT()
4196 return m.MarshalToSizedBufferVT(dAtA[:size])
4197 }
4198
4199 func (m *ReadFileResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4200 if m == nil {
4201 return 0, nil
4202 }
4203 i := len(dAtA)
4204 _ = i
4205 var l int
4206 _ = l
4207 if m.unknownFields != nil {
4208 i -= len(m.unknownFields)
4209 copy(dAtA[i:], m.unknownFields)
4210 }
4211 if len(m.Data) > 0 {
4212 i -= len(m.Data)
4213 copy(dAtA[i:], m.Data)
4214 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Data)))
4215 i--
4216 dAtA[i] = 0xa
4217 }
4218 return len(dAtA) - i, nil
4219 }
4220
4221 func (m *ReadDirRequest) MarshalVT() (dAtA []byte, err error) {
4222 if m == nil {
4223 return nil, nil
4224 }
4225 size := m.SizeVT()
4226 dAtA = make([]byte, size)
4227 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4228 if err != nil {
4229 return nil, err
4230 }
4231 return dAtA[:n], nil
4232 }
4233
4234 func (m *ReadDirRequest) MarshalToVT(dAtA []byte) (int, error) {
4235 size := m.SizeVT()
4236 return m.MarshalToSizedBufferVT(dAtA[:size])
4237 }
4238
4239 func (m *ReadDirRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4240 if m == nil {
4241 return 0, nil
4242 }
4243 i := len(dAtA)
4244 _ = i
4245 var l int
4246 _ = l
4247 if m.unknownFields != nil {
4248 i -= len(m.unknownFields)
4249 copy(dAtA[i:], m.unknownFields)
4250 }
4251 if len(m.IncludePattern) > 0 {
4252 i -= len(m.IncludePattern)
4253 copy(dAtA[i:], m.IncludePattern)
4254 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.IncludePattern)))
4255 i--
4256 dAtA[i] = 0x1a
4257 }
4258 if len(m.DirPath) > 0 {
4259 i -= len(m.DirPath)
4260 copy(dAtA[i:], m.DirPath)
4261 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DirPath)))
4262 i--
4263 dAtA[i] = 0x12
4264 }
4265 if len(m.Ref) > 0 {
4266 i -= len(m.Ref)
4267 copy(dAtA[i:], m.Ref)
4268 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
4269 i--
4270 dAtA[i] = 0xa
4271 }
4272 return len(dAtA) - i, nil
4273 }
4274
4275 func (m *ReadDirResponse) MarshalVT() (dAtA []byte, err error) {
4276 if m == nil {
4277 return nil, nil
4278 }
4279 size := m.SizeVT()
4280 dAtA = make([]byte, size)
4281 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4282 if err != nil {
4283 return nil, err
4284 }
4285 return dAtA[:n], nil
4286 }
4287
4288 func (m *ReadDirResponse) MarshalToVT(dAtA []byte) (int, error) {
4289 size := m.SizeVT()
4290 return m.MarshalToSizedBufferVT(dAtA[:size])
4291 }
4292
4293 func (m *ReadDirResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4294 if m == nil {
4295 return 0, nil
4296 }
4297 i := len(dAtA)
4298 _ = i
4299 var l int
4300 _ = l
4301 if m.unknownFields != nil {
4302 i -= len(m.unknownFields)
4303 copy(dAtA[i:], m.unknownFields)
4304 }
4305 if len(m.Entries) > 0 {
4306 for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
4307 if vtmsg, ok := interface{}(m.Entries[iNdEx]).(interface {
4308 MarshalToSizedBufferVT([]byte) (int, error)
4309 }); ok {
4310 size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
4311 if err != nil {
4312 return 0, err
4313 }
4314 i -= size
4315 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4316 } else {
4317 encoded, err := proto.Marshal(m.Entries[iNdEx])
4318 if err != nil {
4319 return 0, err
4320 }
4321 i -= len(encoded)
4322 copy(dAtA[i:], encoded)
4323 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4324 }
4325 i--
4326 dAtA[i] = 0xa
4327 }
4328 }
4329 return len(dAtA) - i, nil
4330 }
4331
4332 func (m *StatFileRequest) MarshalVT() (dAtA []byte, err error) {
4333 if m == nil {
4334 return nil, nil
4335 }
4336 size := m.SizeVT()
4337 dAtA = make([]byte, size)
4338 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4339 if err != nil {
4340 return nil, err
4341 }
4342 return dAtA[:n], nil
4343 }
4344
4345 func (m *StatFileRequest) MarshalToVT(dAtA []byte) (int, error) {
4346 size := m.SizeVT()
4347 return m.MarshalToSizedBufferVT(dAtA[:size])
4348 }
4349
4350 func (m *StatFileRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4351 if m == nil {
4352 return 0, nil
4353 }
4354 i := len(dAtA)
4355 _ = i
4356 var l int
4357 _ = l
4358 if m.unknownFields != nil {
4359 i -= len(m.unknownFields)
4360 copy(dAtA[i:], m.unknownFields)
4361 }
4362 if len(m.Path) > 0 {
4363 i -= len(m.Path)
4364 copy(dAtA[i:], m.Path)
4365 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))
4366 i--
4367 dAtA[i] = 0x12
4368 }
4369 if len(m.Ref) > 0 {
4370 i -= len(m.Ref)
4371 copy(dAtA[i:], m.Ref)
4372 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
4373 i--
4374 dAtA[i] = 0xa
4375 }
4376 return len(dAtA) - i, nil
4377 }
4378
4379 func (m *StatFileResponse) MarshalVT() (dAtA []byte, err error) {
4380 if m == nil {
4381 return nil, nil
4382 }
4383 size := m.SizeVT()
4384 dAtA = make([]byte, size)
4385 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4386 if err != nil {
4387 return nil, err
4388 }
4389 return dAtA[:n], nil
4390 }
4391
4392 func (m *StatFileResponse) MarshalToVT(dAtA []byte) (int, error) {
4393 size := m.SizeVT()
4394 return m.MarshalToSizedBufferVT(dAtA[:size])
4395 }
4396
4397 func (m *StatFileResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4398 if m == nil {
4399 return 0, nil
4400 }
4401 i := len(dAtA)
4402 _ = i
4403 var l int
4404 _ = l
4405 if m.unknownFields != nil {
4406 i -= len(m.unknownFields)
4407 copy(dAtA[i:], m.unknownFields)
4408 }
4409 if m.Stat != nil {
4410 if vtmsg, ok := interface{}(m.Stat).(interface {
4411 MarshalToSizedBufferVT([]byte) (int, error)
4412 }); ok {
4413 size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
4414 if err != nil {
4415 return 0, err
4416 }
4417 i -= size
4418 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4419 } else {
4420 encoded, err := proto.Marshal(m.Stat)
4421 if err != nil {
4422 return 0, err
4423 }
4424 i -= len(encoded)
4425 copy(dAtA[i:], encoded)
4426 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
4427 }
4428 i--
4429 dAtA[i] = 0xa
4430 }
4431 return len(dAtA) - i, nil
4432 }
4433
4434 func (m *EvaluateRequest) MarshalVT() (dAtA []byte, err error) {
4435 if m == nil {
4436 return nil, nil
4437 }
4438 size := m.SizeVT()
4439 dAtA = make([]byte, size)
4440 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4441 if err != nil {
4442 return nil, err
4443 }
4444 return dAtA[:n], nil
4445 }
4446
4447 func (m *EvaluateRequest) MarshalToVT(dAtA []byte) (int, error) {
4448 size := m.SizeVT()
4449 return m.MarshalToSizedBufferVT(dAtA[:size])
4450 }
4451
4452 func (m *EvaluateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4453 if m == nil {
4454 return 0, nil
4455 }
4456 i := len(dAtA)
4457 _ = i
4458 var l int
4459 _ = l
4460 if m.unknownFields != nil {
4461 i -= len(m.unknownFields)
4462 copy(dAtA[i:], m.unknownFields)
4463 }
4464 if len(m.Ref) > 0 {
4465 i -= len(m.Ref)
4466 copy(dAtA[i:], m.Ref)
4467 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ref)))
4468 i--
4469 dAtA[i] = 0xa
4470 }
4471 return len(dAtA) - i, nil
4472 }
4473
4474 func (m *EvaluateResponse) MarshalVT() (dAtA []byte, err error) {
4475 if m == nil {
4476 return nil, nil
4477 }
4478 size := m.SizeVT()
4479 dAtA = make([]byte, size)
4480 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4481 if err != nil {
4482 return nil, err
4483 }
4484 return dAtA[:n], nil
4485 }
4486
4487 func (m *EvaluateResponse) MarshalToVT(dAtA []byte) (int, error) {
4488 size := m.SizeVT()
4489 return m.MarshalToSizedBufferVT(dAtA[:size])
4490 }
4491
4492 func (m *EvaluateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4493 if m == nil {
4494 return 0, nil
4495 }
4496 i := len(dAtA)
4497 _ = i
4498 var l int
4499 _ = l
4500 if m.unknownFields != nil {
4501 i -= len(m.unknownFields)
4502 copy(dAtA[i:], m.unknownFields)
4503 }
4504 return len(dAtA) - i, nil
4505 }
4506
4507 func (m *PingRequest) MarshalVT() (dAtA []byte, err error) {
4508 if m == nil {
4509 return nil, nil
4510 }
4511 size := m.SizeVT()
4512 dAtA = make([]byte, size)
4513 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4514 if err != nil {
4515 return nil, err
4516 }
4517 return dAtA[:n], nil
4518 }
4519
4520 func (m *PingRequest) MarshalToVT(dAtA []byte) (int, error) {
4521 size := m.SizeVT()
4522 return m.MarshalToSizedBufferVT(dAtA[:size])
4523 }
4524
4525 func (m *PingRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4526 if m == nil {
4527 return 0, nil
4528 }
4529 i := len(dAtA)
4530 _ = i
4531 var l int
4532 _ = l
4533 if m.unknownFields != nil {
4534 i -= len(m.unknownFields)
4535 copy(dAtA[i:], m.unknownFields)
4536 }
4537 return len(dAtA) - i, nil
4538 }
4539
4540 func (m *PongResponse) MarshalVT() (dAtA []byte, err error) {
4541 if m == nil {
4542 return nil, nil
4543 }
4544 size := m.SizeVT()
4545 dAtA = make([]byte, size)
4546 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4547 if err != nil {
4548 return nil, err
4549 }
4550 return dAtA[:n], nil
4551 }
4552
4553 func (m *PongResponse) MarshalToVT(dAtA []byte) (int, error) {
4554 size := m.SizeVT()
4555 return m.MarshalToSizedBufferVT(dAtA[:size])
4556 }
4557
4558 func (m *PongResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4559 if m == nil {
4560 return 0, nil
4561 }
4562 i := len(dAtA)
4563 _ = i
4564 var l int
4565 _ = l
4566 if m.unknownFields != nil {
4567 i -= len(m.unknownFields)
4568 copy(dAtA[i:], m.unknownFields)
4569 }
4570 if len(m.Workers) > 0 {
4571 for iNdEx := len(m.Workers) - 1; iNdEx >= 0; iNdEx-- {
4572 size, err := m.Workers[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
4573 if err != nil {
4574 return 0, err
4575 }
4576 i -= size
4577 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4578 i--
4579 dAtA[i] = 0x1a
4580 }
4581 }
4582 if len(m.LLBCaps) > 0 {
4583 for iNdEx := len(m.LLBCaps) - 1; iNdEx >= 0; iNdEx-- {
4584 size, err := m.LLBCaps[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
4585 if err != nil {
4586 return 0, err
4587 }
4588 i -= size
4589 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4590 i--
4591 dAtA[i] = 0x12
4592 }
4593 }
4594 if len(m.FrontendAPICaps) > 0 {
4595 for iNdEx := len(m.FrontendAPICaps) - 1; iNdEx >= 0; iNdEx-- {
4596 size, err := m.FrontendAPICaps[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
4597 if err != nil {
4598 return 0, err
4599 }
4600 i -= size
4601 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4602 i--
4603 dAtA[i] = 0xa
4604 }
4605 }
4606 return len(dAtA) - i, nil
4607 }
4608
4609 func (m *WarnRequest) MarshalVT() (dAtA []byte, err error) {
4610 if m == nil {
4611 return nil, nil
4612 }
4613 size := m.SizeVT()
4614 dAtA = make([]byte, size)
4615 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4616 if err != nil {
4617 return nil, err
4618 }
4619 return dAtA[:n], nil
4620 }
4621
4622 func (m *WarnRequest) MarshalToVT(dAtA []byte) (int, error) {
4623 size := m.SizeVT()
4624 return m.MarshalToSizedBufferVT(dAtA[:size])
4625 }
4626
4627 func (m *WarnRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4628 if m == nil {
4629 return 0, nil
4630 }
4631 i := len(dAtA)
4632 _ = i
4633 var l int
4634 _ = l
4635 if m.unknownFields != nil {
4636 i -= len(m.unknownFields)
4637 copy(dAtA[i:], m.unknownFields)
4638 }
4639 if len(m.Ranges) > 0 {
4640 for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- {
4641 size, err := m.Ranges[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
4642 if err != nil {
4643 return 0, err
4644 }
4645 i -= size
4646 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4647 i--
4648 dAtA[i] = 0x3a
4649 }
4650 }
4651 if m.Info != nil {
4652 size, err := m.Info.MarshalToSizedBufferVT(dAtA[:i])
4653 if err != nil {
4654 return 0, err
4655 }
4656 i -= size
4657 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4658 i--
4659 dAtA[i] = 0x32
4660 }
4661 if len(m.Url) > 0 {
4662 i -= len(m.Url)
4663 copy(dAtA[i:], m.Url)
4664 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Url)))
4665 i--
4666 dAtA[i] = 0x2a
4667 }
4668 if len(m.Detail) > 0 {
4669 for iNdEx := len(m.Detail) - 1; iNdEx >= 0; iNdEx-- {
4670 i -= len(m.Detail[iNdEx])
4671 copy(dAtA[i:], m.Detail[iNdEx])
4672 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Detail[iNdEx])))
4673 i--
4674 dAtA[i] = 0x22
4675 }
4676 }
4677 if len(m.Short) > 0 {
4678 i -= len(m.Short)
4679 copy(dAtA[i:], m.Short)
4680 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Short)))
4681 i--
4682 dAtA[i] = 0x1a
4683 }
4684 if m.Level != 0 {
4685 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Level))
4686 i--
4687 dAtA[i] = 0x10
4688 }
4689 if len(m.Digest) > 0 {
4690 i -= len(m.Digest)
4691 copy(dAtA[i:], m.Digest)
4692 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Digest)))
4693 i--
4694 dAtA[i] = 0xa
4695 }
4696 return len(dAtA) - i, nil
4697 }
4698
4699 func (m *WarnResponse) MarshalVT() (dAtA []byte, err error) {
4700 if m == nil {
4701 return nil, nil
4702 }
4703 size := m.SizeVT()
4704 dAtA = make([]byte, size)
4705 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4706 if err != nil {
4707 return nil, err
4708 }
4709 return dAtA[:n], nil
4710 }
4711
4712 func (m *WarnResponse) MarshalToVT(dAtA []byte) (int, error) {
4713 size := m.SizeVT()
4714 return m.MarshalToSizedBufferVT(dAtA[:size])
4715 }
4716
4717 func (m *WarnResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4718 if m == nil {
4719 return 0, nil
4720 }
4721 i := len(dAtA)
4722 _ = i
4723 var l int
4724 _ = l
4725 if m.unknownFields != nil {
4726 i -= len(m.unknownFields)
4727 copy(dAtA[i:], m.unknownFields)
4728 }
4729 return len(dAtA) - i, nil
4730 }
4731
4732 func (m *NewContainerRequest) MarshalVT() (dAtA []byte, err error) {
4733 if m == nil {
4734 return nil, nil
4735 }
4736 size := m.SizeVT()
4737 dAtA = make([]byte, size)
4738 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4739 if err != nil {
4740 return nil, err
4741 }
4742 return dAtA[:n], nil
4743 }
4744
4745 func (m *NewContainerRequest) MarshalToVT(dAtA []byte) (int, error) {
4746 size := m.SizeVT()
4747 return m.MarshalToSizedBufferVT(dAtA[:size])
4748 }
4749
4750 func (m *NewContainerRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4751 if m == nil {
4752 return 0, nil
4753 }
4754 i := len(dAtA)
4755 _ = i
4756 var l int
4757 _ = l
4758 if m.unknownFields != nil {
4759 i -= len(m.unknownFields)
4760 copy(dAtA[i:], m.unknownFields)
4761 }
4762 if len(m.Hostname) > 0 {
4763 i -= len(m.Hostname)
4764 copy(dAtA[i:], m.Hostname)
4765 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
4766 i--
4767 dAtA[i] = 0x3a
4768 }
4769 if len(m.ExtraHosts) > 0 {
4770 for iNdEx := len(m.ExtraHosts) - 1; iNdEx >= 0; iNdEx-- {
4771 size, err := m.ExtraHosts[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
4772 if err != nil {
4773 return 0, err
4774 }
4775 i -= size
4776 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4777 i--
4778 dAtA[i] = 0x32
4779 }
4780 }
4781 if m.Constraints != nil {
4782 size, err := m.Constraints.MarshalToSizedBufferVT(dAtA[:i])
4783 if err != nil {
4784 return 0, err
4785 }
4786 i -= size
4787 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4788 i--
4789 dAtA[i] = 0x2a
4790 }
4791 if m.Platform != nil {
4792 size, err := m.Platform.MarshalToSizedBufferVT(dAtA[:i])
4793 if err != nil {
4794 return 0, err
4795 }
4796 i -= size
4797 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4798 i--
4799 dAtA[i] = 0x22
4800 }
4801 if m.Network != 0 {
4802 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Network))
4803 i--
4804 dAtA[i] = 0x18
4805 }
4806 if len(m.Mounts) > 0 {
4807 for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- {
4808 size, err := m.Mounts[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
4809 if err != nil {
4810 return 0, err
4811 }
4812 i -= size
4813 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4814 i--
4815 dAtA[i] = 0x12
4816 }
4817 }
4818 if len(m.ContainerID) > 0 {
4819 i -= len(m.ContainerID)
4820 copy(dAtA[i:], m.ContainerID)
4821 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainerID)))
4822 i--
4823 dAtA[i] = 0xa
4824 }
4825 return len(dAtA) - i, nil
4826 }
4827
4828 func (m *NewContainerResponse) MarshalVT() (dAtA []byte, err error) {
4829 if m == nil {
4830 return nil, nil
4831 }
4832 size := m.SizeVT()
4833 dAtA = make([]byte, size)
4834 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4835 if err != nil {
4836 return nil, err
4837 }
4838 return dAtA[:n], nil
4839 }
4840
4841 func (m *NewContainerResponse) MarshalToVT(dAtA []byte) (int, error) {
4842 size := m.SizeVT()
4843 return m.MarshalToSizedBufferVT(dAtA[:size])
4844 }
4845
4846 func (m *NewContainerResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4847 if m == nil {
4848 return 0, nil
4849 }
4850 i := len(dAtA)
4851 _ = i
4852 var l int
4853 _ = l
4854 if m.unknownFields != nil {
4855 i -= len(m.unknownFields)
4856 copy(dAtA[i:], m.unknownFields)
4857 }
4858 return len(dAtA) - i, nil
4859 }
4860
4861 func (m *ReleaseContainerRequest) MarshalVT() (dAtA []byte, err error) {
4862 if m == nil {
4863 return nil, nil
4864 }
4865 size := m.SizeVT()
4866 dAtA = make([]byte, size)
4867 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4868 if err != nil {
4869 return nil, err
4870 }
4871 return dAtA[:n], nil
4872 }
4873
4874 func (m *ReleaseContainerRequest) MarshalToVT(dAtA []byte) (int, error) {
4875 size := m.SizeVT()
4876 return m.MarshalToSizedBufferVT(dAtA[:size])
4877 }
4878
4879 func (m *ReleaseContainerRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4880 if m == nil {
4881 return 0, nil
4882 }
4883 i := len(dAtA)
4884 _ = i
4885 var l int
4886 _ = l
4887 if m.unknownFields != nil {
4888 i -= len(m.unknownFields)
4889 copy(dAtA[i:], m.unknownFields)
4890 }
4891 if len(m.ContainerID) > 0 {
4892 i -= len(m.ContainerID)
4893 copy(dAtA[i:], m.ContainerID)
4894 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainerID)))
4895 i--
4896 dAtA[i] = 0xa
4897 }
4898 return len(dAtA) - i, nil
4899 }
4900
4901 func (m *ReleaseContainerResponse) MarshalVT() (dAtA []byte, err error) {
4902 if m == nil {
4903 return nil, nil
4904 }
4905 size := m.SizeVT()
4906 dAtA = make([]byte, size)
4907 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4908 if err != nil {
4909 return nil, err
4910 }
4911 return dAtA[:n], nil
4912 }
4913
4914 func (m *ReleaseContainerResponse) MarshalToVT(dAtA []byte) (int, error) {
4915 size := m.SizeVT()
4916 return m.MarshalToSizedBufferVT(dAtA[:size])
4917 }
4918
4919 func (m *ReleaseContainerResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4920 if m == nil {
4921 return 0, nil
4922 }
4923 i := len(dAtA)
4924 _ = i
4925 var l int
4926 _ = l
4927 if m.unknownFields != nil {
4928 i -= len(m.unknownFields)
4929 copy(dAtA[i:], m.unknownFields)
4930 }
4931 return len(dAtA) - i, nil
4932 }
4933
4934 func (m *ExecMessage) MarshalVT() (dAtA []byte, err error) {
4935 if m == nil {
4936 return nil, nil
4937 }
4938 size := m.SizeVT()
4939 dAtA = make([]byte, size)
4940 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
4941 if err != nil {
4942 return nil, err
4943 }
4944 return dAtA[:n], nil
4945 }
4946
4947 func (m *ExecMessage) MarshalToVT(dAtA []byte) (int, error) {
4948 size := m.SizeVT()
4949 return m.MarshalToSizedBufferVT(dAtA[:size])
4950 }
4951
4952 func (m *ExecMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4953 if m == nil {
4954 return 0, nil
4955 }
4956 i := len(dAtA)
4957 _ = i
4958 var l int
4959 _ = l
4960 if m.unknownFields != nil {
4961 i -= len(m.unknownFields)
4962 copy(dAtA[i:], m.unknownFields)
4963 }
4964 if vtmsg, ok := m.Input.(interface {
4965 MarshalToSizedBufferVT([]byte) (int, error)
4966 }); ok {
4967 size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
4968 if err != nil {
4969 return 0, err
4970 }
4971 i -= size
4972 }
4973 if len(m.ProcessID) > 0 {
4974 i -= len(m.ProcessID)
4975 copy(dAtA[i:], m.ProcessID)
4976 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ProcessID)))
4977 i--
4978 dAtA[i] = 0xa
4979 }
4980 return len(dAtA) - i, nil
4981 }
4982
4983 func (m *ExecMessage_Init) MarshalToVT(dAtA []byte) (int, error) {
4984 size := m.SizeVT()
4985 return m.MarshalToSizedBufferVT(dAtA[:size])
4986 }
4987
4988 func (m *ExecMessage_Init) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
4989 i := len(dAtA)
4990 if m.Init != nil {
4991 size, err := m.Init.MarshalToSizedBufferVT(dAtA[:i])
4992 if err != nil {
4993 return 0, err
4994 }
4995 i -= size
4996 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
4997 i--
4998 dAtA[i] = 0x12
4999 } else {
5000 i = protohelpers.EncodeVarint(dAtA, i, 0)
5001 i--
5002 dAtA[i] = 0x12
5003 }
5004 return len(dAtA) - i, nil
5005 }
5006 func (m *ExecMessage_File) MarshalToVT(dAtA []byte) (int, error) {
5007 size := m.SizeVT()
5008 return m.MarshalToSizedBufferVT(dAtA[:size])
5009 }
5010
5011 func (m *ExecMessage_File) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5012 i := len(dAtA)
5013 if m.File != nil {
5014 size, err := m.File.MarshalToSizedBufferVT(dAtA[:i])
5015 if err != nil {
5016 return 0, err
5017 }
5018 i -= size
5019 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5020 i--
5021 dAtA[i] = 0x1a
5022 } else {
5023 i = protohelpers.EncodeVarint(dAtA, i, 0)
5024 i--
5025 dAtA[i] = 0x1a
5026 }
5027 return len(dAtA) - i, nil
5028 }
5029 func (m *ExecMessage_Resize) MarshalToVT(dAtA []byte) (int, error) {
5030 size := m.SizeVT()
5031 return m.MarshalToSizedBufferVT(dAtA[:size])
5032 }
5033
5034 func (m *ExecMessage_Resize) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5035 i := len(dAtA)
5036 if m.Resize != nil {
5037 size, err := m.Resize.MarshalToSizedBufferVT(dAtA[:i])
5038 if err != nil {
5039 return 0, err
5040 }
5041 i -= size
5042 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5043 i--
5044 dAtA[i] = 0x22
5045 } else {
5046 i = protohelpers.EncodeVarint(dAtA, i, 0)
5047 i--
5048 dAtA[i] = 0x22
5049 }
5050 return len(dAtA) - i, nil
5051 }
5052 func (m *ExecMessage_Started) MarshalToVT(dAtA []byte) (int, error) {
5053 size := m.SizeVT()
5054 return m.MarshalToSizedBufferVT(dAtA[:size])
5055 }
5056
5057 func (m *ExecMessage_Started) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5058 i := len(dAtA)
5059 if m.Started != nil {
5060 size, err := m.Started.MarshalToSizedBufferVT(dAtA[:i])
5061 if err != nil {
5062 return 0, err
5063 }
5064 i -= size
5065 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5066 i--
5067 dAtA[i] = 0x2a
5068 } else {
5069 i = protohelpers.EncodeVarint(dAtA, i, 0)
5070 i--
5071 dAtA[i] = 0x2a
5072 }
5073 return len(dAtA) - i, nil
5074 }
5075 func (m *ExecMessage_Exit) MarshalToVT(dAtA []byte) (int, error) {
5076 size := m.SizeVT()
5077 return m.MarshalToSizedBufferVT(dAtA[:size])
5078 }
5079
5080 func (m *ExecMessage_Exit) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5081 i := len(dAtA)
5082 if m.Exit != nil {
5083 size, err := m.Exit.MarshalToSizedBufferVT(dAtA[:i])
5084 if err != nil {
5085 return 0, err
5086 }
5087 i -= size
5088 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5089 i--
5090 dAtA[i] = 0x32
5091 } else {
5092 i = protohelpers.EncodeVarint(dAtA, i, 0)
5093 i--
5094 dAtA[i] = 0x32
5095 }
5096 return len(dAtA) - i, nil
5097 }
5098 func (m *ExecMessage_Done) MarshalToVT(dAtA []byte) (int, error) {
5099 size := m.SizeVT()
5100 return m.MarshalToSizedBufferVT(dAtA[:size])
5101 }
5102
5103 func (m *ExecMessage_Done) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5104 i := len(dAtA)
5105 if m.Done != nil {
5106 size, err := m.Done.MarshalToSizedBufferVT(dAtA[:i])
5107 if err != nil {
5108 return 0, err
5109 }
5110 i -= size
5111 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5112 i--
5113 dAtA[i] = 0x3a
5114 } else {
5115 i = protohelpers.EncodeVarint(dAtA, i, 0)
5116 i--
5117 dAtA[i] = 0x3a
5118 }
5119 return len(dAtA) - i, nil
5120 }
5121 func (m *ExecMessage_Signal) MarshalToVT(dAtA []byte) (int, error) {
5122 size := m.SizeVT()
5123 return m.MarshalToSizedBufferVT(dAtA[:size])
5124 }
5125
5126 func (m *ExecMessage_Signal) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5127 i := len(dAtA)
5128 if m.Signal != nil {
5129 size, err := m.Signal.MarshalToSizedBufferVT(dAtA[:i])
5130 if err != nil {
5131 return 0, err
5132 }
5133 i -= size
5134 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5135 i--
5136 dAtA[i] = 0x42
5137 } else {
5138 i = protohelpers.EncodeVarint(dAtA, i, 0)
5139 i--
5140 dAtA[i] = 0x42
5141 }
5142 return len(dAtA) - i, nil
5143 }
5144 func (m *InitMessage) MarshalVT() (dAtA []byte, err error) {
5145 if m == nil {
5146 return nil, nil
5147 }
5148 size := m.SizeVT()
5149 dAtA = make([]byte, size)
5150 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5151 if err != nil {
5152 return nil, err
5153 }
5154 return dAtA[:n], nil
5155 }
5156
5157 func (m *InitMessage) MarshalToVT(dAtA []byte) (int, error) {
5158 size := m.SizeVT()
5159 return m.MarshalToSizedBufferVT(dAtA[:size])
5160 }
5161
5162 func (m *InitMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5163 if m == nil {
5164 return 0, nil
5165 }
5166 i := len(dAtA)
5167 _ = i
5168 var l int
5169 _ = l
5170 if m.unknownFields != nil {
5171 i -= len(m.unknownFields)
5172 copy(dAtA[i:], m.unknownFields)
5173 }
5174 if len(m.Secretenv) > 0 {
5175 for iNdEx := len(m.Secretenv) - 1; iNdEx >= 0; iNdEx-- {
5176 size, err := m.Secretenv[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
5177 if err != nil {
5178 return 0, err
5179 }
5180 i -= size
5181 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5182 i--
5183 dAtA[i] = 0x32
5184 }
5185 }
5186 if m.Security != 0 {
5187 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Security))
5188 i--
5189 dAtA[i] = 0x28
5190 }
5191 if m.Tty {
5192 i--
5193 if m.Tty {
5194 dAtA[i] = 1
5195 } else {
5196 dAtA[i] = 0
5197 }
5198 i--
5199 dAtA[i] = 0x20
5200 }
5201 if len(m.Fds) > 0 {
5202 var pksize2 int
5203 for _, num := range m.Fds {
5204 pksize2 += protohelpers.SizeOfVarint(uint64(num))
5205 }
5206 i -= pksize2
5207 j1 := i
5208 for _, num := range m.Fds {
5209 for num >= 1<<7 {
5210 dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
5211 num >>= 7
5212 j1++
5213 }
5214 dAtA[j1] = uint8(num)
5215 j1++
5216 }
5217 i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))
5218 i--
5219 dAtA[i] = 0x1a
5220 }
5221 if m.Meta != nil {
5222 size, err := m.Meta.MarshalToSizedBufferVT(dAtA[:i])
5223 if err != nil {
5224 return 0, err
5225 }
5226 i -= size
5227 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5228 i--
5229 dAtA[i] = 0x12
5230 }
5231 if len(m.ContainerID) > 0 {
5232 i -= len(m.ContainerID)
5233 copy(dAtA[i:], m.ContainerID)
5234 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContainerID)))
5235 i--
5236 dAtA[i] = 0xa
5237 }
5238 return len(dAtA) - i, nil
5239 }
5240
5241 func (m *ExitMessage) MarshalVT() (dAtA []byte, err error) {
5242 if m == nil {
5243 return nil, nil
5244 }
5245 size := m.SizeVT()
5246 dAtA = make([]byte, size)
5247 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5248 if err != nil {
5249 return nil, err
5250 }
5251 return dAtA[:n], nil
5252 }
5253
5254 func (m *ExitMessage) MarshalToVT(dAtA []byte) (int, error) {
5255 size := m.SizeVT()
5256 return m.MarshalToSizedBufferVT(dAtA[:size])
5257 }
5258
5259 func (m *ExitMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5260 if m == nil {
5261 return 0, nil
5262 }
5263 i := len(dAtA)
5264 _ = i
5265 var l int
5266 _ = l
5267 if m.unknownFields != nil {
5268 i -= len(m.unknownFields)
5269 copy(dAtA[i:], m.unknownFields)
5270 }
5271 if m.Error != nil {
5272 if vtmsg, ok := interface{}(m.Error).(interface {
5273 MarshalToSizedBufferVT([]byte) (int, error)
5274 }); ok {
5275 size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
5276 if err != nil {
5277 return 0, err
5278 }
5279 i -= size
5280 i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
5281 } else {
5282 encoded, err := proto.Marshal(m.Error)
5283 if err != nil {
5284 return 0, err
5285 }
5286 i -= len(encoded)
5287 copy(dAtA[i:], encoded)
5288 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
5289 }
5290 i--
5291 dAtA[i] = 0x12
5292 }
5293 if m.Code != 0 {
5294 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Code))
5295 i--
5296 dAtA[i] = 0x8
5297 }
5298 return len(dAtA) - i, nil
5299 }
5300
5301 func (m *StartedMessage) MarshalVT() (dAtA []byte, err error) {
5302 if m == nil {
5303 return nil, nil
5304 }
5305 size := m.SizeVT()
5306 dAtA = make([]byte, size)
5307 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5308 if err != nil {
5309 return nil, err
5310 }
5311 return dAtA[:n], nil
5312 }
5313
5314 func (m *StartedMessage) MarshalToVT(dAtA []byte) (int, error) {
5315 size := m.SizeVT()
5316 return m.MarshalToSizedBufferVT(dAtA[:size])
5317 }
5318
5319 func (m *StartedMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5320 if m == nil {
5321 return 0, nil
5322 }
5323 i := len(dAtA)
5324 _ = i
5325 var l int
5326 _ = l
5327 if m.unknownFields != nil {
5328 i -= len(m.unknownFields)
5329 copy(dAtA[i:], m.unknownFields)
5330 }
5331 return len(dAtA) - i, nil
5332 }
5333
5334 func (m *DoneMessage) MarshalVT() (dAtA []byte, err error) {
5335 if m == nil {
5336 return nil, nil
5337 }
5338 size := m.SizeVT()
5339 dAtA = make([]byte, size)
5340 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5341 if err != nil {
5342 return nil, err
5343 }
5344 return dAtA[:n], nil
5345 }
5346
5347 func (m *DoneMessage) MarshalToVT(dAtA []byte) (int, error) {
5348 size := m.SizeVT()
5349 return m.MarshalToSizedBufferVT(dAtA[:size])
5350 }
5351
5352 func (m *DoneMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5353 if m == nil {
5354 return 0, nil
5355 }
5356 i := len(dAtA)
5357 _ = i
5358 var l int
5359 _ = l
5360 if m.unknownFields != nil {
5361 i -= len(m.unknownFields)
5362 copy(dAtA[i:], m.unknownFields)
5363 }
5364 return len(dAtA) - i, nil
5365 }
5366
5367 func (m *FdMessage) MarshalVT() (dAtA []byte, err error) {
5368 if m == nil {
5369 return nil, nil
5370 }
5371 size := m.SizeVT()
5372 dAtA = make([]byte, size)
5373 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5374 if err != nil {
5375 return nil, err
5376 }
5377 return dAtA[:n], nil
5378 }
5379
5380 func (m *FdMessage) MarshalToVT(dAtA []byte) (int, error) {
5381 size := m.SizeVT()
5382 return m.MarshalToSizedBufferVT(dAtA[:size])
5383 }
5384
5385 func (m *FdMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5386 if m == nil {
5387 return 0, nil
5388 }
5389 i := len(dAtA)
5390 _ = i
5391 var l int
5392 _ = l
5393 if m.unknownFields != nil {
5394 i -= len(m.unknownFields)
5395 copy(dAtA[i:], m.unknownFields)
5396 }
5397 if len(m.Data) > 0 {
5398 i -= len(m.Data)
5399 copy(dAtA[i:], m.Data)
5400 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Data)))
5401 i--
5402 dAtA[i] = 0x1a
5403 }
5404 if m.EOF {
5405 i--
5406 if m.EOF {
5407 dAtA[i] = 1
5408 } else {
5409 dAtA[i] = 0
5410 }
5411 i--
5412 dAtA[i] = 0x10
5413 }
5414 if m.Fd != 0 {
5415 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Fd))
5416 i--
5417 dAtA[i] = 0x8
5418 }
5419 return len(dAtA) - i, nil
5420 }
5421
5422 func (m *ResizeMessage) MarshalVT() (dAtA []byte, err error) {
5423 if m == nil {
5424 return nil, nil
5425 }
5426 size := m.SizeVT()
5427 dAtA = make([]byte, size)
5428 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5429 if err != nil {
5430 return nil, err
5431 }
5432 return dAtA[:n], nil
5433 }
5434
5435 func (m *ResizeMessage) MarshalToVT(dAtA []byte) (int, error) {
5436 size := m.SizeVT()
5437 return m.MarshalToSizedBufferVT(dAtA[:size])
5438 }
5439
5440 func (m *ResizeMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5441 if m == nil {
5442 return 0, nil
5443 }
5444 i := len(dAtA)
5445 _ = i
5446 var l int
5447 _ = l
5448 if m.unknownFields != nil {
5449 i -= len(m.unknownFields)
5450 copy(dAtA[i:], m.unknownFields)
5451 }
5452 if m.Cols != 0 {
5453 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Cols))
5454 i--
5455 dAtA[i] = 0x10
5456 }
5457 if m.Rows != 0 {
5458 i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Rows))
5459 i--
5460 dAtA[i] = 0x8
5461 }
5462 return len(dAtA) - i, nil
5463 }
5464
5465 func (m *SignalMessage) MarshalVT() (dAtA []byte, err error) {
5466 if m == nil {
5467 return nil, nil
5468 }
5469 size := m.SizeVT()
5470 dAtA = make([]byte, size)
5471 n, err := m.MarshalToSizedBufferVT(dAtA[:size])
5472 if err != nil {
5473 return nil, err
5474 }
5475 return dAtA[:n], nil
5476 }
5477
5478 func (m *SignalMessage) MarshalToVT(dAtA []byte) (int, error) {
5479 size := m.SizeVT()
5480 return m.MarshalToSizedBufferVT(dAtA[:size])
5481 }
5482
5483 func (m *SignalMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
5484 if m == nil {
5485 return 0, nil
5486 }
5487 i := len(dAtA)
5488 _ = i
5489 var l int
5490 _ = l
5491 if m.unknownFields != nil {
5492 i -= len(m.unknownFields)
5493 copy(dAtA[i:], m.unknownFields)
5494 }
5495 if len(m.Name) > 0 {
5496 i -= len(m.Name)
5497 copy(dAtA[i:], m.Name)
5498 i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
5499 i--
5500 dAtA[i] = 0xa
5501 }
5502 return len(dAtA) - i, nil
5503 }
5504
5505 func (m *Result) SizeVT() (n int) {
5506 if m == nil {
5507 return 0
5508 }
5509 var l int
5510 _ = l
5511 if vtmsg, ok := m.Result.(interface{ SizeVT() int }); ok {
5512 n += vtmsg.SizeVT()
5513 }
5514 if len(m.Metadata) > 0 {
5515 for k, v := range m.Metadata {
5516 _ = k
5517 _ = v
5518 l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))
5519 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
5520 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5521 }
5522 }
5523 if len(m.Attestations) > 0 {
5524 for k, v := range m.Attestations {
5525 _ = k
5526 _ = v
5527 l = 0
5528 if v != nil {
5529 l = v.SizeVT()
5530 }
5531 l += 1 + protohelpers.SizeOfVarint(uint64(l))
5532 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
5533 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5534 }
5535 }
5536 n += len(m.unknownFields)
5537 return n
5538 }
5539
5540 func (m *Result_RefDeprecated) SizeVT() (n int) {
5541 if m == nil {
5542 return 0
5543 }
5544 var l int
5545 _ = l
5546 l = len(m.RefDeprecated)
5547 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5548 return n
5549 }
5550 func (m *Result_RefsDeprecated) SizeVT() (n int) {
5551 if m == nil {
5552 return 0
5553 }
5554 var l int
5555 _ = l
5556 if m.RefsDeprecated != nil {
5557 l = m.RefsDeprecated.SizeVT()
5558 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5559 } else {
5560 n += 3
5561 }
5562 return n
5563 }
5564 func (m *Result_Ref) SizeVT() (n int) {
5565 if m == nil {
5566 return 0
5567 }
5568 var l int
5569 _ = l
5570 if m.Ref != nil {
5571 l = m.Ref.SizeVT()
5572 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5573 } else {
5574 n += 3
5575 }
5576 return n
5577 }
5578 func (m *Result_Refs) SizeVT() (n int) {
5579 if m == nil {
5580 return 0
5581 }
5582 var l int
5583 _ = l
5584 if m.Refs != nil {
5585 l = m.Refs.SizeVT()
5586 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5587 } else {
5588 n += 3
5589 }
5590 return n
5591 }
5592 func (m *RefMapDeprecated) SizeVT() (n int) {
5593 if m == nil {
5594 return 0
5595 }
5596 var l int
5597 _ = l
5598 if len(m.Refs) > 0 {
5599 for k, v := range m.Refs {
5600 _ = k
5601 _ = v
5602 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))
5603 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5604 }
5605 }
5606 n += len(m.unknownFields)
5607 return n
5608 }
5609
5610 func (m *Ref) SizeVT() (n int) {
5611 if m == nil {
5612 return 0
5613 }
5614 var l int
5615 _ = l
5616 l = len(m.Id)
5617 if l > 0 {
5618 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5619 }
5620 if m.Def != nil {
5621 l = m.Def.SizeVT()
5622 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5623 }
5624 n += len(m.unknownFields)
5625 return n
5626 }
5627
5628 func (m *RefMap) SizeVT() (n int) {
5629 if m == nil {
5630 return 0
5631 }
5632 var l int
5633 _ = l
5634 if len(m.Refs) > 0 {
5635 for k, v := range m.Refs {
5636 _ = k
5637 _ = v
5638 l = 0
5639 if v != nil {
5640 l = v.SizeVT()
5641 }
5642 l += 1 + protohelpers.SizeOfVarint(uint64(l))
5643 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
5644 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5645 }
5646 }
5647 n += len(m.unknownFields)
5648 return n
5649 }
5650
5651 func (m *Attestations) SizeVT() (n int) {
5652 if m == nil {
5653 return 0
5654 }
5655 var l int
5656 _ = l
5657 if len(m.Attestation) > 0 {
5658 for _, e := range m.Attestation {
5659 l = e.SizeVT()
5660 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5661 }
5662 }
5663 n += len(m.unknownFields)
5664 return n
5665 }
5666
5667 func (m *Attestation) SizeVT() (n int) {
5668 if m == nil {
5669 return 0
5670 }
5671 var l int
5672 _ = l
5673 if m.Kind != 0 {
5674 n += 1 + protohelpers.SizeOfVarint(uint64(m.Kind))
5675 }
5676 if len(m.Metadata) > 0 {
5677 for k, v := range m.Metadata {
5678 _ = k
5679 _ = v
5680 l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))
5681 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
5682 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5683 }
5684 }
5685 if m.Ref != nil {
5686 l = m.Ref.SizeVT()
5687 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5688 }
5689 l = len(m.Path)
5690 if l > 0 {
5691 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5692 }
5693 l = len(m.InTotoPredicateType)
5694 if l > 0 {
5695 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5696 }
5697 if len(m.InTotoSubjects) > 0 {
5698 for _, e := range m.InTotoSubjects {
5699 l = e.SizeVT()
5700 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5701 }
5702 }
5703 n += len(m.unknownFields)
5704 return n
5705 }
5706
5707 func (m *InTotoSubject) SizeVT() (n int) {
5708 if m == nil {
5709 return 0
5710 }
5711 var l int
5712 _ = l
5713 if m.Kind != 0 {
5714 n += 1 + protohelpers.SizeOfVarint(uint64(m.Kind))
5715 }
5716 if len(m.Digest) > 0 {
5717 for _, s := range m.Digest {
5718 l = len(s)
5719 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5720 }
5721 }
5722 l = len(m.Name)
5723 if l > 0 {
5724 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5725 }
5726 n += len(m.unknownFields)
5727 return n
5728 }
5729
5730 func (m *ReturnRequest) SizeVT() (n int) {
5731 if m == nil {
5732 return 0
5733 }
5734 var l int
5735 _ = l
5736 if m.Result != nil {
5737 l = m.Result.SizeVT()
5738 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5739 }
5740 if m.Error != nil {
5741 if size, ok := interface{}(m.Error).(interface {
5742 SizeVT() int
5743 }); ok {
5744 l = size.SizeVT()
5745 } else {
5746 l = proto.Size(m.Error)
5747 }
5748 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5749 }
5750 n += len(m.unknownFields)
5751 return n
5752 }
5753
5754 func (m *ReturnResponse) SizeVT() (n int) {
5755 if m == nil {
5756 return 0
5757 }
5758 var l int
5759 _ = l
5760 n += len(m.unknownFields)
5761 return n
5762 }
5763
5764 func (m *InputsRequest) SizeVT() (n int) {
5765 if m == nil {
5766 return 0
5767 }
5768 var l int
5769 _ = l
5770 n += len(m.unknownFields)
5771 return n
5772 }
5773
5774 func (m *InputsResponse) SizeVT() (n int) {
5775 if m == nil {
5776 return 0
5777 }
5778 var l int
5779 _ = l
5780 if len(m.Definitions) > 0 {
5781 for k, v := range m.Definitions {
5782 _ = k
5783 _ = v
5784 l = 0
5785 if v != nil {
5786 l = v.SizeVT()
5787 }
5788 l += 1 + protohelpers.SizeOfVarint(uint64(l))
5789 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
5790 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5791 }
5792 }
5793 n += len(m.unknownFields)
5794 return n
5795 }
5796
5797 func (m *ResolveImageConfigRequest) SizeVT() (n int) {
5798 if m == nil {
5799 return 0
5800 }
5801 var l int
5802 _ = l
5803 l = len(m.Ref)
5804 if l > 0 {
5805 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5806 }
5807 if m.Platform != nil {
5808 l = m.Platform.SizeVT()
5809 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5810 }
5811 l = len(m.ResolveMode)
5812 if l > 0 {
5813 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5814 }
5815 l = len(m.LogName)
5816 if l > 0 {
5817 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5818 }
5819 if m.ResolverType != 0 {
5820 n += 1 + protohelpers.SizeOfVarint(uint64(m.ResolverType))
5821 }
5822 l = len(m.SessionID)
5823 if l > 0 {
5824 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5825 }
5826 l = len(m.StoreID)
5827 if l > 0 {
5828 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5829 }
5830 if len(m.SourcePolicies) > 0 {
5831 for _, e := range m.SourcePolicies {
5832 l = e.SizeVT()
5833 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5834 }
5835 }
5836 n += len(m.unknownFields)
5837 return n
5838 }
5839
5840 func (m *ResolveImageConfigResponse) SizeVT() (n int) {
5841 if m == nil {
5842 return 0
5843 }
5844 var l int
5845 _ = l
5846 l = len(m.Digest)
5847 if l > 0 {
5848 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5849 }
5850 l = len(m.Config)
5851 if l > 0 {
5852 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5853 }
5854 l = len(m.Ref)
5855 if l > 0 {
5856 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5857 }
5858 n += len(m.unknownFields)
5859 return n
5860 }
5861
5862 func (m *ResolveSourceMetaRequest) SizeVT() (n int) {
5863 if m == nil {
5864 return 0
5865 }
5866 var l int
5867 _ = l
5868 if m.Source != nil {
5869 l = m.Source.SizeVT()
5870 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5871 }
5872 if m.Platform != nil {
5873 l = m.Platform.SizeVT()
5874 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5875 }
5876 l = len(m.LogName)
5877 if l > 0 {
5878 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5879 }
5880 l = len(m.ResolveMode)
5881 if l > 0 {
5882 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5883 }
5884 if len(m.SourcePolicies) > 0 {
5885 for _, e := range m.SourcePolicies {
5886 l = e.SizeVT()
5887 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5888 }
5889 }
5890 n += len(m.unknownFields)
5891 return n
5892 }
5893
5894 func (m *ResolveSourceMetaResponse) SizeVT() (n int) {
5895 if m == nil {
5896 return 0
5897 }
5898 var l int
5899 _ = l
5900 if m.Source != nil {
5901 l = m.Source.SizeVT()
5902 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5903 }
5904 if m.Image != nil {
5905 l = m.Image.SizeVT()
5906 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5907 }
5908 n += len(m.unknownFields)
5909 return n
5910 }
5911
5912 func (m *ResolveSourceImageResponse) SizeVT() (n int) {
5913 if m == nil {
5914 return 0
5915 }
5916 var l int
5917 _ = l
5918 l = len(m.Digest)
5919 if l > 0 {
5920 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5921 }
5922 l = len(m.Config)
5923 if l > 0 {
5924 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5925 }
5926 n += len(m.unknownFields)
5927 return n
5928 }
5929
5930 func (m *SolveRequest) SizeVT() (n int) {
5931 if m == nil {
5932 return 0
5933 }
5934 var l int
5935 _ = l
5936 if m.Definition != nil {
5937 l = m.Definition.SizeVT()
5938 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5939 }
5940 l = len(m.Frontend)
5941 if l > 0 {
5942 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5943 }
5944 if len(m.FrontendOpt) > 0 {
5945 for k, v := range m.FrontendOpt {
5946 _ = k
5947 _ = v
5948 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))
5949 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5950 }
5951 }
5952 if m.AllowResultReturn {
5953 n += 2
5954 }
5955 if m.AllowResultArrayRef {
5956 n += 2
5957 }
5958 if m.Final {
5959 n += 2
5960 }
5961 l = len(m.ExporterAttr)
5962 if l > 0 {
5963 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5964 }
5965 if len(m.CacheImports) > 0 {
5966 for _, e := range m.CacheImports {
5967 l = e.SizeVT()
5968 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5969 }
5970 }
5971 if len(m.FrontendInputs) > 0 {
5972 for k, v := range m.FrontendInputs {
5973 _ = k
5974 _ = v
5975 l = 0
5976 if v != nil {
5977 l = v.SizeVT()
5978 }
5979 l += 1 + protohelpers.SizeOfVarint(uint64(l))
5980 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
5981 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
5982 }
5983 }
5984 if m.Evaluate {
5985 n += 2
5986 }
5987 if len(m.SourcePolicies) > 0 {
5988 for _, e := range m.SourcePolicies {
5989 l = e.SizeVT()
5990 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
5991 }
5992 }
5993 n += len(m.unknownFields)
5994 return n
5995 }
5996
5997 func (m *CacheOptionsEntry) SizeVT() (n int) {
5998 if m == nil {
5999 return 0
6000 }
6001 var l int
6002 _ = l
6003 l = len(m.Type)
6004 if l > 0 {
6005 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6006 }
6007 if len(m.Attrs) > 0 {
6008 for k, v := range m.Attrs {
6009 _ = k
6010 _ = v
6011 mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))
6012 n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
6013 }
6014 }
6015 n += len(m.unknownFields)
6016 return n
6017 }
6018
6019 func (m *SolveResponse) SizeVT() (n int) {
6020 if m == nil {
6021 return 0
6022 }
6023 var l int
6024 _ = l
6025 l = len(m.Ref)
6026 if l > 0 {
6027 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6028 }
6029 if m.Result != nil {
6030 l = m.Result.SizeVT()
6031 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6032 }
6033 n += len(m.unknownFields)
6034 return n
6035 }
6036
6037 func (m *ReadFileRequest) SizeVT() (n int) {
6038 if m == nil {
6039 return 0
6040 }
6041 var l int
6042 _ = l
6043 l = len(m.Ref)
6044 if l > 0 {
6045 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6046 }
6047 l = len(m.FilePath)
6048 if l > 0 {
6049 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6050 }
6051 if m.Range != nil {
6052 l = m.Range.SizeVT()
6053 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6054 }
6055 n += len(m.unknownFields)
6056 return n
6057 }
6058
6059 func (m *FileRange) SizeVT() (n int) {
6060 if m == nil {
6061 return 0
6062 }
6063 var l int
6064 _ = l
6065 if m.Offset != 0 {
6066 n += 1 + protohelpers.SizeOfVarint(uint64(m.Offset))
6067 }
6068 if m.Length != 0 {
6069 n += 1 + protohelpers.SizeOfVarint(uint64(m.Length))
6070 }
6071 n += len(m.unknownFields)
6072 return n
6073 }
6074
6075 func (m *ReadFileResponse) SizeVT() (n int) {
6076 if m == nil {
6077 return 0
6078 }
6079 var l int
6080 _ = l
6081 l = len(m.Data)
6082 if l > 0 {
6083 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6084 }
6085 n += len(m.unknownFields)
6086 return n
6087 }
6088
6089 func (m *ReadDirRequest) SizeVT() (n int) {
6090 if m == nil {
6091 return 0
6092 }
6093 var l int
6094 _ = l
6095 l = len(m.Ref)
6096 if l > 0 {
6097 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6098 }
6099 l = len(m.DirPath)
6100 if l > 0 {
6101 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6102 }
6103 l = len(m.IncludePattern)
6104 if l > 0 {
6105 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6106 }
6107 n += len(m.unknownFields)
6108 return n
6109 }
6110
6111 func (m *ReadDirResponse) SizeVT() (n int) {
6112 if m == nil {
6113 return 0
6114 }
6115 var l int
6116 _ = l
6117 if len(m.Entries) > 0 {
6118 for _, e := range m.Entries {
6119 if size, ok := interface{}(e).(interface {
6120 SizeVT() int
6121 }); ok {
6122 l = size.SizeVT()
6123 } else {
6124 l = proto.Size(e)
6125 }
6126 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6127 }
6128 }
6129 n += len(m.unknownFields)
6130 return n
6131 }
6132
6133 func (m *StatFileRequest) SizeVT() (n int) {
6134 if m == nil {
6135 return 0
6136 }
6137 var l int
6138 _ = l
6139 l = len(m.Ref)
6140 if l > 0 {
6141 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6142 }
6143 l = len(m.Path)
6144 if l > 0 {
6145 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6146 }
6147 n += len(m.unknownFields)
6148 return n
6149 }
6150
6151 func (m *StatFileResponse) SizeVT() (n int) {
6152 if m == nil {
6153 return 0
6154 }
6155 var l int
6156 _ = l
6157 if m.Stat != nil {
6158 if size, ok := interface{}(m.Stat).(interface {
6159 SizeVT() int
6160 }); ok {
6161 l = size.SizeVT()
6162 } else {
6163 l = proto.Size(m.Stat)
6164 }
6165 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6166 }
6167 n += len(m.unknownFields)
6168 return n
6169 }
6170
6171 func (m *EvaluateRequest) SizeVT() (n int) {
6172 if m == nil {
6173 return 0
6174 }
6175 var l int
6176 _ = l
6177 l = len(m.Ref)
6178 if l > 0 {
6179 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6180 }
6181 n += len(m.unknownFields)
6182 return n
6183 }
6184
6185 func (m *EvaluateResponse) SizeVT() (n int) {
6186 if m == nil {
6187 return 0
6188 }
6189 var l int
6190 _ = l
6191 n += len(m.unknownFields)
6192 return n
6193 }
6194
6195 func (m *PingRequest) SizeVT() (n int) {
6196 if m == nil {
6197 return 0
6198 }
6199 var l int
6200 _ = l
6201 n += len(m.unknownFields)
6202 return n
6203 }
6204
6205 func (m *PongResponse) SizeVT() (n int) {
6206 if m == nil {
6207 return 0
6208 }
6209 var l int
6210 _ = l
6211 if len(m.FrontendAPICaps) > 0 {
6212 for _, e := range m.FrontendAPICaps {
6213 l = e.SizeVT()
6214 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6215 }
6216 }
6217 if len(m.LLBCaps) > 0 {
6218 for _, e := range m.LLBCaps {
6219 l = e.SizeVT()
6220 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6221 }
6222 }
6223 if len(m.Workers) > 0 {
6224 for _, e := range m.Workers {
6225 l = e.SizeVT()
6226 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6227 }
6228 }
6229 n += len(m.unknownFields)
6230 return n
6231 }
6232
6233 func (m *WarnRequest) SizeVT() (n int) {
6234 if m == nil {
6235 return 0
6236 }
6237 var l int
6238 _ = l
6239 l = len(m.Digest)
6240 if l > 0 {
6241 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6242 }
6243 if m.Level != 0 {
6244 n += 1 + protohelpers.SizeOfVarint(uint64(m.Level))
6245 }
6246 l = len(m.Short)
6247 if l > 0 {
6248 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6249 }
6250 if len(m.Detail) > 0 {
6251 for _, b := range m.Detail {
6252 l = len(b)
6253 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6254 }
6255 }
6256 l = len(m.Url)
6257 if l > 0 {
6258 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6259 }
6260 if m.Info != nil {
6261 l = m.Info.SizeVT()
6262 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6263 }
6264 if len(m.Ranges) > 0 {
6265 for _, e := range m.Ranges {
6266 l = e.SizeVT()
6267 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6268 }
6269 }
6270 n += len(m.unknownFields)
6271 return n
6272 }
6273
6274 func (m *WarnResponse) SizeVT() (n int) {
6275 if m == nil {
6276 return 0
6277 }
6278 var l int
6279 _ = l
6280 n += len(m.unknownFields)
6281 return n
6282 }
6283
6284 func (m *NewContainerRequest) SizeVT() (n int) {
6285 if m == nil {
6286 return 0
6287 }
6288 var l int
6289 _ = l
6290 l = len(m.ContainerID)
6291 if l > 0 {
6292 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6293 }
6294 if len(m.Mounts) > 0 {
6295 for _, e := range m.Mounts {
6296 l = e.SizeVT()
6297 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6298 }
6299 }
6300 if m.Network != 0 {
6301 n += 1 + protohelpers.SizeOfVarint(uint64(m.Network))
6302 }
6303 if m.Platform != nil {
6304 l = m.Platform.SizeVT()
6305 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6306 }
6307 if m.Constraints != nil {
6308 l = m.Constraints.SizeVT()
6309 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6310 }
6311 if len(m.ExtraHosts) > 0 {
6312 for _, e := range m.ExtraHosts {
6313 l = e.SizeVT()
6314 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6315 }
6316 }
6317 l = len(m.Hostname)
6318 if l > 0 {
6319 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6320 }
6321 n += len(m.unknownFields)
6322 return n
6323 }
6324
6325 func (m *NewContainerResponse) SizeVT() (n int) {
6326 if m == nil {
6327 return 0
6328 }
6329 var l int
6330 _ = l
6331 n += len(m.unknownFields)
6332 return n
6333 }
6334
6335 func (m *ReleaseContainerRequest) SizeVT() (n int) {
6336 if m == nil {
6337 return 0
6338 }
6339 var l int
6340 _ = l
6341 l = len(m.ContainerID)
6342 if l > 0 {
6343 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6344 }
6345 n += len(m.unknownFields)
6346 return n
6347 }
6348
6349 func (m *ReleaseContainerResponse) SizeVT() (n int) {
6350 if m == nil {
6351 return 0
6352 }
6353 var l int
6354 _ = l
6355 n += len(m.unknownFields)
6356 return n
6357 }
6358
6359 func (m *ExecMessage) SizeVT() (n int) {
6360 if m == nil {
6361 return 0
6362 }
6363 var l int
6364 _ = l
6365 l = len(m.ProcessID)
6366 if l > 0 {
6367 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6368 }
6369 if vtmsg, ok := m.Input.(interface{ SizeVT() int }); ok {
6370 n += vtmsg.SizeVT()
6371 }
6372 n += len(m.unknownFields)
6373 return n
6374 }
6375
6376 func (m *ExecMessage_Init) SizeVT() (n int) {
6377 if m == nil {
6378 return 0
6379 }
6380 var l int
6381 _ = l
6382 if m.Init != nil {
6383 l = m.Init.SizeVT()
6384 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6385 } else {
6386 n += 3
6387 }
6388 return n
6389 }
6390 func (m *ExecMessage_File) SizeVT() (n int) {
6391 if m == nil {
6392 return 0
6393 }
6394 var l int
6395 _ = l
6396 if m.File != nil {
6397 l = m.File.SizeVT()
6398 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6399 } else {
6400 n += 3
6401 }
6402 return n
6403 }
6404 func (m *ExecMessage_Resize) SizeVT() (n int) {
6405 if m == nil {
6406 return 0
6407 }
6408 var l int
6409 _ = l
6410 if m.Resize != nil {
6411 l = m.Resize.SizeVT()
6412 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6413 } else {
6414 n += 3
6415 }
6416 return n
6417 }
6418 func (m *ExecMessage_Started) SizeVT() (n int) {
6419 if m == nil {
6420 return 0
6421 }
6422 var l int
6423 _ = l
6424 if m.Started != nil {
6425 l = m.Started.SizeVT()
6426 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6427 } else {
6428 n += 3
6429 }
6430 return n
6431 }
6432 func (m *ExecMessage_Exit) SizeVT() (n int) {
6433 if m == nil {
6434 return 0
6435 }
6436 var l int
6437 _ = l
6438 if m.Exit != nil {
6439 l = m.Exit.SizeVT()
6440 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6441 } else {
6442 n += 3
6443 }
6444 return n
6445 }
6446 func (m *ExecMessage_Done) SizeVT() (n int) {
6447 if m == nil {
6448 return 0
6449 }
6450 var l int
6451 _ = l
6452 if m.Done != nil {
6453 l = m.Done.SizeVT()
6454 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6455 } else {
6456 n += 3
6457 }
6458 return n
6459 }
6460 func (m *ExecMessage_Signal) SizeVT() (n int) {
6461 if m == nil {
6462 return 0
6463 }
6464 var l int
6465 _ = l
6466 if m.Signal != nil {
6467 l = m.Signal.SizeVT()
6468 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6469 } else {
6470 n += 3
6471 }
6472 return n
6473 }
6474 func (m *InitMessage) SizeVT() (n int) {
6475 if m == nil {
6476 return 0
6477 }
6478 var l int
6479 _ = l
6480 l = len(m.ContainerID)
6481 if l > 0 {
6482 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6483 }
6484 if m.Meta != nil {
6485 l = m.Meta.SizeVT()
6486 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6487 }
6488 if len(m.Fds) > 0 {
6489 l = 0
6490 for _, e := range m.Fds {
6491 l += protohelpers.SizeOfVarint(uint64(e))
6492 }
6493 n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l
6494 }
6495 if m.Tty {
6496 n += 2
6497 }
6498 if m.Security != 0 {
6499 n += 1 + protohelpers.SizeOfVarint(uint64(m.Security))
6500 }
6501 if len(m.Secretenv) > 0 {
6502 for _, e := range m.Secretenv {
6503 l = e.SizeVT()
6504 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6505 }
6506 }
6507 n += len(m.unknownFields)
6508 return n
6509 }
6510
6511 func (m *ExitMessage) SizeVT() (n int) {
6512 if m == nil {
6513 return 0
6514 }
6515 var l int
6516 _ = l
6517 if m.Code != 0 {
6518 n += 1 + protohelpers.SizeOfVarint(uint64(m.Code))
6519 }
6520 if m.Error != nil {
6521 if size, ok := interface{}(m.Error).(interface {
6522 SizeVT() int
6523 }); ok {
6524 l = size.SizeVT()
6525 } else {
6526 l = proto.Size(m.Error)
6527 }
6528 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6529 }
6530 n += len(m.unknownFields)
6531 return n
6532 }
6533
6534 func (m *StartedMessage) SizeVT() (n int) {
6535 if m == nil {
6536 return 0
6537 }
6538 var l int
6539 _ = l
6540 n += len(m.unknownFields)
6541 return n
6542 }
6543
6544 func (m *DoneMessage) SizeVT() (n int) {
6545 if m == nil {
6546 return 0
6547 }
6548 var l int
6549 _ = l
6550 n += len(m.unknownFields)
6551 return n
6552 }
6553
6554 func (m *FdMessage) SizeVT() (n int) {
6555 if m == nil {
6556 return 0
6557 }
6558 var l int
6559 _ = l
6560 if m.Fd != 0 {
6561 n += 1 + protohelpers.SizeOfVarint(uint64(m.Fd))
6562 }
6563 if m.EOF {
6564 n += 2
6565 }
6566 l = len(m.Data)
6567 if l > 0 {
6568 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6569 }
6570 n += len(m.unknownFields)
6571 return n
6572 }
6573
6574 func (m *ResizeMessage) SizeVT() (n int) {
6575 if m == nil {
6576 return 0
6577 }
6578 var l int
6579 _ = l
6580 if m.Rows != 0 {
6581 n += 1 + protohelpers.SizeOfVarint(uint64(m.Rows))
6582 }
6583 if m.Cols != 0 {
6584 n += 1 + protohelpers.SizeOfVarint(uint64(m.Cols))
6585 }
6586 n += len(m.unknownFields)
6587 return n
6588 }
6589
6590 func (m *SignalMessage) SizeVT() (n int) {
6591 if m == nil {
6592 return 0
6593 }
6594 var l int
6595 _ = l
6596 l = len(m.Name)
6597 if l > 0 {
6598 n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
6599 }
6600 n += len(m.unknownFields)
6601 return n
6602 }
6603
6604 func (m *Result) UnmarshalVT(dAtA []byte) error {
6605 l := len(dAtA)
6606 iNdEx := 0
6607 for iNdEx < l {
6608 preIndex := iNdEx
6609 var wire uint64
6610 for shift := uint(0); ; shift += 7 {
6611 if shift >= 64 {
6612 return protohelpers.ErrIntOverflow
6613 }
6614 if iNdEx >= l {
6615 return io.ErrUnexpectedEOF
6616 }
6617 b := dAtA[iNdEx]
6618 iNdEx++
6619 wire |= uint64(b&0x7F) << shift
6620 if b < 0x80 {
6621 break
6622 }
6623 }
6624 fieldNum := int32(wire >> 3)
6625 wireType := int(wire & 0x7)
6626 if wireType == 4 {
6627 return fmt.Errorf("proto: Result: wiretype end group for non-group")
6628 }
6629 if fieldNum <= 0 {
6630 return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire)
6631 }
6632 switch fieldNum {
6633 case 1:
6634 if wireType != 2 {
6635 return fmt.Errorf("proto: wrong wireType = %d for field RefDeprecated", wireType)
6636 }
6637 var stringLen uint64
6638 for shift := uint(0); ; shift += 7 {
6639 if shift >= 64 {
6640 return protohelpers.ErrIntOverflow
6641 }
6642 if iNdEx >= l {
6643 return io.ErrUnexpectedEOF
6644 }
6645 b := dAtA[iNdEx]
6646 iNdEx++
6647 stringLen |= uint64(b&0x7F) << shift
6648 if b < 0x80 {
6649 break
6650 }
6651 }
6652 intStringLen := int(stringLen)
6653 if intStringLen < 0 {
6654 return protohelpers.ErrInvalidLength
6655 }
6656 postIndex := iNdEx + intStringLen
6657 if postIndex < 0 {
6658 return protohelpers.ErrInvalidLength
6659 }
6660 if postIndex > l {
6661 return io.ErrUnexpectedEOF
6662 }
6663 m.Result = &Result_RefDeprecated{RefDeprecated: string(dAtA[iNdEx:postIndex])}
6664 iNdEx = postIndex
6665 case 2:
6666 if wireType != 2 {
6667 return fmt.Errorf("proto: wrong wireType = %d for field RefsDeprecated", wireType)
6668 }
6669 var msglen int
6670 for shift := uint(0); ; shift += 7 {
6671 if shift >= 64 {
6672 return protohelpers.ErrIntOverflow
6673 }
6674 if iNdEx >= l {
6675 return io.ErrUnexpectedEOF
6676 }
6677 b := dAtA[iNdEx]
6678 iNdEx++
6679 msglen |= int(b&0x7F) << shift
6680 if b < 0x80 {
6681 break
6682 }
6683 }
6684 if msglen < 0 {
6685 return protohelpers.ErrInvalidLength
6686 }
6687 postIndex := iNdEx + msglen
6688 if postIndex < 0 {
6689 return protohelpers.ErrInvalidLength
6690 }
6691 if postIndex > l {
6692 return io.ErrUnexpectedEOF
6693 }
6694 if oneof, ok := m.Result.(*Result_RefsDeprecated); ok {
6695 if err := oneof.RefsDeprecated.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
6696 return err
6697 }
6698 } else {
6699 v := &RefMapDeprecated{}
6700 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
6701 return err
6702 }
6703 m.Result = &Result_RefsDeprecated{RefsDeprecated: v}
6704 }
6705 iNdEx = postIndex
6706 case 3:
6707 if wireType != 2 {
6708 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
6709 }
6710 var msglen int
6711 for shift := uint(0); ; shift += 7 {
6712 if shift >= 64 {
6713 return protohelpers.ErrIntOverflow
6714 }
6715 if iNdEx >= l {
6716 return io.ErrUnexpectedEOF
6717 }
6718 b := dAtA[iNdEx]
6719 iNdEx++
6720 msglen |= int(b&0x7F) << shift
6721 if b < 0x80 {
6722 break
6723 }
6724 }
6725 if msglen < 0 {
6726 return protohelpers.ErrInvalidLength
6727 }
6728 postIndex := iNdEx + msglen
6729 if postIndex < 0 {
6730 return protohelpers.ErrInvalidLength
6731 }
6732 if postIndex > l {
6733 return io.ErrUnexpectedEOF
6734 }
6735 if oneof, ok := m.Result.(*Result_Ref); ok {
6736 if err := oneof.Ref.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
6737 return err
6738 }
6739 } else {
6740 v := &Ref{}
6741 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
6742 return err
6743 }
6744 m.Result = &Result_Ref{Ref: v}
6745 }
6746 iNdEx = postIndex
6747 case 4:
6748 if wireType != 2 {
6749 return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType)
6750 }
6751 var msglen int
6752 for shift := uint(0); ; shift += 7 {
6753 if shift >= 64 {
6754 return protohelpers.ErrIntOverflow
6755 }
6756 if iNdEx >= l {
6757 return io.ErrUnexpectedEOF
6758 }
6759 b := dAtA[iNdEx]
6760 iNdEx++
6761 msglen |= int(b&0x7F) << shift
6762 if b < 0x80 {
6763 break
6764 }
6765 }
6766 if msglen < 0 {
6767 return protohelpers.ErrInvalidLength
6768 }
6769 postIndex := iNdEx + msglen
6770 if postIndex < 0 {
6771 return protohelpers.ErrInvalidLength
6772 }
6773 if postIndex > l {
6774 return io.ErrUnexpectedEOF
6775 }
6776 if oneof, ok := m.Result.(*Result_Refs); ok {
6777 if err := oneof.Refs.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
6778 return err
6779 }
6780 } else {
6781 v := &RefMap{}
6782 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
6783 return err
6784 }
6785 m.Result = &Result_Refs{Refs: v}
6786 }
6787 iNdEx = postIndex
6788 case 10:
6789 if wireType != 2 {
6790 return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
6791 }
6792 var msglen int
6793 for shift := uint(0); ; shift += 7 {
6794 if shift >= 64 {
6795 return protohelpers.ErrIntOverflow
6796 }
6797 if iNdEx >= l {
6798 return io.ErrUnexpectedEOF
6799 }
6800 b := dAtA[iNdEx]
6801 iNdEx++
6802 msglen |= int(b&0x7F) << shift
6803 if b < 0x80 {
6804 break
6805 }
6806 }
6807 if msglen < 0 {
6808 return protohelpers.ErrInvalidLength
6809 }
6810 postIndex := iNdEx + msglen
6811 if postIndex < 0 {
6812 return protohelpers.ErrInvalidLength
6813 }
6814 if postIndex > l {
6815 return io.ErrUnexpectedEOF
6816 }
6817 if m.Metadata == nil {
6818 m.Metadata = make(map[string][]byte)
6819 }
6820 var mapkey string
6821 var mapvalue []byte
6822 for iNdEx < postIndex {
6823 entryPreIndex := iNdEx
6824 var wire uint64
6825 for shift := uint(0); ; shift += 7 {
6826 if shift >= 64 {
6827 return protohelpers.ErrIntOverflow
6828 }
6829 if iNdEx >= l {
6830 return io.ErrUnexpectedEOF
6831 }
6832 b := dAtA[iNdEx]
6833 iNdEx++
6834 wire |= uint64(b&0x7F) << shift
6835 if b < 0x80 {
6836 break
6837 }
6838 }
6839 fieldNum := int32(wire >> 3)
6840 if fieldNum == 1 {
6841 var stringLenmapkey uint64
6842 for shift := uint(0); ; shift += 7 {
6843 if shift >= 64 {
6844 return protohelpers.ErrIntOverflow
6845 }
6846 if iNdEx >= l {
6847 return io.ErrUnexpectedEOF
6848 }
6849 b := dAtA[iNdEx]
6850 iNdEx++
6851 stringLenmapkey |= uint64(b&0x7F) << shift
6852 if b < 0x80 {
6853 break
6854 }
6855 }
6856 intStringLenmapkey := int(stringLenmapkey)
6857 if intStringLenmapkey < 0 {
6858 return protohelpers.ErrInvalidLength
6859 }
6860 postStringIndexmapkey := iNdEx + intStringLenmapkey
6861 if postStringIndexmapkey < 0 {
6862 return protohelpers.ErrInvalidLength
6863 }
6864 if postStringIndexmapkey > l {
6865 return io.ErrUnexpectedEOF
6866 }
6867 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6868 iNdEx = postStringIndexmapkey
6869 } else if fieldNum == 2 {
6870 var mapbyteLen uint64
6871 for shift := uint(0); ; shift += 7 {
6872 if shift >= 64 {
6873 return protohelpers.ErrIntOverflow
6874 }
6875 if iNdEx >= l {
6876 return io.ErrUnexpectedEOF
6877 }
6878 b := dAtA[iNdEx]
6879 iNdEx++
6880 mapbyteLen |= uint64(b&0x7F) << shift
6881 if b < 0x80 {
6882 break
6883 }
6884 }
6885 intMapbyteLen := int(mapbyteLen)
6886 if intMapbyteLen < 0 {
6887 return protohelpers.ErrInvalidLength
6888 }
6889 postbytesIndex := iNdEx + intMapbyteLen
6890 if postbytesIndex < 0 {
6891 return protohelpers.ErrInvalidLength
6892 }
6893 if postbytesIndex > l {
6894 return io.ErrUnexpectedEOF
6895 }
6896 mapvalue = make([]byte, mapbyteLen)
6897 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
6898 iNdEx = postbytesIndex
6899 } else {
6900 iNdEx = entryPreIndex
6901 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
6902 if err != nil {
6903 return err
6904 }
6905 if (skippy < 0) || (iNdEx+skippy) < 0 {
6906 return protohelpers.ErrInvalidLength
6907 }
6908 if (iNdEx + skippy) > postIndex {
6909 return io.ErrUnexpectedEOF
6910 }
6911 iNdEx += skippy
6912 }
6913 }
6914 m.Metadata[mapkey] = mapvalue
6915 iNdEx = postIndex
6916 case 12:
6917 if wireType != 2 {
6918 return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType)
6919 }
6920 var msglen int
6921 for shift := uint(0); ; shift += 7 {
6922 if shift >= 64 {
6923 return protohelpers.ErrIntOverflow
6924 }
6925 if iNdEx >= l {
6926 return io.ErrUnexpectedEOF
6927 }
6928 b := dAtA[iNdEx]
6929 iNdEx++
6930 msglen |= int(b&0x7F) << shift
6931 if b < 0x80 {
6932 break
6933 }
6934 }
6935 if msglen < 0 {
6936 return protohelpers.ErrInvalidLength
6937 }
6938 postIndex := iNdEx + msglen
6939 if postIndex < 0 {
6940 return protohelpers.ErrInvalidLength
6941 }
6942 if postIndex > l {
6943 return io.ErrUnexpectedEOF
6944 }
6945 if m.Attestations == nil {
6946 m.Attestations = make(map[string]*Attestations)
6947 }
6948 var mapkey string
6949 var mapvalue *Attestations
6950 for iNdEx < postIndex {
6951 entryPreIndex := iNdEx
6952 var wire uint64
6953 for shift := uint(0); ; shift += 7 {
6954 if shift >= 64 {
6955 return protohelpers.ErrIntOverflow
6956 }
6957 if iNdEx >= l {
6958 return io.ErrUnexpectedEOF
6959 }
6960 b := dAtA[iNdEx]
6961 iNdEx++
6962 wire |= uint64(b&0x7F) << shift
6963 if b < 0x80 {
6964 break
6965 }
6966 }
6967 fieldNum := int32(wire >> 3)
6968 if fieldNum == 1 {
6969 var stringLenmapkey uint64
6970 for shift := uint(0); ; shift += 7 {
6971 if shift >= 64 {
6972 return protohelpers.ErrIntOverflow
6973 }
6974 if iNdEx >= l {
6975 return io.ErrUnexpectedEOF
6976 }
6977 b := dAtA[iNdEx]
6978 iNdEx++
6979 stringLenmapkey |= uint64(b&0x7F) << shift
6980 if b < 0x80 {
6981 break
6982 }
6983 }
6984 intStringLenmapkey := int(stringLenmapkey)
6985 if intStringLenmapkey < 0 {
6986 return protohelpers.ErrInvalidLength
6987 }
6988 postStringIndexmapkey := iNdEx + intStringLenmapkey
6989 if postStringIndexmapkey < 0 {
6990 return protohelpers.ErrInvalidLength
6991 }
6992 if postStringIndexmapkey > l {
6993 return io.ErrUnexpectedEOF
6994 }
6995 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6996 iNdEx = postStringIndexmapkey
6997 } else if fieldNum == 2 {
6998 var mapmsglen int
6999 for shift := uint(0); ; shift += 7 {
7000 if shift >= 64 {
7001 return protohelpers.ErrIntOverflow
7002 }
7003 if iNdEx >= l {
7004 return io.ErrUnexpectedEOF
7005 }
7006 b := dAtA[iNdEx]
7007 iNdEx++
7008 mapmsglen |= int(b&0x7F) << shift
7009 if b < 0x80 {
7010 break
7011 }
7012 }
7013 if mapmsglen < 0 {
7014 return protohelpers.ErrInvalidLength
7015 }
7016 postmsgIndex := iNdEx + mapmsglen
7017 if postmsgIndex < 0 {
7018 return protohelpers.ErrInvalidLength
7019 }
7020 if postmsgIndex > l {
7021 return io.ErrUnexpectedEOF
7022 }
7023 mapvalue = &Attestations{}
7024 if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
7025 return err
7026 }
7027 iNdEx = postmsgIndex
7028 } else {
7029 iNdEx = entryPreIndex
7030 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7031 if err != nil {
7032 return err
7033 }
7034 if (skippy < 0) || (iNdEx+skippy) < 0 {
7035 return protohelpers.ErrInvalidLength
7036 }
7037 if (iNdEx + skippy) > postIndex {
7038 return io.ErrUnexpectedEOF
7039 }
7040 iNdEx += skippy
7041 }
7042 }
7043 m.Attestations[mapkey] = mapvalue
7044 iNdEx = postIndex
7045 default:
7046 iNdEx = preIndex
7047 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7048 if err != nil {
7049 return err
7050 }
7051 if (skippy < 0) || (iNdEx+skippy) < 0 {
7052 return protohelpers.ErrInvalidLength
7053 }
7054 if (iNdEx + skippy) > l {
7055 return io.ErrUnexpectedEOF
7056 }
7057 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
7058 iNdEx += skippy
7059 }
7060 }
7061
7062 if iNdEx > l {
7063 return io.ErrUnexpectedEOF
7064 }
7065 return nil
7066 }
7067 func (m *RefMapDeprecated) UnmarshalVT(dAtA []byte) error {
7068 l := len(dAtA)
7069 iNdEx := 0
7070 for iNdEx < l {
7071 preIndex := iNdEx
7072 var wire uint64
7073 for shift := uint(0); ; shift += 7 {
7074 if shift >= 64 {
7075 return protohelpers.ErrIntOverflow
7076 }
7077 if iNdEx >= l {
7078 return io.ErrUnexpectedEOF
7079 }
7080 b := dAtA[iNdEx]
7081 iNdEx++
7082 wire |= uint64(b&0x7F) << shift
7083 if b < 0x80 {
7084 break
7085 }
7086 }
7087 fieldNum := int32(wire >> 3)
7088 wireType := int(wire & 0x7)
7089 if wireType == 4 {
7090 return fmt.Errorf("proto: RefMapDeprecated: wiretype end group for non-group")
7091 }
7092 if fieldNum <= 0 {
7093 return fmt.Errorf("proto: RefMapDeprecated: illegal tag %d (wire type %d)", fieldNum, wire)
7094 }
7095 switch fieldNum {
7096 case 1:
7097 if wireType != 2 {
7098 return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType)
7099 }
7100 var msglen int
7101 for shift := uint(0); ; shift += 7 {
7102 if shift >= 64 {
7103 return protohelpers.ErrIntOverflow
7104 }
7105 if iNdEx >= l {
7106 return io.ErrUnexpectedEOF
7107 }
7108 b := dAtA[iNdEx]
7109 iNdEx++
7110 msglen |= int(b&0x7F) << shift
7111 if b < 0x80 {
7112 break
7113 }
7114 }
7115 if msglen < 0 {
7116 return protohelpers.ErrInvalidLength
7117 }
7118 postIndex := iNdEx + msglen
7119 if postIndex < 0 {
7120 return protohelpers.ErrInvalidLength
7121 }
7122 if postIndex > l {
7123 return io.ErrUnexpectedEOF
7124 }
7125 if m.Refs == nil {
7126 m.Refs = make(map[string]string)
7127 }
7128 var mapkey string
7129 var mapvalue string
7130 for iNdEx < postIndex {
7131 entryPreIndex := iNdEx
7132 var wire uint64
7133 for shift := uint(0); ; shift += 7 {
7134 if shift >= 64 {
7135 return protohelpers.ErrIntOverflow
7136 }
7137 if iNdEx >= l {
7138 return io.ErrUnexpectedEOF
7139 }
7140 b := dAtA[iNdEx]
7141 iNdEx++
7142 wire |= uint64(b&0x7F) << shift
7143 if b < 0x80 {
7144 break
7145 }
7146 }
7147 fieldNum := int32(wire >> 3)
7148 if fieldNum == 1 {
7149 var stringLenmapkey uint64
7150 for shift := uint(0); ; shift += 7 {
7151 if shift >= 64 {
7152 return protohelpers.ErrIntOverflow
7153 }
7154 if iNdEx >= l {
7155 return io.ErrUnexpectedEOF
7156 }
7157 b := dAtA[iNdEx]
7158 iNdEx++
7159 stringLenmapkey |= uint64(b&0x7F) << shift
7160 if b < 0x80 {
7161 break
7162 }
7163 }
7164 intStringLenmapkey := int(stringLenmapkey)
7165 if intStringLenmapkey < 0 {
7166 return protohelpers.ErrInvalidLength
7167 }
7168 postStringIndexmapkey := iNdEx + intStringLenmapkey
7169 if postStringIndexmapkey < 0 {
7170 return protohelpers.ErrInvalidLength
7171 }
7172 if postStringIndexmapkey > l {
7173 return io.ErrUnexpectedEOF
7174 }
7175 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7176 iNdEx = postStringIndexmapkey
7177 } else if fieldNum == 2 {
7178 var stringLenmapvalue uint64
7179 for shift := uint(0); ; shift += 7 {
7180 if shift >= 64 {
7181 return protohelpers.ErrIntOverflow
7182 }
7183 if iNdEx >= l {
7184 return io.ErrUnexpectedEOF
7185 }
7186 b := dAtA[iNdEx]
7187 iNdEx++
7188 stringLenmapvalue |= uint64(b&0x7F) << shift
7189 if b < 0x80 {
7190 break
7191 }
7192 }
7193 intStringLenmapvalue := int(stringLenmapvalue)
7194 if intStringLenmapvalue < 0 {
7195 return protohelpers.ErrInvalidLength
7196 }
7197 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
7198 if postStringIndexmapvalue < 0 {
7199 return protohelpers.ErrInvalidLength
7200 }
7201 if postStringIndexmapvalue > l {
7202 return io.ErrUnexpectedEOF
7203 }
7204 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
7205 iNdEx = postStringIndexmapvalue
7206 } else {
7207 iNdEx = entryPreIndex
7208 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7209 if err != nil {
7210 return err
7211 }
7212 if (skippy < 0) || (iNdEx+skippy) < 0 {
7213 return protohelpers.ErrInvalidLength
7214 }
7215 if (iNdEx + skippy) > postIndex {
7216 return io.ErrUnexpectedEOF
7217 }
7218 iNdEx += skippy
7219 }
7220 }
7221 m.Refs[mapkey] = mapvalue
7222 iNdEx = postIndex
7223 default:
7224 iNdEx = preIndex
7225 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7226 if err != nil {
7227 return err
7228 }
7229 if (skippy < 0) || (iNdEx+skippy) < 0 {
7230 return protohelpers.ErrInvalidLength
7231 }
7232 if (iNdEx + skippy) > l {
7233 return io.ErrUnexpectedEOF
7234 }
7235 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
7236 iNdEx += skippy
7237 }
7238 }
7239
7240 if iNdEx > l {
7241 return io.ErrUnexpectedEOF
7242 }
7243 return nil
7244 }
7245 func (m *Ref) UnmarshalVT(dAtA []byte) error {
7246 l := len(dAtA)
7247 iNdEx := 0
7248 for iNdEx < l {
7249 preIndex := iNdEx
7250 var wire uint64
7251 for shift := uint(0); ; shift += 7 {
7252 if shift >= 64 {
7253 return protohelpers.ErrIntOverflow
7254 }
7255 if iNdEx >= l {
7256 return io.ErrUnexpectedEOF
7257 }
7258 b := dAtA[iNdEx]
7259 iNdEx++
7260 wire |= uint64(b&0x7F) << shift
7261 if b < 0x80 {
7262 break
7263 }
7264 }
7265 fieldNum := int32(wire >> 3)
7266 wireType := int(wire & 0x7)
7267 if wireType == 4 {
7268 return fmt.Errorf("proto: Ref: wiretype end group for non-group")
7269 }
7270 if fieldNum <= 0 {
7271 return fmt.Errorf("proto: Ref: illegal tag %d (wire type %d)", fieldNum, wire)
7272 }
7273 switch fieldNum {
7274 case 1:
7275 if wireType != 2 {
7276 return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
7277 }
7278 var stringLen uint64
7279 for shift := uint(0); ; shift += 7 {
7280 if shift >= 64 {
7281 return protohelpers.ErrIntOverflow
7282 }
7283 if iNdEx >= l {
7284 return io.ErrUnexpectedEOF
7285 }
7286 b := dAtA[iNdEx]
7287 iNdEx++
7288 stringLen |= uint64(b&0x7F) << shift
7289 if b < 0x80 {
7290 break
7291 }
7292 }
7293 intStringLen := int(stringLen)
7294 if intStringLen < 0 {
7295 return protohelpers.ErrInvalidLength
7296 }
7297 postIndex := iNdEx + intStringLen
7298 if postIndex < 0 {
7299 return protohelpers.ErrInvalidLength
7300 }
7301 if postIndex > l {
7302 return io.ErrUnexpectedEOF
7303 }
7304 m.Id = string(dAtA[iNdEx:postIndex])
7305 iNdEx = postIndex
7306 case 2:
7307 if wireType != 2 {
7308 return fmt.Errorf("proto: wrong wireType = %d for field Def", wireType)
7309 }
7310 var msglen int
7311 for shift := uint(0); ; shift += 7 {
7312 if shift >= 64 {
7313 return protohelpers.ErrIntOverflow
7314 }
7315 if iNdEx >= l {
7316 return io.ErrUnexpectedEOF
7317 }
7318 b := dAtA[iNdEx]
7319 iNdEx++
7320 msglen |= int(b&0x7F) << shift
7321 if b < 0x80 {
7322 break
7323 }
7324 }
7325 if msglen < 0 {
7326 return protohelpers.ErrInvalidLength
7327 }
7328 postIndex := iNdEx + msglen
7329 if postIndex < 0 {
7330 return protohelpers.ErrInvalidLength
7331 }
7332 if postIndex > l {
7333 return io.ErrUnexpectedEOF
7334 }
7335 if m.Def == nil {
7336 m.Def = &pb.Definition{}
7337 }
7338 if err := m.Def.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
7339 return err
7340 }
7341 iNdEx = postIndex
7342 default:
7343 iNdEx = preIndex
7344 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7345 if err != nil {
7346 return err
7347 }
7348 if (skippy < 0) || (iNdEx+skippy) < 0 {
7349 return protohelpers.ErrInvalidLength
7350 }
7351 if (iNdEx + skippy) > l {
7352 return io.ErrUnexpectedEOF
7353 }
7354 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
7355 iNdEx += skippy
7356 }
7357 }
7358
7359 if iNdEx > l {
7360 return io.ErrUnexpectedEOF
7361 }
7362 return nil
7363 }
7364 func (m *RefMap) UnmarshalVT(dAtA []byte) error {
7365 l := len(dAtA)
7366 iNdEx := 0
7367 for iNdEx < l {
7368 preIndex := iNdEx
7369 var wire uint64
7370 for shift := uint(0); ; shift += 7 {
7371 if shift >= 64 {
7372 return protohelpers.ErrIntOverflow
7373 }
7374 if iNdEx >= l {
7375 return io.ErrUnexpectedEOF
7376 }
7377 b := dAtA[iNdEx]
7378 iNdEx++
7379 wire |= uint64(b&0x7F) << shift
7380 if b < 0x80 {
7381 break
7382 }
7383 }
7384 fieldNum := int32(wire >> 3)
7385 wireType := int(wire & 0x7)
7386 if wireType == 4 {
7387 return fmt.Errorf("proto: RefMap: wiretype end group for non-group")
7388 }
7389 if fieldNum <= 0 {
7390 return fmt.Errorf("proto: RefMap: illegal tag %d (wire type %d)", fieldNum, wire)
7391 }
7392 switch fieldNum {
7393 case 1:
7394 if wireType != 2 {
7395 return fmt.Errorf("proto: wrong wireType = %d for field Refs", wireType)
7396 }
7397 var msglen int
7398 for shift := uint(0); ; shift += 7 {
7399 if shift >= 64 {
7400 return protohelpers.ErrIntOverflow
7401 }
7402 if iNdEx >= l {
7403 return io.ErrUnexpectedEOF
7404 }
7405 b := dAtA[iNdEx]
7406 iNdEx++
7407 msglen |= int(b&0x7F) << shift
7408 if b < 0x80 {
7409 break
7410 }
7411 }
7412 if msglen < 0 {
7413 return protohelpers.ErrInvalidLength
7414 }
7415 postIndex := iNdEx + msglen
7416 if postIndex < 0 {
7417 return protohelpers.ErrInvalidLength
7418 }
7419 if postIndex > l {
7420 return io.ErrUnexpectedEOF
7421 }
7422 if m.Refs == nil {
7423 m.Refs = make(map[string]*Ref)
7424 }
7425 var mapkey string
7426 var mapvalue *Ref
7427 for iNdEx < postIndex {
7428 entryPreIndex := iNdEx
7429 var wire uint64
7430 for shift := uint(0); ; shift += 7 {
7431 if shift >= 64 {
7432 return protohelpers.ErrIntOverflow
7433 }
7434 if iNdEx >= l {
7435 return io.ErrUnexpectedEOF
7436 }
7437 b := dAtA[iNdEx]
7438 iNdEx++
7439 wire |= uint64(b&0x7F) << shift
7440 if b < 0x80 {
7441 break
7442 }
7443 }
7444 fieldNum := int32(wire >> 3)
7445 if fieldNum == 1 {
7446 var stringLenmapkey uint64
7447 for shift := uint(0); ; shift += 7 {
7448 if shift >= 64 {
7449 return protohelpers.ErrIntOverflow
7450 }
7451 if iNdEx >= l {
7452 return io.ErrUnexpectedEOF
7453 }
7454 b := dAtA[iNdEx]
7455 iNdEx++
7456 stringLenmapkey |= uint64(b&0x7F) << shift
7457 if b < 0x80 {
7458 break
7459 }
7460 }
7461 intStringLenmapkey := int(stringLenmapkey)
7462 if intStringLenmapkey < 0 {
7463 return protohelpers.ErrInvalidLength
7464 }
7465 postStringIndexmapkey := iNdEx + intStringLenmapkey
7466 if postStringIndexmapkey < 0 {
7467 return protohelpers.ErrInvalidLength
7468 }
7469 if postStringIndexmapkey > l {
7470 return io.ErrUnexpectedEOF
7471 }
7472 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7473 iNdEx = postStringIndexmapkey
7474 } else if fieldNum == 2 {
7475 var mapmsglen int
7476 for shift := uint(0); ; shift += 7 {
7477 if shift >= 64 {
7478 return protohelpers.ErrIntOverflow
7479 }
7480 if iNdEx >= l {
7481 return io.ErrUnexpectedEOF
7482 }
7483 b := dAtA[iNdEx]
7484 iNdEx++
7485 mapmsglen |= int(b&0x7F) << shift
7486 if b < 0x80 {
7487 break
7488 }
7489 }
7490 if mapmsglen < 0 {
7491 return protohelpers.ErrInvalidLength
7492 }
7493 postmsgIndex := iNdEx + mapmsglen
7494 if postmsgIndex < 0 {
7495 return protohelpers.ErrInvalidLength
7496 }
7497 if postmsgIndex > l {
7498 return io.ErrUnexpectedEOF
7499 }
7500 mapvalue = &Ref{}
7501 if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
7502 return err
7503 }
7504 iNdEx = postmsgIndex
7505 } else {
7506 iNdEx = entryPreIndex
7507 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7508 if err != nil {
7509 return err
7510 }
7511 if (skippy < 0) || (iNdEx+skippy) < 0 {
7512 return protohelpers.ErrInvalidLength
7513 }
7514 if (iNdEx + skippy) > postIndex {
7515 return io.ErrUnexpectedEOF
7516 }
7517 iNdEx += skippy
7518 }
7519 }
7520 m.Refs[mapkey] = mapvalue
7521 iNdEx = postIndex
7522 default:
7523 iNdEx = preIndex
7524 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7525 if err != nil {
7526 return err
7527 }
7528 if (skippy < 0) || (iNdEx+skippy) < 0 {
7529 return protohelpers.ErrInvalidLength
7530 }
7531 if (iNdEx + skippy) > l {
7532 return io.ErrUnexpectedEOF
7533 }
7534 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
7535 iNdEx += skippy
7536 }
7537 }
7538
7539 if iNdEx > l {
7540 return io.ErrUnexpectedEOF
7541 }
7542 return nil
7543 }
7544 func (m *Attestations) UnmarshalVT(dAtA []byte) error {
7545 l := len(dAtA)
7546 iNdEx := 0
7547 for iNdEx < l {
7548 preIndex := iNdEx
7549 var wire uint64
7550 for shift := uint(0); ; shift += 7 {
7551 if shift >= 64 {
7552 return protohelpers.ErrIntOverflow
7553 }
7554 if iNdEx >= l {
7555 return io.ErrUnexpectedEOF
7556 }
7557 b := dAtA[iNdEx]
7558 iNdEx++
7559 wire |= uint64(b&0x7F) << shift
7560 if b < 0x80 {
7561 break
7562 }
7563 }
7564 fieldNum := int32(wire >> 3)
7565 wireType := int(wire & 0x7)
7566 if wireType == 4 {
7567 return fmt.Errorf("proto: Attestations: wiretype end group for non-group")
7568 }
7569 if fieldNum <= 0 {
7570 return fmt.Errorf("proto: Attestations: illegal tag %d (wire type %d)", fieldNum, wire)
7571 }
7572 switch fieldNum {
7573 case 1:
7574 if wireType != 2 {
7575 return fmt.Errorf("proto: wrong wireType = %d for field Attestation", wireType)
7576 }
7577 var msglen int
7578 for shift := uint(0); ; shift += 7 {
7579 if shift >= 64 {
7580 return protohelpers.ErrIntOverflow
7581 }
7582 if iNdEx >= l {
7583 return io.ErrUnexpectedEOF
7584 }
7585 b := dAtA[iNdEx]
7586 iNdEx++
7587 msglen |= int(b&0x7F) << shift
7588 if b < 0x80 {
7589 break
7590 }
7591 }
7592 if msglen < 0 {
7593 return protohelpers.ErrInvalidLength
7594 }
7595 postIndex := iNdEx + msglen
7596 if postIndex < 0 {
7597 return protohelpers.ErrInvalidLength
7598 }
7599 if postIndex > l {
7600 return io.ErrUnexpectedEOF
7601 }
7602 m.Attestation = append(m.Attestation, &Attestation{})
7603 if err := m.Attestation[len(m.Attestation)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
7604 return err
7605 }
7606 iNdEx = postIndex
7607 default:
7608 iNdEx = preIndex
7609 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7610 if err != nil {
7611 return err
7612 }
7613 if (skippy < 0) || (iNdEx+skippy) < 0 {
7614 return protohelpers.ErrInvalidLength
7615 }
7616 if (iNdEx + skippy) > l {
7617 return io.ErrUnexpectedEOF
7618 }
7619 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
7620 iNdEx += skippy
7621 }
7622 }
7623
7624 if iNdEx > l {
7625 return io.ErrUnexpectedEOF
7626 }
7627 return nil
7628 }
7629 func (m *Attestation) UnmarshalVT(dAtA []byte) error {
7630 l := len(dAtA)
7631 iNdEx := 0
7632 for iNdEx < l {
7633 preIndex := iNdEx
7634 var wire uint64
7635 for shift := uint(0); ; shift += 7 {
7636 if shift >= 64 {
7637 return protohelpers.ErrIntOverflow
7638 }
7639 if iNdEx >= l {
7640 return io.ErrUnexpectedEOF
7641 }
7642 b := dAtA[iNdEx]
7643 iNdEx++
7644 wire |= uint64(b&0x7F) << shift
7645 if b < 0x80 {
7646 break
7647 }
7648 }
7649 fieldNum := int32(wire >> 3)
7650 wireType := int(wire & 0x7)
7651 if wireType == 4 {
7652 return fmt.Errorf("proto: Attestation: wiretype end group for non-group")
7653 }
7654 if fieldNum <= 0 {
7655 return fmt.Errorf("proto: Attestation: illegal tag %d (wire type %d)", fieldNum, wire)
7656 }
7657 switch fieldNum {
7658 case 1:
7659 if wireType != 0 {
7660 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
7661 }
7662 m.Kind = 0
7663 for shift := uint(0); ; shift += 7 {
7664 if shift >= 64 {
7665 return protohelpers.ErrIntOverflow
7666 }
7667 if iNdEx >= l {
7668 return io.ErrUnexpectedEOF
7669 }
7670 b := dAtA[iNdEx]
7671 iNdEx++
7672 m.Kind |= AttestationKind(b&0x7F) << shift
7673 if b < 0x80 {
7674 break
7675 }
7676 }
7677 case 2:
7678 if wireType != 2 {
7679 return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
7680 }
7681 var msglen int
7682 for shift := uint(0); ; shift += 7 {
7683 if shift >= 64 {
7684 return protohelpers.ErrIntOverflow
7685 }
7686 if iNdEx >= l {
7687 return io.ErrUnexpectedEOF
7688 }
7689 b := dAtA[iNdEx]
7690 iNdEx++
7691 msglen |= int(b&0x7F) << shift
7692 if b < 0x80 {
7693 break
7694 }
7695 }
7696 if msglen < 0 {
7697 return protohelpers.ErrInvalidLength
7698 }
7699 postIndex := iNdEx + msglen
7700 if postIndex < 0 {
7701 return protohelpers.ErrInvalidLength
7702 }
7703 if postIndex > l {
7704 return io.ErrUnexpectedEOF
7705 }
7706 if m.Metadata == nil {
7707 m.Metadata = make(map[string][]byte)
7708 }
7709 var mapkey string
7710 var mapvalue []byte
7711 for iNdEx < postIndex {
7712 entryPreIndex := iNdEx
7713 var wire uint64
7714 for shift := uint(0); ; shift += 7 {
7715 if shift >= 64 {
7716 return protohelpers.ErrIntOverflow
7717 }
7718 if iNdEx >= l {
7719 return io.ErrUnexpectedEOF
7720 }
7721 b := dAtA[iNdEx]
7722 iNdEx++
7723 wire |= uint64(b&0x7F) << shift
7724 if b < 0x80 {
7725 break
7726 }
7727 }
7728 fieldNum := int32(wire >> 3)
7729 if fieldNum == 1 {
7730 var stringLenmapkey uint64
7731 for shift := uint(0); ; shift += 7 {
7732 if shift >= 64 {
7733 return protohelpers.ErrIntOverflow
7734 }
7735 if iNdEx >= l {
7736 return io.ErrUnexpectedEOF
7737 }
7738 b := dAtA[iNdEx]
7739 iNdEx++
7740 stringLenmapkey |= uint64(b&0x7F) << shift
7741 if b < 0x80 {
7742 break
7743 }
7744 }
7745 intStringLenmapkey := int(stringLenmapkey)
7746 if intStringLenmapkey < 0 {
7747 return protohelpers.ErrInvalidLength
7748 }
7749 postStringIndexmapkey := iNdEx + intStringLenmapkey
7750 if postStringIndexmapkey < 0 {
7751 return protohelpers.ErrInvalidLength
7752 }
7753 if postStringIndexmapkey > l {
7754 return io.ErrUnexpectedEOF
7755 }
7756 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7757 iNdEx = postStringIndexmapkey
7758 } else if fieldNum == 2 {
7759 var mapbyteLen uint64
7760 for shift := uint(0); ; shift += 7 {
7761 if shift >= 64 {
7762 return protohelpers.ErrIntOverflow
7763 }
7764 if iNdEx >= l {
7765 return io.ErrUnexpectedEOF
7766 }
7767 b := dAtA[iNdEx]
7768 iNdEx++
7769 mapbyteLen |= uint64(b&0x7F) << shift
7770 if b < 0x80 {
7771 break
7772 }
7773 }
7774 intMapbyteLen := int(mapbyteLen)
7775 if intMapbyteLen < 0 {
7776 return protohelpers.ErrInvalidLength
7777 }
7778 postbytesIndex := iNdEx + intMapbyteLen
7779 if postbytesIndex < 0 {
7780 return protohelpers.ErrInvalidLength
7781 }
7782 if postbytesIndex > l {
7783 return io.ErrUnexpectedEOF
7784 }
7785 mapvalue = make([]byte, mapbyteLen)
7786 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
7787 iNdEx = postbytesIndex
7788 } else {
7789 iNdEx = entryPreIndex
7790 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7791 if err != nil {
7792 return err
7793 }
7794 if (skippy < 0) || (iNdEx+skippy) < 0 {
7795 return protohelpers.ErrInvalidLength
7796 }
7797 if (iNdEx + skippy) > postIndex {
7798 return io.ErrUnexpectedEOF
7799 }
7800 iNdEx += skippy
7801 }
7802 }
7803 m.Metadata[mapkey] = mapvalue
7804 iNdEx = postIndex
7805 case 3:
7806 if wireType != 2 {
7807 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
7808 }
7809 var msglen int
7810 for shift := uint(0); ; shift += 7 {
7811 if shift >= 64 {
7812 return protohelpers.ErrIntOverflow
7813 }
7814 if iNdEx >= l {
7815 return io.ErrUnexpectedEOF
7816 }
7817 b := dAtA[iNdEx]
7818 iNdEx++
7819 msglen |= int(b&0x7F) << shift
7820 if b < 0x80 {
7821 break
7822 }
7823 }
7824 if msglen < 0 {
7825 return protohelpers.ErrInvalidLength
7826 }
7827 postIndex := iNdEx + msglen
7828 if postIndex < 0 {
7829 return protohelpers.ErrInvalidLength
7830 }
7831 if postIndex > l {
7832 return io.ErrUnexpectedEOF
7833 }
7834 if m.Ref == nil {
7835 m.Ref = &Ref{}
7836 }
7837 if err := m.Ref.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
7838 return err
7839 }
7840 iNdEx = postIndex
7841 case 4:
7842 if wireType != 2 {
7843 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
7844 }
7845 var stringLen uint64
7846 for shift := uint(0); ; shift += 7 {
7847 if shift >= 64 {
7848 return protohelpers.ErrIntOverflow
7849 }
7850 if iNdEx >= l {
7851 return io.ErrUnexpectedEOF
7852 }
7853 b := dAtA[iNdEx]
7854 iNdEx++
7855 stringLen |= uint64(b&0x7F) << shift
7856 if b < 0x80 {
7857 break
7858 }
7859 }
7860 intStringLen := int(stringLen)
7861 if intStringLen < 0 {
7862 return protohelpers.ErrInvalidLength
7863 }
7864 postIndex := iNdEx + intStringLen
7865 if postIndex < 0 {
7866 return protohelpers.ErrInvalidLength
7867 }
7868 if postIndex > l {
7869 return io.ErrUnexpectedEOF
7870 }
7871 m.Path = string(dAtA[iNdEx:postIndex])
7872 iNdEx = postIndex
7873 case 5:
7874 if wireType != 2 {
7875 return fmt.Errorf("proto: wrong wireType = %d for field InTotoPredicateType", wireType)
7876 }
7877 var stringLen uint64
7878 for shift := uint(0); ; shift += 7 {
7879 if shift >= 64 {
7880 return protohelpers.ErrIntOverflow
7881 }
7882 if iNdEx >= l {
7883 return io.ErrUnexpectedEOF
7884 }
7885 b := dAtA[iNdEx]
7886 iNdEx++
7887 stringLen |= uint64(b&0x7F) << shift
7888 if b < 0x80 {
7889 break
7890 }
7891 }
7892 intStringLen := int(stringLen)
7893 if intStringLen < 0 {
7894 return protohelpers.ErrInvalidLength
7895 }
7896 postIndex := iNdEx + intStringLen
7897 if postIndex < 0 {
7898 return protohelpers.ErrInvalidLength
7899 }
7900 if postIndex > l {
7901 return io.ErrUnexpectedEOF
7902 }
7903 m.InTotoPredicateType = string(dAtA[iNdEx:postIndex])
7904 iNdEx = postIndex
7905 case 6:
7906 if wireType != 2 {
7907 return fmt.Errorf("proto: wrong wireType = %d for field InTotoSubjects", wireType)
7908 }
7909 var msglen int
7910 for shift := uint(0); ; shift += 7 {
7911 if shift >= 64 {
7912 return protohelpers.ErrIntOverflow
7913 }
7914 if iNdEx >= l {
7915 return io.ErrUnexpectedEOF
7916 }
7917 b := dAtA[iNdEx]
7918 iNdEx++
7919 msglen |= int(b&0x7F) << shift
7920 if b < 0x80 {
7921 break
7922 }
7923 }
7924 if msglen < 0 {
7925 return protohelpers.ErrInvalidLength
7926 }
7927 postIndex := iNdEx + msglen
7928 if postIndex < 0 {
7929 return protohelpers.ErrInvalidLength
7930 }
7931 if postIndex > l {
7932 return io.ErrUnexpectedEOF
7933 }
7934 m.InTotoSubjects = append(m.InTotoSubjects, &InTotoSubject{})
7935 if err := m.InTotoSubjects[len(m.InTotoSubjects)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
7936 return err
7937 }
7938 iNdEx = postIndex
7939 default:
7940 iNdEx = preIndex
7941 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
7942 if err != nil {
7943 return err
7944 }
7945 if (skippy < 0) || (iNdEx+skippy) < 0 {
7946 return protohelpers.ErrInvalidLength
7947 }
7948 if (iNdEx + skippy) > l {
7949 return io.ErrUnexpectedEOF
7950 }
7951 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
7952 iNdEx += skippy
7953 }
7954 }
7955
7956 if iNdEx > l {
7957 return io.ErrUnexpectedEOF
7958 }
7959 return nil
7960 }
7961 func (m *InTotoSubject) UnmarshalVT(dAtA []byte) error {
7962 l := len(dAtA)
7963 iNdEx := 0
7964 for iNdEx < l {
7965 preIndex := iNdEx
7966 var wire uint64
7967 for shift := uint(0); ; shift += 7 {
7968 if shift >= 64 {
7969 return protohelpers.ErrIntOverflow
7970 }
7971 if iNdEx >= l {
7972 return io.ErrUnexpectedEOF
7973 }
7974 b := dAtA[iNdEx]
7975 iNdEx++
7976 wire |= uint64(b&0x7F) << shift
7977 if b < 0x80 {
7978 break
7979 }
7980 }
7981 fieldNum := int32(wire >> 3)
7982 wireType := int(wire & 0x7)
7983 if wireType == 4 {
7984 return fmt.Errorf("proto: InTotoSubject: wiretype end group for non-group")
7985 }
7986 if fieldNum <= 0 {
7987 return fmt.Errorf("proto: InTotoSubject: illegal tag %d (wire type %d)", fieldNum, wire)
7988 }
7989 switch fieldNum {
7990 case 1:
7991 if wireType != 0 {
7992 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
7993 }
7994 m.Kind = 0
7995 for shift := uint(0); ; shift += 7 {
7996 if shift >= 64 {
7997 return protohelpers.ErrIntOverflow
7998 }
7999 if iNdEx >= l {
8000 return io.ErrUnexpectedEOF
8001 }
8002 b := dAtA[iNdEx]
8003 iNdEx++
8004 m.Kind |= InTotoSubjectKind(b&0x7F) << shift
8005 if b < 0x80 {
8006 break
8007 }
8008 }
8009 case 2:
8010 if wireType != 2 {
8011 return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType)
8012 }
8013 var stringLen uint64
8014 for shift := uint(0); ; shift += 7 {
8015 if shift >= 64 {
8016 return protohelpers.ErrIntOverflow
8017 }
8018 if iNdEx >= l {
8019 return io.ErrUnexpectedEOF
8020 }
8021 b := dAtA[iNdEx]
8022 iNdEx++
8023 stringLen |= uint64(b&0x7F) << shift
8024 if b < 0x80 {
8025 break
8026 }
8027 }
8028 intStringLen := int(stringLen)
8029 if intStringLen < 0 {
8030 return protohelpers.ErrInvalidLength
8031 }
8032 postIndex := iNdEx + intStringLen
8033 if postIndex < 0 {
8034 return protohelpers.ErrInvalidLength
8035 }
8036 if postIndex > l {
8037 return io.ErrUnexpectedEOF
8038 }
8039 m.Digest = append(m.Digest, string(dAtA[iNdEx:postIndex]))
8040 iNdEx = postIndex
8041 case 3:
8042 if wireType != 2 {
8043 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
8044 }
8045 var stringLen uint64
8046 for shift := uint(0); ; shift += 7 {
8047 if shift >= 64 {
8048 return protohelpers.ErrIntOverflow
8049 }
8050 if iNdEx >= l {
8051 return io.ErrUnexpectedEOF
8052 }
8053 b := dAtA[iNdEx]
8054 iNdEx++
8055 stringLen |= uint64(b&0x7F) << shift
8056 if b < 0x80 {
8057 break
8058 }
8059 }
8060 intStringLen := int(stringLen)
8061 if intStringLen < 0 {
8062 return protohelpers.ErrInvalidLength
8063 }
8064 postIndex := iNdEx + intStringLen
8065 if postIndex < 0 {
8066 return protohelpers.ErrInvalidLength
8067 }
8068 if postIndex > l {
8069 return io.ErrUnexpectedEOF
8070 }
8071 m.Name = string(dAtA[iNdEx:postIndex])
8072 iNdEx = postIndex
8073 default:
8074 iNdEx = preIndex
8075 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8076 if err != nil {
8077 return err
8078 }
8079 if (skippy < 0) || (iNdEx+skippy) < 0 {
8080 return protohelpers.ErrInvalidLength
8081 }
8082 if (iNdEx + skippy) > l {
8083 return io.ErrUnexpectedEOF
8084 }
8085 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8086 iNdEx += skippy
8087 }
8088 }
8089
8090 if iNdEx > l {
8091 return io.ErrUnexpectedEOF
8092 }
8093 return nil
8094 }
8095 func (m *ReturnRequest) UnmarshalVT(dAtA []byte) error {
8096 l := len(dAtA)
8097 iNdEx := 0
8098 for iNdEx < l {
8099 preIndex := iNdEx
8100 var wire uint64
8101 for shift := uint(0); ; shift += 7 {
8102 if shift >= 64 {
8103 return protohelpers.ErrIntOverflow
8104 }
8105 if iNdEx >= l {
8106 return io.ErrUnexpectedEOF
8107 }
8108 b := dAtA[iNdEx]
8109 iNdEx++
8110 wire |= uint64(b&0x7F) << shift
8111 if b < 0x80 {
8112 break
8113 }
8114 }
8115 fieldNum := int32(wire >> 3)
8116 wireType := int(wire & 0x7)
8117 if wireType == 4 {
8118 return fmt.Errorf("proto: ReturnRequest: wiretype end group for non-group")
8119 }
8120 if fieldNum <= 0 {
8121 return fmt.Errorf("proto: ReturnRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8122 }
8123 switch fieldNum {
8124 case 1:
8125 if wireType != 2 {
8126 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
8127 }
8128 var msglen int
8129 for shift := uint(0); ; shift += 7 {
8130 if shift >= 64 {
8131 return protohelpers.ErrIntOverflow
8132 }
8133 if iNdEx >= l {
8134 return io.ErrUnexpectedEOF
8135 }
8136 b := dAtA[iNdEx]
8137 iNdEx++
8138 msglen |= int(b&0x7F) << shift
8139 if b < 0x80 {
8140 break
8141 }
8142 }
8143 if msglen < 0 {
8144 return protohelpers.ErrInvalidLength
8145 }
8146 postIndex := iNdEx + msglen
8147 if postIndex < 0 {
8148 return protohelpers.ErrInvalidLength
8149 }
8150 if postIndex > l {
8151 return io.ErrUnexpectedEOF
8152 }
8153 if m.Result == nil {
8154 m.Result = &Result{}
8155 }
8156 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
8157 return err
8158 }
8159 iNdEx = postIndex
8160 case 2:
8161 if wireType != 2 {
8162 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
8163 }
8164 var msglen int
8165 for shift := uint(0); ; shift += 7 {
8166 if shift >= 64 {
8167 return protohelpers.ErrIntOverflow
8168 }
8169 if iNdEx >= l {
8170 return io.ErrUnexpectedEOF
8171 }
8172 b := dAtA[iNdEx]
8173 iNdEx++
8174 msglen |= int(b&0x7F) << shift
8175 if b < 0x80 {
8176 break
8177 }
8178 }
8179 if msglen < 0 {
8180 return protohelpers.ErrInvalidLength
8181 }
8182 postIndex := iNdEx + msglen
8183 if postIndex < 0 {
8184 return protohelpers.ErrInvalidLength
8185 }
8186 if postIndex > l {
8187 return io.ErrUnexpectedEOF
8188 }
8189 if m.Error == nil {
8190 m.Error = &status.Status{}
8191 }
8192 if unmarshal, ok := interface{}(m.Error).(interface {
8193 UnmarshalVT([]byte) error
8194 }); ok {
8195 if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
8196 return err
8197 }
8198 } else {
8199 if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Error); err != nil {
8200 return err
8201 }
8202 }
8203 iNdEx = postIndex
8204 default:
8205 iNdEx = preIndex
8206 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8207 if err != nil {
8208 return err
8209 }
8210 if (skippy < 0) || (iNdEx+skippy) < 0 {
8211 return protohelpers.ErrInvalidLength
8212 }
8213 if (iNdEx + skippy) > l {
8214 return io.ErrUnexpectedEOF
8215 }
8216 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8217 iNdEx += skippy
8218 }
8219 }
8220
8221 if iNdEx > l {
8222 return io.ErrUnexpectedEOF
8223 }
8224 return nil
8225 }
8226 func (m *ReturnResponse) UnmarshalVT(dAtA []byte) error {
8227 l := len(dAtA)
8228 iNdEx := 0
8229 for iNdEx < l {
8230 preIndex := iNdEx
8231 var wire uint64
8232 for shift := uint(0); ; shift += 7 {
8233 if shift >= 64 {
8234 return protohelpers.ErrIntOverflow
8235 }
8236 if iNdEx >= l {
8237 return io.ErrUnexpectedEOF
8238 }
8239 b := dAtA[iNdEx]
8240 iNdEx++
8241 wire |= uint64(b&0x7F) << shift
8242 if b < 0x80 {
8243 break
8244 }
8245 }
8246 fieldNum := int32(wire >> 3)
8247 wireType := int(wire & 0x7)
8248 if wireType == 4 {
8249 return fmt.Errorf("proto: ReturnResponse: wiretype end group for non-group")
8250 }
8251 if fieldNum <= 0 {
8252 return fmt.Errorf("proto: ReturnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8253 }
8254 switch fieldNum {
8255 default:
8256 iNdEx = preIndex
8257 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8258 if err != nil {
8259 return err
8260 }
8261 if (skippy < 0) || (iNdEx+skippy) < 0 {
8262 return protohelpers.ErrInvalidLength
8263 }
8264 if (iNdEx + skippy) > l {
8265 return io.ErrUnexpectedEOF
8266 }
8267 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8268 iNdEx += skippy
8269 }
8270 }
8271
8272 if iNdEx > l {
8273 return io.ErrUnexpectedEOF
8274 }
8275 return nil
8276 }
8277 func (m *InputsRequest) UnmarshalVT(dAtA []byte) error {
8278 l := len(dAtA)
8279 iNdEx := 0
8280 for iNdEx < l {
8281 preIndex := iNdEx
8282 var wire uint64
8283 for shift := uint(0); ; shift += 7 {
8284 if shift >= 64 {
8285 return protohelpers.ErrIntOverflow
8286 }
8287 if iNdEx >= l {
8288 return io.ErrUnexpectedEOF
8289 }
8290 b := dAtA[iNdEx]
8291 iNdEx++
8292 wire |= uint64(b&0x7F) << shift
8293 if b < 0x80 {
8294 break
8295 }
8296 }
8297 fieldNum := int32(wire >> 3)
8298 wireType := int(wire & 0x7)
8299 if wireType == 4 {
8300 return fmt.Errorf("proto: InputsRequest: wiretype end group for non-group")
8301 }
8302 if fieldNum <= 0 {
8303 return fmt.Errorf("proto: InputsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8304 }
8305 switch fieldNum {
8306 default:
8307 iNdEx = preIndex
8308 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8309 if err != nil {
8310 return err
8311 }
8312 if (skippy < 0) || (iNdEx+skippy) < 0 {
8313 return protohelpers.ErrInvalidLength
8314 }
8315 if (iNdEx + skippy) > l {
8316 return io.ErrUnexpectedEOF
8317 }
8318 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8319 iNdEx += skippy
8320 }
8321 }
8322
8323 if iNdEx > l {
8324 return io.ErrUnexpectedEOF
8325 }
8326 return nil
8327 }
8328 func (m *InputsResponse) UnmarshalVT(dAtA []byte) error {
8329 l := len(dAtA)
8330 iNdEx := 0
8331 for iNdEx < l {
8332 preIndex := iNdEx
8333 var wire uint64
8334 for shift := uint(0); ; shift += 7 {
8335 if shift >= 64 {
8336 return protohelpers.ErrIntOverflow
8337 }
8338 if iNdEx >= l {
8339 return io.ErrUnexpectedEOF
8340 }
8341 b := dAtA[iNdEx]
8342 iNdEx++
8343 wire |= uint64(b&0x7F) << shift
8344 if b < 0x80 {
8345 break
8346 }
8347 }
8348 fieldNum := int32(wire >> 3)
8349 wireType := int(wire & 0x7)
8350 if wireType == 4 {
8351 return fmt.Errorf("proto: InputsResponse: wiretype end group for non-group")
8352 }
8353 if fieldNum <= 0 {
8354 return fmt.Errorf("proto: InputsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8355 }
8356 switch fieldNum {
8357 case 1:
8358 if wireType != 2 {
8359 return fmt.Errorf("proto: wrong wireType = %d for field Definitions", wireType)
8360 }
8361 var msglen int
8362 for shift := uint(0); ; shift += 7 {
8363 if shift >= 64 {
8364 return protohelpers.ErrIntOverflow
8365 }
8366 if iNdEx >= l {
8367 return io.ErrUnexpectedEOF
8368 }
8369 b := dAtA[iNdEx]
8370 iNdEx++
8371 msglen |= int(b&0x7F) << shift
8372 if b < 0x80 {
8373 break
8374 }
8375 }
8376 if msglen < 0 {
8377 return protohelpers.ErrInvalidLength
8378 }
8379 postIndex := iNdEx + msglen
8380 if postIndex < 0 {
8381 return protohelpers.ErrInvalidLength
8382 }
8383 if postIndex > l {
8384 return io.ErrUnexpectedEOF
8385 }
8386 if m.Definitions == nil {
8387 m.Definitions = make(map[string]*pb.Definition)
8388 }
8389 var mapkey string
8390 var mapvalue *pb.Definition
8391 for iNdEx < postIndex {
8392 entryPreIndex := iNdEx
8393 var wire uint64
8394 for shift := uint(0); ; shift += 7 {
8395 if shift >= 64 {
8396 return protohelpers.ErrIntOverflow
8397 }
8398 if iNdEx >= l {
8399 return io.ErrUnexpectedEOF
8400 }
8401 b := dAtA[iNdEx]
8402 iNdEx++
8403 wire |= uint64(b&0x7F) << shift
8404 if b < 0x80 {
8405 break
8406 }
8407 }
8408 fieldNum := int32(wire >> 3)
8409 if fieldNum == 1 {
8410 var stringLenmapkey uint64
8411 for shift := uint(0); ; shift += 7 {
8412 if shift >= 64 {
8413 return protohelpers.ErrIntOverflow
8414 }
8415 if iNdEx >= l {
8416 return io.ErrUnexpectedEOF
8417 }
8418 b := dAtA[iNdEx]
8419 iNdEx++
8420 stringLenmapkey |= uint64(b&0x7F) << shift
8421 if b < 0x80 {
8422 break
8423 }
8424 }
8425 intStringLenmapkey := int(stringLenmapkey)
8426 if intStringLenmapkey < 0 {
8427 return protohelpers.ErrInvalidLength
8428 }
8429 postStringIndexmapkey := iNdEx + intStringLenmapkey
8430 if postStringIndexmapkey < 0 {
8431 return protohelpers.ErrInvalidLength
8432 }
8433 if postStringIndexmapkey > l {
8434 return io.ErrUnexpectedEOF
8435 }
8436 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8437 iNdEx = postStringIndexmapkey
8438 } else if fieldNum == 2 {
8439 var mapmsglen int
8440 for shift := uint(0); ; shift += 7 {
8441 if shift >= 64 {
8442 return protohelpers.ErrIntOverflow
8443 }
8444 if iNdEx >= l {
8445 return io.ErrUnexpectedEOF
8446 }
8447 b := dAtA[iNdEx]
8448 iNdEx++
8449 mapmsglen |= int(b&0x7F) << shift
8450 if b < 0x80 {
8451 break
8452 }
8453 }
8454 if mapmsglen < 0 {
8455 return protohelpers.ErrInvalidLength
8456 }
8457 postmsgIndex := iNdEx + mapmsglen
8458 if postmsgIndex < 0 {
8459 return protohelpers.ErrInvalidLength
8460 }
8461 if postmsgIndex > l {
8462 return io.ErrUnexpectedEOF
8463 }
8464 mapvalue = &pb.Definition{}
8465 if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
8466 return err
8467 }
8468 iNdEx = postmsgIndex
8469 } else {
8470 iNdEx = entryPreIndex
8471 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8472 if err != nil {
8473 return err
8474 }
8475 if (skippy < 0) || (iNdEx+skippy) < 0 {
8476 return protohelpers.ErrInvalidLength
8477 }
8478 if (iNdEx + skippy) > postIndex {
8479 return io.ErrUnexpectedEOF
8480 }
8481 iNdEx += skippy
8482 }
8483 }
8484 m.Definitions[mapkey] = mapvalue
8485 iNdEx = postIndex
8486 default:
8487 iNdEx = preIndex
8488 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8489 if err != nil {
8490 return err
8491 }
8492 if (skippy < 0) || (iNdEx+skippy) < 0 {
8493 return protohelpers.ErrInvalidLength
8494 }
8495 if (iNdEx + skippy) > l {
8496 return io.ErrUnexpectedEOF
8497 }
8498 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8499 iNdEx += skippy
8500 }
8501 }
8502
8503 if iNdEx > l {
8504 return io.ErrUnexpectedEOF
8505 }
8506 return nil
8507 }
8508 func (m *ResolveImageConfigRequest) UnmarshalVT(dAtA []byte) error {
8509 l := len(dAtA)
8510 iNdEx := 0
8511 for iNdEx < l {
8512 preIndex := iNdEx
8513 var wire uint64
8514 for shift := uint(0); ; shift += 7 {
8515 if shift >= 64 {
8516 return protohelpers.ErrIntOverflow
8517 }
8518 if iNdEx >= l {
8519 return io.ErrUnexpectedEOF
8520 }
8521 b := dAtA[iNdEx]
8522 iNdEx++
8523 wire |= uint64(b&0x7F) << shift
8524 if b < 0x80 {
8525 break
8526 }
8527 }
8528 fieldNum := int32(wire >> 3)
8529 wireType := int(wire & 0x7)
8530 if wireType == 4 {
8531 return fmt.Errorf("proto: ResolveImageConfigRequest: wiretype end group for non-group")
8532 }
8533 if fieldNum <= 0 {
8534 return fmt.Errorf("proto: ResolveImageConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8535 }
8536 switch fieldNum {
8537 case 1:
8538 if wireType != 2 {
8539 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
8540 }
8541 var stringLen uint64
8542 for shift := uint(0); ; shift += 7 {
8543 if shift >= 64 {
8544 return protohelpers.ErrIntOverflow
8545 }
8546 if iNdEx >= l {
8547 return io.ErrUnexpectedEOF
8548 }
8549 b := dAtA[iNdEx]
8550 iNdEx++
8551 stringLen |= uint64(b&0x7F) << shift
8552 if b < 0x80 {
8553 break
8554 }
8555 }
8556 intStringLen := int(stringLen)
8557 if intStringLen < 0 {
8558 return protohelpers.ErrInvalidLength
8559 }
8560 postIndex := iNdEx + intStringLen
8561 if postIndex < 0 {
8562 return protohelpers.ErrInvalidLength
8563 }
8564 if postIndex > l {
8565 return io.ErrUnexpectedEOF
8566 }
8567 m.Ref = string(dAtA[iNdEx:postIndex])
8568 iNdEx = postIndex
8569 case 2:
8570 if wireType != 2 {
8571 return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
8572 }
8573 var msglen int
8574 for shift := uint(0); ; shift += 7 {
8575 if shift >= 64 {
8576 return protohelpers.ErrIntOverflow
8577 }
8578 if iNdEx >= l {
8579 return io.ErrUnexpectedEOF
8580 }
8581 b := dAtA[iNdEx]
8582 iNdEx++
8583 msglen |= int(b&0x7F) << shift
8584 if b < 0x80 {
8585 break
8586 }
8587 }
8588 if msglen < 0 {
8589 return protohelpers.ErrInvalidLength
8590 }
8591 postIndex := iNdEx + msglen
8592 if postIndex < 0 {
8593 return protohelpers.ErrInvalidLength
8594 }
8595 if postIndex > l {
8596 return io.ErrUnexpectedEOF
8597 }
8598 if m.Platform == nil {
8599 m.Platform = &pb.Platform{}
8600 }
8601 if err := m.Platform.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
8602 return err
8603 }
8604 iNdEx = postIndex
8605 case 3:
8606 if wireType != 2 {
8607 return fmt.Errorf("proto: wrong wireType = %d for field ResolveMode", wireType)
8608 }
8609 var stringLen uint64
8610 for shift := uint(0); ; shift += 7 {
8611 if shift >= 64 {
8612 return protohelpers.ErrIntOverflow
8613 }
8614 if iNdEx >= l {
8615 return io.ErrUnexpectedEOF
8616 }
8617 b := dAtA[iNdEx]
8618 iNdEx++
8619 stringLen |= uint64(b&0x7F) << shift
8620 if b < 0x80 {
8621 break
8622 }
8623 }
8624 intStringLen := int(stringLen)
8625 if intStringLen < 0 {
8626 return protohelpers.ErrInvalidLength
8627 }
8628 postIndex := iNdEx + intStringLen
8629 if postIndex < 0 {
8630 return protohelpers.ErrInvalidLength
8631 }
8632 if postIndex > l {
8633 return io.ErrUnexpectedEOF
8634 }
8635 m.ResolveMode = string(dAtA[iNdEx:postIndex])
8636 iNdEx = postIndex
8637 case 4:
8638 if wireType != 2 {
8639 return fmt.Errorf("proto: wrong wireType = %d for field LogName", wireType)
8640 }
8641 var stringLen uint64
8642 for shift := uint(0); ; shift += 7 {
8643 if shift >= 64 {
8644 return protohelpers.ErrIntOverflow
8645 }
8646 if iNdEx >= l {
8647 return io.ErrUnexpectedEOF
8648 }
8649 b := dAtA[iNdEx]
8650 iNdEx++
8651 stringLen |= uint64(b&0x7F) << shift
8652 if b < 0x80 {
8653 break
8654 }
8655 }
8656 intStringLen := int(stringLen)
8657 if intStringLen < 0 {
8658 return protohelpers.ErrInvalidLength
8659 }
8660 postIndex := iNdEx + intStringLen
8661 if postIndex < 0 {
8662 return protohelpers.ErrInvalidLength
8663 }
8664 if postIndex > l {
8665 return io.ErrUnexpectedEOF
8666 }
8667 m.LogName = string(dAtA[iNdEx:postIndex])
8668 iNdEx = postIndex
8669 case 5:
8670 if wireType != 0 {
8671 return fmt.Errorf("proto: wrong wireType = %d for field ResolverType", wireType)
8672 }
8673 m.ResolverType = 0
8674 for shift := uint(0); ; shift += 7 {
8675 if shift >= 64 {
8676 return protohelpers.ErrIntOverflow
8677 }
8678 if iNdEx >= l {
8679 return io.ErrUnexpectedEOF
8680 }
8681 b := dAtA[iNdEx]
8682 iNdEx++
8683 m.ResolverType |= int32(b&0x7F) << shift
8684 if b < 0x80 {
8685 break
8686 }
8687 }
8688 case 6:
8689 if wireType != 2 {
8690 return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType)
8691 }
8692 var stringLen uint64
8693 for shift := uint(0); ; shift += 7 {
8694 if shift >= 64 {
8695 return protohelpers.ErrIntOverflow
8696 }
8697 if iNdEx >= l {
8698 return io.ErrUnexpectedEOF
8699 }
8700 b := dAtA[iNdEx]
8701 iNdEx++
8702 stringLen |= uint64(b&0x7F) << shift
8703 if b < 0x80 {
8704 break
8705 }
8706 }
8707 intStringLen := int(stringLen)
8708 if intStringLen < 0 {
8709 return protohelpers.ErrInvalidLength
8710 }
8711 postIndex := iNdEx + intStringLen
8712 if postIndex < 0 {
8713 return protohelpers.ErrInvalidLength
8714 }
8715 if postIndex > l {
8716 return io.ErrUnexpectedEOF
8717 }
8718 m.SessionID = string(dAtA[iNdEx:postIndex])
8719 iNdEx = postIndex
8720 case 7:
8721 if wireType != 2 {
8722 return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType)
8723 }
8724 var stringLen uint64
8725 for shift := uint(0); ; shift += 7 {
8726 if shift >= 64 {
8727 return protohelpers.ErrIntOverflow
8728 }
8729 if iNdEx >= l {
8730 return io.ErrUnexpectedEOF
8731 }
8732 b := dAtA[iNdEx]
8733 iNdEx++
8734 stringLen |= uint64(b&0x7F) << shift
8735 if b < 0x80 {
8736 break
8737 }
8738 }
8739 intStringLen := int(stringLen)
8740 if intStringLen < 0 {
8741 return protohelpers.ErrInvalidLength
8742 }
8743 postIndex := iNdEx + intStringLen
8744 if postIndex < 0 {
8745 return protohelpers.ErrInvalidLength
8746 }
8747 if postIndex > l {
8748 return io.ErrUnexpectedEOF
8749 }
8750 m.StoreID = string(dAtA[iNdEx:postIndex])
8751 iNdEx = postIndex
8752 case 8:
8753 if wireType != 2 {
8754 return fmt.Errorf("proto: wrong wireType = %d for field SourcePolicies", wireType)
8755 }
8756 var msglen int
8757 for shift := uint(0); ; shift += 7 {
8758 if shift >= 64 {
8759 return protohelpers.ErrIntOverflow
8760 }
8761 if iNdEx >= l {
8762 return io.ErrUnexpectedEOF
8763 }
8764 b := dAtA[iNdEx]
8765 iNdEx++
8766 msglen |= int(b&0x7F) << shift
8767 if b < 0x80 {
8768 break
8769 }
8770 }
8771 if msglen < 0 {
8772 return protohelpers.ErrInvalidLength
8773 }
8774 postIndex := iNdEx + msglen
8775 if postIndex < 0 {
8776 return protohelpers.ErrInvalidLength
8777 }
8778 if postIndex > l {
8779 return io.ErrUnexpectedEOF
8780 }
8781 m.SourcePolicies = append(m.SourcePolicies, &pb1.Policy{})
8782 if err := m.SourcePolicies[len(m.SourcePolicies)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
8783 return err
8784 }
8785 iNdEx = postIndex
8786 default:
8787 iNdEx = preIndex
8788 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8789 if err != nil {
8790 return err
8791 }
8792 if (skippy < 0) || (iNdEx+skippy) < 0 {
8793 return protohelpers.ErrInvalidLength
8794 }
8795 if (iNdEx + skippy) > l {
8796 return io.ErrUnexpectedEOF
8797 }
8798 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8799 iNdEx += skippy
8800 }
8801 }
8802
8803 if iNdEx > l {
8804 return io.ErrUnexpectedEOF
8805 }
8806 return nil
8807 }
8808 func (m *ResolveImageConfigResponse) UnmarshalVT(dAtA []byte) error {
8809 l := len(dAtA)
8810 iNdEx := 0
8811 for iNdEx < l {
8812 preIndex := iNdEx
8813 var wire uint64
8814 for shift := uint(0); ; shift += 7 {
8815 if shift >= 64 {
8816 return protohelpers.ErrIntOverflow
8817 }
8818 if iNdEx >= l {
8819 return io.ErrUnexpectedEOF
8820 }
8821 b := dAtA[iNdEx]
8822 iNdEx++
8823 wire |= uint64(b&0x7F) << shift
8824 if b < 0x80 {
8825 break
8826 }
8827 }
8828 fieldNum := int32(wire >> 3)
8829 wireType := int(wire & 0x7)
8830 if wireType == 4 {
8831 return fmt.Errorf("proto: ResolveImageConfigResponse: wiretype end group for non-group")
8832 }
8833 if fieldNum <= 0 {
8834 return fmt.Errorf("proto: ResolveImageConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
8835 }
8836 switch fieldNum {
8837 case 1:
8838 if wireType != 2 {
8839 return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType)
8840 }
8841 var stringLen uint64
8842 for shift := uint(0); ; shift += 7 {
8843 if shift >= 64 {
8844 return protohelpers.ErrIntOverflow
8845 }
8846 if iNdEx >= l {
8847 return io.ErrUnexpectedEOF
8848 }
8849 b := dAtA[iNdEx]
8850 iNdEx++
8851 stringLen |= uint64(b&0x7F) << shift
8852 if b < 0x80 {
8853 break
8854 }
8855 }
8856 intStringLen := int(stringLen)
8857 if intStringLen < 0 {
8858 return protohelpers.ErrInvalidLength
8859 }
8860 postIndex := iNdEx + intStringLen
8861 if postIndex < 0 {
8862 return protohelpers.ErrInvalidLength
8863 }
8864 if postIndex > l {
8865 return io.ErrUnexpectedEOF
8866 }
8867 m.Digest = string(dAtA[iNdEx:postIndex])
8868 iNdEx = postIndex
8869 case 2:
8870 if wireType != 2 {
8871 return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
8872 }
8873 var byteLen int
8874 for shift := uint(0); ; shift += 7 {
8875 if shift >= 64 {
8876 return protohelpers.ErrIntOverflow
8877 }
8878 if iNdEx >= l {
8879 return io.ErrUnexpectedEOF
8880 }
8881 b := dAtA[iNdEx]
8882 iNdEx++
8883 byteLen |= int(b&0x7F) << shift
8884 if b < 0x80 {
8885 break
8886 }
8887 }
8888 if byteLen < 0 {
8889 return protohelpers.ErrInvalidLength
8890 }
8891 postIndex := iNdEx + byteLen
8892 if postIndex < 0 {
8893 return protohelpers.ErrInvalidLength
8894 }
8895 if postIndex > l {
8896 return io.ErrUnexpectedEOF
8897 }
8898 m.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...)
8899 if m.Config == nil {
8900 m.Config = []byte{}
8901 }
8902 iNdEx = postIndex
8903 case 3:
8904 if wireType != 2 {
8905 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
8906 }
8907 var stringLen uint64
8908 for shift := uint(0); ; shift += 7 {
8909 if shift >= 64 {
8910 return protohelpers.ErrIntOverflow
8911 }
8912 if iNdEx >= l {
8913 return io.ErrUnexpectedEOF
8914 }
8915 b := dAtA[iNdEx]
8916 iNdEx++
8917 stringLen |= uint64(b&0x7F) << shift
8918 if b < 0x80 {
8919 break
8920 }
8921 }
8922 intStringLen := int(stringLen)
8923 if intStringLen < 0 {
8924 return protohelpers.ErrInvalidLength
8925 }
8926 postIndex := iNdEx + intStringLen
8927 if postIndex < 0 {
8928 return protohelpers.ErrInvalidLength
8929 }
8930 if postIndex > l {
8931 return io.ErrUnexpectedEOF
8932 }
8933 m.Ref = string(dAtA[iNdEx:postIndex])
8934 iNdEx = postIndex
8935 default:
8936 iNdEx = preIndex
8937 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
8938 if err != nil {
8939 return err
8940 }
8941 if (skippy < 0) || (iNdEx+skippy) < 0 {
8942 return protohelpers.ErrInvalidLength
8943 }
8944 if (iNdEx + skippy) > l {
8945 return io.ErrUnexpectedEOF
8946 }
8947 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
8948 iNdEx += skippy
8949 }
8950 }
8951
8952 if iNdEx > l {
8953 return io.ErrUnexpectedEOF
8954 }
8955 return nil
8956 }
8957 func (m *ResolveSourceMetaRequest) UnmarshalVT(dAtA []byte) error {
8958 l := len(dAtA)
8959 iNdEx := 0
8960 for iNdEx < l {
8961 preIndex := iNdEx
8962 var wire uint64
8963 for shift := uint(0); ; shift += 7 {
8964 if shift >= 64 {
8965 return protohelpers.ErrIntOverflow
8966 }
8967 if iNdEx >= l {
8968 return io.ErrUnexpectedEOF
8969 }
8970 b := dAtA[iNdEx]
8971 iNdEx++
8972 wire |= uint64(b&0x7F) << shift
8973 if b < 0x80 {
8974 break
8975 }
8976 }
8977 fieldNum := int32(wire >> 3)
8978 wireType := int(wire & 0x7)
8979 if wireType == 4 {
8980 return fmt.Errorf("proto: ResolveSourceMetaRequest: wiretype end group for non-group")
8981 }
8982 if fieldNum <= 0 {
8983 return fmt.Errorf("proto: ResolveSourceMetaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8984 }
8985 switch fieldNum {
8986 case 1:
8987 if wireType != 2 {
8988 return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
8989 }
8990 var msglen int
8991 for shift := uint(0); ; shift += 7 {
8992 if shift >= 64 {
8993 return protohelpers.ErrIntOverflow
8994 }
8995 if iNdEx >= l {
8996 return io.ErrUnexpectedEOF
8997 }
8998 b := dAtA[iNdEx]
8999 iNdEx++
9000 msglen |= int(b&0x7F) << shift
9001 if b < 0x80 {
9002 break
9003 }
9004 }
9005 if msglen < 0 {
9006 return protohelpers.ErrInvalidLength
9007 }
9008 postIndex := iNdEx + msglen
9009 if postIndex < 0 {
9010 return protohelpers.ErrInvalidLength
9011 }
9012 if postIndex > l {
9013 return io.ErrUnexpectedEOF
9014 }
9015 if m.Source == nil {
9016 m.Source = &pb.SourceOp{}
9017 }
9018 if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9019 return err
9020 }
9021 iNdEx = postIndex
9022 case 2:
9023 if wireType != 2 {
9024 return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
9025 }
9026 var msglen int
9027 for shift := uint(0); ; shift += 7 {
9028 if shift >= 64 {
9029 return protohelpers.ErrIntOverflow
9030 }
9031 if iNdEx >= l {
9032 return io.ErrUnexpectedEOF
9033 }
9034 b := dAtA[iNdEx]
9035 iNdEx++
9036 msglen |= int(b&0x7F) << shift
9037 if b < 0x80 {
9038 break
9039 }
9040 }
9041 if msglen < 0 {
9042 return protohelpers.ErrInvalidLength
9043 }
9044 postIndex := iNdEx + msglen
9045 if postIndex < 0 {
9046 return protohelpers.ErrInvalidLength
9047 }
9048 if postIndex > l {
9049 return io.ErrUnexpectedEOF
9050 }
9051 if m.Platform == nil {
9052 m.Platform = &pb.Platform{}
9053 }
9054 if err := m.Platform.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9055 return err
9056 }
9057 iNdEx = postIndex
9058 case 3:
9059 if wireType != 2 {
9060 return fmt.Errorf("proto: wrong wireType = %d for field LogName", wireType)
9061 }
9062 var stringLen uint64
9063 for shift := uint(0); ; shift += 7 {
9064 if shift >= 64 {
9065 return protohelpers.ErrIntOverflow
9066 }
9067 if iNdEx >= l {
9068 return io.ErrUnexpectedEOF
9069 }
9070 b := dAtA[iNdEx]
9071 iNdEx++
9072 stringLen |= uint64(b&0x7F) << shift
9073 if b < 0x80 {
9074 break
9075 }
9076 }
9077 intStringLen := int(stringLen)
9078 if intStringLen < 0 {
9079 return protohelpers.ErrInvalidLength
9080 }
9081 postIndex := iNdEx + intStringLen
9082 if postIndex < 0 {
9083 return protohelpers.ErrInvalidLength
9084 }
9085 if postIndex > l {
9086 return io.ErrUnexpectedEOF
9087 }
9088 m.LogName = string(dAtA[iNdEx:postIndex])
9089 iNdEx = postIndex
9090 case 4:
9091 if wireType != 2 {
9092 return fmt.Errorf("proto: wrong wireType = %d for field ResolveMode", wireType)
9093 }
9094 var stringLen uint64
9095 for shift := uint(0); ; shift += 7 {
9096 if shift >= 64 {
9097 return protohelpers.ErrIntOverflow
9098 }
9099 if iNdEx >= l {
9100 return io.ErrUnexpectedEOF
9101 }
9102 b := dAtA[iNdEx]
9103 iNdEx++
9104 stringLen |= uint64(b&0x7F) << shift
9105 if b < 0x80 {
9106 break
9107 }
9108 }
9109 intStringLen := int(stringLen)
9110 if intStringLen < 0 {
9111 return protohelpers.ErrInvalidLength
9112 }
9113 postIndex := iNdEx + intStringLen
9114 if postIndex < 0 {
9115 return protohelpers.ErrInvalidLength
9116 }
9117 if postIndex > l {
9118 return io.ErrUnexpectedEOF
9119 }
9120 m.ResolveMode = string(dAtA[iNdEx:postIndex])
9121 iNdEx = postIndex
9122 case 8:
9123 if wireType != 2 {
9124 return fmt.Errorf("proto: wrong wireType = %d for field SourcePolicies", wireType)
9125 }
9126 var msglen int
9127 for shift := uint(0); ; shift += 7 {
9128 if shift >= 64 {
9129 return protohelpers.ErrIntOverflow
9130 }
9131 if iNdEx >= l {
9132 return io.ErrUnexpectedEOF
9133 }
9134 b := dAtA[iNdEx]
9135 iNdEx++
9136 msglen |= int(b&0x7F) << shift
9137 if b < 0x80 {
9138 break
9139 }
9140 }
9141 if msglen < 0 {
9142 return protohelpers.ErrInvalidLength
9143 }
9144 postIndex := iNdEx + msglen
9145 if postIndex < 0 {
9146 return protohelpers.ErrInvalidLength
9147 }
9148 if postIndex > l {
9149 return io.ErrUnexpectedEOF
9150 }
9151 m.SourcePolicies = append(m.SourcePolicies, &pb1.Policy{})
9152 if err := m.SourcePolicies[len(m.SourcePolicies)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9153 return err
9154 }
9155 iNdEx = postIndex
9156 default:
9157 iNdEx = preIndex
9158 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
9159 if err != nil {
9160 return err
9161 }
9162 if (skippy < 0) || (iNdEx+skippy) < 0 {
9163 return protohelpers.ErrInvalidLength
9164 }
9165 if (iNdEx + skippy) > l {
9166 return io.ErrUnexpectedEOF
9167 }
9168 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
9169 iNdEx += skippy
9170 }
9171 }
9172
9173 if iNdEx > l {
9174 return io.ErrUnexpectedEOF
9175 }
9176 return nil
9177 }
9178 func (m *ResolveSourceMetaResponse) UnmarshalVT(dAtA []byte) error {
9179 l := len(dAtA)
9180 iNdEx := 0
9181 for iNdEx < l {
9182 preIndex := iNdEx
9183 var wire uint64
9184 for shift := uint(0); ; shift += 7 {
9185 if shift >= 64 {
9186 return protohelpers.ErrIntOverflow
9187 }
9188 if iNdEx >= l {
9189 return io.ErrUnexpectedEOF
9190 }
9191 b := dAtA[iNdEx]
9192 iNdEx++
9193 wire |= uint64(b&0x7F) << shift
9194 if b < 0x80 {
9195 break
9196 }
9197 }
9198 fieldNum := int32(wire >> 3)
9199 wireType := int(wire & 0x7)
9200 if wireType == 4 {
9201 return fmt.Errorf("proto: ResolveSourceMetaResponse: wiretype end group for non-group")
9202 }
9203 if fieldNum <= 0 {
9204 return fmt.Errorf("proto: ResolveSourceMetaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
9205 }
9206 switch fieldNum {
9207 case 1:
9208 if wireType != 2 {
9209 return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
9210 }
9211 var msglen int
9212 for shift := uint(0); ; shift += 7 {
9213 if shift >= 64 {
9214 return protohelpers.ErrIntOverflow
9215 }
9216 if iNdEx >= l {
9217 return io.ErrUnexpectedEOF
9218 }
9219 b := dAtA[iNdEx]
9220 iNdEx++
9221 msglen |= int(b&0x7F) << shift
9222 if b < 0x80 {
9223 break
9224 }
9225 }
9226 if msglen < 0 {
9227 return protohelpers.ErrInvalidLength
9228 }
9229 postIndex := iNdEx + msglen
9230 if postIndex < 0 {
9231 return protohelpers.ErrInvalidLength
9232 }
9233 if postIndex > l {
9234 return io.ErrUnexpectedEOF
9235 }
9236 if m.Source == nil {
9237 m.Source = &pb.SourceOp{}
9238 }
9239 if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9240 return err
9241 }
9242 iNdEx = postIndex
9243 case 2:
9244 if wireType != 2 {
9245 return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
9246 }
9247 var msglen int
9248 for shift := uint(0); ; shift += 7 {
9249 if shift >= 64 {
9250 return protohelpers.ErrIntOverflow
9251 }
9252 if iNdEx >= l {
9253 return io.ErrUnexpectedEOF
9254 }
9255 b := dAtA[iNdEx]
9256 iNdEx++
9257 msglen |= int(b&0x7F) << shift
9258 if b < 0x80 {
9259 break
9260 }
9261 }
9262 if msglen < 0 {
9263 return protohelpers.ErrInvalidLength
9264 }
9265 postIndex := iNdEx + msglen
9266 if postIndex < 0 {
9267 return protohelpers.ErrInvalidLength
9268 }
9269 if postIndex > l {
9270 return io.ErrUnexpectedEOF
9271 }
9272 if m.Image == nil {
9273 m.Image = &ResolveSourceImageResponse{}
9274 }
9275 if err := m.Image.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9276 return err
9277 }
9278 iNdEx = postIndex
9279 default:
9280 iNdEx = preIndex
9281 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
9282 if err != nil {
9283 return err
9284 }
9285 if (skippy < 0) || (iNdEx+skippy) < 0 {
9286 return protohelpers.ErrInvalidLength
9287 }
9288 if (iNdEx + skippy) > l {
9289 return io.ErrUnexpectedEOF
9290 }
9291 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
9292 iNdEx += skippy
9293 }
9294 }
9295
9296 if iNdEx > l {
9297 return io.ErrUnexpectedEOF
9298 }
9299 return nil
9300 }
9301 func (m *ResolveSourceImageResponse) UnmarshalVT(dAtA []byte) error {
9302 l := len(dAtA)
9303 iNdEx := 0
9304 for iNdEx < l {
9305 preIndex := iNdEx
9306 var wire uint64
9307 for shift := uint(0); ; shift += 7 {
9308 if shift >= 64 {
9309 return protohelpers.ErrIntOverflow
9310 }
9311 if iNdEx >= l {
9312 return io.ErrUnexpectedEOF
9313 }
9314 b := dAtA[iNdEx]
9315 iNdEx++
9316 wire |= uint64(b&0x7F) << shift
9317 if b < 0x80 {
9318 break
9319 }
9320 }
9321 fieldNum := int32(wire >> 3)
9322 wireType := int(wire & 0x7)
9323 if wireType == 4 {
9324 return fmt.Errorf("proto: ResolveSourceImageResponse: wiretype end group for non-group")
9325 }
9326 if fieldNum <= 0 {
9327 return fmt.Errorf("proto: ResolveSourceImageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
9328 }
9329 switch fieldNum {
9330 case 1:
9331 if wireType != 2 {
9332 return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType)
9333 }
9334 var stringLen uint64
9335 for shift := uint(0); ; shift += 7 {
9336 if shift >= 64 {
9337 return protohelpers.ErrIntOverflow
9338 }
9339 if iNdEx >= l {
9340 return io.ErrUnexpectedEOF
9341 }
9342 b := dAtA[iNdEx]
9343 iNdEx++
9344 stringLen |= uint64(b&0x7F) << shift
9345 if b < 0x80 {
9346 break
9347 }
9348 }
9349 intStringLen := int(stringLen)
9350 if intStringLen < 0 {
9351 return protohelpers.ErrInvalidLength
9352 }
9353 postIndex := iNdEx + intStringLen
9354 if postIndex < 0 {
9355 return protohelpers.ErrInvalidLength
9356 }
9357 if postIndex > l {
9358 return io.ErrUnexpectedEOF
9359 }
9360 m.Digest = string(dAtA[iNdEx:postIndex])
9361 iNdEx = postIndex
9362 case 2:
9363 if wireType != 2 {
9364 return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
9365 }
9366 var byteLen int
9367 for shift := uint(0); ; shift += 7 {
9368 if shift >= 64 {
9369 return protohelpers.ErrIntOverflow
9370 }
9371 if iNdEx >= l {
9372 return io.ErrUnexpectedEOF
9373 }
9374 b := dAtA[iNdEx]
9375 iNdEx++
9376 byteLen |= int(b&0x7F) << shift
9377 if b < 0x80 {
9378 break
9379 }
9380 }
9381 if byteLen < 0 {
9382 return protohelpers.ErrInvalidLength
9383 }
9384 postIndex := iNdEx + byteLen
9385 if postIndex < 0 {
9386 return protohelpers.ErrInvalidLength
9387 }
9388 if postIndex > l {
9389 return io.ErrUnexpectedEOF
9390 }
9391 m.Config = append(m.Config[:0], dAtA[iNdEx:postIndex]...)
9392 if m.Config == nil {
9393 m.Config = []byte{}
9394 }
9395 iNdEx = postIndex
9396 default:
9397 iNdEx = preIndex
9398 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
9399 if err != nil {
9400 return err
9401 }
9402 if (skippy < 0) || (iNdEx+skippy) < 0 {
9403 return protohelpers.ErrInvalidLength
9404 }
9405 if (iNdEx + skippy) > l {
9406 return io.ErrUnexpectedEOF
9407 }
9408 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
9409 iNdEx += skippy
9410 }
9411 }
9412
9413 if iNdEx > l {
9414 return io.ErrUnexpectedEOF
9415 }
9416 return nil
9417 }
9418 func (m *SolveRequest) UnmarshalVT(dAtA []byte) error {
9419 l := len(dAtA)
9420 iNdEx := 0
9421 for iNdEx < l {
9422 preIndex := iNdEx
9423 var wire uint64
9424 for shift := uint(0); ; shift += 7 {
9425 if shift >= 64 {
9426 return protohelpers.ErrIntOverflow
9427 }
9428 if iNdEx >= l {
9429 return io.ErrUnexpectedEOF
9430 }
9431 b := dAtA[iNdEx]
9432 iNdEx++
9433 wire |= uint64(b&0x7F) << shift
9434 if b < 0x80 {
9435 break
9436 }
9437 }
9438 fieldNum := int32(wire >> 3)
9439 wireType := int(wire & 0x7)
9440 if wireType == 4 {
9441 return fmt.Errorf("proto: SolveRequest: wiretype end group for non-group")
9442 }
9443 if fieldNum <= 0 {
9444 return fmt.Errorf("proto: SolveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
9445 }
9446 switch fieldNum {
9447 case 1:
9448 if wireType != 2 {
9449 return fmt.Errorf("proto: wrong wireType = %d for field Definition", wireType)
9450 }
9451 var msglen int
9452 for shift := uint(0); ; shift += 7 {
9453 if shift >= 64 {
9454 return protohelpers.ErrIntOverflow
9455 }
9456 if iNdEx >= l {
9457 return io.ErrUnexpectedEOF
9458 }
9459 b := dAtA[iNdEx]
9460 iNdEx++
9461 msglen |= int(b&0x7F) << shift
9462 if b < 0x80 {
9463 break
9464 }
9465 }
9466 if msglen < 0 {
9467 return protohelpers.ErrInvalidLength
9468 }
9469 postIndex := iNdEx + msglen
9470 if postIndex < 0 {
9471 return protohelpers.ErrInvalidLength
9472 }
9473 if postIndex > l {
9474 return io.ErrUnexpectedEOF
9475 }
9476 if m.Definition == nil {
9477 m.Definition = &pb.Definition{}
9478 }
9479 if err := m.Definition.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9480 return err
9481 }
9482 iNdEx = postIndex
9483 case 2:
9484 if wireType != 2 {
9485 return fmt.Errorf("proto: wrong wireType = %d for field Frontend", wireType)
9486 }
9487 var stringLen uint64
9488 for shift := uint(0); ; shift += 7 {
9489 if shift >= 64 {
9490 return protohelpers.ErrIntOverflow
9491 }
9492 if iNdEx >= l {
9493 return io.ErrUnexpectedEOF
9494 }
9495 b := dAtA[iNdEx]
9496 iNdEx++
9497 stringLen |= uint64(b&0x7F) << shift
9498 if b < 0x80 {
9499 break
9500 }
9501 }
9502 intStringLen := int(stringLen)
9503 if intStringLen < 0 {
9504 return protohelpers.ErrInvalidLength
9505 }
9506 postIndex := iNdEx + intStringLen
9507 if postIndex < 0 {
9508 return protohelpers.ErrInvalidLength
9509 }
9510 if postIndex > l {
9511 return io.ErrUnexpectedEOF
9512 }
9513 m.Frontend = string(dAtA[iNdEx:postIndex])
9514 iNdEx = postIndex
9515 case 3:
9516 if wireType != 2 {
9517 return fmt.Errorf("proto: wrong wireType = %d for field FrontendOpt", wireType)
9518 }
9519 var msglen int
9520 for shift := uint(0); ; shift += 7 {
9521 if shift >= 64 {
9522 return protohelpers.ErrIntOverflow
9523 }
9524 if iNdEx >= l {
9525 return io.ErrUnexpectedEOF
9526 }
9527 b := dAtA[iNdEx]
9528 iNdEx++
9529 msglen |= int(b&0x7F) << shift
9530 if b < 0x80 {
9531 break
9532 }
9533 }
9534 if msglen < 0 {
9535 return protohelpers.ErrInvalidLength
9536 }
9537 postIndex := iNdEx + msglen
9538 if postIndex < 0 {
9539 return protohelpers.ErrInvalidLength
9540 }
9541 if postIndex > l {
9542 return io.ErrUnexpectedEOF
9543 }
9544 if m.FrontendOpt == nil {
9545 m.FrontendOpt = make(map[string]string)
9546 }
9547 var mapkey string
9548 var mapvalue string
9549 for iNdEx < postIndex {
9550 entryPreIndex := iNdEx
9551 var wire uint64
9552 for shift := uint(0); ; shift += 7 {
9553 if shift >= 64 {
9554 return protohelpers.ErrIntOverflow
9555 }
9556 if iNdEx >= l {
9557 return io.ErrUnexpectedEOF
9558 }
9559 b := dAtA[iNdEx]
9560 iNdEx++
9561 wire |= uint64(b&0x7F) << shift
9562 if b < 0x80 {
9563 break
9564 }
9565 }
9566 fieldNum := int32(wire >> 3)
9567 if fieldNum == 1 {
9568 var stringLenmapkey uint64
9569 for shift := uint(0); ; shift += 7 {
9570 if shift >= 64 {
9571 return protohelpers.ErrIntOverflow
9572 }
9573 if iNdEx >= l {
9574 return io.ErrUnexpectedEOF
9575 }
9576 b := dAtA[iNdEx]
9577 iNdEx++
9578 stringLenmapkey |= uint64(b&0x7F) << shift
9579 if b < 0x80 {
9580 break
9581 }
9582 }
9583 intStringLenmapkey := int(stringLenmapkey)
9584 if intStringLenmapkey < 0 {
9585 return protohelpers.ErrInvalidLength
9586 }
9587 postStringIndexmapkey := iNdEx + intStringLenmapkey
9588 if postStringIndexmapkey < 0 {
9589 return protohelpers.ErrInvalidLength
9590 }
9591 if postStringIndexmapkey > l {
9592 return io.ErrUnexpectedEOF
9593 }
9594 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9595 iNdEx = postStringIndexmapkey
9596 } else if fieldNum == 2 {
9597 var stringLenmapvalue uint64
9598 for shift := uint(0); ; shift += 7 {
9599 if shift >= 64 {
9600 return protohelpers.ErrIntOverflow
9601 }
9602 if iNdEx >= l {
9603 return io.ErrUnexpectedEOF
9604 }
9605 b := dAtA[iNdEx]
9606 iNdEx++
9607 stringLenmapvalue |= uint64(b&0x7F) << shift
9608 if b < 0x80 {
9609 break
9610 }
9611 }
9612 intStringLenmapvalue := int(stringLenmapvalue)
9613 if intStringLenmapvalue < 0 {
9614 return protohelpers.ErrInvalidLength
9615 }
9616 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
9617 if postStringIndexmapvalue < 0 {
9618 return protohelpers.ErrInvalidLength
9619 }
9620 if postStringIndexmapvalue > l {
9621 return io.ErrUnexpectedEOF
9622 }
9623 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
9624 iNdEx = postStringIndexmapvalue
9625 } else {
9626 iNdEx = entryPreIndex
9627 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
9628 if err != nil {
9629 return err
9630 }
9631 if (skippy < 0) || (iNdEx+skippy) < 0 {
9632 return protohelpers.ErrInvalidLength
9633 }
9634 if (iNdEx + skippy) > postIndex {
9635 return io.ErrUnexpectedEOF
9636 }
9637 iNdEx += skippy
9638 }
9639 }
9640 m.FrontendOpt[mapkey] = mapvalue
9641 iNdEx = postIndex
9642 case 5:
9643 if wireType != 0 {
9644 return fmt.Errorf("proto: wrong wireType = %d for field AllowResultReturn", wireType)
9645 }
9646 var v int
9647 for shift := uint(0); ; shift += 7 {
9648 if shift >= 64 {
9649 return protohelpers.ErrIntOverflow
9650 }
9651 if iNdEx >= l {
9652 return io.ErrUnexpectedEOF
9653 }
9654 b := dAtA[iNdEx]
9655 iNdEx++
9656 v |= int(b&0x7F) << shift
9657 if b < 0x80 {
9658 break
9659 }
9660 }
9661 m.AllowResultReturn = bool(v != 0)
9662 case 6:
9663 if wireType != 0 {
9664 return fmt.Errorf("proto: wrong wireType = %d for field AllowResultArrayRef", wireType)
9665 }
9666 var v int
9667 for shift := uint(0); ; shift += 7 {
9668 if shift >= 64 {
9669 return protohelpers.ErrIntOverflow
9670 }
9671 if iNdEx >= l {
9672 return io.ErrUnexpectedEOF
9673 }
9674 b := dAtA[iNdEx]
9675 iNdEx++
9676 v |= int(b&0x7F) << shift
9677 if b < 0x80 {
9678 break
9679 }
9680 }
9681 m.AllowResultArrayRef = bool(v != 0)
9682 case 10:
9683 if wireType != 0 {
9684 return fmt.Errorf("proto: wrong wireType = %d for field Final", wireType)
9685 }
9686 var v int
9687 for shift := uint(0); ; shift += 7 {
9688 if shift >= 64 {
9689 return protohelpers.ErrIntOverflow
9690 }
9691 if iNdEx >= l {
9692 return io.ErrUnexpectedEOF
9693 }
9694 b := dAtA[iNdEx]
9695 iNdEx++
9696 v |= int(b&0x7F) << shift
9697 if b < 0x80 {
9698 break
9699 }
9700 }
9701 m.Final = bool(v != 0)
9702 case 11:
9703 if wireType != 2 {
9704 return fmt.Errorf("proto: wrong wireType = %d for field ExporterAttr", wireType)
9705 }
9706 var byteLen int
9707 for shift := uint(0); ; shift += 7 {
9708 if shift >= 64 {
9709 return protohelpers.ErrIntOverflow
9710 }
9711 if iNdEx >= l {
9712 return io.ErrUnexpectedEOF
9713 }
9714 b := dAtA[iNdEx]
9715 iNdEx++
9716 byteLen |= int(b&0x7F) << shift
9717 if b < 0x80 {
9718 break
9719 }
9720 }
9721 if byteLen < 0 {
9722 return protohelpers.ErrInvalidLength
9723 }
9724 postIndex := iNdEx + byteLen
9725 if postIndex < 0 {
9726 return protohelpers.ErrInvalidLength
9727 }
9728 if postIndex > l {
9729 return io.ErrUnexpectedEOF
9730 }
9731 m.ExporterAttr = append(m.ExporterAttr[:0], dAtA[iNdEx:postIndex]...)
9732 if m.ExporterAttr == nil {
9733 m.ExporterAttr = []byte{}
9734 }
9735 iNdEx = postIndex
9736 case 12:
9737 if wireType != 2 {
9738 return fmt.Errorf("proto: wrong wireType = %d for field CacheImports", wireType)
9739 }
9740 var msglen int
9741 for shift := uint(0); ; shift += 7 {
9742 if shift >= 64 {
9743 return protohelpers.ErrIntOverflow
9744 }
9745 if iNdEx >= l {
9746 return io.ErrUnexpectedEOF
9747 }
9748 b := dAtA[iNdEx]
9749 iNdEx++
9750 msglen |= int(b&0x7F) << shift
9751 if b < 0x80 {
9752 break
9753 }
9754 }
9755 if msglen < 0 {
9756 return protohelpers.ErrInvalidLength
9757 }
9758 postIndex := iNdEx + msglen
9759 if postIndex < 0 {
9760 return protohelpers.ErrInvalidLength
9761 }
9762 if postIndex > l {
9763 return io.ErrUnexpectedEOF
9764 }
9765 m.CacheImports = append(m.CacheImports, &CacheOptionsEntry{})
9766 if err := m.CacheImports[len(m.CacheImports)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9767 return err
9768 }
9769 iNdEx = postIndex
9770 case 13:
9771 if wireType != 2 {
9772 return fmt.Errorf("proto: wrong wireType = %d for field FrontendInputs", wireType)
9773 }
9774 var msglen int
9775 for shift := uint(0); ; shift += 7 {
9776 if shift >= 64 {
9777 return protohelpers.ErrIntOverflow
9778 }
9779 if iNdEx >= l {
9780 return io.ErrUnexpectedEOF
9781 }
9782 b := dAtA[iNdEx]
9783 iNdEx++
9784 msglen |= int(b&0x7F) << shift
9785 if b < 0x80 {
9786 break
9787 }
9788 }
9789 if msglen < 0 {
9790 return protohelpers.ErrInvalidLength
9791 }
9792 postIndex := iNdEx + msglen
9793 if postIndex < 0 {
9794 return protohelpers.ErrInvalidLength
9795 }
9796 if postIndex > l {
9797 return io.ErrUnexpectedEOF
9798 }
9799 if m.FrontendInputs == nil {
9800 m.FrontendInputs = make(map[string]*pb.Definition)
9801 }
9802 var mapkey string
9803 var mapvalue *pb.Definition
9804 for iNdEx < postIndex {
9805 entryPreIndex := iNdEx
9806 var wire uint64
9807 for shift := uint(0); ; shift += 7 {
9808 if shift >= 64 {
9809 return protohelpers.ErrIntOverflow
9810 }
9811 if iNdEx >= l {
9812 return io.ErrUnexpectedEOF
9813 }
9814 b := dAtA[iNdEx]
9815 iNdEx++
9816 wire |= uint64(b&0x7F) << shift
9817 if b < 0x80 {
9818 break
9819 }
9820 }
9821 fieldNum := int32(wire >> 3)
9822 if fieldNum == 1 {
9823 var stringLenmapkey uint64
9824 for shift := uint(0); ; shift += 7 {
9825 if shift >= 64 {
9826 return protohelpers.ErrIntOverflow
9827 }
9828 if iNdEx >= l {
9829 return io.ErrUnexpectedEOF
9830 }
9831 b := dAtA[iNdEx]
9832 iNdEx++
9833 stringLenmapkey |= uint64(b&0x7F) << shift
9834 if b < 0x80 {
9835 break
9836 }
9837 }
9838 intStringLenmapkey := int(stringLenmapkey)
9839 if intStringLenmapkey < 0 {
9840 return protohelpers.ErrInvalidLength
9841 }
9842 postStringIndexmapkey := iNdEx + intStringLenmapkey
9843 if postStringIndexmapkey < 0 {
9844 return protohelpers.ErrInvalidLength
9845 }
9846 if postStringIndexmapkey > l {
9847 return io.ErrUnexpectedEOF
9848 }
9849 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9850 iNdEx = postStringIndexmapkey
9851 } else if fieldNum == 2 {
9852 var mapmsglen int
9853 for shift := uint(0); ; shift += 7 {
9854 if shift >= 64 {
9855 return protohelpers.ErrIntOverflow
9856 }
9857 if iNdEx >= l {
9858 return io.ErrUnexpectedEOF
9859 }
9860 b := dAtA[iNdEx]
9861 iNdEx++
9862 mapmsglen |= int(b&0x7F) << shift
9863 if b < 0x80 {
9864 break
9865 }
9866 }
9867 if mapmsglen < 0 {
9868 return protohelpers.ErrInvalidLength
9869 }
9870 postmsgIndex := iNdEx + mapmsglen
9871 if postmsgIndex < 0 {
9872 return protohelpers.ErrInvalidLength
9873 }
9874 if postmsgIndex > l {
9875 return io.ErrUnexpectedEOF
9876 }
9877 mapvalue = &pb.Definition{}
9878 if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
9879 return err
9880 }
9881 iNdEx = postmsgIndex
9882 } else {
9883 iNdEx = entryPreIndex
9884 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
9885 if err != nil {
9886 return err
9887 }
9888 if (skippy < 0) || (iNdEx+skippy) < 0 {
9889 return protohelpers.ErrInvalidLength
9890 }
9891 if (iNdEx + skippy) > postIndex {
9892 return io.ErrUnexpectedEOF
9893 }
9894 iNdEx += skippy
9895 }
9896 }
9897 m.FrontendInputs[mapkey] = mapvalue
9898 iNdEx = postIndex
9899 case 14:
9900 if wireType != 0 {
9901 return fmt.Errorf("proto: wrong wireType = %d for field Evaluate", wireType)
9902 }
9903 var v int
9904 for shift := uint(0); ; shift += 7 {
9905 if shift >= 64 {
9906 return protohelpers.ErrIntOverflow
9907 }
9908 if iNdEx >= l {
9909 return io.ErrUnexpectedEOF
9910 }
9911 b := dAtA[iNdEx]
9912 iNdEx++
9913 v |= int(b&0x7F) << shift
9914 if b < 0x80 {
9915 break
9916 }
9917 }
9918 m.Evaluate = bool(v != 0)
9919 case 15:
9920 if wireType != 2 {
9921 return fmt.Errorf("proto: wrong wireType = %d for field SourcePolicies", wireType)
9922 }
9923 var msglen int
9924 for shift := uint(0); ; shift += 7 {
9925 if shift >= 64 {
9926 return protohelpers.ErrIntOverflow
9927 }
9928 if iNdEx >= l {
9929 return io.ErrUnexpectedEOF
9930 }
9931 b := dAtA[iNdEx]
9932 iNdEx++
9933 msglen |= int(b&0x7F) << shift
9934 if b < 0x80 {
9935 break
9936 }
9937 }
9938 if msglen < 0 {
9939 return protohelpers.ErrInvalidLength
9940 }
9941 postIndex := iNdEx + msglen
9942 if postIndex < 0 {
9943 return protohelpers.ErrInvalidLength
9944 }
9945 if postIndex > l {
9946 return io.ErrUnexpectedEOF
9947 }
9948 m.SourcePolicies = append(m.SourcePolicies, &pb1.Policy{})
9949 if err := m.SourcePolicies[len(m.SourcePolicies)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
9950 return err
9951 }
9952 iNdEx = postIndex
9953 default:
9954 iNdEx = preIndex
9955 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
9956 if err != nil {
9957 return err
9958 }
9959 if (skippy < 0) || (iNdEx+skippy) < 0 {
9960 return protohelpers.ErrInvalidLength
9961 }
9962 if (iNdEx + skippy) > l {
9963 return io.ErrUnexpectedEOF
9964 }
9965 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
9966 iNdEx += skippy
9967 }
9968 }
9969
9970 if iNdEx > l {
9971 return io.ErrUnexpectedEOF
9972 }
9973 return nil
9974 }
9975 func (m *CacheOptionsEntry) UnmarshalVT(dAtA []byte) error {
9976 l := len(dAtA)
9977 iNdEx := 0
9978 for iNdEx < l {
9979 preIndex := iNdEx
9980 var wire uint64
9981 for shift := uint(0); ; shift += 7 {
9982 if shift >= 64 {
9983 return protohelpers.ErrIntOverflow
9984 }
9985 if iNdEx >= l {
9986 return io.ErrUnexpectedEOF
9987 }
9988 b := dAtA[iNdEx]
9989 iNdEx++
9990 wire |= uint64(b&0x7F) << shift
9991 if b < 0x80 {
9992 break
9993 }
9994 }
9995 fieldNum := int32(wire >> 3)
9996 wireType := int(wire & 0x7)
9997 if wireType == 4 {
9998 return fmt.Errorf("proto: CacheOptionsEntry: wiretype end group for non-group")
9999 }
10000 if fieldNum <= 0 {
10001 return fmt.Errorf("proto: CacheOptionsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
10002 }
10003 switch fieldNum {
10004 case 1:
10005 if wireType != 2 {
10006 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
10007 }
10008 var stringLen uint64
10009 for shift := uint(0); ; shift += 7 {
10010 if shift >= 64 {
10011 return protohelpers.ErrIntOverflow
10012 }
10013 if iNdEx >= l {
10014 return io.ErrUnexpectedEOF
10015 }
10016 b := dAtA[iNdEx]
10017 iNdEx++
10018 stringLen |= uint64(b&0x7F) << shift
10019 if b < 0x80 {
10020 break
10021 }
10022 }
10023 intStringLen := int(stringLen)
10024 if intStringLen < 0 {
10025 return protohelpers.ErrInvalidLength
10026 }
10027 postIndex := iNdEx + intStringLen
10028 if postIndex < 0 {
10029 return protohelpers.ErrInvalidLength
10030 }
10031 if postIndex > l {
10032 return io.ErrUnexpectedEOF
10033 }
10034 m.Type = string(dAtA[iNdEx:postIndex])
10035 iNdEx = postIndex
10036 case 2:
10037 if wireType != 2 {
10038 return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
10039 }
10040 var msglen int
10041 for shift := uint(0); ; shift += 7 {
10042 if shift >= 64 {
10043 return protohelpers.ErrIntOverflow
10044 }
10045 if iNdEx >= l {
10046 return io.ErrUnexpectedEOF
10047 }
10048 b := dAtA[iNdEx]
10049 iNdEx++
10050 msglen |= int(b&0x7F) << shift
10051 if b < 0x80 {
10052 break
10053 }
10054 }
10055 if msglen < 0 {
10056 return protohelpers.ErrInvalidLength
10057 }
10058 postIndex := iNdEx + msglen
10059 if postIndex < 0 {
10060 return protohelpers.ErrInvalidLength
10061 }
10062 if postIndex > l {
10063 return io.ErrUnexpectedEOF
10064 }
10065 if m.Attrs == nil {
10066 m.Attrs = make(map[string]string)
10067 }
10068 var mapkey string
10069 var mapvalue string
10070 for iNdEx < postIndex {
10071 entryPreIndex := iNdEx
10072 var wire uint64
10073 for shift := uint(0); ; shift += 7 {
10074 if shift >= 64 {
10075 return protohelpers.ErrIntOverflow
10076 }
10077 if iNdEx >= l {
10078 return io.ErrUnexpectedEOF
10079 }
10080 b := dAtA[iNdEx]
10081 iNdEx++
10082 wire |= uint64(b&0x7F) << shift
10083 if b < 0x80 {
10084 break
10085 }
10086 }
10087 fieldNum := int32(wire >> 3)
10088 if fieldNum == 1 {
10089 var stringLenmapkey uint64
10090 for shift := uint(0); ; shift += 7 {
10091 if shift >= 64 {
10092 return protohelpers.ErrIntOverflow
10093 }
10094 if iNdEx >= l {
10095 return io.ErrUnexpectedEOF
10096 }
10097 b := dAtA[iNdEx]
10098 iNdEx++
10099 stringLenmapkey |= uint64(b&0x7F) << shift
10100 if b < 0x80 {
10101 break
10102 }
10103 }
10104 intStringLenmapkey := int(stringLenmapkey)
10105 if intStringLenmapkey < 0 {
10106 return protohelpers.ErrInvalidLength
10107 }
10108 postStringIndexmapkey := iNdEx + intStringLenmapkey
10109 if postStringIndexmapkey < 0 {
10110 return protohelpers.ErrInvalidLength
10111 }
10112 if postStringIndexmapkey > l {
10113 return io.ErrUnexpectedEOF
10114 }
10115 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
10116 iNdEx = postStringIndexmapkey
10117 } else if fieldNum == 2 {
10118 var stringLenmapvalue uint64
10119 for shift := uint(0); ; shift += 7 {
10120 if shift >= 64 {
10121 return protohelpers.ErrIntOverflow
10122 }
10123 if iNdEx >= l {
10124 return io.ErrUnexpectedEOF
10125 }
10126 b := dAtA[iNdEx]
10127 iNdEx++
10128 stringLenmapvalue |= uint64(b&0x7F) << shift
10129 if b < 0x80 {
10130 break
10131 }
10132 }
10133 intStringLenmapvalue := int(stringLenmapvalue)
10134 if intStringLenmapvalue < 0 {
10135 return protohelpers.ErrInvalidLength
10136 }
10137 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
10138 if postStringIndexmapvalue < 0 {
10139 return protohelpers.ErrInvalidLength
10140 }
10141 if postStringIndexmapvalue > l {
10142 return io.ErrUnexpectedEOF
10143 }
10144 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
10145 iNdEx = postStringIndexmapvalue
10146 } else {
10147 iNdEx = entryPreIndex
10148 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10149 if err != nil {
10150 return err
10151 }
10152 if (skippy < 0) || (iNdEx+skippy) < 0 {
10153 return protohelpers.ErrInvalidLength
10154 }
10155 if (iNdEx + skippy) > postIndex {
10156 return io.ErrUnexpectedEOF
10157 }
10158 iNdEx += skippy
10159 }
10160 }
10161 m.Attrs[mapkey] = mapvalue
10162 iNdEx = postIndex
10163 default:
10164 iNdEx = preIndex
10165 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10166 if err != nil {
10167 return err
10168 }
10169 if (skippy < 0) || (iNdEx+skippy) < 0 {
10170 return protohelpers.ErrInvalidLength
10171 }
10172 if (iNdEx + skippy) > l {
10173 return io.ErrUnexpectedEOF
10174 }
10175 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10176 iNdEx += skippy
10177 }
10178 }
10179
10180 if iNdEx > l {
10181 return io.ErrUnexpectedEOF
10182 }
10183 return nil
10184 }
10185 func (m *SolveResponse) UnmarshalVT(dAtA []byte) error {
10186 l := len(dAtA)
10187 iNdEx := 0
10188 for iNdEx < l {
10189 preIndex := iNdEx
10190 var wire uint64
10191 for shift := uint(0); ; shift += 7 {
10192 if shift >= 64 {
10193 return protohelpers.ErrIntOverflow
10194 }
10195 if iNdEx >= l {
10196 return io.ErrUnexpectedEOF
10197 }
10198 b := dAtA[iNdEx]
10199 iNdEx++
10200 wire |= uint64(b&0x7F) << shift
10201 if b < 0x80 {
10202 break
10203 }
10204 }
10205 fieldNum := int32(wire >> 3)
10206 wireType := int(wire & 0x7)
10207 if wireType == 4 {
10208 return fmt.Errorf("proto: SolveResponse: wiretype end group for non-group")
10209 }
10210 if fieldNum <= 0 {
10211 return fmt.Errorf("proto: SolveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
10212 }
10213 switch fieldNum {
10214 case 1:
10215 if wireType != 2 {
10216 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
10217 }
10218 var stringLen uint64
10219 for shift := uint(0); ; shift += 7 {
10220 if shift >= 64 {
10221 return protohelpers.ErrIntOverflow
10222 }
10223 if iNdEx >= l {
10224 return io.ErrUnexpectedEOF
10225 }
10226 b := dAtA[iNdEx]
10227 iNdEx++
10228 stringLen |= uint64(b&0x7F) << shift
10229 if b < 0x80 {
10230 break
10231 }
10232 }
10233 intStringLen := int(stringLen)
10234 if intStringLen < 0 {
10235 return protohelpers.ErrInvalidLength
10236 }
10237 postIndex := iNdEx + intStringLen
10238 if postIndex < 0 {
10239 return protohelpers.ErrInvalidLength
10240 }
10241 if postIndex > l {
10242 return io.ErrUnexpectedEOF
10243 }
10244 m.Ref = string(dAtA[iNdEx:postIndex])
10245 iNdEx = postIndex
10246 case 3:
10247 if wireType != 2 {
10248 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
10249 }
10250 var msglen int
10251 for shift := uint(0); ; shift += 7 {
10252 if shift >= 64 {
10253 return protohelpers.ErrIntOverflow
10254 }
10255 if iNdEx >= l {
10256 return io.ErrUnexpectedEOF
10257 }
10258 b := dAtA[iNdEx]
10259 iNdEx++
10260 msglen |= int(b&0x7F) << shift
10261 if b < 0x80 {
10262 break
10263 }
10264 }
10265 if msglen < 0 {
10266 return protohelpers.ErrInvalidLength
10267 }
10268 postIndex := iNdEx + msglen
10269 if postIndex < 0 {
10270 return protohelpers.ErrInvalidLength
10271 }
10272 if postIndex > l {
10273 return io.ErrUnexpectedEOF
10274 }
10275 if m.Result == nil {
10276 m.Result = &Result{}
10277 }
10278 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
10279 return err
10280 }
10281 iNdEx = postIndex
10282 default:
10283 iNdEx = preIndex
10284 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10285 if err != nil {
10286 return err
10287 }
10288 if (skippy < 0) || (iNdEx+skippy) < 0 {
10289 return protohelpers.ErrInvalidLength
10290 }
10291 if (iNdEx + skippy) > l {
10292 return io.ErrUnexpectedEOF
10293 }
10294 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10295 iNdEx += skippy
10296 }
10297 }
10298
10299 if iNdEx > l {
10300 return io.ErrUnexpectedEOF
10301 }
10302 return nil
10303 }
10304 func (m *ReadFileRequest) UnmarshalVT(dAtA []byte) error {
10305 l := len(dAtA)
10306 iNdEx := 0
10307 for iNdEx < l {
10308 preIndex := iNdEx
10309 var wire uint64
10310 for shift := uint(0); ; shift += 7 {
10311 if shift >= 64 {
10312 return protohelpers.ErrIntOverflow
10313 }
10314 if iNdEx >= l {
10315 return io.ErrUnexpectedEOF
10316 }
10317 b := dAtA[iNdEx]
10318 iNdEx++
10319 wire |= uint64(b&0x7F) << shift
10320 if b < 0x80 {
10321 break
10322 }
10323 }
10324 fieldNum := int32(wire >> 3)
10325 wireType := int(wire & 0x7)
10326 if wireType == 4 {
10327 return fmt.Errorf("proto: ReadFileRequest: wiretype end group for non-group")
10328 }
10329 if fieldNum <= 0 {
10330 return fmt.Errorf("proto: ReadFileRequest: illegal tag %d (wire type %d)", fieldNum, wire)
10331 }
10332 switch fieldNum {
10333 case 1:
10334 if wireType != 2 {
10335 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
10336 }
10337 var stringLen uint64
10338 for shift := uint(0); ; shift += 7 {
10339 if shift >= 64 {
10340 return protohelpers.ErrIntOverflow
10341 }
10342 if iNdEx >= l {
10343 return io.ErrUnexpectedEOF
10344 }
10345 b := dAtA[iNdEx]
10346 iNdEx++
10347 stringLen |= uint64(b&0x7F) << shift
10348 if b < 0x80 {
10349 break
10350 }
10351 }
10352 intStringLen := int(stringLen)
10353 if intStringLen < 0 {
10354 return protohelpers.ErrInvalidLength
10355 }
10356 postIndex := iNdEx + intStringLen
10357 if postIndex < 0 {
10358 return protohelpers.ErrInvalidLength
10359 }
10360 if postIndex > l {
10361 return io.ErrUnexpectedEOF
10362 }
10363 m.Ref = string(dAtA[iNdEx:postIndex])
10364 iNdEx = postIndex
10365 case 2:
10366 if wireType != 2 {
10367 return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
10368 }
10369 var stringLen uint64
10370 for shift := uint(0); ; shift += 7 {
10371 if shift >= 64 {
10372 return protohelpers.ErrIntOverflow
10373 }
10374 if iNdEx >= l {
10375 return io.ErrUnexpectedEOF
10376 }
10377 b := dAtA[iNdEx]
10378 iNdEx++
10379 stringLen |= uint64(b&0x7F) << shift
10380 if b < 0x80 {
10381 break
10382 }
10383 }
10384 intStringLen := int(stringLen)
10385 if intStringLen < 0 {
10386 return protohelpers.ErrInvalidLength
10387 }
10388 postIndex := iNdEx + intStringLen
10389 if postIndex < 0 {
10390 return protohelpers.ErrInvalidLength
10391 }
10392 if postIndex > l {
10393 return io.ErrUnexpectedEOF
10394 }
10395 m.FilePath = string(dAtA[iNdEx:postIndex])
10396 iNdEx = postIndex
10397 case 3:
10398 if wireType != 2 {
10399 return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
10400 }
10401 var msglen int
10402 for shift := uint(0); ; shift += 7 {
10403 if shift >= 64 {
10404 return protohelpers.ErrIntOverflow
10405 }
10406 if iNdEx >= l {
10407 return io.ErrUnexpectedEOF
10408 }
10409 b := dAtA[iNdEx]
10410 iNdEx++
10411 msglen |= int(b&0x7F) << shift
10412 if b < 0x80 {
10413 break
10414 }
10415 }
10416 if msglen < 0 {
10417 return protohelpers.ErrInvalidLength
10418 }
10419 postIndex := iNdEx + msglen
10420 if postIndex < 0 {
10421 return protohelpers.ErrInvalidLength
10422 }
10423 if postIndex > l {
10424 return io.ErrUnexpectedEOF
10425 }
10426 if m.Range == nil {
10427 m.Range = &FileRange{}
10428 }
10429 if err := m.Range.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
10430 return err
10431 }
10432 iNdEx = postIndex
10433 default:
10434 iNdEx = preIndex
10435 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10436 if err != nil {
10437 return err
10438 }
10439 if (skippy < 0) || (iNdEx+skippy) < 0 {
10440 return protohelpers.ErrInvalidLength
10441 }
10442 if (iNdEx + skippy) > l {
10443 return io.ErrUnexpectedEOF
10444 }
10445 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10446 iNdEx += skippy
10447 }
10448 }
10449
10450 if iNdEx > l {
10451 return io.ErrUnexpectedEOF
10452 }
10453 return nil
10454 }
10455 func (m *FileRange) UnmarshalVT(dAtA []byte) error {
10456 l := len(dAtA)
10457 iNdEx := 0
10458 for iNdEx < l {
10459 preIndex := iNdEx
10460 var wire uint64
10461 for shift := uint(0); ; shift += 7 {
10462 if shift >= 64 {
10463 return protohelpers.ErrIntOverflow
10464 }
10465 if iNdEx >= l {
10466 return io.ErrUnexpectedEOF
10467 }
10468 b := dAtA[iNdEx]
10469 iNdEx++
10470 wire |= uint64(b&0x7F) << shift
10471 if b < 0x80 {
10472 break
10473 }
10474 }
10475 fieldNum := int32(wire >> 3)
10476 wireType := int(wire & 0x7)
10477 if wireType == 4 {
10478 return fmt.Errorf("proto: FileRange: wiretype end group for non-group")
10479 }
10480 if fieldNum <= 0 {
10481 return fmt.Errorf("proto: FileRange: illegal tag %d (wire type %d)", fieldNum, wire)
10482 }
10483 switch fieldNum {
10484 case 1:
10485 if wireType != 0 {
10486 return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
10487 }
10488 m.Offset = 0
10489 for shift := uint(0); ; shift += 7 {
10490 if shift >= 64 {
10491 return protohelpers.ErrIntOverflow
10492 }
10493 if iNdEx >= l {
10494 return io.ErrUnexpectedEOF
10495 }
10496 b := dAtA[iNdEx]
10497 iNdEx++
10498 m.Offset |= int64(b&0x7F) << shift
10499 if b < 0x80 {
10500 break
10501 }
10502 }
10503 case 2:
10504 if wireType != 0 {
10505 return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
10506 }
10507 m.Length = 0
10508 for shift := uint(0); ; shift += 7 {
10509 if shift >= 64 {
10510 return protohelpers.ErrIntOverflow
10511 }
10512 if iNdEx >= l {
10513 return io.ErrUnexpectedEOF
10514 }
10515 b := dAtA[iNdEx]
10516 iNdEx++
10517 m.Length |= int64(b&0x7F) << shift
10518 if b < 0x80 {
10519 break
10520 }
10521 }
10522 default:
10523 iNdEx = preIndex
10524 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10525 if err != nil {
10526 return err
10527 }
10528 if (skippy < 0) || (iNdEx+skippy) < 0 {
10529 return protohelpers.ErrInvalidLength
10530 }
10531 if (iNdEx + skippy) > l {
10532 return io.ErrUnexpectedEOF
10533 }
10534 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10535 iNdEx += skippy
10536 }
10537 }
10538
10539 if iNdEx > l {
10540 return io.ErrUnexpectedEOF
10541 }
10542 return nil
10543 }
10544 func (m *ReadFileResponse) UnmarshalVT(dAtA []byte) error {
10545 l := len(dAtA)
10546 iNdEx := 0
10547 for iNdEx < l {
10548 preIndex := iNdEx
10549 var wire uint64
10550 for shift := uint(0); ; shift += 7 {
10551 if shift >= 64 {
10552 return protohelpers.ErrIntOverflow
10553 }
10554 if iNdEx >= l {
10555 return io.ErrUnexpectedEOF
10556 }
10557 b := dAtA[iNdEx]
10558 iNdEx++
10559 wire |= uint64(b&0x7F) << shift
10560 if b < 0x80 {
10561 break
10562 }
10563 }
10564 fieldNum := int32(wire >> 3)
10565 wireType := int(wire & 0x7)
10566 if wireType == 4 {
10567 return fmt.Errorf("proto: ReadFileResponse: wiretype end group for non-group")
10568 }
10569 if fieldNum <= 0 {
10570 return fmt.Errorf("proto: ReadFileResponse: illegal tag %d (wire type %d)", fieldNum, wire)
10571 }
10572 switch fieldNum {
10573 case 1:
10574 if wireType != 2 {
10575 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
10576 }
10577 var byteLen int
10578 for shift := uint(0); ; shift += 7 {
10579 if shift >= 64 {
10580 return protohelpers.ErrIntOverflow
10581 }
10582 if iNdEx >= l {
10583 return io.ErrUnexpectedEOF
10584 }
10585 b := dAtA[iNdEx]
10586 iNdEx++
10587 byteLen |= int(b&0x7F) << shift
10588 if b < 0x80 {
10589 break
10590 }
10591 }
10592 if byteLen < 0 {
10593 return protohelpers.ErrInvalidLength
10594 }
10595 postIndex := iNdEx + byteLen
10596 if postIndex < 0 {
10597 return protohelpers.ErrInvalidLength
10598 }
10599 if postIndex > l {
10600 return io.ErrUnexpectedEOF
10601 }
10602 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
10603 if m.Data == nil {
10604 m.Data = []byte{}
10605 }
10606 iNdEx = postIndex
10607 default:
10608 iNdEx = preIndex
10609 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10610 if err != nil {
10611 return err
10612 }
10613 if (skippy < 0) || (iNdEx+skippy) < 0 {
10614 return protohelpers.ErrInvalidLength
10615 }
10616 if (iNdEx + skippy) > l {
10617 return io.ErrUnexpectedEOF
10618 }
10619 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10620 iNdEx += skippy
10621 }
10622 }
10623
10624 if iNdEx > l {
10625 return io.ErrUnexpectedEOF
10626 }
10627 return nil
10628 }
10629 func (m *ReadDirRequest) UnmarshalVT(dAtA []byte) error {
10630 l := len(dAtA)
10631 iNdEx := 0
10632 for iNdEx < l {
10633 preIndex := iNdEx
10634 var wire uint64
10635 for shift := uint(0); ; shift += 7 {
10636 if shift >= 64 {
10637 return protohelpers.ErrIntOverflow
10638 }
10639 if iNdEx >= l {
10640 return io.ErrUnexpectedEOF
10641 }
10642 b := dAtA[iNdEx]
10643 iNdEx++
10644 wire |= uint64(b&0x7F) << shift
10645 if b < 0x80 {
10646 break
10647 }
10648 }
10649 fieldNum := int32(wire >> 3)
10650 wireType := int(wire & 0x7)
10651 if wireType == 4 {
10652 return fmt.Errorf("proto: ReadDirRequest: wiretype end group for non-group")
10653 }
10654 if fieldNum <= 0 {
10655 return fmt.Errorf("proto: ReadDirRequest: illegal tag %d (wire type %d)", fieldNum, wire)
10656 }
10657 switch fieldNum {
10658 case 1:
10659 if wireType != 2 {
10660 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
10661 }
10662 var stringLen uint64
10663 for shift := uint(0); ; shift += 7 {
10664 if shift >= 64 {
10665 return protohelpers.ErrIntOverflow
10666 }
10667 if iNdEx >= l {
10668 return io.ErrUnexpectedEOF
10669 }
10670 b := dAtA[iNdEx]
10671 iNdEx++
10672 stringLen |= uint64(b&0x7F) << shift
10673 if b < 0x80 {
10674 break
10675 }
10676 }
10677 intStringLen := int(stringLen)
10678 if intStringLen < 0 {
10679 return protohelpers.ErrInvalidLength
10680 }
10681 postIndex := iNdEx + intStringLen
10682 if postIndex < 0 {
10683 return protohelpers.ErrInvalidLength
10684 }
10685 if postIndex > l {
10686 return io.ErrUnexpectedEOF
10687 }
10688 m.Ref = string(dAtA[iNdEx:postIndex])
10689 iNdEx = postIndex
10690 case 2:
10691 if wireType != 2 {
10692 return fmt.Errorf("proto: wrong wireType = %d for field DirPath", wireType)
10693 }
10694 var stringLen uint64
10695 for shift := uint(0); ; shift += 7 {
10696 if shift >= 64 {
10697 return protohelpers.ErrIntOverflow
10698 }
10699 if iNdEx >= l {
10700 return io.ErrUnexpectedEOF
10701 }
10702 b := dAtA[iNdEx]
10703 iNdEx++
10704 stringLen |= uint64(b&0x7F) << shift
10705 if b < 0x80 {
10706 break
10707 }
10708 }
10709 intStringLen := int(stringLen)
10710 if intStringLen < 0 {
10711 return protohelpers.ErrInvalidLength
10712 }
10713 postIndex := iNdEx + intStringLen
10714 if postIndex < 0 {
10715 return protohelpers.ErrInvalidLength
10716 }
10717 if postIndex > l {
10718 return io.ErrUnexpectedEOF
10719 }
10720 m.DirPath = string(dAtA[iNdEx:postIndex])
10721 iNdEx = postIndex
10722 case 3:
10723 if wireType != 2 {
10724 return fmt.Errorf("proto: wrong wireType = %d for field IncludePattern", wireType)
10725 }
10726 var stringLen uint64
10727 for shift := uint(0); ; shift += 7 {
10728 if shift >= 64 {
10729 return protohelpers.ErrIntOverflow
10730 }
10731 if iNdEx >= l {
10732 return io.ErrUnexpectedEOF
10733 }
10734 b := dAtA[iNdEx]
10735 iNdEx++
10736 stringLen |= uint64(b&0x7F) << shift
10737 if b < 0x80 {
10738 break
10739 }
10740 }
10741 intStringLen := int(stringLen)
10742 if intStringLen < 0 {
10743 return protohelpers.ErrInvalidLength
10744 }
10745 postIndex := iNdEx + intStringLen
10746 if postIndex < 0 {
10747 return protohelpers.ErrInvalidLength
10748 }
10749 if postIndex > l {
10750 return io.ErrUnexpectedEOF
10751 }
10752 m.IncludePattern = string(dAtA[iNdEx:postIndex])
10753 iNdEx = postIndex
10754 default:
10755 iNdEx = preIndex
10756 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10757 if err != nil {
10758 return err
10759 }
10760 if (skippy < 0) || (iNdEx+skippy) < 0 {
10761 return protohelpers.ErrInvalidLength
10762 }
10763 if (iNdEx + skippy) > l {
10764 return io.ErrUnexpectedEOF
10765 }
10766 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10767 iNdEx += skippy
10768 }
10769 }
10770
10771 if iNdEx > l {
10772 return io.ErrUnexpectedEOF
10773 }
10774 return nil
10775 }
10776 func (m *ReadDirResponse) UnmarshalVT(dAtA []byte) error {
10777 l := len(dAtA)
10778 iNdEx := 0
10779 for iNdEx < l {
10780 preIndex := iNdEx
10781 var wire uint64
10782 for shift := uint(0); ; shift += 7 {
10783 if shift >= 64 {
10784 return protohelpers.ErrIntOverflow
10785 }
10786 if iNdEx >= l {
10787 return io.ErrUnexpectedEOF
10788 }
10789 b := dAtA[iNdEx]
10790 iNdEx++
10791 wire |= uint64(b&0x7F) << shift
10792 if b < 0x80 {
10793 break
10794 }
10795 }
10796 fieldNum := int32(wire >> 3)
10797 wireType := int(wire & 0x7)
10798 if wireType == 4 {
10799 return fmt.Errorf("proto: ReadDirResponse: wiretype end group for non-group")
10800 }
10801 if fieldNum <= 0 {
10802 return fmt.Errorf("proto: ReadDirResponse: illegal tag %d (wire type %d)", fieldNum, wire)
10803 }
10804 switch fieldNum {
10805 case 1:
10806 if wireType != 2 {
10807 return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
10808 }
10809 var msglen int
10810 for shift := uint(0); ; shift += 7 {
10811 if shift >= 64 {
10812 return protohelpers.ErrIntOverflow
10813 }
10814 if iNdEx >= l {
10815 return io.ErrUnexpectedEOF
10816 }
10817 b := dAtA[iNdEx]
10818 iNdEx++
10819 msglen |= int(b&0x7F) << shift
10820 if b < 0x80 {
10821 break
10822 }
10823 }
10824 if msglen < 0 {
10825 return protohelpers.ErrInvalidLength
10826 }
10827 postIndex := iNdEx + msglen
10828 if postIndex < 0 {
10829 return protohelpers.ErrInvalidLength
10830 }
10831 if postIndex > l {
10832 return io.ErrUnexpectedEOF
10833 }
10834 m.Entries = append(m.Entries, &types.Stat{})
10835 if unmarshal, ok := interface{}(m.Entries[len(m.Entries)-1]).(interface {
10836 UnmarshalVT([]byte) error
10837 }); ok {
10838 if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
10839 return err
10840 }
10841 } else {
10842 if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Entries[len(m.Entries)-1]); err != nil {
10843 return err
10844 }
10845 }
10846 iNdEx = postIndex
10847 default:
10848 iNdEx = preIndex
10849 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10850 if err != nil {
10851 return err
10852 }
10853 if (skippy < 0) || (iNdEx+skippy) < 0 {
10854 return protohelpers.ErrInvalidLength
10855 }
10856 if (iNdEx + skippy) > l {
10857 return io.ErrUnexpectedEOF
10858 }
10859 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10860 iNdEx += skippy
10861 }
10862 }
10863
10864 if iNdEx > l {
10865 return io.ErrUnexpectedEOF
10866 }
10867 return nil
10868 }
10869 func (m *StatFileRequest) UnmarshalVT(dAtA []byte) error {
10870 l := len(dAtA)
10871 iNdEx := 0
10872 for iNdEx < l {
10873 preIndex := iNdEx
10874 var wire uint64
10875 for shift := uint(0); ; shift += 7 {
10876 if shift >= 64 {
10877 return protohelpers.ErrIntOverflow
10878 }
10879 if iNdEx >= l {
10880 return io.ErrUnexpectedEOF
10881 }
10882 b := dAtA[iNdEx]
10883 iNdEx++
10884 wire |= uint64(b&0x7F) << shift
10885 if b < 0x80 {
10886 break
10887 }
10888 }
10889 fieldNum := int32(wire >> 3)
10890 wireType := int(wire & 0x7)
10891 if wireType == 4 {
10892 return fmt.Errorf("proto: StatFileRequest: wiretype end group for non-group")
10893 }
10894 if fieldNum <= 0 {
10895 return fmt.Errorf("proto: StatFileRequest: illegal tag %d (wire type %d)", fieldNum, wire)
10896 }
10897 switch fieldNum {
10898 case 1:
10899 if wireType != 2 {
10900 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
10901 }
10902 var stringLen uint64
10903 for shift := uint(0); ; shift += 7 {
10904 if shift >= 64 {
10905 return protohelpers.ErrIntOverflow
10906 }
10907 if iNdEx >= l {
10908 return io.ErrUnexpectedEOF
10909 }
10910 b := dAtA[iNdEx]
10911 iNdEx++
10912 stringLen |= uint64(b&0x7F) << shift
10913 if b < 0x80 {
10914 break
10915 }
10916 }
10917 intStringLen := int(stringLen)
10918 if intStringLen < 0 {
10919 return protohelpers.ErrInvalidLength
10920 }
10921 postIndex := iNdEx + intStringLen
10922 if postIndex < 0 {
10923 return protohelpers.ErrInvalidLength
10924 }
10925 if postIndex > l {
10926 return io.ErrUnexpectedEOF
10927 }
10928 m.Ref = string(dAtA[iNdEx:postIndex])
10929 iNdEx = postIndex
10930 case 2:
10931 if wireType != 2 {
10932 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
10933 }
10934 var stringLen uint64
10935 for shift := uint(0); ; shift += 7 {
10936 if shift >= 64 {
10937 return protohelpers.ErrIntOverflow
10938 }
10939 if iNdEx >= l {
10940 return io.ErrUnexpectedEOF
10941 }
10942 b := dAtA[iNdEx]
10943 iNdEx++
10944 stringLen |= uint64(b&0x7F) << shift
10945 if b < 0x80 {
10946 break
10947 }
10948 }
10949 intStringLen := int(stringLen)
10950 if intStringLen < 0 {
10951 return protohelpers.ErrInvalidLength
10952 }
10953 postIndex := iNdEx + intStringLen
10954 if postIndex < 0 {
10955 return protohelpers.ErrInvalidLength
10956 }
10957 if postIndex > l {
10958 return io.ErrUnexpectedEOF
10959 }
10960 m.Path = string(dAtA[iNdEx:postIndex])
10961 iNdEx = postIndex
10962 default:
10963 iNdEx = preIndex
10964 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
10965 if err != nil {
10966 return err
10967 }
10968 if (skippy < 0) || (iNdEx+skippy) < 0 {
10969 return protohelpers.ErrInvalidLength
10970 }
10971 if (iNdEx + skippy) > l {
10972 return io.ErrUnexpectedEOF
10973 }
10974 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
10975 iNdEx += skippy
10976 }
10977 }
10978
10979 if iNdEx > l {
10980 return io.ErrUnexpectedEOF
10981 }
10982 return nil
10983 }
10984 func (m *StatFileResponse) UnmarshalVT(dAtA []byte) error {
10985 l := len(dAtA)
10986 iNdEx := 0
10987 for iNdEx < l {
10988 preIndex := iNdEx
10989 var wire uint64
10990 for shift := uint(0); ; shift += 7 {
10991 if shift >= 64 {
10992 return protohelpers.ErrIntOverflow
10993 }
10994 if iNdEx >= l {
10995 return io.ErrUnexpectedEOF
10996 }
10997 b := dAtA[iNdEx]
10998 iNdEx++
10999 wire |= uint64(b&0x7F) << shift
11000 if b < 0x80 {
11001 break
11002 }
11003 }
11004 fieldNum := int32(wire >> 3)
11005 wireType := int(wire & 0x7)
11006 if wireType == 4 {
11007 return fmt.Errorf("proto: StatFileResponse: wiretype end group for non-group")
11008 }
11009 if fieldNum <= 0 {
11010 return fmt.Errorf("proto: StatFileResponse: illegal tag %d (wire type %d)", fieldNum, wire)
11011 }
11012 switch fieldNum {
11013 case 1:
11014 if wireType != 2 {
11015 return fmt.Errorf("proto: wrong wireType = %d for field Stat", wireType)
11016 }
11017 var msglen int
11018 for shift := uint(0); ; shift += 7 {
11019 if shift >= 64 {
11020 return protohelpers.ErrIntOverflow
11021 }
11022 if iNdEx >= l {
11023 return io.ErrUnexpectedEOF
11024 }
11025 b := dAtA[iNdEx]
11026 iNdEx++
11027 msglen |= int(b&0x7F) << shift
11028 if b < 0x80 {
11029 break
11030 }
11031 }
11032 if msglen < 0 {
11033 return protohelpers.ErrInvalidLength
11034 }
11035 postIndex := iNdEx + msglen
11036 if postIndex < 0 {
11037 return protohelpers.ErrInvalidLength
11038 }
11039 if postIndex > l {
11040 return io.ErrUnexpectedEOF
11041 }
11042 if m.Stat == nil {
11043 m.Stat = &types.Stat{}
11044 }
11045 if unmarshal, ok := interface{}(m.Stat).(interface {
11046 UnmarshalVT([]byte) error
11047 }); ok {
11048 if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11049 return err
11050 }
11051 } else {
11052 if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Stat); err != nil {
11053 return err
11054 }
11055 }
11056 iNdEx = postIndex
11057 default:
11058 iNdEx = preIndex
11059 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11060 if err != nil {
11061 return err
11062 }
11063 if (skippy < 0) || (iNdEx+skippy) < 0 {
11064 return protohelpers.ErrInvalidLength
11065 }
11066 if (iNdEx + skippy) > l {
11067 return io.ErrUnexpectedEOF
11068 }
11069 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11070 iNdEx += skippy
11071 }
11072 }
11073
11074 if iNdEx > l {
11075 return io.ErrUnexpectedEOF
11076 }
11077 return nil
11078 }
11079 func (m *EvaluateRequest) UnmarshalVT(dAtA []byte) error {
11080 l := len(dAtA)
11081 iNdEx := 0
11082 for iNdEx < l {
11083 preIndex := iNdEx
11084 var wire uint64
11085 for shift := uint(0); ; shift += 7 {
11086 if shift >= 64 {
11087 return protohelpers.ErrIntOverflow
11088 }
11089 if iNdEx >= l {
11090 return io.ErrUnexpectedEOF
11091 }
11092 b := dAtA[iNdEx]
11093 iNdEx++
11094 wire |= uint64(b&0x7F) << shift
11095 if b < 0x80 {
11096 break
11097 }
11098 }
11099 fieldNum := int32(wire >> 3)
11100 wireType := int(wire & 0x7)
11101 if wireType == 4 {
11102 return fmt.Errorf("proto: EvaluateRequest: wiretype end group for non-group")
11103 }
11104 if fieldNum <= 0 {
11105 return fmt.Errorf("proto: EvaluateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
11106 }
11107 switch fieldNum {
11108 case 1:
11109 if wireType != 2 {
11110 return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
11111 }
11112 var stringLen uint64
11113 for shift := uint(0); ; shift += 7 {
11114 if shift >= 64 {
11115 return protohelpers.ErrIntOverflow
11116 }
11117 if iNdEx >= l {
11118 return io.ErrUnexpectedEOF
11119 }
11120 b := dAtA[iNdEx]
11121 iNdEx++
11122 stringLen |= uint64(b&0x7F) << shift
11123 if b < 0x80 {
11124 break
11125 }
11126 }
11127 intStringLen := int(stringLen)
11128 if intStringLen < 0 {
11129 return protohelpers.ErrInvalidLength
11130 }
11131 postIndex := iNdEx + intStringLen
11132 if postIndex < 0 {
11133 return protohelpers.ErrInvalidLength
11134 }
11135 if postIndex > l {
11136 return io.ErrUnexpectedEOF
11137 }
11138 m.Ref = string(dAtA[iNdEx:postIndex])
11139 iNdEx = postIndex
11140 default:
11141 iNdEx = preIndex
11142 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11143 if err != nil {
11144 return err
11145 }
11146 if (skippy < 0) || (iNdEx+skippy) < 0 {
11147 return protohelpers.ErrInvalidLength
11148 }
11149 if (iNdEx + skippy) > l {
11150 return io.ErrUnexpectedEOF
11151 }
11152 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11153 iNdEx += skippy
11154 }
11155 }
11156
11157 if iNdEx > l {
11158 return io.ErrUnexpectedEOF
11159 }
11160 return nil
11161 }
11162 func (m *EvaluateResponse) UnmarshalVT(dAtA []byte) error {
11163 l := len(dAtA)
11164 iNdEx := 0
11165 for iNdEx < l {
11166 preIndex := iNdEx
11167 var wire uint64
11168 for shift := uint(0); ; shift += 7 {
11169 if shift >= 64 {
11170 return protohelpers.ErrIntOverflow
11171 }
11172 if iNdEx >= l {
11173 return io.ErrUnexpectedEOF
11174 }
11175 b := dAtA[iNdEx]
11176 iNdEx++
11177 wire |= uint64(b&0x7F) << shift
11178 if b < 0x80 {
11179 break
11180 }
11181 }
11182 fieldNum := int32(wire >> 3)
11183 wireType := int(wire & 0x7)
11184 if wireType == 4 {
11185 return fmt.Errorf("proto: EvaluateResponse: wiretype end group for non-group")
11186 }
11187 if fieldNum <= 0 {
11188 return fmt.Errorf("proto: EvaluateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
11189 }
11190 switch fieldNum {
11191 default:
11192 iNdEx = preIndex
11193 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11194 if err != nil {
11195 return err
11196 }
11197 if (skippy < 0) || (iNdEx+skippy) < 0 {
11198 return protohelpers.ErrInvalidLength
11199 }
11200 if (iNdEx + skippy) > l {
11201 return io.ErrUnexpectedEOF
11202 }
11203 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11204 iNdEx += skippy
11205 }
11206 }
11207
11208 if iNdEx > l {
11209 return io.ErrUnexpectedEOF
11210 }
11211 return nil
11212 }
11213 func (m *PingRequest) UnmarshalVT(dAtA []byte) error {
11214 l := len(dAtA)
11215 iNdEx := 0
11216 for iNdEx < l {
11217 preIndex := iNdEx
11218 var wire uint64
11219 for shift := uint(0); ; shift += 7 {
11220 if shift >= 64 {
11221 return protohelpers.ErrIntOverflow
11222 }
11223 if iNdEx >= l {
11224 return io.ErrUnexpectedEOF
11225 }
11226 b := dAtA[iNdEx]
11227 iNdEx++
11228 wire |= uint64(b&0x7F) << shift
11229 if b < 0x80 {
11230 break
11231 }
11232 }
11233 fieldNum := int32(wire >> 3)
11234 wireType := int(wire & 0x7)
11235 if wireType == 4 {
11236 return fmt.Errorf("proto: PingRequest: wiretype end group for non-group")
11237 }
11238 if fieldNum <= 0 {
11239 return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
11240 }
11241 switch fieldNum {
11242 default:
11243 iNdEx = preIndex
11244 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11245 if err != nil {
11246 return err
11247 }
11248 if (skippy < 0) || (iNdEx+skippy) < 0 {
11249 return protohelpers.ErrInvalidLength
11250 }
11251 if (iNdEx + skippy) > l {
11252 return io.ErrUnexpectedEOF
11253 }
11254 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11255 iNdEx += skippy
11256 }
11257 }
11258
11259 if iNdEx > l {
11260 return io.ErrUnexpectedEOF
11261 }
11262 return nil
11263 }
11264 func (m *PongResponse) UnmarshalVT(dAtA []byte) error {
11265 l := len(dAtA)
11266 iNdEx := 0
11267 for iNdEx < l {
11268 preIndex := iNdEx
11269 var wire uint64
11270 for shift := uint(0); ; shift += 7 {
11271 if shift >= 64 {
11272 return protohelpers.ErrIntOverflow
11273 }
11274 if iNdEx >= l {
11275 return io.ErrUnexpectedEOF
11276 }
11277 b := dAtA[iNdEx]
11278 iNdEx++
11279 wire |= uint64(b&0x7F) << shift
11280 if b < 0x80 {
11281 break
11282 }
11283 }
11284 fieldNum := int32(wire >> 3)
11285 wireType := int(wire & 0x7)
11286 if wireType == 4 {
11287 return fmt.Errorf("proto: PongResponse: wiretype end group for non-group")
11288 }
11289 if fieldNum <= 0 {
11290 return fmt.Errorf("proto: PongResponse: illegal tag %d (wire type %d)", fieldNum, wire)
11291 }
11292 switch fieldNum {
11293 case 1:
11294 if wireType != 2 {
11295 return fmt.Errorf("proto: wrong wireType = %d for field FrontendAPICaps", wireType)
11296 }
11297 var msglen int
11298 for shift := uint(0); ; shift += 7 {
11299 if shift >= 64 {
11300 return protohelpers.ErrIntOverflow
11301 }
11302 if iNdEx >= l {
11303 return io.ErrUnexpectedEOF
11304 }
11305 b := dAtA[iNdEx]
11306 iNdEx++
11307 msglen |= int(b&0x7F) << shift
11308 if b < 0x80 {
11309 break
11310 }
11311 }
11312 if msglen < 0 {
11313 return protohelpers.ErrInvalidLength
11314 }
11315 postIndex := iNdEx + msglen
11316 if postIndex < 0 {
11317 return protohelpers.ErrInvalidLength
11318 }
11319 if postIndex > l {
11320 return io.ErrUnexpectedEOF
11321 }
11322 m.FrontendAPICaps = append(m.FrontendAPICaps, &pb2.APICap{})
11323 if err := m.FrontendAPICaps[len(m.FrontendAPICaps)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11324 return err
11325 }
11326 iNdEx = postIndex
11327 case 2:
11328 if wireType != 2 {
11329 return fmt.Errorf("proto: wrong wireType = %d for field LLBCaps", wireType)
11330 }
11331 var msglen int
11332 for shift := uint(0); ; shift += 7 {
11333 if shift >= 64 {
11334 return protohelpers.ErrIntOverflow
11335 }
11336 if iNdEx >= l {
11337 return io.ErrUnexpectedEOF
11338 }
11339 b := dAtA[iNdEx]
11340 iNdEx++
11341 msglen |= int(b&0x7F) << shift
11342 if b < 0x80 {
11343 break
11344 }
11345 }
11346 if msglen < 0 {
11347 return protohelpers.ErrInvalidLength
11348 }
11349 postIndex := iNdEx + msglen
11350 if postIndex < 0 {
11351 return protohelpers.ErrInvalidLength
11352 }
11353 if postIndex > l {
11354 return io.ErrUnexpectedEOF
11355 }
11356 m.LLBCaps = append(m.LLBCaps, &pb2.APICap{})
11357 if err := m.LLBCaps[len(m.LLBCaps)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11358 return err
11359 }
11360 iNdEx = postIndex
11361 case 3:
11362 if wireType != 2 {
11363 return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType)
11364 }
11365 var msglen int
11366 for shift := uint(0); ; shift += 7 {
11367 if shift >= 64 {
11368 return protohelpers.ErrIntOverflow
11369 }
11370 if iNdEx >= l {
11371 return io.ErrUnexpectedEOF
11372 }
11373 b := dAtA[iNdEx]
11374 iNdEx++
11375 msglen |= int(b&0x7F) << shift
11376 if b < 0x80 {
11377 break
11378 }
11379 }
11380 if msglen < 0 {
11381 return protohelpers.ErrInvalidLength
11382 }
11383 postIndex := iNdEx + msglen
11384 if postIndex < 0 {
11385 return protohelpers.ErrInvalidLength
11386 }
11387 if postIndex > l {
11388 return io.ErrUnexpectedEOF
11389 }
11390 m.Workers = append(m.Workers, &types1.WorkerRecord{})
11391 if err := m.Workers[len(m.Workers)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11392 return err
11393 }
11394 iNdEx = postIndex
11395 default:
11396 iNdEx = preIndex
11397 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11398 if err != nil {
11399 return err
11400 }
11401 if (skippy < 0) || (iNdEx+skippy) < 0 {
11402 return protohelpers.ErrInvalidLength
11403 }
11404 if (iNdEx + skippy) > l {
11405 return io.ErrUnexpectedEOF
11406 }
11407 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11408 iNdEx += skippy
11409 }
11410 }
11411
11412 if iNdEx > l {
11413 return io.ErrUnexpectedEOF
11414 }
11415 return nil
11416 }
11417 func (m *WarnRequest) UnmarshalVT(dAtA []byte) error {
11418 l := len(dAtA)
11419 iNdEx := 0
11420 for iNdEx < l {
11421 preIndex := iNdEx
11422 var wire uint64
11423 for shift := uint(0); ; shift += 7 {
11424 if shift >= 64 {
11425 return protohelpers.ErrIntOverflow
11426 }
11427 if iNdEx >= l {
11428 return io.ErrUnexpectedEOF
11429 }
11430 b := dAtA[iNdEx]
11431 iNdEx++
11432 wire |= uint64(b&0x7F) << shift
11433 if b < 0x80 {
11434 break
11435 }
11436 }
11437 fieldNum := int32(wire >> 3)
11438 wireType := int(wire & 0x7)
11439 if wireType == 4 {
11440 return fmt.Errorf("proto: WarnRequest: wiretype end group for non-group")
11441 }
11442 if fieldNum <= 0 {
11443 return fmt.Errorf("proto: WarnRequest: illegal tag %d (wire type %d)", fieldNum, wire)
11444 }
11445 switch fieldNum {
11446 case 1:
11447 if wireType != 2 {
11448 return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType)
11449 }
11450 var stringLen uint64
11451 for shift := uint(0); ; shift += 7 {
11452 if shift >= 64 {
11453 return protohelpers.ErrIntOverflow
11454 }
11455 if iNdEx >= l {
11456 return io.ErrUnexpectedEOF
11457 }
11458 b := dAtA[iNdEx]
11459 iNdEx++
11460 stringLen |= uint64(b&0x7F) << shift
11461 if b < 0x80 {
11462 break
11463 }
11464 }
11465 intStringLen := int(stringLen)
11466 if intStringLen < 0 {
11467 return protohelpers.ErrInvalidLength
11468 }
11469 postIndex := iNdEx + intStringLen
11470 if postIndex < 0 {
11471 return protohelpers.ErrInvalidLength
11472 }
11473 if postIndex > l {
11474 return io.ErrUnexpectedEOF
11475 }
11476 m.Digest = string(dAtA[iNdEx:postIndex])
11477 iNdEx = postIndex
11478 case 2:
11479 if wireType != 0 {
11480 return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
11481 }
11482 m.Level = 0
11483 for shift := uint(0); ; shift += 7 {
11484 if shift >= 64 {
11485 return protohelpers.ErrIntOverflow
11486 }
11487 if iNdEx >= l {
11488 return io.ErrUnexpectedEOF
11489 }
11490 b := dAtA[iNdEx]
11491 iNdEx++
11492 m.Level |= int64(b&0x7F) << shift
11493 if b < 0x80 {
11494 break
11495 }
11496 }
11497 case 3:
11498 if wireType != 2 {
11499 return fmt.Errorf("proto: wrong wireType = %d for field Short", wireType)
11500 }
11501 var byteLen int
11502 for shift := uint(0); ; shift += 7 {
11503 if shift >= 64 {
11504 return protohelpers.ErrIntOverflow
11505 }
11506 if iNdEx >= l {
11507 return io.ErrUnexpectedEOF
11508 }
11509 b := dAtA[iNdEx]
11510 iNdEx++
11511 byteLen |= int(b&0x7F) << shift
11512 if b < 0x80 {
11513 break
11514 }
11515 }
11516 if byteLen < 0 {
11517 return protohelpers.ErrInvalidLength
11518 }
11519 postIndex := iNdEx + byteLen
11520 if postIndex < 0 {
11521 return protohelpers.ErrInvalidLength
11522 }
11523 if postIndex > l {
11524 return io.ErrUnexpectedEOF
11525 }
11526 m.Short = append(m.Short[:0], dAtA[iNdEx:postIndex]...)
11527 if m.Short == nil {
11528 m.Short = []byte{}
11529 }
11530 iNdEx = postIndex
11531 case 4:
11532 if wireType != 2 {
11533 return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType)
11534 }
11535 var byteLen int
11536 for shift := uint(0); ; shift += 7 {
11537 if shift >= 64 {
11538 return protohelpers.ErrIntOverflow
11539 }
11540 if iNdEx >= l {
11541 return io.ErrUnexpectedEOF
11542 }
11543 b := dAtA[iNdEx]
11544 iNdEx++
11545 byteLen |= int(b&0x7F) << shift
11546 if b < 0x80 {
11547 break
11548 }
11549 }
11550 if byteLen < 0 {
11551 return protohelpers.ErrInvalidLength
11552 }
11553 postIndex := iNdEx + byteLen
11554 if postIndex < 0 {
11555 return protohelpers.ErrInvalidLength
11556 }
11557 if postIndex > l {
11558 return io.ErrUnexpectedEOF
11559 }
11560 m.Detail = append(m.Detail, make([]byte, postIndex-iNdEx))
11561 copy(m.Detail[len(m.Detail)-1], dAtA[iNdEx:postIndex])
11562 iNdEx = postIndex
11563 case 5:
11564 if wireType != 2 {
11565 return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
11566 }
11567 var stringLen uint64
11568 for shift := uint(0); ; shift += 7 {
11569 if shift >= 64 {
11570 return protohelpers.ErrIntOverflow
11571 }
11572 if iNdEx >= l {
11573 return io.ErrUnexpectedEOF
11574 }
11575 b := dAtA[iNdEx]
11576 iNdEx++
11577 stringLen |= uint64(b&0x7F) << shift
11578 if b < 0x80 {
11579 break
11580 }
11581 }
11582 intStringLen := int(stringLen)
11583 if intStringLen < 0 {
11584 return protohelpers.ErrInvalidLength
11585 }
11586 postIndex := iNdEx + intStringLen
11587 if postIndex < 0 {
11588 return protohelpers.ErrInvalidLength
11589 }
11590 if postIndex > l {
11591 return io.ErrUnexpectedEOF
11592 }
11593 m.Url = string(dAtA[iNdEx:postIndex])
11594 iNdEx = postIndex
11595 case 6:
11596 if wireType != 2 {
11597 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
11598 }
11599 var msglen int
11600 for shift := uint(0); ; shift += 7 {
11601 if shift >= 64 {
11602 return protohelpers.ErrIntOverflow
11603 }
11604 if iNdEx >= l {
11605 return io.ErrUnexpectedEOF
11606 }
11607 b := dAtA[iNdEx]
11608 iNdEx++
11609 msglen |= int(b&0x7F) << shift
11610 if b < 0x80 {
11611 break
11612 }
11613 }
11614 if msglen < 0 {
11615 return protohelpers.ErrInvalidLength
11616 }
11617 postIndex := iNdEx + msglen
11618 if postIndex < 0 {
11619 return protohelpers.ErrInvalidLength
11620 }
11621 if postIndex > l {
11622 return io.ErrUnexpectedEOF
11623 }
11624 if m.Info == nil {
11625 m.Info = &pb.SourceInfo{}
11626 }
11627 if err := m.Info.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11628 return err
11629 }
11630 iNdEx = postIndex
11631 case 7:
11632 if wireType != 2 {
11633 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11634 }
11635 var msglen int
11636 for shift := uint(0); ; shift += 7 {
11637 if shift >= 64 {
11638 return protohelpers.ErrIntOverflow
11639 }
11640 if iNdEx >= l {
11641 return io.ErrUnexpectedEOF
11642 }
11643 b := dAtA[iNdEx]
11644 iNdEx++
11645 msglen |= int(b&0x7F) << shift
11646 if b < 0x80 {
11647 break
11648 }
11649 }
11650 if msglen < 0 {
11651 return protohelpers.ErrInvalidLength
11652 }
11653 postIndex := iNdEx + msglen
11654 if postIndex < 0 {
11655 return protohelpers.ErrInvalidLength
11656 }
11657 if postIndex > l {
11658 return io.ErrUnexpectedEOF
11659 }
11660 m.Ranges = append(m.Ranges, &pb.Range{})
11661 if err := m.Ranges[len(m.Ranges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11662 return err
11663 }
11664 iNdEx = postIndex
11665 default:
11666 iNdEx = preIndex
11667 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11668 if err != nil {
11669 return err
11670 }
11671 if (skippy < 0) || (iNdEx+skippy) < 0 {
11672 return protohelpers.ErrInvalidLength
11673 }
11674 if (iNdEx + skippy) > l {
11675 return io.ErrUnexpectedEOF
11676 }
11677 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11678 iNdEx += skippy
11679 }
11680 }
11681
11682 if iNdEx > l {
11683 return io.ErrUnexpectedEOF
11684 }
11685 return nil
11686 }
11687 func (m *WarnResponse) UnmarshalVT(dAtA []byte) error {
11688 l := len(dAtA)
11689 iNdEx := 0
11690 for iNdEx < l {
11691 preIndex := iNdEx
11692 var wire uint64
11693 for shift := uint(0); ; shift += 7 {
11694 if shift >= 64 {
11695 return protohelpers.ErrIntOverflow
11696 }
11697 if iNdEx >= l {
11698 return io.ErrUnexpectedEOF
11699 }
11700 b := dAtA[iNdEx]
11701 iNdEx++
11702 wire |= uint64(b&0x7F) << shift
11703 if b < 0x80 {
11704 break
11705 }
11706 }
11707 fieldNum := int32(wire >> 3)
11708 wireType := int(wire & 0x7)
11709 if wireType == 4 {
11710 return fmt.Errorf("proto: WarnResponse: wiretype end group for non-group")
11711 }
11712 if fieldNum <= 0 {
11713 return fmt.Errorf("proto: WarnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
11714 }
11715 switch fieldNum {
11716 default:
11717 iNdEx = preIndex
11718 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11719 if err != nil {
11720 return err
11721 }
11722 if (skippy < 0) || (iNdEx+skippy) < 0 {
11723 return protohelpers.ErrInvalidLength
11724 }
11725 if (iNdEx + skippy) > l {
11726 return io.ErrUnexpectedEOF
11727 }
11728 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
11729 iNdEx += skippy
11730 }
11731 }
11732
11733 if iNdEx > l {
11734 return io.ErrUnexpectedEOF
11735 }
11736 return nil
11737 }
11738 func (m *NewContainerRequest) UnmarshalVT(dAtA []byte) error {
11739 l := len(dAtA)
11740 iNdEx := 0
11741 for iNdEx < l {
11742 preIndex := iNdEx
11743 var wire uint64
11744 for shift := uint(0); ; shift += 7 {
11745 if shift >= 64 {
11746 return protohelpers.ErrIntOverflow
11747 }
11748 if iNdEx >= l {
11749 return io.ErrUnexpectedEOF
11750 }
11751 b := dAtA[iNdEx]
11752 iNdEx++
11753 wire |= uint64(b&0x7F) << shift
11754 if b < 0x80 {
11755 break
11756 }
11757 }
11758 fieldNum := int32(wire >> 3)
11759 wireType := int(wire & 0x7)
11760 if wireType == 4 {
11761 return fmt.Errorf("proto: NewContainerRequest: wiretype end group for non-group")
11762 }
11763 if fieldNum <= 0 {
11764 return fmt.Errorf("proto: NewContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
11765 }
11766 switch fieldNum {
11767 case 1:
11768 if wireType != 2 {
11769 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
11770 }
11771 var stringLen uint64
11772 for shift := uint(0); ; shift += 7 {
11773 if shift >= 64 {
11774 return protohelpers.ErrIntOverflow
11775 }
11776 if iNdEx >= l {
11777 return io.ErrUnexpectedEOF
11778 }
11779 b := dAtA[iNdEx]
11780 iNdEx++
11781 stringLen |= uint64(b&0x7F) << shift
11782 if b < 0x80 {
11783 break
11784 }
11785 }
11786 intStringLen := int(stringLen)
11787 if intStringLen < 0 {
11788 return protohelpers.ErrInvalidLength
11789 }
11790 postIndex := iNdEx + intStringLen
11791 if postIndex < 0 {
11792 return protohelpers.ErrInvalidLength
11793 }
11794 if postIndex > l {
11795 return io.ErrUnexpectedEOF
11796 }
11797 m.ContainerID = string(dAtA[iNdEx:postIndex])
11798 iNdEx = postIndex
11799 case 2:
11800 if wireType != 2 {
11801 return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType)
11802 }
11803 var msglen int
11804 for shift := uint(0); ; shift += 7 {
11805 if shift >= 64 {
11806 return protohelpers.ErrIntOverflow
11807 }
11808 if iNdEx >= l {
11809 return io.ErrUnexpectedEOF
11810 }
11811 b := dAtA[iNdEx]
11812 iNdEx++
11813 msglen |= int(b&0x7F) << shift
11814 if b < 0x80 {
11815 break
11816 }
11817 }
11818 if msglen < 0 {
11819 return protohelpers.ErrInvalidLength
11820 }
11821 postIndex := iNdEx + msglen
11822 if postIndex < 0 {
11823 return protohelpers.ErrInvalidLength
11824 }
11825 if postIndex > l {
11826 return io.ErrUnexpectedEOF
11827 }
11828 m.Mounts = append(m.Mounts, &pb.Mount{})
11829 if err := m.Mounts[len(m.Mounts)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11830 return err
11831 }
11832 iNdEx = postIndex
11833 case 3:
11834 if wireType != 0 {
11835 return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
11836 }
11837 m.Network = 0
11838 for shift := uint(0); ; shift += 7 {
11839 if shift >= 64 {
11840 return protohelpers.ErrIntOverflow
11841 }
11842 if iNdEx >= l {
11843 return io.ErrUnexpectedEOF
11844 }
11845 b := dAtA[iNdEx]
11846 iNdEx++
11847 m.Network |= pb.NetMode(b&0x7F) << shift
11848 if b < 0x80 {
11849 break
11850 }
11851 }
11852 case 4:
11853 if wireType != 2 {
11854 return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
11855 }
11856 var msglen int
11857 for shift := uint(0); ; shift += 7 {
11858 if shift >= 64 {
11859 return protohelpers.ErrIntOverflow
11860 }
11861 if iNdEx >= l {
11862 return io.ErrUnexpectedEOF
11863 }
11864 b := dAtA[iNdEx]
11865 iNdEx++
11866 msglen |= int(b&0x7F) << shift
11867 if b < 0x80 {
11868 break
11869 }
11870 }
11871 if msglen < 0 {
11872 return protohelpers.ErrInvalidLength
11873 }
11874 postIndex := iNdEx + msglen
11875 if postIndex < 0 {
11876 return protohelpers.ErrInvalidLength
11877 }
11878 if postIndex > l {
11879 return io.ErrUnexpectedEOF
11880 }
11881 if m.Platform == nil {
11882 m.Platform = &pb.Platform{}
11883 }
11884 if err := m.Platform.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11885 return err
11886 }
11887 iNdEx = postIndex
11888 case 5:
11889 if wireType != 2 {
11890 return fmt.Errorf("proto: wrong wireType = %d for field Constraints", wireType)
11891 }
11892 var msglen int
11893 for shift := uint(0); ; shift += 7 {
11894 if shift >= 64 {
11895 return protohelpers.ErrIntOverflow
11896 }
11897 if iNdEx >= l {
11898 return io.ErrUnexpectedEOF
11899 }
11900 b := dAtA[iNdEx]
11901 iNdEx++
11902 msglen |= int(b&0x7F) << shift
11903 if b < 0x80 {
11904 break
11905 }
11906 }
11907 if msglen < 0 {
11908 return protohelpers.ErrInvalidLength
11909 }
11910 postIndex := iNdEx + msglen
11911 if postIndex < 0 {
11912 return protohelpers.ErrInvalidLength
11913 }
11914 if postIndex > l {
11915 return io.ErrUnexpectedEOF
11916 }
11917 if m.Constraints == nil {
11918 m.Constraints = &pb.WorkerConstraints{}
11919 }
11920 if err := m.Constraints.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11921 return err
11922 }
11923 iNdEx = postIndex
11924 case 6:
11925 if wireType != 2 {
11926 return fmt.Errorf("proto: wrong wireType = %d for field ExtraHosts", wireType)
11927 }
11928 var msglen int
11929 for shift := uint(0); ; shift += 7 {
11930 if shift >= 64 {
11931 return protohelpers.ErrIntOverflow
11932 }
11933 if iNdEx >= l {
11934 return io.ErrUnexpectedEOF
11935 }
11936 b := dAtA[iNdEx]
11937 iNdEx++
11938 msglen |= int(b&0x7F) << shift
11939 if b < 0x80 {
11940 break
11941 }
11942 }
11943 if msglen < 0 {
11944 return protohelpers.ErrInvalidLength
11945 }
11946 postIndex := iNdEx + msglen
11947 if postIndex < 0 {
11948 return protohelpers.ErrInvalidLength
11949 }
11950 if postIndex > l {
11951 return io.ErrUnexpectedEOF
11952 }
11953 m.ExtraHosts = append(m.ExtraHosts, &pb.HostIP{})
11954 if err := m.ExtraHosts[len(m.ExtraHosts)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
11955 return err
11956 }
11957 iNdEx = postIndex
11958 case 7:
11959 if wireType != 2 {
11960 return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
11961 }
11962 var stringLen uint64
11963 for shift := uint(0); ; shift += 7 {
11964 if shift >= 64 {
11965 return protohelpers.ErrIntOverflow
11966 }
11967 if iNdEx >= l {
11968 return io.ErrUnexpectedEOF
11969 }
11970 b := dAtA[iNdEx]
11971 iNdEx++
11972 stringLen |= uint64(b&0x7F) << shift
11973 if b < 0x80 {
11974 break
11975 }
11976 }
11977 intStringLen := int(stringLen)
11978 if intStringLen < 0 {
11979 return protohelpers.ErrInvalidLength
11980 }
11981 postIndex := iNdEx + intStringLen
11982 if postIndex < 0 {
11983 return protohelpers.ErrInvalidLength
11984 }
11985 if postIndex > l {
11986 return io.ErrUnexpectedEOF
11987 }
11988 m.Hostname = string(dAtA[iNdEx:postIndex])
11989 iNdEx = postIndex
11990 default:
11991 iNdEx = preIndex
11992 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
11993 if err != nil {
11994 return err
11995 }
11996 if (skippy < 0) || (iNdEx+skippy) < 0 {
11997 return protohelpers.ErrInvalidLength
11998 }
11999 if (iNdEx + skippy) > l {
12000 return io.ErrUnexpectedEOF
12001 }
12002 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12003 iNdEx += skippy
12004 }
12005 }
12006
12007 if iNdEx > l {
12008 return io.ErrUnexpectedEOF
12009 }
12010 return nil
12011 }
12012 func (m *NewContainerResponse) UnmarshalVT(dAtA []byte) error {
12013 l := len(dAtA)
12014 iNdEx := 0
12015 for iNdEx < l {
12016 preIndex := iNdEx
12017 var wire uint64
12018 for shift := uint(0); ; shift += 7 {
12019 if shift >= 64 {
12020 return protohelpers.ErrIntOverflow
12021 }
12022 if iNdEx >= l {
12023 return io.ErrUnexpectedEOF
12024 }
12025 b := dAtA[iNdEx]
12026 iNdEx++
12027 wire |= uint64(b&0x7F) << shift
12028 if b < 0x80 {
12029 break
12030 }
12031 }
12032 fieldNum := int32(wire >> 3)
12033 wireType := int(wire & 0x7)
12034 if wireType == 4 {
12035 return fmt.Errorf("proto: NewContainerResponse: wiretype end group for non-group")
12036 }
12037 if fieldNum <= 0 {
12038 return fmt.Errorf("proto: NewContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
12039 }
12040 switch fieldNum {
12041 default:
12042 iNdEx = preIndex
12043 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12044 if err != nil {
12045 return err
12046 }
12047 if (skippy < 0) || (iNdEx+skippy) < 0 {
12048 return protohelpers.ErrInvalidLength
12049 }
12050 if (iNdEx + skippy) > l {
12051 return io.ErrUnexpectedEOF
12052 }
12053 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12054 iNdEx += skippy
12055 }
12056 }
12057
12058 if iNdEx > l {
12059 return io.ErrUnexpectedEOF
12060 }
12061 return nil
12062 }
12063 func (m *ReleaseContainerRequest) UnmarshalVT(dAtA []byte) error {
12064 l := len(dAtA)
12065 iNdEx := 0
12066 for iNdEx < l {
12067 preIndex := iNdEx
12068 var wire uint64
12069 for shift := uint(0); ; shift += 7 {
12070 if shift >= 64 {
12071 return protohelpers.ErrIntOverflow
12072 }
12073 if iNdEx >= l {
12074 return io.ErrUnexpectedEOF
12075 }
12076 b := dAtA[iNdEx]
12077 iNdEx++
12078 wire |= uint64(b&0x7F) << shift
12079 if b < 0x80 {
12080 break
12081 }
12082 }
12083 fieldNum := int32(wire >> 3)
12084 wireType := int(wire & 0x7)
12085 if wireType == 4 {
12086 return fmt.Errorf("proto: ReleaseContainerRequest: wiretype end group for non-group")
12087 }
12088 if fieldNum <= 0 {
12089 return fmt.Errorf("proto: ReleaseContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
12090 }
12091 switch fieldNum {
12092 case 1:
12093 if wireType != 2 {
12094 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
12095 }
12096 var stringLen uint64
12097 for shift := uint(0); ; shift += 7 {
12098 if shift >= 64 {
12099 return protohelpers.ErrIntOverflow
12100 }
12101 if iNdEx >= l {
12102 return io.ErrUnexpectedEOF
12103 }
12104 b := dAtA[iNdEx]
12105 iNdEx++
12106 stringLen |= uint64(b&0x7F) << shift
12107 if b < 0x80 {
12108 break
12109 }
12110 }
12111 intStringLen := int(stringLen)
12112 if intStringLen < 0 {
12113 return protohelpers.ErrInvalidLength
12114 }
12115 postIndex := iNdEx + intStringLen
12116 if postIndex < 0 {
12117 return protohelpers.ErrInvalidLength
12118 }
12119 if postIndex > l {
12120 return io.ErrUnexpectedEOF
12121 }
12122 m.ContainerID = string(dAtA[iNdEx:postIndex])
12123 iNdEx = postIndex
12124 default:
12125 iNdEx = preIndex
12126 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12127 if err != nil {
12128 return err
12129 }
12130 if (skippy < 0) || (iNdEx+skippy) < 0 {
12131 return protohelpers.ErrInvalidLength
12132 }
12133 if (iNdEx + skippy) > l {
12134 return io.ErrUnexpectedEOF
12135 }
12136 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12137 iNdEx += skippy
12138 }
12139 }
12140
12141 if iNdEx > l {
12142 return io.ErrUnexpectedEOF
12143 }
12144 return nil
12145 }
12146 func (m *ReleaseContainerResponse) UnmarshalVT(dAtA []byte) error {
12147 l := len(dAtA)
12148 iNdEx := 0
12149 for iNdEx < l {
12150 preIndex := iNdEx
12151 var wire uint64
12152 for shift := uint(0); ; shift += 7 {
12153 if shift >= 64 {
12154 return protohelpers.ErrIntOverflow
12155 }
12156 if iNdEx >= l {
12157 return io.ErrUnexpectedEOF
12158 }
12159 b := dAtA[iNdEx]
12160 iNdEx++
12161 wire |= uint64(b&0x7F) << shift
12162 if b < 0x80 {
12163 break
12164 }
12165 }
12166 fieldNum := int32(wire >> 3)
12167 wireType := int(wire & 0x7)
12168 if wireType == 4 {
12169 return fmt.Errorf("proto: ReleaseContainerResponse: wiretype end group for non-group")
12170 }
12171 if fieldNum <= 0 {
12172 return fmt.Errorf("proto: ReleaseContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
12173 }
12174 switch fieldNum {
12175 default:
12176 iNdEx = preIndex
12177 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12178 if err != nil {
12179 return err
12180 }
12181 if (skippy < 0) || (iNdEx+skippy) < 0 {
12182 return protohelpers.ErrInvalidLength
12183 }
12184 if (iNdEx + skippy) > l {
12185 return io.ErrUnexpectedEOF
12186 }
12187 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12188 iNdEx += skippy
12189 }
12190 }
12191
12192 if iNdEx > l {
12193 return io.ErrUnexpectedEOF
12194 }
12195 return nil
12196 }
12197 func (m *ExecMessage) UnmarshalVT(dAtA []byte) error {
12198 l := len(dAtA)
12199 iNdEx := 0
12200 for iNdEx < l {
12201 preIndex := iNdEx
12202 var wire uint64
12203 for shift := uint(0); ; shift += 7 {
12204 if shift >= 64 {
12205 return protohelpers.ErrIntOverflow
12206 }
12207 if iNdEx >= l {
12208 return io.ErrUnexpectedEOF
12209 }
12210 b := dAtA[iNdEx]
12211 iNdEx++
12212 wire |= uint64(b&0x7F) << shift
12213 if b < 0x80 {
12214 break
12215 }
12216 }
12217 fieldNum := int32(wire >> 3)
12218 wireType := int(wire & 0x7)
12219 if wireType == 4 {
12220 return fmt.Errorf("proto: ExecMessage: wiretype end group for non-group")
12221 }
12222 if fieldNum <= 0 {
12223 return fmt.Errorf("proto: ExecMessage: illegal tag %d (wire type %d)", fieldNum, wire)
12224 }
12225 switch fieldNum {
12226 case 1:
12227 if wireType != 2 {
12228 return fmt.Errorf("proto: wrong wireType = %d for field ProcessID", wireType)
12229 }
12230 var stringLen uint64
12231 for shift := uint(0); ; shift += 7 {
12232 if shift >= 64 {
12233 return protohelpers.ErrIntOverflow
12234 }
12235 if iNdEx >= l {
12236 return io.ErrUnexpectedEOF
12237 }
12238 b := dAtA[iNdEx]
12239 iNdEx++
12240 stringLen |= uint64(b&0x7F) << shift
12241 if b < 0x80 {
12242 break
12243 }
12244 }
12245 intStringLen := int(stringLen)
12246 if intStringLen < 0 {
12247 return protohelpers.ErrInvalidLength
12248 }
12249 postIndex := iNdEx + intStringLen
12250 if postIndex < 0 {
12251 return protohelpers.ErrInvalidLength
12252 }
12253 if postIndex > l {
12254 return io.ErrUnexpectedEOF
12255 }
12256 m.ProcessID = string(dAtA[iNdEx:postIndex])
12257 iNdEx = postIndex
12258 case 2:
12259 if wireType != 2 {
12260 return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)
12261 }
12262 var msglen int
12263 for shift := uint(0); ; shift += 7 {
12264 if shift >= 64 {
12265 return protohelpers.ErrIntOverflow
12266 }
12267 if iNdEx >= l {
12268 return io.ErrUnexpectedEOF
12269 }
12270 b := dAtA[iNdEx]
12271 iNdEx++
12272 msglen |= int(b&0x7F) << shift
12273 if b < 0x80 {
12274 break
12275 }
12276 }
12277 if msglen < 0 {
12278 return protohelpers.ErrInvalidLength
12279 }
12280 postIndex := iNdEx + msglen
12281 if postIndex < 0 {
12282 return protohelpers.ErrInvalidLength
12283 }
12284 if postIndex > l {
12285 return io.ErrUnexpectedEOF
12286 }
12287 if oneof, ok := m.Input.(*ExecMessage_Init); ok {
12288 if err := oneof.Init.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12289 return err
12290 }
12291 } else {
12292 v := &InitMessage{}
12293 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12294 return err
12295 }
12296 m.Input = &ExecMessage_Init{Init: v}
12297 }
12298 iNdEx = postIndex
12299 case 3:
12300 if wireType != 2 {
12301 return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
12302 }
12303 var msglen int
12304 for shift := uint(0); ; shift += 7 {
12305 if shift >= 64 {
12306 return protohelpers.ErrIntOverflow
12307 }
12308 if iNdEx >= l {
12309 return io.ErrUnexpectedEOF
12310 }
12311 b := dAtA[iNdEx]
12312 iNdEx++
12313 msglen |= int(b&0x7F) << shift
12314 if b < 0x80 {
12315 break
12316 }
12317 }
12318 if msglen < 0 {
12319 return protohelpers.ErrInvalidLength
12320 }
12321 postIndex := iNdEx + msglen
12322 if postIndex < 0 {
12323 return protohelpers.ErrInvalidLength
12324 }
12325 if postIndex > l {
12326 return io.ErrUnexpectedEOF
12327 }
12328 if oneof, ok := m.Input.(*ExecMessage_File); ok {
12329 if err := oneof.File.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12330 return err
12331 }
12332 } else {
12333 v := &FdMessage{}
12334 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12335 return err
12336 }
12337 m.Input = &ExecMessage_File{File: v}
12338 }
12339 iNdEx = postIndex
12340 case 4:
12341 if wireType != 2 {
12342 return fmt.Errorf("proto: wrong wireType = %d for field Resize", wireType)
12343 }
12344 var msglen int
12345 for shift := uint(0); ; shift += 7 {
12346 if shift >= 64 {
12347 return protohelpers.ErrIntOverflow
12348 }
12349 if iNdEx >= l {
12350 return io.ErrUnexpectedEOF
12351 }
12352 b := dAtA[iNdEx]
12353 iNdEx++
12354 msglen |= int(b&0x7F) << shift
12355 if b < 0x80 {
12356 break
12357 }
12358 }
12359 if msglen < 0 {
12360 return protohelpers.ErrInvalidLength
12361 }
12362 postIndex := iNdEx + msglen
12363 if postIndex < 0 {
12364 return protohelpers.ErrInvalidLength
12365 }
12366 if postIndex > l {
12367 return io.ErrUnexpectedEOF
12368 }
12369 if oneof, ok := m.Input.(*ExecMessage_Resize); ok {
12370 if err := oneof.Resize.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12371 return err
12372 }
12373 } else {
12374 v := &ResizeMessage{}
12375 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12376 return err
12377 }
12378 m.Input = &ExecMessage_Resize{Resize: v}
12379 }
12380 iNdEx = postIndex
12381 case 5:
12382 if wireType != 2 {
12383 return fmt.Errorf("proto: wrong wireType = %d for field Started", wireType)
12384 }
12385 var msglen int
12386 for shift := uint(0); ; shift += 7 {
12387 if shift >= 64 {
12388 return protohelpers.ErrIntOverflow
12389 }
12390 if iNdEx >= l {
12391 return io.ErrUnexpectedEOF
12392 }
12393 b := dAtA[iNdEx]
12394 iNdEx++
12395 msglen |= int(b&0x7F) << shift
12396 if b < 0x80 {
12397 break
12398 }
12399 }
12400 if msglen < 0 {
12401 return protohelpers.ErrInvalidLength
12402 }
12403 postIndex := iNdEx + msglen
12404 if postIndex < 0 {
12405 return protohelpers.ErrInvalidLength
12406 }
12407 if postIndex > l {
12408 return io.ErrUnexpectedEOF
12409 }
12410 if oneof, ok := m.Input.(*ExecMessage_Started); ok {
12411 if err := oneof.Started.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12412 return err
12413 }
12414 } else {
12415 v := &StartedMessage{}
12416 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12417 return err
12418 }
12419 m.Input = &ExecMessage_Started{Started: v}
12420 }
12421 iNdEx = postIndex
12422 case 6:
12423 if wireType != 2 {
12424 return fmt.Errorf("proto: wrong wireType = %d for field Exit", wireType)
12425 }
12426 var msglen int
12427 for shift := uint(0); ; shift += 7 {
12428 if shift >= 64 {
12429 return protohelpers.ErrIntOverflow
12430 }
12431 if iNdEx >= l {
12432 return io.ErrUnexpectedEOF
12433 }
12434 b := dAtA[iNdEx]
12435 iNdEx++
12436 msglen |= int(b&0x7F) << shift
12437 if b < 0x80 {
12438 break
12439 }
12440 }
12441 if msglen < 0 {
12442 return protohelpers.ErrInvalidLength
12443 }
12444 postIndex := iNdEx + msglen
12445 if postIndex < 0 {
12446 return protohelpers.ErrInvalidLength
12447 }
12448 if postIndex > l {
12449 return io.ErrUnexpectedEOF
12450 }
12451 if oneof, ok := m.Input.(*ExecMessage_Exit); ok {
12452 if err := oneof.Exit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12453 return err
12454 }
12455 } else {
12456 v := &ExitMessage{}
12457 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12458 return err
12459 }
12460 m.Input = &ExecMessage_Exit{Exit: v}
12461 }
12462 iNdEx = postIndex
12463 case 7:
12464 if wireType != 2 {
12465 return fmt.Errorf("proto: wrong wireType = %d for field Done", wireType)
12466 }
12467 var msglen int
12468 for shift := uint(0); ; shift += 7 {
12469 if shift >= 64 {
12470 return protohelpers.ErrIntOverflow
12471 }
12472 if iNdEx >= l {
12473 return io.ErrUnexpectedEOF
12474 }
12475 b := dAtA[iNdEx]
12476 iNdEx++
12477 msglen |= int(b&0x7F) << shift
12478 if b < 0x80 {
12479 break
12480 }
12481 }
12482 if msglen < 0 {
12483 return protohelpers.ErrInvalidLength
12484 }
12485 postIndex := iNdEx + msglen
12486 if postIndex < 0 {
12487 return protohelpers.ErrInvalidLength
12488 }
12489 if postIndex > l {
12490 return io.ErrUnexpectedEOF
12491 }
12492 if oneof, ok := m.Input.(*ExecMessage_Done); ok {
12493 if err := oneof.Done.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12494 return err
12495 }
12496 } else {
12497 v := &DoneMessage{}
12498 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12499 return err
12500 }
12501 m.Input = &ExecMessage_Done{Done: v}
12502 }
12503 iNdEx = postIndex
12504 case 8:
12505 if wireType != 2 {
12506 return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType)
12507 }
12508 var msglen int
12509 for shift := uint(0); ; shift += 7 {
12510 if shift >= 64 {
12511 return protohelpers.ErrIntOverflow
12512 }
12513 if iNdEx >= l {
12514 return io.ErrUnexpectedEOF
12515 }
12516 b := dAtA[iNdEx]
12517 iNdEx++
12518 msglen |= int(b&0x7F) << shift
12519 if b < 0x80 {
12520 break
12521 }
12522 }
12523 if msglen < 0 {
12524 return protohelpers.ErrInvalidLength
12525 }
12526 postIndex := iNdEx + msglen
12527 if postIndex < 0 {
12528 return protohelpers.ErrInvalidLength
12529 }
12530 if postIndex > l {
12531 return io.ErrUnexpectedEOF
12532 }
12533 if oneof, ok := m.Input.(*ExecMessage_Signal); ok {
12534 if err := oneof.Signal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12535 return err
12536 }
12537 } else {
12538 v := &SignalMessage{}
12539 if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12540 return err
12541 }
12542 m.Input = &ExecMessage_Signal{Signal: v}
12543 }
12544 iNdEx = postIndex
12545 default:
12546 iNdEx = preIndex
12547 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12548 if err != nil {
12549 return err
12550 }
12551 if (skippy < 0) || (iNdEx+skippy) < 0 {
12552 return protohelpers.ErrInvalidLength
12553 }
12554 if (iNdEx + skippy) > l {
12555 return io.ErrUnexpectedEOF
12556 }
12557 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12558 iNdEx += skippy
12559 }
12560 }
12561
12562 if iNdEx > l {
12563 return io.ErrUnexpectedEOF
12564 }
12565 return nil
12566 }
12567 func (m *InitMessage) UnmarshalVT(dAtA []byte) error {
12568 l := len(dAtA)
12569 iNdEx := 0
12570 for iNdEx < l {
12571 preIndex := iNdEx
12572 var wire uint64
12573 for shift := uint(0); ; shift += 7 {
12574 if shift >= 64 {
12575 return protohelpers.ErrIntOverflow
12576 }
12577 if iNdEx >= l {
12578 return io.ErrUnexpectedEOF
12579 }
12580 b := dAtA[iNdEx]
12581 iNdEx++
12582 wire |= uint64(b&0x7F) << shift
12583 if b < 0x80 {
12584 break
12585 }
12586 }
12587 fieldNum := int32(wire >> 3)
12588 wireType := int(wire & 0x7)
12589 if wireType == 4 {
12590 return fmt.Errorf("proto: InitMessage: wiretype end group for non-group")
12591 }
12592 if fieldNum <= 0 {
12593 return fmt.Errorf("proto: InitMessage: illegal tag %d (wire type %d)", fieldNum, wire)
12594 }
12595 switch fieldNum {
12596 case 1:
12597 if wireType != 2 {
12598 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
12599 }
12600 var stringLen uint64
12601 for shift := uint(0); ; shift += 7 {
12602 if shift >= 64 {
12603 return protohelpers.ErrIntOverflow
12604 }
12605 if iNdEx >= l {
12606 return io.ErrUnexpectedEOF
12607 }
12608 b := dAtA[iNdEx]
12609 iNdEx++
12610 stringLen |= uint64(b&0x7F) << shift
12611 if b < 0x80 {
12612 break
12613 }
12614 }
12615 intStringLen := int(stringLen)
12616 if intStringLen < 0 {
12617 return protohelpers.ErrInvalidLength
12618 }
12619 postIndex := iNdEx + intStringLen
12620 if postIndex < 0 {
12621 return protohelpers.ErrInvalidLength
12622 }
12623 if postIndex > l {
12624 return io.ErrUnexpectedEOF
12625 }
12626 m.ContainerID = string(dAtA[iNdEx:postIndex])
12627 iNdEx = postIndex
12628 case 2:
12629 if wireType != 2 {
12630 return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
12631 }
12632 var msglen int
12633 for shift := uint(0); ; shift += 7 {
12634 if shift >= 64 {
12635 return protohelpers.ErrIntOverflow
12636 }
12637 if iNdEx >= l {
12638 return io.ErrUnexpectedEOF
12639 }
12640 b := dAtA[iNdEx]
12641 iNdEx++
12642 msglen |= int(b&0x7F) << shift
12643 if b < 0x80 {
12644 break
12645 }
12646 }
12647 if msglen < 0 {
12648 return protohelpers.ErrInvalidLength
12649 }
12650 postIndex := iNdEx + msglen
12651 if postIndex < 0 {
12652 return protohelpers.ErrInvalidLength
12653 }
12654 if postIndex > l {
12655 return io.ErrUnexpectedEOF
12656 }
12657 if m.Meta == nil {
12658 m.Meta = &pb.Meta{}
12659 }
12660 if err := m.Meta.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12661 return err
12662 }
12663 iNdEx = postIndex
12664 case 3:
12665 if wireType == 0 {
12666 var v uint32
12667 for shift := uint(0); ; shift += 7 {
12668 if shift >= 64 {
12669 return protohelpers.ErrIntOverflow
12670 }
12671 if iNdEx >= l {
12672 return io.ErrUnexpectedEOF
12673 }
12674 b := dAtA[iNdEx]
12675 iNdEx++
12676 v |= uint32(b&0x7F) << shift
12677 if b < 0x80 {
12678 break
12679 }
12680 }
12681 m.Fds = append(m.Fds, v)
12682 } else if wireType == 2 {
12683 var packedLen int
12684 for shift := uint(0); ; shift += 7 {
12685 if shift >= 64 {
12686 return protohelpers.ErrIntOverflow
12687 }
12688 if iNdEx >= l {
12689 return io.ErrUnexpectedEOF
12690 }
12691 b := dAtA[iNdEx]
12692 iNdEx++
12693 packedLen |= int(b&0x7F) << shift
12694 if b < 0x80 {
12695 break
12696 }
12697 }
12698 if packedLen < 0 {
12699 return protohelpers.ErrInvalidLength
12700 }
12701 postIndex := iNdEx + packedLen
12702 if postIndex < 0 {
12703 return protohelpers.ErrInvalidLength
12704 }
12705 if postIndex > l {
12706 return io.ErrUnexpectedEOF
12707 }
12708 var elementCount int
12709 var count int
12710 for _, integer := range dAtA[iNdEx:postIndex] {
12711 if integer < 128 {
12712 count++
12713 }
12714 }
12715 elementCount = count
12716 if elementCount != 0 && len(m.Fds) == 0 {
12717 m.Fds = make([]uint32, 0, elementCount)
12718 }
12719 for iNdEx < postIndex {
12720 var v uint32
12721 for shift := uint(0); ; shift += 7 {
12722 if shift >= 64 {
12723 return protohelpers.ErrIntOverflow
12724 }
12725 if iNdEx >= l {
12726 return io.ErrUnexpectedEOF
12727 }
12728 b := dAtA[iNdEx]
12729 iNdEx++
12730 v |= uint32(b&0x7F) << shift
12731 if b < 0x80 {
12732 break
12733 }
12734 }
12735 m.Fds = append(m.Fds, v)
12736 }
12737 } else {
12738 return fmt.Errorf("proto: wrong wireType = %d for field Fds", wireType)
12739 }
12740 case 4:
12741 if wireType != 0 {
12742 return fmt.Errorf("proto: wrong wireType = %d for field Tty", wireType)
12743 }
12744 var v int
12745 for shift := uint(0); ; shift += 7 {
12746 if shift >= 64 {
12747 return protohelpers.ErrIntOverflow
12748 }
12749 if iNdEx >= l {
12750 return io.ErrUnexpectedEOF
12751 }
12752 b := dAtA[iNdEx]
12753 iNdEx++
12754 v |= int(b&0x7F) << shift
12755 if b < 0x80 {
12756 break
12757 }
12758 }
12759 m.Tty = bool(v != 0)
12760 case 5:
12761 if wireType != 0 {
12762 return fmt.Errorf("proto: wrong wireType = %d for field Security", wireType)
12763 }
12764 m.Security = 0
12765 for shift := uint(0); ; shift += 7 {
12766 if shift >= 64 {
12767 return protohelpers.ErrIntOverflow
12768 }
12769 if iNdEx >= l {
12770 return io.ErrUnexpectedEOF
12771 }
12772 b := dAtA[iNdEx]
12773 iNdEx++
12774 m.Security |= pb.SecurityMode(b&0x7F) << shift
12775 if b < 0x80 {
12776 break
12777 }
12778 }
12779 case 6:
12780 if wireType != 2 {
12781 return fmt.Errorf("proto: wrong wireType = %d for field Secretenv", wireType)
12782 }
12783 var msglen int
12784 for shift := uint(0); ; shift += 7 {
12785 if shift >= 64 {
12786 return protohelpers.ErrIntOverflow
12787 }
12788 if iNdEx >= l {
12789 return io.ErrUnexpectedEOF
12790 }
12791 b := dAtA[iNdEx]
12792 iNdEx++
12793 msglen |= int(b&0x7F) << shift
12794 if b < 0x80 {
12795 break
12796 }
12797 }
12798 if msglen < 0 {
12799 return protohelpers.ErrInvalidLength
12800 }
12801 postIndex := iNdEx + msglen
12802 if postIndex < 0 {
12803 return protohelpers.ErrInvalidLength
12804 }
12805 if postIndex > l {
12806 return io.ErrUnexpectedEOF
12807 }
12808 m.Secretenv = append(m.Secretenv, &pb.SecretEnv{})
12809 if err := m.Secretenv[len(m.Secretenv)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12810 return err
12811 }
12812 iNdEx = postIndex
12813 default:
12814 iNdEx = preIndex
12815 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12816 if err != nil {
12817 return err
12818 }
12819 if (skippy < 0) || (iNdEx+skippy) < 0 {
12820 return protohelpers.ErrInvalidLength
12821 }
12822 if (iNdEx + skippy) > l {
12823 return io.ErrUnexpectedEOF
12824 }
12825 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12826 iNdEx += skippy
12827 }
12828 }
12829
12830 if iNdEx > l {
12831 return io.ErrUnexpectedEOF
12832 }
12833 return nil
12834 }
12835 func (m *ExitMessage) UnmarshalVT(dAtA []byte) error {
12836 l := len(dAtA)
12837 iNdEx := 0
12838 for iNdEx < l {
12839 preIndex := iNdEx
12840 var wire uint64
12841 for shift := uint(0); ; shift += 7 {
12842 if shift >= 64 {
12843 return protohelpers.ErrIntOverflow
12844 }
12845 if iNdEx >= l {
12846 return io.ErrUnexpectedEOF
12847 }
12848 b := dAtA[iNdEx]
12849 iNdEx++
12850 wire |= uint64(b&0x7F) << shift
12851 if b < 0x80 {
12852 break
12853 }
12854 }
12855 fieldNum := int32(wire >> 3)
12856 wireType := int(wire & 0x7)
12857 if wireType == 4 {
12858 return fmt.Errorf("proto: ExitMessage: wiretype end group for non-group")
12859 }
12860 if fieldNum <= 0 {
12861 return fmt.Errorf("proto: ExitMessage: illegal tag %d (wire type %d)", fieldNum, wire)
12862 }
12863 switch fieldNum {
12864 case 1:
12865 if wireType != 0 {
12866 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
12867 }
12868 m.Code = 0
12869 for shift := uint(0); ; shift += 7 {
12870 if shift >= 64 {
12871 return protohelpers.ErrIntOverflow
12872 }
12873 if iNdEx >= l {
12874 return io.ErrUnexpectedEOF
12875 }
12876 b := dAtA[iNdEx]
12877 iNdEx++
12878 m.Code |= uint32(b&0x7F) << shift
12879 if b < 0x80 {
12880 break
12881 }
12882 }
12883 case 2:
12884 if wireType != 2 {
12885 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
12886 }
12887 var msglen int
12888 for shift := uint(0); ; shift += 7 {
12889 if shift >= 64 {
12890 return protohelpers.ErrIntOverflow
12891 }
12892 if iNdEx >= l {
12893 return io.ErrUnexpectedEOF
12894 }
12895 b := dAtA[iNdEx]
12896 iNdEx++
12897 msglen |= int(b&0x7F) << shift
12898 if b < 0x80 {
12899 break
12900 }
12901 }
12902 if msglen < 0 {
12903 return protohelpers.ErrInvalidLength
12904 }
12905 postIndex := iNdEx + msglen
12906 if postIndex < 0 {
12907 return protohelpers.ErrInvalidLength
12908 }
12909 if postIndex > l {
12910 return io.ErrUnexpectedEOF
12911 }
12912 if m.Error == nil {
12913 m.Error = &status.Status{}
12914 }
12915 if unmarshal, ok := interface{}(m.Error).(interface {
12916 UnmarshalVT([]byte) error
12917 }); ok {
12918 if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
12919 return err
12920 }
12921 } else {
12922 if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Error); err != nil {
12923 return err
12924 }
12925 }
12926 iNdEx = postIndex
12927 default:
12928 iNdEx = preIndex
12929 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12930 if err != nil {
12931 return err
12932 }
12933 if (skippy < 0) || (iNdEx+skippy) < 0 {
12934 return protohelpers.ErrInvalidLength
12935 }
12936 if (iNdEx + skippy) > l {
12937 return io.ErrUnexpectedEOF
12938 }
12939 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12940 iNdEx += skippy
12941 }
12942 }
12943
12944 if iNdEx > l {
12945 return io.ErrUnexpectedEOF
12946 }
12947 return nil
12948 }
12949 func (m *StartedMessage) UnmarshalVT(dAtA []byte) error {
12950 l := len(dAtA)
12951 iNdEx := 0
12952 for iNdEx < l {
12953 preIndex := iNdEx
12954 var wire uint64
12955 for shift := uint(0); ; shift += 7 {
12956 if shift >= 64 {
12957 return protohelpers.ErrIntOverflow
12958 }
12959 if iNdEx >= l {
12960 return io.ErrUnexpectedEOF
12961 }
12962 b := dAtA[iNdEx]
12963 iNdEx++
12964 wire |= uint64(b&0x7F) << shift
12965 if b < 0x80 {
12966 break
12967 }
12968 }
12969 fieldNum := int32(wire >> 3)
12970 wireType := int(wire & 0x7)
12971 if wireType == 4 {
12972 return fmt.Errorf("proto: StartedMessage: wiretype end group for non-group")
12973 }
12974 if fieldNum <= 0 {
12975 return fmt.Errorf("proto: StartedMessage: illegal tag %d (wire type %d)", fieldNum, wire)
12976 }
12977 switch fieldNum {
12978 default:
12979 iNdEx = preIndex
12980 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
12981 if err != nil {
12982 return err
12983 }
12984 if (skippy < 0) || (iNdEx+skippy) < 0 {
12985 return protohelpers.ErrInvalidLength
12986 }
12987 if (iNdEx + skippy) > l {
12988 return io.ErrUnexpectedEOF
12989 }
12990 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
12991 iNdEx += skippy
12992 }
12993 }
12994
12995 if iNdEx > l {
12996 return io.ErrUnexpectedEOF
12997 }
12998 return nil
12999 }
13000 func (m *DoneMessage) UnmarshalVT(dAtA []byte) error {
13001 l := len(dAtA)
13002 iNdEx := 0
13003 for iNdEx < l {
13004 preIndex := iNdEx
13005 var wire uint64
13006 for shift := uint(0); ; shift += 7 {
13007 if shift >= 64 {
13008 return protohelpers.ErrIntOverflow
13009 }
13010 if iNdEx >= l {
13011 return io.ErrUnexpectedEOF
13012 }
13013 b := dAtA[iNdEx]
13014 iNdEx++
13015 wire |= uint64(b&0x7F) << shift
13016 if b < 0x80 {
13017 break
13018 }
13019 }
13020 fieldNum := int32(wire >> 3)
13021 wireType := int(wire & 0x7)
13022 if wireType == 4 {
13023 return fmt.Errorf("proto: DoneMessage: wiretype end group for non-group")
13024 }
13025 if fieldNum <= 0 {
13026 return fmt.Errorf("proto: DoneMessage: illegal tag %d (wire type %d)", fieldNum, wire)
13027 }
13028 switch fieldNum {
13029 default:
13030 iNdEx = preIndex
13031 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
13032 if err != nil {
13033 return err
13034 }
13035 if (skippy < 0) || (iNdEx+skippy) < 0 {
13036 return protohelpers.ErrInvalidLength
13037 }
13038 if (iNdEx + skippy) > l {
13039 return io.ErrUnexpectedEOF
13040 }
13041 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
13042 iNdEx += skippy
13043 }
13044 }
13045
13046 if iNdEx > l {
13047 return io.ErrUnexpectedEOF
13048 }
13049 return nil
13050 }
13051 func (m *FdMessage) UnmarshalVT(dAtA []byte) error {
13052 l := len(dAtA)
13053 iNdEx := 0
13054 for iNdEx < l {
13055 preIndex := iNdEx
13056 var wire uint64
13057 for shift := uint(0); ; shift += 7 {
13058 if shift >= 64 {
13059 return protohelpers.ErrIntOverflow
13060 }
13061 if iNdEx >= l {
13062 return io.ErrUnexpectedEOF
13063 }
13064 b := dAtA[iNdEx]
13065 iNdEx++
13066 wire |= uint64(b&0x7F) << shift
13067 if b < 0x80 {
13068 break
13069 }
13070 }
13071 fieldNum := int32(wire >> 3)
13072 wireType := int(wire & 0x7)
13073 if wireType == 4 {
13074 return fmt.Errorf("proto: FdMessage: wiretype end group for non-group")
13075 }
13076 if fieldNum <= 0 {
13077 return fmt.Errorf("proto: FdMessage: illegal tag %d (wire type %d)", fieldNum, wire)
13078 }
13079 switch fieldNum {
13080 case 1:
13081 if wireType != 0 {
13082 return fmt.Errorf("proto: wrong wireType = %d for field Fd", wireType)
13083 }
13084 m.Fd = 0
13085 for shift := uint(0); ; shift += 7 {
13086 if shift >= 64 {
13087 return protohelpers.ErrIntOverflow
13088 }
13089 if iNdEx >= l {
13090 return io.ErrUnexpectedEOF
13091 }
13092 b := dAtA[iNdEx]
13093 iNdEx++
13094 m.Fd |= uint32(b&0x7F) << shift
13095 if b < 0x80 {
13096 break
13097 }
13098 }
13099 case 2:
13100 if wireType != 0 {
13101 return fmt.Errorf("proto: wrong wireType = %d for field EOF", wireType)
13102 }
13103 var v int
13104 for shift := uint(0); ; shift += 7 {
13105 if shift >= 64 {
13106 return protohelpers.ErrIntOverflow
13107 }
13108 if iNdEx >= l {
13109 return io.ErrUnexpectedEOF
13110 }
13111 b := dAtA[iNdEx]
13112 iNdEx++
13113 v |= int(b&0x7F) << shift
13114 if b < 0x80 {
13115 break
13116 }
13117 }
13118 m.EOF = bool(v != 0)
13119 case 3:
13120 if wireType != 2 {
13121 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
13122 }
13123 var byteLen int
13124 for shift := uint(0); ; shift += 7 {
13125 if shift >= 64 {
13126 return protohelpers.ErrIntOverflow
13127 }
13128 if iNdEx >= l {
13129 return io.ErrUnexpectedEOF
13130 }
13131 b := dAtA[iNdEx]
13132 iNdEx++
13133 byteLen |= int(b&0x7F) << shift
13134 if b < 0x80 {
13135 break
13136 }
13137 }
13138 if byteLen < 0 {
13139 return protohelpers.ErrInvalidLength
13140 }
13141 postIndex := iNdEx + byteLen
13142 if postIndex < 0 {
13143 return protohelpers.ErrInvalidLength
13144 }
13145 if postIndex > l {
13146 return io.ErrUnexpectedEOF
13147 }
13148 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
13149 if m.Data == nil {
13150 m.Data = []byte{}
13151 }
13152 iNdEx = postIndex
13153 default:
13154 iNdEx = preIndex
13155 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
13156 if err != nil {
13157 return err
13158 }
13159 if (skippy < 0) || (iNdEx+skippy) < 0 {
13160 return protohelpers.ErrInvalidLength
13161 }
13162 if (iNdEx + skippy) > l {
13163 return io.ErrUnexpectedEOF
13164 }
13165 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
13166 iNdEx += skippy
13167 }
13168 }
13169
13170 if iNdEx > l {
13171 return io.ErrUnexpectedEOF
13172 }
13173 return nil
13174 }
13175 func (m *ResizeMessage) UnmarshalVT(dAtA []byte) error {
13176 l := len(dAtA)
13177 iNdEx := 0
13178 for iNdEx < l {
13179 preIndex := iNdEx
13180 var wire uint64
13181 for shift := uint(0); ; shift += 7 {
13182 if shift >= 64 {
13183 return protohelpers.ErrIntOverflow
13184 }
13185 if iNdEx >= l {
13186 return io.ErrUnexpectedEOF
13187 }
13188 b := dAtA[iNdEx]
13189 iNdEx++
13190 wire |= uint64(b&0x7F) << shift
13191 if b < 0x80 {
13192 break
13193 }
13194 }
13195 fieldNum := int32(wire >> 3)
13196 wireType := int(wire & 0x7)
13197 if wireType == 4 {
13198 return fmt.Errorf("proto: ResizeMessage: wiretype end group for non-group")
13199 }
13200 if fieldNum <= 0 {
13201 return fmt.Errorf("proto: ResizeMessage: illegal tag %d (wire type %d)", fieldNum, wire)
13202 }
13203 switch fieldNum {
13204 case 1:
13205 if wireType != 0 {
13206 return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
13207 }
13208 m.Rows = 0
13209 for shift := uint(0); ; shift += 7 {
13210 if shift >= 64 {
13211 return protohelpers.ErrIntOverflow
13212 }
13213 if iNdEx >= l {
13214 return io.ErrUnexpectedEOF
13215 }
13216 b := dAtA[iNdEx]
13217 iNdEx++
13218 m.Rows |= uint32(b&0x7F) << shift
13219 if b < 0x80 {
13220 break
13221 }
13222 }
13223 case 2:
13224 if wireType != 0 {
13225 return fmt.Errorf("proto: wrong wireType = %d for field Cols", wireType)
13226 }
13227 m.Cols = 0
13228 for shift := uint(0); ; shift += 7 {
13229 if shift >= 64 {
13230 return protohelpers.ErrIntOverflow
13231 }
13232 if iNdEx >= l {
13233 return io.ErrUnexpectedEOF
13234 }
13235 b := dAtA[iNdEx]
13236 iNdEx++
13237 m.Cols |= uint32(b&0x7F) << shift
13238 if b < 0x80 {
13239 break
13240 }
13241 }
13242 default:
13243 iNdEx = preIndex
13244 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
13245 if err != nil {
13246 return err
13247 }
13248 if (skippy < 0) || (iNdEx+skippy) < 0 {
13249 return protohelpers.ErrInvalidLength
13250 }
13251 if (iNdEx + skippy) > l {
13252 return io.ErrUnexpectedEOF
13253 }
13254 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
13255 iNdEx += skippy
13256 }
13257 }
13258
13259 if iNdEx > l {
13260 return io.ErrUnexpectedEOF
13261 }
13262 return nil
13263 }
13264 func (m *SignalMessage) UnmarshalVT(dAtA []byte) error {
13265 l := len(dAtA)
13266 iNdEx := 0
13267 for iNdEx < l {
13268 preIndex := iNdEx
13269 var wire uint64
13270 for shift := uint(0); ; shift += 7 {
13271 if shift >= 64 {
13272 return protohelpers.ErrIntOverflow
13273 }
13274 if iNdEx >= l {
13275 return io.ErrUnexpectedEOF
13276 }
13277 b := dAtA[iNdEx]
13278 iNdEx++
13279 wire |= uint64(b&0x7F) << shift
13280 if b < 0x80 {
13281 break
13282 }
13283 }
13284 fieldNum := int32(wire >> 3)
13285 wireType := int(wire & 0x7)
13286 if wireType == 4 {
13287 return fmt.Errorf("proto: SignalMessage: wiretype end group for non-group")
13288 }
13289 if fieldNum <= 0 {
13290 return fmt.Errorf("proto: SignalMessage: illegal tag %d (wire type %d)", fieldNum, wire)
13291 }
13292 switch fieldNum {
13293 case 1:
13294 if wireType != 2 {
13295 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
13296 }
13297 var stringLen uint64
13298 for shift := uint(0); ; shift += 7 {
13299 if shift >= 64 {
13300 return protohelpers.ErrIntOverflow
13301 }
13302 if iNdEx >= l {
13303 return io.ErrUnexpectedEOF
13304 }
13305 b := dAtA[iNdEx]
13306 iNdEx++
13307 stringLen |= uint64(b&0x7F) << shift
13308 if b < 0x80 {
13309 break
13310 }
13311 }
13312 intStringLen := int(stringLen)
13313 if intStringLen < 0 {
13314 return protohelpers.ErrInvalidLength
13315 }
13316 postIndex := iNdEx + intStringLen
13317 if postIndex < 0 {
13318 return protohelpers.ErrInvalidLength
13319 }
13320 if postIndex > l {
13321 return io.ErrUnexpectedEOF
13322 }
13323 m.Name = string(dAtA[iNdEx:postIndex])
13324 iNdEx = postIndex
13325 default:
13326 iNdEx = preIndex
13327 skippy, err := protohelpers.Skip(dAtA[iNdEx:])
13328 if err != nil {
13329 return err
13330 }
13331 if (skippy < 0) || (iNdEx+skippy) < 0 {
13332 return protohelpers.ErrInvalidLength
13333 }
13334 if (iNdEx + skippy) > l {
13335 return io.ErrUnexpectedEOF
13336 }
13337 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
13338 iNdEx += skippy
13339 }
13340 }
13341
13342 if iNdEx > l {
13343 return io.ErrUnexpectedEOF
13344 }
13345 return nil
13346 }