blob: 19bf225fa31a55218d37971550ebaa26686d66c4 [file] [log] [blame]
Scott Bakere7144bc2019-10-01 14:16:47 -07001/*
2Copyright The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17// Code generated by protoc-gen-gogo. DO NOT EDIT.
18// source: k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto
19
20/*
21 Package v1beta1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto
25
26 It has these top-level messages:
27 CertificateSigningRequest
28 CertificateSigningRequestCondition
29 CertificateSigningRequestList
30 CertificateSigningRequestSpec
31 CertificateSigningRequestStatus
32 ExtraValue
33*/
34package v1beta1
35
36import proto "github.com/gogo/protobuf/proto"
37import fmt "fmt"
38import math "math"
39
40import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
41
42import strings "strings"
43import reflect "reflect"
44
45import io "io"
46
47// Reference imports to suppress errors if they are not otherwise used.
48var _ = proto.Marshal
49var _ = fmt.Errorf
50var _ = math.Inf
51
52// This is a compile-time assertion to ensure that this generated file
53// is compatible with the proto package it is being compiled against.
54// A compilation error at this line likely means your copy of the
55// proto package needs to be updated.
56const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
57
58func (m *CertificateSigningRequest) Reset() { *m = CertificateSigningRequest{} }
59func (*CertificateSigningRequest) ProtoMessage() {}
60func (*CertificateSigningRequest) Descriptor() ([]byte, []int) {
61 return fileDescriptorGenerated, []int{0}
62}
63
64func (m *CertificateSigningRequestCondition) Reset() { *m = CertificateSigningRequestCondition{} }
65func (*CertificateSigningRequestCondition) ProtoMessage() {}
66func (*CertificateSigningRequestCondition) Descriptor() ([]byte, []int) {
67 return fileDescriptorGenerated, []int{1}
68}
69
70func (m *CertificateSigningRequestList) Reset() { *m = CertificateSigningRequestList{} }
71func (*CertificateSigningRequestList) ProtoMessage() {}
72func (*CertificateSigningRequestList) Descriptor() ([]byte, []int) {
73 return fileDescriptorGenerated, []int{2}
74}
75
76func (m *CertificateSigningRequestSpec) Reset() { *m = CertificateSigningRequestSpec{} }
77func (*CertificateSigningRequestSpec) ProtoMessage() {}
78func (*CertificateSigningRequestSpec) Descriptor() ([]byte, []int) {
79 return fileDescriptorGenerated, []int{3}
80}
81
82func (m *CertificateSigningRequestStatus) Reset() { *m = CertificateSigningRequestStatus{} }
83func (*CertificateSigningRequestStatus) ProtoMessage() {}
84func (*CertificateSigningRequestStatus) Descriptor() ([]byte, []int) {
85 return fileDescriptorGenerated, []int{4}
86}
87
88func (m *ExtraValue) Reset() { *m = ExtraValue{} }
89func (*ExtraValue) ProtoMessage() {}
90func (*ExtraValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
91
92func init() {
93 proto.RegisterType((*CertificateSigningRequest)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequest")
94 proto.RegisterType((*CertificateSigningRequestCondition)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestCondition")
95 proto.RegisterType((*CertificateSigningRequestList)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestList")
96 proto.RegisterType((*CertificateSigningRequestSpec)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestSpec")
97 proto.RegisterType((*CertificateSigningRequestStatus)(nil), "k8s.io.api.certificates.v1beta1.CertificateSigningRequestStatus")
98 proto.RegisterType((*ExtraValue)(nil), "k8s.io.api.certificates.v1beta1.ExtraValue")
99}
100func (m *CertificateSigningRequest) Marshal() (dAtA []byte, err error) {
101 size := m.Size()
102 dAtA = make([]byte, size)
103 n, err := m.MarshalTo(dAtA)
104 if err != nil {
105 return nil, err
106 }
107 return dAtA[:n], nil
108}
109
110func (m *CertificateSigningRequest) MarshalTo(dAtA []byte) (int, error) {
111 var i int
112 _ = i
113 var l int
114 _ = l
115 dAtA[i] = 0xa
116 i++
117 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
118 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
119 if err != nil {
120 return 0, err
121 }
122 i += n1
123 dAtA[i] = 0x12
124 i++
125 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
126 n2, err := m.Spec.MarshalTo(dAtA[i:])
127 if err != nil {
128 return 0, err
129 }
130 i += n2
131 dAtA[i] = 0x1a
132 i++
133 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
134 n3, err := m.Status.MarshalTo(dAtA[i:])
135 if err != nil {
136 return 0, err
137 }
138 i += n3
139 return i, nil
140}
141
142func (m *CertificateSigningRequestCondition) Marshal() (dAtA []byte, err error) {
143 size := m.Size()
144 dAtA = make([]byte, size)
145 n, err := m.MarshalTo(dAtA)
146 if err != nil {
147 return nil, err
148 }
149 return dAtA[:n], nil
150}
151
152func (m *CertificateSigningRequestCondition) MarshalTo(dAtA []byte) (int, error) {
153 var i int
154 _ = i
155 var l int
156 _ = l
157 dAtA[i] = 0xa
158 i++
159 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
160 i += copy(dAtA[i:], m.Type)
161 dAtA[i] = 0x12
162 i++
163 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
164 i += copy(dAtA[i:], m.Reason)
165 dAtA[i] = 0x1a
166 i++
167 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
168 i += copy(dAtA[i:], m.Message)
169 dAtA[i] = 0x22
170 i++
171 i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
172 n4, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
173 if err != nil {
174 return 0, err
175 }
176 i += n4
177 return i, nil
178}
179
180func (m *CertificateSigningRequestList) Marshal() (dAtA []byte, err error) {
181 size := m.Size()
182 dAtA = make([]byte, size)
183 n, err := m.MarshalTo(dAtA)
184 if err != nil {
185 return nil, err
186 }
187 return dAtA[:n], nil
188}
189
190func (m *CertificateSigningRequestList) MarshalTo(dAtA []byte) (int, error) {
191 var i int
192 _ = i
193 var l int
194 _ = l
195 dAtA[i] = 0xa
196 i++
197 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
198 n5, err := m.ListMeta.MarshalTo(dAtA[i:])
199 if err != nil {
200 return 0, err
201 }
202 i += n5
203 if len(m.Items) > 0 {
204 for _, msg := range m.Items {
205 dAtA[i] = 0x12
206 i++
207 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
208 n, err := msg.MarshalTo(dAtA[i:])
209 if err != nil {
210 return 0, err
211 }
212 i += n
213 }
214 }
215 return i, nil
216}
217
218func (m *CertificateSigningRequestSpec) Marshal() (dAtA []byte, err error) {
219 size := m.Size()
220 dAtA = make([]byte, size)
221 n, err := m.MarshalTo(dAtA)
222 if err != nil {
223 return nil, err
224 }
225 return dAtA[:n], nil
226}
227
228func (m *CertificateSigningRequestSpec) MarshalTo(dAtA []byte) (int, error) {
229 var i int
230 _ = i
231 var l int
232 _ = l
233 if m.Request != nil {
234 dAtA[i] = 0xa
235 i++
236 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Request)))
237 i += copy(dAtA[i:], m.Request)
238 }
239 dAtA[i] = 0x12
240 i++
241 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Username)))
242 i += copy(dAtA[i:], m.Username)
243 dAtA[i] = 0x1a
244 i++
245 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
246 i += copy(dAtA[i:], m.UID)
247 if len(m.Groups) > 0 {
248 for _, s := range m.Groups {
249 dAtA[i] = 0x22
250 i++
251 l = len(s)
252 for l >= 1<<7 {
253 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
254 l >>= 7
255 i++
256 }
257 dAtA[i] = uint8(l)
258 i++
259 i += copy(dAtA[i:], s)
260 }
261 }
262 if len(m.Usages) > 0 {
263 for _, s := range m.Usages {
264 dAtA[i] = 0x2a
265 i++
266 l = len(s)
267 for l >= 1<<7 {
268 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
269 l >>= 7
270 i++
271 }
272 dAtA[i] = uint8(l)
273 i++
274 i += copy(dAtA[i:], s)
275 }
276 }
277 if len(m.Extra) > 0 {
278 keysForExtra := make([]string, 0, len(m.Extra))
279 for k := range m.Extra {
280 keysForExtra = append(keysForExtra, string(k))
281 }
282 github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
283 for _, k := range keysForExtra {
284 dAtA[i] = 0x32
285 i++
286 v := m.Extra[string(k)]
287 msgSize := 0
288 if (&v) != nil {
289 msgSize = (&v).Size()
290 msgSize += 1 + sovGenerated(uint64(msgSize))
291 }
292 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
293 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
294 dAtA[i] = 0xa
295 i++
296 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
297 i += copy(dAtA[i:], k)
298 dAtA[i] = 0x12
299 i++
300 i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
301 n6, err := (&v).MarshalTo(dAtA[i:])
302 if err != nil {
303 return 0, err
304 }
305 i += n6
306 }
307 }
308 return i, nil
309}
310
311func (m *CertificateSigningRequestStatus) Marshal() (dAtA []byte, err error) {
312 size := m.Size()
313 dAtA = make([]byte, size)
314 n, err := m.MarshalTo(dAtA)
315 if err != nil {
316 return nil, err
317 }
318 return dAtA[:n], nil
319}
320
321func (m *CertificateSigningRequestStatus) MarshalTo(dAtA []byte) (int, error) {
322 var i int
323 _ = i
324 var l int
325 _ = l
326 if len(m.Conditions) > 0 {
327 for _, msg := range m.Conditions {
328 dAtA[i] = 0xa
329 i++
330 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
331 n, err := msg.MarshalTo(dAtA[i:])
332 if err != nil {
333 return 0, err
334 }
335 i += n
336 }
337 }
338 if m.Certificate != nil {
339 dAtA[i] = 0x12
340 i++
341 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Certificate)))
342 i += copy(dAtA[i:], m.Certificate)
343 }
344 return i, nil
345}
346
347func (m ExtraValue) Marshal() (dAtA []byte, err error) {
348 size := m.Size()
349 dAtA = make([]byte, size)
350 n, err := m.MarshalTo(dAtA)
351 if err != nil {
352 return nil, err
353 }
354 return dAtA[:n], nil
355}
356
357func (m ExtraValue) MarshalTo(dAtA []byte) (int, error) {
358 var i int
359 _ = i
360 var l int
361 _ = l
362 if len(m) > 0 {
363 for _, s := range m {
364 dAtA[i] = 0xa
365 i++
366 l = len(s)
367 for l >= 1<<7 {
368 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
369 l >>= 7
370 i++
371 }
372 dAtA[i] = uint8(l)
373 i++
374 i += copy(dAtA[i:], s)
375 }
376 }
377 return i, nil
378}
379
380func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
381 for v >= 1<<7 {
382 dAtA[offset] = uint8(v&0x7f | 0x80)
383 v >>= 7
384 offset++
385 }
386 dAtA[offset] = uint8(v)
387 return offset + 1
388}
389func (m *CertificateSigningRequest) Size() (n int) {
390 var l int
391 _ = l
392 l = m.ObjectMeta.Size()
393 n += 1 + l + sovGenerated(uint64(l))
394 l = m.Spec.Size()
395 n += 1 + l + sovGenerated(uint64(l))
396 l = m.Status.Size()
397 n += 1 + l + sovGenerated(uint64(l))
398 return n
399}
400
401func (m *CertificateSigningRequestCondition) Size() (n int) {
402 var l int
403 _ = l
404 l = len(m.Type)
405 n += 1 + l + sovGenerated(uint64(l))
406 l = len(m.Reason)
407 n += 1 + l + sovGenerated(uint64(l))
408 l = len(m.Message)
409 n += 1 + l + sovGenerated(uint64(l))
410 l = m.LastUpdateTime.Size()
411 n += 1 + l + sovGenerated(uint64(l))
412 return n
413}
414
415func (m *CertificateSigningRequestList) Size() (n int) {
416 var l int
417 _ = l
418 l = m.ListMeta.Size()
419 n += 1 + l + sovGenerated(uint64(l))
420 if len(m.Items) > 0 {
421 for _, e := range m.Items {
422 l = e.Size()
423 n += 1 + l + sovGenerated(uint64(l))
424 }
425 }
426 return n
427}
428
429func (m *CertificateSigningRequestSpec) Size() (n int) {
430 var l int
431 _ = l
432 if m.Request != nil {
433 l = len(m.Request)
434 n += 1 + l + sovGenerated(uint64(l))
435 }
436 l = len(m.Username)
437 n += 1 + l + sovGenerated(uint64(l))
438 l = len(m.UID)
439 n += 1 + l + sovGenerated(uint64(l))
440 if len(m.Groups) > 0 {
441 for _, s := range m.Groups {
442 l = len(s)
443 n += 1 + l + sovGenerated(uint64(l))
444 }
445 }
446 if len(m.Usages) > 0 {
447 for _, s := range m.Usages {
448 l = len(s)
449 n += 1 + l + sovGenerated(uint64(l))
450 }
451 }
452 if len(m.Extra) > 0 {
453 for k, v := range m.Extra {
454 _ = k
455 _ = v
456 l = v.Size()
457 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
458 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
459 }
460 }
461 return n
462}
463
464func (m *CertificateSigningRequestStatus) Size() (n int) {
465 var l int
466 _ = l
467 if len(m.Conditions) > 0 {
468 for _, e := range m.Conditions {
469 l = e.Size()
470 n += 1 + l + sovGenerated(uint64(l))
471 }
472 }
473 if m.Certificate != nil {
474 l = len(m.Certificate)
475 n += 1 + l + sovGenerated(uint64(l))
476 }
477 return n
478}
479
480func (m ExtraValue) Size() (n int) {
481 var l int
482 _ = l
483 if len(m) > 0 {
484 for _, s := range m {
485 l = len(s)
486 n += 1 + l + sovGenerated(uint64(l))
487 }
488 }
489 return n
490}
491
492func sovGenerated(x uint64) (n int) {
493 for {
494 n++
495 x >>= 7
496 if x == 0 {
497 break
498 }
499 }
500 return n
501}
502func sozGenerated(x uint64) (n int) {
503 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
504}
505func (this *CertificateSigningRequest) String() string {
506 if this == nil {
507 return "nil"
508 }
509 s := strings.Join([]string{`&CertificateSigningRequest{`,
510 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
511 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CertificateSigningRequestSpec", "CertificateSigningRequestSpec", 1), `&`, ``, 1) + `,`,
512 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CertificateSigningRequestStatus", "CertificateSigningRequestStatus", 1), `&`, ``, 1) + `,`,
513 `}`,
514 }, "")
515 return s
516}
517func (this *CertificateSigningRequestCondition) String() string {
518 if this == nil {
519 return "nil"
520 }
521 s := strings.Join([]string{`&CertificateSigningRequestCondition{`,
522 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
523 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
524 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
525 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
526 `}`,
527 }, "")
528 return s
529}
530func (this *CertificateSigningRequestList) String() string {
531 if this == nil {
532 return "nil"
533 }
534 s := strings.Join([]string{`&CertificateSigningRequestList{`,
535 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
536 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "CertificateSigningRequest", "CertificateSigningRequest", 1), `&`, ``, 1) + `,`,
537 `}`,
538 }, "")
539 return s
540}
541func (this *CertificateSigningRequestSpec) String() string {
542 if this == nil {
543 return "nil"
544 }
545 keysForExtra := make([]string, 0, len(this.Extra))
546 for k := range this.Extra {
547 keysForExtra = append(keysForExtra, k)
548 }
549 github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
550 mapStringForExtra := "map[string]ExtraValue{"
551 for _, k := range keysForExtra {
552 mapStringForExtra += fmt.Sprintf("%v: %v,", k, this.Extra[k])
553 }
554 mapStringForExtra += "}"
555 s := strings.Join([]string{`&CertificateSigningRequestSpec{`,
556 `Request:` + valueToStringGenerated(this.Request) + `,`,
557 `Username:` + fmt.Sprintf("%v", this.Username) + `,`,
558 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
559 `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
560 `Usages:` + fmt.Sprintf("%v", this.Usages) + `,`,
561 `Extra:` + mapStringForExtra + `,`,
562 `}`,
563 }, "")
564 return s
565}
566func (this *CertificateSigningRequestStatus) String() string {
567 if this == nil {
568 return "nil"
569 }
570 s := strings.Join([]string{`&CertificateSigningRequestStatus{`,
571 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "CertificateSigningRequestCondition", "CertificateSigningRequestCondition", 1), `&`, ``, 1) + `,`,
572 `Certificate:` + valueToStringGenerated(this.Certificate) + `,`,
573 `}`,
574 }, "")
575 return s
576}
577func valueToStringGenerated(v interface{}) string {
578 rv := reflect.ValueOf(v)
579 if rv.IsNil() {
580 return "nil"
581 }
582 pv := reflect.Indirect(rv).Interface()
583 return fmt.Sprintf("*%v", pv)
584}
585func (m *CertificateSigningRequest) Unmarshal(dAtA []byte) error {
586 l := len(dAtA)
587 iNdEx := 0
588 for iNdEx < l {
589 preIndex := iNdEx
590 var wire uint64
591 for shift := uint(0); ; shift += 7 {
592 if shift >= 64 {
593 return ErrIntOverflowGenerated
594 }
595 if iNdEx >= l {
596 return io.ErrUnexpectedEOF
597 }
598 b := dAtA[iNdEx]
599 iNdEx++
600 wire |= (uint64(b) & 0x7F) << shift
601 if b < 0x80 {
602 break
603 }
604 }
605 fieldNum := int32(wire >> 3)
606 wireType := int(wire & 0x7)
607 if wireType == 4 {
608 return fmt.Errorf("proto: CertificateSigningRequest: wiretype end group for non-group")
609 }
610 if fieldNum <= 0 {
611 return fmt.Errorf("proto: CertificateSigningRequest: illegal tag %d (wire type %d)", fieldNum, wire)
612 }
613 switch fieldNum {
614 case 1:
615 if wireType != 2 {
616 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
617 }
618 var msglen int
619 for shift := uint(0); ; shift += 7 {
620 if shift >= 64 {
621 return ErrIntOverflowGenerated
622 }
623 if iNdEx >= l {
624 return io.ErrUnexpectedEOF
625 }
626 b := dAtA[iNdEx]
627 iNdEx++
628 msglen |= (int(b) & 0x7F) << shift
629 if b < 0x80 {
630 break
631 }
632 }
633 if msglen < 0 {
634 return ErrInvalidLengthGenerated
635 }
636 postIndex := iNdEx + msglen
637 if postIndex > l {
638 return io.ErrUnexpectedEOF
639 }
640 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
641 return err
642 }
643 iNdEx = postIndex
644 case 2:
645 if wireType != 2 {
646 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
647 }
648 var msglen int
649 for shift := uint(0); ; shift += 7 {
650 if shift >= 64 {
651 return ErrIntOverflowGenerated
652 }
653 if iNdEx >= l {
654 return io.ErrUnexpectedEOF
655 }
656 b := dAtA[iNdEx]
657 iNdEx++
658 msglen |= (int(b) & 0x7F) << shift
659 if b < 0x80 {
660 break
661 }
662 }
663 if msglen < 0 {
664 return ErrInvalidLengthGenerated
665 }
666 postIndex := iNdEx + msglen
667 if postIndex > l {
668 return io.ErrUnexpectedEOF
669 }
670 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
671 return err
672 }
673 iNdEx = postIndex
674 case 3:
675 if wireType != 2 {
676 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
677 }
678 var msglen int
679 for shift := uint(0); ; shift += 7 {
680 if shift >= 64 {
681 return ErrIntOverflowGenerated
682 }
683 if iNdEx >= l {
684 return io.ErrUnexpectedEOF
685 }
686 b := dAtA[iNdEx]
687 iNdEx++
688 msglen |= (int(b) & 0x7F) << shift
689 if b < 0x80 {
690 break
691 }
692 }
693 if msglen < 0 {
694 return ErrInvalidLengthGenerated
695 }
696 postIndex := iNdEx + msglen
697 if postIndex > l {
698 return io.ErrUnexpectedEOF
699 }
700 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
701 return err
702 }
703 iNdEx = postIndex
704 default:
705 iNdEx = preIndex
706 skippy, err := skipGenerated(dAtA[iNdEx:])
707 if err != nil {
708 return err
709 }
710 if skippy < 0 {
711 return ErrInvalidLengthGenerated
712 }
713 if (iNdEx + skippy) > l {
714 return io.ErrUnexpectedEOF
715 }
716 iNdEx += skippy
717 }
718 }
719
720 if iNdEx > l {
721 return io.ErrUnexpectedEOF
722 }
723 return nil
724}
725func (m *CertificateSigningRequestCondition) Unmarshal(dAtA []byte) error {
726 l := len(dAtA)
727 iNdEx := 0
728 for iNdEx < l {
729 preIndex := iNdEx
730 var wire uint64
731 for shift := uint(0); ; shift += 7 {
732 if shift >= 64 {
733 return ErrIntOverflowGenerated
734 }
735 if iNdEx >= l {
736 return io.ErrUnexpectedEOF
737 }
738 b := dAtA[iNdEx]
739 iNdEx++
740 wire |= (uint64(b) & 0x7F) << shift
741 if b < 0x80 {
742 break
743 }
744 }
745 fieldNum := int32(wire >> 3)
746 wireType := int(wire & 0x7)
747 if wireType == 4 {
748 return fmt.Errorf("proto: CertificateSigningRequestCondition: wiretype end group for non-group")
749 }
750 if fieldNum <= 0 {
751 return fmt.Errorf("proto: CertificateSigningRequestCondition: illegal tag %d (wire type %d)", fieldNum, wire)
752 }
753 switch fieldNum {
754 case 1:
755 if wireType != 2 {
756 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
757 }
758 var stringLen uint64
759 for shift := uint(0); ; shift += 7 {
760 if shift >= 64 {
761 return ErrIntOverflowGenerated
762 }
763 if iNdEx >= l {
764 return io.ErrUnexpectedEOF
765 }
766 b := dAtA[iNdEx]
767 iNdEx++
768 stringLen |= (uint64(b) & 0x7F) << shift
769 if b < 0x80 {
770 break
771 }
772 }
773 intStringLen := int(stringLen)
774 if intStringLen < 0 {
775 return ErrInvalidLengthGenerated
776 }
777 postIndex := iNdEx + intStringLen
778 if postIndex > l {
779 return io.ErrUnexpectedEOF
780 }
781 m.Type = RequestConditionType(dAtA[iNdEx:postIndex])
782 iNdEx = postIndex
783 case 2:
784 if wireType != 2 {
785 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
786 }
787 var stringLen uint64
788 for shift := uint(0); ; shift += 7 {
789 if shift >= 64 {
790 return ErrIntOverflowGenerated
791 }
792 if iNdEx >= l {
793 return io.ErrUnexpectedEOF
794 }
795 b := dAtA[iNdEx]
796 iNdEx++
797 stringLen |= (uint64(b) & 0x7F) << shift
798 if b < 0x80 {
799 break
800 }
801 }
802 intStringLen := int(stringLen)
803 if intStringLen < 0 {
804 return ErrInvalidLengthGenerated
805 }
806 postIndex := iNdEx + intStringLen
807 if postIndex > l {
808 return io.ErrUnexpectedEOF
809 }
810 m.Reason = string(dAtA[iNdEx:postIndex])
811 iNdEx = postIndex
812 case 3:
813 if wireType != 2 {
814 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
815 }
816 var stringLen uint64
817 for shift := uint(0); ; shift += 7 {
818 if shift >= 64 {
819 return ErrIntOverflowGenerated
820 }
821 if iNdEx >= l {
822 return io.ErrUnexpectedEOF
823 }
824 b := dAtA[iNdEx]
825 iNdEx++
826 stringLen |= (uint64(b) & 0x7F) << shift
827 if b < 0x80 {
828 break
829 }
830 }
831 intStringLen := int(stringLen)
832 if intStringLen < 0 {
833 return ErrInvalidLengthGenerated
834 }
835 postIndex := iNdEx + intStringLen
836 if postIndex > l {
837 return io.ErrUnexpectedEOF
838 }
839 m.Message = string(dAtA[iNdEx:postIndex])
840 iNdEx = postIndex
841 case 4:
842 if wireType != 2 {
843 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
844 }
845 var msglen int
846 for shift := uint(0); ; shift += 7 {
847 if shift >= 64 {
848 return ErrIntOverflowGenerated
849 }
850 if iNdEx >= l {
851 return io.ErrUnexpectedEOF
852 }
853 b := dAtA[iNdEx]
854 iNdEx++
855 msglen |= (int(b) & 0x7F) << shift
856 if b < 0x80 {
857 break
858 }
859 }
860 if msglen < 0 {
861 return ErrInvalidLengthGenerated
862 }
863 postIndex := iNdEx + msglen
864 if postIndex > l {
865 return io.ErrUnexpectedEOF
866 }
867 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
868 return err
869 }
870 iNdEx = postIndex
871 default:
872 iNdEx = preIndex
873 skippy, err := skipGenerated(dAtA[iNdEx:])
874 if err != nil {
875 return err
876 }
877 if skippy < 0 {
878 return ErrInvalidLengthGenerated
879 }
880 if (iNdEx + skippy) > l {
881 return io.ErrUnexpectedEOF
882 }
883 iNdEx += skippy
884 }
885 }
886
887 if iNdEx > l {
888 return io.ErrUnexpectedEOF
889 }
890 return nil
891}
892func (m *CertificateSigningRequestList) Unmarshal(dAtA []byte) error {
893 l := len(dAtA)
894 iNdEx := 0
895 for iNdEx < l {
896 preIndex := iNdEx
897 var wire uint64
898 for shift := uint(0); ; shift += 7 {
899 if shift >= 64 {
900 return ErrIntOverflowGenerated
901 }
902 if iNdEx >= l {
903 return io.ErrUnexpectedEOF
904 }
905 b := dAtA[iNdEx]
906 iNdEx++
907 wire |= (uint64(b) & 0x7F) << shift
908 if b < 0x80 {
909 break
910 }
911 }
912 fieldNum := int32(wire >> 3)
913 wireType := int(wire & 0x7)
914 if wireType == 4 {
915 return fmt.Errorf("proto: CertificateSigningRequestList: wiretype end group for non-group")
916 }
917 if fieldNum <= 0 {
918 return fmt.Errorf("proto: CertificateSigningRequestList: illegal tag %d (wire type %d)", fieldNum, wire)
919 }
920 switch fieldNum {
921 case 1:
922 if wireType != 2 {
923 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
924 }
925 var msglen int
926 for shift := uint(0); ; shift += 7 {
927 if shift >= 64 {
928 return ErrIntOverflowGenerated
929 }
930 if iNdEx >= l {
931 return io.ErrUnexpectedEOF
932 }
933 b := dAtA[iNdEx]
934 iNdEx++
935 msglen |= (int(b) & 0x7F) << shift
936 if b < 0x80 {
937 break
938 }
939 }
940 if msglen < 0 {
941 return ErrInvalidLengthGenerated
942 }
943 postIndex := iNdEx + msglen
944 if postIndex > l {
945 return io.ErrUnexpectedEOF
946 }
947 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
948 return err
949 }
950 iNdEx = postIndex
951 case 2:
952 if wireType != 2 {
953 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
954 }
955 var msglen int
956 for shift := uint(0); ; shift += 7 {
957 if shift >= 64 {
958 return ErrIntOverflowGenerated
959 }
960 if iNdEx >= l {
961 return io.ErrUnexpectedEOF
962 }
963 b := dAtA[iNdEx]
964 iNdEx++
965 msglen |= (int(b) & 0x7F) << shift
966 if b < 0x80 {
967 break
968 }
969 }
970 if msglen < 0 {
971 return ErrInvalidLengthGenerated
972 }
973 postIndex := iNdEx + msglen
974 if postIndex > l {
975 return io.ErrUnexpectedEOF
976 }
977 m.Items = append(m.Items, CertificateSigningRequest{})
978 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
979 return err
980 }
981 iNdEx = postIndex
982 default:
983 iNdEx = preIndex
984 skippy, err := skipGenerated(dAtA[iNdEx:])
985 if err != nil {
986 return err
987 }
988 if skippy < 0 {
989 return ErrInvalidLengthGenerated
990 }
991 if (iNdEx + skippy) > l {
992 return io.ErrUnexpectedEOF
993 }
994 iNdEx += skippy
995 }
996 }
997
998 if iNdEx > l {
999 return io.ErrUnexpectedEOF
1000 }
1001 return nil
1002}
1003func (m *CertificateSigningRequestSpec) Unmarshal(dAtA []byte) error {
1004 l := len(dAtA)
1005 iNdEx := 0
1006 for iNdEx < l {
1007 preIndex := iNdEx
1008 var wire uint64
1009 for shift := uint(0); ; shift += 7 {
1010 if shift >= 64 {
1011 return ErrIntOverflowGenerated
1012 }
1013 if iNdEx >= l {
1014 return io.ErrUnexpectedEOF
1015 }
1016 b := dAtA[iNdEx]
1017 iNdEx++
1018 wire |= (uint64(b) & 0x7F) << shift
1019 if b < 0x80 {
1020 break
1021 }
1022 }
1023 fieldNum := int32(wire >> 3)
1024 wireType := int(wire & 0x7)
1025 if wireType == 4 {
1026 return fmt.Errorf("proto: CertificateSigningRequestSpec: wiretype end group for non-group")
1027 }
1028 if fieldNum <= 0 {
1029 return fmt.Errorf("proto: CertificateSigningRequestSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1030 }
1031 switch fieldNum {
1032 case 1:
1033 if wireType != 2 {
1034 return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
1035 }
1036 var byteLen int
1037 for shift := uint(0); ; shift += 7 {
1038 if shift >= 64 {
1039 return ErrIntOverflowGenerated
1040 }
1041 if iNdEx >= l {
1042 return io.ErrUnexpectedEOF
1043 }
1044 b := dAtA[iNdEx]
1045 iNdEx++
1046 byteLen |= (int(b) & 0x7F) << shift
1047 if b < 0x80 {
1048 break
1049 }
1050 }
1051 if byteLen < 0 {
1052 return ErrInvalidLengthGenerated
1053 }
1054 postIndex := iNdEx + byteLen
1055 if postIndex > l {
1056 return io.ErrUnexpectedEOF
1057 }
1058 m.Request = append(m.Request[:0], dAtA[iNdEx:postIndex]...)
1059 if m.Request == nil {
1060 m.Request = []byte{}
1061 }
1062 iNdEx = postIndex
1063 case 2:
1064 if wireType != 2 {
1065 return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
1066 }
1067 var stringLen uint64
1068 for shift := uint(0); ; shift += 7 {
1069 if shift >= 64 {
1070 return ErrIntOverflowGenerated
1071 }
1072 if iNdEx >= l {
1073 return io.ErrUnexpectedEOF
1074 }
1075 b := dAtA[iNdEx]
1076 iNdEx++
1077 stringLen |= (uint64(b) & 0x7F) << shift
1078 if b < 0x80 {
1079 break
1080 }
1081 }
1082 intStringLen := int(stringLen)
1083 if intStringLen < 0 {
1084 return ErrInvalidLengthGenerated
1085 }
1086 postIndex := iNdEx + intStringLen
1087 if postIndex > l {
1088 return io.ErrUnexpectedEOF
1089 }
1090 m.Username = string(dAtA[iNdEx:postIndex])
1091 iNdEx = postIndex
1092 case 3:
1093 if wireType != 2 {
1094 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
1095 }
1096 var stringLen uint64
1097 for shift := uint(0); ; shift += 7 {
1098 if shift >= 64 {
1099 return ErrIntOverflowGenerated
1100 }
1101 if iNdEx >= l {
1102 return io.ErrUnexpectedEOF
1103 }
1104 b := dAtA[iNdEx]
1105 iNdEx++
1106 stringLen |= (uint64(b) & 0x7F) << shift
1107 if b < 0x80 {
1108 break
1109 }
1110 }
1111 intStringLen := int(stringLen)
1112 if intStringLen < 0 {
1113 return ErrInvalidLengthGenerated
1114 }
1115 postIndex := iNdEx + intStringLen
1116 if postIndex > l {
1117 return io.ErrUnexpectedEOF
1118 }
1119 m.UID = string(dAtA[iNdEx:postIndex])
1120 iNdEx = postIndex
1121 case 4:
1122 if wireType != 2 {
1123 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
1124 }
1125 var stringLen uint64
1126 for shift := uint(0); ; shift += 7 {
1127 if shift >= 64 {
1128 return ErrIntOverflowGenerated
1129 }
1130 if iNdEx >= l {
1131 return io.ErrUnexpectedEOF
1132 }
1133 b := dAtA[iNdEx]
1134 iNdEx++
1135 stringLen |= (uint64(b) & 0x7F) << shift
1136 if b < 0x80 {
1137 break
1138 }
1139 }
1140 intStringLen := int(stringLen)
1141 if intStringLen < 0 {
1142 return ErrInvalidLengthGenerated
1143 }
1144 postIndex := iNdEx + intStringLen
1145 if postIndex > l {
1146 return io.ErrUnexpectedEOF
1147 }
1148 m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
1149 iNdEx = postIndex
1150 case 5:
1151 if wireType != 2 {
1152 return fmt.Errorf("proto: wrong wireType = %d for field Usages", wireType)
1153 }
1154 var stringLen uint64
1155 for shift := uint(0); ; shift += 7 {
1156 if shift >= 64 {
1157 return ErrIntOverflowGenerated
1158 }
1159 if iNdEx >= l {
1160 return io.ErrUnexpectedEOF
1161 }
1162 b := dAtA[iNdEx]
1163 iNdEx++
1164 stringLen |= (uint64(b) & 0x7F) << shift
1165 if b < 0x80 {
1166 break
1167 }
1168 }
1169 intStringLen := int(stringLen)
1170 if intStringLen < 0 {
1171 return ErrInvalidLengthGenerated
1172 }
1173 postIndex := iNdEx + intStringLen
1174 if postIndex > l {
1175 return io.ErrUnexpectedEOF
1176 }
1177 m.Usages = append(m.Usages, KeyUsage(dAtA[iNdEx:postIndex]))
1178 iNdEx = postIndex
1179 case 6:
1180 if wireType != 2 {
1181 return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
1182 }
1183 var msglen int
1184 for shift := uint(0); ; shift += 7 {
1185 if shift >= 64 {
1186 return ErrIntOverflowGenerated
1187 }
1188 if iNdEx >= l {
1189 return io.ErrUnexpectedEOF
1190 }
1191 b := dAtA[iNdEx]
1192 iNdEx++
1193 msglen |= (int(b) & 0x7F) << shift
1194 if b < 0x80 {
1195 break
1196 }
1197 }
1198 if msglen < 0 {
1199 return ErrInvalidLengthGenerated
1200 }
1201 postIndex := iNdEx + msglen
1202 if postIndex > l {
1203 return io.ErrUnexpectedEOF
1204 }
1205 if m.Extra == nil {
1206 m.Extra = make(map[string]ExtraValue)
1207 }
1208 var mapkey string
1209 mapvalue := &ExtraValue{}
1210 for iNdEx < postIndex {
1211 entryPreIndex := iNdEx
1212 var wire uint64
1213 for shift := uint(0); ; shift += 7 {
1214 if shift >= 64 {
1215 return ErrIntOverflowGenerated
1216 }
1217 if iNdEx >= l {
1218 return io.ErrUnexpectedEOF
1219 }
1220 b := dAtA[iNdEx]
1221 iNdEx++
1222 wire |= (uint64(b) & 0x7F) << shift
1223 if b < 0x80 {
1224 break
1225 }
1226 }
1227 fieldNum := int32(wire >> 3)
1228 if fieldNum == 1 {
1229 var stringLenmapkey uint64
1230 for shift := uint(0); ; shift += 7 {
1231 if shift >= 64 {
1232 return ErrIntOverflowGenerated
1233 }
1234 if iNdEx >= l {
1235 return io.ErrUnexpectedEOF
1236 }
1237 b := dAtA[iNdEx]
1238 iNdEx++
1239 stringLenmapkey |= (uint64(b) & 0x7F) << shift
1240 if b < 0x80 {
1241 break
1242 }
1243 }
1244 intStringLenmapkey := int(stringLenmapkey)
1245 if intStringLenmapkey < 0 {
1246 return ErrInvalidLengthGenerated
1247 }
1248 postStringIndexmapkey := iNdEx + intStringLenmapkey
1249 if postStringIndexmapkey > l {
1250 return io.ErrUnexpectedEOF
1251 }
1252 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1253 iNdEx = postStringIndexmapkey
1254 } else if fieldNum == 2 {
1255 var mapmsglen int
1256 for shift := uint(0); ; shift += 7 {
1257 if shift >= 64 {
1258 return ErrIntOverflowGenerated
1259 }
1260 if iNdEx >= l {
1261 return io.ErrUnexpectedEOF
1262 }
1263 b := dAtA[iNdEx]
1264 iNdEx++
1265 mapmsglen |= (int(b) & 0x7F) << shift
1266 if b < 0x80 {
1267 break
1268 }
1269 }
1270 if mapmsglen < 0 {
1271 return ErrInvalidLengthGenerated
1272 }
1273 postmsgIndex := iNdEx + mapmsglen
1274 if mapmsglen < 0 {
1275 return ErrInvalidLengthGenerated
1276 }
1277 if postmsgIndex > l {
1278 return io.ErrUnexpectedEOF
1279 }
1280 mapvalue = &ExtraValue{}
1281 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
1282 return err
1283 }
1284 iNdEx = postmsgIndex
1285 } else {
1286 iNdEx = entryPreIndex
1287 skippy, err := skipGenerated(dAtA[iNdEx:])
1288 if err != nil {
1289 return err
1290 }
1291 if skippy < 0 {
1292 return ErrInvalidLengthGenerated
1293 }
1294 if (iNdEx + skippy) > postIndex {
1295 return io.ErrUnexpectedEOF
1296 }
1297 iNdEx += skippy
1298 }
1299 }
1300 m.Extra[mapkey] = *mapvalue
1301 iNdEx = postIndex
1302 default:
1303 iNdEx = preIndex
1304 skippy, err := skipGenerated(dAtA[iNdEx:])
1305 if err != nil {
1306 return err
1307 }
1308 if skippy < 0 {
1309 return ErrInvalidLengthGenerated
1310 }
1311 if (iNdEx + skippy) > l {
1312 return io.ErrUnexpectedEOF
1313 }
1314 iNdEx += skippy
1315 }
1316 }
1317
1318 if iNdEx > l {
1319 return io.ErrUnexpectedEOF
1320 }
1321 return nil
1322}
1323func (m *CertificateSigningRequestStatus) Unmarshal(dAtA []byte) error {
1324 l := len(dAtA)
1325 iNdEx := 0
1326 for iNdEx < l {
1327 preIndex := iNdEx
1328 var wire uint64
1329 for shift := uint(0); ; shift += 7 {
1330 if shift >= 64 {
1331 return ErrIntOverflowGenerated
1332 }
1333 if iNdEx >= l {
1334 return io.ErrUnexpectedEOF
1335 }
1336 b := dAtA[iNdEx]
1337 iNdEx++
1338 wire |= (uint64(b) & 0x7F) << shift
1339 if b < 0x80 {
1340 break
1341 }
1342 }
1343 fieldNum := int32(wire >> 3)
1344 wireType := int(wire & 0x7)
1345 if wireType == 4 {
1346 return fmt.Errorf("proto: CertificateSigningRequestStatus: wiretype end group for non-group")
1347 }
1348 if fieldNum <= 0 {
1349 return fmt.Errorf("proto: CertificateSigningRequestStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1350 }
1351 switch fieldNum {
1352 case 1:
1353 if wireType != 2 {
1354 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
1355 }
1356 var msglen int
1357 for shift := uint(0); ; shift += 7 {
1358 if shift >= 64 {
1359 return ErrIntOverflowGenerated
1360 }
1361 if iNdEx >= l {
1362 return io.ErrUnexpectedEOF
1363 }
1364 b := dAtA[iNdEx]
1365 iNdEx++
1366 msglen |= (int(b) & 0x7F) << shift
1367 if b < 0x80 {
1368 break
1369 }
1370 }
1371 if msglen < 0 {
1372 return ErrInvalidLengthGenerated
1373 }
1374 postIndex := iNdEx + msglen
1375 if postIndex > l {
1376 return io.ErrUnexpectedEOF
1377 }
1378 m.Conditions = append(m.Conditions, CertificateSigningRequestCondition{})
1379 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1380 return err
1381 }
1382 iNdEx = postIndex
1383 case 2:
1384 if wireType != 2 {
1385 return fmt.Errorf("proto: wrong wireType = %d for field Certificate", wireType)
1386 }
1387 var byteLen int
1388 for shift := uint(0); ; shift += 7 {
1389 if shift >= 64 {
1390 return ErrIntOverflowGenerated
1391 }
1392 if iNdEx >= l {
1393 return io.ErrUnexpectedEOF
1394 }
1395 b := dAtA[iNdEx]
1396 iNdEx++
1397 byteLen |= (int(b) & 0x7F) << shift
1398 if b < 0x80 {
1399 break
1400 }
1401 }
1402 if byteLen < 0 {
1403 return ErrInvalidLengthGenerated
1404 }
1405 postIndex := iNdEx + byteLen
1406 if postIndex > l {
1407 return io.ErrUnexpectedEOF
1408 }
1409 m.Certificate = append(m.Certificate[:0], dAtA[iNdEx:postIndex]...)
1410 if m.Certificate == nil {
1411 m.Certificate = []byte{}
1412 }
1413 iNdEx = postIndex
1414 default:
1415 iNdEx = preIndex
1416 skippy, err := skipGenerated(dAtA[iNdEx:])
1417 if err != nil {
1418 return err
1419 }
1420 if skippy < 0 {
1421 return ErrInvalidLengthGenerated
1422 }
1423 if (iNdEx + skippy) > l {
1424 return io.ErrUnexpectedEOF
1425 }
1426 iNdEx += skippy
1427 }
1428 }
1429
1430 if iNdEx > l {
1431 return io.ErrUnexpectedEOF
1432 }
1433 return nil
1434}
1435func (m *ExtraValue) Unmarshal(dAtA []byte) error {
1436 l := len(dAtA)
1437 iNdEx := 0
1438 for iNdEx < l {
1439 preIndex := iNdEx
1440 var wire uint64
1441 for shift := uint(0); ; shift += 7 {
1442 if shift >= 64 {
1443 return ErrIntOverflowGenerated
1444 }
1445 if iNdEx >= l {
1446 return io.ErrUnexpectedEOF
1447 }
1448 b := dAtA[iNdEx]
1449 iNdEx++
1450 wire |= (uint64(b) & 0x7F) << shift
1451 if b < 0x80 {
1452 break
1453 }
1454 }
1455 fieldNum := int32(wire >> 3)
1456 wireType := int(wire & 0x7)
1457 if wireType == 4 {
1458 return fmt.Errorf("proto: ExtraValue: wiretype end group for non-group")
1459 }
1460 if fieldNum <= 0 {
1461 return fmt.Errorf("proto: ExtraValue: illegal tag %d (wire type %d)", fieldNum, wire)
1462 }
1463 switch fieldNum {
1464 case 1:
1465 if wireType != 2 {
1466 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1467 }
1468 var stringLen uint64
1469 for shift := uint(0); ; shift += 7 {
1470 if shift >= 64 {
1471 return ErrIntOverflowGenerated
1472 }
1473 if iNdEx >= l {
1474 return io.ErrUnexpectedEOF
1475 }
1476 b := dAtA[iNdEx]
1477 iNdEx++
1478 stringLen |= (uint64(b) & 0x7F) << shift
1479 if b < 0x80 {
1480 break
1481 }
1482 }
1483 intStringLen := int(stringLen)
1484 if intStringLen < 0 {
1485 return ErrInvalidLengthGenerated
1486 }
1487 postIndex := iNdEx + intStringLen
1488 if postIndex > l {
1489 return io.ErrUnexpectedEOF
1490 }
1491 *m = append(*m, string(dAtA[iNdEx:postIndex]))
1492 iNdEx = postIndex
1493 default:
1494 iNdEx = preIndex
1495 skippy, err := skipGenerated(dAtA[iNdEx:])
1496 if err != nil {
1497 return err
1498 }
1499 if skippy < 0 {
1500 return ErrInvalidLengthGenerated
1501 }
1502 if (iNdEx + skippy) > l {
1503 return io.ErrUnexpectedEOF
1504 }
1505 iNdEx += skippy
1506 }
1507 }
1508
1509 if iNdEx > l {
1510 return io.ErrUnexpectedEOF
1511 }
1512 return nil
1513}
1514func skipGenerated(dAtA []byte) (n int, err error) {
1515 l := len(dAtA)
1516 iNdEx := 0
1517 for iNdEx < l {
1518 var wire uint64
1519 for shift := uint(0); ; shift += 7 {
1520 if shift >= 64 {
1521 return 0, ErrIntOverflowGenerated
1522 }
1523 if iNdEx >= l {
1524 return 0, io.ErrUnexpectedEOF
1525 }
1526 b := dAtA[iNdEx]
1527 iNdEx++
1528 wire |= (uint64(b) & 0x7F) << shift
1529 if b < 0x80 {
1530 break
1531 }
1532 }
1533 wireType := int(wire & 0x7)
1534 switch wireType {
1535 case 0:
1536 for shift := uint(0); ; shift += 7 {
1537 if shift >= 64 {
1538 return 0, ErrIntOverflowGenerated
1539 }
1540 if iNdEx >= l {
1541 return 0, io.ErrUnexpectedEOF
1542 }
1543 iNdEx++
1544 if dAtA[iNdEx-1] < 0x80 {
1545 break
1546 }
1547 }
1548 return iNdEx, nil
1549 case 1:
1550 iNdEx += 8
1551 return iNdEx, nil
1552 case 2:
1553 var length int
1554 for shift := uint(0); ; shift += 7 {
1555 if shift >= 64 {
1556 return 0, ErrIntOverflowGenerated
1557 }
1558 if iNdEx >= l {
1559 return 0, io.ErrUnexpectedEOF
1560 }
1561 b := dAtA[iNdEx]
1562 iNdEx++
1563 length |= (int(b) & 0x7F) << shift
1564 if b < 0x80 {
1565 break
1566 }
1567 }
1568 iNdEx += length
1569 if length < 0 {
1570 return 0, ErrInvalidLengthGenerated
1571 }
1572 return iNdEx, nil
1573 case 3:
1574 for {
1575 var innerWire uint64
1576 var start int = iNdEx
1577 for shift := uint(0); ; shift += 7 {
1578 if shift >= 64 {
1579 return 0, ErrIntOverflowGenerated
1580 }
1581 if iNdEx >= l {
1582 return 0, io.ErrUnexpectedEOF
1583 }
1584 b := dAtA[iNdEx]
1585 iNdEx++
1586 innerWire |= (uint64(b) & 0x7F) << shift
1587 if b < 0x80 {
1588 break
1589 }
1590 }
1591 innerWireType := int(innerWire & 0x7)
1592 if innerWireType == 4 {
1593 break
1594 }
1595 next, err := skipGenerated(dAtA[start:])
1596 if err != nil {
1597 return 0, err
1598 }
1599 iNdEx = start + next
1600 }
1601 return iNdEx, nil
1602 case 4:
1603 return iNdEx, nil
1604 case 5:
1605 iNdEx += 4
1606 return iNdEx, nil
1607 default:
1608 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1609 }
1610 }
1611 panic("unreachable")
1612}
1613
1614var (
1615 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1616 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1617)
1618
1619func init() {
1620 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/certificates/v1beta1/generated.proto", fileDescriptorGenerated)
1621}
1622
1623var fileDescriptorGenerated = []byte{
1624 // 804 bytes of a gzipped FileDescriptorProto
1625 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x8f, 0xdb, 0x44,
1626 0x18, 0x8e, 0xf3, 0xb5, 0xc9, 0x64, 0xd9, 0x56, 0x23, 0x54, 0x99, 0x95, 0x6a, 0xaf, 0x2c, 0x40,
1627 0xcb, 0x47, 0xc7, 0x6c, 0x85, 0x60, 0xb5, 0x07, 0x04, 0x5e, 0x2a, 0x58, 0xd1, 0x0a, 0x69, 0xda,
1628 0x70, 0x40, 0x48, 0x74, 0xe2, 0xbc, 0x75, 0xa6, 0xa9, 0x3f, 0xf0, 0x8c, 0x03, 0xb9, 0xf5, 0x27,
1629 0x70, 0xe4, 0x82, 0xc4, 0x2f, 0xe1, 0xbc, 0x1c, 0x90, 0x7a, 0xec, 0x01, 0x45, 0x6c, 0xf8, 0x17,
1630 0x3d, 0xa1, 0x19, 0x4f, 0xe2, 0x90, 0x55, 0x48, 0xd5, 0xbd, 0x79, 0x9e, 0xf7, 0x79, 0x9e, 0xf7,
1631 0x63, 0xde, 0x31, 0xfa, 0x72, 0x7c, 0x2c, 0x08, 0x4f, 0xfd, 0x71, 0x31, 0x80, 0x3c, 0x01, 0x09,
1632 0xc2, 0x9f, 0x40, 0x32, 0x4c, 0x73, 0xdf, 0x04, 0x58, 0xc6, 0xfd, 0x10, 0x72, 0xc9, 0x1f, 0xf1,
1633 0x90, 0xe9, 0xf0, 0xd1, 0x00, 0x24, 0x3b, 0xf2, 0x23, 0x48, 0x20, 0x67, 0x12, 0x86, 0x24, 0xcb,
1634 0x53, 0x99, 0x62, 0xb7, 0x14, 0x10, 0x96, 0x71, 0xb2, 0x2a, 0x20, 0x46, 0xb0, 0x7f, 0x2b, 0xe2,
1635 0x72, 0x54, 0x0c, 0x48, 0x98, 0xc6, 0x7e, 0x94, 0x46, 0xa9, 0xaf, 0x75, 0x83, 0xe2, 0x91, 0x3e,
1636 0xe9, 0x83, 0xfe, 0x2a, 0xfd, 0xf6, 0x3f, 0xac, 0x0a, 0x88, 0x59, 0x38, 0xe2, 0x09, 0xe4, 0x53,
1637 0x3f, 0x1b, 0x47, 0x0a, 0x10, 0x7e, 0x0c, 0x92, 0xf9, 0x93, 0x4b, 0x55, 0xec, 0xfb, 0x9b, 0x54,
1638 0x79, 0x91, 0x48, 0x1e, 0xc3, 0x25, 0xc1, 0x47, 0xdb, 0x04, 0x22, 0x1c, 0x41, 0xcc, 0xd6, 0x75,
1639 0xde, 0x1f, 0x75, 0xf4, 0xc6, 0x69, 0xd5, 0xe6, 0x7d, 0x1e, 0x25, 0x3c, 0x89, 0x28, 0xfc, 0x50,
1640 0x80, 0x90, 0xf8, 0x21, 0xea, 0xa8, 0x0a, 0x87, 0x4c, 0x32, 0xdb, 0x3a, 0xb0, 0x0e, 0x7b, 0xb7,
1641 0x3f, 0x20, 0xd5, 0x7c, 0x96, 0x89, 0x48, 0x36, 0x8e, 0x14, 0x20, 0x88, 0x62, 0x93, 0xc9, 0x11,
1642 0xf9, 0x7a, 0xf0, 0x18, 0x42, 0x79, 0x0f, 0x24, 0x0b, 0xf0, 0xf9, 0xcc, 0xad, 0xcd, 0x67, 0x2e,
1643 0xaa, 0x30, 0xba, 0x74, 0xc5, 0x0f, 0x51, 0x53, 0x64, 0x10, 0xda, 0x75, 0xed, 0xfe, 0x09, 0xd9,
1644 0x32, 0x7d, 0xb2, 0xb1, 0xd6, 0xfb, 0x19, 0x84, 0xc1, 0xae, 0xc9, 0xd5, 0x54, 0x27, 0xaa, 0x9d,
1645 0xf1, 0x08, 0xb5, 0x85, 0x64, 0xb2, 0x10, 0x76, 0x43, 0xe7, 0xf8, 0xf4, 0x0a, 0x39, 0xb4, 0x4f,
1646 0xb0, 0x67, 0xb2, 0xb4, 0xcb, 0x33, 0x35, 0xfe, 0xde, 0xaf, 0x75, 0xe4, 0x6d, 0xd4, 0x9e, 0xa6,
1647 0xc9, 0x90, 0x4b, 0x9e, 0x26, 0xf8, 0x18, 0x35, 0xe5, 0x34, 0x03, 0x3d, 0xd0, 0x6e, 0xf0, 0xe6,
1648 0xa2, 0xe4, 0x07, 0xd3, 0x0c, 0x5e, 0xcc, 0xdc, 0xd7, 0xd7, 0xf9, 0x0a, 0xa7, 0x5a, 0x81, 0xdf,
1649 0x46, 0xed, 0x1c, 0x98, 0x48, 0x13, 0x3d, 0xae, 0x6e, 0x55, 0x08, 0xd5, 0x28, 0x35, 0x51, 0xfc,
1650 0x0e, 0xda, 0x89, 0x41, 0x08, 0x16, 0x81, 0xee, 0xb9, 0x1b, 0x5c, 0x33, 0xc4, 0x9d, 0x7b, 0x25,
1651 0x4c, 0x17, 0x71, 0xfc, 0x18, 0xed, 0x3d, 0x61, 0x42, 0xf6, 0xb3, 0x21, 0x93, 0xf0, 0x80, 0xc7,
1652 0x60, 0x37, 0xf5, 0x94, 0xde, 0x7d, 0xb9, 0x7b, 0x56, 0x8a, 0xe0, 0x86, 0x71, 0xdf, 0xbb, 0xfb,
1653 0x1f, 0x27, 0xba, 0xe6, 0xec, 0xcd, 0x2c, 0x74, 0x73, 0xe3, 0x7c, 0xee, 0x72, 0x21, 0xf1, 0x77,
1654 0x97, 0xf6, 0x8d, 0xbc, 0x5c, 0x1d, 0x4a, 0xad, 0xb7, 0xed, 0xba, 0xa9, 0xa5, 0xb3, 0x40, 0x56,
1655 0x76, 0xed, 0x7b, 0xd4, 0xe2, 0x12, 0x62, 0x61, 0xd7, 0x0f, 0x1a, 0x87, 0xbd, 0xdb, 0x27, 0xaf,
1656 0xbe, 0x08, 0xc1, 0x6b, 0x26, 0x4d, 0xeb, 0x4c, 0x19, 0xd2, 0xd2, 0xd7, 0xfb, 0xbd, 0xf1, 0x3f,
1657 0x0d, 0xaa, 0x95, 0xc4, 0x6f, 0xa1, 0x9d, 0xbc, 0x3c, 0xea, 0xfe, 0x76, 0x83, 0x9e, 0xba, 0x15,
1658 0xc3, 0xa0, 0x8b, 0x18, 0x7e, 0x1f, 0x75, 0x0a, 0x01, 0x79, 0xc2, 0x62, 0x30, 0x57, 0xbd, 0xec,
1659 0xab, 0x6f, 0x70, 0xba, 0x64, 0xe0, 0x9b, 0xa8, 0x51, 0xf0, 0xa1, 0xb9, 0xea, 0x9e, 0x21, 0x36,
1660 0xfa, 0x67, 0x9f, 0x53, 0x85, 0x63, 0x0f, 0xb5, 0xa3, 0x3c, 0x2d, 0x32, 0x61, 0x37, 0x0f, 0x1a,
1661 0x87, 0xdd, 0x00, 0xa9, 0x8d, 0xf9, 0x42, 0x23, 0xd4, 0x44, 0x30, 0x41, 0xed, 0x42, 0xed, 0x83,
1662 0xb0, 0x5b, 0x9a, 0x73, 0x43, 0x71, 0xfa, 0x1a, 0x79, 0x31, 0x73, 0x3b, 0x5f, 0xc1, 0x54, 0x1f,
1663 0xa8, 0x61, 0xe1, 0x04, 0xb5, 0xe0, 0x27, 0x99, 0x33, 0xbb, 0xad, 0x47, 0x79, 0x76, 0xb5, 0x77,
1664 0x4b, 0xee, 0x28, 0xaf, 0x3b, 0x89, 0xcc, 0xa7, 0xd5, 0x64, 0x35, 0x46, 0xcb, 0x34, 0xfb, 0x80,
1665 0x50, 0xc5, 0xc1, 0xd7, 0x51, 0x63, 0x0c, 0xd3, 0xf2, 0x01, 0x51, 0xf5, 0x89, 0x3f, 0x43, 0xad,
1666 0x09, 0x7b, 0x52, 0x80, 0xf9, 0x8f, 0xbc, 0xb7, 0xb5, 0x1e, 0xed, 0xf6, 0x8d, 0x92, 0xd0, 0x52,
1667 0x79, 0x52, 0x3f, 0xb6, 0xbc, 0x3f, 0x2d, 0xe4, 0x6e, 0x79, 0xfd, 0xf8, 0x47, 0x84, 0xc2, 0xc5,
1668 0xdb, 0x14, 0xb6, 0xa5, 0xfb, 0x3f, 0x7d, 0xf5, 0xfe, 0x97, 0xef, 0xbc, 0xfa, 0x51, 0x2e, 0x21,
1669 0x41, 0x57, 0x52, 0xe1, 0x23, 0xd4, 0x5b, 0xb1, 0xd6, 0x9d, 0xee, 0x06, 0xd7, 0xe6, 0x33, 0xb7,
1670 0xb7, 0x62, 0x4e, 0x57, 0x39, 0xde, 0xc7, 0x66, 0x6c, 0xba, 0x51, 0xec, 0x2e, 0xf6, 0xdf, 0xd2,
1671 0x77, 0xdc, 0x5d, 0xdf, 0xdf, 0x93, 0xce, 0x2f, 0xbf, 0xb9, 0xb5, 0xa7, 0x7f, 0x1d, 0xd4, 0x82,
1672 0x5b, 0xe7, 0x17, 0x4e, 0xed, 0xd9, 0x85, 0x53, 0x7b, 0x7e, 0xe1, 0xd4, 0x9e, 0xce, 0x1d, 0xeb,
1673 0x7c, 0xee, 0x58, 0xcf, 0xe6, 0x8e, 0xf5, 0x7c, 0xee, 0x58, 0x7f, 0xcf, 0x1d, 0xeb, 0xe7, 0x7f,
1674 0x9c, 0xda, 0xb7, 0x3b, 0xa6, 0xbb, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xb7, 0x6b, 0x5b, 0xf9,
1675 0x7f, 0x07, 0x00, 0x00,
1676}