blob: 03040aa5a5541bdab796aeb74775c39e8a5c1b4a [file] [log] [blame]
Zack Williamse940c7a2019-08-21 14:25:39 -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/authorization/v1/generated.proto
19
20/*
21 Package v1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/api/authorization/v1/generated.proto
25
26 It has these top-level messages:
27 ExtraValue
28 LocalSubjectAccessReview
29 NonResourceAttributes
30 NonResourceRule
31 ResourceAttributes
32 ResourceRule
33 SelfSubjectAccessReview
34 SelfSubjectAccessReviewSpec
35 SelfSubjectRulesReview
36 SelfSubjectRulesReviewSpec
37 SubjectAccessReview
38 SubjectAccessReviewSpec
39 SubjectAccessReviewStatus
40 SubjectRulesReviewStatus
41*/
42package v1
43
Scott Baker4a35a702019-11-26 08:17:33 -080044import (
45 fmt "fmt"
Zack Williamse940c7a2019-08-21 14:25:39 -070046
Scott Baker4a35a702019-11-26 08:17:33 -080047 proto "github.com/gogo/protobuf/proto"
Zack Williamse940c7a2019-08-21 14:25:39 -070048
Scott Baker4a35a702019-11-26 08:17:33 -080049 math "math"
Zack Williamse940c7a2019-08-21 14:25:39 -070050
Scott Baker4a35a702019-11-26 08:17:33 -080051 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
52
53 strings "strings"
54
55 reflect "reflect"
56
57 io "io"
58)
Zack Williamse940c7a2019-08-21 14:25:39 -070059
60// Reference imports to suppress errors if they are not otherwise used.
61var _ = proto.Marshal
62var _ = fmt.Errorf
63var _ = math.Inf
64
65// This is a compile-time assertion to ensure that this generated file
66// is compatible with the proto package it is being compiled against.
67// A compilation error at this line likely means your copy of the
68// proto package needs to be updated.
69const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
70
71func (m *ExtraValue) Reset() { *m = ExtraValue{} }
72func (*ExtraValue) ProtoMessage() {}
73func (*ExtraValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
74
75func (m *LocalSubjectAccessReview) Reset() { *m = LocalSubjectAccessReview{} }
76func (*LocalSubjectAccessReview) ProtoMessage() {}
77func (*LocalSubjectAccessReview) Descriptor() ([]byte, []int) {
78 return fileDescriptorGenerated, []int{1}
79}
80
81func (m *NonResourceAttributes) Reset() { *m = NonResourceAttributes{} }
82func (*NonResourceAttributes) ProtoMessage() {}
83func (*NonResourceAttributes) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
84
85func (m *NonResourceRule) Reset() { *m = NonResourceRule{} }
86func (*NonResourceRule) ProtoMessage() {}
87func (*NonResourceRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
88
89func (m *ResourceAttributes) Reset() { *m = ResourceAttributes{} }
90func (*ResourceAttributes) ProtoMessage() {}
91func (*ResourceAttributes) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
92
93func (m *ResourceRule) Reset() { *m = ResourceRule{} }
94func (*ResourceRule) ProtoMessage() {}
95func (*ResourceRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
96
97func (m *SelfSubjectAccessReview) Reset() { *m = SelfSubjectAccessReview{} }
98func (*SelfSubjectAccessReview) ProtoMessage() {}
99func (*SelfSubjectAccessReview) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
100
101func (m *SelfSubjectAccessReviewSpec) Reset() { *m = SelfSubjectAccessReviewSpec{} }
102func (*SelfSubjectAccessReviewSpec) ProtoMessage() {}
103func (*SelfSubjectAccessReviewSpec) Descriptor() ([]byte, []int) {
104 return fileDescriptorGenerated, []int{7}
105}
106
107func (m *SelfSubjectRulesReview) Reset() { *m = SelfSubjectRulesReview{} }
108func (*SelfSubjectRulesReview) ProtoMessage() {}
109func (*SelfSubjectRulesReview) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
110
111func (m *SelfSubjectRulesReviewSpec) Reset() { *m = SelfSubjectRulesReviewSpec{} }
112func (*SelfSubjectRulesReviewSpec) ProtoMessage() {}
113func (*SelfSubjectRulesReviewSpec) Descriptor() ([]byte, []int) {
114 return fileDescriptorGenerated, []int{9}
115}
116
117func (m *SubjectAccessReview) Reset() { *m = SubjectAccessReview{} }
118func (*SubjectAccessReview) ProtoMessage() {}
119func (*SubjectAccessReview) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
120
121func (m *SubjectAccessReviewSpec) Reset() { *m = SubjectAccessReviewSpec{} }
122func (*SubjectAccessReviewSpec) ProtoMessage() {}
123func (*SubjectAccessReviewSpec) Descriptor() ([]byte, []int) {
124 return fileDescriptorGenerated, []int{11}
125}
126
127func (m *SubjectAccessReviewStatus) Reset() { *m = SubjectAccessReviewStatus{} }
128func (*SubjectAccessReviewStatus) ProtoMessage() {}
129func (*SubjectAccessReviewStatus) Descriptor() ([]byte, []int) {
130 return fileDescriptorGenerated, []int{12}
131}
132
133func (m *SubjectRulesReviewStatus) Reset() { *m = SubjectRulesReviewStatus{} }
134func (*SubjectRulesReviewStatus) ProtoMessage() {}
135func (*SubjectRulesReviewStatus) Descriptor() ([]byte, []int) {
136 return fileDescriptorGenerated, []int{13}
137}
138
139func init() {
140 proto.RegisterType((*ExtraValue)(nil), "k8s.io.api.authorization.v1.ExtraValue")
141 proto.RegisterType((*LocalSubjectAccessReview)(nil), "k8s.io.api.authorization.v1.LocalSubjectAccessReview")
142 proto.RegisterType((*NonResourceAttributes)(nil), "k8s.io.api.authorization.v1.NonResourceAttributes")
143 proto.RegisterType((*NonResourceRule)(nil), "k8s.io.api.authorization.v1.NonResourceRule")
144 proto.RegisterType((*ResourceAttributes)(nil), "k8s.io.api.authorization.v1.ResourceAttributes")
145 proto.RegisterType((*ResourceRule)(nil), "k8s.io.api.authorization.v1.ResourceRule")
146 proto.RegisterType((*SelfSubjectAccessReview)(nil), "k8s.io.api.authorization.v1.SelfSubjectAccessReview")
147 proto.RegisterType((*SelfSubjectAccessReviewSpec)(nil), "k8s.io.api.authorization.v1.SelfSubjectAccessReviewSpec")
148 proto.RegisterType((*SelfSubjectRulesReview)(nil), "k8s.io.api.authorization.v1.SelfSubjectRulesReview")
149 proto.RegisterType((*SelfSubjectRulesReviewSpec)(nil), "k8s.io.api.authorization.v1.SelfSubjectRulesReviewSpec")
150 proto.RegisterType((*SubjectAccessReview)(nil), "k8s.io.api.authorization.v1.SubjectAccessReview")
151 proto.RegisterType((*SubjectAccessReviewSpec)(nil), "k8s.io.api.authorization.v1.SubjectAccessReviewSpec")
152 proto.RegisterType((*SubjectAccessReviewStatus)(nil), "k8s.io.api.authorization.v1.SubjectAccessReviewStatus")
153 proto.RegisterType((*SubjectRulesReviewStatus)(nil), "k8s.io.api.authorization.v1.SubjectRulesReviewStatus")
154}
155func (m ExtraValue) Marshal() (dAtA []byte, err error) {
156 size := m.Size()
157 dAtA = make([]byte, size)
158 n, err := m.MarshalTo(dAtA)
159 if err != nil {
160 return nil, err
161 }
162 return dAtA[:n], nil
163}
164
165func (m ExtraValue) MarshalTo(dAtA []byte) (int, error) {
166 var i int
167 _ = i
168 var l int
169 _ = l
170 if len(m) > 0 {
171 for _, s := range m {
172 dAtA[i] = 0xa
173 i++
174 l = len(s)
175 for l >= 1<<7 {
176 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
177 l >>= 7
178 i++
179 }
180 dAtA[i] = uint8(l)
181 i++
182 i += copy(dAtA[i:], s)
183 }
184 }
185 return i, nil
186}
187
188func (m *LocalSubjectAccessReview) Marshal() (dAtA []byte, err error) {
189 size := m.Size()
190 dAtA = make([]byte, size)
191 n, err := m.MarshalTo(dAtA)
192 if err != nil {
193 return nil, err
194 }
195 return dAtA[:n], nil
196}
197
198func (m *LocalSubjectAccessReview) MarshalTo(dAtA []byte) (int, error) {
199 var i int
200 _ = i
201 var l int
202 _ = l
203 dAtA[i] = 0xa
204 i++
205 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
206 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
207 if err != nil {
208 return 0, err
209 }
210 i += n1
211 dAtA[i] = 0x12
212 i++
213 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
214 n2, err := m.Spec.MarshalTo(dAtA[i:])
215 if err != nil {
216 return 0, err
217 }
218 i += n2
219 dAtA[i] = 0x1a
220 i++
221 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
222 n3, err := m.Status.MarshalTo(dAtA[i:])
223 if err != nil {
224 return 0, err
225 }
226 i += n3
227 return i, nil
228}
229
230func (m *NonResourceAttributes) Marshal() (dAtA []byte, err error) {
231 size := m.Size()
232 dAtA = make([]byte, size)
233 n, err := m.MarshalTo(dAtA)
234 if err != nil {
235 return nil, err
236 }
237 return dAtA[:n], nil
238}
239
240func (m *NonResourceAttributes) MarshalTo(dAtA []byte) (int, error) {
241 var i int
242 _ = i
243 var l int
244 _ = l
245 dAtA[i] = 0xa
246 i++
247 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
248 i += copy(dAtA[i:], m.Path)
249 dAtA[i] = 0x12
250 i++
251 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verb)))
252 i += copy(dAtA[i:], m.Verb)
253 return i, nil
254}
255
256func (m *NonResourceRule) Marshal() (dAtA []byte, err error) {
257 size := m.Size()
258 dAtA = make([]byte, size)
259 n, err := m.MarshalTo(dAtA)
260 if err != nil {
261 return nil, err
262 }
263 return dAtA[:n], nil
264}
265
266func (m *NonResourceRule) MarshalTo(dAtA []byte) (int, error) {
267 var i int
268 _ = i
269 var l int
270 _ = l
271 if len(m.Verbs) > 0 {
272 for _, s := range m.Verbs {
273 dAtA[i] = 0xa
274 i++
275 l = len(s)
276 for l >= 1<<7 {
277 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
278 l >>= 7
279 i++
280 }
281 dAtA[i] = uint8(l)
282 i++
283 i += copy(dAtA[i:], s)
284 }
285 }
286 if len(m.NonResourceURLs) > 0 {
287 for _, s := range m.NonResourceURLs {
288 dAtA[i] = 0x12
289 i++
290 l = len(s)
291 for l >= 1<<7 {
292 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
293 l >>= 7
294 i++
295 }
296 dAtA[i] = uint8(l)
297 i++
298 i += copy(dAtA[i:], s)
299 }
300 }
301 return i, nil
302}
303
304func (m *ResourceAttributes) Marshal() (dAtA []byte, err error) {
305 size := m.Size()
306 dAtA = make([]byte, size)
307 n, err := m.MarshalTo(dAtA)
308 if err != nil {
309 return nil, err
310 }
311 return dAtA[:n], nil
312}
313
314func (m *ResourceAttributes) MarshalTo(dAtA []byte) (int, error) {
315 var i int
316 _ = i
317 var l int
318 _ = l
319 dAtA[i] = 0xa
320 i++
321 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
322 i += copy(dAtA[i:], m.Namespace)
323 dAtA[i] = 0x12
324 i++
325 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verb)))
326 i += copy(dAtA[i:], m.Verb)
327 dAtA[i] = 0x1a
328 i++
329 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
330 i += copy(dAtA[i:], m.Group)
331 dAtA[i] = 0x22
332 i++
333 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
334 i += copy(dAtA[i:], m.Version)
335 dAtA[i] = 0x2a
336 i++
337 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
338 i += copy(dAtA[i:], m.Resource)
339 dAtA[i] = 0x32
340 i++
341 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subresource)))
342 i += copy(dAtA[i:], m.Subresource)
343 dAtA[i] = 0x3a
344 i++
345 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
346 i += copy(dAtA[i:], m.Name)
347 return i, nil
348}
349
350func (m *ResourceRule) Marshal() (dAtA []byte, err error) {
351 size := m.Size()
352 dAtA = make([]byte, size)
353 n, err := m.MarshalTo(dAtA)
354 if err != nil {
355 return nil, err
356 }
357 return dAtA[:n], nil
358}
359
360func (m *ResourceRule) MarshalTo(dAtA []byte) (int, error) {
361 var i int
362 _ = i
363 var l int
364 _ = l
365 if len(m.Verbs) > 0 {
366 for _, s := range m.Verbs {
367 dAtA[i] = 0xa
368 i++
369 l = len(s)
370 for l >= 1<<7 {
371 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
372 l >>= 7
373 i++
374 }
375 dAtA[i] = uint8(l)
376 i++
377 i += copy(dAtA[i:], s)
378 }
379 }
380 if len(m.APIGroups) > 0 {
381 for _, s := range m.APIGroups {
382 dAtA[i] = 0x12
383 i++
384 l = len(s)
385 for l >= 1<<7 {
386 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
387 l >>= 7
388 i++
389 }
390 dAtA[i] = uint8(l)
391 i++
392 i += copy(dAtA[i:], s)
393 }
394 }
395 if len(m.Resources) > 0 {
396 for _, s := range m.Resources {
397 dAtA[i] = 0x1a
398 i++
399 l = len(s)
400 for l >= 1<<7 {
401 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
402 l >>= 7
403 i++
404 }
405 dAtA[i] = uint8(l)
406 i++
407 i += copy(dAtA[i:], s)
408 }
409 }
410 if len(m.ResourceNames) > 0 {
411 for _, s := range m.ResourceNames {
412 dAtA[i] = 0x22
413 i++
414 l = len(s)
415 for l >= 1<<7 {
416 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
417 l >>= 7
418 i++
419 }
420 dAtA[i] = uint8(l)
421 i++
422 i += copy(dAtA[i:], s)
423 }
424 }
425 return i, nil
426}
427
428func (m *SelfSubjectAccessReview) Marshal() (dAtA []byte, err error) {
429 size := m.Size()
430 dAtA = make([]byte, size)
431 n, err := m.MarshalTo(dAtA)
432 if err != nil {
433 return nil, err
434 }
435 return dAtA[:n], nil
436}
437
438func (m *SelfSubjectAccessReview) MarshalTo(dAtA []byte) (int, error) {
439 var i int
440 _ = i
441 var l int
442 _ = l
443 dAtA[i] = 0xa
444 i++
445 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
446 n4, err := m.ObjectMeta.MarshalTo(dAtA[i:])
447 if err != nil {
448 return 0, err
449 }
450 i += n4
451 dAtA[i] = 0x12
452 i++
453 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
454 n5, err := m.Spec.MarshalTo(dAtA[i:])
455 if err != nil {
456 return 0, err
457 }
458 i += n5
459 dAtA[i] = 0x1a
460 i++
461 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
462 n6, err := m.Status.MarshalTo(dAtA[i:])
463 if err != nil {
464 return 0, err
465 }
466 i += n6
467 return i, nil
468}
469
470func (m *SelfSubjectAccessReviewSpec) Marshal() (dAtA []byte, err error) {
471 size := m.Size()
472 dAtA = make([]byte, size)
473 n, err := m.MarshalTo(dAtA)
474 if err != nil {
475 return nil, err
476 }
477 return dAtA[:n], nil
478}
479
480func (m *SelfSubjectAccessReviewSpec) MarshalTo(dAtA []byte) (int, error) {
481 var i int
482 _ = i
483 var l int
484 _ = l
485 if m.ResourceAttributes != nil {
486 dAtA[i] = 0xa
487 i++
488 i = encodeVarintGenerated(dAtA, i, uint64(m.ResourceAttributes.Size()))
489 n7, err := m.ResourceAttributes.MarshalTo(dAtA[i:])
490 if err != nil {
491 return 0, err
492 }
493 i += n7
494 }
495 if m.NonResourceAttributes != nil {
496 dAtA[i] = 0x12
497 i++
498 i = encodeVarintGenerated(dAtA, i, uint64(m.NonResourceAttributes.Size()))
499 n8, err := m.NonResourceAttributes.MarshalTo(dAtA[i:])
500 if err != nil {
501 return 0, err
502 }
503 i += n8
504 }
505 return i, nil
506}
507
508func (m *SelfSubjectRulesReview) Marshal() (dAtA []byte, err error) {
509 size := m.Size()
510 dAtA = make([]byte, size)
511 n, err := m.MarshalTo(dAtA)
512 if err != nil {
513 return nil, err
514 }
515 return dAtA[:n], nil
516}
517
518func (m *SelfSubjectRulesReview) MarshalTo(dAtA []byte) (int, error) {
519 var i int
520 _ = i
521 var l int
522 _ = l
523 dAtA[i] = 0xa
524 i++
525 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
526 n9, err := m.ObjectMeta.MarshalTo(dAtA[i:])
527 if err != nil {
528 return 0, err
529 }
530 i += n9
531 dAtA[i] = 0x12
532 i++
533 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
534 n10, err := m.Spec.MarshalTo(dAtA[i:])
535 if err != nil {
536 return 0, err
537 }
538 i += n10
539 dAtA[i] = 0x1a
540 i++
541 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
542 n11, err := m.Status.MarshalTo(dAtA[i:])
543 if err != nil {
544 return 0, err
545 }
546 i += n11
547 return i, nil
548}
549
550func (m *SelfSubjectRulesReviewSpec) Marshal() (dAtA []byte, err error) {
551 size := m.Size()
552 dAtA = make([]byte, size)
553 n, err := m.MarshalTo(dAtA)
554 if err != nil {
555 return nil, err
556 }
557 return dAtA[:n], nil
558}
559
560func (m *SelfSubjectRulesReviewSpec) MarshalTo(dAtA []byte) (int, error) {
561 var i int
562 _ = i
563 var l int
564 _ = l
565 dAtA[i] = 0xa
566 i++
567 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
568 i += copy(dAtA[i:], m.Namespace)
569 return i, nil
570}
571
572func (m *SubjectAccessReview) Marshal() (dAtA []byte, err error) {
573 size := m.Size()
574 dAtA = make([]byte, size)
575 n, err := m.MarshalTo(dAtA)
576 if err != nil {
577 return nil, err
578 }
579 return dAtA[:n], nil
580}
581
582func (m *SubjectAccessReview) MarshalTo(dAtA []byte) (int, error) {
583 var i int
584 _ = i
585 var l int
586 _ = l
587 dAtA[i] = 0xa
588 i++
589 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
590 n12, err := m.ObjectMeta.MarshalTo(dAtA[i:])
591 if err != nil {
592 return 0, err
593 }
594 i += n12
595 dAtA[i] = 0x12
596 i++
597 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
598 n13, err := m.Spec.MarshalTo(dAtA[i:])
599 if err != nil {
600 return 0, err
601 }
602 i += n13
603 dAtA[i] = 0x1a
604 i++
605 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
606 n14, err := m.Status.MarshalTo(dAtA[i:])
607 if err != nil {
608 return 0, err
609 }
610 i += n14
611 return i, nil
612}
613
614func (m *SubjectAccessReviewSpec) Marshal() (dAtA []byte, err error) {
615 size := m.Size()
616 dAtA = make([]byte, size)
617 n, err := m.MarshalTo(dAtA)
618 if err != nil {
619 return nil, err
620 }
621 return dAtA[:n], nil
622}
623
624func (m *SubjectAccessReviewSpec) MarshalTo(dAtA []byte) (int, error) {
625 var i int
626 _ = i
627 var l int
628 _ = l
629 if m.ResourceAttributes != nil {
630 dAtA[i] = 0xa
631 i++
632 i = encodeVarintGenerated(dAtA, i, uint64(m.ResourceAttributes.Size()))
633 n15, err := m.ResourceAttributes.MarshalTo(dAtA[i:])
634 if err != nil {
635 return 0, err
636 }
637 i += n15
638 }
639 if m.NonResourceAttributes != nil {
640 dAtA[i] = 0x12
641 i++
642 i = encodeVarintGenerated(dAtA, i, uint64(m.NonResourceAttributes.Size()))
643 n16, err := m.NonResourceAttributes.MarshalTo(dAtA[i:])
644 if err != nil {
645 return 0, err
646 }
647 i += n16
648 }
649 dAtA[i] = 0x1a
650 i++
651 i = encodeVarintGenerated(dAtA, i, uint64(len(m.User)))
652 i += copy(dAtA[i:], m.User)
653 if len(m.Groups) > 0 {
654 for _, s := range m.Groups {
655 dAtA[i] = 0x22
656 i++
657 l = len(s)
658 for l >= 1<<7 {
659 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
660 l >>= 7
661 i++
662 }
663 dAtA[i] = uint8(l)
664 i++
665 i += copy(dAtA[i:], s)
666 }
667 }
668 if len(m.Extra) > 0 {
669 keysForExtra := make([]string, 0, len(m.Extra))
670 for k := range m.Extra {
671 keysForExtra = append(keysForExtra, string(k))
672 }
673 github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
674 for _, k := range keysForExtra {
675 dAtA[i] = 0x2a
676 i++
677 v := m.Extra[string(k)]
678 msgSize := 0
679 if (&v) != nil {
680 msgSize = (&v).Size()
681 msgSize += 1 + sovGenerated(uint64(msgSize))
682 }
683 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
684 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
685 dAtA[i] = 0xa
686 i++
687 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
688 i += copy(dAtA[i:], k)
689 dAtA[i] = 0x12
690 i++
691 i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
692 n17, err := (&v).MarshalTo(dAtA[i:])
693 if err != nil {
694 return 0, err
695 }
696 i += n17
697 }
698 }
699 dAtA[i] = 0x32
700 i++
701 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
702 i += copy(dAtA[i:], m.UID)
703 return i, nil
704}
705
706func (m *SubjectAccessReviewStatus) Marshal() (dAtA []byte, err error) {
707 size := m.Size()
708 dAtA = make([]byte, size)
709 n, err := m.MarshalTo(dAtA)
710 if err != nil {
711 return nil, err
712 }
713 return dAtA[:n], nil
714}
715
716func (m *SubjectAccessReviewStatus) MarshalTo(dAtA []byte) (int, error) {
717 var i int
718 _ = i
719 var l int
720 _ = l
721 dAtA[i] = 0x8
722 i++
723 if m.Allowed {
724 dAtA[i] = 1
725 } else {
726 dAtA[i] = 0
727 }
728 i++
729 dAtA[i] = 0x12
730 i++
731 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
732 i += copy(dAtA[i:], m.Reason)
733 dAtA[i] = 0x1a
734 i++
735 i = encodeVarintGenerated(dAtA, i, uint64(len(m.EvaluationError)))
736 i += copy(dAtA[i:], m.EvaluationError)
737 dAtA[i] = 0x20
738 i++
739 if m.Denied {
740 dAtA[i] = 1
741 } else {
742 dAtA[i] = 0
743 }
744 i++
745 return i, nil
746}
747
748func (m *SubjectRulesReviewStatus) Marshal() (dAtA []byte, err error) {
749 size := m.Size()
750 dAtA = make([]byte, size)
751 n, err := m.MarshalTo(dAtA)
752 if err != nil {
753 return nil, err
754 }
755 return dAtA[:n], nil
756}
757
758func (m *SubjectRulesReviewStatus) MarshalTo(dAtA []byte) (int, error) {
759 var i int
760 _ = i
761 var l int
762 _ = l
763 if len(m.ResourceRules) > 0 {
764 for _, msg := range m.ResourceRules {
765 dAtA[i] = 0xa
766 i++
767 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
768 n, err := msg.MarshalTo(dAtA[i:])
769 if err != nil {
770 return 0, err
771 }
772 i += n
773 }
774 }
775 if len(m.NonResourceRules) > 0 {
776 for _, msg := range m.NonResourceRules {
777 dAtA[i] = 0x12
778 i++
779 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
780 n, err := msg.MarshalTo(dAtA[i:])
781 if err != nil {
782 return 0, err
783 }
784 i += n
785 }
786 }
787 dAtA[i] = 0x18
788 i++
789 if m.Incomplete {
790 dAtA[i] = 1
791 } else {
792 dAtA[i] = 0
793 }
794 i++
795 dAtA[i] = 0x22
796 i++
797 i = encodeVarintGenerated(dAtA, i, uint64(len(m.EvaluationError)))
798 i += copy(dAtA[i:], m.EvaluationError)
799 return i, nil
800}
801
802func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
803 for v >= 1<<7 {
804 dAtA[offset] = uint8(v&0x7f | 0x80)
805 v >>= 7
806 offset++
807 }
808 dAtA[offset] = uint8(v)
809 return offset + 1
810}
811func (m ExtraValue) Size() (n int) {
812 var l int
813 _ = l
814 if len(m) > 0 {
815 for _, s := range m {
816 l = len(s)
817 n += 1 + l + sovGenerated(uint64(l))
818 }
819 }
820 return n
821}
822
823func (m *LocalSubjectAccessReview) Size() (n int) {
824 var l int
825 _ = l
826 l = m.ObjectMeta.Size()
827 n += 1 + l + sovGenerated(uint64(l))
828 l = m.Spec.Size()
829 n += 1 + l + sovGenerated(uint64(l))
830 l = m.Status.Size()
831 n += 1 + l + sovGenerated(uint64(l))
832 return n
833}
834
835func (m *NonResourceAttributes) Size() (n int) {
836 var l int
837 _ = l
838 l = len(m.Path)
839 n += 1 + l + sovGenerated(uint64(l))
840 l = len(m.Verb)
841 n += 1 + l + sovGenerated(uint64(l))
842 return n
843}
844
845func (m *NonResourceRule) Size() (n int) {
846 var l int
847 _ = l
848 if len(m.Verbs) > 0 {
849 for _, s := range m.Verbs {
850 l = len(s)
851 n += 1 + l + sovGenerated(uint64(l))
852 }
853 }
854 if len(m.NonResourceURLs) > 0 {
855 for _, s := range m.NonResourceURLs {
856 l = len(s)
857 n += 1 + l + sovGenerated(uint64(l))
858 }
859 }
860 return n
861}
862
863func (m *ResourceAttributes) Size() (n int) {
864 var l int
865 _ = l
866 l = len(m.Namespace)
867 n += 1 + l + sovGenerated(uint64(l))
868 l = len(m.Verb)
869 n += 1 + l + sovGenerated(uint64(l))
870 l = len(m.Group)
871 n += 1 + l + sovGenerated(uint64(l))
872 l = len(m.Version)
873 n += 1 + l + sovGenerated(uint64(l))
874 l = len(m.Resource)
875 n += 1 + l + sovGenerated(uint64(l))
876 l = len(m.Subresource)
877 n += 1 + l + sovGenerated(uint64(l))
878 l = len(m.Name)
879 n += 1 + l + sovGenerated(uint64(l))
880 return n
881}
882
883func (m *ResourceRule) Size() (n int) {
884 var l int
885 _ = l
886 if len(m.Verbs) > 0 {
887 for _, s := range m.Verbs {
888 l = len(s)
889 n += 1 + l + sovGenerated(uint64(l))
890 }
891 }
892 if len(m.APIGroups) > 0 {
893 for _, s := range m.APIGroups {
894 l = len(s)
895 n += 1 + l + sovGenerated(uint64(l))
896 }
897 }
898 if len(m.Resources) > 0 {
899 for _, s := range m.Resources {
900 l = len(s)
901 n += 1 + l + sovGenerated(uint64(l))
902 }
903 }
904 if len(m.ResourceNames) > 0 {
905 for _, s := range m.ResourceNames {
906 l = len(s)
907 n += 1 + l + sovGenerated(uint64(l))
908 }
909 }
910 return n
911}
912
913func (m *SelfSubjectAccessReview) Size() (n int) {
914 var l int
915 _ = l
916 l = m.ObjectMeta.Size()
917 n += 1 + l + sovGenerated(uint64(l))
918 l = m.Spec.Size()
919 n += 1 + l + sovGenerated(uint64(l))
920 l = m.Status.Size()
921 n += 1 + l + sovGenerated(uint64(l))
922 return n
923}
924
925func (m *SelfSubjectAccessReviewSpec) Size() (n int) {
926 var l int
927 _ = l
928 if m.ResourceAttributes != nil {
929 l = m.ResourceAttributes.Size()
930 n += 1 + l + sovGenerated(uint64(l))
931 }
932 if m.NonResourceAttributes != nil {
933 l = m.NonResourceAttributes.Size()
934 n += 1 + l + sovGenerated(uint64(l))
935 }
936 return n
937}
938
939func (m *SelfSubjectRulesReview) Size() (n int) {
940 var l int
941 _ = l
942 l = m.ObjectMeta.Size()
943 n += 1 + l + sovGenerated(uint64(l))
944 l = m.Spec.Size()
945 n += 1 + l + sovGenerated(uint64(l))
946 l = m.Status.Size()
947 n += 1 + l + sovGenerated(uint64(l))
948 return n
949}
950
951func (m *SelfSubjectRulesReviewSpec) Size() (n int) {
952 var l int
953 _ = l
954 l = len(m.Namespace)
955 n += 1 + l + sovGenerated(uint64(l))
956 return n
957}
958
959func (m *SubjectAccessReview) Size() (n int) {
960 var l int
961 _ = l
962 l = m.ObjectMeta.Size()
963 n += 1 + l + sovGenerated(uint64(l))
964 l = m.Spec.Size()
965 n += 1 + l + sovGenerated(uint64(l))
966 l = m.Status.Size()
967 n += 1 + l + sovGenerated(uint64(l))
968 return n
969}
970
971func (m *SubjectAccessReviewSpec) Size() (n int) {
972 var l int
973 _ = l
974 if m.ResourceAttributes != nil {
975 l = m.ResourceAttributes.Size()
976 n += 1 + l + sovGenerated(uint64(l))
977 }
978 if m.NonResourceAttributes != nil {
979 l = m.NonResourceAttributes.Size()
980 n += 1 + l + sovGenerated(uint64(l))
981 }
982 l = len(m.User)
983 n += 1 + l + sovGenerated(uint64(l))
984 if len(m.Groups) > 0 {
985 for _, s := range m.Groups {
986 l = len(s)
987 n += 1 + l + sovGenerated(uint64(l))
988 }
989 }
990 if len(m.Extra) > 0 {
991 for k, v := range m.Extra {
992 _ = k
993 _ = v
994 l = v.Size()
995 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
996 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
997 }
998 }
999 l = len(m.UID)
1000 n += 1 + l + sovGenerated(uint64(l))
1001 return n
1002}
1003
1004func (m *SubjectAccessReviewStatus) Size() (n int) {
1005 var l int
1006 _ = l
1007 n += 2
1008 l = len(m.Reason)
1009 n += 1 + l + sovGenerated(uint64(l))
1010 l = len(m.EvaluationError)
1011 n += 1 + l + sovGenerated(uint64(l))
1012 n += 2
1013 return n
1014}
1015
1016func (m *SubjectRulesReviewStatus) Size() (n int) {
1017 var l int
1018 _ = l
1019 if len(m.ResourceRules) > 0 {
1020 for _, e := range m.ResourceRules {
1021 l = e.Size()
1022 n += 1 + l + sovGenerated(uint64(l))
1023 }
1024 }
1025 if len(m.NonResourceRules) > 0 {
1026 for _, e := range m.NonResourceRules {
1027 l = e.Size()
1028 n += 1 + l + sovGenerated(uint64(l))
1029 }
1030 }
1031 n += 2
1032 l = len(m.EvaluationError)
1033 n += 1 + l + sovGenerated(uint64(l))
1034 return n
1035}
1036
1037func sovGenerated(x uint64) (n int) {
1038 for {
1039 n++
1040 x >>= 7
1041 if x == 0 {
1042 break
1043 }
1044 }
1045 return n
1046}
1047func sozGenerated(x uint64) (n int) {
1048 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1049}
1050func (this *LocalSubjectAccessReview) String() string {
1051 if this == nil {
1052 return "nil"
1053 }
1054 s := strings.Join([]string{`&LocalSubjectAccessReview{`,
1055 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1056 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SubjectAccessReviewSpec", "SubjectAccessReviewSpec", 1), `&`, ``, 1) + `,`,
1057 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "SubjectAccessReviewStatus", "SubjectAccessReviewStatus", 1), `&`, ``, 1) + `,`,
1058 `}`,
1059 }, "")
1060 return s
1061}
1062func (this *NonResourceAttributes) String() string {
1063 if this == nil {
1064 return "nil"
1065 }
1066 s := strings.Join([]string{`&NonResourceAttributes{`,
1067 `Path:` + fmt.Sprintf("%v", this.Path) + `,`,
1068 `Verb:` + fmt.Sprintf("%v", this.Verb) + `,`,
1069 `}`,
1070 }, "")
1071 return s
1072}
1073func (this *NonResourceRule) String() string {
1074 if this == nil {
1075 return "nil"
1076 }
1077 s := strings.Join([]string{`&NonResourceRule{`,
1078 `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`,
1079 `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`,
1080 `}`,
1081 }, "")
1082 return s
1083}
1084func (this *ResourceAttributes) String() string {
1085 if this == nil {
1086 return "nil"
1087 }
1088 s := strings.Join([]string{`&ResourceAttributes{`,
1089 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
1090 `Verb:` + fmt.Sprintf("%v", this.Verb) + `,`,
1091 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
1092 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
1093 `Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
1094 `Subresource:` + fmt.Sprintf("%v", this.Subresource) + `,`,
1095 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
1096 `}`,
1097 }, "")
1098 return s
1099}
1100func (this *ResourceRule) String() string {
1101 if this == nil {
1102 return "nil"
1103 }
1104 s := strings.Join([]string{`&ResourceRule{`,
1105 `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`,
1106 `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
1107 `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
1108 `ResourceNames:` + fmt.Sprintf("%v", this.ResourceNames) + `,`,
1109 `}`,
1110 }, "")
1111 return s
1112}
1113func (this *SelfSubjectAccessReview) String() string {
1114 if this == nil {
1115 return "nil"
1116 }
1117 s := strings.Join([]string{`&SelfSubjectAccessReview{`,
1118 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1119 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SelfSubjectAccessReviewSpec", "SelfSubjectAccessReviewSpec", 1), `&`, ``, 1) + `,`,
1120 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "SubjectAccessReviewStatus", "SubjectAccessReviewStatus", 1), `&`, ``, 1) + `,`,
1121 `}`,
1122 }, "")
1123 return s
1124}
1125func (this *SelfSubjectAccessReviewSpec) String() string {
1126 if this == nil {
1127 return "nil"
1128 }
1129 s := strings.Join([]string{`&SelfSubjectAccessReviewSpec{`,
1130 `ResourceAttributes:` + strings.Replace(fmt.Sprintf("%v", this.ResourceAttributes), "ResourceAttributes", "ResourceAttributes", 1) + `,`,
1131 `NonResourceAttributes:` + strings.Replace(fmt.Sprintf("%v", this.NonResourceAttributes), "NonResourceAttributes", "NonResourceAttributes", 1) + `,`,
1132 `}`,
1133 }, "")
1134 return s
1135}
1136func (this *SelfSubjectRulesReview) String() string {
1137 if this == nil {
1138 return "nil"
1139 }
1140 s := strings.Join([]string{`&SelfSubjectRulesReview{`,
1141 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1142 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SelfSubjectRulesReviewSpec", "SelfSubjectRulesReviewSpec", 1), `&`, ``, 1) + `,`,
1143 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "SubjectRulesReviewStatus", "SubjectRulesReviewStatus", 1), `&`, ``, 1) + `,`,
1144 `}`,
1145 }, "")
1146 return s
1147}
1148func (this *SelfSubjectRulesReviewSpec) String() string {
1149 if this == nil {
1150 return "nil"
1151 }
1152 s := strings.Join([]string{`&SelfSubjectRulesReviewSpec{`,
1153 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
1154 `}`,
1155 }, "")
1156 return s
1157}
1158func (this *SubjectAccessReview) String() string {
1159 if this == nil {
1160 return "nil"
1161 }
1162 s := strings.Join([]string{`&SubjectAccessReview{`,
1163 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1164 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SubjectAccessReviewSpec", "SubjectAccessReviewSpec", 1), `&`, ``, 1) + `,`,
1165 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "SubjectAccessReviewStatus", "SubjectAccessReviewStatus", 1), `&`, ``, 1) + `,`,
1166 `}`,
1167 }, "")
1168 return s
1169}
1170func (this *SubjectAccessReviewSpec) String() string {
1171 if this == nil {
1172 return "nil"
1173 }
1174 keysForExtra := make([]string, 0, len(this.Extra))
1175 for k := range this.Extra {
1176 keysForExtra = append(keysForExtra, k)
1177 }
1178 github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
1179 mapStringForExtra := "map[string]ExtraValue{"
1180 for _, k := range keysForExtra {
1181 mapStringForExtra += fmt.Sprintf("%v: %v,", k, this.Extra[k])
1182 }
1183 mapStringForExtra += "}"
1184 s := strings.Join([]string{`&SubjectAccessReviewSpec{`,
1185 `ResourceAttributes:` + strings.Replace(fmt.Sprintf("%v", this.ResourceAttributes), "ResourceAttributes", "ResourceAttributes", 1) + `,`,
1186 `NonResourceAttributes:` + strings.Replace(fmt.Sprintf("%v", this.NonResourceAttributes), "NonResourceAttributes", "NonResourceAttributes", 1) + `,`,
1187 `User:` + fmt.Sprintf("%v", this.User) + `,`,
1188 `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
1189 `Extra:` + mapStringForExtra + `,`,
1190 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
1191 `}`,
1192 }, "")
1193 return s
1194}
1195func (this *SubjectAccessReviewStatus) String() string {
1196 if this == nil {
1197 return "nil"
1198 }
1199 s := strings.Join([]string{`&SubjectAccessReviewStatus{`,
1200 `Allowed:` + fmt.Sprintf("%v", this.Allowed) + `,`,
1201 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
1202 `EvaluationError:` + fmt.Sprintf("%v", this.EvaluationError) + `,`,
1203 `Denied:` + fmt.Sprintf("%v", this.Denied) + `,`,
1204 `}`,
1205 }, "")
1206 return s
1207}
1208func (this *SubjectRulesReviewStatus) String() string {
1209 if this == nil {
1210 return "nil"
1211 }
1212 s := strings.Join([]string{`&SubjectRulesReviewStatus{`,
1213 `ResourceRules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ResourceRules), "ResourceRule", "ResourceRule", 1), `&`, ``, 1) + `,`,
1214 `NonResourceRules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.NonResourceRules), "NonResourceRule", "NonResourceRule", 1), `&`, ``, 1) + `,`,
1215 `Incomplete:` + fmt.Sprintf("%v", this.Incomplete) + `,`,
1216 `EvaluationError:` + fmt.Sprintf("%v", this.EvaluationError) + `,`,
1217 `}`,
1218 }, "")
1219 return s
1220}
1221func valueToStringGenerated(v interface{}) string {
1222 rv := reflect.ValueOf(v)
1223 if rv.IsNil() {
1224 return "nil"
1225 }
1226 pv := reflect.Indirect(rv).Interface()
1227 return fmt.Sprintf("*%v", pv)
1228}
1229func (m *ExtraValue) Unmarshal(dAtA []byte) error {
1230 l := len(dAtA)
1231 iNdEx := 0
1232 for iNdEx < l {
1233 preIndex := iNdEx
1234 var wire uint64
1235 for shift := uint(0); ; shift += 7 {
1236 if shift >= 64 {
1237 return ErrIntOverflowGenerated
1238 }
1239 if iNdEx >= l {
1240 return io.ErrUnexpectedEOF
1241 }
1242 b := dAtA[iNdEx]
1243 iNdEx++
1244 wire |= (uint64(b) & 0x7F) << shift
1245 if b < 0x80 {
1246 break
1247 }
1248 }
1249 fieldNum := int32(wire >> 3)
1250 wireType := int(wire & 0x7)
1251 if wireType == 4 {
1252 return fmt.Errorf("proto: ExtraValue: wiretype end group for non-group")
1253 }
1254 if fieldNum <= 0 {
1255 return fmt.Errorf("proto: ExtraValue: illegal tag %d (wire type %d)", fieldNum, wire)
1256 }
1257 switch fieldNum {
1258 case 1:
1259 if wireType != 2 {
1260 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1261 }
1262 var stringLen uint64
1263 for shift := uint(0); ; shift += 7 {
1264 if shift >= 64 {
1265 return ErrIntOverflowGenerated
1266 }
1267 if iNdEx >= l {
1268 return io.ErrUnexpectedEOF
1269 }
1270 b := dAtA[iNdEx]
1271 iNdEx++
1272 stringLen |= (uint64(b) & 0x7F) << shift
1273 if b < 0x80 {
1274 break
1275 }
1276 }
1277 intStringLen := int(stringLen)
1278 if intStringLen < 0 {
1279 return ErrInvalidLengthGenerated
1280 }
1281 postIndex := iNdEx + intStringLen
1282 if postIndex > l {
1283 return io.ErrUnexpectedEOF
1284 }
1285 *m = append(*m, string(dAtA[iNdEx:postIndex]))
1286 iNdEx = postIndex
1287 default:
1288 iNdEx = preIndex
1289 skippy, err := skipGenerated(dAtA[iNdEx:])
1290 if err != nil {
1291 return err
1292 }
1293 if skippy < 0 {
1294 return ErrInvalidLengthGenerated
1295 }
1296 if (iNdEx + skippy) > l {
1297 return io.ErrUnexpectedEOF
1298 }
1299 iNdEx += skippy
1300 }
1301 }
1302
1303 if iNdEx > l {
1304 return io.ErrUnexpectedEOF
1305 }
1306 return nil
1307}
1308func (m *LocalSubjectAccessReview) Unmarshal(dAtA []byte) error {
1309 l := len(dAtA)
1310 iNdEx := 0
1311 for iNdEx < l {
1312 preIndex := iNdEx
1313 var wire uint64
1314 for shift := uint(0); ; shift += 7 {
1315 if shift >= 64 {
1316 return ErrIntOverflowGenerated
1317 }
1318 if iNdEx >= l {
1319 return io.ErrUnexpectedEOF
1320 }
1321 b := dAtA[iNdEx]
1322 iNdEx++
1323 wire |= (uint64(b) & 0x7F) << shift
1324 if b < 0x80 {
1325 break
1326 }
1327 }
1328 fieldNum := int32(wire >> 3)
1329 wireType := int(wire & 0x7)
1330 if wireType == 4 {
1331 return fmt.Errorf("proto: LocalSubjectAccessReview: wiretype end group for non-group")
1332 }
1333 if fieldNum <= 0 {
1334 return fmt.Errorf("proto: LocalSubjectAccessReview: illegal tag %d (wire type %d)", fieldNum, wire)
1335 }
1336 switch fieldNum {
1337 case 1:
1338 if wireType != 2 {
1339 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1340 }
1341 var msglen int
1342 for shift := uint(0); ; shift += 7 {
1343 if shift >= 64 {
1344 return ErrIntOverflowGenerated
1345 }
1346 if iNdEx >= l {
1347 return io.ErrUnexpectedEOF
1348 }
1349 b := dAtA[iNdEx]
1350 iNdEx++
1351 msglen |= (int(b) & 0x7F) << shift
1352 if b < 0x80 {
1353 break
1354 }
1355 }
1356 if msglen < 0 {
1357 return ErrInvalidLengthGenerated
1358 }
1359 postIndex := iNdEx + msglen
1360 if postIndex > l {
1361 return io.ErrUnexpectedEOF
1362 }
1363 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1364 return err
1365 }
1366 iNdEx = postIndex
1367 case 2:
1368 if wireType != 2 {
1369 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
1370 }
1371 var msglen int
1372 for shift := uint(0); ; shift += 7 {
1373 if shift >= 64 {
1374 return ErrIntOverflowGenerated
1375 }
1376 if iNdEx >= l {
1377 return io.ErrUnexpectedEOF
1378 }
1379 b := dAtA[iNdEx]
1380 iNdEx++
1381 msglen |= (int(b) & 0x7F) << shift
1382 if b < 0x80 {
1383 break
1384 }
1385 }
1386 if msglen < 0 {
1387 return ErrInvalidLengthGenerated
1388 }
1389 postIndex := iNdEx + msglen
1390 if postIndex > l {
1391 return io.ErrUnexpectedEOF
1392 }
1393 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1394 return err
1395 }
1396 iNdEx = postIndex
1397 case 3:
1398 if wireType != 2 {
1399 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
1400 }
1401 var msglen int
1402 for shift := uint(0); ; shift += 7 {
1403 if shift >= 64 {
1404 return ErrIntOverflowGenerated
1405 }
1406 if iNdEx >= l {
1407 return io.ErrUnexpectedEOF
1408 }
1409 b := dAtA[iNdEx]
1410 iNdEx++
1411 msglen |= (int(b) & 0x7F) << shift
1412 if b < 0x80 {
1413 break
1414 }
1415 }
1416 if msglen < 0 {
1417 return ErrInvalidLengthGenerated
1418 }
1419 postIndex := iNdEx + msglen
1420 if postIndex > l {
1421 return io.ErrUnexpectedEOF
1422 }
1423 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1424 return err
1425 }
1426 iNdEx = postIndex
1427 default:
1428 iNdEx = preIndex
1429 skippy, err := skipGenerated(dAtA[iNdEx:])
1430 if err != nil {
1431 return err
1432 }
1433 if skippy < 0 {
1434 return ErrInvalidLengthGenerated
1435 }
1436 if (iNdEx + skippy) > l {
1437 return io.ErrUnexpectedEOF
1438 }
1439 iNdEx += skippy
1440 }
1441 }
1442
1443 if iNdEx > l {
1444 return io.ErrUnexpectedEOF
1445 }
1446 return nil
1447}
1448func (m *NonResourceAttributes) Unmarshal(dAtA []byte) error {
1449 l := len(dAtA)
1450 iNdEx := 0
1451 for iNdEx < l {
1452 preIndex := iNdEx
1453 var wire uint64
1454 for shift := uint(0); ; shift += 7 {
1455 if shift >= 64 {
1456 return ErrIntOverflowGenerated
1457 }
1458 if iNdEx >= l {
1459 return io.ErrUnexpectedEOF
1460 }
1461 b := dAtA[iNdEx]
1462 iNdEx++
1463 wire |= (uint64(b) & 0x7F) << shift
1464 if b < 0x80 {
1465 break
1466 }
1467 }
1468 fieldNum := int32(wire >> 3)
1469 wireType := int(wire & 0x7)
1470 if wireType == 4 {
1471 return fmt.Errorf("proto: NonResourceAttributes: wiretype end group for non-group")
1472 }
1473 if fieldNum <= 0 {
1474 return fmt.Errorf("proto: NonResourceAttributes: illegal tag %d (wire type %d)", fieldNum, wire)
1475 }
1476 switch fieldNum {
1477 case 1:
1478 if wireType != 2 {
1479 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
1480 }
1481 var stringLen uint64
1482 for shift := uint(0); ; shift += 7 {
1483 if shift >= 64 {
1484 return ErrIntOverflowGenerated
1485 }
1486 if iNdEx >= l {
1487 return io.ErrUnexpectedEOF
1488 }
1489 b := dAtA[iNdEx]
1490 iNdEx++
1491 stringLen |= (uint64(b) & 0x7F) << shift
1492 if b < 0x80 {
1493 break
1494 }
1495 }
1496 intStringLen := int(stringLen)
1497 if intStringLen < 0 {
1498 return ErrInvalidLengthGenerated
1499 }
1500 postIndex := iNdEx + intStringLen
1501 if postIndex > l {
1502 return io.ErrUnexpectedEOF
1503 }
1504 m.Path = string(dAtA[iNdEx:postIndex])
1505 iNdEx = postIndex
1506 case 2:
1507 if wireType != 2 {
1508 return fmt.Errorf("proto: wrong wireType = %d for field Verb", wireType)
1509 }
1510 var stringLen uint64
1511 for shift := uint(0); ; shift += 7 {
1512 if shift >= 64 {
1513 return ErrIntOverflowGenerated
1514 }
1515 if iNdEx >= l {
1516 return io.ErrUnexpectedEOF
1517 }
1518 b := dAtA[iNdEx]
1519 iNdEx++
1520 stringLen |= (uint64(b) & 0x7F) << shift
1521 if b < 0x80 {
1522 break
1523 }
1524 }
1525 intStringLen := int(stringLen)
1526 if intStringLen < 0 {
1527 return ErrInvalidLengthGenerated
1528 }
1529 postIndex := iNdEx + intStringLen
1530 if postIndex > l {
1531 return io.ErrUnexpectedEOF
1532 }
1533 m.Verb = string(dAtA[iNdEx:postIndex])
1534 iNdEx = postIndex
1535 default:
1536 iNdEx = preIndex
1537 skippy, err := skipGenerated(dAtA[iNdEx:])
1538 if err != nil {
1539 return err
1540 }
1541 if skippy < 0 {
1542 return ErrInvalidLengthGenerated
1543 }
1544 if (iNdEx + skippy) > l {
1545 return io.ErrUnexpectedEOF
1546 }
1547 iNdEx += skippy
1548 }
1549 }
1550
1551 if iNdEx > l {
1552 return io.ErrUnexpectedEOF
1553 }
1554 return nil
1555}
1556func (m *NonResourceRule) Unmarshal(dAtA []byte) error {
1557 l := len(dAtA)
1558 iNdEx := 0
1559 for iNdEx < l {
1560 preIndex := iNdEx
1561 var wire uint64
1562 for shift := uint(0); ; shift += 7 {
1563 if shift >= 64 {
1564 return ErrIntOverflowGenerated
1565 }
1566 if iNdEx >= l {
1567 return io.ErrUnexpectedEOF
1568 }
1569 b := dAtA[iNdEx]
1570 iNdEx++
1571 wire |= (uint64(b) & 0x7F) << shift
1572 if b < 0x80 {
1573 break
1574 }
1575 }
1576 fieldNum := int32(wire >> 3)
1577 wireType := int(wire & 0x7)
1578 if wireType == 4 {
1579 return fmt.Errorf("proto: NonResourceRule: wiretype end group for non-group")
1580 }
1581 if fieldNum <= 0 {
1582 return fmt.Errorf("proto: NonResourceRule: illegal tag %d (wire type %d)", fieldNum, wire)
1583 }
1584 switch fieldNum {
1585 case 1:
1586 if wireType != 2 {
1587 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
1588 }
1589 var stringLen uint64
1590 for shift := uint(0); ; shift += 7 {
1591 if shift >= 64 {
1592 return ErrIntOverflowGenerated
1593 }
1594 if iNdEx >= l {
1595 return io.ErrUnexpectedEOF
1596 }
1597 b := dAtA[iNdEx]
1598 iNdEx++
1599 stringLen |= (uint64(b) & 0x7F) << shift
1600 if b < 0x80 {
1601 break
1602 }
1603 }
1604 intStringLen := int(stringLen)
1605 if intStringLen < 0 {
1606 return ErrInvalidLengthGenerated
1607 }
1608 postIndex := iNdEx + intStringLen
1609 if postIndex > l {
1610 return io.ErrUnexpectedEOF
1611 }
1612 m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex]))
1613 iNdEx = postIndex
1614 case 2:
1615 if wireType != 2 {
1616 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceURLs", wireType)
1617 }
1618 var stringLen uint64
1619 for shift := uint(0); ; shift += 7 {
1620 if shift >= 64 {
1621 return ErrIntOverflowGenerated
1622 }
1623 if iNdEx >= l {
1624 return io.ErrUnexpectedEOF
1625 }
1626 b := dAtA[iNdEx]
1627 iNdEx++
1628 stringLen |= (uint64(b) & 0x7F) << shift
1629 if b < 0x80 {
1630 break
1631 }
1632 }
1633 intStringLen := int(stringLen)
1634 if intStringLen < 0 {
1635 return ErrInvalidLengthGenerated
1636 }
1637 postIndex := iNdEx + intStringLen
1638 if postIndex > l {
1639 return io.ErrUnexpectedEOF
1640 }
1641 m.NonResourceURLs = append(m.NonResourceURLs, string(dAtA[iNdEx:postIndex]))
1642 iNdEx = postIndex
1643 default:
1644 iNdEx = preIndex
1645 skippy, err := skipGenerated(dAtA[iNdEx:])
1646 if err != nil {
1647 return err
1648 }
1649 if skippy < 0 {
1650 return ErrInvalidLengthGenerated
1651 }
1652 if (iNdEx + skippy) > l {
1653 return io.ErrUnexpectedEOF
1654 }
1655 iNdEx += skippy
1656 }
1657 }
1658
1659 if iNdEx > l {
1660 return io.ErrUnexpectedEOF
1661 }
1662 return nil
1663}
1664func (m *ResourceAttributes) Unmarshal(dAtA []byte) error {
1665 l := len(dAtA)
1666 iNdEx := 0
1667 for iNdEx < l {
1668 preIndex := iNdEx
1669 var wire uint64
1670 for shift := uint(0); ; shift += 7 {
1671 if shift >= 64 {
1672 return ErrIntOverflowGenerated
1673 }
1674 if iNdEx >= l {
1675 return io.ErrUnexpectedEOF
1676 }
1677 b := dAtA[iNdEx]
1678 iNdEx++
1679 wire |= (uint64(b) & 0x7F) << shift
1680 if b < 0x80 {
1681 break
1682 }
1683 }
1684 fieldNum := int32(wire >> 3)
1685 wireType := int(wire & 0x7)
1686 if wireType == 4 {
1687 return fmt.Errorf("proto: ResourceAttributes: wiretype end group for non-group")
1688 }
1689 if fieldNum <= 0 {
1690 return fmt.Errorf("proto: ResourceAttributes: illegal tag %d (wire type %d)", fieldNum, wire)
1691 }
1692 switch fieldNum {
1693 case 1:
1694 if wireType != 2 {
1695 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
1696 }
1697 var stringLen uint64
1698 for shift := uint(0); ; shift += 7 {
1699 if shift >= 64 {
1700 return ErrIntOverflowGenerated
1701 }
1702 if iNdEx >= l {
1703 return io.ErrUnexpectedEOF
1704 }
1705 b := dAtA[iNdEx]
1706 iNdEx++
1707 stringLen |= (uint64(b) & 0x7F) << shift
1708 if b < 0x80 {
1709 break
1710 }
1711 }
1712 intStringLen := int(stringLen)
1713 if intStringLen < 0 {
1714 return ErrInvalidLengthGenerated
1715 }
1716 postIndex := iNdEx + intStringLen
1717 if postIndex > l {
1718 return io.ErrUnexpectedEOF
1719 }
1720 m.Namespace = string(dAtA[iNdEx:postIndex])
1721 iNdEx = postIndex
1722 case 2:
1723 if wireType != 2 {
1724 return fmt.Errorf("proto: wrong wireType = %d for field Verb", wireType)
1725 }
1726 var stringLen uint64
1727 for shift := uint(0); ; shift += 7 {
1728 if shift >= 64 {
1729 return ErrIntOverflowGenerated
1730 }
1731 if iNdEx >= l {
1732 return io.ErrUnexpectedEOF
1733 }
1734 b := dAtA[iNdEx]
1735 iNdEx++
1736 stringLen |= (uint64(b) & 0x7F) << shift
1737 if b < 0x80 {
1738 break
1739 }
1740 }
1741 intStringLen := int(stringLen)
1742 if intStringLen < 0 {
1743 return ErrInvalidLengthGenerated
1744 }
1745 postIndex := iNdEx + intStringLen
1746 if postIndex > l {
1747 return io.ErrUnexpectedEOF
1748 }
1749 m.Verb = string(dAtA[iNdEx:postIndex])
1750 iNdEx = postIndex
1751 case 3:
1752 if wireType != 2 {
1753 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
1754 }
1755 var stringLen uint64
1756 for shift := uint(0); ; shift += 7 {
1757 if shift >= 64 {
1758 return ErrIntOverflowGenerated
1759 }
1760 if iNdEx >= l {
1761 return io.ErrUnexpectedEOF
1762 }
1763 b := dAtA[iNdEx]
1764 iNdEx++
1765 stringLen |= (uint64(b) & 0x7F) << shift
1766 if b < 0x80 {
1767 break
1768 }
1769 }
1770 intStringLen := int(stringLen)
1771 if intStringLen < 0 {
1772 return ErrInvalidLengthGenerated
1773 }
1774 postIndex := iNdEx + intStringLen
1775 if postIndex > l {
1776 return io.ErrUnexpectedEOF
1777 }
1778 m.Group = string(dAtA[iNdEx:postIndex])
1779 iNdEx = postIndex
1780 case 4:
1781 if wireType != 2 {
1782 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
1783 }
1784 var stringLen uint64
1785 for shift := uint(0); ; shift += 7 {
1786 if shift >= 64 {
1787 return ErrIntOverflowGenerated
1788 }
1789 if iNdEx >= l {
1790 return io.ErrUnexpectedEOF
1791 }
1792 b := dAtA[iNdEx]
1793 iNdEx++
1794 stringLen |= (uint64(b) & 0x7F) << shift
1795 if b < 0x80 {
1796 break
1797 }
1798 }
1799 intStringLen := int(stringLen)
1800 if intStringLen < 0 {
1801 return ErrInvalidLengthGenerated
1802 }
1803 postIndex := iNdEx + intStringLen
1804 if postIndex > l {
1805 return io.ErrUnexpectedEOF
1806 }
1807 m.Version = string(dAtA[iNdEx:postIndex])
1808 iNdEx = postIndex
1809 case 5:
1810 if wireType != 2 {
1811 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
1812 }
1813 var stringLen uint64
1814 for shift := uint(0); ; shift += 7 {
1815 if shift >= 64 {
1816 return ErrIntOverflowGenerated
1817 }
1818 if iNdEx >= l {
1819 return io.ErrUnexpectedEOF
1820 }
1821 b := dAtA[iNdEx]
1822 iNdEx++
1823 stringLen |= (uint64(b) & 0x7F) << shift
1824 if b < 0x80 {
1825 break
1826 }
1827 }
1828 intStringLen := int(stringLen)
1829 if intStringLen < 0 {
1830 return ErrInvalidLengthGenerated
1831 }
1832 postIndex := iNdEx + intStringLen
1833 if postIndex > l {
1834 return io.ErrUnexpectedEOF
1835 }
1836 m.Resource = string(dAtA[iNdEx:postIndex])
1837 iNdEx = postIndex
1838 case 6:
1839 if wireType != 2 {
1840 return fmt.Errorf("proto: wrong wireType = %d for field Subresource", wireType)
1841 }
1842 var stringLen uint64
1843 for shift := uint(0); ; shift += 7 {
1844 if shift >= 64 {
1845 return ErrIntOverflowGenerated
1846 }
1847 if iNdEx >= l {
1848 return io.ErrUnexpectedEOF
1849 }
1850 b := dAtA[iNdEx]
1851 iNdEx++
1852 stringLen |= (uint64(b) & 0x7F) << shift
1853 if b < 0x80 {
1854 break
1855 }
1856 }
1857 intStringLen := int(stringLen)
1858 if intStringLen < 0 {
1859 return ErrInvalidLengthGenerated
1860 }
1861 postIndex := iNdEx + intStringLen
1862 if postIndex > l {
1863 return io.ErrUnexpectedEOF
1864 }
1865 m.Subresource = string(dAtA[iNdEx:postIndex])
1866 iNdEx = postIndex
1867 case 7:
1868 if wireType != 2 {
1869 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1870 }
1871 var stringLen uint64
1872 for shift := uint(0); ; shift += 7 {
1873 if shift >= 64 {
1874 return ErrIntOverflowGenerated
1875 }
1876 if iNdEx >= l {
1877 return io.ErrUnexpectedEOF
1878 }
1879 b := dAtA[iNdEx]
1880 iNdEx++
1881 stringLen |= (uint64(b) & 0x7F) << shift
1882 if b < 0x80 {
1883 break
1884 }
1885 }
1886 intStringLen := int(stringLen)
1887 if intStringLen < 0 {
1888 return ErrInvalidLengthGenerated
1889 }
1890 postIndex := iNdEx + intStringLen
1891 if postIndex > l {
1892 return io.ErrUnexpectedEOF
1893 }
1894 m.Name = string(dAtA[iNdEx:postIndex])
1895 iNdEx = postIndex
1896 default:
1897 iNdEx = preIndex
1898 skippy, err := skipGenerated(dAtA[iNdEx:])
1899 if err != nil {
1900 return err
1901 }
1902 if skippy < 0 {
1903 return ErrInvalidLengthGenerated
1904 }
1905 if (iNdEx + skippy) > l {
1906 return io.ErrUnexpectedEOF
1907 }
1908 iNdEx += skippy
1909 }
1910 }
1911
1912 if iNdEx > l {
1913 return io.ErrUnexpectedEOF
1914 }
1915 return nil
1916}
1917func (m *ResourceRule) Unmarshal(dAtA []byte) error {
1918 l := len(dAtA)
1919 iNdEx := 0
1920 for iNdEx < l {
1921 preIndex := iNdEx
1922 var wire uint64
1923 for shift := uint(0); ; shift += 7 {
1924 if shift >= 64 {
1925 return ErrIntOverflowGenerated
1926 }
1927 if iNdEx >= l {
1928 return io.ErrUnexpectedEOF
1929 }
1930 b := dAtA[iNdEx]
1931 iNdEx++
1932 wire |= (uint64(b) & 0x7F) << shift
1933 if b < 0x80 {
1934 break
1935 }
1936 }
1937 fieldNum := int32(wire >> 3)
1938 wireType := int(wire & 0x7)
1939 if wireType == 4 {
1940 return fmt.Errorf("proto: ResourceRule: wiretype end group for non-group")
1941 }
1942 if fieldNum <= 0 {
1943 return fmt.Errorf("proto: ResourceRule: illegal tag %d (wire type %d)", fieldNum, wire)
1944 }
1945 switch fieldNum {
1946 case 1:
1947 if wireType != 2 {
1948 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
1949 }
1950 var stringLen uint64
1951 for shift := uint(0); ; shift += 7 {
1952 if shift >= 64 {
1953 return ErrIntOverflowGenerated
1954 }
1955 if iNdEx >= l {
1956 return io.ErrUnexpectedEOF
1957 }
1958 b := dAtA[iNdEx]
1959 iNdEx++
1960 stringLen |= (uint64(b) & 0x7F) << shift
1961 if b < 0x80 {
1962 break
1963 }
1964 }
1965 intStringLen := int(stringLen)
1966 if intStringLen < 0 {
1967 return ErrInvalidLengthGenerated
1968 }
1969 postIndex := iNdEx + intStringLen
1970 if postIndex > l {
1971 return io.ErrUnexpectedEOF
1972 }
1973 m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex]))
1974 iNdEx = postIndex
1975 case 2:
1976 if wireType != 2 {
1977 return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
1978 }
1979 var stringLen uint64
1980 for shift := uint(0); ; shift += 7 {
1981 if shift >= 64 {
1982 return ErrIntOverflowGenerated
1983 }
1984 if iNdEx >= l {
1985 return io.ErrUnexpectedEOF
1986 }
1987 b := dAtA[iNdEx]
1988 iNdEx++
1989 stringLen |= (uint64(b) & 0x7F) << shift
1990 if b < 0x80 {
1991 break
1992 }
1993 }
1994 intStringLen := int(stringLen)
1995 if intStringLen < 0 {
1996 return ErrInvalidLengthGenerated
1997 }
1998 postIndex := iNdEx + intStringLen
1999 if postIndex > l {
2000 return io.ErrUnexpectedEOF
2001 }
2002 m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
2003 iNdEx = postIndex
2004 case 3:
2005 if wireType != 2 {
2006 return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
2007 }
2008 var stringLen uint64
2009 for shift := uint(0); ; shift += 7 {
2010 if shift >= 64 {
2011 return ErrIntOverflowGenerated
2012 }
2013 if iNdEx >= l {
2014 return io.ErrUnexpectedEOF
2015 }
2016 b := dAtA[iNdEx]
2017 iNdEx++
2018 stringLen |= (uint64(b) & 0x7F) << shift
2019 if b < 0x80 {
2020 break
2021 }
2022 }
2023 intStringLen := int(stringLen)
2024 if intStringLen < 0 {
2025 return ErrInvalidLengthGenerated
2026 }
2027 postIndex := iNdEx + intStringLen
2028 if postIndex > l {
2029 return io.ErrUnexpectedEOF
2030 }
2031 m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
2032 iNdEx = postIndex
2033 case 4:
2034 if wireType != 2 {
2035 return fmt.Errorf("proto: wrong wireType = %d for field ResourceNames", wireType)
2036 }
2037 var stringLen uint64
2038 for shift := uint(0); ; shift += 7 {
2039 if shift >= 64 {
2040 return ErrIntOverflowGenerated
2041 }
2042 if iNdEx >= l {
2043 return io.ErrUnexpectedEOF
2044 }
2045 b := dAtA[iNdEx]
2046 iNdEx++
2047 stringLen |= (uint64(b) & 0x7F) << shift
2048 if b < 0x80 {
2049 break
2050 }
2051 }
2052 intStringLen := int(stringLen)
2053 if intStringLen < 0 {
2054 return ErrInvalidLengthGenerated
2055 }
2056 postIndex := iNdEx + intStringLen
2057 if postIndex > l {
2058 return io.ErrUnexpectedEOF
2059 }
2060 m.ResourceNames = append(m.ResourceNames, string(dAtA[iNdEx:postIndex]))
2061 iNdEx = postIndex
2062 default:
2063 iNdEx = preIndex
2064 skippy, err := skipGenerated(dAtA[iNdEx:])
2065 if err != nil {
2066 return err
2067 }
2068 if skippy < 0 {
2069 return ErrInvalidLengthGenerated
2070 }
2071 if (iNdEx + skippy) > l {
2072 return io.ErrUnexpectedEOF
2073 }
2074 iNdEx += skippy
2075 }
2076 }
2077
2078 if iNdEx > l {
2079 return io.ErrUnexpectedEOF
2080 }
2081 return nil
2082}
2083func (m *SelfSubjectAccessReview) Unmarshal(dAtA []byte) error {
2084 l := len(dAtA)
2085 iNdEx := 0
2086 for iNdEx < l {
2087 preIndex := iNdEx
2088 var wire uint64
2089 for shift := uint(0); ; shift += 7 {
2090 if shift >= 64 {
2091 return ErrIntOverflowGenerated
2092 }
2093 if iNdEx >= l {
2094 return io.ErrUnexpectedEOF
2095 }
2096 b := dAtA[iNdEx]
2097 iNdEx++
2098 wire |= (uint64(b) & 0x7F) << shift
2099 if b < 0x80 {
2100 break
2101 }
2102 }
2103 fieldNum := int32(wire >> 3)
2104 wireType := int(wire & 0x7)
2105 if wireType == 4 {
2106 return fmt.Errorf("proto: SelfSubjectAccessReview: wiretype end group for non-group")
2107 }
2108 if fieldNum <= 0 {
2109 return fmt.Errorf("proto: SelfSubjectAccessReview: illegal tag %d (wire type %d)", fieldNum, wire)
2110 }
2111 switch fieldNum {
2112 case 1:
2113 if wireType != 2 {
2114 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2115 }
2116 var msglen int
2117 for shift := uint(0); ; shift += 7 {
2118 if shift >= 64 {
2119 return ErrIntOverflowGenerated
2120 }
2121 if iNdEx >= l {
2122 return io.ErrUnexpectedEOF
2123 }
2124 b := dAtA[iNdEx]
2125 iNdEx++
2126 msglen |= (int(b) & 0x7F) << shift
2127 if b < 0x80 {
2128 break
2129 }
2130 }
2131 if msglen < 0 {
2132 return ErrInvalidLengthGenerated
2133 }
2134 postIndex := iNdEx + msglen
2135 if postIndex > l {
2136 return io.ErrUnexpectedEOF
2137 }
2138 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2139 return err
2140 }
2141 iNdEx = postIndex
2142 case 2:
2143 if wireType != 2 {
2144 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2145 }
2146 var msglen int
2147 for shift := uint(0); ; shift += 7 {
2148 if shift >= 64 {
2149 return ErrIntOverflowGenerated
2150 }
2151 if iNdEx >= l {
2152 return io.ErrUnexpectedEOF
2153 }
2154 b := dAtA[iNdEx]
2155 iNdEx++
2156 msglen |= (int(b) & 0x7F) << shift
2157 if b < 0x80 {
2158 break
2159 }
2160 }
2161 if msglen < 0 {
2162 return ErrInvalidLengthGenerated
2163 }
2164 postIndex := iNdEx + msglen
2165 if postIndex > l {
2166 return io.ErrUnexpectedEOF
2167 }
2168 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2169 return err
2170 }
2171 iNdEx = postIndex
2172 case 3:
2173 if wireType != 2 {
2174 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2175 }
2176 var msglen int
2177 for shift := uint(0); ; shift += 7 {
2178 if shift >= 64 {
2179 return ErrIntOverflowGenerated
2180 }
2181 if iNdEx >= l {
2182 return io.ErrUnexpectedEOF
2183 }
2184 b := dAtA[iNdEx]
2185 iNdEx++
2186 msglen |= (int(b) & 0x7F) << shift
2187 if b < 0x80 {
2188 break
2189 }
2190 }
2191 if msglen < 0 {
2192 return ErrInvalidLengthGenerated
2193 }
2194 postIndex := iNdEx + msglen
2195 if postIndex > l {
2196 return io.ErrUnexpectedEOF
2197 }
2198 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2199 return err
2200 }
2201 iNdEx = postIndex
2202 default:
2203 iNdEx = preIndex
2204 skippy, err := skipGenerated(dAtA[iNdEx:])
2205 if err != nil {
2206 return err
2207 }
2208 if skippy < 0 {
2209 return ErrInvalidLengthGenerated
2210 }
2211 if (iNdEx + skippy) > l {
2212 return io.ErrUnexpectedEOF
2213 }
2214 iNdEx += skippy
2215 }
2216 }
2217
2218 if iNdEx > l {
2219 return io.ErrUnexpectedEOF
2220 }
2221 return nil
2222}
2223func (m *SelfSubjectAccessReviewSpec) Unmarshal(dAtA []byte) error {
2224 l := len(dAtA)
2225 iNdEx := 0
2226 for iNdEx < l {
2227 preIndex := iNdEx
2228 var wire uint64
2229 for shift := uint(0); ; shift += 7 {
2230 if shift >= 64 {
2231 return ErrIntOverflowGenerated
2232 }
2233 if iNdEx >= l {
2234 return io.ErrUnexpectedEOF
2235 }
2236 b := dAtA[iNdEx]
2237 iNdEx++
2238 wire |= (uint64(b) & 0x7F) << shift
2239 if b < 0x80 {
2240 break
2241 }
2242 }
2243 fieldNum := int32(wire >> 3)
2244 wireType := int(wire & 0x7)
2245 if wireType == 4 {
2246 return fmt.Errorf("proto: SelfSubjectAccessReviewSpec: wiretype end group for non-group")
2247 }
2248 if fieldNum <= 0 {
2249 return fmt.Errorf("proto: SelfSubjectAccessReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2250 }
2251 switch fieldNum {
2252 case 1:
2253 if wireType != 2 {
2254 return fmt.Errorf("proto: wrong wireType = %d for field ResourceAttributes", wireType)
2255 }
2256 var msglen int
2257 for shift := uint(0); ; shift += 7 {
2258 if shift >= 64 {
2259 return ErrIntOverflowGenerated
2260 }
2261 if iNdEx >= l {
2262 return io.ErrUnexpectedEOF
2263 }
2264 b := dAtA[iNdEx]
2265 iNdEx++
2266 msglen |= (int(b) & 0x7F) << shift
2267 if b < 0x80 {
2268 break
2269 }
2270 }
2271 if msglen < 0 {
2272 return ErrInvalidLengthGenerated
2273 }
2274 postIndex := iNdEx + msglen
2275 if postIndex > l {
2276 return io.ErrUnexpectedEOF
2277 }
2278 if m.ResourceAttributes == nil {
2279 m.ResourceAttributes = &ResourceAttributes{}
2280 }
2281 if err := m.ResourceAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2282 return err
2283 }
2284 iNdEx = postIndex
2285 case 2:
2286 if wireType != 2 {
2287 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceAttributes", wireType)
2288 }
2289 var msglen int
2290 for shift := uint(0); ; shift += 7 {
2291 if shift >= 64 {
2292 return ErrIntOverflowGenerated
2293 }
2294 if iNdEx >= l {
2295 return io.ErrUnexpectedEOF
2296 }
2297 b := dAtA[iNdEx]
2298 iNdEx++
2299 msglen |= (int(b) & 0x7F) << shift
2300 if b < 0x80 {
2301 break
2302 }
2303 }
2304 if msglen < 0 {
2305 return ErrInvalidLengthGenerated
2306 }
2307 postIndex := iNdEx + msglen
2308 if postIndex > l {
2309 return io.ErrUnexpectedEOF
2310 }
2311 if m.NonResourceAttributes == nil {
2312 m.NonResourceAttributes = &NonResourceAttributes{}
2313 }
2314 if err := m.NonResourceAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2315 return err
2316 }
2317 iNdEx = postIndex
2318 default:
2319 iNdEx = preIndex
2320 skippy, err := skipGenerated(dAtA[iNdEx:])
2321 if err != nil {
2322 return err
2323 }
2324 if skippy < 0 {
2325 return ErrInvalidLengthGenerated
2326 }
2327 if (iNdEx + skippy) > l {
2328 return io.ErrUnexpectedEOF
2329 }
2330 iNdEx += skippy
2331 }
2332 }
2333
2334 if iNdEx > l {
2335 return io.ErrUnexpectedEOF
2336 }
2337 return nil
2338}
2339func (m *SelfSubjectRulesReview) Unmarshal(dAtA []byte) error {
2340 l := len(dAtA)
2341 iNdEx := 0
2342 for iNdEx < l {
2343 preIndex := iNdEx
2344 var wire uint64
2345 for shift := uint(0); ; shift += 7 {
2346 if shift >= 64 {
2347 return ErrIntOverflowGenerated
2348 }
2349 if iNdEx >= l {
2350 return io.ErrUnexpectedEOF
2351 }
2352 b := dAtA[iNdEx]
2353 iNdEx++
2354 wire |= (uint64(b) & 0x7F) << shift
2355 if b < 0x80 {
2356 break
2357 }
2358 }
2359 fieldNum := int32(wire >> 3)
2360 wireType := int(wire & 0x7)
2361 if wireType == 4 {
2362 return fmt.Errorf("proto: SelfSubjectRulesReview: wiretype end group for non-group")
2363 }
2364 if fieldNum <= 0 {
2365 return fmt.Errorf("proto: SelfSubjectRulesReview: illegal tag %d (wire type %d)", fieldNum, wire)
2366 }
2367 switch fieldNum {
2368 case 1:
2369 if wireType != 2 {
2370 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2371 }
2372 var msglen int
2373 for shift := uint(0); ; shift += 7 {
2374 if shift >= 64 {
2375 return ErrIntOverflowGenerated
2376 }
2377 if iNdEx >= l {
2378 return io.ErrUnexpectedEOF
2379 }
2380 b := dAtA[iNdEx]
2381 iNdEx++
2382 msglen |= (int(b) & 0x7F) << shift
2383 if b < 0x80 {
2384 break
2385 }
2386 }
2387 if msglen < 0 {
2388 return ErrInvalidLengthGenerated
2389 }
2390 postIndex := iNdEx + msglen
2391 if postIndex > l {
2392 return io.ErrUnexpectedEOF
2393 }
2394 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2395 return err
2396 }
2397 iNdEx = postIndex
2398 case 2:
2399 if wireType != 2 {
2400 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2401 }
2402 var msglen int
2403 for shift := uint(0); ; shift += 7 {
2404 if shift >= 64 {
2405 return ErrIntOverflowGenerated
2406 }
2407 if iNdEx >= l {
2408 return io.ErrUnexpectedEOF
2409 }
2410 b := dAtA[iNdEx]
2411 iNdEx++
2412 msglen |= (int(b) & 0x7F) << shift
2413 if b < 0x80 {
2414 break
2415 }
2416 }
2417 if msglen < 0 {
2418 return ErrInvalidLengthGenerated
2419 }
2420 postIndex := iNdEx + msglen
2421 if postIndex > l {
2422 return io.ErrUnexpectedEOF
2423 }
2424 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2425 return err
2426 }
2427 iNdEx = postIndex
2428 case 3:
2429 if wireType != 2 {
2430 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2431 }
2432 var msglen int
2433 for shift := uint(0); ; shift += 7 {
2434 if shift >= 64 {
2435 return ErrIntOverflowGenerated
2436 }
2437 if iNdEx >= l {
2438 return io.ErrUnexpectedEOF
2439 }
2440 b := dAtA[iNdEx]
2441 iNdEx++
2442 msglen |= (int(b) & 0x7F) << shift
2443 if b < 0x80 {
2444 break
2445 }
2446 }
2447 if msglen < 0 {
2448 return ErrInvalidLengthGenerated
2449 }
2450 postIndex := iNdEx + msglen
2451 if postIndex > l {
2452 return io.ErrUnexpectedEOF
2453 }
2454 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2455 return err
2456 }
2457 iNdEx = postIndex
2458 default:
2459 iNdEx = preIndex
2460 skippy, err := skipGenerated(dAtA[iNdEx:])
2461 if err != nil {
2462 return err
2463 }
2464 if skippy < 0 {
2465 return ErrInvalidLengthGenerated
2466 }
2467 if (iNdEx + skippy) > l {
2468 return io.ErrUnexpectedEOF
2469 }
2470 iNdEx += skippy
2471 }
2472 }
2473
2474 if iNdEx > l {
2475 return io.ErrUnexpectedEOF
2476 }
2477 return nil
2478}
2479func (m *SelfSubjectRulesReviewSpec) Unmarshal(dAtA []byte) error {
2480 l := len(dAtA)
2481 iNdEx := 0
2482 for iNdEx < l {
2483 preIndex := iNdEx
2484 var wire uint64
2485 for shift := uint(0); ; shift += 7 {
2486 if shift >= 64 {
2487 return ErrIntOverflowGenerated
2488 }
2489 if iNdEx >= l {
2490 return io.ErrUnexpectedEOF
2491 }
2492 b := dAtA[iNdEx]
2493 iNdEx++
2494 wire |= (uint64(b) & 0x7F) << shift
2495 if b < 0x80 {
2496 break
2497 }
2498 }
2499 fieldNum := int32(wire >> 3)
2500 wireType := int(wire & 0x7)
2501 if wireType == 4 {
2502 return fmt.Errorf("proto: SelfSubjectRulesReviewSpec: wiretype end group for non-group")
2503 }
2504 if fieldNum <= 0 {
2505 return fmt.Errorf("proto: SelfSubjectRulesReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2506 }
2507 switch fieldNum {
2508 case 1:
2509 if wireType != 2 {
2510 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
2511 }
2512 var stringLen uint64
2513 for shift := uint(0); ; shift += 7 {
2514 if shift >= 64 {
2515 return ErrIntOverflowGenerated
2516 }
2517 if iNdEx >= l {
2518 return io.ErrUnexpectedEOF
2519 }
2520 b := dAtA[iNdEx]
2521 iNdEx++
2522 stringLen |= (uint64(b) & 0x7F) << shift
2523 if b < 0x80 {
2524 break
2525 }
2526 }
2527 intStringLen := int(stringLen)
2528 if intStringLen < 0 {
2529 return ErrInvalidLengthGenerated
2530 }
2531 postIndex := iNdEx + intStringLen
2532 if postIndex > l {
2533 return io.ErrUnexpectedEOF
2534 }
2535 m.Namespace = string(dAtA[iNdEx:postIndex])
2536 iNdEx = postIndex
2537 default:
2538 iNdEx = preIndex
2539 skippy, err := skipGenerated(dAtA[iNdEx:])
2540 if err != nil {
2541 return err
2542 }
2543 if skippy < 0 {
2544 return ErrInvalidLengthGenerated
2545 }
2546 if (iNdEx + skippy) > l {
2547 return io.ErrUnexpectedEOF
2548 }
2549 iNdEx += skippy
2550 }
2551 }
2552
2553 if iNdEx > l {
2554 return io.ErrUnexpectedEOF
2555 }
2556 return nil
2557}
2558func (m *SubjectAccessReview) Unmarshal(dAtA []byte) error {
2559 l := len(dAtA)
2560 iNdEx := 0
2561 for iNdEx < l {
2562 preIndex := iNdEx
2563 var wire uint64
2564 for shift := uint(0); ; shift += 7 {
2565 if shift >= 64 {
2566 return ErrIntOverflowGenerated
2567 }
2568 if iNdEx >= l {
2569 return io.ErrUnexpectedEOF
2570 }
2571 b := dAtA[iNdEx]
2572 iNdEx++
2573 wire |= (uint64(b) & 0x7F) << shift
2574 if b < 0x80 {
2575 break
2576 }
2577 }
2578 fieldNum := int32(wire >> 3)
2579 wireType := int(wire & 0x7)
2580 if wireType == 4 {
2581 return fmt.Errorf("proto: SubjectAccessReview: wiretype end group for non-group")
2582 }
2583 if fieldNum <= 0 {
2584 return fmt.Errorf("proto: SubjectAccessReview: illegal tag %d (wire type %d)", fieldNum, wire)
2585 }
2586 switch fieldNum {
2587 case 1:
2588 if wireType != 2 {
2589 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2590 }
2591 var msglen int
2592 for shift := uint(0); ; shift += 7 {
2593 if shift >= 64 {
2594 return ErrIntOverflowGenerated
2595 }
2596 if iNdEx >= l {
2597 return io.ErrUnexpectedEOF
2598 }
2599 b := dAtA[iNdEx]
2600 iNdEx++
2601 msglen |= (int(b) & 0x7F) << shift
2602 if b < 0x80 {
2603 break
2604 }
2605 }
2606 if msglen < 0 {
2607 return ErrInvalidLengthGenerated
2608 }
2609 postIndex := iNdEx + msglen
2610 if postIndex > l {
2611 return io.ErrUnexpectedEOF
2612 }
2613 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2614 return err
2615 }
2616 iNdEx = postIndex
2617 case 2:
2618 if wireType != 2 {
2619 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2620 }
2621 var msglen int
2622 for shift := uint(0); ; shift += 7 {
2623 if shift >= 64 {
2624 return ErrIntOverflowGenerated
2625 }
2626 if iNdEx >= l {
2627 return io.ErrUnexpectedEOF
2628 }
2629 b := dAtA[iNdEx]
2630 iNdEx++
2631 msglen |= (int(b) & 0x7F) << shift
2632 if b < 0x80 {
2633 break
2634 }
2635 }
2636 if msglen < 0 {
2637 return ErrInvalidLengthGenerated
2638 }
2639 postIndex := iNdEx + msglen
2640 if postIndex > l {
2641 return io.ErrUnexpectedEOF
2642 }
2643 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2644 return err
2645 }
2646 iNdEx = postIndex
2647 case 3:
2648 if wireType != 2 {
2649 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2650 }
2651 var msglen int
2652 for shift := uint(0); ; shift += 7 {
2653 if shift >= 64 {
2654 return ErrIntOverflowGenerated
2655 }
2656 if iNdEx >= l {
2657 return io.ErrUnexpectedEOF
2658 }
2659 b := dAtA[iNdEx]
2660 iNdEx++
2661 msglen |= (int(b) & 0x7F) << shift
2662 if b < 0x80 {
2663 break
2664 }
2665 }
2666 if msglen < 0 {
2667 return ErrInvalidLengthGenerated
2668 }
2669 postIndex := iNdEx + msglen
2670 if postIndex > l {
2671 return io.ErrUnexpectedEOF
2672 }
2673 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2674 return err
2675 }
2676 iNdEx = postIndex
2677 default:
2678 iNdEx = preIndex
2679 skippy, err := skipGenerated(dAtA[iNdEx:])
2680 if err != nil {
2681 return err
2682 }
2683 if skippy < 0 {
2684 return ErrInvalidLengthGenerated
2685 }
2686 if (iNdEx + skippy) > l {
2687 return io.ErrUnexpectedEOF
2688 }
2689 iNdEx += skippy
2690 }
2691 }
2692
2693 if iNdEx > l {
2694 return io.ErrUnexpectedEOF
2695 }
2696 return nil
2697}
2698func (m *SubjectAccessReviewSpec) Unmarshal(dAtA []byte) error {
2699 l := len(dAtA)
2700 iNdEx := 0
2701 for iNdEx < l {
2702 preIndex := iNdEx
2703 var wire uint64
2704 for shift := uint(0); ; shift += 7 {
2705 if shift >= 64 {
2706 return ErrIntOverflowGenerated
2707 }
2708 if iNdEx >= l {
2709 return io.ErrUnexpectedEOF
2710 }
2711 b := dAtA[iNdEx]
2712 iNdEx++
2713 wire |= (uint64(b) & 0x7F) << shift
2714 if b < 0x80 {
2715 break
2716 }
2717 }
2718 fieldNum := int32(wire >> 3)
2719 wireType := int(wire & 0x7)
2720 if wireType == 4 {
2721 return fmt.Errorf("proto: SubjectAccessReviewSpec: wiretype end group for non-group")
2722 }
2723 if fieldNum <= 0 {
2724 return fmt.Errorf("proto: SubjectAccessReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2725 }
2726 switch fieldNum {
2727 case 1:
2728 if wireType != 2 {
2729 return fmt.Errorf("proto: wrong wireType = %d for field ResourceAttributes", wireType)
2730 }
2731 var msglen int
2732 for shift := uint(0); ; shift += 7 {
2733 if shift >= 64 {
2734 return ErrIntOverflowGenerated
2735 }
2736 if iNdEx >= l {
2737 return io.ErrUnexpectedEOF
2738 }
2739 b := dAtA[iNdEx]
2740 iNdEx++
2741 msglen |= (int(b) & 0x7F) << shift
2742 if b < 0x80 {
2743 break
2744 }
2745 }
2746 if msglen < 0 {
2747 return ErrInvalidLengthGenerated
2748 }
2749 postIndex := iNdEx + msglen
2750 if postIndex > l {
2751 return io.ErrUnexpectedEOF
2752 }
2753 if m.ResourceAttributes == nil {
2754 m.ResourceAttributes = &ResourceAttributes{}
2755 }
2756 if err := m.ResourceAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2757 return err
2758 }
2759 iNdEx = postIndex
2760 case 2:
2761 if wireType != 2 {
2762 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceAttributes", wireType)
2763 }
2764 var msglen int
2765 for shift := uint(0); ; shift += 7 {
2766 if shift >= 64 {
2767 return ErrIntOverflowGenerated
2768 }
2769 if iNdEx >= l {
2770 return io.ErrUnexpectedEOF
2771 }
2772 b := dAtA[iNdEx]
2773 iNdEx++
2774 msglen |= (int(b) & 0x7F) << shift
2775 if b < 0x80 {
2776 break
2777 }
2778 }
2779 if msglen < 0 {
2780 return ErrInvalidLengthGenerated
2781 }
2782 postIndex := iNdEx + msglen
2783 if postIndex > l {
2784 return io.ErrUnexpectedEOF
2785 }
2786 if m.NonResourceAttributes == nil {
2787 m.NonResourceAttributes = &NonResourceAttributes{}
2788 }
2789 if err := m.NonResourceAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2790 return err
2791 }
2792 iNdEx = postIndex
2793 case 3:
2794 if wireType != 2 {
2795 return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
2796 }
2797 var stringLen uint64
2798 for shift := uint(0); ; shift += 7 {
2799 if shift >= 64 {
2800 return ErrIntOverflowGenerated
2801 }
2802 if iNdEx >= l {
2803 return io.ErrUnexpectedEOF
2804 }
2805 b := dAtA[iNdEx]
2806 iNdEx++
2807 stringLen |= (uint64(b) & 0x7F) << shift
2808 if b < 0x80 {
2809 break
2810 }
2811 }
2812 intStringLen := int(stringLen)
2813 if intStringLen < 0 {
2814 return ErrInvalidLengthGenerated
2815 }
2816 postIndex := iNdEx + intStringLen
2817 if postIndex > l {
2818 return io.ErrUnexpectedEOF
2819 }
2820 m.User = string(dAtA[iNdEx:postIndex])
2821 iNdEx = postIndex
2822 case 4:
2823 if wireType != 2 {
2824 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
2825 }
2826 var stringLen uint64
2827 for shift := uint(0); ; shift += 7 {
2828 if shift >= 64 {
2829 return ErrIntOverflowGenerated
2830 }
2831 if iNdEx >= l {
2832 return io.ErrUnexpectedEOF
2833 }
2834 b := dAtA[iNdEx]
2835 iNdEx++
2836 stringLen |= (uint64(b) & 0x7F) << shift
2837 if b < 0x80 {
2838 break
2839 }
2840 }
2841 intStringLen := int(stringLen)
2842 if intStringLen < 0 {
2843 return ErrInvalidLengthGenerated
2844 }
2845 postIndex := iNdEx + intStringLen
2846 if postIndex > l {
2847 return io.ErrUnexpectedEOF
2848 }
2849 m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
2850 iNdEx = postIndex
2851 case 5:
2852 if wireType != 2 {
2853 return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
2854 }
2855 var msglen int
2856 for shift := uint(0); ; shift += 7 {
2857 if shift >= 64 {
2858 return ErrIntOverflowGenerated
2859 }
2860 if iNdEx >= l {
2861 return io.ErrUnexpectedEOF
2862 }
2863 b := dAtA[iNdEx]
2864 iNdEx++
2865 msglen |= (int(b) & 0x7F) << shift
2866 if b < 0x80 {
2867 break
2868 }
2869 }
2870 if msglen < 0 {
2871 return ErrInvalidLengthGenerated
2872 }
2873 postIndex := iNdEx + msglen
2874 if postIndex > l {
2875 return io.ErrUnexpectedEOF
2876 }
2877 if m.Extra == nil {
2878 m.Extra = make(map[string]ExtraValue)
2879 }
2880 var mapkey string
2881 mapvalue := &ExtraValue{}
2882 for iNdEx < postIndex {
2883 entryPreIndex := iNdEx
2884 var wire uint64
2885 for shift := uint(0); ; shift += 7 {
2886 if shift >= 64 {
2887 return ErrIntOverflowGenerated
2888 }
2889 if iNdEx >= l {
2890 return io.ErrUnexpectedEOF
2891 }
2892 b := dAtA[iNdEx]
2893 iNdEx++
2894 wire |= (uint64(b) & 0x7F) << shift
2895 if b < 0x80 {
2896 break
2897 }
2898 }
2899 fieldNum := int32(wire >> 3)
2900 if fieldNum == 1 {
2901 var stringLenmapkey uint64
2902 for shift := uint(0); ; shift += 7 {
2903 if shift >= 64 {
2904 return ErrIntOverflowGenerated
2905 }
2906 if iNdEx >= l {
2907 return io.ErrUnexpectedEOF
2908 }
2909 b := dAtA[iNdEx]
2910 iNdEx++
2911 stringLenmapkey |= (uint64(b) & 0x7F) << shift
2912 if b < 0x80 {
2913 break
2914 }
2915 }
2916 intStringLenmapkey := int(stringLenmapkey)
2917 if intStringLenmapkey < 0 {
2918 return ErrInvalidLengthGenerated
2919 }
2920 postStringIndexmapkey := iNdEx + intStringLenmapkey
2921 if postStringIndexmapkey > l {
2922 return io.ErrUnexpectedEOF
2923 }
2924 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
2925 iNdEx = postStringIndexmapkey
2926 } else if fieldNum == 2 {
2927 var mapmsglen int
2928 for shift := uint(0); ; shift += 7 {
2929 if shift >= 64 {
2930 return ErrIntOverflowGenerated
2931 }
2932 if iNdEx >= l {
2933 return io.ErrUnexpectedEOF
2934 }
2935 b := dAtA[iNdEx]
2936 iNdEx++
2937 mapmsglen |= (int(b) & 0x7F) << shift
2938 if b < 0x80 {
2939 break
2940 }
2941 }
2942 if mapmsglen < 0 {
2943 return ErrInvalidLengthGenerated
2944 }
2945 postmsgIndex := iNdEx + mapmsglen
2946 if mapmsglen < 0 {
2947 return ErrInvalidLengthGenerated
2948 }
2949 if postmsgIndex > l {
2950 return io.ErrUnexpectedEOF
2951 }
2952 mapvalue = &ExtraValue{}
2953 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
2954 return err
2955 }
2956 iNdEx = postmsgIndex
2957 } else {
2958 iNdEx = entryPreIndex
2959 skippy, err := skipGenerated(dAtA[iNdEx:])
2960 if err != nil {
2961 return err
2962 }
2963 if skippy < 0 {
2964 return ErrInvalidLengthGenerated
2965 }
2966 if (iNdEx + skippy) > postIndex {
2967 return io.ErrUnexpectedEOF
2968 }
2969 iNdEx += skippy
2970 }
2971 }
2972 m.Extra[mapkey] = *mapvalue
2973 iNdEx = postIndex
2974 case 6:
2975 if wireType != 2 {
2976 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
2977 }
2978 var stringLen uint64
2979 for shift := uint(0); ; shift += 7 {
2980 if shift >= 64 {
2981 return ErrIntOverflowGenerated
2982 }
2983 if iNdEx >= l {
2984 return io.ErrUnexpectedEOF
2985 }
2986 b := dAtA[iNdEx]
2987 iNdEx++
2988 stringLen |= (uint64(b) & 0x7F) << shift
2989 if b < 0x80 {
2990 break
2991 }
2992 }
2993 intStringLen := int(stringLen)
2994 if intStringLen < 0 {
2995 return ErrInvalidLengthGenerated
2996 }
2997 postIndex := iNdEx + intStringLen
2998 if postIndex > l {
2999 return io.ErrUnexpectedEOF
3000 }
3001 m.UID = string(dAtA[iNdEx:postIndex])
3002 iNdEx = postIndex
3003 default:
3004 iNdEx = preIndex
3005 skippy, err := skipGenerated(dAtA[iNdEx:])
3006 if err != nil {
3007 return err
3008 }
3009 if skippy < 0 {
3010 return ErrInvalidLengthGenerated
3011 }
3012 if (iNdEx + skippy) > l {
3013 return io.ErrUnexpectedEOF
3014 }
3015 iNdEx += skippy
3016 }
3017 }
3018
3019 if iNdEx > l {
3020 return io.ErrUnexpectedEOF
3021 }
3022 return nil
3023}
3024func (m *SubjectAccessReviewStatus) Unmarshal(dAtA []byte) error {
3025 l := len(dAtA)
3026 iNdEx := 0
3027 for iNdEx < l {
3028 preIndex := iNdEx
3029 var wire uint64
3030 for shift := uint(0); ; shift += 7 {
3031 if shift >= 64 {
3032 return ErrIntOverflowGenerated
3033 }
3034 if iNdEx >= l {
3035 return io.ErrUnexpectedEOF
3036 }
3037 b := dAtA[iNdEx]
3038 iNdEx++
3039 wire |= (uint64(b) & 0x7F) << shift
3040 if b < 0x80 {
3041 break
3042 }
3043 }
3044 fieldNum := int32(wire >> 3)
3045 wireType := int(wire & 0x7)
3046 if wireType == 4 {
3047 return fmt.Errorf("proto: SubjectAccessReviewStatus: wiretype end group for non-group")
3048 }
3049 if fieldNum <= 0 {
3050 return fmt.Errorf("proto: SubjectAccessReviewStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3051 }
3052 switch fieldNum {
3053 case 1:
3054 if wireType != 0 {
3055 return fmt.Errorf("proto: wrong wireType = %d for field Allowed", wireType)
3056 }
3057 var v int
3058 for shift := uint(0); ; shift += 7 {
3059 if shift >= 64 {
3060 return ErrIntOverflowGenerated
3061 }
3062 if iNdEx >= l {
3063 return io.ErrUnexpectedEOF
3064 }
3065 b := dAtA[iNdEx]
3066 iNdEx++
3067 v |= (int(b) & 0x7F) << shift
3068 if b < 0x80 {
3069 break
3070 }
3071 }
3072 m.Allowed = bool(v != 0)
3073 case 2:
3074 if wireType != 2 {
3075 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
3076 }
3077 var stringLen uint64
3078 for shift := uint(0); ; shift += 7 {
3079 if shift >= 64 {
3080 return ErrIntOverflowGenerated
3081 }
3082 if iNdEx >= l {
3083 return io.ErrUnexpectedEOF
3084 }
3085 b := dAtA[iNdEx]
3086 iNdEx++
3087 stringLen |= (uint64(b) & 0x7F) << shift
3088 if b < 0x80 {
3089 break
3090 }
3091 }
3092 intStringLen := int(stringLen)
3093 if intStringLen < 0 {
3094 return ErrInvalidLengthGenerated
3095 }
3096 postIndex := iNdEx + intStringLen
3097 if postIndex > l {
3098 return io.ErrUnexpectedEOF
3099 }
3100 m.Reason = string(dAtA[iNdEx:postIndex])
3101 iNdEx = postIndex
3102 case 3:
3103 if wireType != 2 {
3104 return fmt.Errorf("proto: wrong wireType = %d for field EvaluationError", wireType)
3105 }
3106 var stringLen uint64
3107 for shift := uint(0); ; shift += 7 {
3108 if shift >= 64 {
3109 return ErrIntOverflowGenerated
3110 }
3111 if iNdEx >= l {
3112 return io.ErrUnexpectedEOF
3113 }
3114 b := dAtA[iNdEx]
3115 iNdEx++
3116 stringLen |= (uint64(b) & 0x7F) << shift
3117 if b < 0x80 {
3118 break
3119 }
3120 }
3121 intStringLen := int(stringLen)
3122 if intStringLen < 0 {
3123 return ErrInvalidLengthGenerated
3124 }
3125 postIndex := iNdEx + intStringLen
3126 if postIndex > l {
3127 return io.ErrUnexpectedEOF
3128 }
3129 m.EvaluationError = string(dAtA[iNdEx:postIndex])
3130 iNdEx = postIndex
3131 case 4:
3132 if wireType != 0 {
3133 return fmt.Errorf("proto: wrong wireType = %d for field Denied", wireType)
3134 }
3135 var v int
3136 for shift := uint(0); ; shift += 7 {
3137 if shift >= 64 {
3138 return ErrIntOverflowGenerated
3139 }
3140 if iNdEx >= l {
3141 return io.ErrUnexpectedEOF
3142 }
3143 b := dAtA[iNdEx]
3144 iNdEx++
3145 v |= (int(b) & 0x7F) << shift
3146 if b < 0x80 {
3147 break
3148 }
3149 }
3150 m.Denied = bool(v != 0)
3151 default:
3152 iNdEx = preIndex
3153 skippy, err := skipGenerated(dAtA[iNdEx:])
3154 if err != nil {
3155 return err
3156 }
3157 if skippy < 0 {
3158 return ErrInvalidLengthGenerated
3159 }
3160 if (iNdEx + skippy) > l {
3161 return io.ErrUnexpectedEOF
3162 }
3163 iNdEx += skippy
3164 }
3165 }
3166
3167 if iNdEx > l {
3168 return io.ErrUnexpectedEOF
3169 }
3170 return nil
3171}
3172func (m *SubjectRulesReviewStatus) Unmarshal(dAtA []byte) error {
3173 l := len(dAtA)
3174 iNdEx := 0
3175 for iNdEx < l {
3176 preIndex := iNdEx
3177 var wire uint64
3178 for shift := uint(0); ; shift += 7 {
3179 if shift >= 64 {
3180 return ErrIntOverflowGenerated
3181 }
3182 if iNdEx >= l {
3183 return io.ErrUnexpectedEOF
3184 }
3185 b := dAtA[iNdEx]
3186 iNdEx++
3187 wire |= (uint64(b) & 0x7F) << shift
3188 if b < 0x80 {
3189 break
3190 }
3191 }
3192 fieldNum := int32(wire >> 3)
3193 wireType := int(wire & 0x7)
3194 if wireType == 4 {
3195 return fmt.Errorf("proto: SubjectRulesReviewStatus: wiretype end group for non-group")
3196 }
3197 if fieldNum <= 0 {
3198 return fmt.Errorf("proto: SubjectRulesReviewStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3199 }
3200 switch fieldNum {
3201 case 1:
3202 if wireType != 2 {
3203 return fmt.Errorf("proto: wrong wireType = %d for field ResourceRules", wireType)
3204 }
3205 var msglen int
3206 for shift := uint(0); ; shift += 7 {
3207 if shift >= 64 {
3208 return ErrIntOverflowGenerated
3209 }
3210 if iNdEx >= l {
3211 return io.ErrUnexpectedEOF
3212 }
3213 b := dAtA[iNdEx]
3214 iNdEx++
3215 msglen |= (int(b) & 0x7F) << shift
3216 if b < 0x80 {
3217 break
3218 }
3219 }
3220 if msglen < 0 {
3221 return ErrInvalidLengthGenerated
3222 }
3223 postIndex := iNdEx + msglen
3224 if postIndex > l {
3225 return io.ErrUnexpectedEOF
3226 }
3227 m.ResourceRules = append(m.ResourceRules, ResourceRule{})
3228 if err := m.ResourceRules[len(m.ResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3229 return err
3230 }
3231 iNdEx = postIndex
3232 case 2:
3233 if wireType != 2 {
3234 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceRules", wireType)
3235 }
3236 var msglen int
3237 for shift := uint(0); ; shift += 7 {
3238 if shift >= 64 {
3239 return ErrIntOverflowGenerated
3240 }
3241 if iNdEx >= l {
3242 return io.ErrUnexpectedEOF
3243 }
3244 b := dAtA[iNdEx]
3245 iNdEx++
3246 msglen |= (int(b) & 0x7F) << shift
3247 if b < 0x80 {
3248 break
3249 }
3250 }
3251 if msglen < 0 {
3252 return ErrInvalidLengthGenerated
3253 }
3254 postIndex := iNdEx + msglen
3255 if postIndex > l {
3256 return io.ErrUnexpectedEOF
3257 }
3258 m.NonResourceRules = append(m.NonResourceRules, NonResourceRule{})
3259 if err := m.NonResourceRules[len(m.NonResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3260 return err
3261 }
3262 iNdEx = postIndex
3263 case 3:
3264 if wireType != 0 {
3265 return fmt.Errorf("proto: wrong wireType = %d for field Incomplete", wireType)
3266 }
3267 var v int
3268 for shift := uint(0); ; shift += 7 {
3269 if shift >= 64 {
3270 return ErrIntOverflowGenerated
3271 }
3272 if iNdEx >= l {
3273 return io.ErrUnexpectedEOF
3274 }
3275 b := dAtA[iNdEx]
3276 iNdEx++
3277 v |= (int(b) & 0x7F) << shift
3278 if b < 0x80 {
3279 break
3280 }
3281 }
3282 m.Incomplete = bool(v != 0)
3283 case 4:
3284 if wireType != 2 {
3285 return fmt.Errorf("proto: wrong wireType = %d for field EvaluationError", wireType)
3286 }
3287 var stringLen uint64
3288 for shift := uint(0); ; shift += 7 {
3289 if shift >= 64 {
3290 return ErrIntOverflowGenerated
3291 }
3292 if iNdEx >= l {
3293 return io.ErrUnexpectedEOF
3294 }
3295 b := dAtA[iNdEx]
3296 iNdEx++
3297 stringLen |= (uint64(b) & 0x7F) << shift
3298 if b < 0x80 {
3299 break
3300 }
3301 }
3302 intStringLen := int(stringLen)
3303 if intStringLen < 0 {
3304 return ErrInvalidLengthGenerated
3305 }
3306 postIndex := iNdEx + intStringLen
3307 if postIndex > l {
3308 return io.ErrUnexpectedEOF
3309 }
3310 m.EvaluationError = string(dAtA[iNdEx:postIndex])
3311 iNdEx = postIndex
3312 default:
3313 iNdEx = preIndex
3314 skippy, err := skipGenerated(dAtA[iNdEx:])
3315 if err != nil {
3316 return err
3317 }
3318 if skippy < 0 {
3319 return ErrInvalidLengthGenerated
3320 }
3321 if (iNdEx + skippy) > l {
3322 return io.ErrUnexpectedEOF
3323 }
3324 iNdEx += skippy
3325 }
3326 }
3327
3328 if iNdEx > l {
3329 return io.ErrUnexpectedEOF
3330 }
3331 return nil
3332}
3333func skipGenerated(dAtA []byte) (n int, err error) {
3334 l := len(dAtA)
3335 iNdEx := 0
3336 for iNdEx < l {
3337 var wire uint64
3338 for shift := uint(0); ; shift += 7 {
3339 if shift >= 64 {
3340 return 0, ErrIntOverflowGenerated
3341 }
3342 if iNdEx >= l {
3343 return 0, io.ErrUnexpectedEOF
3344 }
3345 b := dAtA[iNdEx]
3346 iNdEx++
3347 wire |= (uint64(b) & 0x7F) << shift
3348 if b < 0x80 {
3349 break
3350 }
3351 }
3352 wireType := int(wire & 0x7)
3353 switch wireType {
3354 case 0:
3355 for shift := uint(0); ; shift += 7 {
3356 if shift >= 64 {
3357 return 0, ErrIntOverflowGenerated
3358 }
3359 if iNdEx >= l {
3360 return 0, io.ErrUnexpectedEOF
3361 }
3362 iNdEx++
3363 if dAtA[iNdEx-1] < 0x80 {
3364 break
3365 }
3366 }
3367 return iNdEx, nil
3368 case 1:
3369 iNdEx += 8
3370 return iNdEx, nil
3371 case 2:
3372 var length int
3373 for shift := uint(0); ; shift += 7 {
3374 if shift >= 64 {
3375 return 0, ErrIntOverflowGenerated
3376 }
3377 if iNdEx >= l {
3378 return 0, io.ErrUnexpectedEOF
3379 }
3380 b := dAtA[iNdEx]
3381 iNdEx++
3382 length |= (int(b) & 0x7F) << shift
3383 if b < 0x80 {
3384 break
3385 }
3386 }
3387 iNdEx += length
3388 if length < 0 {
3389 return 0, ErrInvalidLengthGenerated
3390 }
3391 return iNdEx, nil
3392 case 3:
3393 for {
3394 var innerWire uint64
3395 var start int = iNdEx
3396 for shift := uint(0); ; shift += 7 {
3397 if shift >= 64 {
3398 return 0, ErrIntOverflowGenerated
3399 }
3400 if iNdEx >= l {
3401 return 0, io.ErrUnexpectedEOF
3402 }
3403 b := dAtA[iNdEx]
3404 iNdEx++
3405 innerWire |= (uint64(b) & 0x7F) << shift
3406 if b < 0x80 {
3407 break
3408 }
3409 }
3410 innerWireType := int(innerWire & 0x7)
3411 if innerWireType == 4 {
3412 break
3413 }
3414 next, err := skipGenerated(dAtA[start:])
3415 if err != nil {
3416 return 0, err
3417 }
3418 iNdEx = start + next
3419 }
3420 return iNdEx, nil
3421 case 4:
3422 return iNdEx, nil
3423 case 5:
3424 iNdEx += 4
3425 return iNdEx, nil
3426 default:
3427 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
3428 }
3429 }
3430 panic("unreachable")
3431}
3432
3433var (
3434 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
3435 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
3436)
3437
3438func init() {
3439 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/authorization/v1/generated.proto", fileDescriptorGenerated)
3440}
3441
3442var fileDescriptorGenerated = []byte{
3443 // 1140 bytes of a gzipped FileDescriptorProto
3444 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4d, 0x6f, 0x1b, 0xc5,
3445 0x1b, 0xf7, 0xae, 0xed, 0xc4, 0x1e, 0x37, 0xff, 0xa4, 0x13, 0xa5, 0xd9, 0xa6, 0xfa, 0xdb, 0xd1,
3446 0x22, 0x41, 0x2a, 0xca, 0x2e, 0xb1, 0xda, 0x26, 0xaa, 0x54, 0xa1, 0x58, 0x89, 0x50, 0xa4, 0xb6,
3447 0x54, 0x13, 0x25, 0x12, 0x45, 0x20, 0xc6, 0xeb, 0x89, 0xbd, 0xc4, 0xde, 0x5d, 0x66, 0x66, 0x1d,
3448 0xc2, 0xa9, 0x12, 0x5f, 0x80, 0x23, 0x07, 0x0e, 0x7c, 0x03, 0x2e, 0x48, 0xdc, 0x38, 0x70, 0x40,
3449 0x39, 0xf6, 0x58, 0x24, 0x64, 0x91, 0xe5, 0xcc, 0x77, 0x40, 0x33, 0x3b, 0xf6, 0xae, 0x93, 0xb5,
3450 0x9b, 0x70, 0xa0, 0x97, 0xde, 0x76, 0x9f, 0xdf, 0xef, 0x79, 0x99, 0xe7, 0x65, 0xe6, 0x01, 0xdb,
3451 0x47, 0x9b, 0xcc, 0x72, 0x7d, 0xfb, 0x28, 0x6c, 0x12, 0xea, 0x11, 0x4e, 0x98, 0xdd, 0x27, 0x5e,
3452 0xcb, 0xa7, 0xb6, 0x02, 0x70, 0xe0, 0xda, 0x38, 0xe4, 0x1d, 0x9f, 0xba, 0x5f, 0x63, 0xee, 0xfa,
3453 0x9e, 0xdd, 0x5f, 0xb7, 0xdb, 0xc4, 0x23, 0x14, 0x73, 0xd2, 0xb2, 0x02, 0xea, 0x73, 0x1f, 0xde,
3454 0x8a, 0xc9, 0x16, 0x0e, 0x5c, 0x6b, 0x8c, 0x6c, 0xf5, 0xd7, 0x57, 0xde, 0x6b, 0xbb, 0xbc, 0x13,
3455 0x36, 0x2d, 0xc7, 0xef, 0xd9, 0x6d, 0xbf, 0xed, 0xdb, 0x52, 0xa7, 0x19, 0x1e, 0xca, 0x3f, 0xf9,
3456 0x23, 0xbf, 0x62, 0x5b, 0x2b, 0x77, 0x13, 0xc7, 0x3d, 0xec, 0x74, 0x5c, 0x8f, 0xd0, 0x13, 0x3b,
3457 0x38, 0x6a, 0x0b, 0x01, 0xb3, 0x7b, 0x84, 0xe3, 0x8c, 0x08, 0x56, 0xec, 0x49, 0x5a, 0x34, 0xf4,
3458 0xb8, 0xdb, 0x23, 0x17, 0x14, 0xee, 0xbf, 0x4a, 0x81, 0x39, 0x1d, 0xd2, 0xc3, 0xe7, 0xf5, 0xcc,
3459 0x0d, 0x00, 0x76, 0xbe, 0xe2, 0x14, 0x1f, 0xe0, 0x6e, 0x48, 0x60, 0x0d, 0x14, 0x5d, 0x4e, 0x7a,
3460 0xcc, 0xd0, 0x56, 0xf3, 0x6b, 0xe5, 0x46, 0x39, 0x1a, 0xd4, 0x8a, 0xbb, 0x42, 0x80, 0x62, 0xf9,
3461 0x83, 0xd2, 0x77, 0x3f, 0xd4, 0x72, 0xcf, 0xff, 0x58, 0xcd, 0x99, 0x3f, 0xe9, 0xc0, 0x78, 0xe4,
3462 0x3b, 0xb8, 0xbb, 0x17, 0x36, 0xbf, 0x20, 0x0e, 0xdf, 0x72, 0x1c, 0xc2, 0x18, 0x22, 0x7d, 0x97,
3463 0x1c, 0xc3, 0xcf, 0x41, 0x49, 0x9c, 0xac, 0x85, 0x39, 0x36, 0xb4, 0x55, 0x6d, 0xad, 0x52, 0x7f,
3464 0xdf, 0x4a, 0x72, 0x3a, 0x0a, 0xd0, 0x0a, 0x8e, 0xda, 0x42, 0xc0, 0x2c, 0xc1, 0xb6, 0xfa, 0xeb,
3465 0xd6, 0x47, 0xd2, 0xd6, 0x63, 0xc2, 0x71, 0x03, 0x9e, 0x0e, 0x6a, 0xb9, 0x68, 0x50, 0x03, 0x89,
3466 0x0c, 0x8d, 0xac, 0xc2, 0x03, 0x50, 0x60, 0x01, 0x71, 0x0c, 0x5d, 0x5a, 0xbf, 0x6b, 0x4d, 0xa9,
3467 0x98, 0x95, 0x11, 0xe1, 0x5e, 0x40, 0x9c, 0xc6, 0x35, 0xe5, 0xa1, 0x20, 0xfe, 0x90, 0xb4, 0x07,
3468 0x3f, 0x03, 0x33, 0x8c, 0x63, 0x1e, 0x32, 0x23, 0x2f, 0x2d, 0xdf, 0xbf, 0xb2, 0x65, 0xa9, 0xdd,
3469 0xf8, 0x9f, 0xb2, 0x3d, 0x13, 0xff, 0x23, 0x65, 0xd5, 0xfc, 0x04, 0x2c, 0x3d, 0xf1, 0x3d, 0x44,
3470 0x98, 0x1f, 0x52, 0x87, 0x6c, 0x71, 0x4e, 0xdd, 0x66, 0xc8, 0x09, 0x83, 0xab, 0xa0, 0x10, 0x60,
3471 0xde, 0x91, 0xe9, 0x2a, 0x27, 0xa1, 0x3d, 0xc5, 0xbc, 0x83, 0x24, 0x22, 0x18, 0x7d, 0x42, 0x9b,
3472 0xf2, 0xc8, 0x29, 0xc6, 0x01, 0xa1, 0x4d, 0x24, 0x11, 0xf3, 0x4b, 0x30, 0x9f, 0x32, 0x8e, 0xc2,
3473 0xae, 0xac, 0xa8, 0x80, 0xc6, 0x2a, 0x2a, 0x34, 0x18, 0x8a, 0xe5, 0xf0, 0x21, 0x98, 0xf7, 0x12,
3474 0x9d, 0x7d, 0xf4, 0x88, 0x19, 0xba, 0xa4, 0x2e, 0x46, 0x83, 0x5a, 0xda, 0x9c, 0x80, 0xd0, 0x79,
3475 0xae, 0xf9, 0x8b, 0x0e, 0x60, 0xc6, 0x69, 0x6c, 0x50, 0xf6, 0x70, 0x8f, 0xb0, 0x00, 0x3b, 0x44,
3476 0x1d, 0xe9, 0xba, 0x0a, 0xb8, 0xfc, 0x64, 0x08, 0xa0, 0x84, 0xf3, 0xea, 0xc3, 0xc1, 0xb7, 0x40,
3477 0xb1, 0x4d, 0xfd, 0x30, 0x90, 0x85, 0x29, 0x37, 0xe6, 0x14, 0xa5, 0xf8, 0xa1, 0x10, 0xa2, 0x18,
3478 0x83, 0xb7, 0xc1, 0x6c, 0x9f, 0x50, 0xe6, 0xfa, 0x9e, 0x51, 0x90, 0xb4, 0x79, 0x45, 0x9b, 0x3d,
3479 0x88, 0xc5, 0x68, 0x88, 0xc3, 0x3b, 0xa0, 0x44, 0x55, 0xe0, 0x46, 0x51, 0x72, 0x17, 0x14, 0xb7,
3480 0x34, 0xca, 0xe0, 0x88, 0x01, 0xef, 0x81, 0x0a, 0x0b, 0x9b, 0x23, 0x85, 0x19, 0xa9, 0xb0, 0xa8,
3481 0x14, 0x2a, 0x7b, 0x09, 0x84, 0xd2, 0x3c, 0x71, 0x2c, 0x71, 0x46, 0x63, 0x76, 0xfc, 0x58, 0x22,
3482 0x05, 0x48, 0x22, 0xe6, 0xaf, 0x1a, 0xb8, 0x76, 0xb5, 0x8a, 0xbd, 0x0b, 0xca, 0x38, 0x70, 0xe5,
3483 0xb1, 0x87, 0xb5, 0x9a, 0x13, 0x79, 0xdd, 0x7a, 0xba, 0x1b, 0x0b, 0x51, 0x82, 0x0b, 0xf2, 0x30,
3484 0x18, 0xd1, 0xd2, 0x23, 0xf2, 0xd0, 0x25, 0x43, 0x09, 0x0e, 0x37, 0xc0, 0xdc, 0xf0, 0x47, 0x16,
3485 0xc9, 0x28, 0x48, 0x85, 0xeb, 0xd1, 0xa0, 0x36, 0x87, 0xd2, 0x00, 0x1a, 0xe7, 0x99, 0x3f, 0xeb,
3486 0x60, 0x79, 0x8f, 0x74, 0x0f, 0x5f, 0xcf, 0x5d, 0xf0, 0x6c, 0xec, 0x2e, 0xd8, 0x9c, 0x3e, 0xb1,
3487 0xd9, 0x51, 0xbe, 0xb6, 0xfb, 0xe0, 0x7b, 0x1d, 0xdc, 0x9a, 0x12, 0x13, 0x3c, 0x06, 0x90, 0x5e,
3488 0x18, 0x2f, 0x95, 0x47, 0x7b, 0x6a, 0x2c, 0x17, 0xa7, 0xb2, 0x71, 0x23, 0x1a, 0xd4, 0x32, 0xa6,
3489 0x15, 0x65, 0xb8, 0x80, 0xdf, 0x68, 0x60, 0xc9, 0xcb, 0xba, 0xa9, 0x54, 0x9a, 0xeb, 0x53, 0x9d,
3490 0x67, 0xde, 0x71, 0x8d, 0x9b, 0xd1, 0xa0, 0x96, 0x7d, 0xfd, 0xa1, 0x6c, 0x5f, 0xe2, 0x95, 0xb9,
3491 0x91, 0x4a, 0x8f, 0x18, 0x90, 0xff, 0xae, 0xaf, 0x3e, 0x1e, 0xeb, 0xab, 0x8d, 0xcb, 0xf6, 0x55,
3492 0x2a, 0xc8, 0x89, 0x6d, 0xf5, 0xe9, 0xb9, 0xb6, 0xba, 0x77, 0x99, 0xb6, 0x4a, 0x1b, 0x9e, 0xde,
3493 0x55, 0x8f, 0xc1, 0xca, 0xe4, 0x80, 0xae, 0x7c, 0x39, 0x9b, 0x3f, 0xea, 0x60, 0xf1, 0xcd, 0x33,
3494 0x7f, 0x95, 0xb1, 0xfe, 0xad, 0x00, 0x96, 0xdf, 0x8c, 0xf4, 0xa4, 0x45, 0x27, 0x64, 0x84, 0xaa,
3495 0x67, 0x7c, 0x54, 0x9c, 0x7d, 0x46, 0x28, 0x92, 0x08, 0x34, 0xc1, 0x4c, 0x3b, 0x7e, 0xdd, 0xe2,
3496 0xf7, 0x07, 0x88, 0x04, 0xab, 0xa7, 0x4d, 0x21, 0xb0, 0x05, 0x8a, 0x44, 0xec, 0xad, 0x46, 0x71,
3497 0x35, 0xbf, 0x56, 0xa9, 0x7f, 0xf0, 0x6f, 0x3a, 0xc3, 0x92, 0x9b, 0xef, 0x8e, 0xc7, 0xe9, 0x49,
3498 0xb2, 0x4e, 0x48, 0x19, 0x8a, 0x8d, 0xc3, 0xff, 0x83, 0x7c, 0xe8, 0xb6, 0xd4, 0x6b, 0x5f, 0x51,
3499 0x94, 0xfc, 0xfe, 0xee, 0x36, 0x12, 0xf2, 0x15, 0xac, 0x96, 0x67, 0x69, 0x02, 0x2e, 0x80, 0xfc,
3500 0x11, 0x39, 0x89, 0x07, 0x0a, 0x89, 0x4f, 0xf8, 0x10, 0x14, 0xfb, 0x62, 0xaf, 0x56, 0xf9, 0x7d,
3501 0x67, 0x6a, 0x90, 0xc9, 0x1a, 0x8e, 0x62, 0xad, 0x07, 0xfa, 0xa6, 0x66, 0xfe, 0xae, 0x81, 0x9b,
3502 0x13, 0xdb, 0x4f, 0xac, 0x3b, 0xb8, 0xdb, 0xf5, 0x8f, 0x49, 0x4b, 0xba, 0x2d, 0x25, 0xeb, 0xce,
3503 0x56, 0x2c, 0x46, 0x43, 0x1c, 0xbe, 0x0d, 0x66, 0x28, 0xc1, 0xcc, 0xf7, 0xd4, 0x8a, 0x35, 0xea,
3504 0x5c, 0x24, 0xa5, 0x48, 0xa1, 0x70, 0x0b, 0xcc, 0x13, 0xe1, 0x5e, 0xc6, 0xb5, 0x43, 0xa9, 0x3f,
3505 0xac, 0xd4, 0xb2, 0x52, 0x98, 0xdf, 0x19, 0x87, 0xd1, 0x79, 0xbe, 0x70, 0xd5, 0x22, 0x9e, 0x4b,
3506 0x5a, 0x72, 0x07, 0x2b, 0x25, 0xae, 0xb6, 0xa5, 0x14, 0x29, 0xd4, 0xfc, 0x5b, 0x07, 0xc6, 0xa4,
3507 0xab, 0x0d, 0x1e, 0x26, 0xbb, 0x88, 0x04, 0xe5, 0x3a, 0x54, 0xa9, 0xdf, 0xbe, 0xd4, 0x80, 0x08,
3508 0x8d, 0xc6, 0x92, 0x72, 0x3b, 0x97, 0x96, 0xa6, 0x56, 0x17, 0xf9, 0x0b, 0x29, 0x58, 0xf0, 0xc6,
3509 0x77, 0xe6, 0x78, 0xa9, 0xaa, 0xd4, 0xef, 0x5c, 0x76, 0x1c, 0xa4, 0x37, 0x43, 0x79, 0x5b, 0x38,
3510 0x07, 0x30, 0x74, 0xc1, 0x3e, 0xac, 0x03, 0xe0, 0x7a, 0x8e, 0xdf, 0x0b, 0xba, 0x84, 0x13, 0x99,
3511 0xde, 0x52, 0x72, 0x0f, 0xee, 0x8e, 0x10, 0x94, 0x62, 0x65, 0xd5, 0xa5, 0x70, 0xb5, 0xba, 0x34,
3512 0xd6, 0x4e, 0xcf, 0xaa, 0xb9, 0x17, 0x67, 0xd5, 0xdc, 0xcb, 0xb3, 0x6a, 0xee, 0x79, 0x54, 0xd5,
3513 0x4e, 0xa3, 0xaa, 0xf6, 0x22, 0xaa, 0x6a, 0x2f, 0xa3, 0xaa, 0xf6, 0x67, 0x54, 0xd5, 0xbe, 0xfd,
3514 0xab, 0x9a, 0x7b, 0xa6, 0xf7, 0xd7, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x9f, 0x85, 0x45, 0x74,
3515 0x47, 0x0f, 0x00, 0x00,
3516}