1
2
3
4 package v1
5
6 import (
7 fmt "fmt"
8
9 io "io"
10
11 proto "github.com/gogo/protobuf/proto"
12 k8s_io_api_core_v1 "k8s.io/api/core/v1"
13 v1 "k8s.io/api/core/v1"
14
15 math "math"
16 math_bits "math/bits"
17 reflect "reflect"
18 strings "strings"
19 )
20
21
22 var _ = proto.Marshal
23 var _ = fmt.Errorf
24 var _ = math.Inf
25
26
27
28
29
30 const _ = proto.GoGoProtoPackageIsVersion3
31
32 func (m *AllowedFlexVolume) Reset() { *m = AllowedFlexVolume{} }
33 func (*AllowedFlexVolume) ProtoMessage() {}
34 func (*AllowedFlexVolume) Descriptor() ([]byte, []int) {
35 return fileDescriptor_af65d9655aa67551, []int{0}
36 }
37 func (m *AllowedFlexVolume) XXX_Unmarshal(b []byte) error {
38 return m.Unmarshal(b)
39 }
40 func (m *AllowedFlexVolume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
41 b = b[:cap(b)]
42 n, err := m.MarshalToSizedBuffer(b)
43 if err != nil {
44 return nil, err
45 }
46 return b[:n], nil
47 }
48 func (m *AllowedFlexVolume) XXX_Merge(src proto.Message) {
49 xxx_messageInfo_AllowedFlexVolume.Merge(m, src)
50 }
51 func (m *AllowedFlexVolume) XXX_Size() int {
52 return m.Size()
53 }
54 func (m *AllowedFlexVolume) XXX_DiscardUnknown() {
55 xxx_messageInfo_AllowedFlexVolume.DiscardUnknown(m)
56 }
57
58 var xxx_messageInfo_AllowedFlexVolume proto.InternalMessageInfo
59
60 func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} }
61 func (*FSGroupStrategyOptions) ProtoMessage() {}
62 func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) {
63 return fileDescriptor_af65d9655aa67551, []int{1}
64 }
65 func (m *FSGroupStrategyOptions) XXX_Unmarshal(b []byte) error {
66 return m.Unmarshal(b)
67 }
68 func (m *FSGroupStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
69 b = b[:cap(b)]
70 n, err := m.MarshalToSizedBuffer(b)
71 if err != nil {
72 return nil, err
73 }
74 return b[:n], nil
75 }
76 func (m *FSGroupStrategyOptions) XXX_Merge(src proto.Message) {
77 xxx_messageInfo_FSGroupStrategyOptions.Merge(m, src)
78 }
79 func (m *FSGroupStrategyOptions) XXX_Size() int {
80 return m.Size()
81 }
82 func (m *FSGroupStrategyOptions) XXX_DiscardUnknown() {
83 xxx_messageInfo_FSGroupStrategyOptions.DiscardUnknown(m)
84 }
85
86 var xxx_messageInfo_FSGroupStrategyOptions proto.InternalMessageInfo
87
88 func (m *IDRange) Reset() { *m = IDRange{} }
89 func (*IDRange) ProtoMessage() {}
90 func (*IDRange) Descriptor() ([]byte, []int) {
91 return fileDescriptor_af65d9655aa67551, []int{2}
92 }
93 func (m *IDRange) XXX_Unmarshal(b []byte) error {
94 return m.Unmarshal(b)
95 }
96 func (m *IDRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
97 b = b[:cap(b)]
98 n, err := m.MarshalToSizedBuffer(b)
99 if err != nil {
100 return nil, err
101 }
102 return b[:n], nil
103 }
104 func (m *IDRange) XXX_Merge(src proto.Message) {
105 xxx_messageInfo_IDRange.Merge(m, src)
106 }
107 func (m *IDRange) XXX_Size() int {
108 return m.Size()
109 }
110 func (m *IDRange) XXX_DiscardUnknown() {
111 xxx_messageInfo_IDRange.DiscardUnknown(m)
112 }
113
114 var xxx_messageInfo_IDRange proto.InternalMessageInfo
115
116 func (m *PodSecurityPolicyReview) Reset() { *m = PodSecurityPolicyReview{} }
117 func (*PodSecurityPolicyReview) ProtoMessage() {}
118 func (*PodSecurityPolicyReview) Descriptor() ([]byte, []int) {
119 return fileDescriptor_af65d9655aa67551, []int{3}
120 }
121 func (m *PodSecurityPolicyReview) XXX_Unmarshal(b []byte) error {
122 return m.Unmarshal(b)
123 }
124 func (m *PodSecurityPolicyReview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
125 b = b[:cap(b)]
126 n, err := m.MarshalToSizedBuffer(b)
127 if err != nil {
128 return nil, err
129 }
130 return b[:n], nil
131 }
132 func (m *PodSecurityPolicyReview) XXX_Merge(src proto.Message) {
133 xxx_messageInfo_PodSecurityPolicyReview.Merge(m, src)
134 }
135 func (m *PodSecurityPolicyReview) XXX_Size() int {
136 return m.Size()
137 }
138 func (m *PodSecurityPolicyReview) XXX_DiscardUnknown() {
139 xxx_messageInfo_PodSecurityPolicyReview.DiscardUnknown(m)
140 }
141
142 var xxx_messageInfo_PodSecurityPolicyReview proto.InternalMessageInfo
143
144 func (m *PodSecurityPolicyReviewSpec) Reset() { *m = PodSecurityPolicyReviewSpec{} }
145 func (*PodSecurityPolicyReviewSpec) ProtoMessage() {}
146 func (*PodSecurityPolicyReviewSpec) Descriptor() ([]byte, []int) {
147 return fileDescriptor_af65d9655aa67551, []int{4}
148 }
149 func (m *PodSecurityPolicyReviewSpec) XXX_Unmarshal(b []byte) error {
150 return m.Unmarshal(b)
151 }
152 func (m *PodSecurityPolicyReviewSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
153 b = b[:cap(b)]
154 n, err := m.MarshalToSizedBuffer(b)
155 if err != nil {
156 return nil, err
157 }
158 return b[:n], nil
159 }
160 func (m *PodSecurityPolicyReviewSpec) XXX_Merge(src proto.Message) {
161 xxx_messageInfo_PodSecurityPolicyReviewSpec.Merge(m, src)
162 }
163 func (m *PodSecurityPolicyReviewSpec) XXX_Size() int {
164 return m.Size()
165 }
166 func (m *PodSecurityPolicyReviewSpec) XXX_DiscardUnknown() {
167 xxx_messageInfo_PodSecurityPolicyReviewSpec.DiscardUnknown(m)
168 }
169
170 var xxx_messageInfo_PodSecurityPolicyReviewSpec proto.InternalMessageInfo
171
172 func (m *PodSecurityPolicyReviewStatus) Reset() { *m = PodSecurityPolicyReviewStatus{} }
173 func (*PodSecurityPolicyReviewStatus) ProtoMessage() {}
174 func (*PodSecurityPolicyReviewStatus) Descriptor() ([]byte, []int) {
175 return fileDescriptor_af65d9655aa67551, []int{5}
176 }
177 func (m *PodSecurityPolicyReviewStatus) XXX_Unmarshal(b []byte) error {
178 return m.Unmarshal(b)
179 }
180 func (m *PodSecurityPolicyReviewStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
181 b = b[:cap(b)]
182 n, err := m.MarshalToSizedBuffer(b)
183 if err != nil {
184 return nil, err
185 }
186 return b[:n], nil
187 }
188 func (m *PodSecurityPolicyReviewStatus) XXX_Merge(src proto.Message) {
189 xxx_messageInfo_PodSecurityPolicyReviewStatus.Merge(m, src)
190 }
191 func (m *PodSecurityPolicyReviewStatus) XXX_Size() int {
192 return m.Size()
193 }
194 func (m *PodSecurityPolicyReviewStatus) XXX_DiscardUnknown() {
195 xxx_messageInfo_PodSecurityPolicyReviewStatus.DiscardUnknown(m)
196 }
197
198 var xxx_messageInfo_PodSecurityPolicyReviewStatus proto.InternalMessageInfo
199
200 func (m *PodSecurityPolicySelfSubjectReview) Reset() { *m = PodSecurityPolicySelfSubjectReview{} }
201 func (*PodSecurityPolicySelfSubjectReview) ProtoMessage() {}
202 func (*PodSecurityPolicySelfSubjectReview) Descriptor() ([]byte, []int) {
203 return fileDescriptor_af65d9655aa67551, []int{6}
204 }
205 func (m *PodSecurityPolicySelfSubjectReview) XXX_Unmarshal(b []byte) error {
206 return m.Unmarshal(b)
207 }
208 func (m *PodSecurityPolicySelfSubjectReview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
209 b = b[:cap(b)]
210 n, err := m.MarshalToSizedBuffer(b)
211 if err != nil {
212 return nil, err
213 }
214 return b[:n], nil
215 }
216 func (m *PodSecurityPolicySelfSubjectReview) XXX_Merge(src proto.Message) {
217 xxx_messageInfo_PodSecurityPolicySelfSubjectReview.Merge(m, src)
218 }
219 func (m *PodSecurityPolicySelfSubjectReview) XXX_Size() int {
220 return m.Size()
221 }
222 func (m *PodSecurityPolicySelfSubjectReview) XXX_DiscardUnknown() {
223 xxx_messageInfo_PodSecurityPolicySelfSubjectReview.DiscardUnknown(m)
224 }
225
226 var xxx_messageInfo_PodSecurityPolicySelfSubjectReview proto.InternalMessageInfo
227
228 func (m *PodSecurityPolicySelfSubjectReviewSpec) Reset() {
229 *m = PodSecurityPolicySelfSubjectReviewSpec{}
230 }
231 func (*PodSecurityPolicySelfSubjectReviewSpec) ProtoMessage() {}
232 func (*PodSecurityPolicySelfSubjectReviewSpec) Descriptor() ([]byte, []int) {
233 return fileDescriptor_af65d9655aa67551, []int{7}
234 }
235 func (m *PodSecurityPolicySelfSubjectReviewSpec) XXX_Unmarshal(b []byte) error {
236 return m.Unmarshal(b)
237 }
238 func (m *PodSecurityPolicySelfSubjectReviewSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
239 b = b[:cap(b)]
240 n, err := m.MarshalToSizedBuffer(b)
241 if err != nil {
242 return nil, err
243 }
244 return b[:n], nil
245 }
246 func (m *PodSecurityPolicySelfSubjectReviewSpec) XXX_Merge(src proto.Message) {
247 xxx_messageInfo_PodSecurityPolicySelfSubjectReviewSpec.Merge(m, src)
248 }
249 func (m *PodSecurityPolicySelfSubjectReviewSpec) XXX_Size() int {
250 return m.Size()
251 }
252 func (m *PodSecurityPolicySelfSubjectReviewSpec) XXX_DiscardUnknown() {
253 xxx_messageInfo_PodSecurityPolicySelfSubjectReviewSpec.DiscardUnknown(m)
254 }
255
256 var xxx_messageInfo_PodSecurityPolicySelfSubjectReviewSpec proto.InternalMessageInfo
257
258 func (m *PodSecurityPolicySubjectReview) Reset() { *m = PodSecurityPolicySubjectReview{} }
259 func (*PodSecurityPolicySubjectReview) ProtoMessage() {}
260 func (*PodSecurityPolicySubjectReview) Descriptor() ([]byte, []int) {
261 return fileDescriptor_af65d9655aa67551, []int{8}
262 }
263 func (m *PodSecurityPolicySubjectReview) XXX_Unmarshal(b []byte) error {
264 return m.Unmarshal(b)
265 }
266 func (m *PodSecurityPolicySubjectReview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
267 b = b[:cap(b)]
268 n, err := m.MarshalToSizedBuffer(b)
269 if err != nil {
270 return nil, err
271 }
272 return b[:n], nil
273 }
274 func (m *PodSecurityPolicySubjectReview) XXX_Merge(src proto.Message) {
275 xxx_messageInfo_PodSecurityPolicySubjectReview.Merge(m, src)
276 }
277 func (m *PodSecurityPolicySubjectReview) XXX_Size() int {
278 return m.Size()
279 }
280 func (m *PodSecurityPolicySubjectReview) XXX_DiscardUnknown() {
281 xxx_messageInfo_PodSecurityPolicySubjectReview.DiscardUnknown(m)
282 }
283
284 var xxx_messageInfo_PodSecurityPolicySubjectReview proto.InternalMessageInfo
285
286 func (m *PodSecurityPolicySubjectReviewSpec) Reset() { *m = PodSecurityPolicySubjectReviewSpec{} }
287 func (*PodSecurityPolicySubjectReviewSpec) ProtoMessage() {}
288 func (*PodSecurityPolicySubjectReviewSpec) Descriptor() ([]byte, []int) {
289 return fileDescriptor_af65d9655aa67551, []int{9}
290 }
291 func (m *PodSecurityPolicySubjectReviewSpec) XXX_Unmarshal(b []byte) error {
292 return m.Unmarshal(b)
293 }
294 func (m *PodSecurityPolicySubjectReviewSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
295 b = b[:cap(b)]
296 n, err := m.MarshalToSizedBuffer(b)
297 if err != nil {
298 return nil, err
299 }
300 return b[:n], nil
301 }
302 func (m *PodSecurityPolicySubjectReviewSpec) XXX_Merge(src proto.Message) {
303 xxx_messageInfo_PodSecurityPolicySubjectReviewSpec.Merge(m, src)
304 }
305 func (m *PodSecurityPolicySubjectReviewSpec) XXX_Size() int {
306 return m.Size()
307 }
308 func (m *PodSecurityPolicySubjectReviewSpec) XXX_DiscardUnknown() {
309 xxx_messageInfo_PodSecurityPolicySubjectReviewSpec.DiscardUnknown(m)
310 }
311
312 var xxx_messageInfo_PodSecurityPolicySubjectReviewSpec proto.InternalMessageInfo
313
314 func (m *PodSecurityPolicySubjectReviewStatus) Reset() { *m = PodSecurityPolicySubjectReviewStatus{} }
315 func (*PodSecurityPolicySubjectReviewStatus) ProtoMessage() {}
316 func (*PodSecurityPolicySubjectReviewStatus) Descriptor() ([]byte, []int) {
317 return fileDescriptor_af65d9655aa67551, []int{10}
318 }
319 func (m *PodSecurityPolicySubjectReviewStatus) XXX_Unmarshal(b []byte) error {
320 return m.Unmarshal(b)
321 }
322 func (m *PodSecurityPolicySubjectReviewStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
323 b = b[:cap(b)]
324 n, err := m.MarshalToSizedBuffer(b)
325 if err != nil {
326 return nil, err
327 }
328 return b[:n], nil
329 }
330 func (m *PodSecurityPolicySubjectReviewStatus) XXX_Merge(src proto.Message) {
331 xxx_messageInfo_PodSecurityPolicySubjectReviewStatus.Merge(m, src)
332 }
333 func (m *PodSecurityPolicySubjectReviewStatus) XXX_Size() int {
334 return m.Size()
335 }
336 func (m *PodSecurityPolicySubjectReviewStatus) XXX_DiscardUnknown() {
337 xxx_messageInfo_PodSecurityPolicySubjectReviewStatus.DiscardUnknown(m)
338 }
339
340 var xxx_messageInfo_PodSecurityPolicySubjectReviewStatus proto.InternalMessageInfo
341
342 func (m *RangeAllocation) Reset() { *m = RangeAllocation{} }
343 func (*RangeAllocation) ProtoMessage() {}
344 func (*RangeAllocation) Descriptor() ([]byte, []int) {
345 return fileDescriptor_af65d9655aa67551, []int{11}
346 }
347 func (m *RangeAllocation) XXX_Unmarshal(b []byte) error {
348 return m.Unmarshal(b)
349 }
350 func (m *RangeAllocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
351 b = b[:cap(b)]
352 n, err := m.MarshalToSizedBuffer(b)
353 if err != nil {
354 return nil, err
355 }
356 return b[:n], nil
357 }
358 func (m *RangeAllocation) XXX_Merge(src proto.Message) {
359 xxx_messageInfo_RangeAllocation.Merge(m, src)
360 }
361 func (m *RangeAllocation) XXX_Size() int {
362 return m.Size()
363 }
364 func (m *RangeAllocation) XXX_DiscardUnknown() {
365 xxx_messageInfo_RangeAllocation.DiscardUnknown(m)
366 }
367
368 var xxx_messageInfo_RangeAllocation proto.InternalMessageInfo
369
370 func (m *RangeAllocationList) Reset() { *m = RangeAllocationList{} }
371 func (*RangeAllocationList) ProtoMessage() {}
372 func (*RangeAllocationList) Descriptor() ([]byte, []int) {
373 return fileDescriptor_af65d9655aa67551, []int{12}
374 }
375 func (m *RangeAllocationList) XXX_Unmarshal(b []byte) error {
376 return m.Unmarshal(b)
377 }
378 func (m *RangeAllocationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
379 b = b[:cap(b)]
380 n, err := m.MarshalToSizedBuffer(b)
381 if err != nil {
382 return nil, err
383 }
384 return b[:n], nil
385 }
386 func (m *RangeAllocationList) XXX_Merge(src proto.Message) {
387 xxx_messageInfo_RangeAllocationList.Merge(m, src)
388 }
389 func (m *RangeAllocationList) XXX_Size() int {
390 return m.Size()
391 }
392 func (m *RangeAllocationList) XXX_DiscardUnknown() {
393 xxx_messageInfo_RangeAllocationList.DiscardUnknown(m)
394 }
395
396 var xxx_messageInfo_RangeAllocationList proto.InternalMessageInfo
397
398 func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} }
399 func (*RunAsUserStrategyOptions) ProtoMessage() {}
400 func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) {
401 return fileDescriptor_af65d9655aa67551, []int{13}
402 }
403 func (m *RunAsUserStrategyOptions) XXX_Unmarshal(b []byte) error {
404 return m.Unmarshal(b)
405 }
406 func (m *RunAsUserStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
407 b = b[:cap(b)]
408 n, err := m.MarshalToSizedBuffer(b)
409 if err != nil {
410 return nil, err
411 }
412 return b[:n], nil
413 }
414 func (m *RunAsUserStrategyOptions) XXX_Merge(src proto.Message) {
415 xxx_messageInfo_RunAsUserStrategyOptions.Merge(m, src)
416 }
417 func (m *RunAsUserStrategyOptions) XXX_Size() int {
418 return m.Size()
419 }
420 func (m *RunAsUserStrategyOptions) XXX_DiscardUnknown() {
421 xxx_messageInfo_RunAsUserStrategyOptions.DiscardUnknown(m)
422 }
423
424 var xxx_messageInfo_RunAsUserStrategyOptions proto.InternalMessageInfo
425
426 func (m *SELinuxContextStrategyOptions) Reset() { *m = SELinuxContextStrategyOptions{} }
427 func (*SELinuxContextStrategyOptions) ProtoMessage() {}
428 func (*SELinuxContextStrategyOptions) Descriptor() ([]byte, []int) {
429 return fileDescriptor_af65d9655aa67551, []int{14}
430 }
431 func (m *SELinuxContextStrategyOptions) XXX_Unmarshal(b []byte) error {
432 return m.Unmarshal(b)
433 }
434 func (m *SELinuxContextStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
435 b = b[:cap(b)]
436 n, err := m.MarshalToSizedBuffer(b)
437 if err != nil {
438 return nil, err
439 }
440 return b[:n], nil
441 }
442 func (m *SELinuxContextStrategyOptions) XXX_Merge(src proto.Message) {
443 xxx_messageInfo_SELinuxContextStrategyOptions.Merge(m, src)
444 }
445 func (m *SELinuxContextStrategyOptions) XXX_Size() int {
446 return m.Size()
447 }
448 func (m *SELinuxContextStrategyOptions) XXX_DiscardUnknown() {
449 xxx_messageInfo_SELinuxContextStrategyOptions.DiscardUnknown(m)
450 }
451
452 var xxx_messageInfo_SELinuxContextStrategyOptions proto.InternalMessageInfo
453
454 func (m *SecurityContextConstraints) Reset() { *m = SecurityContextConstraints{} }
455 func (*SecurityContextConstraints) ProtoMessage() {}
456 func (*SecurityContextConstraints) Descriptor() ([]byte, []int) {
457 return fileDescriptor_af65d9655aa67551, []int{15}
458 }
459 func (m *SecurityContextConstraints) XXX_Unmarshal(b []byte) error {
460 return m.Unmarshal(b)
461 }
462 func (m *SecurityContextConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
463 b = b[:cap(b)]
464 n, err := m.MarshalToSizedBuffer(b)
465 if err != nil {
466 return nil, err
467 }
468 return b[:n], nil
469 }
470 func (m *SecurityContextConstraints) XXX_Merge(src proto.Message) {
471 xxx_messageInfo_SecurityContextConstraints.Merge(m, src)
472 }
473 func (m *SecurityContextConstraints) XXX_Size() int {
474 return m.Size()
475 }
476 func (m *SecurityContextConstraints) XXX_DiscardUnknown() {
477 xxx_messageInfo_SecurityContextConstraints.DiscardUnknown(m)
478 }
479
480 var xxx_messageInfo_SecurityContextConstraints proto.InternalMessageInfo
481
482 func (m *SecurityContextConstraintsList) Reset() { *m = SecurityContextConstraintsList{} }
483 func (*SecurityContextConstraintsList) ProtoMessage() {}
484 func (*SecurityContextConstraintsList) Descriptor() ([]byte, []int) {
485 return fileDescriptor_af65d9655aa67551, []int{16}
486 }
487 func (m *SecurityContextConstraintsList) XXX_Unmarshal(b []byte) error {
488 return m.Unmarshal(b)
489 }
490 func (m *SecurityContextConstraintsList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
491 b = b[:cap(b)]
492 n, err := m.MarshalToSizedBuffer(b)
493 if err != nil {
494 return nil, err
495 }
496 return b[:n], nil
497 }
498 func (m *SecurityContextConstraintsList) XXX_Merge(src proto.Message) {
499 xxx_messageInfo_SecurityContextConstraintsList.Merge(m, src)
500 }
501 func (m *SecurityContextConstraintsList) XXX_Size() int {
502 return m.Size()
503 }
504 func (m *SecurityContextConstraintsList) XXX_DiscardUnknown() {
505 xxx_messageInfo_SecurityContextConstraintsList.DiscardUnknown(m)
506 }
507
508 var xxx_messageInfo_SecurityContextConstraintsList proto.InternalMessageInfo
509
510 func (m *ServiceAccountPodSecurityPolicyReviewStatus) Reset() {
511 *m = ServiceAccountPodSecurityPolicyReviewStatus{}
512 }
513 func (*ServiceAccountPodSecurityPolicyReviewStatus) ProtoMessage() {}
514 func (*ServiceAccountPodSecurityPolicyReviewStatus) Descriptor() ([]byte, []int) {
515 return fileDescriptor_af65d9655aa67551, []int{17}
516 }
517 func (m *ServiceAccountPodSecurityPolicyReviewStatus) XXX_Unmarshal(b []byte) error {
518 return m.Unmarshal(b)
519 }
520 func (m *ServiceAccountPodSecurityPolicyReviewStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
521 b = b[:cap(b)]
522 n, err := m.MarshalToSizedBuffer(b)
523 if err != nil {
524 return nil, err
525 }
526 return b[:n], nil
527 }
528 func (m *ServiceAccountPodSecurityPolicyReviewStatus) XXX_Merge(src proto.Message) {
529 xxx_messageInfo_ServiceAccountPodSecurityPolicyReviewStatus.Merge(m, src)
530 }
531 func (m *ServiceAccountPodSecurityPolicyReviewStatus) XXX_Size() int {
532 return m.Size()
533 }
534 func (m *ServiceAccountPodSecurityPolicyReviewStatus) XXX_DiscardUnknown() {
535 xxx_messageInfo_ServiceAccountPodSecurityPolicyReviewStatus.DiscardUnknown(m)
536 }
537
538 var xxx_messageInfo_ServiceAccountPodSecurityPolicyReviewStatus proto.InternalMessageInfo
539
540 func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} }
541 func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
542 func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) {
543 return fileDescriptor_af65d9655aa67551, []int{18}
544 }
545 func (m *SupplementalGroupsStrategyOptions) XXX_Unmarshal(b []byte) error {
546 return m.Unmarshal(b)
547 }
548 func (m *SupplementalGroupsStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
549 b = b[:cap(b)]
550 n, err := m.MarshalToSizedBuffer(b)
551 if err != nil {
552 return nil, err
553 }
554 return b[:n], nil
555 }
556 func (m *SupplementalGroupsStrategyOptions) XXX_Merge(src proto.Message) {
557 xxx_messageInfo_SupplementalGroupsStrategyOptions.Merge(m, src)
558 }
559 func (m *SupplementalGroupsStrategyOptions) XXX_Size() int {
560 return m.Size()
561 }
562 func (m *SupplementalGroupsStrategyOptions) XXX_DiscardUnknown() {
563 xxx_messageInfo_SupplementalGroupsStrategyOptions.DiscardUnknown(m)
564 }
565
566 var xxx_messageInfo_SupplementalGroupsStrategyOptions proto.InternalMessageInfo
567
568 func init() {
569 proto.RegisterType((*AllowedFlexVolume)(nil), "github.com.openshift.api.security.v1.AllowedFlexVolume")
570 proto.RegisterType((*FSGroupStrategyOptions)(nil), "github.com.openshift.api.security.v1.FSGroupStrategyOptions")
571 proto.RegisterType((*IDRange)(nil), "github.com.openshift.api.security.v1.IDRange")
572 proto.RegisterType((*PodSecurityPolicyReview)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicyReview")
573 proto.RegisterType((*PodSecurityPolicyReviewSpec)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicyReviewSpec")
574 proto.RegisterType((*PodSecurityPolicyReviewStatus)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicyReviewStatus")
575 proto.RegisterType((*PodSecurityPolicySelfSubjectReview)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicySelfSubjectReview")
576 proto.RegisterType((*PodSecurityPolicySelfSubjectReviewSpec)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicySelfSubjectReviewSpec")
577 proto.RegisterType((*PodSecurityPolicySubjectReview)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicySubjectReview")
578 proto.RegisterType((*PodSecurityPolicySubjectReviewSpec)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicySubjectReviewSpec")
579 proto.RegisterType((*PodSecurityPolicySubjectReviewStatus)(nil), "github.com.openshift.api.security.v1.PodSecurityPolicySubjectReviewStatus")
580 proto.RegisterType((*RangeAllocation)(nil), "github.com.openshift.api.security.v1.RangeAllocation")
581 proto.RegisterType((*RangeAllocationList)(nil), "github.com.openshift.api.security.v1.RangeAllocationList")
582 proto.RegisterType((*RunAsUserStrategyOptions)(nil), "github.com.openshift.api.security.v1.RunAsUserStrategyOptions")
583 proto.RegisterType((*SELinuxContextStrategyOptions)(nil), "github.com.openshift.api.security.v1.SELinuxContextStrategyOptions")
584 proto.RegisterType((*SecurityContextConstraints)(nil), "github.com.openshift.api.security.v1.SecurityContextConstraints")
585 proto.RegisterType((*SecurityContextConstraintsList)(nil), "github.com.openshift.api.security.v1.SecurityContextConstraintsList")
586 proto.RegisterType((*ServiceAccountPodSecurityPolicyReviewStatus)(nil), "github.com.openshift.api.security.v1.ServiceAccountPodSecurityPolicyReviewStatus")
587 proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "github.com.openshift.api.security.v1.SupplementalGroupsStrategyOptions")
588 }
589
590 func init() {
591 proto.RegisterFile("github.com/openshift/api/security/v1/generated.proto", fileDescriptor_af65d9655aa67551)
592 }
593
594 var fileDescriptor_af65d9655aa67551 = []byte{
595
596 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x6f, 0x1c, 0x49,
597 0x15, 0x77, 0x7b, 0xfc, 0x35, 0x65, 0xc7, 0x1f, 0x65, 0xc7, 0xe9, 0x35, 0xeb, 0x19, 0xd3, 0x36,
598 0xab, 0x08, 0xd8, 0x19, 0x12, 0x2d, 0x6c, 0xd0, 0xb2, 0xd1, 0x4e, 0x7b, 0xd6, 0x59, 0xaf, 0x9c,
599 0x64, 0xb6, 0x66, 0xbd, 0x42, 0xab, 0x15, 0xa2, 0xdc, 0x53, 0x33, 0xae, 0xb8, 0xbf, 0xe8, 0xaa,
600 0x76, 0x3c, 0xe2, 0x12, 0x89, 0x0b, 0x47, 0x24, 0xae, 0x88, 0x33, 0xfc, 0x03, 0x5c, 0x10, 0x70,
601 0x8d, 0x04, 0x12, 0x39, 0xa1, 0x9c, 0x46, 0x64, 0x10, 0x27, 0x8e, 0xdc, 0x72, 0x42, 0x55, 0x53,
602 0xf3, 0xd1, 0x3d, 0xdd, 0xe3, 0x4e, 0x48, 0xa2, 0xbd, 0x4d, 0xbf, 0x8f, 0xdf, 0xef, 0xbd, 0xd7,
603 0xaf, 0x5f, 0xbd, 0x1a, 0xf0, 0x5e, 0x8b, 0xf2, 0xd3, 0xf0, 0xa4, 0x64, 0x79, 0x4e, 0xd9, 0xf3,
604 0x89, 0xcb, 0x4e, 0x69, 0x93, 0x97, 0xb1, 0x4f, 0xcb, 0x8c, 0x58, 0x61, 0x40, 0x79, 0xbb, 0x7c,
605 0x7e, 0xa3, 0xdc, 0x22, 0x2e, 0x09, 0x30, 0x27, 0x8d, 0x92, 0x1f, 0x78, 0xdc, 0x83, 0x7b, 0x43,
606 0xaf, 0xd2, 0xc0, 0xab, 0x84, 0x7d, 0x5a, 0xea, 0x7b, 0x95, 0xce, 0x6f, 0x6c, 0xbd, 0x3b, 0x82,
607 0xdd, 0xf2, 0x5a, 0x5e, 0x59, 0x3a, 0x9f, 0x84, 0x4d, 0xf9, 0x24, 0x1f, 0xe4, 0xaf, 0x1e, 0xe8,
608 0x96, 0x71, 0x76, 0x8b, 0x95, 0xa8, 0x27, 0xc9, 0x2d, 0x2f, 0x20, 0x09, 0xc4, 0x5b, 0xef, 0x0d,
609 0x6d, 0x1c, 0x6c, 0x9d, 0x52, 0x97, 0x04, 0xed, 0xb2, 0x7f, 0xd6, 0x12, 0x02, 0x56, 0x76, 0x08,
610 0xc7, 0x49, 0x5e, 0x3f, 0x48, 0xf3, 0x0a, 0x42, 0x97, 0x53, 0x87, 0x94, 0x99, 0x75, 0x4a, 0x1c,
611 0x1c, 0xf7, 0x33, 0x3e, 0x00, 0x6b, 0x15, 0xdb, 0xf6, 0x1e, 0x92, 0xc6, 0x81, 0x4d, 0x2e, 0xbe,
612 0xf0, 0xec, 0xd0, 0x21, 0xf0, 0x1d, 0x30, 0xd7, 0x08, 0xe8, 0x39, 0x09, 0x74, 0x6d, 0x47, 0xbb,
613 0x9e, 0x37, 0x97, 0x1f, 0x77, 0x8a, 0x53, 0xdd, 0x4e, 0x71, 0xae, 0x2a, 0xa5, 0x48, 0x69, 0x8d,
614 0xdf, 0x69, 0x60, 0xf3, 0xa0, 0x7e, 0x27, 0xf0, 0x42, 0xbf, 0xce, 0x05, 0x6a, 0xab, 0x7d, 0xdf,
615 0xe7, 0xd4, 0x73, 0x19, 0x7c, 0x1f, 0xcc, 0xf0, 0xb6, 0x4f, 0x14, 0xc0, 0xae, 0x02, 0x98, 0xf9,
616 0xbc, 0xed, 0x93, 0xe7, 0x9d, 0xe2, 0x7a, 0xcc, 0x4b, 0x88, 0x91, 0x74, 0x80, 0xc7, 0x60, 0x2e,
617 0xc0, 0x6e, 0x8b, 0x30, 0x7d, 0x7a, 0x27, 0x77, 0x7d, 0xf1, 0xe6, 0xbb, 0xa5, 0x2c, 0x2f, 0xa2,
618 0x74, 0x58, 0x45, 0xc2, 0x6b, 0x18, 0xaa, 0x7c, 0x64, 0x48, 0x81, 0x19, 0x77, 0xc0, 0xbc, 0x32,
619 0x81, 0xdb, 0x20, 0xe7, 0x50, 0x57, 0x46, 0x96, 0x33, 0x17, 0x95, 0x7d, 0xee, 0x2e, 0x75, 0x91,
620 0x90, 0x4b, 0x35, 0xbe, 0xd0, 0xa7, 0x63, 0x6a, 0x7c, 0x81, 0x84, 0xdc, 0xf8, 0x8f, 0x06, 0xae,
621 0xd5, 0xbc, 0x46, 0x5d, 0x71, 0xd7, 0x3c, 0x9b, 0x5a, 0x6d, 0x44, 0xce, 0x29, 0x79, 0x08, 0x2d,
622 0x30, 0xc3, 0x7c, 0x62, 0x49, 0xe8, 0xc5, 0x9b, 0x95, 0x6c, 0x91, 0xa7, 0x80, 0xd5, 0x7d, 0x62,
623 0x99, 0x4b, 0xfd, 0xba, 0x89, 0x27, 0x24, 0xc1, 0xe1, 0x19, 0x98, 0x63, 0x1c, 0xf3, 0x90, 0xc9,
624 0x10, 0x17, 0x6f, 0xee, 0xff, 0x7f, 0x34, 0x12, 0x6a, 0x58, 0xb6, 0xde, 0x33, 0x52, 0x14, 0xc6,
625 0x1f, 0x35, 0xf0, 0x8d, 0x09, 0x01, 0xc2, 0xcf, 0xc0, 0x02, 0x27, 0x8e, 0x6f, 0x63, 0x4e, 0x54,
626 0xd6, 0xbb, 0xa5, 0x5e, 0x27, 0xca, 0x00, 0x44, 0x8f, 0x2b, 0xf2, 0xcf, 0x95, 0x99, 0xcc, 0x6b,
627 0x55, 0xd1, 0x2d, 0xf4, 0xa5, 0x68, 0x00, 0x03, 0x0f, 0xc1, 0x3a, 0x23, 0xc1, 0x39, 0xb5, 0x48,
628 0xc5, 0xb2, 0xbc, 0xd0, 0xe5, 0xf7, 0xb0, 0xa3, 0xba, 0x21, 0x6f, 0x5e, 0xeb, 0x76, 0x8a, 0xeb,
629 0xf5, 0x71, 0x35, 0x4a, 0xf2, 0x31, 0xfe, 0xaa, 0x81, 0xed, 0x89, 0x79, 0xc3, 0xdf, 0x6b, 0x60,
630 0x13, 0xf7, 0xfa, 0x3f, 0x8a, 0xca, 0x74, 0x4d, 0xb6, 0xdf, 0x67, 0xd9, 0xaa, 0x1b, 0x75, 0x9e,
631 0x5c, 0xeb, 0x82, 0x4a, 0x7e, 0xb3, 0x92, 0x48, 0x8c, 0x52, 0x02, 0x32, 0x7e, 0x39, 0x0d, 0x8c,
632 0x31, 0xe4, 0x3a, 0xb1, 0x9b, 0xf5, 0xf0, 0xe4, 0x01, 0xb1, 0xb8, 0x6a, 0x42, 0x37, 0xd2, 0x84,
633 0x47, 0x2f, 0xd9, 0x1d, 0x63, 0xb8, 0xa9, 0xfd, 0x18, 0xc4, 0xfa, 0xf1, 0xd3, 0x97, 0x65, 0x8c,
634 0xb0, 0x4d, 0x6e, 0xcb, 0x9f, 0x83, 0x77, 0xb2, 0x45, 0xfc, 0x1a, 0x1a, 0xd4, 0x78, 0x34, 0x0d,
635 0x0a, 0x93, 0xa3, 0x87, 0x0f, 0x22, 0xef, 0xe0, 0x93, 0x57, 0x52, 0x91, 0xaf, 0x53, 0xfd, 0xff,
636 0xa4, 0x25, 0xb5, 0xe2, 0x1b, 0x28, 0x3e, 0xdc, 0x01, 0x33, 0x21, 0x23, 0x81, 0xcc, 0x35, 0x3f,
637 0xac, 0xc7, 0x31, 0x23, 0x01, 0x92, 0x1a, 0x68, 0x80, 0xb9, 0x96, 0x38, 0x5b, 0x98, 0x9e, 0x93,
638 0x23, 0x03, 0x88, 0xf8, 0xe5, 0x69, 0xc3, 0x90, 0xd2, 0x18, 0xff, 0xd5, 0xc0, 0x5e, 0x96, 0x02,
639 0xc0, 0x1a, 0xc8, 0xab, 0xaf, 0xd1, 0x6c, 0x4f, 0x4a, 0xe1, 0xbe, 0x72, 0x6d, 0x92, 0x80, 0xb8,
640 0x16, 0x31, 0xaf, 0x74, 0x3b, 0xc5, 0x7c, 0xa5, 0xef, 0x89, 0x86, 0x20, 0xe2, 0x6c, 0x0d, 0x08,
641 0x66, 0x9e, 0xab, 0x52, 0x18, 0x1e, 0x58, 0x52, 0x8a, 0x94, 0x36, 0x52, 0xbb, 0xdc, 0xab, 0x69,
642 0xdc, 0x3f, 0x68, 0x60, 0x45, 0x1e, 0x81, 0x22, 0x30, 0x0b, 0x8b, 0x83, 0x1a, 0xfe, 0x14, 0x2c,
643 0x88, 0x95, 0xa2, 0x81, 0x39, 0x56, 0xf9, 0x7d, 0x6f, 0x84, 0x66, 0xb0, 0x4a, 0x94, 0xfc, 0xb3,
644 0x96, 0x10, 0xb0, 0x92, 0xb0, 0x1e, 0x66, 0x7c, 0x97, 0x70, 0x6c, 0x42, 0xc5, 0x09, 0x86, 0x32,
645 0x34, 0x40, 0x85, 0xbb, 0x60, 0x56, 0x9e, 0xc1, 0x2a, 0xdf, 0x2b, 0xca, 0x78, 0x56, 0x46, 0x82,
646 0x7a, 0x3a, 0xf8, 0x36, 0x98, 0x91, 0x21, 0x88, 0x4c, 0x97, 0xcc, 0x05, 0xf1, 0x4a, 0xab, 0x98,
647 0x63, 0x24, 0xa5, 0xc6, 0xdf, 0x35, 0xb0, 0x1e, 0x0b, 0xfc, 0x88, 0x32, 0x0e, 0xbf, 0x1a, 0x0b,
648 0xbe, 0x94, 0x2d, 0x78, 0xe1, 0x2d, 0x43, 0x1f, 0x94, 0xab, 0x2f, 0x19, 0x09, 0xfc, 0x4b, 0x30,
649 0x4b, 0x39, 0x71, 0xfa, 0x8b, 0xc8, 0xf7, 0xb3, 0x7d, 0x57, 0xb1, 0x38, 0x87, 0xf9, 0x1e, 0x0a,
650 0x2c, 0xd4, 0x83, 0x34, 0xfe, 0xa1, 0x01, 0x1d, 0x85, 0x6e, 0x85, 0x89, 0xc6, 0x8d, 0xef, 0x4e,
651 0x3f, 0x8c, 0xec, 0x4e, 0xdf, 0x8a, 0xed, 0x4e, 0x57, 0xc7, 0xfc, 0x46, 0xb6, 0xa7, 0xb7, 0x40,
652 0x2e, 0xa4, 0x0d, 0xb5, 0xbc, 0xcc, 0x8b, 0xc5, 0xe5, 0xf8, 0xb0, 0x8a, 0x84, 0x0c, 0xde, 0x00,
653 0x8b, 0x21, 0x6d, 0xc8, 0xf0, 0xee, 0x52, 0x57, 0x56, 0x3a, 0x67, 0xae, 0x74, 0x3b, 0xc5, 0xc5,
654 0x63, 0xb5, 0x19, 0x89, 0x15, 0x68, 0xd4, 0x26, 0xe2, 0x82, 0x2f, 0xf4, 0x99, 0x04, 0x17, 0x7c,
655 0x81, 0x46, 0x6d, 0x8c, 0xbf, 0x68, 0x60, 0xbb, 0xfe, 0xf1, 0x11, 0x75, 0xc3, 0x8b, 0x7d, 0xcf,
656 0xe5, 0xe4, 0x82, 0xc7, 0xb3, 0xbb, 0x1d, 0xc9, 0xee, 0xdb, 0xb1, 0xec, 0xb6, 0x92, 0x9d, 0x47,
657 0x52, 0xfc, 0x09, 0x58, 0x66, 0x44, 0xda, 0x28, 0x44, 0x35, 0xf7, 0x8c, 0xa4, 0xcf, 0x43, 0xa1,
658 0x29, 0x4b, 0x13, 0x76, 0x3b, 0xc5, 0xe5, 0xa8, 0x0c, 0xc5, 0xd0, 0x8c, 0xdf, 0xac, 0x81, 0xad,
659 0xfe, 0x60, 0x50, 0x51, 0xec, 0x7b, 0x2e, 0xe3, 0x01, 0xa6, 0x2e, 0x67, 0x6f, 0xe0, 0x83, 0xb9,
660 0x0e, 0x16, 0xfc, 0x80, 0x7a, 0x82, 0x5f, 0xa6, 0x36, 0x6b, 0x2e, 0x89, 0x0e, 0xad, 0x29, 0x19,
661 0x1a, 0x68, 0xe1, 0x57, 0x40, 0x97, 0x83, 0xa5, 0x16, 0xd0, 0x73, 0x6a, 0x93, 0x16, 0x69, 0x88,
662 0x80, 0xb1, 0x08, 0x40, 0xbe, 0xdf, 0x05, 0x73, 0x47, 0x31, 0xe9, 0x95, 0x14, 0x3b, 0x94, 0x8a,
663 0x00, 0x19, 0xd8, 0x6c, 0x90, 0x26, 0x0e, 0x6d, 0x5e, 0x69, 0x34, 0xf6, 0xb1, 0x8f, 0x4f, 0xa8,
664 0x4d, 0x39, 0x25, 0x4c, 0x9f, 0x91, 0x83, 0xf5, 0x03, 0xb1, 0xc3, 0x54, 0x13, 0x2d, 0x9e, 0x77,
665 0x8a, 0xdb, 0xe3, 0x57, 0x9d, 0xd2, 0xc0, 0xa4, 0x8d, 0x52, 0xa0, 0x61, 0x1b, 0xe8, 0x01, 0xf9,
666 0x59, 0x48, 0x03, 0xd2, 0xa8, 0x06, 0x9e, 0x1f, 0xa1, 0x9d, 0x95, 0xb4, 0x1f, 0x8a, 0x74, 0x50,
667 0x8a, 0xcd, 0xe5, 0xc4, 0xa9, 0xf0, 0xf0, 0x01, 0x58, 0x57, 0x63, 0x3a, 0xc2, 0x3a, 0x27, 0x59,
668 0x6f, 0x89, 0xc5, 0xb3, 0x32, 0xae, 0xbe, 0x9c, 0x30, 0x09, 0x74, 0xf0, 0xe6, 0x3e, 0xf1, 0x18,
669 0xaf, 0xd2, 0xa0, 0x77, 0xef, 0xaa, 0xd9, 0x61, 0x8b, 0xba, 0xfa, 0x7c, 0xc2, 0x9b, 0x4b, 0xb0,
670 0x43, 0xa9, 0x08, 0xb0, 0x0c, 0xe6, 0xcf, 0xe5, 0x33, 0xd3, 0x17, 0x64, 0xf4, 0x57, 0xbb, 0x9d,
671 0xe2, 0x7c, 0xcf, 0x44, 0x44, 0x3c, 0x77, 0x50, 0x97, 0x1f, 0x54, 0xdf, 0x0a, 0xfe, 0x42, 0x03,
672 0x10, 0xc7, 0xaf, 0x81, 0x4c, 0xbf, 0x2a, 0x07, 0xdf, 0xfb, 0xd9, 0x06, 0xdf, 0xd8, 0x35, 0xd2,
673 0xdc, 0x52, 0x29, 0xc0, 0x31, 0x15, 0x43, 0x09, 0x74, 0xb0, 0x0a, 0x56, 0x07, 0x29, 0xdd, 0x23,
674 0xfc, 0xa1, 0x17, 0x9c, 0xe9, 0x79, 0x59, 0x0c, 0x5d, 0x21, 0xad, 0x56, 0x62, 0x7a, 0x34, 0xe6,
675 0x01, 0x6f, 0x83, 0xe5, 0x81, 0xac, 0xe6, 0x05, 0x9c, 0xe9, 0x40, 0x62, 0x6c, 0x2a, 0x8c, 0xe5,
676 0x4a, 0x44, 0x8b, 0x62, 0xd6, 0xf0, 0x16, 0x58, 0x1a, 0x4a, 0x0e, 0xab, 0xfa, 0xa2, 0xf4, 0xde,
677 0x50, 0xde, 0x4b, 0x95, 0x11, 0x1d, 0x8a, 0x58, 0x46, 0x3c, 0x0f, 0x6b, 0xfb, 0xfa, 0x52, 0x8a,
678 0xe7, 0x61, 0x6d, 0x1f, 0x45, 0x2c, 0xa1, 0x03, 0x8a, 0xfd, 0xef, 0x21, 0xf2, 0x35, 0x7e, 0xcc,
679 0x2c, 0x6c, 0xcb, 0x73, 0x44, 0xdf, 0x94, 0x60, 0xbb, 0xdd, 0x4e, 0xb1, 0x58, 0x9d, 0x6c, 0x8a,
680 0x2e, 0xc3, 0x82, 0x3f, 0x8e, 0xcf, 0x8d, 0x11, 0x9e, 0x6b, 0x92, 0xe7, 0xed, 0xf1, 0x99, 0x31,
681 0x42, 0x90, 0xea, 0x2d, 0x1a, 0xa9, 0x3f, 0x4f, 0xd5, 0xec, 0xd4, 0xaf, 0xbc, 0xc8, 0x2d, 0x75,
682 0xe2, 0xd1, 0x31, 0x7c, 0x85, 0x51, 0x33, 0x14, 0xa3, 0x84, 0x1e, 0xc8, 0x07, 0xfd, 0x43, 0x52,
683 0x5f, 0x96, 0xfc, 0xb7, 0x33, 0x9e, 0xde, 0x29, 0x67, 0xb2, 0xb9, 0xa6, 0xa8, 0xf3, 0x03, 0x0b,
684 0x34, 0xe4, 0x80, 0xbf, 0xd6, 0x00, 0x64, 0xa1, 0xef, 0xdb, 0xc4, 0x21, 0x2e, 0xc7, 0x76, 0x6f,
685 0xdd, 0xd4, 0x57, 0x24, 0xf5, 0x9d, 0x8c, 0xa9, 0x8f, 0xf9, 0xc7, 0x63, 0x18, 0x7c, 0x4f, 0xe3,
686 0xa6, 0x28, 0x81, 0x1e, 0xb6, 0xc0, 0x7c, 0x93, 0xc9, 0xdf, 0xfa, 0xaa, 0x8c, 0xe4, 0x47, 0xd9,
687 0x22, 0x49, 0xfe, 0x4b, 0xc7, 0x5c, 0x51, 0xf4, 0xf3, 0x4a, 0x8f, 0xfa, 0xe8, 0xf0, 0x0b, 0xb0,
688 0x19, 0x10, 0xdc, 0xb8, 0xef, 0xda, 0x6d, 0xe4, 0x79, 0xfc, 0x80, 0xda, 0x84, 0xb5, 0x19, 0x27,
689 0x8e, 0xbe, 0x26, 0xbb, 0x69, 0x70, 0xe3, 0x45, 0x89, 0x56, 0x28, 0xc5, 0x1b, 0x16, 0xc1, 0xac,
690 0x58, 0xe9, 0x99, 0x0e, 0xe5, 0x14, 0xcb, 0x8b, 0x35, 0x4a, 0xd4, 0x9b, 0xa1, 0x9e, 0x7c, 0x64,
691 0xd7, 0x5f, 0x4f, 0xdb, 0xf5, 0xe1, 0x87, 0x60, 0x85, 0x11, 0xcb, 0xf2, 0x1c, 0xbf, 0x16, 0x78,
692 0x4d, 0x01, 0xae, 0x6f, 0x48, 0xe3, 0xf5, 0x6e, 0xa7, 0xb8, 0x52, 0x8f, 0xaa, 0x50, 0xdc, 0x16,
693 0x1e, 0x81, 0x0d, 0x35, 0xaa, 0x8e, 0x5d, 0x86, 0x9b, 0xa4, 0xde, 0x66, 0x16, 0xb7, 0x99, 0xae,
694 0x4b, 0x0c, 0xbd, 0xdb, 0x29, 0x6e, 0x54, 0x12, 0xf4, 0x28, 0xd1, 0x0b, 0x7e, 0x04, 0x56, 0x9b,
695 0x5e, 0x70, 0x42, 0x1b, 0x0d, 0xe2, 0xf6, 0x91, 0xde, 0x92, 0x48, 0x1b, 0x62, 0xbc, 0x1d, 0xc4,
696 0x74, 0x68, 0xcc, 0xda, 0xf8, 0xb7, 0x06, 0x0a, 0xe9, 0xeb, 0xc9, 0x1b, 0x58, 0x8b, 0x49, 0x74,
697 0x2d, 0xfe, 0x28, 0xeb, 0x1f, 0x24, 0x69, 0x21, 0xa7, 0x6c, 0xc8, 0xbf, 0x9d, 0x06, 0xdf, 0x79,
698 0x81, 0x7f, 0x55, 0xe0, 0xdf, 0x34, 0xb0, 0xe7, 0x67, 0xb8, 0xd2, 0xa9, 0x8a, 0xbc, 0xca, 0x5b,
699 0xf2, 0x77, 0x55, 0x02, 0x99, 0xae, 0x94, 0x28, 0x53, 0x94, 0xe2, 0x9e, 0xeb, 0x62, 0x87, 0xc4,
700 0xef, 0xb9, 0xf7, 0xb0, 0x43, 0x90, 0xd4, 0x18, 0x7f, 0xd6, 0xc0, 0x37, 0x2f, 0x9d, 0x19, 0xd0,
701 0x8c, 0x6c, 0xdb, 0xa5, 0xd8, 0xb6, 0x5d, 0x48, 0x07, 0x78, 0xed, 0x7f, 0xc9, 0x9a, 0x9f, 0x3e,
702 0x7e, 0x56, 0x98, 0x7a, 0xf2, 0xac, 0x30, 0xf5, 0xf4, 0x59, 0x61, 0xea, 0x51, 0xb7, 0xa0, 0x3d,
703 0xee, 0x16, 0xb4, 0x27, 0xdd, 0x82, 0xf6, 0xb4, 0x5b, 0xd0, 0xfe, 0xd9, 0x2d, 0x68, 0xbf, 0xfa,
704 0x57, 0x61, 0xea, 0xcb, 0xbd, 0x2c, 0xff, 0xde, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x31,
705 0x4b, 0x4e, 0xe4, 0x17, 0x00, 0x00,
706 }
707
708 func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) {
709 size := m.Size()
710 dAtA = make([]byte, size)
711 n, err := m.MarshalToSizedBuffer(dAtA[:size])
712 if err != nil {
713 return nil, err
714 }
715 return dAtA[:n], nil
716 }
717
718 func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) {
719 size := m.Size()
720 return m.MarshalToSizedBuffer(dAtA[:size])
721 }
722
723 func (m *AllowedFlexVolume) MarshalToSizedBuffer(dAtA []byte) (int, error) {
724 i := len(dAtA)
725 _ = i
726 var l int
727 _ = l
728 i -= len(m.Driver)
729 copy(dAtA[i:], m.Driver)
730 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
731 i--
732 dAtA[i] = 0xa
733 return len(dAtA) - i, nil
734 }
735
736 func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
737 size := m.Size()
738 dAtA = make([]byte, size)
739 n, err := m.MarshalToSizedBuffer(dAtA[:size])
740 if err != nil {
741 return nil, err
742 }
743 return dAtA[:n], nil
744 }
745
746 func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
747 size := m.Size()
748 return m.MarshalToSizedBuffer(dAtA[:size])
749 }
750
751 func (m *FSGroupStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
752 i := len(dAtA)
753 _ = i
754 var l int
755 _ = l
756 if len(m.Ranges) > 0 {
757 for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- {
758 {
759 size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
760 if err != nil {
761 return 0, err
762 }
763 i -= size
764 i = encodeVarintGenerated(dAtA, i, uint64(size))
765 }
766 i--
767 dAtA[i] = 0x12
768 }
769 }
770 i -= len(m.Type)
771 copy(dAtA[i:], m.Type)
772 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
773 i--
774 dAtA[i] = 0xa
775 return len(dAtA) - i, nil
776 }
777
778 func (m *IDRange) Marshal() (dAtA []byte, err error) {
779 size := m.Size()
780 dAtA = make([]byte, size)
781 n, err := m.MarshalToSizedBuffer(dAtA[:size])
782 if err != nil {
783 return nil, err
784 }
785 return dAtA[:n], nil
786 }
787
788 func (m *IDRange) MarshalTo(dAtA []byte) (int, error) {
789 size := m.Size()
790 return m.MarshalToSizedBuffer(dAtA[:size])
791 }
792
793 func (m *IDRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
794 i := len(dAtA)
795 _ = i
796 var l int
797 _ = l
798 i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
799 i--
800 dAtA[i] = 0x10
801 i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
802 i--
803 dAtA[i] = 0x8
804 return len(dAtA) - i, nil
805 }
806
807 func (m *PodSecurityPolicyReview) Marshal() (dAtA []byte, err error) {
808 size := m.Size()
809 dAtA = make([]byte, size)
810 n, err := m.MarshalToSizedBuffer(dAtA[:size])
811 if err != nil {
812 return nil, err
813 }
814 return dAtA[:n], nil
815 }
816
817 func (m *PodSecurityPolicyReview) MarshalTo(dAtA []byte) (int, error) {
818 size := m.Size()
819 return m.MarshalToSizedBuffer(dAtA[:size])
820 }
821
822 func (m *PodSecurityPolicyReview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
823 i := len(dAtA)
824 _ = i
825 var l int
826 _ = l
827 {
828 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
829 if err != nil {
830 return 0, err
831 }
832 i -= size
833 i = encodeVarintGenerated(dAtA, i, uint64(size))
834 }
835 i--
836 dAtA[i] = 0x12
837 {
838 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
839 if err != nil {
840 return 0, err
841 }
842 i -= size
843 i = encodeVarintGenerated(dAtA, i, uint64(size))
844 }
845 i--
846 dAtA[i] = 0xa
847 return len(dAtA) - i, nil
848 }
849
850 func (m *PodSecurityPolicyReviewSpec) Marshal() (dAtA []byte, err error) {
851 size := m.Size()
852 dAtA = make([]byte, size)
853 n, err := m.MarshalToSizedBuffer(dAtA[:size])
854 if err != nil {
855 return nil, err
856 }
857 return dAtA[:n], nil
858 }
859
860 func (m *PodSecurityPolicyReviewSpec) MarshalTo(dAtA []byte) (int, error) {
861 size := m.Size()
862 return m.MarshalToSizedBuffer(dAtA[:size])
863 }
864
865 func (m *PodSecurityPolicyReviewSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
866 i := len(dAtA)
867 _ = i
868 var l int
869 _ = l
870 if len(m.ServiceAccountNames) > 0 {
871 for iNdEx := len(m.ServiceAccountNames) - 1; iNdEx >= 0; iNdEx-- {
872 i -= len(m.ServiceAccountNames[iNdEx])
873 copy(dAtA[i:], m.ServiceAccountNames[iNdEx])
874 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceAccountNames[iNdEx])))
875 i--
876 dAtA[i] = 0x12
877 }
878 }
879 {
880 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
881 if err != nil {
882 return 0, err
883 }
884 i -= size
885 i = encodeVarintGenerated(dAtA, i, uint64(size))
886 }
887 i--
888 dAtA[i] = 0xa
889 return len(dAtA) - i, nil
890 }
891
892 func (m *PodSecurityPolicyReviewStatus) Marshal() (dAtA []byte, err error) {
893 size := m.Size()
894 dAtA = make([]byte, size)
895 n, err := m.MarshalToSizedBuffer(dAtA[:size])
896 if err != nil {
897 return nil, err
898 }
899 return dAtA[:n], nil
900 }
901
902 func (m *PodSecurityPolicyReviewStatus) MarshalTo(dAtA []byte) (int, error) {
903 size := m.Size()
904 return m.MarshalToSizedBuffer(dAtA[:size])
905 }
906
907 func (m *PodSecurityPolicyReviewStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
908 i := len(dAtA)
909 _ = i
910 var l int
911 _ = l
912 if len(m.AllowedServiceAccounts) > 0 {
913 for iNdEx := len(m.AllowedServiceAccounts) - 1; iNdEx >= 0; iNdEx-- {
914 {
915 size, err := m.AllowedServiceAccounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
916 if err != nil {
917 return 0, err
918 }
919 i -= size
920 i = encodeVarintGenerated(dAtA, i, uint64(size))
921 }
922 i--
923 dAtA[i] = 0xa
924 }
925 }
926 return len(dAtA) - i, nil
927 }
928
929 func (m *PodSecurityPolicySelfSubjectReview) Marshal() (dAtA []byte, err error) {
930 size := m.Size()
931 dAtA = make([]byte, size)
932 n, err := m.MarshalToSizedBuffer(dAtA[:size])
933 if err != nil {
934 return nil, err
935 }
936 return dAtA[:n], nil
937 }
938
939 func (m *PodSecurityPolicySelfSubjectReview) MarshalTo(dAtA []byte) (int, error) {
940 size := m.Size()
941 return m.MarshalToSizedBuffer(dAtA[:size])
942 }
943
944 func (m *PodSecurityPolicySelfSubjectReview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
945 i := len(dAtA)
946 _ = i
947 var l int
948 _ = l
949 {
950 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
951 if err != nil {
952 return 0, err
953 }
954 i -= size
955 i = encodeVarintGenerated(dAtA, i, uint64(size))
956 }
957 i--
958 dAtA[i] = 0x12
959 {
960 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
961 if err != nil {
962 return 0, err
963 }
964 i -= size
965 i = encodeVarintGenerated(dAtA, i, uint64(size))
966 }
967 i--
968 dAtA[i] = 0xa
969 return len(dAtA) - i, nil
970 }
971
972 func (m *PodSecurityPolicySelfSubjectReviewSpec) Marshal() (dAtA []byte, err error) {
973 size := m.Size()
974 dAtA = make([]byte, size)
975 n, err := m.MarshalToSizedBuffer(dAtA[:size])
976 if err != nil {
977 return nil, err
978 }
979 return dAtA[:n], nil
980 }
981
982 func (m *PodSecurityPolicySelfSubjectReviewSpec) MarshalTo(dAtA []byte) (int, error) {
983 size := m.Size()
984 return m.MarshalToSizedBuffer(dAtA[:size])
985 }
986
987 func (m *PodSecurityPolicySelfSubjectReviewSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
988 i := len(dAtA)
989 _ = i
990 var l int
991 _ = l
992 {
993 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
994 if err != nil {
995 return 0, err
996 }
997 i -= size
998 i = encodeVarintGenerated(dAtA, i, uint64(size))
999 }
1000 i--
1001 dAtA[i] = 0xa
1002 return len(dAtA) - i, nil
1003 }
1004
1005 func (m *PodSecurityPolicySubjectReview) Marshal() (dAtA []byte, err error) {
1006 size := m.Size()
1007 dAtA = make([]byte, size)
1008 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1009 if err != nil {
1010 return nil, err
1011 }
1012 return dAtA[:n], nil
1013 }
1014
1015 func (m *PodSecurityPolicySubjectReview) MarshalTo(dAtA []byte) (int, error) {
1016 size := m.Size()
1017 return m.MarshalToSizedBuffer(dAtA[:size])
1018 }
1019
1020 func (m *PodSecurityPolicySubjectReview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1021 i := len(dAtA)
1022 _ = i
1023 var l int
1024 _ = l
1025 {
1026 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1027 if err != nil {
1028 return 0, err
1029 }
1030 i -= size
1031 i = encodeVarintGenerated(dAtA, i, uint64(size))
1032 }
1033 i--
1034 dAtA[i] = 0x12
1035 {
1036 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1037 if err != nil {
1038 return 0, err
1039 }
1040 i -= size
1041 i = encodeVarintGenerated(dAtA, i, uint64(size))
1042 }
1043 i--
1044 dAtA[i] = 0xa
1045 return len(dAtA) - i, nil
1046 }
1047
1048 func (m *PodSecurityPolicySubjectReviewSpec) Marshal() (dAtA []byte, err error) {
1049 size := m.Size()
1050 dAtA = make([]byte, size)
1051 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1052 if err != nil {
1053 return nil, err
1054 }
1055 return dAtA[:n], nil
1056 }
1057
1058 func (m *PodSecurityPolicySubjectReviewSpec) MarshalTo(dAtA []byte) (int, error) {
1059 size := m.Size()
1060 return m.MarshalToSizedBuffer(dAtA[:size])
1061 }
1062
1063 func (m *PodSecurityPolicySubjectReviewSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1064 i := len(dAtA)
1065 _ = i
1066 var l int
1067 _ = l
1068 if len(m.Groups) > 0 {
1069 for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
1070 i -= len(m.Groups[iNdEx])
1071 copy(dAtA[i:], m.Groups[iNdEx])
1072 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Groups[iNdEx])))
1073 i--
1074 dAtA[i] = 0x1a
1075 }
1076 }
1077 i -= len(m.User)
1078 copy(dAtA[i:], m.User)
1079 i = encodeVarintGenerated(dAtA, i, uint64(len(m.User)))
1080 i--
1081 dAtA[i] = 0x12
1082 {
1083 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
1084 if err != nil {
1085 return 0, err
1086 }
1087 i -= size
1088 i = encodeVarintGenerated(dAtA, i, uint64(size))
1089 }
1090 i--
1091 dAtA[i] = 0xa
1092 return len(dAtA) - i, nil
1093 }
1094
1095 func (m *PodSecurityPolicySubjectReviewStatus) Marshal() (dAtA []byte, err error) {
1096 size := m.Size()
1097 dAtA = make([]byte, size)
1098 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1099 if err != nil {
1100 return nil, err
1101 }
1102 return dAtA[:n], nil
1103 }
1104
1105 func (m *PodSecurityPolicySubjectReviewStatus) MarshalTo(dAtA []byte) (int, error) {
1106 size := m.Size()
1107 return m.MarshalToSizedBuffer(dAtA[:size])
1108 }
1109
1110 func (m *PodSecurityPolicySubjectReviewStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1111 i := len(dAtA)
1112 _ = i
1113 var l int
1114 _ = l
1115 {
1116 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
1117 if err != nil {
1118 return 0, err
1119 }
1120 i -= size
1121 i = encodeVarintGenerated(dAtA, i, uint64(size))
1122 }
1123 i--
1124 dAtA[i] = 0x1a
1125 i -= len(m.Reason)
1126 copy(dAtA[i:], m.Reason)
1127 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1128 i--
1129 dAtA[i] = 0x12
1130 if m.AllowedBy != nil {
1131 {
1132 size, err := m.AllowedBy.MarshalToSizedBuffer(dAtA[:i])
1133 if err != nil {
1134 return 0, err
1135 }
1136 i -= size
1137 i = encodeVarintGenerated(dAtA, i, uint64(size))
1138 }
1139 i--
1140 dAtA[i] = 0xa
1141 }
1142 return len(dAtA) - i, nil
1143 }
1144
1145 func (m *RangeAllocation) Marshal() (dAtA []byte, err error) {
1146 size := m.Size()
1147 dAtA = make([]byte, size)
1148 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1149 if err != nil {
1150 return nil, err
1151 }
1152 return dAtA[:n], nil
1153 }
1154
1155 func (m *RangeAllocation) MarshalTo(dAtA []byte) (int, error) {
1156 size := m.Size()
1157 return m.MarshalToSizedBuffer(dAtA[:size])
1158 }
1159
1160 func (m *RangeAllocation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1161 i := len(dAtA)
1162 _ = i
1163 var l int
1164 _ = l
1165 if m.Data != nil {
1166 i -= len(m.Data)
1167 copy(dAtA[i:], m.Data)
1168 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Data)))
1169 i--
1170 dAtA[i] = 0x1a
1171 }
1172 i -= len(m.Range)
1173 copy(dAtA[i:], m.Range)
1174 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Range)))
1175 i--
1176 dAtA[i] = 0x12
1177 {
1178 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1179 if err != nil {
1180 return 0, err
1181 }
1182 i -= size
1183 i = encodeVarintGenerated(dAtA, i, uint64(size))
1184 }
1185 i--
1186 dAtA[i] = 0xa
1187 return len(dAtA) - i, nil
1188 }
1189
1190 func (m *RangeAllocationList) Marshal() (dAtA []byte, err error) {
1191 size := m.Size()
1192 dAtA = make([]byte, size)
1193 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1194 if err != nil {
1195 return nil, err
1196 }
1197 return dAtA[:n], nil
1198 }
1199
1200 func (m *RangeAllocationList) MarshalTo(dAtA []byte) (int, error) {
1201 size := m.Size()
1202 return m.MarshalToSizedBuffer(dAtA[:size])
1203 }
1204
1205 func (m *RangeAllocationList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1206 i := len(dAtA)
1207 _ = i
1208 var l int
1209 _ = l
1210 if len(m.Items) > 0 {
1211 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1212 {
1213 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1214 if err != nil {
1215 return 0, err
1216 }
1217 i -= size
1218 i = encodeVarintGenerated(dAtA, i, uint64(size))
1219 }
1220 i--
1221 dAtA[i] = 0x12
1222 }
1223 }
1224 {
1225 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1226 if err != nil {
1227 return 0, err
1228 }
1229 i -= size
1230 i = encodeVarintGenerated(dAtA, i, uint64(size))
1231 }
1232 i--
1233 dAtA[i] = 0xa
1234 return len(dAtA) - i, nil
1235 }
1236
1237 func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) {
1238 size := m.Size()
1239 dAtA = make([]byte, size)
1240 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1241 if err != nil {
1242 return nil, err
1243 }
1244 return dAtA[:n], nil
1245 }
1246
1247 func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
1248 size := m.Size()
1249 return m.MarshalToSizedBuffer(dAtA[:size])
1250 }
1251
1252 func (m *RunAsUserStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1253 i := len(dAtA)
1254 _ = i
1255 var l int
1256 _ = l
1257 if m.UIDRangeMax != nil {
1258 i = encodeVarintGenerated(dAtA, i, uint64(*m.UIDRangeMax))
1259 i--
1260 dAtA[i] = 0x20
1261 }
1262 if m.UIDRangeMin != nil {
1263 i = encodeVarintGenerated(dAtA, i, uint64(*m.UIDRangeMin))
1264 i--
1265 dAtA[i] = 0x18
1266 }
1267 if m.UID != nil {
1268 i = encodeVarintGenerated(dAtA, i, uint64(*m.UID))
1269 i--
1270 dAtA[i] = 0x10
1271 }
1272 i -= len(m.Type)
1273 copy(dAtA[i:], m.Type)
1274 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1275 i--
1276 dAtA[i] = 0xa
1277 return len(dAtA) - i, nil
1278 }
1279
1280 func (m *SELinuxContextStrategyOptions) Marshal() (dAtA []byte, err error) {
1281 size := m.Size()
1282 dAtA = make([]byte, size)
1283 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1284 if err != nil {
1285 return nil, err
1286 }
1287 return dAtA[:n], nil
1288 }
1289
1290 func (m *SELinuxContextStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
1291 size := m.Size()
1292 return m.MarshalToSizedBuffer(dAtA[:size])
1293 }
1294
1295 func (m *SELinuxContextStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1296 i := len(dAtA)
1297 _ = i
1298 var l int
1299 _ = l
1300 if m.SELinuxOptions != nil {
1301 {
1302 size, err := m.SELinuxOptions.MarshalToSizedBuffer(dAtA[:i])
1303 if err != nil {
1304 return 0, err
1305 }
1306 i -= size
1307 i = encodeVarintGenerated(dAtA, i, uint64(size))
1308 }
1309 i--
1310 dAtA[i] = 0x12
1311 }
1312 i -= len(m.Type)
1313 copy(dAtA[i:], m.Type)
1314 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1315 i--
1316 dAtA[i] = 0xa
1317 return len(dAtA) - i, nil
1318 }
1319
1320 func (m *SecurityContextConstraints) Marshal() (dAtA []byte, err error) {
1321 size := m.Size()
1322 dAtA = make([]byte, size)
1323 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1324 if err != nil {
1325 return nil, err
1326 }
1327 return dAtA[:n], nil
1328 }
1329
1330 func (m *SecurityContextConstraints) MarshalTo(dAtA []byte) (int, error) {
1331 size := m.Size()
1332 return m.MarshalToSizedBuffer(dAtA[:size])
1333 }
1334
1335 func (m *SecurityContextConstraints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1336 i := len(dAtA)
1337 _ = i
1338 var l int
1339 _ = l
1340 if len(m.ForbiddenSysctls) > 0 {
1341 for iNdEx := len(m.ForbiddenSysctls) - 1; iNdEx >= 0; iNdEx-- {
1342 i -= len(m.ForbiddenSysctls[iNdEx])
1343 copy(dAtA[i:], m.ForbiddenSysctls[iNdEx])
1344 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ForbiddenSysctls[iNdEx])))
1345 i--
1346 dAtA[i] = 0x1
1347 i--
1348 dAtA[i] = 0xca
1349 }
1350 }
1351 if len(m.AllowedUnsafeSysctls) > 0 {
1352 for iNdEx := len(m.AllowedUnsafeSysctls) - 1; iNdEx >= 0; iNdEx-- {
1353 i -= len(m.AllowedUnsafeSysctls[iNdEx])
1354 copy(dAtA[i:], m.AllowedUnsafeSysctls[iNdEx])
1355 i = encodeVarintGenerated(dAtA, i, uint64(len(m.AllowedUnsafeSysctls[iNdEx])))
1356 i--
1357 dAtA[i] = 0x1
1358 i--
1359 dAtA[i] = 0xc2
1360 }
1361 }
1362 if m.AllowPrivilegeEscalation != nil {
1363 i--
1364 if *m.AllowPrivilegeEscalation {
1365 dAtA[i] = 1
1366 } else {
1367 dAtA[i] = 0
1368 }
1369 i--
1370 dAtA[i] = 0x1
1371 i--
1372 dAtA[i] = 0xb8
1373 }
1374 if m.DefaultAllowPrivilegeEscalation != nil {
1375 i--
1376 if *m.DefaultAllowPrivilegeEscalation {
1377 dAtA[i] = 1
1378 } else {
1379 dAtA[i] = 0
1380 }
1381 i--
1382 dAtA[i] = 0x1
1383 i--
1384 dAtA[i] = 0xb0
1385 }
1386 if len(m.AllowedFlexVolumes) > 0 {
1387 for iNdEx := len(m.AllowedFlexVolumes) - 1; iNdEx >= 0; iNdEx-- {
1388 {
1389 size, err := m.AllowedFlexVolumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1390 if err != nil {
1391 return 0, err
1392 }
1393 i -= size
1394 i = encodeVarintGenerated(dAtA, i, uint64(size))
1395 }
1396 i--
1397 dAtA[i] = 0x1
1398 i--
1399 dAtA[i] = 0xaa
1400 }
1401 }
1402 if len(m.SeccompProfiles) > 0 {
1403 for iNdEx := len(m.SeccompProfiles) - 1; iNdEx >= 0; iNdEx-- {
1404 i -= len(m.SeccompProfiles[iNdEx])
1405 copy(dAtA[i:], m.SeccompProfiles[iNdEx])
1406 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SeccompProfiles[iNdEx])))
1407 i--
1408 dAtA[i] = 0x1
1409 i--
1410 dAtA[i] = 0xa2
1411 }
1412 }
1413 if len(m.Groups) > 0 {
1414 for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
1415 i -= len(m.Groups[iNdEx])
1416 copy(dAtA[i:], m.Groups[iNdEx])
1417 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Groups[iNdEx])))
1418 i--
1419 dAtA[i] = 0x1
1420 i--
1421 dAtA[i] = 0x9a
1422 }
1423 }
1424 if len(m.Users) > 0 {
1425 for iNdEx := len(m.Users) - 1; iNdEx >= 0; iNdEx-- {
1426 i -= len(m.Users[iNdEx])
1427 copy(dAtA[i:], m.Users[iNdEx])
1428 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Users[iNdEx])))
1429 i--
1430 dAtA[i] = 0x1
1431 i--
1432 dAtA[i] = 0x92
1433 }
1434 }
1435 i--
1436 if m.ReadOnlyRootFilesystem {
1437 dAtA[i] = 1
1438 } else {
1439 dAtA[i] = 0
1440 }
1441 i--
1442 dAtA[i] = 0x1
1443 i--
1444 dAtA[i] = 0x88
1445 {
1446 size, err := m.FSGroup.MarshalToSizedBuffer(dAtA[:i])
1447 if err != nil {
1448 return 0, err
1449 }
1450 i -= size
1451 i = encodeVarintGenerated(dAtA, i, uint64(size))
1452 }
1453 i--
1454 dAtA[i] = 0x1
1455 i--
1456 dAtA[i] = 0x82
1457 {
1458 size, err := m.SupplementalGroups.MarshalToSizedBuffer(dAtA[:i])
1459 if err != nil {
1460 return 0, err
1461 }
1462 i -= size
1463 i = encodeVarintGenerated(dAtA, i, uint64(size))
1464 }
1465 i--
1466 dAtA[i] = 0x7a
1467 {
1468 size, err := m.RunAsUser.MarshalToSizedBuffer(dAtA[:i])
1469 if err != nil {
1470 return 0, err
1471 }
1472 i -= size
1473 i = encodeVarintGenerated(dAtA, i, uint64(size))
1474 }
1475 i--
1476 dAtA[i] = 0x72
1477 {
1478 size, err := m.SELinuxContext.MarshalToSizedBuffer(dAtA[:i])
1479 if err != nil {
1480 return 0, err
1481 }
1482 i -= size
1483 i = encodeVarintGenerated(dAtA, i, uint64(size))
1484 }
1485 i--
1486 dAtA[i] = 0x6a
1487 i--
1488 if m.AllowHostIPC {
1489 dAtA[i] = 1
1490 } else {
1491 dAtA[i] = 0
1492 }
1493 i--
1494 dAtA[i] = 0x60
1495 i--
1496 if m.AllowHostPID {
1497 dAtA[i] = 1
1498 } else {
1499 dAtA[i] = 0
1500 }
1501 i--
1502 dAtA[i] = 0x58
1503 i--
1504 if m.AllowHostPorts {
1505 dAtA[i] = 1
1506 } else {
1507 dAtA[i] = 0
1508 }
1509 i--
1510 dAtA[i] = 0x50
1511 i--
1512 if m.AllowHostNetwork {
1513 dAtA[i] = 1
1514 } else {
1515 dAtA[i] = 0
1516 }
1517 i--
1518 dAtA[i] = 0x48
1519 if len(m.Volumes) > 0 {
1520 for iNdEx := len(m.Volumes) - 1; iNdEx >= 0; iNdEx-- {
1521 i -= len(m.Volumes[iNdEx])
1522 copy(dAtA[i:], m.Volumes[iNdEx])
1523 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Volumes[iNdEx])))
1524 i--
1525 dAtA[i] = 0x42
1526 }
1527 }
1528 i--
1529 if m.AllowHostDirVolumePlugin {
1530 dAtA[i] = 1
1531 } else {
1532 dAtA[i] = 0
1533 }
1534 i--
1535 dAtA[i] = 0x38
1536 if len(m.AllowedCapabilities) > 0 {
1537 for iNdEx := len(m.AllowedCapabilities) - 1; iNdEx >= 0; iNdEx-- {
1538 i -= len(m.AllowedCapabilities[iNdEx])
1539 copy(dAtA[i:], m.AllowedCapabilities[iNdEx])
1540 i = encodeVarintGenerated(dAtA, i, uint64(len(m.AllowedCapabilities[iNdEx])))
1541 i--
1542 dAtA[i] = 0x32
1543 }
1544 }
1545 if len(m.RequiredDropCapabilities) > 0 {
1546 for iNdEx := len(m.RequiredDropCapabilities) - 1; iNdEx >= 0; iNdEx-- {
1547 i -= len(m.RequiredDropCapabilities[iNdEx])
1548 copy(dAtA[i:], m.RequiredDropCapabilities[iNdEx])
1549 i = encodeVarintGenerated(dAtA, i, uint64(len(m.RequiredDropCapabilities[iNdEx])))
1550 i--
1551 dAtA[i] = 0x2a
1552 }
1553 }
1554 if len(m.DefaultAddCapabilities) > 0 {
1555 for iNdEx := len(m.DefaultAddCapabilities) - 1; iNdEx >= 0; iNdEx-- {
1556 i -= len(m.DefaultAddCapabilities[iNdEx])
1557 copy(dAtA[i:], m.DefaultAddCapabilities[iNdEx])
1558 i = encodeVarintGenerated(dAtA, i, uint64(len(m.DefaultAddCapabilities[iNdEx])))
1559 i--
1560 dAtA[i] = 0x22
1561 }
1562 }
1563 i--
1564 if m.AllowPrivilegedContainer {
1565 dAtA[i] = 1
1566 } else {
1567 dAtA[i] = 0
1568 }
1569 i--
1570 dAtA[i] = 0x18
1571 if m.Priority != nil {
1572 i = encodeVarintGenerated(dAtA, i, uint64(*m.Priority))
1573 i--
1574 dAtA[i] = 0x10
1575 }
1576 {
1577 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1578 if err != nil {
1579 return 0, err
1580 }
1581 i -= size
1582 i = encodeVarintGenerated(dAtA, i, uint64(size))
1583 }
1584 i--
1585 dAtA[i] = 0xa
1586 return len(dAtA) - i, nil
1587 }
1588
1589 func (m *SecurityContextConstraintsList) Marshal() (dAtA []byte, err error) {
1590 size := m.Size()
1591 dAtA = make([]byte, size)
1592 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1593 if err != nil {
1594 return nil, err
1595 }
1596 return dAtA[:n], nil
1597 }
1598
1599 func (m *SecurityContextConstraintsList) MarshalTo(dAtA []byte) (int, error) {
1600 size := m.Size()
1601 return m.MarshalToSizedBuffer(dAtA[:size])
1602 }
1603
1604 func (m *SecurityContextConstraintsList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1605 i := len(dAtA)
1606 _ = i
1607 var l int
1608 _ = l
1609 if len(m.Items) > 0 {
1610 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1611 {
1612 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1613 if err != nil {
1614 return 0, err
1615 }
1616 i -= size
1617 i = encodeVarintGenerated(dAtA, i, uint64(size))
1618 }
1619 i--
1620 dAtA[i] = 0x12
1621 }
1622 }
1623 {
1624 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1625 if err != nil {
1626 return 0, err
1627 }
1628 i -= size
1629 i = encodeVarintGenerated(dAtA, i, uint64(size))
1630 }
1631 i--
1632 dAtA[i] = 0xa
1633 return len(dAtA) - i, nil
1634 }
1635
1636 func (m *ServiceAccountPodSecurityPolicyReviewStatus) Marshal() (dAtA []byte, err error) {
1637 size := m.Size()
1638 dAtA = make([]byte, size)
1639 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1640 if err != nil {
1641 return nil, err
1642 }
1643 return dAtA[:n], nil
1644 }
1645
1646 func (m *ServiceAccountPodSecurityPolicyReviewStatus) MarshalTo(dAtA []byte) (int, error) {
1647 size := m.Size()
1648 return m.MarshalToSizedBuffer(dAtA[:size])
1649 }
1650
1651 func (m *ServiceAccountPodSecurityPolicyReviewStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1652 i := len(dAtA)
1653 _ = i
1654 var l int
1655 _ = l
1656 i -= len(m.Name)
1657 copy(dAtA[i:], m.Name)
1658 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1659 i--
1660 dAtA[i] = 0x12
1661 {
1662 size, err := m.PodSecurityPolicySubjectReviewStatus.MarshalToSizedBuffer(dAtA[:i])
1663 if err != nil {
1664 return 0, err
1665 }
1666 i -= size
1667 i = encodeVarintGenerated(dAtA, i, uint64(size))
1668 }
1669 i--
1670 dAtA[i] = 0xa
1671 return len(dAtA) - i, nil
1672 }
1673
1674 func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) {
1675 size := m.Size()
1676 dAtA = make([]byte, size)
1677 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1678 if err != nil {
1679 return nil, err
1680 }
1681 return dAtA[:n], nil
1682 }
1683
1684 func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
1685 size := m.Size()
1686 return m.MarshalToSizedBuffer(dAtA[:size])
1687 }
1688
1689 func (m *SupplementalGroupsStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1690 i := len(dAtA)
1691 _ = i
1692 var l int
1693 _ = l
1694 if len(m.Ranges) > 0 {
1695 for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- {
1696 {
1697 size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1698 if err != nil {
1699 return 0, err
1700 }
1701 i -= size
1702 i = encodeVarintGenerated(dAtA, i, uint64(size))
1703 }
1704 i--
1705 dAtA[i] = 0x12
1706 }
1707 }
1708 i -= len(m.Type)
1709 copy(dAtA[i:], m.Type)
1710 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1711 i--
1712 dAtA[i] = 0xa
1713 return len(dAtA) - i, nil
1714 }
1715
1716 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1717 offset -= sovGenerated(v)
1718 base := offset
1719 for v >= 1<<7 {
1720 dAtA[offset] = uint8(v&0x7f | 0x80)
1721 v >>= 7
1722 offset++
1723 }
1724 dAtA[offset] = uint8(v)
1725 return base
1726 }
1727 func (m *AllowedFlexVolume) Size() (n int) {
1728 if m == nil {
1729 return 0
1730 }
1731 var l int
1732 _ = l
1733 l = len(m.Driver)
1734 n += 1 + l + sovGenerated(uint64(l))
1735 return n
1736 }
1737
1738 func (m *FSGroupStrategyOptions) Size() (n int) {
1739 if m == nil {
1740 return 0
1741 }
1742 var l int
1743 _ = l
1744 l = len(m.Type)
1745 n += 1 + l + sovGenerated(uint64(l))
1746 if len(m.Ranges) > 0 {
1747 for _, e := range m.Ranges {
1748 l = e.Size()
1749 n += 1 + l + sovGenerated(uint64(l))
1750 }
1751 }
1752 return n
1753 }
1754
1755 func (m *IDRange) Size() (n int) {
1756 if m == nil {
1757 return 0
1758 }
1759 var l int
1760 _ = l
1761 n += 1 + sovGenerated(uint64(m.Min))
1762 n += 1 + sovGenerated(uint64(m.Max))
1763 return n
1764 }
1765
1766 func (m *PodSecurityPolicyReview) Size() (n int) {
1767 if m == nil {
1768 return 0
1769 }
1770 var l int
1771 _ = l
1772 l = m.Spec.Size()
1773 n += 1 + l + sovGenerated(uint64(l))
1774 l = m.Status.Size()
1775 n += 1 + l + sovGenerated(uint64(l))
1776 return n
1777 }
1778
1779 func (m *PodSecurityPolicyReviewSpec) Size() (n int) {
1780 if m == nil {
1781 return 0
1782 }
1783 var l int
1784 _ = l
1785 l = m.Template.Size()
1786 n += 1 + l + sovGenerated(uint64(l))
1787 if len(m.ServiceAccountNames) > 0 {
1788 for _, s := range m.ServiceAccountNames {
1789 l = len(s)
1790 n += 1 + l + sovGenerated(uint64(l))
1791 }
1792 }
1793 return n
1794 }
1795
1796 func (m *PodSecurityPolicyReviewStatus) Size() (n int) {
1797 if m == nil {
1798 return 0
1799 }
1800 var l int
1801 _ = l
1802 if len(m.AllowedServiceAccounts) > 0 {
1803 for _, e := range m.AllowedServiceAccounts {
1804 l = e.Size()
1805 n += 1 + l + sovGenerated(uint64(l))
1806 }
1807 }
1808 return n
1809 }
1810
1811 func (m *PodSecurityPolicySelfSubjectReview) Size() (n int) {
1812 if m == nil {
1813 return 0
1814 }
1815 var l int
1816 _ = l
1817 l = m.Spec.Size()
1818 n += 1 + l + sovGenerated(uint64(l))
1819 l = m.Status.Size()
1820 n += 1 + l + sovGenerated(uint64(l))
1821 return n
1822 }
1823
1824 func (m *PodSecurityPolicySelfSubjectReviewSpec) Size() (n int) {
1825 if m == nil {
1826 return 0
1827 }
1828 var l int
1829 _ = l
1830 l = m.Template.Size()
1831 n += 1 + l + sovGenerated(uint64(l))
1832 return n
1833 }
1834
1835 func (m *PodSecurityPolicySubjectReview) Size() (n int) {
1836 if m == nil {
1837 return 0
1838 }
1839 var l int
1840 _ = l
1841 l = m.Spec.Size()
1842 n += 1 + l + sovGenerated(uint64(l))
1843 l = m.Status.Size()
1844 n += 1 + l + sovGenerated(uint64(l))
1845 return n
1846 }
1847
1848 func (m *PodSecurityPolicySubjectReviewSpec) Size() (n int) {
1849 if m == nil {
1850 return 0
1851 }
1852 var l int
1853 _ = l
1854 l = m.Template.Size()
1855 n += 1 + l + sovGenerated(uint64(l))
1856 l = len(m.User)
1857 n += 1 + l + sovGenerated(uint64(l))
1858 if len(m.Groups) > 0 {
1859 for _, s := range m.Groups {
1860 l = len(s)
1861 n += 1 + l + sovGenerated(uint64(l))
1862 }
1863 }
1864 return n
1865 }
1866
1867 func (m *PodSecurityPolicySubjectReviewStatus) Size() (n int) {
1868 if m == nil {
1869 return 0
1870 }
1871 var l int
1872 _ = l
1873 if m.AllowedBy != nil {
1874 l = m.AllowedBy.Size()
1875 n += 1 + l + sovGenerated(uint64(l))
1876 }
1877 l = len(m.Reason)
1878 n += 1 + l + sovGenerated(uint64(l))
1879 l = m.Template.Size()
1880 n += 1 + l + sovGenerated(uint64(l))
1881 return n
1882 }
1883
1884 func (m *RangeAllocation) Size() (n int) {
1885 if m == nil {
1886 return 0
1887 }
1888 var l int
1889 _ = l
1890 l = m.ObjectMeta.Size()
1891 n += 1 + l + sovGenerated(uint64(l))
1892 l = len(m.Range)
1893 n += 1 + l + sovGenerated(uint64(l))
1894 if m.Data != nil {
1895 l = len(m.Data)
1896 n += 1 + l + sovGenerated(uint64(l))
1897 }
1898 return n
1899 }
1900
1901 func (m *RangeAllocationList) Size() (n int) {
1902 if m == nil {
1903 return 0
1904 }
1905 var l int
1906 _ = l
1907 l = m.ListMeta.Size()
1908 n += 1 + l + sovGenerated(uint64(l))
1909 if len(m.Items) > 0 {
1910 for _, e := range m.Items {
1911 l = e.Size()
1912 n += 1 + l + sovGenerated(uint64(l))
1913 }
1914 }
1915 return n
1916 }
1917
1918 func (m *RunAsUserStrategyOptions) Size() (n int) {
1919 if m == nil {
1920 return 0
1921 }
1922 var l int
1923 _ = l
1924 l = len(m.Type)
1925 n += 1 + l + sovGenerated(uint64(l))
1926 if m.UID != nil {
1927 n += 1 + sovGenerated(uint64(*m.UID))
1928 }
1929 if m.UIDRangeMin != nil {
1930 n += 1 + sovGenerated(uint64(*m.UIDRangeMin))
1931 }
1932 if m.UIDRangeMax != nil {
1933 n += 1 + sovGenerated(uint64(*m.UIDRangeMax))
1934 }
1935 return n
1936 }
1937
1938 func (m *SELinuxContextStrategyOptions) Size() (n int) {
1939 if m == nil {
1940 return 0
1941 }
1942 var l int
1943 _ = l
1944 l = len(m.Type)
1945 n += 1 + l + sovGenerated(uint64(l))
1946 if m.SELinuxOptions != nil {
1947 l = m.SELinuxOptions.Size()
1948 n += 1 + l + sovGenerated(uint64(l))
1949 }
1950 return n
1951 }
1952
1953 func (m *SecurityContextConstraints) Size() (n int) {
1954 if m == nil {
1955 return 0
1956 }
1957 var l int
1958 _ = l
1959 l = m.ObjectMeta.Size()
1960 n += 1 + l + sovGenerated(uint64(l))
1961 if m.Priority != nil {
1962 n += 1 + sovGenerated(uint64(*m.Priority))
1963 }
1964 n += 2
1965 if len(m.DefaultAddCapabilities) > 0 {
1966 for _, s := range m.DefaultAddCapabilities {
1967 l = len(s)
1968 n += 1 + l + sovGenerated(uint64(l))
1969 }
1970 }
1971 if len(m.RequiredDropCapabilities) > 0 {
1972 for _, s := range m.RequiredDropCapabilities {
1973 l = len(s)
1974 n += 1 + l + sovGenerated(uint64(l))
1975 }
1976 }
1977 if len(m.AllowedCapabilities) > 0 {
1978 for _, s := range m.AllowedCapabilities {
1979 l = len(s)
1980 n += 1 + l + sovGenerated(uint64(l))
1981 }
1982 }
1983 n += 2
1984 if len(m.Volumes) > 0 {
1985 for _, s := range m.Volumes {
1986 l = len(s)
1987 n += 1 + l + sovGenerated(uint64(l))
1988 }
1989 }
1990 n += 2
1991 n += 2
1992 n += 2
1993 n += 2
1994 l = m.SELinuxContext.Size()
1995 n += 1 + l + sovGenerated(uint64(l))
1996 l = m.RunAsUser.Size()
1997 n += 1 + l + sovGenerated(uint64(l))
1998 l = m.SupplementalGroups.Size()
1999 n += 1 + l + sovGenerated(uint64(l))
2000 l = m.FSGroup.Size()
2001 n += 2 + l + sovGenerated(uint64(l))
2002 n += 3
2003 if len(m.Users) > 0 {
2004 for _, s := range m.Users {
2005 l = len(s)
2006 n += 2 + l + sovGenerated(uint64(l))
2007 }
2008 }
2009 if len(m.Groups) > 0 {
2010 for _, s := range m.Groups {
2011 l = len(s)
2012 n += 2 + l + sovGenerated(uint64(l))
2013 }
2014 }
2015 if len(m.SeccompProfiles) > 0 {
2016 for _, s := range m.SeccompProfiles {
2017 l = len(s)
2018 n += 2 + l + sovGenerated(uint64(l))
2019 }
2020 }
2021 if len(m.AllowedFlexVolumes) > 0 {
2022 for _, e := range m.AllowedFlexVolumes {
2023 l = e.Size()
2024 n += 2 + l + sovGenerated(uint64(l))
2025 }
2026 }
2027 if m.DefaultAllowPrivilegeEscalation != nil {
2028 n += 3
2029 }
2030 if m.AllowPrivilegeEscalation != nil {
2031 n += 3
2032 }
2033 if len(m.AllowedUnsafeSysctls) > 0 {
2034 for _, s := range m.AllowedUnsafeSysctls {
2035 l = len(s)
2036 n += 2 + l + sovGenerated(uint64(l))
2037 }
2038 }
2039 if len(m.ForbiddenSysctls) > 0 {
2040 for _, s := range m.ForbiddenSysctls {
2041 l = len(s)
2042 n += 2 + l + sovGenerated(uint64(l))
2043 }
2044 }
2045 return n
2046 }
2047
2048 func (m *SecurityContextConstraintsList) Size() (n int) {
2049 if m == nil {
2050 return 0
2051 }
2052 var l int
2053 _ = l
2054 l = m.ListMeta.Size()
2055 n += 1 + l + sovGenerated(uint64(l))
2056 if len(m.Items) > 0 {
2057 for _, e := range m.Items {
2058 l = e.Size()
2059 n += 1 + l + sovGenerated(uint64(l))
2060 }
2061 }
2062 return n
2063 }
2064
2065 func (m *ServiceAccountPodSecurityPolicyReviewStatus) Size() (n int) {
2066 if m == nil {
2067 return 0
2068 }
2069 var l int
2070 _ = l
2071 l = m.PodSecurityPolicySubjectReviewStatus.Size()
2072 n += 1 + l + sovGenerated(uint64(l))
2073 l = len(m.Name)
2074 n += 1 + l + sovGenerated(uint64(l))
2075 return n
2076 }
2077
2078 func (m *SupplementalGroupsStrategyOptions) Size() (n int) {
2079 if m == nil {
2080 return 0
2081 }
2082 var l int
2083 _ = l
2084 l = len(m.Type)
2085 n += 1 + l + sovGenerated(uint64(l))
2086 if len(m.Ranges) > 0 {
2087 for _, e := range m.Ranges {
2088 l = e.Size()
2089 n += 1 + l + sovGenerated(uint64(l))
2090 }
2091 }
2092 return n
2093 }
2094
2095 func sovGenerated(x uint64) (n int) {
2096 return (math_bits.Len64(x|1) + 6) / 7
2097 }
2098 func sozGenerated(x uint64) (n int) {
2099 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2100 }
2101 func (this *AllowedFlexVolume) String() string {
2102 if this == nil {
2103 return "nil"
2104 }
2105 s := strings.Join([]string{`&AllowedFlexVolume{`,
2106 `Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
2107 `}`,
2108 }, "")
2109 return s
2110 }
2111 func (this *FSGroupStrategyOptions) String() string {
2112 if this == nil {
2113 return "nil"
2114 }
2115 repeatedStringForRanges := "[]IDRange{"
2116 for _, f := range this.Ranges {
2117 repeatedStringForRanges += strings.Replace(strings.Replace(f.String(), "IDRange", "IDRange", 1), `&`, ``, 1) + ","
2118 }
2119 repeatedStringForRanges += "}"
2120 s := strings.Join([]string{`&FSGroupStrategyOptions{`,
2121 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2122 `Ranges:` + repeatedStringForRanges + `,`,
2123 `}`,
2124 }, "")
2125 return s
2126 }
2127 func (this *IDRange) String() string {
2128 if this == nil {
2129 return "nil"
2130 }
2131 s := strings.Join([]string{`&IDRange{`,
2132 `Min:` + fmt.Sprintf("%v", this.Min) + `,`,
2133 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
2134 `}`,
2135 }, "")
2136 return s
2137 }
2138 func (this *PodSecurityPolicyReview) String() string {
2139 if this == nil {
2140 return "nil"
2141 }
2142 s := strings.Join([]string{`&PodSecurityPolicyReview{`,
2143 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicyReviewSpec", "PodSecurityPolicyReviewSpec", 1), `&`, ``, 1) + `,`,
2144 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PodSecurityPolicyReviewStatus", "PodSecurityPolicyReviewStatus", 1), `&`, ``, 1) + `,`,
2145 `}`,
2146 }, "")
2147 return s
2148 }
2149 func (this *PodSecurityPolicyReviewSpec) String() string {
2150 if this == nil {
2151 return "nil"
2152 }
2153 s := strings.Join([]string{`&PodSecurityPolicyReviewSpec{`,
2154 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2155 `ServiceAccountNames:` + fmt.Sprintf("%v", this.ServiceAccountNames) + `,`,
2156 `}`,
2157 }, "")
2158 return s
2159 }
2160 func (this *PodSecurityPolicyReviewStatus) String() string {
2161 if this == nil {
2162 return "nil"
2163 }
2164 repeatedStringForAllowedServiceAccounts := "[]ServiceAccountPodSecurityPolicyReviewStatus{"
2165 for _, f := range this.AllowedServiceAccounts {
2166 repeatedStringForAllowedServiceAccounts += strings.Replace(strings.Replace(f.String(), "ServiceAccountPodSecurityPolicyReviewStatus", "ServiceAccountPodSecurityPolicyReviewStatus", 1), `&`, ``, 1) + ","
2167 }
2168 repeatedStringForAllowedServiceAccounts += "}"
2169 s := strings.Join([]string{`&PodSecurityPolicyReviewStatus{`,
2170 `AllowedServiceAccounts:` + repeatedStringForAllowedServiceAccounts + `,`,
2171 `}`,
2172 }, "")
2173 return s
2174 }
2175 func (this *PodSecurityPolicySelfSubjectReview) String() string {
2176 if this == nil {
2177 return "nil"
2178 }
2179 s := strings.Join([]string{`&PodSecurityPolicySelfSubjectReview{`,
2180 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySelfSubjectReviewSpec", "PodSecurityPolicySelfSubjectReviewSpec", 1), `&`, ``, 1) + `,`,
2181 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PodSecurityPolicySubjectReviewStatus", "PodSecurityPolicySubjectReviewStatus", 1), `&`, ``, 1) + `,`,
2182 `}`,
2183 }, "")
2184 return s
2185 }
2186 func (this *PodSecurityPolicySelfSubjectReviewSpec) String() string {
2187 if this == nil {
2188 return "nil"
2189 }
2190 s := strings.Join([]string{`&PodSecurityPolicySelfSubjectReviewSpec{`,
2191 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2192 `}`,
2193 }, "")
2194 return s
2195 }
2196 func (this *PodSecurityPolicySubjectReview) String() string {
2197 if this == nil {
2198 return "nil"
2199 }
2200 s := strings.Join([]string{`&PodSecurityPolicySubjectReview{`,
2201 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySubjectReviewSpec", "PodSecurityPolicySubjectReviewSpec", 1), `&`, ``, 1) + `,`,
2202 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PodSecurityPolicySubjectReviewStatus", "PodSecurityPolicySubjectReviewStatus", 1), `&`, ``, 1) + `,`,
2203 `}`,
2204 }, "")
2205 return s
2206 }
2207 func (this *PodSecurityPolicySubjectReviewSpec) String() string {
2208 if this == nil {
2209 return "nil"
2210 }
2211 s := strings.Join([]string{`&PodSecurityPolicySubjectReviewSpec{`,
2212 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2213 `User:` + fmt.Sprintf("%v", this.User) + `,`,
2214 `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
2215 `}`,
2216 }, "")
2217 return s
2218 }
2219 func (this *PodSecurityPolicySubjectReviewStatus) String() string {
2220 if this == nil {
2221 return "nil"
2222 }
2223 s := strings.Join([]string{`&PodSecurityPolicySubjectReviewStatus{`,
2224 `AllowedBy:` + strings.Replace(fmt.Sprintf("%v", this.AllowedBy), "ObjectReference", "v1.ObjectReference", 1) + `,`,
2225 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2226 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2227 `}`,
2228 }, "")
2229 return s
2230 }
2231 func (this *RangeAllocation) String() string {
2232 if this == nil {
2233 return "nil"
2234 }
2235 s := strings.Join([]string{`&RangeAllocation{`,
2236 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
2237 `Range:` + fmt.Sprintf("%v", this.Range) + `,`,
2238 `Data:` + valueToStringGenerated(this.Data) + `,`,
2239 `}`,
2240 }, "")
2241 return s
2242 }
2243 func (this *RangeAllocationList) String() string {
2244 if this == nil {
2245 return "nil"
2246 }
2247 repeatedStringForItems := "[]RangeAllocation{"
2248 for _, f := range this.Items {
2249 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "RangeAllocation", "RangeAllocation", 1), `&`, ``, 1) + ","
2250 }
2251 repeatedStringForItems += "}"
2252 s := strings.Join([]string{`&RangeAllocationList{`,
2253 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
2254 `Items:` + repeatedStringForItems + `,`,
2255 `}`,
2256 }, "")
2257 return s
2258 }
2259 func (this *RunAsUserStrategyOptions) String() string {
2260 if this == nil {
2261 return "nil"
2262 }
2263 s := strings.Join([]string{`&RunAsUserStrategyOptions{`,
2264 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2265 `UID:` + valueToStringGenerated(this.UID) + `,`,
2266 `UIDRangeMin:` + valueToStringGenerated(this.UIDRangeMin) + `,`,
2267 `UIDRangeMax:` + valueToStringGenerated(this.UIDRangeMax) + `,`,
2268 `}`,
2269 }, "")
2270 return s
2271 }
2272 func (this *SELinuxContextStrategyOptions) String() string {
2273 if this == nil {
2274 return "nil"
2275 }
2276 s := strings.Join([]string{`&SELinuxContextStrategyOptions{`,
2277 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2278 `SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "v1.SELinuxOptions", 1) + `,`,
2279 `}`,
2280 }, "")
2281 return s
2282 }
2283 func (this *SecurityContextConstraints) String() string {
2284 if this == nil {
2285 return "nil"
2286 }
2287 repeatedStringForAllowedFlexVolumes := "[]AllowedFlexVolume{"
2288 for _, f := range this.AllowedFlexVolumes {
2289 repeatedStringForAllowedFlexVolumes += strings.Replace(strings.Replace(f.String(), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + ","
2290 }
2291 repeatedStringForAllowedFlexVolumes += "}"
2292 s := strings.Join([]string{`&SecurityContextConstraints{`,
2293 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
2294 `Priority:` + valueToStringGenerated(this.Priority) + `,`,
2295 `AllowPrivilegedContainer:` + fmt.Sprintf("%v", this.AllowPrivilegedContainer) + `,`,
2296 `DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`,
2297 `RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`,
2298 `AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`,
2299 `AllowHostDirVolumePlugin:` + fmt.Sprintf("%v", this.AllowHostDirVolumePlugin) + `,`,
2300 `Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`,
2301 `AllowHostNetwork:` + fmt.Sprintf("%v", this.AllowHostNetwork) + `,`,
2302 `AllowHostPorts:` + fmt.Sprintf("%v", this.AllowHostPorts) + `,`,
2303 `AllowHostPID:` + fmt.Sprintf("%v", this.AllowHostPID) + `,`,
2304 `AllowHostIPC:` + fmt.Sprintf("%v", this.AllowHostIPC) + `,`,
2305 `SELinuxContext:` + strings.Replace(strings.Replace(this.SELinuxContext.String(), "SELinuxContextStrategyOptions", "SELinuxContextStrategyOptions", 1), `&`, ``, 1) + `,`,
2306 `RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`,
2307 `SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`,
2308 `FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`,
2309 `ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`,
2310 `Users:` + fmt.Sprintf("%v", this.Users) + `,`,
2311 `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
2312 `SeccompProfiles:` + fmt.Sprintf("%v", this.SeccompProfiles) + `,`,
2313 `AllowedFlexVolumes:` + repeatedStringForAllowedFlexVolumes + `,`,
2314 `DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`,
2315 `AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`,
2316 `AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`,
2317 `ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`,
2318 `}`,
2319 }, "")
2320 return s
2321 }
2322 func (this *SecurityContextConstraintsList) String() string {
2323 if this == nil {
2324 return "nil"
2325 }
2326 repeatedStringForItems := "[]SecurityContextConstraints{"
2327 for _, f := range this.Items {
2328 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "SecurityContextConstraints", "SecurityContextConstraints", 1), `&`, ``, 1) + ","
2329 }
2330 repeatedStringForItems += "}"
2331 s := strings.Join([]string{`&SecurityContextConstraintsList{`,
2332 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
2333 `Items:` + repeatedStringForItems + `,`,
2334 `}`,
2335 }, "")
2336 return s
2337 }
2338 func (this *ServiceAccountPodSecurityPolicyReviewStatus) String() string {
2339 if this == nil {
2340 return "nil"
2341 }
2342 s := strings.Join([]string{`&ServiceAccountPodSecurityPolicyReviewStatus{`,
2343 `PodSecurityPolicySubjectReviewStatus:` + strings.Replace(strings.Replace(this.PodSecurityPolicySubjectReviewStatus.String(), "PodSecurityPolicySubjectReviewStatus", "PodSecurityPolicySubjectReviewStatus", 1), `&`, ``, 1) + `,`,
2344 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2345 `}`,
2346 }, "")
2347 return s
2348 }
2349 func (this *SupplementalGroupsStrategyOptions) String() string {
2350 if this == nil {
2351 return "nil"
2352 }
2353 repeatedStringForRanges := "[]IDRange{"
2354 for _, f := range this.Ranges {
2355 repeatedStringForRanges += strings.Replace(strings.Replace(f.String(), "IDRange", "IDRange", 1), `&`, ``, 1) + ","
2356 }
2357 repeatedStringForRanges += "}"
2358 s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`,
2359 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2360 `Ranges:` + repeatedStringForRanges + `,`,
2361 `}`,
2362 }, "")
2363 return s
2364 }
2365 func valueToStringGenerated(v interface{}) string {
2366 rv := reflect.ValueOf(v)
2367 if rv.IsNil() {
2368 return "nil"
2369 }
2370 pv := reflect.Indirect(rv).Interface()
2371 return fmt.Sprintf("*%v", pv)
2372 }
2373 func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error {
2374 l := len(dAtA)
2375 iNdEx := 0
2376 for iNdEx < l {
2377 preIndex := iNdEx
2378 var wire uint64
2379 for shift := uint(0); ; shift += 7 {
2380 if shift >= 64 {
2381 return ErrIntOverflowGenerated
2382 }
2383 if iNdEx >= l {
2384 return io.ErrUnexpectedEOF
2385 }
2386 b := dAtA[iNdEx]
2387 iNdEx++
2388 wire |= uint64(b&0x7F) << shift
2389 if b < 0x80 {
2390 break
2391 }
2392 }
2393 fieldNum := int32(wire >> 3)
2394 wireType := int(wire & 0x7)
2395 if wireType == 4 {
2396 return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group")
2397 }
2398 if fieldNum <= 0 {
2399 return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire)
2400 }
2401 switch fieldNum {
2402 case 1:
2403 if wireType != 2 {
2404 return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
2405 }
2406 var stringLen uint64
2407 for shift := uint(0); ; shift += 7 {
2408 if shift >= 64 {
2409 return ErrIntOverflowGenerated
2410 }
2411 if iNdEx >= l {
2412 return io.ErrUnexpectedEOF
2413 }
2414 b := dAtA[iNdEx]
2415 iNdEx++
2416 stringLen |= uint64(b&0x7F) << shift
2417 if b < 0x80 {
2418 break
2419 }
2420 }
2421 intStringLen := int(stringLen)
2422 if intStringLen < 0 {
2423 return ErrInvalidLengthGenerated
2424 }
2425 postIndex := iNdEx + intStringLen
2426 if postIndex < 0 {
2427 return ErrInvalidLengthGenerated
2428 }
2429 if postIndex > l {
2430 return io.ErrUnexpectedEOF
2431 }
2432 m.Driver = string(dAtA[iNdEx:postIndex])
2433 iNdEx = postIndex
2434 default:
2435 iNdEx = preIndex
2436 skippy, err := skipGenerated(dAtA[iNdEx:])
2437 if err != nil {
2438 return err
2439 }
2440 if (skippy < 0) || (iNdEx+skippy) < 0 {
2441 return ErrInvalidLengthGenerated
2442 }
2443 if (iNdEx + skippy) > l {
2444 return io.ErrUnexpectedEOF
2445 }
2446 iNdEx += skippy
2447 }
2448 }
2449
2450 if iNdEx > l {
2451 return io.ErrUnexpectedEOF
2452 }
2453 return nil
2454 }
2455 func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error {
2456 l := len(dAtA)
2457 iNdEx := 0
2458 for iNdEx < l {
2459 preIndex := iNdEx
2460 var wire uint64
2461 for shift := uint(0); ; shift += 7 {
2462 if shift >= 64 {
2463 return ErrIntOverflowGenerated
2464 }
2465 if iNdEx >= l {
2466 return io.ErrUnexpectedEOF
2467 }
2468 b := dAtA[iNdEx]
2469 iNdEx++
2470 wire |= uint64(b&0x7F) << shift
2471 if b < 0x80 {
2472 break
2473 }
2474 }
2475 fieldNum := int32(wire >> 3)
2476 wireType := int(wire & 0x7)
2477 if wireType == 4 {
2478 return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group")
2479 }
2480 if fieldNum <= 0 {
2481 return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
2482 }
2483 switch fieldNum {
2484 case 1:
2485 if wireType != 2 {
2486 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2487 }
2488 var stringLen uint64
2489 for shift := uint(0); ; shift += 7 {
2490 if shift >= 64 {
2491 return ErrIntOverflowGenerated
2492 }
2493 if iNdEx >= l {
2494 return io.ErrUnexpectedEOF
2495 }
2496 b := dAtA[iNdEx]
2497 iNdEx++
2498 stringLen |= uint64(b&0x7F) << shift
2499 if b < 0x80 {
2500 break
2501 }
2502 }
2503 intStringLen := int(stringLen)
2504 if intStringLen < 0 {
2505 return ErrInvalidLengthGenerated
2506 }
2507 postIndex := iNdEx + intStringLen
2508 if postIndex < 0 {
2509 return ErrInvalidLengthGenerated
2510 }
2511 if postIndex > l {
2512 return io.ErrUnexpectedEOF
2513 }
2514 m.Type = FSGroupStrategyType(dAtA[iNdEx:postIndex])
2515 iNdEx = postIndex
2516 case 2:
2517 if wireType != 2 {
2518 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
2519 }
2520 var msglen int
2521 for shift := uint(0); ; shift += 7 {
2522 if shift >= 64 {
2523 return ErrIntOverflowGenerated
2524 }
2525 if iNdEx >= l {
2526 return io.ErrUnexpectedEOF
2527 }
2528 b := dAtA[iNdEx]
2529 iNdEx++
2530 msglen |= int(b&0x7F) << shift
2531 if b < 0x80 {
2532 break
2533 }
2534 }
2535 if msglen < 0 {
2536 return ErrInvalidLengthGenerated
2537 }
2538 postIndex := iNdEx + msglen
2539 if postIndex < 0 {
2540 return ErrInvalidLengthGenerated
2541 }
2542 if postIndex > l {
2543 return io.ErrUnexpectedEOF
2544 }
2545 m.Ranges = append(m.Ranges, IDRange{})
2546 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2547 return err
2548 }
2549 iNdEx = postIndex
2550 default:
2551 iNdEx = preIndex
2552 skippy, err := skipGenerated(dAtA[iNdEx:])
2553 if err != nil {
2554 return err
2555 }
2556 if (skippy < 0) || (iNdEx+skippy) < 0 {
2557 return ErrInvalidLengthGenerated
2558 }
2559 if (iNdEx + skippy) > l {
2560 return io.ErrUnexpectedEOF
2561 }
2562 iNdEx += skippy
2563 }
2564 }
2565
2566 if iNdEx > l {
2567 return io.ErrUnexpectedEOF
2568 }
2569 return nil
2570 }
2571 func (m *IDRange) Unmarshal(dAtA []byte) error {
2572 l := len(dAtA)
2573 iNdEx := 0
2574 for iNdEx < l {
2575 preIndex := iNdEx
2576 var wire uint64
2577 for shift := uint(0); ; shift += 7 {
2578 if shift >= 64 {
2579 return ErrIntOverflowGenerated
2580 }
2581 if iNdEx >= l {
2582 return io.ErrUnexpectedEOF
2583 }
2584 b := dAtA[iNdEx]
2585 iNdEx++
2586 wire |= uint64(b&0x7F) << shift
2587 if b < 0x80 {
2588 break
2589 }
2590 }
2591 fieldNum := int32(wire >> 3)
2592 wireType := int(wire & 0x7)
2593 if wireType == 4 {
2594 return fmt.Errorf("proto: IDRange: wiretype end group for non-group")
2595 }
2596 if fieldNum <= 0 {
2597 return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire)
2598 }
2599 switch fieldNum {
2600 case 1:
2601 if wireType != 0 {
2602 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
2603 }
2604 m.Min = 0
2605 for shift := uint(0); ; shift += 7 {
2606 if shift >= 64 {
2607 return ErrIntOverflowGenerated
2608 }
2609 if iNdEx >= l {
2610 return io.ErrUnexpectedEOF
2611 }
2612 b := dAtA[iNdEx]
2613 iNdEx++
2614 m.Min |= int64(b&0x7F) << shift
2615 if b < 0x80 {
2616 break
2617 }
2618 }
2619 case 2:
2620 if wireType != 0 {
2621 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
2622 }
2623 m.Max = 0
2624 for shift := uint(0); ; shift += 7 {
2625 if shift >= 64 {
2626 return ErrIntOverflowGenerated
2627 }
2628 if iNdEx >= l {
2629 return io.ErrUnexpectedEOF
2630 }
2631 b := dAtA[iNdEx]
2632 iNdEx++
2633 m.Max |= int64(b&0x7F) << shift
2634 if b < 0x80 {
2635 break
2636 }
2637 }
2638 default:
2639 iNdEx = preIndex
2640 skippy, err := skipGenerated(dAtA[iNdEx:])
2641 if err != nil {
2642 return err
2643 }
2644 if (skippy < 0) || (iNdEx+skippy) < 0 {
2645 return ErrInvalidLengthGenerated
2646 }
2647 if (iNdEx + skippy) > l {
2648 return io.ErrUnexpectedEOF
2649 }
2650 iNdEx += skippy
2651 }
2652 }
2653
2654 if iNdEx > l {
2655 return io.ErrUnexpectedEOF
2656 }
2657 return nil
2658 }
2659 func (m *PodSecurityPolicyReview) Unmarshal(dAtA []byte) error {
2660 l := len(dAtA)
2661 iNdEx := 0
2662 for iNdEx < l {
2663 preIndex := iNdEx
2664 var wire uint64
2665 for shift := uint(0); ; shift += 7 {
2666 if shift >= 64 {
2667 return ErrIntOverflowGenerated
2668 }
2669 if iNdEx >= l {
2670 return io.ErrUnexpectedEOF
2671 }
2672 b := dAtA[iNdEx]
2673 iNdEx++
2674 wire |= uint64(b&0x7F) << shift
2675 if b < 0x80 {
2676 break
2677 }
2678 }
2679 fieldNum := int32(wire >> 3)
2680 wireType := int(wire & 0x7)
2681 if wireType == 4 {
2682 return fmt.Errorf("proto: PodSecurityPolicyReview: wiretype end group for non-group")
2683 }
2684 if fieldNum <= 0 {
2685 return fmt.Errorf("proto: PodSecurityPolicyReview: illegal tag %d (wire type %d)", fieldNum, wire)
2686 }
2687 switch fieldNum {
2688 case 1:
2689 if wireType != 2 {
2690 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2691 }
2692 var msglen int
2693 for shift := uint(0); ; shift += 7 {
2694 if shift >= 64 {
2695 return ErrIntOverflowGenerated
2696 }
2697 if iNdEx >= l {
2698 return io.ErrUnexpectedEOF
2699 }
2700 b := dAtA[iNdEx]
2701 iNdEx++
2702 msglen |= int(b&0x7F) << shift
2703 if b < 0x80 {
2704 break
2705 }
2706 }
2707 if msglen < 0 {
2708 return ErrInvalidLengthGenerated
2709 }
2710 postIndex := iNdEx + msglen
2711 if postIndex < 0 {
2712 return ErrInvalidLengthGenerated
2713 }
2714 if postIndex > l {
2715 return io.ErrUnexpectedEOF
2716 }
2717 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2718 return err
2719 }
2720 iNdEx = postIndex
2721 case 2:
2722 if wireType != 2 {
2723 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2724 }
2725 var msglen int
2726 for shift := uint(0); ; shift += 7 {
2727 if shift >= 64 {
2728 return ErrIntOverflowGenerated
2729 }
2730 if iNdEx >= l {
2731 return io.ErrUnexpectedEOF
2732 }
2733 b := dAtA[iNdEx]
2734 iNdEx++
2735 msglen |= int(b&0x7F) << shift
2736 if b < 0x80 {
2737 break
2738 }
2739 }
2740 if msglen < 0 {
2741 return ErrInvalidLengthGenerated
2742 }
2743 postIndex := iNdEx + msglen
2744 if postIndex < 0 {
2745 return ErrInvalidLengthGenerated
2746 }
2747 if postIndex > l {
2748 return io.ErrUnexpectedEOF
2749 }
2750 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2751 return err
2752 }
2753 iNdEx = postIndex
2754 default:
2755 iNdEx = preIndex
2756 skippy, err := skipGenerated(dAtA[iNdEx:])
2757 if err != nil {
2758 return err
2759 }
2760 if (skippy < 0) || (iNdEx+skippy) < 0 {
2761 return ErrInvalidLengthGenerated
2762 }
2763 if (iNdEx + skippy) > l {
2764 return io.ErrUnexpectedEOF
2765 }
2766 iNdEx += skippy
2767 }
2768 }
2769
2770 if iNdEx > l {
2771 return io.ErrUnexpectedEOF
2772 }
2773 return nil
2774 }
2775 func (m *PodSecurityPolicyReviewSpec) Unmarshal(dAtA []byte) error {
2776 l := len(dAtA)
2777 iNdEx := 0
2778 for iNdEx < l {
2779 preIndex := iNdEx
2780 var wire uint64
2781 for shift := uint(0); ; shift += 7 {
2782 if shift >= 64 {
2783 return ErrIntOverflowGenerated
2784 }
2785 if iNdEx >= l {
2786 return io.ErrUnexpectedEOF
2787 }
2788 b := dAtA[iNdEx]
2789 iNdEx++
2790 wire |= uint64(b&0x7F) << shift
2791 if b < 0x80 {
2792 break
2793 }
2794 }
2795 fieldNum := int32(wire >> 3)
2796 wireType := int(wire & 0x7)
2797 if wireType == 4 {
2798 return fmt.Errorf("proto: PodSecurityPolicyReviewSpec: wiretype end group for non-group")
2799 }
2800 if fieldNum <= 0 {
2801 return fmt.Errorf("proto: PodSecurityPolicyReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2802 }
2803 switch fieldNum {
2804 case 1:
2805 if wireType != 2 {
2806 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
2807 }
2808 var msglen int
2809 for shift := uint(0); ; shift += 7 {
2810 if shift >= 64 {
2811 return ErrIntOverflowGenerated
2812 }
2813 if iNdEx >= l {
2814 return io.ErrUnexpectedEOF
2815 }
2816 b := dAtA[iNdEx]
2817 iNdEx++
2818 msglen |= int(b&0x7F) << shift
2819 if b < 0x80 {
2820 break
2821 }
2822 }
2823 if msglen < 0 {
2824 return ErrInvalidLengthGenerated
2825 }
2826 postIndex := iNdEx + msglen
2827 if postIndex < 0 {
2828 return ErrInvalidLengthGenerated
2829 }
2830 if postIndex > l {
2831 return io.ErrUnexpectedEOF
2832 }
2833 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2834 return err
2835 }
2836 iNdEx = postIndex
2837 case 2:
2838 if wireType != 2 {
2839 return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccountNames", wireType)
2840 }
2841 var stringLen uint64
2842 for shift := uint(0); ; shift += 7 {
2843 if shift >= 64 {
2844 return ErrIntOverflowGenerated
2845 }
2846 if iNdEx >= l {
2847 return io.ErrUnexpectedEOF
2848 }
2849 b := dAtA[iNdEx]
2850 iNdEx++
2851 stringLen |= uint64(b&0x7F) << shift
2852 if b < 0x80 {
2853 break
2854 }
2855 }
2856 intStringLen := int(stringLen)
2857 if intStringLen < 0 {
2858 return ErrInvalidLengthGenerated
2859 }
2860 postIndex := iNdEx + intStringLen
2861 if postIndex < 0 {
2862 return ErrInvalidLengthGenerated
2863 }
2864 if postIndex > l {
2865 return io.ErrUnexpectedEOF
2866 }
2867 m.ServiceAccountNames = append(m.ServiceAccountNames, string(dAtA[iNdEx:postIndex]))
2868 iNdEx = postIndex
2869 default:
2870 iNdEx = preIndex
2871 skippy, err := skipGenerated(dAtA[iNdEx:])
2872 if err != nil {
2873 return err
2874 }
2875 if (skippy < 0) || (iNdEx+skippy) < 0 {
2876 return ErrInvalidLengthGenerated
2877 }
2878 if (iNdEx + skippy) > l {
2879 return io.ErrUnexpectedEOF
2880 }
2881 iNdEx += skippy
2882 }
2883 }
2884
2885 if iNdEx > l {
2886 return io.ErrUnexpectedEOF
2887 }
2888 return nil
2889 }
2890 func (m *PodSecurityPolicyReviewStatus) Unmarshal(dAtA []byte) error {
2891 l := len(dAtA)
2892 iNdEx := 0
2893 for iNdEx < l {
2894 preIndex := iNdEx
2895 var wire uint64
2896 for shift := uint(0); ; shift += 7 {
2897 if shift >= 64 {
2898 return ErrIntOverflowGenerated
2899 }
2900 if iNdEx >= l {
2901 return io.ErrUnexpectedEOF
2902 }
2903 b := dAtA[iNdEx]
2904 iNdEx++
2905 wire |= uint64(b&0x7F) << shift
2906 if b < 0x80 {
2907 break
2908 }
2909 }
2910 fieldNum := int32(wire >> 3)
2911 wireType := int(wire & 0x7)
2912 if wireType == 4 {
2913 return fmt.Errorf("proto: PodSecurityPolicyReviewStatus: wiretype end group for non-group")
2914 }
2915 if fieldNum <= 0 {
2916 return fmt.Errorf("proto: PodSecurityPolicyReviewStatus: illegal tag %d (wire type %d)", fieldNum, wire)
2917 }
2918 switch fieldNum {
2919 case 1:
2920 if wireType != 2 {
2921 return fmt.Errorf("proto: wrong wireType = %d for field AllowedServiceAccounts", wireType)
2922 }
2923 var msglen int
2924 for shift := uint(0); ; shift += 7 {
2925 if shift >= 64 {
2926 return ErrIntOverflowGenerated
2927 }
2928 if iNdEx >= l {
2929 return io.ErrUnexpectedEOF
2930 }
2931 b := dAtA[iNdEx]
2932 iNdEx++
2933 msglen |= int(b&0x7F) << shift
2934 if b < 0x80 {
2935 break
2936 }
2937 }
2938 if msglen < 0 {
2939 return ErrInvalidLengthGenerated
2940 }
2941 postIndex := iNdEx + msglen
2942 if postIndex < 0 {
2943 return ErrInvalidLengthGenerated
2944 }
2945 if postIndex > l {
2946 return io.ErrUnexpectedEOF
2947 }
2948 m.AllowedServiceAccounts = append(m.AllowedServiceAccounts, ServiceAccountPodSecurityPolicyReviewStatus{})
2949 if err := m.AllowedServiceAccounts[len(m.AllowedServiceAccounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2950 return err
2951 }
2952 iNdEx = postIndex
2953 default:
2954 iNdEx = preIndex
2955 skippy, err := skipGenerated(dAtA[iNdEx:])
2956 if err != nil {
2957 return err
2958 }
2959 if (skippy < 0) || (iNdEx+skippy) < 0 {
2960 return ErrInvalidLengthGenerated
2961 }
2962 if (iNdEx + skippy) > l {
2963 return io.ErrUnexpectedEOF
2964 }
2965 iNdEx += skippy
2966 }
2967 }
2968
2969 if iNdEx > l {
2970 return io.ErrUnexpectedEOF
2971 }
2972 return nil
2973 }
2974 func (m *PodSecurityPolicySelfSubjectReview) Unmarshal(dAtA []byte) error {
2975 l := len(dAtA)
2976 iNdEx := 0
2977 for iNdEx < l {
2978 preIndex := iNdEx
2979 var wire uint64
2980 for shift := uint(0); ; shift += 7 {
2981 if shift >= 64 {
2982 return ErrIntOverflowGenerated
2983 }
2984 if iNdEx >= l {
2985 return io.ErrUnexpectedEOF
2986 }
2987 b := dAtA[iNdEx]
2988 iNdEx++
2989 wire |= uint64(b&0x7F) << shift
2990 if b < 0x80 {
2991 break
2992 }
2993 }
2994 fieldNum := int32(wire >> 3)
2995 wireType := int(wire & 0x7)
2996 if wireType == 4 {
2997 return fmt.Errorf("proto: PodSecurityPolicySelfSubjectReview: wiretype end group for non-group")
2998 }
2999 if fieldNum <= 0 {
3000 return fmt.Errorf("proto: PodSecurityPolicySelfSubjectReview: illegal tag %d (wire type %d)", fieldNum, wire)
3001 }
3002 switch fieldNum {
3003 case 1:
3004 if wireType != 2 {
3005 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3006 }
3007 var msglen int
3008 for shift := uint(0); ; shift += 7 {
3009 if shift >= 64 {
3010 return ErrIntOverflowGenerated
3011 }
3012 if iNdEx >= l {
3013 return io.ErrUnexpectedEOF
3014 }
3015 b := dAtA[iNdEx]
3016 iNdEx++
3017 msglen |= int(b&0x7F) << shift
3018 if b < 0x80 {
3019 break
3020 }
3021 }
3022 if msglen < 0 {
3023 return ErrInvalidLengthGenerated
3024 }
3025 postIndex := iNdEx + msglen
3026 if postIndex < 0 {
3027 return ErrInvalidLengthGenerated
3028 }
3029 if postIndex > l {
3030 return io.ErrUnexpectedEOF
3031 }
3032 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3033 return err
3034 }
3035 iNdEx = postIndex
3036 case 2:
3037 if wireType != 2 {
3038 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3039 }
3040 var msglen int
3041 for shift := uint(0); ; shift += 7 {
3042 if shift >= 64 {
3043 return ErrIntOverflowGenerated
3044 }
3045 if iNdEx >= l {
3046 return io.ErrUnexpectedEOF
3047 }
3048 b := dAtA[iNdEx]
3049 iNdEx++
3050 msglen |= int(b&0x7F) << shift
3051 if b < 0x80 {
3052 break
3053 }
3054 }
3055 if msglen < 0 {
3056 return ErrInvalidLengthGenerated
3057 }
3058 postIndex := iNdEx + msglen
3059 if postIndex < 0 {
3060 return ErrInvalidLengthGenerated
3061 }
3062 if postIndex > l {
3063 return io.ErrUnexpectedEOF
3064 }
3065 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3066 return err
3067 }
3068 iNdEx = postIndex
3069 default:
3070 iNdEx = preIndex
3071 skippy, err := skipGenerated(dAtA[iNdEx:])
3072 if err != nil {
3073 return err
3074 }
3075 if (skippy < 0) || (iNdEx+skippy) < 0 {
3076 return ErrInvalidLengthGenerated
3077 }
3078 if (iNdEx + skippy) > l {
3079 return io.ErrUnexpectedEOF
3080 }
3081 iNdEx += skippy
3082 }
3083 }
3084
3085 if iNdEx > l {
3086 return io.ErrUnexpectedEOF
3087 }
3088 return nil
3089 }
3090 func (m *PodSecurityPolicySelfSubjectReviewSpec) Unmarshal(dAtA []byte) error {
3091 l := len(dAtA)
3092 iNdEx := 0
3093 for iNdEx < l {
3094 preIndex := iNdEx
3095 var wire uint64
3096 for shift := uint(0); ; shift += 7 {
3097 if shift >= 64 {
3098 return ErrIntOverflowGenerated
3099 }
3100 if iNdEx >= l {
3101 return io.ErrUnexpectedEOF
3102 }
3103 b := dAtA[iNdEx]
3104 iNdEx++
3105 wire |= uint64(b&0x7F) << shift
3106 if b < 0x80 {
3107 break
3108 }
3109 }
3110 fieldNum := int32(wire >> 3)
3111 wireType := int(wire & 0x7)
3112 if wireType == 4 {
3113 return fmt.Errorf("proto: PodSecurityPolicySelfSubjectReviewSpec: wiretype end group for non-group")
3114 }
3115 if fieldNum <= 0 {
3116 return fmt.Errorf("proto: PodSecurityPolicySelfSubjectReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3117 }
3118 switch fieldNum {
3119 case 1:
3120 if wireType != 2 {
3121 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
3122 }
3123 var msglen int
3124 for shift := uint(0); ; shift += 7 {
3125 if shift >= 64 {
3126 return ErrIntOverflowGenerated
3127 }
3128 if iNdEx >= l {
3129 return io.ErrUnexpectedEOF
3130 }
3131 b := dAtA[iNdEx]
3132 iNdEx++
3133 msglen |= int(b&0x7F) << shift
3134 if b < 0x80 {
3135 break
3136 }
3137 }
3138 if msglen < 0 {
3139 return ErrInvalidLengthGenerated
3140 }
3141 postIndex := iNdEx + msglen
3142 if postIndex < 0 {
3143 return ErrInvalidLengthGenerated
3144 }
3145 if postIndex > l {
3146 return io.ErrUnexpectedEOF
3147 }
3148 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3149 return err
3150 }
3151 iNdEx = postIndex
3152 default:
3153 iNdEx = preIndex
3154 skippy, err := skipGenerated(dAtA[iNdEx:])
3155 if err != nil {
3156 return err
3157 }
3158 if (skippy < 0) || (iNdEx+skippy) < 0 {
3159 return ErrInvalidLengthGenerated
3160 }
3161 if (iNdEx + skippy) > l {
3162 return io.ErrUnexpectedEOF
3163 }
3164 iNdEx += skippy
3165 }
3166 }
3167
3168 if iNdEx > l {
3169 return io.ErrUnexpectedEOF
3170 }
3171 return nil
3172 }
3173 func (m *PodSecurityPolicySubjectReview) Unmarshal(dAtA []byte) error {
3174 l := len(dAtA)
3175 iNdEx := 0
3176 for iNdEx < l {
3177 preIndex := iNdEx
3178 var wire uint64
3179 for shift := uint(0); ; shift += 7 {
3180 if shift >= 64 {
3181 return ErrIntOverflowGenerated
3182 }
3183 if iNdEx >= l {
3184 return io.ErrUnexpectedEOF
3185 }
3186 b := dAtA[iNdEx]
3187 iNdEx++
3188 wire |= uint64(b&0x7F) << shift
3189 if b < 0x80 {
3190 break
3191 }
3192 }
3193 fieldNum := int32(wire >> 3)
3194 wireType := int(wire & 0x7)
3195 if wireType == 4 {
3196 return fmt.Errorf("proto: PodSecurityPolicySubjectReview: wiretype end group for non-group")
3197 }
3198 if fieldNum <= 0 {
3199 return fmt.Errorf("proto: PodSecurityPolicySubjectReview: illegal tag %d (wire type %d)", fieldNum, wire)
3200 }
3201 switch fieldNum {
3202 case 1:
3203 if wireType != 2 {
3204 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3205 }
3206 var msglen int
3207 for shift := uint(0); ; shift += 7 {
3208 if shift >= 64 {
3209 return ErrIntOverflowGenerated
3210 }
3211 if iNdEx >= l {
3212 return io.ErrUnexpectedEOF
3213 }
3214 b := dAtA[iNdEx]
3215 iNdEx++
3216 msglen |= int(b&0x7F) << shift
3217 if b < 0x80 {
3218 break
3219 }
3220 }
3221 if msglen < 0 {
3222 return ErrInvalidLengthGenerated
3223 }
3224 postIndex := iNdEx + msglen
3225 if postIndex < 0 {
3226 return ErrInvalidLengthGenerated
3227 }
3228 if postIndex > l {
3229 return io.ErrUnexpectedEOF
3230 }
3231 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3232 return err
3233 }
3234 iNdEx = postIndex
3235 case 2:
3236 if wireType != 2 {
3237 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3238 }
3239 var msglen int
3240 for shift := uint(0); ; shift += 7 {
3241 if shift >= 64 {
3242 return ErrIntOverflowGenerated
3243 }
3244 if iNdEx >= l {
3245 return io.ErrUnexpectedEOF
3246 }
3247 b := dAtA[iNdEx]
3248 iNdEx++
3249 msglen |= int(b&0x7F) << shift
3250 if b < 0x80 {
3251 break
3252 }
3253 }
3254 if msglen < 0 {
3255 return ErrInvalidLengthGenerated
3256 }
3257 postIndex := iNdEx + msglen
3258 if postIndex < 0 {
3259 return ErrInvalidLengthGenerated
3260 }
3261 if postIndex > l {
3262 return io.ErrUnexpectedEOF
3263 }
3264 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3265 return err
3266 }
3267 iNdEx = postIndex
3268 default:
3269 iNdEx = preIndex
3270 skippy, err := skipGenerated(dAtA[iNdEx:])
3271 if err != nil {
3272 return err
3273 }
3274 if (skippy < 0) || (iNdEx+skippy) < 0 {
3275 return ErrInvalidLengthGenerated
3276 }
3277 if (iNdEx + skippy) > l {
3278 return io.ErrUnexpectedEOF
3279 }
3280 iNdEx += skippy
3281 }
3282 }
3283
3284 if iNdEx > l {
3285 return io.ErrUnexpectedEOF
3286 }
3287 return nil
3288 }
3289 func (m *PodSecurityPolicySubjectReviewSpec) Unmarshal(dAtA []byte) error {
3290 l := len(dAtA)
3291 iNdEx := 0
3292 for iNdEx < l {
3293 preIndex := iNdEx
3294 var wire uint64
3295 for shift := uint(0); ; shift += 7 {
3296 if shift >= 64 {
3297 return ErrIntOverflowGenerated
3298 }
3299 if iNdEx >= l {
3300 return io.ErrUnexpectedEOF
3301 }
3302 b := dAtA[iNdEx]
3303 iNdEx++
3304 wire |= uint64(b&0x7F) << shift
3305 if b < 0x80 {
3306 break
3307 }
3308 }
3309 fieldNum := int32(wire >> 3)
3310 wireType := int(wire & 0x7)
3311 if wireType == 4 {
3312 return fmt.Errorf("proto: PodSecurityPolicySubjectReviewSpec: wiretype end group for non-group")
3313 }
3314 if fieldNum <= 0 {
3315 return fmt.Errorf("proto: PodSecurityPolicySubjectReviewSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3316 }
3317 switch fieldNum {
3318 case 1:
3319 if wireType != 2 {
3320 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
3321 }
3322 var msglen int
3323 for shift := uint(0); ; shift += 7 {
3324 if shift >= 64 {
3325 return ErrIntOverflowGenerated
3326 }
3327 if iNdEx >= l {
3328 return io.ErrUnexpectedEOF
3329 }
3330 b := dAtA[iNdEx]
3331 iNdEx++
3332 msglen |= int(b&0x7F) << shift
3333 if b < 0x80 {
3334 break
3335 }
3336 }
3337 if msglen < 0 {
3338 return ErrInvalidLengthGenerated
3339 }
3340 postIndex := iNdEx + msglen
3341 if postIndex < 0 {
3342 return ErrInvalidLengthGenerated
3343 }
3344 if postIndex > l {
3345 return io.ErrUnexpectedEOF
3346 }
3347 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3348 return err
3349 }
3350 iNdEx = postIndex
3351 case 2:
3352 if wireType != 2 {
3353 return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
3354 }
3355 var stringLen uint64
3356 for shift := uint(0); ; shift += 7 {
3357 if shift >= 64 {
3358 return ErrIntOverflowGenerated
3359 }
3360 if iNdEx >= l {
3361 return io.ErrUnexpectedEOF
3362 }
3363 b := dAtA[iNdEx]
3364 iNdEx++
3365 stringLen |= uint64(b&0x7F) << shift
3366 if b < 0x80 {
3367 break
3368 }
3369 }
3370 intStringLen := int(stringLen)
3371 if intStringLen < 0 {
3372 return ErrInvalidLengthGenerated
3373 }
3374 postIndex := iNdEx + intStringLen
3375 if postIndex < 0 {
3376 return ErrInvalidLengthGenerated
3377 }
3378 if postIndex > l {
3379 return io.ErrUnexpectedEOF
3380 }
3381 m.User = string(dAtA[iNdEx:postIndex])
3382 iNdEx = postIndex
3383 case 3:
3384 if wireType != 2 {
3385 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
3386 }
3387 var stringLen uint64
3388 for shift := uint(0); ; shift += 7 {
3389 if shift >= 64 {
3390 return ErrIntOverflowGenerated
3391 }
3392 if iNdEx >= l {
3393 return io.ErrUnexpectedEOF
3394 }
3395 b := dAtA[iNdEx]
3396 iNdEx++
3397 stringLen |= uint64(b&0x7F) << shift
3398 if b < 0x80 {
3399 break
3400 }
3401 }
3402 intStringLen := int(stringLen)
3403 if intStringLen < 0 {
3404 return ErrInvalidLengthGenerated
3405 }
3406 postIndex := iNdEx + intStringLen
3407 if postIndex < 0 {
3408 return ErrInvalidLengthGenerated
3409 }
3410 if postIndex > l {
3411 return io.ErrUnexpectedEOF
3412 }
3413 m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
3414 iNdEx = postIndex
3415 default:
3416 iNdEx = preIndex
3417 skippy, err := skipGenerated(dAtA[iNdEx:])
3418 if err != nil {
3419 return err
3420 }
3421 if (skippy < 0) || (iNdEx+skippy) < 0 {
3422 return ErrInvalidLengthGenerated
3423 }
3424 if (iNdEx + skippy) > l {
3425 return io.ErrUnexpectedEOF
3426 }
3427 iNdEx += skippy
3428 }
3429 }
3430
3431 if iNdEx > l {
3432 return io.ErrUnexpectedEOF
3433 }
3434 return nil
3435 }
3436 func (m *PodSecurityPolicySubjectReviewStatus) Unmarshal(dAtA []byte) error {
3437 l := len(dAtA)
3438 iNdEx := 0
3439 for iNdEx < l {
3440 preIndex := iNdEx
3441 var wire uint64
3442 for shift := uint(0); ; shift += 7 {
3443 if shift >= 64 {
3444 return ErrIntOverflowGenerated
3445 }
3446 if iNdEx >= l {
3447 return io.ErrUnexpectedEOF
3448 }
3449 b := dAtA[iNdEx]
3450 iNdEx++
3451 wire |= uint64(b&0x7F) << shift
3452 if b < 0x80 {
3453 break
3454 }
3455 }
3456 fieldNum := int32(wire >> 3)
3457 wireType := int(wire & 0x7)
3458 if wireType == 4 {
3459 return fmt.Errorf("proto: PodSecurityPolicySubjectReviewStatus: wiretype end group for non-group")
3460 }
3461 if fieldNum <= 0 {
3462 return fmt.Errorf("proto: PodSecurityPolicySubjectReviewStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3463 }
3464 switch fieldNum {
3465 case 1:
3466 if wireType != 2 {
3467 return fmt.Errorf("proto: wrong wireType = %d for field AllowedBy", wireType)
3468 }
3469 var msglen int
3470 for shift := uint(0); ; shift += 7 {
3471 if shift >= 64 {
3472 return ErrIntOverflowGenerated
3473 }
3474 if iNdEx >= l {
3475 return io.ErrUnexpectedEOF
3476 }
3477 b := dAtA[iNdEx]
3478 iNdEx++
3479 msglen |= int(b&0x7F) << shift
3480 if b < 0x80 {
3481 break
3482 }
3483 }
3484 if msglen < 0 {
3485 return ErrInvalidLengthGenerated
3486 }
3487 postIndex := iNdEx + msglen
3488 if postIndex < 0 {
3489 return ErrInvalidLengthGenerated
3490 }
3491 if postIndex > l {
3492 return io.ErrUnexpectedEOF
3493 }
3494 if m.AllowedBy == nil {
3495 m.AllowedBy = &v1.ObjectReference{}
3496 }
3497 if err := m.AllowedBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3498 return err
3499 }
3500 iNdEx = postIndex
3501 case 2:
3502 if wireType != 2 {
3503 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
3504 }
3505 var stringLen uint64
3506 for shift := uint(0); ; shift += 7 {
3507 if shift >= 64 {
3508 return ErrIntOverflowGenerated
3509 }
3510 if iNdEx >= l {
3511 return io.ErrUnexpectedEOF
3512 }
3513 b := dAtA[iNdEx]
3514 iNdEx++
3515 stringLen |= uint64(b&0x7F) << shift
3516 if b < 0x80 {
3517 break
3518 }
3519 }
3520 intStringLen := int(stringLen)
3521 if intStringLen < 0 {
3522 return ErrInvalidLengthGenerated
3523 }
3524 postIndex := iNdEx + intStringLen
3525 if postIndex < 0 {
3526 return ErrInvalidLengthGenerated
3527 }
3528 if postIndex > l {
3529 return io.ErrUnexpectedEOF
3530 }
3531 m.Reason = string(dAtA[iNdEx:postIndex])
3532 iNdEx = postIndex
3533 case 3:
3534 if wireType != 2 {
3535 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
3536 }
3537 var msglen int
3538 for shift := uint(0); ; shift += 7 {
3539 if shift >= 64 {
3540 return ErrIntOverflowGenerated
3541 }
3542 if iNdEx >= l {
3543 return io.ErrUnexpectedEOF
3544 }
3545 b := dAtA[iNdEx]
3546 iNdEx++
3547 msglen |= int(b&0x7F) << shift
3548 if b < 0x80 {
3549 break
3550 }
3551 }
3552 if msglen < 0 {
3553 return ErrInvalidLengthGenerated
3554 }
3555 postIndex := iNdEx + msglen
3556 if postIndex < 0 {
3557 return ErrInvalidLengthGenerated
3558 }
3559 if postIndex > l {
3560 return io.ErrUnexpectedEOF
3561 }
3562 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3563 return err
3564 }
3565 iNdEx = postIndex
3566 default:
3567 iNdEx = preIndex
3568 skippy, err := skipGenerated(dAtA[iNdEx:])
3569 if err != nil {
3570 return err
3571 }
3572 if (skippy < 0) || (iNdEx+skippy) < 0 {
3573 return ErrInvalidLengthGenerated
3574 }
3575 if (iNdEx + skippy) > l {
3576 return io.ErrUnexpectedEOF
3577 }
3578 iNdEx += skippy
3579 }
3580 }
3581
3582 if iNdEx > l {
3583 return io.ErrUnexpectedEOF
3584 }
3585 return nil
3586 }
3587 func (m *RangeAllocation) Unmarshal(dAtA []byte) error {
3588 l := len(dAtA)
3589 iNdEx := 0
3590 for iNdEx < l {
3591 preIndex := iNdEx
3592 var wire uint64
3593 for shift := uint(0); ; shift += 7 {
3594 if shift >= 64 {
3595 return ErrIntOverflowGenerated
3596 }
3597 if iNdEx >= l {
3598 return io.ErrUnexpectedEOF
3599 }
3600 b := dAtA[iNdEx]
3601 iNdEx++
3602 wire |= uint64(b&0x7F) << shift
3603 if b < 0x80 {
3604 break
3605 }
3606 }
3607 fieldNum := int32(wire >> 3)
3608 wireType := int(wire & 0x7)
3609 if wireType == 4 {
3610 return fmt.Errorf("proto: RangeAllocation: wiretype end group for non-group")
3611 }
3612 if fieldNum <= 0 {
3613 return fmt.Errorf("proto: RangeAllocation: illegal tag %d (wire type %d)", fieldNum, wire)
3614 }
3615 switch fieldNum {
3616 case 1:
3617 if wireType != 2 {
3618 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3619 }
3620 var msglen int
3621 for shift := uint(0); ; shift += 7 {
3622 if shift >= 64 {
3623 return ErrIntOverflowGenerated
3624 }
3625 if iNdEx >= l {
3626 return io.ErrUnexpectedEOF
3627 }
3628 b := dAtA[iNdEx]
3629 iNdEx++
3630 msglen |= int(b&0x7F) << shift
3631 if b < 0x80 {
3632 break
3633 }
3634 }
3635 if msglen < 0 {
3636 return ErrInvalidLengthGenerated
3637 }
3638 postIndex := iNdEx + msglen
3639 if postIndex < 0 {
3640 return ErrInvalidLengthGenerated
3641 }
3642 if postIndex > l {
3643 return io.ErrUnexpectedEOF
3644 }
3645 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3646 return err
3647 }
3648 iNdEx = postIndex
3649 case 2:
3650 if wireType != 2 {
3651 return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
3652 }
3653 var stringLen uint64
3654 for shift := uint(0); ; shift += 7 {
3655 if shift >= 64 {
3656 return ErrIntOverflowGenerated
3657 }
3658 if iNdEx >= l {
3659 return io.ErrUnexpectedEOF
3660 }
3661 b := dAtA[iNdEx]
3662 iNdEx++
3663 stringLen |= uint64(b&0x7F) << shift
3664 if b < 0x80 {
3665 break
3666 }
3667 }
3668 intStringLen := int(stringLen)
3669 if intStringLen < 0 {
3670 return ErrInvalidLengthGenerated
3671 }
3672 postIndex := iNdEx + intStringLen
3673 if postIndex < 0 {
3674 return ErrInvalidLengthGenerated
3675 }
3676 if postIndex > l {
3677 return io.ErrUnexpectedEOF
3678 }
3679 m.Range = string(dAtA[iNdEx:postIndex])
3680 iNdEx = postIndex
3681 case 3:
3682 if wireType != 2 {
3683 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
3684 }
3685 var byteLen int
3686 for shift := uint(0); ; shift += 7 {
3687 if shift >= 64 {
3688 return ErrIntOverflowGenerated
3689 }
3690 if iNdEx >= l {
3691 return io.ErrUnexpectedEOF
3692 }
3693 b := dAtA[iNdEx]
3694 iNdEx++
3695 byteLen |= int(b&0x7F) << shift
3696 if b < 0x80 {
3697 break
3698 }
3699 }
3700 if byteLen < 0 {
3701 return ErrInvalidLengthGenerated
3702 }
3703 postIndex := iNdEx + byteLen
3704 if postIndex < 0 {
3705 return ErrInvalidLengthGenerated
3706 }
3707 if postIndex > l {
3708 return io.ErrUnexpectedEOF
3709 }
3710 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
3711 if m.Data == nil {
3712 m.Data = []byte{}
3713 }
3714 iNdEx = postIndex
3715 default:
3716 iNdEx = preIndex
3717 skippy, err := skipGenerated(dAtA[iNdEx:])
3718 if err != nil {
3719 return err
3720 }
3721 if (skippy < 0) || (iNdEx+skippy) < 0 {
3722 return ErrInvalidLengthGenerated
3723 }
3724 if (iNdEx + skippy) > l {
3725 return io.ErrUnexpectedEOF
3726 }
3727 iNdEx += skippy
3728 }
3729 }
3730
3731 if iNdEx > l {
3732 return io.ErrUnexpectedEOF
3733 }
3734 return nil
3735 }
3736 func (m *RangeAllocationList) Unmarshal(dAtA []byte) error {
3737 l := len(dAtA)
3738 iNdEx := 0
3739 for iNdEx < l {
3740 preIndex := iNdEx
3741 var wire uint64
3742 for shift := uint(0); ; shift += 7 {
3743 if shift >= 64 {
3744 return ErrIntOverflowGenerated
3745 }
3746 if iNdEx >= l {
3747 return io.ErrUnexpectedEOF
3748 }
3749 b := dAtA[iNdEx]
3750 iNdEx++
3751 wire |= uint64(b&0x7F) << shift
3752 if b < 0x80 {
3753 break
3754 }
3755 }
3756 fieldNum := int32(wire >> 3)
3757 wireType := int(wire & 0x7)
3758 if wireType == 4 {
3759 return fmt.Errorf("proto: RangeAllocationList: wiretype end group for non-group")
3760 }
3761 if fieldNum <= 0 {
3762 return fmt.Errorf("proto: RangeAllocationList: illegal tag %d (wire type %d)", fieldNum, wire)
3763 }
3764 switch fieldNum {
3765 case 1:
3766 if wireType != 2 {
3767 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3768 }
3769 var msglen int
3770 for shift := uint(0); ; shift += 7 {
3771 if shift >= 64 {
3772 return ErrIntOverflowGenerated
3773 }
3774 if iNdEx >= l {
3775 return io.ErrUnexpectedEOF
3776 }
3777 b := dAtA[iNdEx]
3778 iNdEx++
3779 msglen |= int(b&0x7F) << shift
3780 if b < 0x80 {
3781 break
3782 }
3783 }
3784 if msglen < 0 {
3785 return ErrInvalidLengthGenerated
3786 }
3787 postIndex := iNdEx + msglen
3788 if postIndex < 0 {
3789 return ErrInvalidLengthGenerated
3790 }
3791 if postIndex > l {
3792 return io.ErrUnexpectedEOF
3793 }
3794 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3795 return err
3796 }
3797 iNdEx = postIndex
3798 case 2:
3799 if wireType != 2 {
3800 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3801 }
3802 var msglen int
3803 for shift := uint(0); ; shift += 7 {
3804 if shift >= 64 {
3805 return ErrIntOverflowGenerated
3806 }
3807 if iNdEx >= l {
3808 return io.ErrUnexpectedEOF
3809 }
3810 b := dAtA[iNdEx]
3811 iNdEx++
3812 msglen |= int(b&0x7F) << shift
3813 if b < 0x80 {
3814 break
3815 }
3816 }
3817 if msglen < 0 {
3818 return ErrInvalidLengthGenerated
3819 }
3820 postIndex := iNdEx + msglen
3821 if postIndex < 0 {
3822 return ErrInvalidLengthGenerated
3823 }
3824 if postIndex > l {
3825 return io.ErrUnexpectedEOF
3826 }
3827 m.Items = append(m.Items, RangeAllocation{})
3828 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3829 return err
3830 }
3831 iNdEx = postIndex
3832 default:
3833 iNdEx = preIndex
3834 skippy, err := skipGenerated(dAtA[iNdEx:])
3835 if err != nil {
3836 return err
3837 }
3838 if (skippy < 0) || (iNdEx+skippy) < 0 {
3839 return ErrInvalidLengthGenerated
3840 }
3841 if (iNdEx + skippy) > l {
3842 return io.ErrUnexpectedEOF
3843 }
3844 iNdEx += skippy
3845 }
3846 }
3847
3848 if iNdEx > l {
3849 return io.ErrUnexpectedEOF
3850 }
3851 return nil
3852 }
3853 func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error {
3854 l := len(dAtA)
3855 iNdEx := 0
3856 for iNdEx < l {
3857 preIndex := iNdEx
3858 var wire uint64
3859 for shift := uint(0); ; shift += 7 {
3860 if shift >= 64 {
3861 return ErrIntOverflowGenerated
3862 }
3863 if iNdEx >= l {
3864 return io.ErrUnexpectedEOF
3865 }
3866 b := dAtA[iNdEx]
3867 iNdEx++
3868 wire |= uint64(b&0x7F) << shift
3869 if b < 0x80 {
3870 break
3871 }
3872 }
3873 fieldNum := int32(wire >> 3)
3874 wireType := int(wire & 0x7)
3875 if wireType == 4 {
3876 return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group")
3877 }
3878 if fieldNum <= 0 {
3879 return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3880 }
3881 switch fieldNum {
3882 case 1:
3883 if wireType != 2 {
3884 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3885 }
3886 var stringLen uint64
3887 for shift := uint(0); ; shift += 7 {
3888 if shift >= 64 {
3889 return ErrIntOverflowGenerated
3890 }
3891 if iNdEx >= l {
3892 return io.ErrUnexpectedEOF
3893 }
3894 b := dAtA[iNdEx]
3895 iNdEx++
3896 stringLen |= uint64(b&0x7F) << shift
3897 if b < 0x80 {
3898 break
3899 }
3900 }
3901 intStringLen := int(stringLen)
3902 if intStringLen < 0 {
3903 return ErrInvalidLengthGenerated
3904 }
3905 postIndex := iNdEx + intStringLen
3906 if postIndex < 0 {
3907 return ErrInvalidLengthGenerated
3908 }
3909 if postIndex > l {
3910 return io.ErrUnexpectedEOF
3911 }
3912 m.Type = RunAsUserStrategyType(dAtA[iNdEx:postIndex])
3913 iNdEx = postIndex
3914 case 2:
3915 if wireType != 0 {
3916 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
3917 }
3918 var v int64
3919 for shift := uint(0); ; shift += 7 {
3920 if shift >= 64 {
3921 return ErrIntOverflowGenerated
3922 }
3923 if iNdEx >= l {
3924 return io.ErrUnexpectedEOF
3925 }
3926 b := dAtA[iNdEx]
3927 iNdEx++
3928 v |= int64(b&0x7F) << shift
3929 if b < 0x80 {
3930 break
3931 }
3932 }
3933 m.UID = &v
3934 case 3:
3935 if wireType != 0 {
3936 return fmt.Errorf("proto: wrong wireType = %d for field UIDRangeMin", wireType)
3937 }
3938 var v int64
3939 for shift := uint(0); ; shift += 7 {
3940 if shift >= 64 {
3941 return ErrIntOverflowGenerated
3942 }
3943 if iNdEx >= l {
3944 return io.ErrUnexpectedEOF
3945 }
3946 b := dAtA[iNdEx]
3947 iNdEx++
3948 v |= int64(b&0x7F) << shift
3949 if b < 0x80 {
3950 break
3951 }
3952 }
3953 m.UIDRangeMin = &v
3954 case 4:
3955 if wireType != 0 {
3956 return fmt.Errorf("proto: wrong wireType = %d for field UIDRangeMax", wireType)
3957 }
3958 var v int64
3959 for shift := uint(0); ; shift += 7 {
3960 if shift >= 64 {
3961 return ErrIntOverflowGenerated
3962 }
3963 if iNdEx >= l {
3964 return io.ErrUnexpectedEOF
3965 }
3966 b := dAtA[iNdEx]
3967 iNdEx++
3968 v |= int64(b&0x7F) << shift
3969 if b < 0x80 {
3970 break
3971 }
3972 }
3973 m.UIDRangeMax = &v
3974 default:
3975 iNdEx = preIndex
3976 skippy, err := skipGenerated(dAtA[iNdEx:])
3977 if err != nil {
3978 return err
3979 }
3980 if (skippy < 0) || (iNdEx+skippy) < 0 {
3981 return ErrInvalidLengthGenerated
3982 }
3983 if (iNdEx + skippy) > l {
3984 return io.ErrUnexpectedEOF
3985 }
3986 iNdEx += skippy
3987 }
3988 }
3989
3990 if iNdEx > l {
3991 return io.ErrUnexpectedEOF
3992 }
3993 return nil
3994 }
3995 func (m *SELinuxContextStrategyOptions) Unmarshal(dAtA []byte) error {
3996 l := len(dAtA)
3997 iNdEx := 0
3998 for iNdEx < l {
3999 preIndex := iNdEx
4000 var wire uint64
4001 for shift := uint(0); ; shift += 7 {
4002 if shift >= 64 {
4003 return ErrIntOverflowGenerated
4004 }
4005 if iNdEx >= l {
4006 return io.ErrUnexpectedEOF
4007 }
4008 b := dAtA[iNdEx]
4009 iNdEx++
4010 wire |= uint64(b&0x7F) << shift
4011 if b < 0x80 {
4012 break
4013 }
4014 }
4015 fieldNum := int32(wire >> 3)
4016 wireType := int(wire & 0x7)
4017 if wireType == 4 {
4018 return fmt.Errorf("proto: SELinuxContextStrategyOptions: wiretype end group for non-group")
4019 }
4020 if fieldNum <= 0 {
4021 return fmt.Errorf("proto: SELinuxContextStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
4022 }
4023 switch fieldNum {
4024 case 1:
4025 if wireType != 2 {
4026 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4027 }
4028 var stringLen uint64
4029 for shift := uint(0); ; shift += 7 {
4030 if shift >= 64 {
4031 return ErrIntOverflowGenerated
4032 }
4033 if iNdEx >= l {
4034 return io.ErrUnexpectedEOF
4035 }
4036 b := dAtA[iNdEx]
4037 iNdEx++
4038 stringLen |= uint64(b&0x7F) << shift
4039 if b < 0x80 {
4040 break
4041 }
4042 }
4043 intStringLen := int(stringLen)
4044 if intStringLen < 0 {
4045 return ErrInvalidLengthGenerated
4046 }
4047 postIndex := iNdEx + intStringLen
4048 if postIndex < 0 {
4049 return ErrInvalidLengthGenerated
4050 }
4051 if postIndex > l {
4052 return io.ErrUnexpectedEOF
4053 }
4054 m.Type = SELinuxContextStrategyType(dAtA[iNdEx:postIndex])
4055 iNdEx = postIndex
4056 case 2:
4057 if wireType != 2 {
4058 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
4059 }
4060 var msglen int
4061 for shift := uint(0); ; shift += 7 {
4062 if shift >= 64 {
4063 return ErrIntOverflowGenerated
4064 }
4065 if iNdEx >= l {
4066 return io.ErrUnexpectedEOF
4067 }
4068 b := dAtA[iNdEx]
4069 iNdEx++
4070 msglen |= int(b&0x7F) << shift
4071 if b < 0x80 {
4072 break
4073 }
4074 }
4075 if msglen < 0 {
4076 return ErrInvalidLengthGenerated
4077 }
4078 postIndex := iNdEx + msglen
4079 if postIndex < 0 {
4080 return ErrInvalidLengthGenerated
4081 }
4082 if postIndex > l {
4083 return io.ErrUnexpectedEOF
4084 }
4085 if m.SELinuxOptions == nil {
4086 m.SELinuxOptions = &v1.SELinuxOptions{}
4087 }
4088 if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4089 return err
4090 }
4091 iNdEx = postIndex
4092 default:
4093 iNdEx = preIndex
4094 skippy, err := skipGenerated(dAtA[iNdEx:])
4095 if err != nil {
4096 return err
4097 }
4098 if (skippy < 0) || (iNdEx+skippy) < 0 {
4099 return ErrInvalidLengthGenerated
4100 }
4101 if (iNdEx + skippy) > l {
4102 return io.ErrUnexpectedEOF
4103 }
4104 iNdEx += skippy
4105 }
4106 }
4107
4108 if iNdEx > l {
4109 return io.ErrUnexpectedEOF
4110 }
4111 return nil
4112 }
4113 func (m *SecurityContextConstraints) Unmarshal(dAtA []byte) error {
4114 l := len(dAtA)
4115 iNdEx := 0
4116 for iNdEx < l {
4117 preIndex := iNdEx
4118 var wire uint64
4119 for shift := uint(0); ; shift += 7 {
4120 if shift >= 64 {
4121 return ErrIntOverflowGenerated
4122 }
4123 if iNdEx >= l {
4124 return io.ErrUnexpectedEOF
4125 }
4126 b := dAtA[iNdEx]
4127 iNdEx++
4128 wire |= uint64(b&0x7F) << shift
4129 if b < 0x80 {
4130 break
4131 }
4132 }
4133 fieldNum := int32(wire >> 3)
4134 wireType := int(wire & 0x7)
4135 if wireType == 4 {
4136 return fmt.Errorf("proto: SecurityContextConstraints: wiretype end group for non-group")
4137 }
4138 if fieldNum <= 0 {
4139 return fmt.Errorf("proto: SecurityContextConstraints: illegal tag %d (wire type %d)", fieldNum, wire)
4140 }
4141 switch fieldNum {
4142 case 1:
4143 if wireType != 2 {
4144 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4145 }
4146 var msglen int
4147 for shift := uint(0); ; shift += 7 {
4148 if shift >= 64 {
4149 return ErrIntOverflowGenerated
4150 }
4151 if iNdEx >= l {
4152 return io.ErrUnexpectedEOF
4153 }
4154 b := dAtA[iNdEx]
4155 iNdEx++
4156 msglen |= int(b&0x7F) << shift
4157 if b < 0x80 {
4158 break
4159 }
4160 }
4161 if msglen < 0 {
4162 return ErrInvalidLengthGenerated
4163 }
4164 postIndex := iNdEx + msglen
4165 if postIndex < 0 {
4166 return ErrInvalidLengthGenerated
4167 }
4168 if postIndex > l {
4169 return io.ErrUnexpectedEOF
4170 }
4171 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4172 return err
4173 }
4174 iNdEx = postIndex
4175 case 2:
4176 if wireType != 0 {
4177 return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
4178 }
4179 var v int32
4180 for shift := uint(0); ; shift += 7 {
4181 if shift >= 64 {
4182 return ErrIntOverflowGenerated
4183 }
4184 if iNdEx >= l {
4185 return io.ErrUnexpectedEOF
4186 }
4187 b := dAtA[iNdEx]
4188 iNdEx++
4189 v |= int32(b&0x7F) << shift
4190 if b < 0x80 {
4191 break
4192 }
4193 }
4194 m.Priority = &v
4195 case 3:
4196 if wireType != 0 {
4197 return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegedContainer", wireType)
4198 }
4199 var v int
4200 for shift := uint(0); ; shift += 7 {
4201 if shift >= 64 {
4202 return ErrIntOverflowGenerated
4203 }
4204 if iNdEx >= l {
4205 return io.ErrUnexpectedEOF
4206 }
4207 b := dAtA[iNdEx]
4208 iNdEx++
4209 v |= int(b&0x7F) << shift
4210 if b < 0x80 {
4211 break
4212 }
4213 }
4214 m.AllowPrivilegedContainer = bool(v != 0)
4215 case 4:
4216 if wireType != 2 {
4217 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType)
4218 }
4219 var stringLen uint64
4220 for shift := uint(0); ; shift += 7 {
4221 if shift >= 64 {
4222 return ErrIntOverflowGenerated
4223 }
4224 if iNdEx >= l {
4225 return io.ErrUnexpectedEOF
4226 }
4227 b := dAtA[iNdEx]
4228 iNdEx++
4229 stringLen |= uint64(b&0x7F) << shift
4230 if b < 0x80 {
4231 break
4232 }
4233 }
4234 intStringLen := int(stringLen)
4235 if intStringLen < 0 {
4236 return ErrInvalidLengthGenerated
4237 }
4238 postIndex := iNdEx + intStringLen
4239 if postIndex < 0 {
4240 return ErrInvalidLengthGenerated
4241 }
4242 if postIndex > l {
4243 return io.ErrUnexpectedEOF
4244 }
4245 m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
4246 iNdEx = postIndex
4247 case 5:
4248 if wireType != 2 {
4249 return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType)
4250 }
4251 var stringLen uint64
4252 for shift := uint(0); ; shift += 7 {
4253 if shift >= 64 {
4254 return ErrIntOverflowGenerated
4255 }
4256 if iNdEx >= l {
4257 return io.ErrUnexpectedEOF
4258 }
4259 b := dAtA[iNdEx]
4260 iNdEx++
4261 stringLen |= uint64(b&0x7F) << shift
4262 if b < 0x80 {
4263 break
4264 }
4265 }
4266 intStringLen := int(stringLen)
4267 if intStringLen < 0 {
4268 return ErrInvalidLengthGenerated
4269 }
4270 postIndex := iNdEx + intStringLen
4271 if postIndex < 0 {
4272 return ErrInvalidLengthGenerated
4273 }
4274 if postIndex > l {
4275 return io.ErrUnexpectedEOF
4276 }
4277 m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
4278 iNdEx = postIndex
4279 case 6:
4280 if wireType != 2 {
4281 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType)
4282 }
4283 var stringLen uint64
4284 for shift := uint(0); ; shift += 7 {
4285 if shift >= 64 {
4286 return ErrIntOverflowGenerated
4287 }
4288 if iNdEx >= l {
4289 return io.ErrUnexpectedEOF
4290 }
4291 b := dAtA[iNdEx]
4292 iNdEx++
4293 stringLen |= uint64(b&0x7F) << shift
4294 if b < 0x80 {
4295 break
4296 }
4297 }
4298 intStringLen := int(stringLen)
4299 if intStringLen < 0 {
4300 return ErrInvalidLengthGenerated
4301 }
4302 postIndex := iNdEx + intStringLen
4303 if postIndex < 0 {
4304 return ErrInvalidLengthGenerated
4305 }
4306 if postIndex > l {
4307 return io.ErrUnexpectedEOF
4308 }
4309 m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
4310 iNdEx = postIndex
4311 case 7:
4312 if wireType != 0 {
4313 return fmt.Errorf("proto: wrong wireType = %d for field AllowHostDirVolumePlugin", wireType)
4314 }
4315 var v int
4316 for shift := uint(0); ; shift += 7 {
4317 if shift >= 64 {
4318 return ErrIntOverflowGenerated
4319 }
4320 if iNdEx >= l {
4321 return io.ErrUnexpectedEOF
4322 }
4323 b := dAtA[iNdEx]
4324 iNdEx++
4325 v |= int(b&0x7F) << shift
4326 if b < 0x80 {
4327 break
4328 }
4329 }
4330 m.AllowHostDirVolumePlugin = bool(v != 0)
4331 case 8:
4332 if wireType != 2 {
4333 return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
4334 }
4335 var stringLen uint64
4336 for shift := uint(0); ; shift += 7 {
4337 if shift >= 64 {
4338 return ErrIntOverflowGenerated
4339 }
4340 if iNdEx >= l {
4341 return io.ErrUnexpectedEOF
4342 }
4343 b := dAtA[iNdEx]
4344 iNdEx++
4345 stringLen |= uint64(b&0x7F) << shift
4346 if b < 0x80 {
4347 break
4348 }
4349 }
4350 intStringLen := int(stringLen)
4351 if intStringLen < 0 {
4352 return ErrInvalidLengthGenerated
4353 }
4354 postIndex := iNdEx + intStringLen
4355 if postIndex < 0 {
4356 return ErrInvalidLengthGenerated
4357 }
4358 if postIndex > l {
4359 return io.ErrUnexpectedEOF
4360 }
4361 m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex]))
4362 iNdEx = postIndex
4363 case 9:
4364 if wireType != 0 {
4365 return fmt.Errorf("proto: wrong wireType = %d for field AllowHostNetwork", wireType)
4366 }
4367 var v int
4368 for shift := uint(0); ; shift += 7 {
4369 if shift >= 64 {
4370 return ErrIntOverflowGenerated
4371 }
4372 if iNdEx >= l {
4373 return io.ErrUnexpectedEOF
4374 }
4375 b := dAtA[iNdEx]
4376 iNdEx++
4377 v |= int(b&0x7F) << shift
4378 if b < 0x80 {
4379 break
4380 }
4381 }
4382 m.AllowHostNetwork = bool(v != 0)
4383 case 10:
4384 if wireType != 0 {
4385 return fmt.Errorf("proto: wrong wireType = %d for field AllowHostPorts", wireType)
4386 }
4387 var v int
4388 for shift := uint(0); ; shift += 7 {
4389 if shift >= 64 {
4390 return ErrIntOverflowGenerated
4391 }
4392 if iNdEx >= l {
4393 return io.ErrUnexpectedEOF
4394 }
4395 b := dAtA[iNdEx]
4396 iNdEx++
4397 v |= int(b&0x7F) << shift
4398 if b < 0x80 {
4399 break
4400 }
4401 }
4402 m.AllowHostPorts = bool(v != 0)
4403 case 11:
4404 if wireType != 0 {
4405 return fmt.Errorf("proto: wrong wireType = %d for field AllowHostPID", wireType)
4406 }
4407 var v int
4408 for shift := uint(0); ; shift += 7 {
4409 if shift >= 64 {
4410 return ErrIntOverflowGenerated
4411 }
4412 if iNdEx >= l {
4413 return io.ErrUnexpectedEOF
4414 }
4415 b := dAtA[iNdEx]
4416 iNdEx++
4417 v |= int(b&0x7F) << shift
4418 if b < 0x80 {
4419 break
4420 }
4421 }
4422 m.AllowHostPID = bool(v != 0)
4423 case 12:
4424 if wireType != 0 {
4425 return fmt.Errorf("proto: wrong wireType = %d for field AllowHostIPC", wireType)
4426 }
4427 var v int
4428 for shift := uint(0); ; shift += 7 {
4429 if shift >= 64 {
4430 return ErrIntOverflowGenerated
4431 }
4432 if iNdEx >= l {
4433 return io.ErrUnexpectedEOF
4434 }
4435 b := dAtA[iNdEx]
4436 iNdEx++
4437 v |= int(b&0x7F) << shift
4438 if b < 0x80 {
4439 break
4440 }
4441 }
4442 m.AllowHostIPC = bool(v != 0)
4443 case 13:
4444 if wireType != 2 {
4445 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxContext", wireType)
4446 }
4447 var msglen int
4448 for shift := uint(0); ; shift += 7 {
4449 if shift >= 64 {
4450 return ErrIntOverflowGenerated
4451 }
4452 if iNdEx >= l {
4453 return io.ErrUnexpectedEOF
4454 }
4455 b := dAtA[iNdEx]
4456 iNdEx++
4457 msglen |= int(b&0x7F) << shift
4458 if b < 0x80 {
4459 break
4460 }
4461 }
4462 if msglen < 0 {
4463 return ErrInvalidLengthGenerated
4464 }
4465 postIndex := iNdEx + msglen
4466 if postIndex < 0 {
4467 return ErrInvalidLengthGenerated
4468 }
4469 if postIndex > l {
4470 return io.ErrUnexpectedEOF
4471 }
4472 if err := m.SELinuxContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4473 return err
4474 }
4475 iNdEx = postIndex
4476 case 14:
4477 if wireType != 2 {
4478 return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
4479 }
4480 var msglen int
4481 for shift := uint(0); ; shift += 7 {
4482 if shift >= 64 {
4483 return ErrIntOverflowGenerated
4484 }
4485 if iNdEx >= l {
4486 return io.ErrUnexpectedEOF
4487 }
4488 b := dAtA[iNdEx]
4489 iNdEx++
4490 msglen |= int(b&0x7F) << shift
4491 if b < 0x80 {
4492 break
4493 }
4494 }
4495 if msglen < 0 {
4496 return ErrInvalidLengthGenerated
4497 }
4498 postIndex := iNdEx + msglen
4499 if postIndex < 0 {
4500 return ErrInvalidLengthGenerated
4501 }
4502 if postIndex > l {
4503 return io.ErrUnexpectedEOF
4504 }
4505 if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4506 return err
4507 }
4508 iNdEx = postIndex
4509 case 15:
4510 if wireType != 2 {
4511 return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
4512 }
4513 var msglen int
4514 for shift := uint(0); ; shift += 7 {
4515 if shift >= 64 {
4516 return ErrIntOverflowGenerated
4517 }
4518 if iNdEx >= l {
4519 return io.ErrUnexpectedEOF
4520 }
4521 b := dAtA[iNdEx]
4522 iNdEx++
4523 msglen |= int(b&0x7F) << shift
4524 if b < 0x80 {
4525 break
4526 }
4527 }
4528 if msglen < 0 {
4529 return ErrInvalidLengthGenerated
4530 }
4531 postIndex := iNdEx + msglen
4532 if postIndex < 0 {
4533 return ErrInvalidLengthGenerated
4534 }
4535 if postIndex > l {
4536 return io.ErrUnexpectedEOF
4537 }
4538 if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4539 return err
4540 }
4541 iNdEx = postIndex
4542 case 16:
4543 if wireType != 2 {
4544 return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
4545 }
4546 var msglen int
4547 for shift := uint(0); ; shift += 7 {
4548 if shift >= 64 {
4549 return ErrIntOverflowGenerated
4550 }
4551 if iNdEx >= l {
4552 return io.ErrUnexpectedEOF
4553 }
4554 b := dAtA[iNdEx]
4555 iNdEx++
4556 msglen |= int(b&0x7F) << shift
4557 if b < 0x80 {
4558 break
4559 }
4560 }
4561 if msglen < 0 {
4562 return ErrInvalidLengthGenerated
4563 }
4564 postIndex := iNdEx + msglen
4565 if postIndex < 0 {
4566 return ErrInvalidLengthGenerated
4567 }
4568 if postIndex > l {
4569 return io.ErrUnexpectedEOF
4570 }
4571 if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4572 return err
4573 }
4574 iNdEx = postIndex
4575 case 17:
4576 if wireType != 0 {
4577 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
4578 }
4579 var v int
4580 for shift := uint(0); ; shift += 7 {
4581 if shift >= 64 {
4582 return ErrIntOverflowGenerated
4583 }
4584 if iNdEx >= l {
4585 return io.ErrUnexpectedEOF
4586 }
4587 b := dAtA[iNdEx]
4588 iNdEx++
4589 v |= int(b&0x7F) << shift
4590 if b < 0x80 {
4591 break
4592 }
4593 }
4594 m.ReadOnlyRootFilesystem = bool(v != 0)
4595 case 18:
4596 if wireType != 2 {
4597 return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType)
4598 }
4599 var stringLen uint64
4600 for shift := uint(0); ; shift += 7 {
4601 if shift >= 64 {
4602 return ErrIntOverflowGenerated
4603 }
4604 if iNdEx >= l {
4605 return io.ErrUnexpectedEOF
4606 }
4607 b := dAtA[iNdEx]
4608 iNdEx++
4609 stringLen |= uint64(b&0x7F) << shift
4610 if b < 0x80 {
4611 break
4612 }
4613 }
4614 intStringLen := int(stringLen)
4615 if intStringLen < 0 {
4616 return ErrInvalidLengthGenerated
4617 }
4618 postIndex := iNdEx + intStringLen
4619 if postIndex < 0 {
4620 return ErrInvalidLengthGenerated
4621 }
4622 if postIndex > l {
4623 return io.ErrUnexpectedEOF
4624 }
4625 m.Users = append(m.Users, string(dAtA[iNdEx:postIndex]))
4626 iNdEx = postIndex
4627 case 19:
4628 if wireType != 2 {
4629 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
4630 }
4631 var stringLen uint64
4632 for shift := uint(0); ; shift += 7 {
4633 if shift >= 64 {
4634 return ErrIntOverflowGenerated
4635 }
4636 if iNdEx >= l {
4637 return io.ErrUnexpectedEOF
4638 }
4639 b := dAtA[iNdEx]
4640 iNdEx++
4641 stringLen |= uint64(b&0x7F) << shift
4642 if b < 0x80 {
4643 break
4644 }
4645 }
4646 intStringLen := int(stringLen)
4647 if intStringLen < 0 {
4648 return ErrInvalidLengthGenerated
4649 }
4650 postIndex := iNdEx + intStringLen
4651 if postIndex < 0 {
4652 return ErrInvalidLengthGenerated
4653 }
4654 if postIndex > l {
4655 return io.ErrUnexpectedEOF
4656 }
4657 m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
4658 iNdEx = postIndex
4659 case 20:
4660 if wireType != 2 {
4661 return fmt.Errorf("proto: wrong wireType = %d for field SeccompProfiles", wireType)
4662 }
4663 var stringLen uint64
4664 for shift := uint(0); ; shift += 7 {
4665 if shift >= 64 {
4666 return ErrIntOverflowGenerated
4667 }
4668 if iNdEx >= l {
4669 return io.ErrUnexpectedEOF
4670 }
4671 b := dAtA[iNdEx]
4672 iNdEx++
4673 stringLen |= uint64(b&0x7F) << shift
4674 if b < 0x80 {
4675 break
4676 }
4677 }
4678 intStringLen := int(stringLen)
4679 if intStringLen < 0 {
4680 return ErrInvalidLengthGenerated
4681 }
4682 postIndex := iNdEx + intStringLen
4683 if postIndex < 0 {
4684 return ErrInvalidLengthGenerated
4685 }
4686 if postIndex > l {
4687 return io.ErrUnexpectedEOF
4688 }
4689 m.SeccompProfiles = append(m.SeccompProfiles, string(dAtA[iNdEx:postIndex]))
4690 iNdEx = postIndex
4691 case 21:
4692 if wireType != 2 {
4693 return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType)
4694 }
4695 var msglen int
4696 for shift := uint(0); ; shift += 7 {
4697 if shift >= 64 {
4698 return ErrIntOverflowGenerated
4699 }
4700 if iNdEx >= l {
4701 return io.ErrUnexpectedEOF
4702 }
4703 b := dAtA[iNdEx]
4704 iNdEx++
4705 msglen |= int(b&0x7F) << shift
4706 if b < 0x80 {
4707 break
4708 }
4709 }
4710 if msglen < 0 {
4711 return ErrInvalidLengthGenerated
4712 }
4713 postIndex := iNdEx + msglen
4714 if postIndex < 0 {
4715 return ErrInvalidLengthGenerated
4716 }
4717 if postIndex > l {
4718 return io.ErrUnexpectedEOF
4719 }
4720 m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{})
4721 if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4722 return err
4723 }
4724 iNdEx = postIndex
4725 case 22:
4726 if wireType != 0 {
4727 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType)
4728 }
4729 var v int
4730 for shift := uint(0); ; shift += 7 {
4731 if shift >= 64 {
4732 return ErrIntOverflowGenerated
4733 }
4734 if iNdEx >= l {
4735 return io.ErrUnexpectedEOF
4736 }
4737 b := dAtA[iNdEx]
4738 iNdEx++
4739 v |= int(b&0x7F) << shift
4740 if b < 0x80 {
4741 break
4742 }
4743 }
4744 b := bool(v != 0)
4745 m.DefaultAllowPrivilegeEscalation = &b
4746 case 23:
4747 if wireType != 0 {
4748 return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType)
4749 }
4750 var v int
4751 for shift := uint(0); ; shift += 7 {
4752 if shift >= 64 {
4753 return ErrIntOverflowGenerated
4754 }
4755 if iNdEx >= l {
4756 return io.ErrUnexpectedEOF
4757 }
4758 b := dAtA[iNdEx]
4759 iNdEx++
4760 v |= int(b&0x7F) << shift
4761 if b < 0x80 {
4762 break
4763 }
4764 }
4765 b := bool(v != 0)
4766 m.AllowPrivilegeEscalation = &b
4767 case 24:
4768 if wireType != 2 {
4769 return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType)
4770 }
4771 var stringLen uint64
4772 for shift := uint(0); ; shift += 7 {
4773 if shift >= 64 {
4774 return ErrIntOverflowGenerated
4775 }
4776 if iNdEx >= l {
4777 return io.ErrUnexpectedEOF
4778 }
4779 b := dAtA[iNdEx]
4780 iNdEx++
4781 stringLen |= uint64(b&0x7F) << shift
4782 if b < 0x80 {
4783 break
4784 }
4785 }
4786 intStringLen := int(stringLen)
4787 if intStringLen < 0 {
4788 return ErrInvalidLengthGenerated
4789 }
4790 postIndex := iNdEx + intStringLen
4791 if postIndex < 0 {
4792 return ErrInvalidLengthGenerated
4793 }
4794 if postIndex > l {
4795 return io.ErrUnexpectedEOF
4796 }
4797 m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex]))
4798 iNdEx = postIndex
4799 case 25:
4800 if wireType != 2 {
4801 return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType)
4802 }
4803 var stringLen uint64
4804 for shift := uint(0); ; shift += 7 {
4805 if shift >= 64 {
4806 return ErrIntOverflowGenerated
4807 }
4808 if iNdEx >= l {
4809 return io.ErrUnexpectedEOF
4810 }
4811 b := dAtA[iNdEx]
4812 iNdEx++
4813 stringLen |= uint64(b&0x7F) << shift
4814 if b < 0x80 {
4815 break
4816 }
4817 }
4818 intStringLen := int(stringLen)
4819 if intStringLen < 0 {
4820 return ErrInvalidLengthGenerated
4821 }
4822 postIndex := iNdEx + intStringLen
4823 if postIndex < 0 {
4824 return ErrInvalidLengthGenerated
4825 }
4826 if postIndex > l {
4827 return io.ErrUnexpectedEOF
4828 }
4829 m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex]))
4830 iNdEx = postIndex
4831 default:
4832 iNdEx = preIndex
4833 skippy, err := skipGenerated(dAtA[iNdEx:])
4834 if err != nil {
4835 return err
4836 }
4837 if (skippy < 0) || (iNdEx+skippy) < 0 {
4838 return ErrInvalidLengthGenerated
4839 }
4840 if (iNdEx + skippy) > l {
4841 return io.ErrUnexpectedEOF
4842 }
4843 iNdEx += skippy
4844 }
4845 }
4846
4847 if iNdEx > l {
4848 return io.ErrUnexpectedEOF
4849 }
4850 return nil
4851 }
4852 func (m *SecurityContextConstraintsList) Unmarshal(dAtA []byte) error {
4853 l := len(dAtA)
4854 iNdEx := 0
4855 for iNdEx < l {
4856 preIndex := iNdEx
4857 var wire uint64
4858 for shift := uint(0); ; shift += 7 {
4859 if shift >= 64 {
4860 return ErrIntOverflowGenerated
4861 }
4862 if iNdEx >= l {
4863 return io.ErrUnexpectedEOF
4864 }
4865 b := dAtA[iNdEx]
4866 iNdEx++
4867 wire |= uint64(b&0x7F) << shift
4868 if b < 0x80 {
4869 break
4870 }
4871 }
4872 fieldNum := int32(wire >> 3)
4873 wireType := int(wire & 0x7)
4874 if wireType == 4 {
4875 return fmt.Errorf("proto: SecurityContextConstraintsList: wiretype end group for non-group")
4876 }
4877 if fieldNum <= 0 {
4878 return fmt.Errorf("proto: SecurityContextConstraintsList: illegal tag %d (wire type %d)", fieldNum, wire)
4879 }
4880 switch fieldNum {
4881 case 1:
4882 if wireType != 2 {
4883 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4884 }
4885 var msglen int
4886 for shift := uint(0); ; shift += 7 {
4887 if shift >= 64 {
4888 return ErrIntOverflowGenerated
4889 }
4890 if iNdEx >= l {
4891 return io.ErrUnexpectedEOF
4892 }
4893 b := dAtA[iNdEx]
4894 iNdEx++
4895 msglen |= int(b&0x7F) << shift
4896 if b < 0x80 {
4897 break
4898 }
4899 }
4900 if msglen < 0 {
4901 return ErrInvalidLengthGenerated
4902 }
4903 postIndex := iNdEx + msglen
4904 if postIndex < 0 {
4905 return ErrInvalidLengthGenerated
4906 }
4907 if postIndex > l {
4908 return io.ErrUnexpectedEOF
4909 }
4910 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4911 return err
4912 }
4913 iNdEx = postIndex
4914 case 2:
4915 if wireType != 2 {
4916 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4917 }
4918 var msglen int
4919 for shift := uint(0); ; shift += 7 {
4920 if shift >= 64 {
4921 return ErrIntOverflowGenerated
4922 }
4923 if iNdEx >= l {
4924 return io.ErrUnexpectedEOF
4925 }
4926 b := dAtA[iNdEx]
4927 iNdEx++
4928 msglen |= int(b&0x7F) << shift
4929 if b < 0x80 {
4930 break
4931 }
4932 }
4933 if msglen < 0 {
4934 return ErrInvalidLengthGenerated
4935 }
4936 postIndex := iNdEx + msglen
4937 if postIndex < 0 {
4938 return ErrInvalidLengthGenerated
4939 }
4940 if postIndex > l {
4941 return io.ErrUnexpectedEOF
4942 }
4943 m.Items = append(m.Items, SecurityContextConstraints{})
4944 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4945 return err
4946 }
4947 iNdEx = postIndex
4948 default:
4949 iNdEx = preIndex
4950 skippy, err := skipGenerated(dAtA[iNdEx:])
4951 if err != nil {
4952 return err
4953 }
4954 if (skippy < 0) || (iNdEx+skippy) < 0 {
4955 return ErrInvalidLengthGenerated
4956 }
4957 if (iNdEx + skippy) > l {
4958 return io.ErrUnexpectedEOF
4959 }
4960 iNdEx += skippy
4961 }
4962 }
4963
4964 if iNdEx > l {
4965 return io.ErrUnexpectedEOF
4966 }
4967 return nil
4968 }
4969 func (m *ServiceAccountPodSecurityPolicyReviewStatus) Unmarshal(dAtA []byte) error {
4970 l := len(dAtA)
4971 iNdEx := 0
4972 for iNdEx < l {
4973 preIndex := iNdEx
4974 var wire uint64
4975 for shift := uint(0); ; shift += 7 {
4976 if shift >= 64 {
4977 return ErrIntOverflowGenerated
4978 }
4979 if iNdEx >= l {
4980 return io.ErrUnexpectedEOF
4981 }
4982 b := dAtA[iNdEx]
4983 iNdEx++
4984 wire |= uint64(b&0x7F) << shift
4985 if b < 0x80 {
4986 break
4987 }
4988 }
4989 fieldNum := int32(wire >> 3)
4990 wireType := int(wire & 0x7)
4991 if wireType == 4 {
4992 return fmt.Errorf("proto: ServiceAccountPodSecurityPolicyReviewStatus: wiretype end group for non-group")
4993 }
4994 if fieldNum <= 0 {
4995 return fmt.Errorf("proto: ServiceAccountPodSecurityPolicyReviewStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4996 }
4997 switch fieldNum {
4998 case 1:
4999 if wireType != 2 {
5000 return fmt.Errorf("proto: wrong wireType = %d for field PodSecurityPolicySubjectReviewStatus", wireType)
5001 }
5002 var msglen int
5003 for shift := uint(0); ; shift += 7 {
5004 if shift >= 64 {
5005 return ErrIntOverflowGenerated
5006 }
5007 if iNdEx >= l {
5008 return io.ErrUnexpectedEOF
5009 }
5010 b := dAtA[iNdEx]
5011 iNdEx++
5012 msglen |= int(b&0x7F) << shift
5013 if b < 0x80 {
5014 break
5015 }
5016 }
5017 if msglen < 0 {
5018 return ErrInvalidLengthGenerated
5019 }
5020 postIndex := iNdEx + msglen
5021 if postIndex < 0 {
5022 return ErrInvalidLengthGenerated
5023 }
5024 if postIndex > l {
5025 return io.ErrUnexpectedEOF
5026 }
5027 if err := m.PodSecurityPolicySubjectReviewStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5028 return err
5029 }
5030 iNdEx = postIndex
5031 case 2:
5032 if wireType != 2 {
5033 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5034 }
5035 var stringLen uint64
5036 for shift := uint(0); ; shift += 7 {
5037 if shift >= 64 {
5038 return ErrIntOverflowGenerated
5039 }
5040 if iNdEx >= l {
5041 return io.ErrUnexpectedEOF
5042 }
5043 b := dAtA[iNdEx]
5044 iNdEx++
5045 stringLen |= uint64(b&0x7F) << shift
5046 if b < 0x80 {
5047 break
5048 }
5049 }
5050 intStringLen := int(stringLen)
5051 if intStringLen < 0 {
5052 return ErrInvalidLengthGenerated
5053 }
5054 postIndex := iNdEx + intStringLen
5055 if postIndex < 0 {
5056 return ErrInvalidLengthGenerated
5057 }
5058 if postIndex > l {
5059 return io.ErrUnexpectedEOF
5060 }
5061 m.Name = string(dAtA[iNdEx:postIndex])
5062 iNdEx = postIndex
5063 default:
5064 iNdEx = preIndex
5065 skippy, err := skipGenerated(dAtA[iNdEx:])
5066 if err != nil {
5067 return err
5068 }
5069 if (skippy < 0) || (iNdEx+skippy) < 0 {
5070 return ErrInvalidLengthGenerated
5071 }
5072 if (iNdEx + skippy) > l {
5073 return io.ErrUnexpectedEOF
5074 }
5075 iNdEx += skippy
5076 }
5077 }
5078
5079 if iNdEx > l {
5080 return io.ErrUnexpectedEOF
5081 }
5082 return nil
5083 }
5084 func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error {
5085 l := len(dAtA)
5086 iNdEx := 0
5087 for iNdEx < l {
5088 preIndex := iNdEx
5089 var wire uint64
5090 for shift := uint(0); ; shift += 7 {
5091 if shift >= 64 {
5092 return ErrIntOverflowGenerated
5093 }
5094 if iNdEx >= l {
5095 return io.ErrUnexpectedEOF
5096 }
5097 b := dAtA[iNdEx]
5098 iNdEx++
5099 wire |= uint64(b&0x7F) << shift
5100 if b < 0x80 {
5101 break
5102 }
5103 }
5104 fieldNum := int32(wire >> 3)
5105 wireType := int(wire & 0x7)
5106 if wireType == 4 {
5107 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group")
5108 }
5109 if fieldNum <= 0 {
5110 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
5111 }
5112 switch fieldNum {
5113 case 1:
5114 if wireType != 2 {
5115 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5116 }
5117 var stringLen uint64
5118 for shift := uint(0); ; shift += 7 {
5119 if shift >= 64 {
5120 return ErrIntOverflowGenerated
5121 }
5122 if iNdEx >= l {
5123 return io.ErrUnexpectedEOF
5124 }
5125 b := dAtA[iNdEx]
5126 iNdEx++
5127 stringLen |= uint64(b&0x7F) << shift
5128 if b < 0x80 {
5129 break
5130 }
5131 }
5132 intStringLen := int(stringLen)
5133 if intStringLen < 0 {
5134 return ErrInvalidLengthGenerated
5135 }
5136 postIndex := iNdEx + intStringLen
5137 if postIndex < 0 {
5138 return ErrInvalidLengthGenerated
5139 }
5140 if postIndex > l {
5141 return io.ErrUnexpectedEOF
5142 }
5143 m.Type = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex])
5144 iNdEx = postIndex
5145 case 2:
5146 if wireType != 2 {
5147 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
5148 }
5149 var msglen int
5150 for shift := uint(0); ; shift += 7 {
5151 if shift >= 64 {
5152 return ErrIntOverflowGenerated
5153 }
5154 if iNdEx >= l {
5155 return io.ErrUnexpectedEOF
5156 }
5157 b := dAtA[iNdEx]
5158 iNdEx++
5159 msglen |= int(b&0x7F) << shift
5160 if b < 0x80 {
5161 break
5162 }
5163 }
5164 if msglen < 0 {
5165 return ErrInvalidLengthGenerated
5166 }
5167 postIndex := iNdEx + msglen
5168 if postIndex < 0 {
5169 return ErrInvalidLengthGenerated
5170 }
5171 if postIndex > l {
5172 return io.ErrUnexpectedEOF
5173 }
5174 m.Ranges = append(m.Ranges, IDRange{})
5175 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5176 return err
5177 }
5178 iNdEx = postIndex
5179 default:
5180 iNdEx = preIndex
5181 skippy, err := skipGenerated(dAtA[iNdEx:])
5182 if err != nil {
5183 return err
5184 }
5185 if (skippy < 0) || (iNdEx+skippy) < 0 {
5186 return ErrInvalidLengthGenerated
5187 }
5188 if (iNdEx + skippy) > l {
5189 return io.ErrUnexpectedEOF
5190 }
5191 iNdEx += skippy
5192 }
5193 }
5194
5195 if iNdEx > l {
5196 return io.ErrUnexpectedEOF
5197 }
5198 return nil
5199 }
5200 func skipGenerated(dAtA []byte) (n int, err error) {
5201 l := len(dAtA)
5202 iNdEx := 0
5203 depth := 0
5204 for iNdEx < l {
5205 var wire uint64
5206 for shift := uint(0); ; shift += 7 {
5207 if shift >= 64 {
5208 return 0, ErrIntOverflowGenerated
5209 }
5210 if iNdEx >= l {
5211 return 0, io.ErrUnexpectedEOF
5212 }
5213 b := dAtA[iNdEx]
5214 iNdEx++
5215 wire |= (uint64(b) & 0x7F) << shift
5216 if b < 0x80 {
5217 break
5218 }
5219 }
5220 wireType := int(wire & 0x7)
5221 switch wireType {
5222 case 0:
5223 for shift := uint(0); ; shift += 7 {
5224 if shift >= 64 {
5225 return 0, ErrIntOverflowGenerated
5226 }
5227 if iNdEx >= l {
5228 return 0, io.ErrUnexpectedEOF
5229 }
5230 iNdEx++
5231 if dAtA[iNdEx-1] < 0x80 {
5232 break
5233 }
5234 }
5235 case 1:
5236 iNdEx += 8
5237 case 2:
5238 var length int
5239 for shift := uint(0); ; shift += 7 {
5240 if shift >= 64 {
5241 return 0, ErrIntOverflowGenerated
5242 }
5243 if iNdEx >= l {
5244 return 0, io.ErrUnexpectedEOF
5245 }
5246 b := dAtA[iNdEx]
5247 iNdEx++
5248 length |= (int(b) & 0x7F) << shift
5249 if b < 0x80 {
5250 break
5251 }
5252 }
5253 if length < 0 {
5254 return 0, ErrInvalidLengthGenerated
5255 }
5256 iNdEx += length
5257 case 3:
5258 depth++
5259 case 4:
5260 if depth == 0 {
5261 return 0, ErrUnexpectedEndOfGroupGenerated
5262 }
5263 depth--
5264 case 5:
5265 iNdEx += 4
5266 default:
5267 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
5268 }
5269 if iNdEx < 0 {
5270 return 0, ErrInvalidLengthGenerated
5271 }
5272 if depth == 0 {
5273 return iNdEx, nil
5274 }
5275 }
5276 return 0, io.ErrUnexpectedEOF
5277 }
5278
5279 var (
5280 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
5281 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
5282 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
5283 )
5284
View as plain text