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