blob: d122fcfda12beb5e88b74ae727de3b795b019e52 [file] [log] [blame]
sslobodr60a6d0f2019-01-18 14:51:05 -05001/*
2Copyright The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17// Code generated by protoc-gen-gogo. DO NOT EDIT.
18// source: k8s.io/kubernetes/vendor/k8s.io/api/policy/v1beta1/generated.proto
19
20/*
21 Package v1beta1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/api/policy/v1beta1/generated.proto
25
26 It has these top-level messages:
27 AllowedFlexVolume
28 AllowedHostPath
29 Eviction
30 FSGroupStrategyOptions
31 HostPortRange
32 IDRange
33 PodDisruptionBudget
34 PodDisruptionBudgetList
35 PodDisruptionBudgetSpec
36 PodDisruptionBudgetStatus
37 PodSecurityPolicy
38 PodSecurityPolicyList
39 PodSecurityPolicySpec
40 RunAsGroupStrategyOptions
41 RunAsUserStrategyOptions
42 SELinuxStrategyOptions
43 SupplementalGroupsStrategyOptions
44*/
45package v1beta1
46
47import proto "github.com/gogo/protobuf/proto"
48import fmt "fmt"
49import math "math"
50
51import k8s_io_api_core_v1 "k8s.io/api/core/v1"
52import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
53
54import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr"
55
56import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
57
58import strings "strings"
59import reflect "reflect"
60
61import io "io"
62
63// Reference imports to suppress errors if they are not otherwise used.
64var _ = proto.Marshal
65var _ = fmt.Errorf
66var _ = math.Inf
67
68// This is a compile-time assertion to ensure that this generated file
69// is compatible with the proto package it is being compiled against.
70// A compilation error at this line likely means your copy of the
71// proto package needs to be updated.
72const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
73
74func (m *AllowedFlexVolume) Reset() { *m = AllowedFlexVolume{} }
75func (*AllowedFlexVolume) ProtoMessage() {}
76func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
77
78func (m *AllowedHostPath) Reset() { *m = AllowedHostPath{} }
79func (*AllowedHostPath) ProtoMessage() {}
80func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
81
82func (m *Eviction) Reset() { *m = Eviction{} }
83func (*Eviction) ProtoMessage() {}
84func (*Eviction) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
85
86func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} }
87func (*FSGroupStrategyOptions) ProtoMessage() {}
88func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
89
90func (m *HostPortRange) Reset() { *m = HostPortRange{} }
91func (*HostPortRange) ProtoMessage() {}
92func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
93
94func (m *IDRange) Reset() { *m = IDRange{} }
95func (*IDRange) ProtoMessage() {}
96func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
97
98func (m *PodDisruptionBudget) Reset() { *m = PodDisruptionBudget{} }
99func (*PodDisruptionBudget) ProtoMessage() {}
100func (*PodDisruptionBudget) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
101
102func (m *PodDisruptionBudgetList) Reset() { *m = PodDisruptionBudgetList{} }
103func (*PodDisruptionBudgetList) ProtoMessage() {}
104func (*PodDisruptionBudgetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
105
106func (m *PodDisruptionBudgetSpec) Reset() { *m = PodDisruptionBudgetSpec{} }
107func (*PodDisruptionBudgetSpec) ProtoMessage() {}
108func (*PodDisruptionBudgetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
109
110func (m *PodDisruptionBudgetStatus) Reset() { *m = PodDisruptionBudgetStatus{} }
111func (*PodDisruptionBudgetStatus) ProtoMessage() {}
112func (*PodDisruptionBudgetStatus) Descriptor() ([]byte, []int) {
113 return fileDescriptorGenerated, []int{9}
114}
115
116func (m *PodSecurityPolicy) Reset() { *m = PodSecurityPolicy{} }
117func (*PodSecurityPolicy) ProtoMessage() {}
118func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
119
120func (m *PodSecurityPolicyList) Reset() { *m = PodSecurityPolicyList{} }
121func (*PodSecurityPolicyList) ProtoMessage() {}
122func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
123
124func (m *PodSecurityPolicySpec) Reset() { *m = PodSecurityPolicySpec{} }
125func (*PodSecurityPolicySpec) ProtoMessage() {}
126func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
127
128func (m *RunAsGroupStrategyOptions) Reset() { *m = RunAsGroupStrategyOptions{} }
129func (*RunAsGroupStrategyOptions) ProtoMessage() {}
130func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) {
131 return fileDescriptorGenerated, []int{13}
132}
133
134func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} }
135func (*RunAsUserStrategyOptions) ProtoMessage() {}
136func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) {
137 return fileDescriptorGenerated, []int{14}
138}
139
140func (m *SELinuxStrategyOptions) Reset() { *m = SELinuxStrategyOptions{} }
141func (*SELinuxStrategyOptions) ProtoMessage() {}
142func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
143
144func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} }
145func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
146func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) {
147 return fileDescriptorGenerated, []int{16}
148}
149
150func init() {
151 proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.policy.v1beta1.AllowedFlexVolume")
152 proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.policy.v1beta1.AllowedHostPath")
153 proto.RegisterType((*Eviction)(nil), "k8s.io.api.policy.v1beta1.Eviction")
154 proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.policy.v1beta1.FSGroupStrategyOptions")
155 proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.policy.v1beta1.HostPortRange")
156 proto.RegisterType((*IDRange)(nil), "k8s.io.api.policy.v1beta1.IDRange")
157 proto.RegisterType((*PodDisruptionBudget)(nil), "k8s.io.api.policy.v1beta1.PodDisruptionBudget")
158 proto.RegisterType((*PodDisruptionBudgetList)(nil), "k8s.io.api.policy.v1beta1.PodDisruptionBudgetList")
159 proto.RegisterType((*PodDisruptionBudgetSpec)(nil), "k8s.io.api.policy.v1beta1.PodDisruptionBudgetSpec")
160 proto.RegisterType((*PodDisruptionBudgetStatus)(nil), "k8s.io.api.policy.v1beta1.PodDisruptionBudgetStatus")
161 proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.policy.v1beta1.PodSecurityPolicy")
162 proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.policy.v1beta1.PodSecurityPolicyList")
163 proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.policy.v1beta1.PodSecurityPolicySpec")
164 proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.policy.v1beta1.RunAsGroupStrategyOptions")
165 proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.policy.v1beta1.RunAsUserStrategyOptions")
166 proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.policy.v1beta1.SELinuxStrategyOptions")
167 proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.policy.v1beta1.SupplementalGroupsStrategyOptions")
168}
169func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) {
170 size := m.Size()
171 dAtA = make([]byte, size)
172 n, err := m.MarshalTo(dAtA)
173 if err != nil {
174 return nil, err
175 }
176 return dAtA[:n], nil
177}
178
179func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) {
180 var i int
181 _ = i
182 var l int
183 _ = l
184 dAtA[i] = 0xa
185 i++
186 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
187 i += copy(dAtA[i:], m.Driver)
188 return i, nil
189}
190
191func (m *AllowedHostPath) Marshal() (dAtA []byte, err error) {
192 size := m.Size()
193 dAtA = make([]byte, size)
194 n, err := m.MarshalTo(dAtA)
195 if err != nil {
196 return nil, err
197 }
198 return dAtA[:n], nil
199}
200
201func (m *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) {
202 var i int
203 _ = i
204 var l int
205 _ = l
206 dAtA[i] = 0xa
207 i++
208 i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix)))
209 i += copy(dAtA[i:], m.PathPrefix)
210 dAtA[i] = 0x10
211 i++
212 if m.ReadOnly {
213 dAtA[i] = 1
214 } else {
215 dAtA[i] = 0
216 }
217 i++
218 return i, nil
219}
220
221func (m *Eviction) Marshal() (dAtA []byte, err error) {
222 size := m.Size()
223 dAtA = make([]byte, size)
224 n, err := m.MarshalTo(dAtA)
225 if err != nil {
226 return nil, err
227 }
228 return dAtA[:n], nil
229}
230
231func (m *Eviction) MarshalTo(dAtA []byte) (int, error) {
232 var i int
233 _ = i
234 var l int
235 _ = l
236 dAtA[i] = 0xa
237 i++
238 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
239 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
240 if err != nil {
241 return 0, err
242 }
243 i += n1
244 if m.DeleteOptions != nil {
245 dAtA[i] = 0x12
246 i++
247 i = encodeVarintGenerated(dAtA, i, uint64(m.DeleteOptions.Size()))
248 n2, err := m.DeleteOptions.MarshalTo(dAtA[i:])
249 if err != nil {
250 return 0, err
251 }
252 i += n2
253 }
254 return i, nil
255}
256
257func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
258 size := m.Size()
259 dAtA = make([]byte, size)
260 n, err := m.MarshalTo(dAtA)
261 if err != nil {
262 return nil, err
263 }
264 return dAtA[:n], nil
265}
266
267func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
268 var i int
269 _ = i
270 var l int
271 _ = l
272 dAtA[i] = 0xa
273 i++
274 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
275 i += copy(dAtA[i:], m.Rule)
276 if len(m.Ranges) > 0 {
277 for _, msg := range m.Ranges {
278 dAtA[i] = 0x12
279 i++
280 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
281 n, err := msg.MarshalTo(dAtA[i:])
282 if err != nil {
283 return 0, err
284 }
285 i += n
286 }
287 }
288 return i, nil
289}
290
291func (m *HostPortRange) Marshal() (dAtA []byte, err error) {
292 size := m.Size()
293 dAtA = make([]byte, size)
294 n, err := m.MarshalTo(dAtA)
295 if err != nil {
296 return nil, err
297 }
298 return dAtA[:n], nil
299}
300
301func (m *HostPortRange) MarshalTo(dAtA []byte) (int, error) {
302 var i int
303 _ = i
304 var l int
305 _ = l
306 dAtA[i] = 0x8
307 i++
308 i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
309 dAtA[i] = 0x10
310 i++
311 i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
312 return i, nil
313}
314
315func (m *IDRange) Marshal() (dAtA []byte, err error) {
316 size := m.Size()
317 dAtA = make([]byte, size)
318 n, err := m.MarshalTo(dAtA)
319 if err != nil {
320 return nil, err
321 }
322 return dAtA[:n], nil
323}
324
325func (m *IDRange) MarshalTo(dAtA []byte) (int, error) {
326 var i int
327 _ = i
328 var l int
329 _ = l
330 dAtA[i] = 0x8
331 i++
332 i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
333 dAtA[i] = 0x10
334 i++
335 i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
336 return i, nil
337}
338
339func (m *PodDisruptionBudget) Marshal() (dAtA []byte, err error) {
340 size := m.Size()
341 dAtA = make([]byte, size)
342 n, err := m.MarshalTo(dAtA)
343 if err != nil {
344 return nil, err
345 }
346 return dAtA[:n], nil
347}
348
349func (m *PodDisruptionBudget) MarshalTo(dAtA []byte) (int, error) {
350 var i int
351 _ = i
352 var l int
353 _ = l
354 dAtA[i] = 0xa
355 i++
356 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
357 n3, err := m.ObjectMeta.MarshalTo(dAtA[i:])
358 if err != nil {
359 return 0, err
360 }
361 i += n3
362 dAtA[i] = 0x12
363 i++
364 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
365 n4, err := m.Spec.MarshalTo(dAtA[i:])
366 if err != nil {
367 return 0, err
368 }
369 i += n4
370 dAtA[i] = 0x1a
371 i++
372 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
373 n5, err := m.Status.MarshalTo(dAtA[i:])
374 if err != nil {
375 return 0, err
376 }
377 i += n5
378 return i, nil
379}
380
381func (m *PodDisruptionBudgetList) Marshal() (dAtA []byte, err error) {
382 size := m.Size()
383 dAtA = make([]byte, size)
384 n, err := m.MarshalTo(dAtA)
385 if err != nil {
386 return nil, err
387 }
388 return dAtA[:n], nil
389}
390
391func (m *PodDisruptionBudgetList) MarshalTo(dAtA []byte) (int, error) {
392 var i int
393 _ = i
394 var l int
395 _ = l
396 dAtA[i] = 0xa
397 i++
398 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
399 n6, err := m.ListMeta.MarshalTo(dAtA[i:])
400 if err != nil {
401 return 0, err
402 }
403 i += n6
404 if len(m.Items) > 0 {
405 for _, msg := range m.Items {
406 dAtA[i] = 0x12
407 i++
408 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
409 n, err := msg.MarshalTo(dAtA[i:])
410 if err != nil {
411 return 0, err
412 }
413 i += n
414 }
415 }
416 return i, nil
417}
418
419func (m *PodDisruptionBudgetSpec) Marshal() (dAtA []byte, err error) {
420 size := m.Size()
421 dAtA = make([]byte, size)
422 n, err := m.MarshalTo(dAtA)
423 if err != nil {
424 return nil, err
425 }
426 return dAtA[:n], nil
427}
428
429func (m *PodDisruptionBudgetSpec) MarshalTo(dAtA []byte) (int, error) {
430 var i int
431 _ = i
432 var l int
433 _ = l
434 if m.MinAvailable != nil {
435 dAtA[i] = 0xa
436 i++
437 i = encodeVarintGenerated(dAtA, i, uint64(m.MinAvailable.Size()))
438 n7, err := m.MinAvailable.MarshalTo(dAtA[i:])
439 if err != nil {
440 return 0, err
441 }
442 i += n7
443 }
444 if m.Selector != nil {
445 dAtA[i] = 0x12
446 i++
447 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
448 n8, err := m.Selector.MarshalTo(dAtA[i:])
449 if err != nil {
450 return 0, err
451 }
452 i += n8
453 }
454 if m.MaxUnavailable != nil {
455 dAtA[i] = 0x1a
456 i++
457 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
458 n9, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
459 if err != nil {
460 return 0, err
461 }
462 i += n9
463 }
464 return i, nil
465}
466
467func (m *PodDisruptionBudgetStatus) Marshal() (dAtA []byte, err error) {
468 size := m.Size()
469 dAtA = make([]byte, size)
470 n, err := m.MarshalTo(dAtA)
471 if err != nil {
472 return nil, err
473 }
474 return dAtA[:n], nil
475}
476
477func (m *PodDisruptionBudgetStatus) MarshalTo(dAtA []byte) (int, error) {
478 var i int
479 _ = i
480 var l int
481 _ = l
482 dAtA[i] = 0x8
483 i++
484 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
485 if len(m.DisruptedPods) > 0 {
486 keysForDisruptedPods := make([]string, 0, len(m.DisruptedPods))
487 for k := range m.DisruptedPods {
488 keysForDisruptedPods = append(keysForDisruptedPods, string(k))
489 }
490 github_com_gogo_protobuf_sortkeys.Strings(keysForDisruptedPods)
491 for _, k := range keysForDisruptedPods {
492 dAtA[i] = 0x12
493 i++
494 v := m.DisruptedPods[string(k)]
495 msgSize := 0
496 if (&v) != nil {
497 msgSize = (&v).Size()
498 msgSize += 1 + sovGenerated(uint64(msgSize))
499 }
500 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
501 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
502 dAtA[i] = 0xa
503 i++
504 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
505 i += copy(dAtA[i:], k)
506 dAtA[i] = 0x12
507 i++
508 i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
509 n10, err := (&v).MarshalTo(dAtA[i:])
510 if err != nil {
511 return 0, err
512 }
513 i += n10
514 }
515 }
516 dAtA[i] = 0x18
517 i++
518 i = encodeVarintGenerated(dAtA, i, uint64(m.PodDisruptionsAllowed))
519 dAtA[i] = 0x20
520 i++
521 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentHealthy))
522 dAtA[i] = 0x28
523 i++
524 i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredHealthy))
525 dAtA[i] = 0x30
526 i++
527 i = encodeVarintGenerated(dAtA, i, uint64(m.ExpectedPods))
528 return i, nil
529}
530
531func (m *PodSecurityPolicy) Marshal() (dAtA []byte, err error) {
532 size := m.Size()
533 dAtA = make([]byte, size)
534 n, err := m.MarshalTo(dAtA)
535 if err != nil {
536 return nil, err
537 }
538 return dAtA[:n], nil
539}
540
541func (m *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) {
542 var i int
543 _ = i
544 var l int
545 _ = l
546 dAtA[i] = 0xa
547 i++
548 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
549 n11, err := m.ObjectMeta.MarshalTo(dAtA[i:])
550 if err != nil {
551 return 0, err
552 }
553 i += n11
554 dAtA[i] = 0x12
555 i++
556 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
557 n12, err := m.Spec.MarshalTo(dAtA[i:])
558 if err != nil {
559 return 0, err
560 }
561 i += n12
562 return i, nil
563}
564
565func (m *PodSecurityPolicyList) Marshal() (dAtA []byte, err error) {
566 size := m.Size()
567 dAtA = make([]byte, size)
568 n, err := m.MarshalTo(dAtA)
569 if err != nil {
570 return nil, err
571 }
572 return dAtA[:n], nil
573}
574
575func (m *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) {
576 var i int
577 _ = i
578 var l int
579 _ = l
580 dAtA[i] = 0xa
581 i++
582 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
583 n13, err := m.ListMeta.MarshalTo(dAtA[i:])
584 if err != nil {
585 return 0, err
586 }
587 i += n13
588 if len(m.Items) > 0 {
589 for _, msg := range m.Items {
590 dAtA[i] = 0x12
591 i++
592 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
593 n, err := msg.MarshalTo(dAtA[i:])
594 if err != nil {
595 return 0, err
596 }
597 i += n
598 }
599 }
600 return i, nil
601}
602
603func (m *PodSecurityPolicySpec) Marshal() (dAtA []byte, err error) {
604 size := m.Size()
605 dAtA = make([]byte, size)
606 n, err := m.MarshalTo(dAtA)
607 if err != nil {
608 return nil, err
609 }
610 return dAtA[:n], nil
611}
612
613func (m *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) {
614 var i int
615 _ = i
616 var l int
617 _ = l
618 dAtA[i] = 0x8
619 i++
620 if m.Privileged {
621 dAtA[i] = 1
622 } else {
623 dAtA[i] = 0
624 }
625 i++
626 if len(m.DefaultAddCapabilities) > 0 {
627 for _, s := range m.DefaultAddCapabilities {
628 dAtA[i] = 0x12
629 i++
630 l = len(s)
631 for l >= 1<<7 {
632 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
633 l >>= 7
634 i++
635 }
636 dAtA[i] = uint8(l)
637 i++
638 i += copy(dAtA[i:], s)
639 }
640 }
641 if len(m.RequiredDropCapabilities) > 0 {
642 for _, s := range m.RequiredDropCapabilities {
643 dAtA[i] = 0x1a
644 i++
645 l = len(s)
646 for l >= 1<<7 {
647 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
648 l >>= 7
649 i++
650 }
651 dAtA[i] = uint8(l)
652 i++
653 i += copy(dAtA[i:], s)
654 }
655 }
656 if len(m.AllowedCapabilities) > 0 {
657 for _, s := range m.AllowedCapabilities {
658 dAtA[i] = 0x22
659 i++
660 l = len(s)
661 for l >= 1<<7 {
662 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
663 l >>= 7
664 i++
665 }
666 dAtA[i] = uint8(l)
667 i++
668 i += copy(dAtA[i:], s)
669 }
670 }
671 if len(m.Volumes) > 0 {
672 for _, s := range m.Volumes {
673 dAtA[i] = 0x2a
674 i++
675 l = len(s)
676 for l >= 1<<7 {
677 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
678 l >>= 7
679 i++
680 }
681 dAtA[i] = uint8(l)
682 i++
683 i += copy(dAtA[i:], s)
684 }
685 }
686 dAtA[i] = 0x30
687 i++
688 if m.HostNetwork {
689 dAtA[i] = 1
690 } else {
691 dAtA[i] = 0
692 }
693 i++
694 if len(m.HostPorts) > 0 {
695 for _, msg := range m.HostPorts {
696 dAtA[i] = 0x3a
697 i++
698 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
699 n, err := msg.MarshalTo(dAtA[i:])
700 if err != nil {
701 return 0, err
702 }
703 i += n
704 }
705 }
706 dAtA[i] = 0x40
707 i++
708 if m.HostPID {
709 dAtA[i] = 1
710 } else {
711 dAtA[i] = 0
712 }
713 i++
714 dAtA[i] = 0x48
715 i++
716 if m.HostIPC {
717 dAtA[i] = 1
718 } else {
719 dAtA[i] = 0
720 }
721 i++
722 dAtA[i] = 0x52
723 i++
724 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinux.Size()))
725 n14, err := m.SELinux.MarshalTo(dAtA[i:])
726 if err != nil {
727 return 0, err
728 }
729 i += n14
730 dAtA[i] = 0x5a
731 i++
732 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsUser.Size()))
733 n15, err := m.RunAsUser.MarshalTo(dAtA[i:])
734 if err != nil {
735 return 0, err
736 }
737 i += n15
738 dAtA[i] = 0x62
739 i++
740 i = encodeVarintGenerated(dAtA, i, uint64(m.SupplementalGroups.Size()))
741 n16, err := m.SupplementalGroups.MarshalTo(dAtA[i:])
742 if err != nil {
743 return 0, err
744 }
745 i += n16
746 dAtA[i] = 0x6a
747 i++
748 i = encodeVarintGenerated(dAtA, i, uint64(m.FSGroup.Size()))
749 n17, err := m.FSGroup.MarshalTo(dAtA[i:])
750 if err != nil {
751 return 0, err
752 }
753 i += n17
754 dAtA[i] = 0x70
755 i++
756 if m.ReadOnlyRootFilesystem {
757 dAtA[i] = 1
758 } else {
759 dAtA[i] = 0
760 }
761 i++
762 if m.DefaultAllowPrivilegeEscalation != nil {
763 dAtA[i] = 0x78
764 i++
765 if *m.DefaultAllowPrivilegeEscalation {
766 dAtA[i] = 1
767 } else {
768 dAtA[i] = 0
769 }
770 i++
771 }
772 if m.AllowPrivilegeEscalation != nil {
773 dAtA[i] = 0x80
774 i++
775 dAtA[i] = 0x1
776 i++
777 if *m.AllowPrivilegeEscalation {
778 dAtA[i] = 1
779 } else {
780 dAtA[i] = 0
781 }
782 i++
783 }
784 if len(m.AllowedHostPaths) > 0 {
785 for _, msg := range m.AllowedHostPaths {
786 dAtA[i] = 0x8a
787 i++
788 dAtA[i] = 0x1
789 i++
790 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
791 n, err := msg.MarshalTo(dAtA[i:])
792 if err != nil {
793 return 0, err
794 }
795 i += n
796 }
797 }
798 if len(m.AllowedFlexVolumes) > 0 {
799 for _, msg := range m.AllowedFlexVolumes {
800 dAtA[i] = 0x92
801 i++
802 dAtA[i] = 0x1
803 i++
804 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
805 n, err := msg.MarshalTo(dAtA[i:])
806 if err != nil {
807 return 0, err
808 }
809 i += n
810 }
811 }
812 if len(m.AllowedUnsafeSysctls) > 0 {
813 for _, s := range m.AllowedUnsafeSysctls {
814 dAtA[i] = 0x9a
815 i++
816 dAtA[i] = 0x1
817 i++
818 l = len(s)
819 for l >= 1<<7 {
820 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
821 l >>= 7
822 i++
823 }
824 dAtA[i] = uint8(l)
825 i++
826 i += copy(dAtA[i:], s)
827 }
828 }
829 if len(m.ForbiddenSysctls) > 0 {
830 for _, s := range m.ForbiddenSysctls {
831 dAtA[i] = 0xa2
832 i++
833 dAtA[i] = 0x1
834 i++
835 l = len(s)
836 for l >= 1<<7 {
837 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
838 l >>= 7
839 i++
840 }
841 dAtA[i] = uint8(l)
842 i++
843 i += copy(dAtA[i:], s)
844 }
845 }
846 if len(m.AllowedProcMountTypes) > 0 {
847 for _, s := range m.AllowedProcMountTypes {
848 dAtA[i] = 0xaa
849 i++
850 dAtA[i] = 0x1
851 i++
852 l = len(s)
853 for l >= 1<<7 {
854 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
855 l >>= 7
856 i++
857 }
858 dAtA[i] = uint8(l)
859 i++
860 i += copy(dAtA[i:], s)
861 }
862 }
863 if m.RunAsGroup != nil {
864 dAtA[i] = 0xb2
865 i++
866 dAtA[i] = 0x1
867 i++
868 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsGroup.Size()))
869 n18, err := m.RunAsGroup.MarshalTo(dAtA[i:])
870 if err != nil {
871 return 0, err
872 }
873 i += n18
874 }
875 return i, nil
876}
877
878func (m *RunAsGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
879 size := m.Size()
880 dAtA = make([]byte, size)
881 n, err := m.MarshalTo(dAtA)
882 if err != nil {
883 return nil, err
884 }
885 return dAtA[:n], nil
886}
887
888func (m *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
889 var i int
890 _ = i
891 var l int
892 _ = l
893 dAtA[i] = 0xa
894 i++
895 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
896 i += copy(dAtA[i:], m.Rule)
897 if len(m.Ranges) > 0 {
898 for _, msg := range m.Ranges {
899 dAtA[i] = 0x12
900 i++
901 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
902 n, err := msg.MarshalTo(dAtA[i:])
903 if err != nil {
904 return 0, err
905 }
906 i += n
907 }
908 }
909 return i, nil
910}
911
912func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) {
913 size := m.Size()
914 dAtA = make([]byte, size)
915 n, err := m.MarshalTo(dAtA)
916 if err != nil {
917 return nil, err
918 }
919 return dAtA[:n], nil
920}
921
922func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
923 var i int
924 _ = i
925 var l int
926 _ = l
927 dAtA[i] = 0xa
928 i++
929 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
930 i += copy(dAtA[i:], m.Rule)
931 if len(m.Ranges) > 0 {
932 for _, msg := range m.Ranges {
933 dAtA[i] = 0x12
934 i++
935 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
936 n, err := msg.MarshalTo(dAtA[i:])
937 if err != nil {
938 return 0, err
939 }
940 i += n
941 }
942 }
943 return i, nil
944}
945
946func (m *SELinuxStrategyOptions) Marshal() (dAtA []byte, err error) {
947 size := m.Size()
948 dAtA = make([]byte, size)
949 n, err := m.MarshalTo(dAtA)
950 if err != nil {
951 return nil, err
952 }
953 return dAtA[:n], nil
954}
955
956func (m *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
957 var i int
958 _ = i
959 var l int
960 _ = l
961 dAtA[i] = 0xa
962 i++
963 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
964 i += copy(dAtA[i:], m.Rule)
965 if m.SELinuxOptions != nil {
966 dAtA[i] = 0x12
967 i++
968 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinuxOptions.Size()))
969 n19, err := m.SELinuxOptions.MarshalTo(dAtA[i:])
970 if err != nil {
971 return 0, err
972 }
973 i += n19
974 }
975 return i, nil
976}
977
978func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) {
979 size := m.Size()
980 dAtA = make([]byte, size)
981 n, err := m.MarshalTo(dAtA)
982 if err != nil {
983 return nil, err
984 }
985 return dAtA[:n], nil
986}
987
988func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
989 var i int
990 _ = i
991 var l int
992 _ = l
993 dAtA[i] = 0xa
994 i++
995 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
996 i += copy(dAtA[i:], m.Rule)
997 if len(m.Ranges) > 0 {
998 for _, msg := range m.Ranges {
999 dAtA[i] = 0x12
1000 i++
1001 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1002 n, err := msg.MarshalTo(dAtA[i:])
1003 if err != nil {
1004 return 0, err
1005 }
1006 i += n
1007 }
1008 }
1009 return i, nil
1010}
1011
1012func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1013 for v >= 1<<7 {
1014 dAtA[offset] = uint8(v&0x7f | 0x80)
1015 v >>= 7
1016 offset++
1017 }
1018 dAtA[offset] = uint8(v)
1019 return offset + 1
1020}
1021func (m *AllowedFlexVolume) Size() (n int) {
1022 var l int
1023 _ = l
1024 l = len(m.Driver)
1025 n += 1 + l + sovGenerated(uint64(l))
1026 return n
1027}
1028
1029func (m *AllowedHostPath) Size() (n int) {
1030 var l int
1031 _ = l
1032 l = len(m.PathPrefix)
1033 n += 1 + l + sovGenerated(uint64(l))
1034 n += 2
1035 return n
1036}
1037
1038func (m *Eviction) Size() (n int) {
1039 var l int
1040 _ = l
1041 l = m.ObjectMeta.Size()
1042 n += 1 + l + sovGenerated(uint64(l))
1043 if m.DeleteOptions != nil {
1044 l = m.DeleteOptions.Size()
1045 n += 1 + l + sovGenerated(uint64(l))
1046 }
1047 return n
1048}
1049
1050func (m *FSGroupStrategyOptions) Size() (n int) {
1051 var l int
1052 _ = l
1053 l = len(m.Rule)
1054 n += 1 + l + sovGenerated(uint64(l))
1055 if len(m.Ranges) > 0 {
1056 for _, e := range m.Ranges {
1057 l = e.Size()
1058 n += 1 + l + sovGenerated(uint64(l))
1059 }
1060 }
1061 return n
1062}
1063
1064func (m *HostPortRange) Size() (n int) {
1065 var l int
1066 _ = l
1067 n += 1 + sovGenerated(uint64(m.Min))
1068 n += 1 + sovGenerated(uint64(m.Max))
1069 return n
1070}
1071
1072func (m *IDRange) Size() (n int) {
1073 var l int
1074 _ = l
1075 n += 1 + sovGenerated(uint64(m.Min))
1076 n += 1 + sovGenerated(uint64(m.Max))
1077 return n
1078}
1079
1080func (m *PodDisruptionBudget) Size() (n int) {
1081 var l int
1082 _ = l
1083 l = m.ObjectMeta.Size()
1084 n += 1 + l + sovGenerated(uint64(l))
1085 l = m.Spec.Size()
1086 n += 1 + l + sovGenerated(uint64(l))
1087 l = m.Status.Size()
1088 n += 1 + l + sovGenerated(uint64(l))
1089 return n
1090}
1091
1092func (m *PodDisruptionBudgetList) Size() (n int) {
1093 var l int
1094 _ = l
1095 l = m.ListMeta.Size()
1096 n += 1 + l + sovGenerated(uint64(l))
1097 if len(m.Items) > 0 {
1098 for _, e := range m.Items {
1099 l = e.Size()
1100 n += 1 + l + sovGenerated(uint64(l))
1101 }
1102 }
1103 return n
1104}
1105
1106func (m *PodDisruptionBudgetSpec) Size() (n int) {
1107 var l int
1108 _ = l
1109 if m.MinAvailable != nil {
1110 l = m.MinAvailable.Size()
1111 n += 1 + l + sovGenerated(uint64(l))
1112 }
1113 if m.Selector != nil {
1114 l = m.Selector.Size()
1115 n += 1 + l + sovGenerated(uint64(l))
1116 }
1117 if m.MaxUnavailable != nil {
1118 l = m.MaxUnavailable.Size()
1119 n += 1 + l + sovGenerated(uint64(l))
1120 }
1121 return n
1122}
1123
1124func (m *PodDisruptionBudgetStatus) Size() (n int) {
1125 var l int
1126 _ = l
1127 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
1128 if len(m.DisruptedPods) > 0 {
1129 for k, v := range m.DisruptedPods {
1130 _ = k
1131 _ = v
1132 l = v.Size()
1133 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
1134 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
1135 }
1136 }
1137 n += 1 + sovGenerated(uint64(m.PodDisruptionsAllowed))
1138 n += 1 + sovGenerated(uint64(m.CurrentHealthy))
1139 n += 1 + sovGenerated(uint64(m.DesiredHealthy))
1140 n += 1 + sovGenerated(uint64(m.ExpectedPods))
1141 return n
1142}
1143
1144func (m *PodSecurityPolicy) Size() (n int) {
1145 var l int
1146 _ = l
1147 l = m.ObjectMeta.Size()
1148 n += 1 + l + sovGenerated(uint64(l))
1149 l = m.Spec.Size()
1150 n += 1 + l + sovGenerated(uint64(l))
1151 return n
1152}
1153
1154func (m *PodSecurityPolicyList) Size() (n int) {
1155 var l int
1156 _ = l
1157 l = m.ListMeta.Size()
1158 n += 1 + l + sovGenerated(uint64(l))
1159 if len(m.Items) > 0 {
1160 for _, e := range m.Items {
1161 l = e.Size()
1162 n += 1 + l + sovGenerated(uint64(l))
1163 }
1164 }
1165 return n
1166}
1167
1168func (m *PodSecurityPolicySpec) Size() (n int) {
1169 var l int
1170 _ = l
1171 n += 2
1172 if len(m.DefaultAddCapabilities) > 0 {
1173 for _, s := range m.DefaultAddCapabilities {
1174 l = len(s)
1175 n += 1 + l + sovGenerated(uint64(l))
1176 }
1177 }
1178 if len(m.RequiredDropCapabilities) > 0 {
1179 for _, s := range m.RequiredDropCapabilities {
1180 l = len(s)
1181 n += 1 + l + sovGenerated(uint64(l))
1182 }
1183 }
1184 if len(m.AllowedCapabilities) > 0 {
1185 for _, s := range m.AllowedCapabilities {
1186 l = len(s)
1187 n += 1 + l + sovGenerated(uint64(l))
1188 }
1189 }
1190 if len(m.Volumes) > 0 {
1191 for _, s := range m.Volumes {
1192 l = len(s)
1193 n += 1 + l + sovGenerated(uint64(l))
1194 }
1195 }
1196 n += 2
1197 if len(m.HostPorts) > 0 {
1198 for _, e := range m.HostPorts {
1199 l = e.Size()
1200 n += 1 + l + sovGenerated(uint64(l))
1201 }
1202 }
1203 n += 2
1204 n += 2
1205 l = m.SELinux.Size()
1206 n += 1 + l + sovGenerated(uint64(l))
1207 l = m.RunAsUser.Size()
1208 n += 1 + l + sovGenerated(uint64(l))
1209 l = m.SupplementalGroups.Size()
1210 n += 1 + l + sovGenerated(uint64(l))
1211 l = m.FSGroup.Size()
1212 n += 1 + l + sovGenerated(uint64(l))
1213 n += 2
1214 if m.DefaultAllowPrivilegeEscalation != nil {
1215 n += 2
1216 }
1217 if m.AllowPrivilegeEscalation != nil {
1218 n += 3
1219 }
1220 if len(m.AllowedHostPaths) > 0 {
1221 for _, e := range m.AllowedHostPaths {
1222 l = e.Size()
1223 n += 2 + l + sovGenerated(uint64(l))
1224 }
1225 }
1226 if len(m.AllowedFlexVolumes) > 0 {
1227 for _, e := range m.AllowedFlexVolumes {
1228 l = e.Size()
1229 n += 2 + l + sovGenerated(uint64(l))
1230 }
1231 }
1232 if len(m.AllowedUnsafeSysctls) > 0 {
1233 for _, s := range m.AllowedUnsafeSysctls {
1234 l = len(s)
1235 n += 2 + l + sovGenerated(uint64(l))
1236 }
1237 }
1238 if len(m.ForbiddenSysctls) > 0 {
1239 for _, s := range m.ForbiddenSysctls {
1240 l = len(s)
1241 n += 2 + l + sovGenerated(uint64(l))
1242 }
1243 }
1244 if len(m.AllowedProcMountTypes) > 0 {
1245 for _, s := range m.AllowedProcMountTypes {
1246 l = len(s)
1247 n += 2 + l + sovGenerated(uint64(l))
1248 }
1249 }
1250 if m.RunAsGroup != nil {
1251 l = m.RunAsGroup.Size()
1252 n += 2 + l + sovGenerated(uint64(l))
1253 }
1254 return n
1255}
1256
1257func (m *RunAsGroupStrategyOptions) Size() (n int) {
1258 var l int
1259 _ = l
1260 l = len(m.Rule)
1261 n += 1 + l + sovGenerated(uint64(l))
1262 if len(m.Ranges) > 0 {
1263 for _, e := range m.Ranges {
1264 l = e.Size()
1265 n += 1 + l + sovGenerated(uint64(l))
1266 }
1267 }
1268 return n
1269}
1270
1271func (m *RunAsUserStrategyOptions) Size() (n int) {
1272 var l int
1273 _ = l
1274 l = len(m.Rule)
1275 n += 1 + l + sovGenerated(uint64(l))
1276 if len(m.Ranges) > 0 {
1277 for _, e := range m.Ranges {
1278 l = e.Size()
1279 n += 1 + l + sovGenerated(uint64(l))
1280 }
1281 }
1282 return n
1283}
1284
1285func (m *SELinuxStrategyOptions) Size() (n int) {
1286 var l int
1287 _ = l
1288 l = len(m.Rule)
1289 n += 1 + l + sovGenerated(uint64(l))
1290 if m.SELinuxOptions != nil {
1291 l = m.SELinuxOptions.Size()
1292 n += 1 + l + sovGenerated(uint64(l))
1293 }
1294 return n
1295}
1296
1297func (m *SupplementalGroupsStrategyOptions) Size() (n int) {
1298 var l int
1299 _ = l
1300 l = len(m.Rule)
1301 n += 1 + l + sovGenerated(uint64(l))
1302 if len(m.Ranges) > 0 {
1303 for _, e := range m.Ranges {
1304 l = e.Size()
1305 n += 1 + l + sovGenerated(uint64(l))
1306 }
1307 }
1308 return n
1309}
1310
1311func sovGenerated(x uint64) (n int) {
1312 for {
1313 n++
1314 x >>= 7
1315 if x == 0 {
1316 break
1317 }
1318 }
1319 return n
1320}
1321func sozGenerated(x uint64) (n int) {
1322 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1323}
1324func (this *AllowedFlexVolume) String() string {
1325 if this == nil {
1326 return "nil"
1327 }
1328 s := strings.Join([]string{`&AllowedFlexVolume{`,
1329 `Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
1330 `}`,
1331 }, "")
1332 return s
1333}
1334func (this *AllowedHostPath) String() string {
1335 if this == nil {
1336 return "nil"
1337 }
1338 s := strings.Join([]string{`&AllowedHostPath{`,
1339 `PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`,
1340 `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
1341 `}`,
1342 }, "")
1343 return s
1344}
1345func (this *Eviction) String() string {
1346 if this == nil {
1347 return "nil"
1348 }
1349 s := strings.Join([]string{`&Eviction{`,
1350 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1351 `DeleteOptions:` + strings.Replace(fmt.Sprintf("%v", this.DeleteOptions), "DeleteOptions", "k8s_io_apimachinery_pkg_apis_meta_v1.DeleteOptions", 1) + `,`,
1352 `}`,
1353 }, "")
1354 return s
1355}
1356func (this *FSGroupStrategyOptions) String() string {
1357 if this == nil {
1358 return "nil"
1359 }
1360 s := strings.Join([]string{`&FSGroupStrategyOptions{`,
1361 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
1362 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
1363 `}`,
1364 }, "")
1365 return s
1366}
1367func (this *HostPortRange) String() string {
1368 if this == nil {
1369 return "nil"
1370 }
1371 s := strings.Join([]string{`&HostPortRange{`,
1372 `Min:` + fmt.Sprintf("%v", this.Min) + `,`,
1373 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
1374 `}`,
1375 }, "")
1376 return s
1377}
1378func (this *IDRange) String() string {
1379 if this == nil {
1380 return "nil"
1381 }
1382 s := strings.Join([]string{`&IDRange{`,
1383 `Min:` + fmt.Sprintf("%v", this.Min) + `,`,
1384 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
1385 `}`,
1386 }, "")
1387 return s
1388}
1389func (this *PodDisruptionBudget) String() string {
1390 if this == nil {
1391 return "nil"
1392 }
1393 s := strings.Join([]string{`&PodDisruptionBudget{`,
1394 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1395 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodDisruptionBudgetSpec", "PodDisruptionBudgetSpec", 1), `&`, ``, 1) + `,`,
1396 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PodDisruptionBudgetStatus", "PodDisruptionBudgetStatus", 1), `&`, ``, 1) + `,`,
1397 `}`,
1398 }, "")
1399 return s
1400}
1401func (this *PodDisruptionBudgetList) String() string {
1402 if this == nil {
1403 return "nil"
1404 }
1405 s := strings.Join([]string{`&PodDisruptionBudgetList{`,
1406 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1407 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodDisruptionBudget", "PodDisruptionBudget", 1), `&`, ``, 1) + `,`,
1408 `}`,
1409 }, "")
1410 return s
1411}
1412func (this *PodDisruptionBudgetSpec) String() string {
1413 if this == nil {
1414 return "nil"
1415 }
1416 s := strings.Join([]string{`&PodDisruptionBudgetSpec{`,
1417 `MinAvailable:` + strings.Replace(fmt.Sprintf("%v", this.MinAvailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
1418 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1419 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
1420 `}`,
1421 }, "")
1422 return s
1423}
1424func (this *PodDisruptionBudgetStatus) String() string {
1425 if this == nil {
1426 return "nil"
1427 }
1428 keysForDisruptedPods := make([]string, 0, len(this.DisruptedPods))
1429 for k := range this.DisruptedPods {
1430 keysForDisruptedPods = append(keysForDisruptedPods, k)
1431 }
1432 github_com_gogo_protobuf_sortkeys.Strings(keysForDisruptedPods)
1433 mapStringForDisruptedPods := "map[string]k8s_io_apimachinery_pkg_apis_meta_v1.Time{"
1434 for _, k := range keysForDisruptedPods {
1435 mapStringForDisruptedPods += fmt.Sprintf("%v: %v,", k, this.DisruptedPods[k])
1436 }
1437 mapStringForDisruptedPods += "}"
1438 s := strings.Join([]string{`&PodDisruptionBudgetStatus{`,
1439 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
1440 `DisruptedPods:` + mapStringForDisruptedPods + `,`,
1441 `PodDisruptionsAllowed:` + fmt.Sprintf("%v", this.PodDisruptionsAllowed) + `,`,
1442 `CurrentHealthy:` + fmt.Sprintf("%v", this.CurrentHealthy) + `,`,
1443 `DesiredHealthy:` + fmt.Sprintf("%v", this.DesiredHealthy) + `,`,
1444 `ExpectedPods:` + fmt.Sprintf("%v", this.ExpectedPods) + `,`,
1445 `}`,
1446 }, "")
1447 return s
1448}
1449func (this *PodSecurityPolicy) String() string {
1450 if this == nil {
1451 return "nil"
1452 }
1453 s := strings.Join([]string{`&PodSecurityPolicy{`,
1454 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1455 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`,
1456 `}`,
1457 }, "")
1458 return s
1459}
1460func (this *PodSecurityPolicyList) String() string {
1461 if this == nil {
1462 return "nil"
1463 }
1464 s := strings.Join([]string{`&PodSecurityPolicyList{`,
1465 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1466 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + `,`,
1467 `}`,
1468 }, "")
1469 return s
1470}
1471func (this *PodSecurityPolicySpec) String() string {
1472 if this == nil {
1473 return "nil"
1474 }
1475 s := strings.Join([]string{`&PodSecurityPolicySpec{`,
1476 `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
1477 `DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`,
1478 `RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`,
1479 `AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`,
1480 `Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`,
1481 `HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`,
1482 `HostPorts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.HostPorts), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + `,`,
1483 `HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`,
1484 `HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`,
1485 `SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`,
1486 `RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`,
1487 `SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`,
1488 `FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`,
1489 `ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`,
1490 `DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`,
1491 `AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`,
1492 `AllowedHostPaths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedHostPaths), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + `,`,
1493 `AllowedFlexVolumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedFlexVolumes), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + `,`,
1494 `AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`,
1495 `ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`,
1496 `AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`,
1497 `RunAsGroup:` + strings.Replace(fmt.Sprintf("%v", this.RunAsGroup), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`,
1498 `}`,
1499 }, "")
1500 return s
1501}
1502func (this *RunAsGroupStrategyOptions) String() string {
1503 if this == nil {
1504 return "nil"
1505 }
1506 s := strings.Join([]string{`&RunAsGroupStrategyOptions{`,
1507 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
1508 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
1509 `}`,
1510 }, "")
1511 return s
1512}
1513func (this *RunAsUserStrategyOptions) String() string {
1514 if this == nil {
1515 return "nil"
1516 }
1517 s := strings.Join([]string{`&RunAsUserStrategyOptions{`,
1518 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
1519 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
1520 `}`,
1521 }, "")
1522 return s
1523}
1524func (this *SELinuxStrategyOptions) String() string {
1525 if this == nil {
1526 return "nil"
1527 }
1528 s := strings.Join([]string{`&SELinuxStrategyOptions{`,
1529 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
1530 `SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "k8s_io_api_core_v1.SELinuxOptions", 1) + `,`,
1531 `}`,
1532 }, "")
1533 return s
1534}
1535func (this *SupplementalGroupsStrategyOptions) String() string {
1536 if this == nil {
1537 return "nil"
1538 }
1539 s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`,
1540 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
1541 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
1542 `}`,
1543 }, "")
1544 return s
1545}
1546func valueToStringGenerated(v interface{}) string {
1547 rv := reflect.ValueOf(v)
1548 if rv.IsNil() {
1549 return "nil"
1550 }
1551 pv := reflect.Indirect(rv).Interface()
1552 return fmt.Sprintf("*%v", pv)
1553}
1554func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error {
1555 l := len(dAtA)
1556 iNdEx := 0
1557 for iNdEx < l {
1558 preIndex := iNdEx
1559 var wire uint64
1560 for shift := uint(0); ; shift += 7 {
1561 if shift >= 64 {
1562 return ErrIntOverflowGenerated
1563 }
1564 if iNdEx >= l {
1565 return io.ErrUnexpectedEOF
1566 }
1567 b := dAtA[iNdEx]
1568 iNdEx++
1569 wire |= (uint64(b) & 0x7F) << shift
1570 if b < 0x80 {
1571 break
1572 }
1573 }
1574 fieldNum := int32(wire >> 3)
1575 wireType := int(wire & 0x7)
1576 if wireType == 4 {
1577 return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group")
1578 }
1579 if fieldNum <= 0 {
1580 return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire)
1581 }
1582 switch fieldNum {
1583 case 1:
1584 if wireType != 2 {
1585 return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
1586 }
1587 var stringLen uint64
1588 for shift := uint(0); ; shift += 7 {
1589 if shift >= 64 {
1590 return ErrIntOverflowGenerated
1591 }
1592 if iNdEx >= l {
1593 return io.ErrUnexpectedEOF
1594 }
1595 b := dAtA[iNdEx]
1596 iNdEx++
1597 stringLen |= (uint64(b) & 0x7F) << shift
1598 if b < 0x80 {
1599 break
1600 }
1601 }
1602 intStringLen := int(stringLen)
1603 if intStringLen < 0 {
1604 return ErrInvalidLengthGenerated
1605 }
1606 postIndex := iNdEx + intStringLen
1607 if postIndex > l {
1608 return io.ErrUnexpectedEOF
1609 }
1610 m.Driver = string(dAtA[iNdEx:postIndex])
1611 iNdEx = postIndex
1612 default:
1613 iNdEx = preIndex
1614 skippy, err := skipGenerated(dAtA[iNdEx:])
1615 if err != nil {
1616 return err
1617 }
1618 if skippy < 0 {
1619 return ErrInvalidLengthGenerated
1620 }
1621 if (iNdEx + skippy) > l {
1622 return io.ErrUnexpectedEOF
1623 }
1624 iNdEx += skippy
1625 }
1626 }
1627
1628 if iNdEx > l {
1629 return io.ErrUnexpectedEOF
1630 }
1631 return nil
1632}
1633func (m *AllowedHostPath) Unmarshal(dAtA []byte) error {
1634 l := len(dAtA)
1635 iNdEx := 0
1636 for iNdEx < l {
1637 preIndex := iNdEx
1638 var wire uint64
1639 for shift := uint(0); ; shift += 7 {
1640 if shift >= 64 {
1641 return ErrIntOverflowGenerated
1642 }
1643 if iNdEx >= l {
1644 return io.ErrUnexpectedEOF
1645 }
1646 b := dAtA[iNdEx]
1647 iNdEx++
1648 wire |= (uint64(b) & 0x7F) << shift
1649 if b < 0x80 {
1650 break
1651 }
1652 }
1653 fieldNum := int32(wire >> 3)
1654 wireType := int(wire & 0x7)
1655 if wireType == 4 {
1656 return fmt.Errorf("proto: AllowedHostPath: wiretype end group for non-group")
1657 }
1658 if fieldNum <= 0 {
1659 return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire)
1660 }
1661 switch fieldNum {
1662 case 1:
1663 if wireType != 2 {
1664 return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType)
1665 }
1666 var stringLen uint64
1667 for shift := uint(0); ; shift += 7 {
1668 if shift >= 64 {
1669 return ErrIntOverflowGenerated
1670 }
1671 if iNdEx >= l {
1672 return io.ErrUnexpectedEOF
1673 }
1674 b := dAtA[iNdEx]
1675 iNdEx++
1676 stringLen |= (uint64(b) & 0x7F) << shift
1677 if b < 0x80 {
1678 break
1679 }
1680 }
1681 intStringLen := int(stringLen)
1682 if intStringLen < 0 {
1683 return ErrInvalidLengthGenerated
1684 }
1685 postIndex := iNdEx + intStringLen
1686 if postIndex > l {
1687 return io.ErrUnexpectedEOF
1688 }
1689 m.PathPrefix = string(dAtA[iNdEx:postIndex])
1690 iNdEx = postIndex
1691 case 2:
1692 if wireType != 0 {
1693 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
1694 }
1695 var v int
1696 for shift := uint(0); ; shift += 7 {
1697 if shift >= 64 {
1698 return ErrIntOverflowGenerated
1699 }
1700 if iNdEx >= l {
1701 return io.ErrUnexpectedEOF
1702 }
1703 b := dAtA[iNdEx]
1704 iNdEx++
1705 v |= (int(b) & 0x7F) << shift
1706 if b < 0x80 {
1707 break
1708 }
1709 }
1710 m.ReadOnly = bool(v != 0)
1711 default:
1712 iNdEx = preIndex
1713 skippy, err := skipGenerated(dAtA[iNdEx:])
1714 if err != nil {
1715 return err
1716 }
1717 if skippy < 0 {
1718 return ErrInvalidLengthGenerated
1719 }
1720 if (iNdEx + skippy) > l {
1721 return io.ErrUnexpectedEOF
1722 }
1723 iNdEx += skippy
1724 }
1725 }
1726
1727 if iNdEx > l {
1728 return io.ErrUnexpectedEOF
1729 }
1730 return nil
1731}
1732func (m *Eviction) Unmarshal(dAtA []byte) error {
1733 l := len(dAtA)
1734 iNdEx := 0
1735 for iNdEx < l {
1736 preIndex := iNdEx
1737 var wire uint64
1738 for shift := uint(0); ; shift += 7 {
1739 if shift >= 64 {
1740 return ErrIntOverflowGenerated
1741 }
1742 if iNdEx >= l {
1743 return io.ErrUnexpectedEOF
1744 }
1745 b := dAtA[iNdEx]
1746 iNdEx++
1747 wire |= (uint64(b) & 0x7F) << shift
1748 if b < 0x80 {
1749 break
1750 }
1751 }
1752 fieldNum := int32(wire >> 3)
1753 wireType := int(wire & 0x7)
1754 if wireType == 4 {
1755 return fmt.Errorf("proto: Eviction: wiretype end group for non-group")
1756 }
1757 if fieldNum <= 0 {
1758 return fmt.Errorf("proto: Eviction: illegal tag %d (wire type %d)", fieldNum, wire)
1759 }
1760 switch fieldNum {
1761 case 1:
1762 if wireType != 2 {
1763 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1764 }
1765 var msglen int
1766 for shift := uint(0); ; shift += 7 {
1767 if shift >= 64 {
1768 return ErrIntOverflowGenerated
1769 }
1770 if iNdEx >= l {
1771 return io.ErrUnexpectedEOF
1772 }
1773 b := dAtA[iNdEx]
1774 iNdEx++
1775 msglen |= (int(b) & 0x7F) << shift
1776 if b < 0x80 {
1777 break
1778 }
1779 }
1780 if msglen < 0 {
1781 return ErrInvalidLengthGenerated
1782 }
1783 postIndex := iNdEx + msglen
1784 if postIndex > l {
1785 return io.ErrUnexpectedEOF
1786 }
1787 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1788 return err
1789 }
1790 iNdEx = postIndex
1791 case 2:
1792 if wireType != 2 {
1793 return fmt.Errorf("proto: wrong wireType = %d for field DeleteOptions", wireType)
1794 }
1795 var msglen int
1796 for shift := uint(0); ; shift += 7 {
1797 if shift >= 64 {
1798 return ErrIntOverflowGenerated
1799 }
1800 if iNdEx >= l {
1801 return io.ErrUnexpectedEOF
1802 }
1803 b := dAtA[iNdEx]
1804 iNdEx++
1805 msglen |= (int(b) & 0x7F) << shift
1806 if b < 0x80 {
1807 break
1808 }
1809 }
1810 if msglen < 0 {
1811 return ErrInvalidLengthGenerated
1812 }
1813 postIndex := iNdEx + msglen
1814 if postIndex > l {
1815 return io.ErrUnexpectedEOF
1816 }
1817 if m.DeleteOptions == nil {
1818 m.DeleteOptions = &k8s_io_apimachinery_pkg_apis_meta_v1.DeleteOptions{}
1819 }
1820 if err := m.DeleteOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1821 return err
1822 }
1823 iNdEx = postIndex
1824 default:
1825 iNdEx = preIndex
1826 skippy, err := skipGenerated(dAtA[iNdEx:])
1827 if err != nil {
1828 return err
1829 }
1830 if skippy < 0 {
1831 return ErrInvalidLengthGenerated
1832 }
1833 if (iNdEx + skippy) > l {
1834 return io.ErrUnexpectedEOF
1835 }
1836 iNdEx += skippy
1837 }
1838 }
1839
1840 if iNdEx > l {
1841 return io.ErrUnexpectedEOF
1842 }
1843 return nil
1844}
1845func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error {
1846 l := len(dAtA)
1847 iNdEx := 0
1848 for iNdEx < l {
1849 preIndex := iNdEx
1850 var wire uint64
1851 for shift := uint(0); ; shift += 7 {
1852 if shift >= 64 {
1853 return ErrIntOverflowGenerated
1854 }
1855 if iNdEx >= l {
1856 return io.ErrUnexpectedEOF
1857 }
1858 b := dAtA[iNdEx]
1859 iNdEx++
1860 wire |= (uint64(b) & 0x7F) << shift
1861 if b < 0x80 {
1862 break
1863 }
1864 }
1865 fieldNum := int32(wire >> 3)
1866 wireType := int(wire & 0x7)
1867 if wireType == 4 {
1868 return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group")
1869 }
1870 if fieldNum <= 0 {
1871 return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
1872 }
1873 switch fieldNum {
1874 case 1:
1875 if wireType != 2 {
1876 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
1877 }
1878 var stringLen uint64
1879 for shift := uint(0); ; shift += 7 {
1880 if shift >= 64 {
1881 return ErrIntOverflowGenerated
1882 }
1883 if iNdEx >= l {
1884 return io.ErrUnexpectedEOF
1885 }
1886 b := dAtA[iNdEx]
1887 iNdEx++
1888 stringLen |= (uint64(b) & 0x7F) << shift
1889 if b < 0x80 {
1890 break
1891 }
1892 }
1893 intStringLen := int(stringLen)
1894 if intStringLen < 0 {
1895 return ErrInvalidLengthGenerated
1896 }
1897 postIndex := iNdEx + intStringLen
1898 if postIndex > l {
1899 return io.ErrUnexpectedEOF
1900 }
1901 m.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex])
1902 iNdEx = postIndex
1903 case 2:
1904 if wireType != 2 {
1905 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
1906 }
1907 var msglen int
1908 for shift := uint(0); ; shift += 7 {
1909 if shift >= 64 {
1910 return ErrIntOverflowGenerated
1911 }
1912 if iNdEx >= l {
1913 return io.ErrUnexpectedEOF
1914 }
1915 b := dAtA[iNdEx]
1916 iNdEx++
1917 msglen |= (int(b) & 0x7F) << shift
1918 if b < 0x80 {
1919 break
1920 }
1921 }
1922 if msglen < 0 {
1923 return ErrInvalidLengthGenerated
1924 }
1925 postIndex := iNdEx + msglen
1926 if postIndex > l {
1927 return io.ErrUnexpectedEOF
1928 }
1929 m.Ranges = append(m.Ranges, IDRange{})
1930 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1931 return err
1932 }
1933 iNdEx = postIndex
1934 default:
1935 iNdEx = preIndex
1936 skippy, err := skipGenerated(dAtA[iNdEx:])
1937 if err != nil {
1938 return err
1939 }
1940 if skippy < 0 {
1941 return ErrInvalidLengthGenerated
1942 }
1943 if (iNdEx + skippy) > l {
1944 return io.ErrUnexpectedEOF
1945 }
1946 iNdEx += skippy
1947 }
1948 }
1949
1950 if iNdEx > l {
1951 return io.ErrUnexpectedEOF
1952 }
1953 return nil
1954}
1955func (m *HostPortRange) Unmarshal(dAtA []byte) error {
1956 l := len(dAtA)
1957 iNdEx := 0
1958 for iNdEx < l {
1959 preIndex := iNdEx
1960 var wire uint64
1961 for shift := uint(0); ; shift += 7 {
1962 if shift >= 64 {
1963 return ErrIntOverflowGenerated
1964 }
1965 if iNdEx >= l {
1966 return io.ErrUnexpectedEOF
1967 }
1968 b := dAtA[iNdEx]
1969 iNdEx++
1970 wire |= (uint64(b) & 0x7F) << shift
1971 if b < 0x80 {
1972 break
1973 }
1974 }
1975 fieldNum := int32(wire >> 3)
1976 wireType := int(wire & 0x7)
1977 if wireType == 4 {
1978 return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group")
1979 }
1980 if fieldNum <= 0 {
1981 return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire)
1982 }
1983 switch fieldNum {
1984 case 1:
1985 if wireType != 0 {
1986 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
1987 }
1988 m.Min = 0
1989 for shift := uint(0); ; shift += 7 {
1990 if shift >= 64 {
1991 return ErrIntOverflowGenerated
1992 }
1993 if iNdEx >= l {
1994 return io.ErrUnexpectedEOF
1995 }
1996 b := dAtA[iNdEx]
1997 iNdEx++
1998 m.Min |= (int32(b) & 0x7F) << shift
1999 if b < 0x80 {
2000 break
2001 }
2002 }
2003 case 2:
2004 if wireType != 0 {
2005 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
2006 }
2007 m.Max = 0
2008 for shift := uint(0); ; shift += 7 {
2009 if shift >= 64 {
2010 return ErrIntOverflowGenerated
2011 }
2012 if iNdEx >= l {
2013 return io.ErrUnexpectedEOF
2014 }
2015 b := dAtA[iNdEx]
2016 iNdEx++
2017 m.Max |= (int32(b) & 0x7F) << shift
2018 if b < 0x80 {
2019 break
2020 }
2021 }
2022 default:
2023 iNdEx = preIndex
2024 skippy, err := skipGenerated(dAtA[iNdEx:])
2025 if err != nil {
2026 return err
2027 }
2028 if skippy < 0 {
2029 return ErrInvalidLengthGenerated
2030 }
2031 if (iNdEx + skippy) > l {
2032 return io.ErrUnexpectedEOF
2033 }
2034 iNdEx += skippy
2035 }
2036 }
2037
2038 if iNdEx > l {
2039 return io.ErrUnexpectedEOF
2040 }
2041 return nil
2042}
2043func (m *IDRange) Unmarshal(dAtA []byte) error {
2044 l := len(dAtA)
2045 iNdEx := 0
2046 for iNdEx < l {
2047 preIndex := iNdEx
2048 var wire uint64
2049 for shift := uint(0); ; shift += 7 {
2050 if shift >= 64 {
2051 return ErrIntOverflowGenerated
2052 }
2053 if iNdEx >= l {
2054 return io.ErrUnexpectedEOF
2055 }
2056 b := dAtA[iNdEx]
2057 iNdEx++
2058 wire |= (uint64(b) & 0x7F) << shift
2059 if b < 0x80 {
2060 break
2061 }
2062 }
2063 fieldNum := int32(wire >> 3)
2064 wireType := int(wire & 0x7)
2065 if wireType == 4 {
2066 return fmt.Errorf("proto: IDRange: wiretype end group for non-group")
2067 }
2068 if fieldNum <= 0 {
2069 return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire)
2070 }
2071 switch fieldNum {
2072 case 1:
2073 if wireType != 0 {
2074 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
2075 }
2076 m.Min = 0
2077 for shift := uint(0); ; shift += 7 {
2078 if shift >= 64 {
2079 return ErrIntOverflowGenerated
2080 }
2081 if iNdEx >= l {
2082 return io.ErrUnexpectedEOF
2083 }
2084 b := dAtA[iNdEx]
2085 iNdEx++
2086 m.Min |= (int64(b) & 0x7F) << shift
2087 if b < 0x80 {
2088 break
2089 }
2090 }
2091 case 2:
2092 if wireType != 0 {
2093 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
2094 }
2095 m.Max = 0
2096 for shift := uint(0); ; shift += 7 {
2097 if shift >= 64 {
2098 return ErrIntOverflowGenerated
2099 }
2100 if iNdEx >= l {
2101 return io.ErrUnexpectedEOF
2102 }
2103 b := dAtA[iNdEx]
2104 iNdEx++
2105 m.Max |= (int64(b) & 0x7F) << shift
2106 if b < 0x80 {
2107 break
2108 }
2109 }
2110 default:
2111 iNdEx = preIndex
2112 skippy, err := skipGenerated(dAtA[iNdEx:])
2113 if err != nil {
2114 return err
2115 }
2116 if skippy < 0 {
2117 return ErrInvalidLengthGenerated
2118 }
2119 if (iNdEx + skippy) > l {
2120 return io.ErrUnexpectedEOF
2121 }
2122 iNdEx += skippy
2123 }
2124 }
2125
2126 if iNdEx > l {
2127 return io.ErrUnexpectedEOF
2128 }
2129 return nil
2130}
2131func (m *PodDisruptionBudget) Unmarshal(dAtA []byte) error {
2132 l := len(dAtA)
2133 iNdEx := 0
2134 for iNdEx < l {
2135 preIndex := iNdEx
2136 var wire uint64
2137 for shift := uint(0); ; shift += 7 {
2138 if shift >= 64 {
2139 return ErrIntOverflowGenerated
2140 }
2141 if iNdEx >= l {
2142 return io.ErrUnexpectedEOF
2143 }
2144 b := dAtA[iNdEx]
2145 iNdEx++
2146 wire |= (uint64(b) & 0x7F) << shift
2147 if b < 0x80 {
2148 break
2149 }
2150 }
2151 fieldNum := int32(wire >> 3)
2152 wireType := int(wire & 0x7)
2153 if wireType == 4 {
2154 return fmt.Errorf("proto: PodDisruptionBudget: wiretype end group for non-group")
2155 }
2156 if fieldNum <= 0 {
2157 return fmt.Errorf("proto: PodDisruptionBudget: illegal tag %d (wire type %d)", fieldNum, wire)
2158 }
2159 switch fieldNum {
2160 case 1:
2161 if wireType != 2 {
2162 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2163 }
2164 var msglen int
2165 for shift := uint(0); ; shift += 7 {
2166 if shift >= 64 {
2167 return ErrIntOverflowGenerated
2168 }
2169 if iNdEx >= l {
2170 return io.ErrUnexpectedEOF
2171 }
2172 b := dAtA[iNdEx]
2173 iNdEx++
2174 msglen |= (int(b) & 0x7F) << shift
2175 if b < 0x80 {
2176 break
2177 }
2178 }
2179 if msglen < 0 {
2180 return ErrInvalidLengthGenerated
2181 }
2182 postIndex := iNdEx + msglen
2183 if postIndex > l {
2184 return io.ErrUnexpectedEOF
2185 }
2186 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2187 return err
2188 }
2189 iNdEx = postIndex
2190 case 2:
2191 if wireType != 2 {
2192 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2193 }
2194 var msglen int
2195 for shift := uint(0); ; shift += 7 {
2196 if shift >= 64 {
2197 return ErrIntOverflowGenerated
2198 }
2199 if iNdEx >= l {
2200 return io.ErrUnexpectedEOF
2201 }
2202 b := dAtA[iNdEx]
2203 iNdEx++
2204 msglen |= (int(b) & 0x7F) << shift
2205 if b < 0x80 {
2206 break
2207 }
2208 }
2209 if msglen < 0 {
2210 return ErrInvalidLengthGenerated
2211 }
2212 postIndex := iNdEx + msglen
2213 if postIndex > l {
2214 return io.ErrUnexpectedEOF
2215 }
2216 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2217 return err
2218 }
2219 iNdEx = postIndex
2220 case 3:
2221 if wireType != 2 {
2222 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2223 }
2224 var msglen int
2225 for shift := uint(0); ; shift += 7 {
2226 if shift >= 64 {
2227 return ErrIntOverflowGenerated
2228 }
2229 if iNdEx >= l {
2230 return io.ErrUnexpectedEOF
2231 }
2232 b := dAtA[iNdEx]
2233 iNdEx++
2234 msglen |= (int(b) & 0x7F) << shift
2235 if b < 0x80 {
2236 break
2237 }
2238 }
2239 if msglen < 0 {
2240 return ErrInvalidLengthGenerated
2241 }
2242 postIndex := iNdEx + msglen
2243 if postIndex > l {
2244 return io.ErrUnexpectedEOF
2245 }
2246 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2247 return err
2248 }
2249 iNdEx = postIndex
2250 default:
2251 iNdEx = preIndex
2252 skippy, err := skipGenerated(dAtA[iNdEx:])
2253 if err != nil {
2254 return err
2255 }
2256 if skippy < 0 {
2257 return ErrInvalidLengthGenerated
2258 }
2259 if (iNdEx + skippy) > l {
2260 return io.ErrUnexpectedEOF
2261 }
2262 iNdEx += skippy
2263 }
2264 }
2265
2266 if iNdEx > l {
2267 return io.ErrUnexpectedEOF
2268 }
2269 return nil
2270}
2271func (m *PodDisruptionBudgetList) Unmarshal(dAtA []byte) error {
2272 l := len(dAtA)
2273 iNdEx := 0
2274 for iNdEx < l {
2275 preIndex := iNdEx
2276 var wire uint64
2277 for shift := uint(0); ; shift += 7 {
2278 if shift >= 64 {
2279 return ErrIntOverflowGenerated
2280 }
2281 if iNdEx >= l {
2282 return io.ErrUnexpectedEOF
2283 }
2284 b := dAtA[iNdEx]
2285 iNdEx++
2286 wire |= (uint64(b) & 0x7F) << shift
2287 if b < 0x80 {
2288 break
2289 }
2290 }
2291 fieldNum := int32(wire >> 3)
2292 wireType := int(wire & 0x7)
2293 if wireType == 4 {
2294 return fmt.Errorf("proto: PodDisruptionBudgetList: wiretype end group for non-group")
2295 }
2296 if fieldNum <= 0 {
2297 return fmt.Errorf("proto: PodDisruptionBudgetList: illegal tag %d (wire type %d)", fieldNum, wire)
2298 }
2299 switch fieldNum {
2300 case 1:
2301 if wireType != 2 {
2302 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2303 }
2304 var msglen int
2305 for shift := uint(0); ; shift += 7 {
2306 if shift >= 64 {
2307 return ErrIntOverflowGenerated
2308 }
2309 if iNdEx >= l {
2310 return io.ErrUnexpectedEOF
2311 }
2312 b := dAtA[iNdEx]
2313 iNdEx++
2314 msglen |= (int(b) & 0x7F) << shift
2315 if b < 0x80 {
2316 break
2317 }
2318 }
2319 if msglen < 0 {
2320 return ErrInvalidLengthGenerated
2321 }
2322 postIndex := iNdEx + msglen
2323 if postIndex > l {
2324 return io.ErrUnexpectedEOF
2325 }
2326 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2327 return err
2328 }
2329 iNdEx = postIndex
2330 case 2:
2331 if wireType != 2 {
2332 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2333 }
2334 var msglen int
2335 for shift := uint(0); ; shift += 7 {
2336 if shift >= 64 {
2337 return ErrIntOverflowGenerated
2338 }
2339 if iNdEx >= l {
2340 return io.ErrUnexpectedEOF
2341 }
2342 b := dAtA[iNdEx]
2343 iNdEx++
2344 msglen |= (int(b) & 0x7F) << shift
2345 if b < 0x80 {
2346 break
2347 }
2348 }
2349 if msglen < 0 {
2350 return ErrInvalidLengthGenerated
2351 }
2352 postIndex := iNdEx + msglen
2353 if postIndex > l {
2354 return io.ErrUnexpectedEOF
2355 }
2356 m.Items = append(m.Items, PodDisruptionBudget{})
2357 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2358 return err
2359 }
2360 iNdEx = postIndex
2361 default:
2362 iNdEx = preIndex
2363 skippy, err := skipGenerated(dAtA[iNdEx:])
2364 if err != nil {
2365 return err
2366 }
2367 if skippy < 0 {
2368 return ErrInvalidLengthGenerated
2369 }
2370 if (iNdEx + skippy) > l {
2371 return io.ErrUnexpectedEOF
2372 }
2373 iNdEx += skippy
2374 }
2375 }
2376
2377 if iNdEx > l {
2378 return io.ErrUnexpectedEOF
2379 }
2380 return nil
2381}
2382func (m *PodDisruptionBudgetSpec) Unmarshal(dAtA []byte) error {
2383 l := len(dAtA)
2384 iNdEx := 0
2385 for iNdEx < l {
2386 preIndex := iNdEx
2387 var wire uint64
2388 for shift := uint(0); ; shift += 7 {
2389 if shift >= 64 {
2390 return ErrIntOverflowGenerated
2391 }
2392 if iNdEx >= l {
2393 return io.ErrUnexpectedEOF
2394 }
2395 b := dAtA[iNdEx]
2396 iNdEx++
2397 wire |= (uint64(b) & 0x7F) << shift
2398 if b < 0x80 {
2399 break
2400 }
2401 }
2402 fieldNum := int32(wire >> 3)
2403 wireType := int(wire & 0x7)
2404 if wireType == 4 {
2405 return fmt.Errorf("proto: PodDisruptionBudgetSpec: wiretype end group for non-group")
2406 }
2407 if fieldNum <= 0 {
2408 return fmt.Errorf("proto: PodDisruptionBudgetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2409 }
2410 switch fieldNum {
2411 case 1:
2412 if wireType != 2 {
2413 return fmt.Errorf("proto: wrong wireType = %d for field MinAvailable", wireType)
2414 }
2415 var msglen int
2416 for shift := uint(0); ; shift += 7 {
2417 if shift >= 64 {
2418 return ErrIntOverflowGenerated
2419 }
2420 if iNdEx >= l {
2421 return io.ErrUnexpectedEOF
2422 }
2423 b := dAtA[iNdEx]
2424 iNdEx++
2425 msglen |= (int(b) & 0x7F) << shift
2426 if b < 0x80 {
2427 break
2428 }
2429 }
2430 if msglen < 0 {
2431 return ErrInvalidLengthGenerated
2432 }
2433 postIndex := iNdEx + msglen
2434 if postIndex > l {
2435 return io.ErrUnexpectedEOF
2436 }
2437 if m.MinAvailable == nil {
2438 m.MinAvailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
2439 }
2440 if err := m.MinAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2441 return err
2442 }
2443 iNdEx = postIndex
2444 case 2:
2445 if wireType != 2 {
2446 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
2447 }
2448 var msglen int
2449 for shift := uint(0); ; shift += 7 {
2450 if shift >= 64 {
2451 return ErrIntOverflowGenerated
2452 }
2453 if iNdEx >= l {
2454 return io.ErrUnexpectedEOF
2455 }
2456 b := dAtA[iNdEx]
2457 iNdEx++
2458 msglen |= (int(b) & 0x7F) << shift
2459 if b < 0x80 {
2460 break
2461 }
2462 }
2463 if msglen < 0 {
2464 return ErrInvalidLengthGenerated
2465 }
2466 postIndex := iNdEx + msglen
2467 if postIndex > l {
2468 return io.ErrUnexpectedEOF
2469 }
2470 if m.Selector == nil {
2471 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
2472 }
2473 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2474 return err
2475 }
2476 iNdEx = postIndex
2477 case 3:
2478 if wireType != 2 {
2479 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
2480 }
2481 var msglen int
2482 for shift := uint(0); ; shift += 7 {
2483 if shift >= 64 {
2484 return ErrIntOverflowGenerated
2485 }
2486 if iNdEx >= l {
2487 return io.ErrUnexpectedEOF
2488 }
2489 b := dAtA[iNdEx]
2490 iNdEx++
2491 msglen |= (int(b) & 0x7F) << shift
2492 if b < 0x80 {
2493 break
2494 }
2495 }
2496 if msglen < 0 {
2497 return ErrInvalidLengthGenerated
2498 }
2499 postIndex := iNdEx + msglen
2500 if postIndex > l {
2501 return io.ErrUnexpectedEOF
2502 }
2503 if m.MaxUnavailable == nil {
2504 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
2505 }
2506 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2507 return err
2508 }
2509 iNdEx = postIndex
2510 default:
2511 iNdEx = preIndex
2512 skippy, err := skipGenerated(dAtA[iNdEx:])
2513 if err != nil {
2514 return err
2515 }
2516 if skippy < 0 {
2517 return ErrInvalidLengthGenerated
2518 }
2519 if (iNdEx + skippy) > l {
2520 return io.ErrUnexpectedEOF
2521 }
2522 iNdEx += skippy
2523 }
2524 }
2525
2526 if iNdEx > l {
2527 return io.ErrUnexpectedEOF
2528 }
2529 return nil
2530}
2531func (m *PodDisruptionBudgetStatus) Unmarshal(dAtA []byte) error {
2532 l := len(dAtA)
2533 iNdEx := 0
2534 for iNdEx < l {
2535 preIndex := iNdEx
2536 var wire uint64
2537 for shift := uint(0); ; shift += 7 {
2538 if shift >= 64 {
2539 return ErrIntOverflowGenerated
2540 }
2541 if iNdEx >= l {
2542 return io.ErrUnexpectedEOF
2543 }
2544 b := dAtA[iNdEx]
2545 iNdEx++
2546 wire |= (uint64(b) & 0x7F) << shift
2547 if b < 0x80 {
2548 break
2549 }
2550 }
2551 fieldNum := int32(wire >> 3)
2552 wireType := int(wire & 0x7)
2553 if wireType == 4 {
2554 return fmt.Errorf("proto: PodDisruptionBudgetStatus: wiretype end group for non-group")
2555 }
2556 if fieldNum <= 0 {
2557 return fmt.Errorf("proto: PodDisruptionBudgetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
2558 }
2559 switch fieldNum {
2560 case 1:
2561 if wireType != 0 {
2562 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
2563 }
2564 m.ObservedGeneration = 0
2565 for shift := uint(0); ; shift += 7 {
2566 if shift >= 64 {
2567 return ErrIntOverflowGenerated
2568 }
2569 if iNdEx >= l {
2570 return io.ErrUnexpectedEOF
2571 }
2572 b := dAtA[iNdEx]
2573 iNdEx++
2574 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
2575 if b < 0x80 {
2576 break
2577 }
2578 }
2579 case 2:
2580 if wireType != 2 {
2581 return fmt.Errorf("proto: wrong wireType = %d for field DisruptedPods", wireType)
2582 }
2583 var msglen int
2584 for shift := uint(0); ; shift += 7 {
2585 if shift >= 64 {
2586 return ErrIntOverflowGenerated
2587 }
2588 if iNdEx >= l {
2589 return io.ErrUnexpectedEOF
2590 }
2591 b := dAtA[iNdEx]
2592 iNdEx++
2593 msglen |= (int(b) & 0x7F) << shift
2594 if b < 0x80 {
2595 break
2596 }
2597 }
2598 if msglen < 0 {
2599 return ErrInvalidLengthGenerated
2600 }
2601 postIndex := iNdEx + msglen
2602 if postIndex > l {
2603 return io.ErrUnexpectedEOF
2604 }
2605 if m.DisruptedPods == nil {
2606 m.DisruptedPods = make(map[string]k8s_io_apimachinery_pkg_apis_meta_v1.Time)
2607 }
2608 var mapkey string
2609 mapvalue := &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
2610 for iNdEx < postIndex {
2611 entryPreIndex := iNdEx
2612 var wire uint64
2613 for shift := uint(0); ; shift += 7 {
2614 if shift >= 64 {
2615 return ErrIntOverflowGenerated
2616 }
2617 if iNdEx >= l {
2618 return io.ErrUnexpectedEOF
2619 }
2620 b := dAtA[iNdEx]
2621 iNdEx++
2622 wire |= (uint64(b) & 0x7F) << shift
2623 if b < 0x80 {
2624 break
2625 }
2626 }
2627 fieldNum := int32(wire >> 3)
2628 if fieldNum == 1 {
2629 var stringLenmapkey uint64
2630 for shift := uint(0); ; shift += 7 {
2631 if shift >= 64 {
2632 return ErrIntOverflowGenerated
2633 }
2634 if iNdEx >= l {
2635 return io.ErrUnexpectedEOF
2636 }
2637 b := dAtA[iNdEx]
2638 iNdEx++
2639 stringLenmapkey |= (uint64(b) & 0x7F) << shift
2640 if b < 0x80 {
2641 break
2642 }
2643 }
2644 intStringLenmapkey := int(stringLenmapkey)
2645 if intStringLenmapkey < 0 {
2646 return ErrInvalidLengthGenerated
2647 }
2648 postStringIndexmapkey := iNdEx + intStringLenmapkey
2649 if postStringIndexmapkey > l {
2650 return io.ErrUnexpectedEOF
2651 }
2652 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
2653 iNdEx = postStringIndexmapkey
2654 } else if fieldNum == 2 {
2655 var mapmsglen int
2656 for shift := uint(0); ; shift += 7 {
2657 if shift >= 64 {
2658 return ErrIntOverflowGenerated
2659 }
2660 if iNdEx >= l {
2661 return io.ErrUnexpectedEOF
2662 }
2663 b := dAtA[iNdEx]
2664 iNdEx++
2665 mapmsglen |= (int(b) & 0x7F) << shift
2666 if b < 0x80 {
2667 break
2668 }
2669 }
2670 if mapmsglen < 0 {
2671 return ErrInvalidLengthGenerated
2672 }
2673 postmsgIndex := iNdEx + mapmsglen
2674 if mapmsglen < 0 {
2675 return ErrInvalidLengthGenerated
2676 }
2677 if postmsgIndex > l {
2678 return io.ErrUnexpectedEOF
2679 }
2680 mapvalue = &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
2681 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
2682 return err
2683 }
2684 iNdEx = postmsgIndex
2685 } else {
2686 iNdEx = entryPreIndex
2687 skippy, err := skipGenerated(dAtA[iNdEx:])
2688 if err != nil {
2689 return err
2690 }
2691 if skippy < 0 {
2692 return ErrInvalidLengthGenerated
2693 }
2694 if (iNdEx + skippy) > postIndex {
2695 return io.ErrUnexpectedEOF
2696 }
2697 iNdEx += skippy
2698 }
2699 }
2700 m.DisruptedPods[mapkey] = *mapvalue
2701 iNdEx = postIndex
2702 case 3:
2703 if wireType != 0 {
2704 return fmt.Errorf("proto: wrong wireType = %d for field PodDisruptionsAllowed", wireType)
2705 }
2706 m.PodDisruptionsAllowed = 0
2707 for shift := uint(0); ; shift += 7 {
2708 if shift >= 64 {
2709 return ErrIntOverflowGenerated
2710 }
2711 if iNdEx >= l {
2712 return io.ErrUnexpectedEOF
2713 }
2714 b := dAtA[iNdEx]
2715 iNdEx++
2716 m.PodDisruptionsAllowed |= (int32(b) & 0x7F) << shift
2717 if b < 0x80 {
2718 break
2719 }
2720 }
2721 case 4:
2722 if wireType != 0 {
2723 return fmt.Errorf("proto: wrong wireType = %d for field CurrentHealthy", wireType)
2724 }
2725 m.CurrentHealthy = 0
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 m.CurrentHealthy |= (int32(b) & 0x7F) << shift
2736 if b < 0x80 {
2737 break
2738 }
2739 }
2740 case 5:
2741 if wireType != 0 {
2742 return fmt.Errorf("proto: wrong wireType = %d for field DesiredHealthy", wireType)
2743 }
2744 m.DesiredHealthy = 0
2745 for shift := uint(0); ; shift += 7 {
2746 if shift >= 64 {
2747 return ErrIntOverflowGenerated
2748 }
2749 if iNdEx >= l {
2750 return io.ErrUnexpectedEOF
2751 }
2752 b := dAtA[iNdEx]
2753 iNdEx++
2754 m.DesiredHealthy |= (int32(b) & 0x7F) << shift
2755 if b < 0x80 {
2756 break
2757 }
2758 }
2759 case 6:
2760 if wireType != 0 {
2761 return fmt.Errorf("proto: wrong wireType = %d for field ExpectedPods", wireType)
2762 }
2763 m.ExpectedPods = 0
2764 for shift := uint(0); ; shift += 7 {
2765 if shift >= 64 {
2766 return ErrIntOverflowGenerated
2767 }
2768 if iNdEx >= l {
2769 return io.ErrUnexpectedEOF
2770 }
2771 b := dAtA[iNdEx]
2772 iNdEx++
2773 m.ExpectedPods |= (int32(b) & 0x7F) << shift
2774 if b < 0x80 {
2775 break
2776 }
2777 }
2778 default:
2779 iNdEx = preIndex
2780 skippy, err := skipGenerated(dAtA[iNdEx:])
2781 if err != nil {
2782 return err
2783 }
2784 if skippy < 0 {
2785 return ErrInvalidLengthGenerated
2786 }
2787 if (iNdEx + skippy) > l {
2788 return io.ErrUnexpectedEOF
2789 }
2790 iNdEx += skippy
2791 }
2792 }
2793
2794 if iNdEx > l {
2795 return io.ErrUnexpectedEOF
2796 }
2797 return nil
2798}
2799func (m *PodSecurityPolicy) Unmarshal(dAtA []byte) error {
2800 l := len(dAtA)
2801 iNdEx := 0
2802 for iNdEx < l {
2803 preIndex := iNdEx
2804 var wire uint64
2805 for shift := uint(0); ; shift += 7 {
2806 if shift >= 64 {
2807 return ErrIntOverflowGenerated
2808 }
2809 if iNdEx >= l {
2810 return io.ErrUnexpectedEOF
2811 }
2812 b := dAtA[iNdEx]
2813 iNdEx++
2814 wire |= (uint64(b) & 0x7F) << shift
2815 if b < 0x80 {
2816 break
2817 }
2818 }
2819 fieldNum := int32(wire >> 3)
2820 wireType := int(wire & 0x7)
2821 if wireType == 4 {
2822 return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group")
2823 }
2824 if fieldNum <= 0 {
2825 return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
2826 }
2827 switch fieldNum {
2828 case 1:
2829 if wireType != 2 {
2830 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2831 }
2832 var msglen int
2833 for shift := uint(0); ; shift += 7 {
2834 if shift >= 64 {
2835 return ErrIntOverflowGenerated
2836 }
2837 if iNdEx >= l {
2838 return io.ErrUnexpectedEOF
2839 }
2840 b := dAtA[iNdEx]
2841 iNdEx++
2842 msglen |= (int(b) & 0x7F) << shift
2843 if b < 0x80 {
2844 break
2845 }
2846 }
2847 if msglen < 0 {
2848 return ErrInvalidLengthGenerated
2849 }
2850 postIndex := iNdEx + msglen
2851 if postIndex > l {
2852 return io.ErrUnexpectedEOF
2853 }
2854 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2855 return err
2856 }
2857 iNdEx = postIndex
2858 case 2:
2859 if wireType != 2 {
2860 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2861 }
2862 var msglen int
2863 for shift := uint(0); ; shift += 7 {
2864 if shift >= 64 {
2865 return ErrIntOverflowGenerated
2866 }
2867 if iNdEx >= l {
2868 return io.ErrUnexpectedEOF
2869 }
2870 b := dAtA[iNdEx]
2871 iNdEx++
2872 msglen |= (int(b) & 0x7F) << shift
2873 if b < 0x80 {
2874 break
2875 }
2876 }
2877 if msglen < 0 {
2878 return ErrInvalidLengthGenerated
2879 }
2880 postIndex := iNdEx + msglen
2881 if postIndex > l {
2882 return io.ErrUnexpectedEOF
2883 }
2884 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2885 return err
2886 }
2887 iNdEx = postIndex
2888 default:
2889 iNdEx = preIndex
2890 skippy, err := skipGenerated(dAtA[iNdEx:])
2891 if err != nil {
2892 return err
2893 }
2894 if skippy < 0 {
2895 return ErrInvalidLengthGenerated
2896 }
2897 if (iNdEx + skippy) > l {
2898 return io.ErrUnexpectedEOF
2899 }
2900 iNdEx += skippy
2901 }
2902 }
2903
2904 if iNdEx > l {
2905 return io.ErrUnexpectedEOF
2906 }
2907 return nil
2908}
2909func (m *PodSecurityPolicyList) Unmarshal(dAtA []byte) error {
2910 l := len(dAtA)
2911 iNdEx := 0
2912 for iNdEx < l {
2913 preIndex := iNdEx
2914 var wire uint64
2915 for shift := uint(0); ; shift += 7 {
2916 if shift >= 64 {
2917 return ErrIntOverflowGenerated
2918 }
2919 if iNdEx >= l {
2920 return io.ErrUnexpectedEOF
2921 }
2922 b := dAtA[iNdEx]
2923 iNdEx++
2924 wire |= (uint64(b) & 0x7F) << shift
2925 if b < 0x80 {
2926 break
2927 }
2928 }
2929 fieldNum := int32(wire >> 3)
2930 wireType := int(wire & 0x7)
2931 if wireType == 4 {
2932 return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group")
2933 }
2934 if fieldNum <= 0 {
2935 return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
2936 }
2937 switch fieldNum {
2938 case 1:
2939 if wireType != 2 {
2940 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2941 }
2942 var msglen int
2943 for shift := uint(0); ; shift += 7 {
2944 if shift >= 64 {
2945 return ErrIntOverflowGenerated
2946 }
2947 if iNdEx >= l {
2948 return io.ErrUnexpectedEOF
2949 }
2950 b := dAtA[iNdEx]
2951 iNdEx++
2952 msglen |= (int(b) & 0x7F) << shift
2953 if b < 0x80 {
2954 break
2955 }
2956 }
2957 if msglen < 0 {
2958 return ErrInvalidLengthGenerated
2959 }
2960 postIndex := iNdEx + msglen
2961 if postIndex > l {
2962 return io.ErrUnexpectedEOF
2963 }
2964 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2965 return err
2966 }
2967 iNdEx = postIndex
2968 case 2:
2969 if wireType != 2 {
2970 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2971 }
2972 var msglen int
2973 for shift := uint(0); ; shift += 7 {
2974 if shift >= 64 {
2975 return ErrIntOverflowGenerated
2976 }
2977 if iNdEx >= l {
2978 return io.ErrUnexpectedEOF
2979 }
2980 b := dAtA[iNdEx]
2981 iNdEx++
2982 msglen |= (int(b) & 0x7F) << shift
2983 if b < 0x80 {
2984 break
2985 }
2986 }
2987 if msglen < 0 {
2988 return ErrInvalidLengthGenerated
2989 }
2990 postIndex := iNdEx + msglen
2991 if postIndex > l {
2992 return io.ErrUnexpectedEOF
2993 }
2994 m.Items = append(m.Items, PodSecurityPolicy{})
2995 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2996 return err
2997 }
2998 iNdEx = postIndex
2999 default:
3000 iNdEx = preIndex
3001 skippy, err := skipGenerated(dAtA[iNdEx:])
3002 if err != nil {
3003 return err
3004 }
3005 if skippy < 0 {
3006 return ErrInvalidLengthGenerated
3007 }
3008 if (iNdEx + skippy) > l {
3009 return io.ErrUnexpectedEOF
3010 }
3011 iNdEx += skippy
3012 }
3013 }
3014
3015 if iNdEx > l {
3016 return io.ErrUnexpectedEOF
3017 }
3018 return nil
3019}
3020func (m *PodSecurityPolicySpec) Unmarshal(dAtA []byte) error {
3021 l := len(dAtA)
3022 iNdEx := 0
3023 for iNdEx < l {
3024 preIndex := iNdEx
3025 var wire uint64
3026 for shift := uint(0); ; shift += 7 {
3027 if shift >= 64 {
3028 return ErrIntOverflowGenerated
3029 }
3030 if iNdEx >= l {
3031 return io.ErrUnexpectedEOF
3032 }
3033 b := dAtA[iNdEx]
3034 iNdEx++
3035 wire |= (uint64(b) & 0x7F) << shift
3036 if b < 0x80 {
3037 break
3038 }
3039 }
3040 fieldNum := int32(wire >> 3)
3041 wireType := int(wire & 0x7)
3042 if wireType == 4 {
3043 return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group")
3044 }
3045 if fieldNum <= 0 {
3046 return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
3047 }
3048 switch fieldNum {
3049 case 1:
3050 if wireType != 0 {
3051 return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
3052 }
3053 var v int
3054 for shift := uint(0); ; shift += 7 {
3055 if shift >= 64 {
3056 return ErrIntOverflowGenerated
3057 }
3058 if iNdEx >= l {
3059 return io.ErrUnexpectedEOF
3060 }
3061 b := dAtA[iNdEx]
3062 iNdEx++
3063 v |= (int(b) & 0x7F) << shift
3064 if b < 0x80 {
3065 break
3066 }
3067 }
3068 m.Privileged = bool(v != 0)
3069 case 2:
3070 if wireType != 2 {
3071 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType)
3072 }
3073 var stringLen uint64
3074 for shift := uint(0); ; shift += 7 {
3075 if shift >= 64 {
3076 return ErrIntOverflowGenerated
3077 }
3078 if iNdEx >= l {
3079 return io.ErrUnexpectedEOF
3080 }
3081 b := dAtA[iNdEx]
3082 iNdEx++
3083 stringLen |= (uint64(b) & 0x7F) << shift
3084 if b < 0x80 {
3085 break
3086 }
3087 }
3088 intStringLen := int(stringLen)
3089 if intStringLen < 0 {
3090 return ErrInvalidLengthGenerated
3091 }
3092 postIndex := iNdEx + intStringLen
3093 if postIndex > l {
3094 return io.ErrUnexpectedEOF
3095 }
3096 m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
3097 iNdEx = postIndex
3098 case 3:
3099 if wireType != 2 {
3100 return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType)
3101 }
3102 var stringLen uint64
3103 for shift := uint(0); ; shift += 7 {
3104 if shift >= 64 {
3105 return ErrIntOverflowGenerated
3106 }
3107 if iNdEx >= l {
3108 return io.ErrUnexpectedEOF
3109 }
3110 b := dAtA[iNdEx]
3111 iNdEx++
3112 stringLen |= (uint64(b) & 0x7F) << shift
3113 if b < 0x80 {
3114 break
3115 }
3116 }
3117 intStringLen := int(stringLen)
3118 if intStringLen < 0 {
3119 return ErrInvalidLengthGenerated
3120 }
3121 postIndex := iNdEx + intStringLen
3122 if postIndex > l {
3123 return io.ErrUnexpectedEOF
3124 }
3125 m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
3126 iNdEx = postIndex
3127 case 4:
3128 if wireType != 2 {
3129 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType)
3130 }
3131 var stringLen uint64
3132 for shift := uint(0); ; shift += 7 {
3133 if shift >= 64 {
3134 return ErrIntOverflowGenerated
3135 }
3136 if iNdEx >= l {
3137 return io.ErrUnexpectedEOF
3138 }
3139 b := dAtA[iNdEx]
3140 iNdEx++
3141 stringLen |= (uint64(b) & 0x7F) << shift
3142 if b < 0x80 {
3143 break
3144 }
3145 }
3146 intStringLen := int(stringLen)
3147 if intStringLen < 0 {
3148 return ErrInvalidLengthGenerated
3149 }
3150 postIndex := iNdEx + intStringLen
3151 if postIndex > l {
3152 return io.ErrUnexpectedEOF
3153 }
3154 m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
3155 iNdEx = postIndex
3156 case 5:
3157 if wireType != 2 {
3158 return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
3159 }
3160 var stringLen uint64
3161 for shift := uint(0); ; shift += 7 {
3162 if shift >= 64 {
3163 return ErrIntOverflowGenerated
3164 }
3165 if iNdEx >= l {
3166 return io.ErrUnexpectedEOF
3167 }
3168 b := dAtA[iNdEx]
3169 iNdEx++
3170 stringLen |= (uint64(b) & 0x7F) << shift
3171 if b < 0x80 {
3172 break
3173 }
3174 }
3175 intStringLen := int(stringLen)
3176 if intStringLen < 0 {
3177 return ErrInvalidLengthGenerated
3178 }
3179 postIndex := iNdEx + intStringLen
3180 if postIndex > l {
3181 return io.ErrUnexpectedEOF
3182 }
3183 m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex]))
3184 iNdEx = postIndex
3185 case 6:
3186 if wireType != 0 {
3187 return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
3188 }
3189 var v int
3190 for shift := uint(0); ; shift += 7 {
3191 if shift >= 64 {
3192 return ErrIntOverflowGenerated
3193 }
3194 if iNdEx >= l {
3195 return io.ErrUnexpectedEOF
3196 }
3197 b := dAtA[iNdEx]
3198 iNdEx++
3199 v |= (int(b) & 0x7F) << shift
3200 if b < 0x80 {
3201 break
3202 }
3203 }
3204 m.HostNetwork = bool(v != 0)
3205 case 7:
3206 if wireType != 2 {
3207 return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType)
3208 }
3209 var msglen int
3210 for shift := uint(0); ; shift += 7 {
3211 if shift >= 64 {
3212 return ErrIntOverflowGenerated
3213 }
3214 if iNdEx >= l {
3215 return io.ErrUnexpectedEOF
3216 }
3217 b := dAtA[iNdEx]
3218 iNdEx++
3219 msglen |= (int(b) & 0x7F) << shift
3220 if b < 0x80 {
3221 break
3222 }
3223 }
3224 if msglen < 0 {
3225 return ErrInvalidLengthGenerated
3226 }
3227 postIndex := iNdEx + msglen
3228 if postIndex > l {
3229 return io.ErrUnexpectedEOF
3230 }
3231 m.HostPorts = append(m.HostPorts, HostPortRange{})
3232 if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3233 return err
3234 }
3235 iNdEx = postIndex
3236 case 8:
3237 if wireType != 0 {
3238 return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
3239 }
3240 var v int
3241 for shift := uint(0); ; shift += 7 {
3242 if shift >= 64 {
3243 return ErrIntOverflowGenerated
3244 }
3245 if iNdEx >= l {
3246 return io.ErrUnexpectedEOF
3247 }
3248 b := dAtA[iNdEx]
3249 iNdEx++
3250 v |= (int(b) & 0x7F) << shift
3251 if b < 0x80 {
3252 break
3253 }
3254 }
3255 m.HostPID = bool(v != 0)
3256 case 9:
3257 if wireType != 0 {
3258 return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
3259 }
3260 var v int
3261 for shift := uint(0); ; shift += 7 {
3262 if shift >= 64 {
3263 return ErrIntOverflowGenerated
3264 }
3265 if iNdEx >= l {
3266 return io.ErrUnexpectedEOF
3267 }
3268 b := dAtA[iNdEx]
3269 iNdEx++
3270 v |= (int(b) & 0x7F) << shift
3271 if b < 0x80 {
3272 break
3273 }
3274 }
3275 m.HostIPC = bool(v != 0)
3276 case 10:
3277 if wireType != 2 {
3278 return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType)
3279 }
3280 var msglen int
3281 for shift := uint(0); ; shift += 7 {
3282 if shift >= 64 {
3283 return ErrIntOverflowGenerated
3284 }
3285 if iNdEx >= l {
3286 return io.ErrUnexpectedEOF
3287 }
3288 b := dAtA[iNdEx]
3289 iNdEx++
3290 msglen |= (int(b) & 0x7F) << shift
3291 if b < 0x80 {
3292 break
3293 }
3294 }
3295 if msglen < 0 {
3296 return ErrInvalidLengthGenerated
3297 }
3298 postIndex := iNdEx + msglen
3299 if postIndex > l {
3300 return io.ErrUnexpectedEOF
3301 }
3302 if err := m.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3303 return err
3304 }
3305 iNdEx = postIndex
3306 case 11:
3307 if wireType != 2 {
3308 return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
3309 }
3310 var msglen int
3311 for shift := uint(0); ; shift += 7 {
3312 if shift >= 64 {
3313 return ErrIntOverflowGenerated
3314 }
3315 if iNdEx >= l {
3316 return io.ErrUnexpectedEOF
3317 }
3318 b := dAtA[iNdEx]
3319 iNdEx++
3320 msglen |= (int(b) & 0x7F) << shift
3321 if b < 0x80 {
3322 break
3323 }
3324 }
3325 if msglen < 0 {
3326 return ErrInvalidLengthGenerated
3327 }
3328 postIndex := iNdEx + msglen
3329 if postIndex > l {
3330 return io.ErrUnexpectedEOF
3331 }
3332 if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3333 return err
3334 }
3335 iNdEx = postIndex
3336 case 12:
3337 if wireType != 2 {
3338 return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
3339 }
3340 var msglen int
3341 for shift := uint(0); ; shift += 7 {
3342 if shift >= 64 {
3343 return ErrIntOverflowGenerated
3344 }
3345 if iNdEx >= l {
3346 return io.ErrUnexpectedEOF
3347 }
3348 b := dAtA[iNdEx]
3349 iNdEx++
3350 msglen |= (int(b) & 0x7F) << shift
3351 if b < 0x80 {
3352 break
3353 }
3354 }
3355 if msglen < 0 {
3356 return ErrInvalidLengthGenerated
3357 }
3358 postIndex := iNdEx + msglen
3359 if postIndex > l {
3360 return io.ErrUnexpectedEOF
3361 }
3362 if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3363 return err
3364 }
3365 iNdEx = postIndex
3366 case 13:
3367 if wireType != 2 {
3368 return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
3369 }
3370 var msglen int
3371 for shift := uint(0); ; shift += 7 {
3372 if shift >= 64 {
3373 return ErrIntOverflowGenerated
3374 }
3375 if iNdEx >= l {
3376 return io.ErrUnexpectedEOF
3377 }
3378 b := dAtA[iNdEx]
3379 iNdEx++
3380 msglen |= (int(b) & 0x7F) << shift
3381 if b < 0x80 {
3382 break
3383 }
3384 }
3385 if msglen < 0 {
3386 return ErrInvalidLengthGenerated
3387 }
3388 postIndex := iNdEx + msglen
3389 if postIndex > l {
3390 return io.ErrUnexpectedEOF
3391 }
3392 if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3393 return err
3394 }
3395 iNdEx = postIndex
3396 case 14:
3397 if wireType != 0 {
3398 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
3399 }
3400 var v int
3401 for shift := uint(0); ; shift += 7 {
3402 if shift >= 64 {
3403 return ErrIntOverflowGenerated
3404 }
3405 if iNdEx >= l {
3406 return io.ErrUnexpectedEOF
3407 }
3408 b := dAtA[iNdEx]
3409 iNdEx++
3410 v |= (int(b) & 0x7F) << shift
3411 if b < 0x80 {
3412 break
3413 }
3414 }
3415 m.ReadOnlyRootFilesystem = bool(v != 0)
3416 case 15:
3417 if wireType != 0 {
3418 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType)
3419 }
3420 var v int
3421 for shift := uint(0); ; shift += 7 {
3422 if shift >= 64 {
3423 return ErrIntOverflowGenerated
3424 }
3425 if iNdEx >= l {
3426 return io.ErrUnexpectedEOF
3427 }
3428 b := dAtA[iNdEx]
3429 iNdEx++
3430 v |= (int(b) & 0x7F) << shift
3431 if b < 0x80 {
3432 break
3433 }
3434 }
3435 b := bool(v != 0)
3436 m.DefaultAllowPrivilegeEscalation = &b
3437 case 16:
3438 if wireType != 0 {
3439 return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType)
3440 }
3441 var v int
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 v |= (int(b) & 0x7F) << shift
3452 if b < 0x80 {
3453 break
3454 }
3455 }
3456 b := bool(v != 0)
3457 m.AllowPrivilegeEscalation = &b
3458 case 17:
3459 if wireType != 2 {
3460 return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", wireType)
3461 }
3462 var msglen int
3463 for shift := uint(0); ; shift += 7 {
3464 if shift >= 64 {
3465 return ErrIntOverflowGenerated
3466 }
3467 if iNdEx >= l {
3468 return io.ErrUnexpectedEOF
3469 }
3470 b := dAtA[iNdEx]
3471 iNdEx++
3472 msglen |= (int(b) & 0x7F) << shift
3473 if b < 0x80 {
3474 break
3475 }
3476 }
3477 if msglen < 0 {
3478 return ErrInvalidLengthGenerated
3479 }
3480 postIndex := iNdEx + msglen
3481 if postIndex > l {
3482 return io.ErrUnexpectedEOF
3483 }
3484 m.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{})
3485 if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3486 return err
3487 }
3488 iNdEx = postIndex
3489 case 18:
3490 if wireType != 2 {
3491 return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType)
3492 }
3493 var msglen int
3494 for shift := uint(0); ; shift += 7 {
3495 if shift >= 64 {
3496 return ErrIntOverflowGenerated
3497 }
3498 if iNdEx >= l {
3499 return io.ErrUnexpectedEOF
3500 }
3501 b := dAtA[iNdEx]
3502 iNdEx++
3503 msglen |= (int(b) & 0x7F) << shift
3504 if b < 0x80 {
3505 break
3506 }
3507 }
3508 if msglen < 0 {
3509 return ErrInvalidLengthGenerated
3510 }
3511 postIndex := iNdEx + msglen
3512 if postIndex > l {
3513 return io.ErrUnexpectedEOF
3514 }
3515 m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{})
3516 if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3517 return err
3518 }
3519 iNdEx = postIndex
3520 case 19:
3521 if wireType != 2 {
3522 return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType)
3523 }
3524 var stringLen uint64
3525 for shift := uint(0); ; shift += 7 {
3526 if shift >= 64 {
3527 return ErrIntOverflowGenerated
3528 }
3529 if iNdEx >= l {
3530 return io.ErrUnexpectedEOF
3531 }
3532 b := dAtA[iNdEx]
3533 iNdEx++
3534 stringLen |= (uint64(b) & 0x7F) << shift
3535 if b < 0x80 {
3536 break
3537 }
3538 }
3539 intStringLen := int(stringLen)
3540 if intStringLen < 0 {
3541 return ErrInvalidLengthGenerated
3542 }
3543 postIndex := iNdEx + intStringLen
3544 if postIndex > l {
3545 return io.ErrUnexpectedEOF
3546 }
3547 m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex]))
3548 iNdEx = postIndex
3549 case 20:
3550 if wireType != 2 {
3551 return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType)
3552 }
3553 var stringLen uint64
3554 for shift := uint(0); ; shift += 7 {
3555 if shift >= 64 {
3556 return ErrIntOverflowGenerated
3557 }
3558 if iNdEx >= l {
3559 return io.ErrUnexpectedEOF
3560 }
3561 b := dAtA[iNdEx]
3562 iNdEx++
3563 stringLen |= (uint64(b) & 0x7F) << shift
3564 if b < 0x80 {
3565 break
3566 }
3567 }
3568 intStringLen := int(stringLen)
3569 if intStringLen < 0 {
3570 return ErrInvalidLengthGenerated
3571 }
3572 postIndex := iNdEx + intStringLen
3573 if postIndex > l {
3574 return io.ErrUnexpectedEOF
3575 }
3576 m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex]))
3577 iNdEx = postIndex
3578 case 21:
3579 if wireType != 2 {
3580 return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", wireType)
3581 }
3582 var stringLen uint64
3583 for shift := uint(0); ; shift += 7 {
3584 if shift >= 64 {
3585 return ErrIntOverflowGenerated
3586 }
3587 if iNdEx >= l {
3588 return io.ErrUnexpectedEOF
3589 }
3590 b := dAtA[iNdEx]
3591 iNdEx++
3592 stringLen |= (uint64(b) & 0x7F) << shift
3593 if b < 0x80 {
3594 break
3595 }
3596 }
3597 intStringLen := int(stringLen)
3598 if intStringLen < 0 {
3599 return ErrInvalidLengthGenerated
3600 }
3601 postIndex := iNdEx + intStringLen
3602 if postIndex > l {
3603 return io.ErrUnexpectedEOF
3604 }
3605 m.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex]))
3606 iNdEx = postIndex
3607 case 22:
3608 if wireType != 2 {
3609 return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", wireType)
3610 }
3611 var msglen int
3612 for shift := uint(0); ; shift += 7 {
3613 if shift >= 64 {
3614 return ErrIntOverflowGenerated
3615 }
3616 if iNdEx >= l {
3617 return io.ErrUnexpectedEOF
3618 }
3619 b := dAtA[iNdEx]
3620 iNdEx++
3621 msglen |= (int(b) & 0x7F) << shift
3622 if b < 0x80 {
3623 break
3624 }
3625 }
3626 if msglen < 0 {
3627 return ErrInvalidLengthGenerated
3628 }
3629 postIndex := iNdEx + msglen
3630 if postIndex > l {
3631 return io.ErrUnexpectedEOF
3632 }
3633 if m.RunAsGroup == nil {
3634 m.RunAsGroup = &RunAsGroupStrategyOptions{}
3635 }
3636 if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3637 return err
3638 }
3639 iNdEx = postIndex
3640 default:
3641 iNdEx = preIndex
3642 skippy, err := skipGenerated(dAtA[iNdEx:])
3643 if err != nil {
3644 return err
3645 }
3646 if skippy < 0 {
3647 return ErrInvalidLengthGenerated
3648 }
3649 if (iNdEx + skippy) > l {
3650 return io.ErrUnexpectedEOF
3651 }
3652 iNdEx += skippy
3653 }
3654 }
3655
3656 if iNdEx > l {
3657 return io.ErrUnexpectedEOF
3658 }
3659 return nil
3660}
3661func (m *RunAsGroupStrategyOptions) Unmarshal(dAtA []byte) error {
3662 l := len(dAtA)
3663 iNdEx := 0
3664 for iNdEx < l {
3665 preIndex := iNdEx
3666 var wire uint64
3667 for shift := uint(0); ; shift += 7 {
3668 if shift >= 64 {
3669 return ErrIntOverflowGenerated
3670 }
3671 if iNdEx >= l {
3672 return io.ErrUnexpectedEOF
3673 }
3674 b := dAtA[iNdEx]
3675 iNdEx++
3676 wire |= (uint64(b) & 0x7F) << shift
3677 if b < 0x80 {
3678 break
3679 }
3680 }
3681 fieldNum := int32(wire >> 3)
3682 wireType := int(wire & 0x7)
3683 if wireType == 4 {
3684 return fmt.Errorf("proto: RunAsGroupStrategyOptions: wiretype end group for non-group")
3685 }
3686 if fieldNum <= 0 {
3687 return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3688 }
3689 switch fieldNum {
3690 case 1:
3691 if wireType != 2 {
3692 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
3693 }
3694 var stringLen uint64
3695 for shift := uint(0); ; shift += 7 {
3696 if shift >= 64 {
3697 return ErrIntOverflowGenerated
3698 }
3699 if iNdEx >= l {
3700 return io.ErrUnexpectedEOF
3701 }
3702 b := dAtA[iNdEx]
3703 iNdEx++
3704 stringLen |= (uint64(b) & 0x7F) << shift
3705 if b < 0x80 {
3706 break
3707 }
3708 }
3709 intStringLen := int(stringLen)
3710 if intStringLen < 0 {
3711 return ErrInvalidLengthGenerated
3712 }
3713 postIndex := iNdEx + intStringLen
3714 if postIndex > l {
3715 return io.ErrUnexpectedEOF
3716 }
3717 m.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex])
3718 iNdEx = postIndex
3719 case 2:
3720 if wireType != 2 {
3721 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
3722 }
3723 var msglen int
3724 for shift := uint(0); ; shift += 7 {
3725 if shift >= 64 {
3726 return ErrIntOverflowGenerated
3727 }
3728 if iNdEx >= l {
3729 return io.ErrUnexpectedEOF
3730 }
3731 b := dAtA[iNdEx]
3732 iNdEx++
3733 msglen |= (int(b) & 0x7F) << shift
3734 if b < 0x80 {
3735 break
3736 }
3737 }
3738 if msglen < 0 {
3739 return ErrInvalidLengthGenerated
3740 }
3741 postIndex := iNdEx + msglen
3742 if postIndex > l {
3743 return io.ErrUnexpectedEOF
3744 }
3745 m.Ranges = append(m.Ranges, IDRange{})
3746 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3747 return err
3748 }
3749 iNdEx = postIndex
3750 default:
3751 iNdEx = preIndex
3752 skippy, err := skipGenerated(dAtA[iNdEx:])
3753 if err != nil {
3754 return err
3755 }
3756 if skippy < 0 {
3757 return ErrInvalidLengthGenerated
3758 }
3759 if (iNdEx + skippy) > l {
3760 return io.ErrUnexpectedEOF
3761 }
3762 iNdEx += skippy
3763 }
3764 }
3765
3766 if iNdEx > l {
3767 return io.ErrUnexpectedEOF
3768 }
3769 return nil
3770}
3771func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error {
3772 l := len(dAtA)
3773 iNdEx := 0
3774 for iNdEx < l {
3775 preIndex := iNdEx
3776 var wire uint64
3777 for shift := uint(0); ; shift += 7 {
3778 if shift >= 64 {
3779 return ErrIntOverflowGenerated
3780 }
3781 if iNdEx >= l {
3782 return io.ErrUnexpectedEOF
3783 }
3784 b := dAtA[iNdEx]
3785 iNdEx++
3786 wire |= (uint64(b) & 0x7F) << shift
3787 if b < 0x80 {
3788 break
3789 }
3790 }
3791 fieldNum := int32(wire >> 3)
3792 wireType := int(wire & 0x7)
3793 if wireType == 4 {
3794 return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group")
3795 }
3796 if fieldNum <= 0 {
3797 return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3798 }
3799 switch fieldNum {
3800 case 1:
3801 if wireType != 2 {
3802 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
3803 }
3804 var stringLen uint64
3805 for shift := uint(0); ; shift += 7 {
3806 if shift >= 64 {
3807 return ErrIntOverflowGenerated
3808 }
3809 if iNdEx >= l {
3810 return io.ErrUnexpectedEOF
3811 }
3812 b := dAtA[iNdEx]
3813 iNdEx++
3814 stringLen |= (uint64(b) & 0x7F) << shift
3815 if b < 0x80 {
3816 break
3817 }
3818 }
3819 intStringLen := int(stringLen)
3820 if intStringLen < 0 {
3821 return ErrInvalidLengthGenerated
3822 }
3823 postIndex := iNdEx + intStringLen
3824 if postIndex > l {
3825 return io.ErrUnexpectedEOF
3826 }
3827 m.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex])
3828 iNdEx = postIndex
3829 case 2:
3830 if wireType != 2 {
3831 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
3832 }
3833 var msglen int
3834 for shift := uint(0); ; shift += 7 {
3835 if shift >= 64 {
3836 return ErrIntOverflowGenerated
3837 }
3838 if iNdEx >= l {
3839 return io.ErrUnexpectedEOF
3840 }
3841 b := dAtA[iNdEx]
3842 iNdEx++
3843 msglen |= (int(b) & 0x7F) << shift
3844 if b < 0x80 {
3845 break
3846 }
3847 }
3848 if msglen < 0 {
3849 return ErrInvalidLengthGenerated
3850 }
3851 postIndex := iNdEx + msglen
3852 if postIndex > l {
3853 return io.ErrUnexpectedEOF
3854 }
3855 m.Ranges = append(m.Ranges, IDRange{})
3856 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3857 return err
3858 }
3859 iNdEx = postIndex
3860 default:
3861 iNdEx = preIndex
3862 skippy, err := skipGenerated(dAtA[iNdEx:])
3863 if err != nil {
3864 return err
3865 }
3866 if skippy < 0 {
3867 return ErrInvalidLengthGenerated
3868 }
3869 if (iNdEx + skippy) > l {
3870 return io.ErrUnexpectedEOF
3871 }
3872 iNdEx += skippy
3873 }
3874 }
3875
3876 if iNdEx > l {
3877 return io.ErrUnexpectedEOF
3878 }
3879 return nil
3880}
3881func (m *SELinuxStrategyOptions) Unmarshal(dAtA []byte) error {
3882 l := len(dAtA)
3883 iNdEx := 0
3884 for iNdEx < l {
3885 preIndex := iNdEx
3886 var wire 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 wire |= (uint64(b) & 0x7F) << shift
3897 if b < 0x80 {
3898 break
3899 }
3900 }
3901 fieldNum := int32(wire >> 3)
3902 wireType := int(wire & 0x7)
3903 if wireType == 4 {
3904 return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group")
3905 }
3906 if fieldNum <= 0 {
3907 return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3908 }
3909 switch fieldNum {
3910 case 1:
3911 if wireType != 2 {
3912 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
3913 }
3914 var stringLen uint64
3915 for shift := uint(0); ; shift += 7 {
3916 if shift >= 64 {
3917 return ErrIntOverflowGenerated
3918 }
3919 if iNdEx >= l {
3920 return io.ErrUnexpectedEOF
3921 }
3922 b := dAtA[iNdEx]
3923 iNdEx++
3924 stringLen |= (uint64(b) & 0x7F) << shift
3925 if b < 0x80 {
3926 break
3927 }
3928 }
3929 intStringLen := int(stringLen)
3930 if intStringLen < 0 {
3931 return ErrInvalidLengthGenerated
3932 }
3933 postIndex := iNdEx + intStringLen
3934 if postIndex > l {
3935 return io.ErrUnexpectedEOF
3936 }
3937 m.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex])
3938 iNdEx = postIndex
3939 case 2:
3940 if wireType != 2 {
3941 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
3942 }
3943 var msglen int
3944 for shift := uint(0); ; shift += 7 {
3945 if shift >= 64 {
3946 return ErrIntOverflowGenerated
3947 }
3948 if iNdEx >= l {
3949 return io.ErrUnexpectedEOF
3950 }
3951 b := dAtA[iNdEx]
3952 iNdEx++
3953 msglen |= (int(b) & 0x7F) << shift
3954 if b < 0x80 {
3955 break
3956 }
3957 }
3958 if msglen < 0 {
3959 return ErrInvalidLengthGenerated
3960 }
3961 postIndex := iNdEx + msglen
3962 if postIndex > l {
3963 return io.ErrUnexpectedEOF
3964 }
3965 if m.SELinuxOptions == nil {
3966 m.SELinuxOptions = &k8s_io_api_core_v1.SELinuxOptions{}
3967 }
3968 if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3969 return err
3970 }
3971 iNdEx = postIndex
3972 default:
3973 iNdEx = preIndex
3974 skippy, err := skipGenerated(dAtA[iNdEx:])
3975 if err != nil {
3976 return err
3977 }
3978 if skippy < 0 {
3979 return ErrInvalidLengthGenerated
3980 }
3981 if (iNdEx + skippy) > l {
3982 return io.ErrUnexpectedEOF
3983 }
3984 iNdEx += skippy
3985 }
3986 }
3987
3988 if iNdEx > l {
3989 return io.ErrUnexpectedEOF
3990 }
3991 return nil
3992}
3993func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error {
3994 l := len(dAtA)
3995 iNdEx := 0
3996 for iNdEx < l {
3997 preIndex := iNdEx
3998 var wire uint64
3999 for shift := uint(0); ; shift += 7 {
4000 if shift >= 64 {
4001 return ErrIntOverflowGenerated
4002 }
4003 if iNdEx >= l {
4004 return io.ErrUnexpectedEOF
4005 }
4006 b := dAtA[iNdEx]
4007 iNdEx++
4008 wire |= (uint64(b) & 0x7F) << shift
4009 if b < 0x80 {
4010 break
4011 }
4012 }
4013 fieldNum := int32(wire >> 3)
4014 wireType := int(wire & 0x7)
4015 if wireType == 4 {
4016 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group")
4017 }
4018 if fieldNum <= 0 {
4019 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
4020 }
4021 switch fieldNum {
4022 case 1:
4023 if wireType != 2 {
4024 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
4025 }
4026 var stringLen uint64
4027 for shift := uint(0); ; shift += 7 {
4028 if shift >= 64 {
4029 return ErrIntOverflowGenerated
4030 }
4031 if iNdEx >= l {
4032 return io.ErrUnexpectedEOF
4033 }
4034 b := dAtA[iNdEx]
4035 iNdEx++
4036 stringLen |= (uint64(b) & 0x7F) << shift
4037 if b < 0x80 {
4038 break
4039 }
4040 }
4041 intStringLen := int(stringLen)
4042 if intStringLen < 0 {
4043 return ErrInvalidLengthGenerated
4044 }
4045 postIndex := iNdEx + intStringLen
4046 if postIndex > l {
4047 return io.ErrUnexpectedEOF
4048 }
4049 m.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex])
4050 iNdEx = postIndex
4051 case 2:
4052 if wireType != 2 {
4053 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
4054 }
4055 var msglen int
4056 for shift := uint(0); ; shift += 7 {
4057 if shift >= 64 {
4058 return ErrIntOverflowGenerated
4059 }
4060 if iNdEx >= l {
4061 return io.ErrUnexpectedEOF
4062 }
4063 b := dAtA[iNdEx]
4064 iNdEx++
4065 msglen |= (int(b) & 0x7F) << shift
4066 if b < 0x80 {
4067 break
4068 }
4069 }
4070 if msglen < 0 {
4071 return ErrInvalidLengthGenerated
4072 }
4073 postIndex := iNdEx + msglen
4074 if postIndex > l {
4075 return io.ErrUnexpectedEOF
4076 }
4077 m.Ranges = append(m.Ranges, IDRange{})
4078 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4079 return err
4080 }
4081 iNdEx = postIndex
4082 default:
4083 iNdEx = preIndex
4084 skippy, err := skipGenerated(dAtA[iNdEx:])
4085 if err != nil {
4086 return err
4087 }
4088 if skippy < 0 {
4089 return ErrInvalidLengthGenerated
4090 }
4091 if (iNdEx + skippy) > l {
4092 return io.ErrUnexpectedEOF
4093 }
4094 iNdEx += skippy
4095 }
4096 }
4097
4098 if iNdEx > l {
4099 return io.ErrUnexpectedEOF
4100 }
4101 return nil
4102}
4103func skipGenerated(dAtA []byte) (n int, err error) {
4104 l := len(dAtA)
4105 iNdEx := 0
4106 for iNdEx < l {
4107 var wire uint64
4108 for shift := uint(0); ; shift += 7 {
4109 if shift >= 64 {
4110 return 0, ErrIntOverflowGenerated
4111 }
4112 if iNdEx >= l {
4113 return 0, io.ErrUnexpectedEOF
4114 }
4115 b := dAtA[iNdEx]
4116 iNdEx++
4117 wire |= (uint64(b) & 0x7F) << shift
4118 if b < 0x80 {
4119 break
4120 }
4121 }
4122 wireType := int(wire & 0x7)
4123 switch wireType {
4124 case 0:
4125 for shift := uint(0); ; shift += 7 {
4126 if shift >= 64 {
4127 return 0, ErrIntOverflowGenerated
4128 }
4129 if iNdEx >= l {
4130 return 0, io.ErrUnexpectedEOF
4131 }
4132 iNdEx++
4133 if dAtA[iNdEx-1] < 0x80 {
4134 break
4135 }
4136 }
4137 return iNdEx, nil
4138 case 1:
4139 iNdEx += 8
4140 return iNdEx, nil
4141 case 2:
4142 var length int
4143 for shift := uint(0); ; shift += 7 {
4144 if shift >= 64 {
4145 return 0, ErrIntOverflowGenerated
4146 }
4147 if iNdEx >= l {
4148 return 0, io.ErrUnexpectedEOF
4149 }
4150 b := dAtA[iNdEx]
4151 iNdEx++
4152 length |= (int(b) & 0x7F) << shift
4153 if b < 0x80 {
4154 break
4155 }
4156 }
4157 iNdEx += length
4158 if length < 0 {
4159 return 0, ErrInvalidLengthGenerated
4160 }
4161 return iNdEx, nil
4162 case 3:
4163 for {
4164 var innerWire uint64
4165 var start int = iNdEx
4166 for shift := uint(0); ; shift += 7 {
4167 if shift >= 64 {
4168 return 0, ErrIntOverflowGenerated
4169 }
4170 if iNdEx >= l {
4171 return 0, io.ErrUnexpectedEOF
4172 }
4173 b := dAtA[iNdEx]
4174 iNdEx++
4175 innerWire |= (uint64(b) & 0x7F) << shift
4176 if b < 0x80 {
4177 break
4178 }
4179 }
4180 innerWireType := int(innerWire & 0x7)
4181 if innerWireType == 4 {
4182 break
4183 }
4184 next, err := skipGenerated(dAtA[start:])
4185 if err != nil {
4186 return 0, err
4187 }
4188 iNdEx = start + next
4189 }
4190 return iNdEx, nil
4191 case 4:
4192 return iNdEx, nil
4193 case 5:
4194 iNdEx += 4
4195 return iNdEx, nil
4196 default:
4197 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
4198 }
4199 }
4200 panic("unreachable")
4201}
4202
4203var (
4204 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
4205 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
4206)
4207
4208func init() {
4209 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/policy/v1beta1/generated.proto", fileDescriptorGenerated)
4210}
4211
4212var fileDescriptorGenerated = []byte{
4213 // 1756 bytes of a gzipped FileDescriptorProto
4214 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x8e, 0xdb, 0xc6,
4215 0x15, 0x5e, 0x5a, 0xfb, 0xa3, 0x9d, 0xfd, 0x9f, 0xfd, 0x29, 0xbd, 0xa8, 0x45, 0x47, 0x01, 0x0a,
4216 0x37, 0x48, 0xa8, 0x78, 0x9d, 0xa4, 0x46, 0xd3, 0x16, 0x59, 0x5a, 0xbb, 0xf6, 0x06, 0xde, 0xae,
4217 0x3a, 0xb2, 0x83, 0xb6, 0x70, 0x8b, 0x8e, 0xc4, 0x59, 0xed, 0x64, 0x29, 0x92, 0x9d, 0x19, 0x2a,
4218 0xab, 0xbb, 0x5e, 0xf4, 0xa2, 0x97, 0x7d, 0x81, 0xa0, 0x0f, 0x50, 0xf4, 0xaa, 0x2f, 0xe1, 0x02,
4219 0x45, 0x91, 0xcb, 0xa0, 0x17, 0x42, 0xad, 0x22, 0x2f, 0xe1, 0xab, 0x80, 0xa3, 0x21, 0x25, 0xfe,
4220 0x49, 0x5e, 0x03, 0xf6, 0x1d, 0x39, 0xe7, 0xfb, 0xbe, 0x73, 0xe6, 0xcc, 0x99, 0x33, 0x43, 0x02,
4221 0xeb, 0xf2, 0x3e, 0x37, 0xa9, 0x57, 0xbb, 0x0c, 0x5a, 0x84, 0xb9, 0x44, 0x10, 0x5e, 0xeb, 0x11,
4222 0xd7, 0xf6, 0x58, 0x4d, 0x19, 0xb0, 0x4f, 0x6b, 0xbe, 0xe7, 0xd0, 0x76, 0xbf, 0xd6, 0xbb, 0xdb,
4223 0x22, 0x02, 0xdf, 0xad, 0x75, 0x88, 0x4b, 0x18, 0x16, 0xc4, 0x36, 0x7d, 0xe6, 0x09, 0x0f, 0xde,
4224 0x1c, 0x41, 0x4d, 0xec, 0x53, 0x73, 0x04, 0x35, 0x15, 0x74, 0xff, 0x83, 0x0e, 0x15, 0x17, 0x41,
4225 0xcb, 0x6c, 0x7b, 0xdd, 0x5a, 0xc7, 0xeb, 0x78, 0x35, 0xc9, 0x68, 0x05, 0xe7, 0xf2, 0x4d, 0xbe,
4226 0xc8, 0xa7, 0x91, 0xd2, 0x7e, 0x75, 0xc2, 0x69, 0xdb, 0x63, 0xa4, 0xd6, 0xcb, 0x78, 0xdb, 0xff,
4227 0x68, 0x8c, 0xe9, 0xe2, 0xf6, 0x05, 0x75, 0x09, 0xeb, 0xd7, 0xfc, 0xcb, 0x4e, 0x38, 0xc0, 0x6b,
4228 0x5d, 0x22, 0x70, 0x1e, 0xab, 0x56, 0xc4, 0x62, 0x81, 0x2b, 0x68, 0x97, 0x64, 0x08, 0x9f, 0xcc,
4229 0x22, 0xf0, 0xf6, 0x05, 0xe9, 0xe2, 0x0c, 0xef, 0x5e, 0x11, 0x2f, 0x10, 0xd4, 0xa9, 0x51, 0x57,
4230 0x70, 0xc1, 0xd2, 0xa4, 0xea, 0xa7, 0x60, 0xeb, 0xd0, 0x71, 0xbc, 0xaf, 0x88, 0x7d, 0xec, 0x90,
4231 0xab, 0x2f, 0x3c, 0x27, 0xe8, 0x12, 0xf8, 0x23, 0xb0, 0x68, 0x33, 0xda, 0x23, 0x4c, 0xd7, 0x6e,
4232 0x6b, 0x77, 0x96, 0xad, 0xf5, 0xe7, 0x03, 0x63, 0x6e, 0x38, 0x30, 0x16, 0xeb, 0x72, 0x14, 0x29,
4233 0x6b, 0x95, 0x83, 0x0d, 0x45, 0x7e, 0xe4, 0x71, 0xd1, 0xc0, 0xe2, 0x02, 0x1e, 0x00, 0xe0, 0x63,
4234 0x71, 0xd1, 0x60, 0xe4, 0x9c, 0x5e, 0x29, 0x3a, 0x54, 0x74, 0xd0, 0x88, 0x2d, 0x68, 0x02, 0x05,
4235 0xdf, 0x07, 0x65, 0x46, 0xb0, 0x7d, 0xe6, 0x3a, 0x7d, 0xfd, 0xc6, 0x6d, 0xed, 0x4e, 0xd9, 0xda,
4236 0x54, 0x8c, 0x32, 0x52, 0xe3, 0x28, 0x46, 0x54, 0xff, 0xab, 0x81, 0xf2, 0x51, 0x8f, 0xb6, 0x05,
4237 0xf5, 0x5c, 0xf8, 0x07, 0x50, 0x0e, 0xf3, 0x6e, 0x63, 0x81, 0xa5, 0xb3, 0x95, 0x83, 0x0f, 0xcd,
4238 0x71, 0x4d, 0xc4, 0x69, 0x30, 0xfd, 0xcb, 0x4e, 0x38, 0xc0, 0xcd, 0x10, 0x6d, 0xf6, 0xee, 0x9a,
4239 0x67, 0xad, 0x2f, 0x49, 0x5b, 0x9c, 0x12, 0x81, 0xc7, 0xe1, 0x8d, 0xc7, 0x50, 0xac, 0x0a, 0x1d,
4240 0xb0, 0x66, 0x13, 0x87, 0x08, 0x72, 0xe6, 0x87, 0x1e, 0xb9, 0x8c, 0x70, 0xe5, 0xe0, 0xde, 0xab,
4241 0xb9, 0xa9, 0x4f, 0x52, 0xad, 0xad, 0xe1, 0xc0, 0x58, 0x4b, 0x0c, 0xa1, 0xa4, 0x78, 0xf5, 0x6b,
4242 0x0d, 0xec, 0x1d, 0x37, 0x1f, 0x32, 0x2f, 0xf0, 0x9b, 0x22, 0x5c, 0xa7, 0x4e, 0x5f, 0x99, 0xe0,
4243 0x4f, 0xc0, 0x3c, 0x0b, 0x1c, 0xa2, 0x72, 0xfa, 0xae, 0x0a, 0x7a, 0x1e, 0x05, 0x0e, 0x79, 0x39,
4244 0x30, 0xb6, 0x53, 0xac, 0x27, 0x7d, 0x9f, 0x20, 0x49, 0x80, 0x9f, 0x83, 0x45, 0x86, 0xdd, 0x0e,
4245 0x09, 0x43, 0x2f, 0xdd, 0x59, 0x39, 0xa8, 0x9a, 0x85, 0xbb, 0xc6, 0x3c, 0xa9, 0xa3, 0x10, 0x3a,
4246 0x5e, 0x71, 0xf9, 0xca, 0x91, 0x52, 0xa8, 0x9e, 0x82, 0x35, 0xb9, 0xd4, 0x1e, 0x13, 0xd2, 0x02,
4247 0x6f, 0x81, 0x52, 0x97, 0xba, 0x32, 0xa8, 0x05, 0x6b, 0x45, 0xb1, 0x4a, 0xa7, 0xd4, 0x45, 0xe1,
4248 0xb8, 0x34, 0xe3, 0x2b, 0x99, 0xb3, 0x49, 0x33, 0xbe, 0x42, 0xe1, 0x78, 0xf5, 0x21, 0x58, 0x52,
4249 0x1e, 0x27, 0x85, 0x4a, 0xd3, 0x85, 0x4a, 0x39, 0x42, 0x7f, 0xbf, 0x01, 0xb6, 0x1b, 0x9e, 0x5d,
4250 0xa7, 0x9c, 0x05, 0x32, 0x5f, 0x56, 0x60, 0x77, 0x88, 0x78, 0x0b, 0xf5, 0xf1, 0x04, 0xcc, 0x73,
4251 0x9f, 0xb4, 0x55, 0x59, 0x1c, 0x4c, 0xc9, 0x6d, 0x4e, 0x7c, 0x4d, 0x9f, 0xb4, 0xad, 0xd5, 0x68,
4252 0x29, 0xc3, 0x37, 0x24, 0xd5, 0xe0, 0x33, 0xb0, 0xc8, 0x05, 0x16, 0x01, 0xd7, 0x4b, 0x52, 0xf7,
4253 0xa3, 0x6b, 0xea, 0x4a, 0xee, 0x78, 0x15, 0x47, 0xef, 0x48, 0x69, 0x56, 0xff, 0xad, 0x81, 0x1f,
4254 0xe4, 0xb0, 0x1e, 0x53, 0x2e, 0xe0, 0xb3, 0x4c, 0xc6, 0xcc, 0x57, 0xcb, 0x58, 0xc8, 0x96, 0xf9,
4255 0x8a, 0x37, 0x6f, 0x34, 0x32, 0x91, 0xad, 0x26, 0x58, 0xa0, 0x82, 0x74, 0xa3, 0x52, 0x34, 0xaf,
4256 0x37, 0x2d, 0x6b, 0x4d, 0x49, 0x2f, 0x9c, 0x84, 0x22, 0x68, 0xa4, 0x55, 0xfd, 0xcf, 0x8d, 0xdc,
4257 0xe9, 0x84, 0xe9, 0x84, 0xe7, 0x60, 0xb5, 0x4b, 0xdd, 0xc3, 0x1e, 0xa6, 0x0e, 0x6e, 0xa9, 0xdd,
4258 0x33, 0xad, 0x08, 0xc2, 0x5e, 0x69, 0x8e, 0x7a, 0xa5, 0x79, 0xe2, 0x8a, 0x33, 0xd6, 0x14, 0x8c,
4259 0xba, 0x1d, 0x6b, 0x73, 0x38, 0x30, 0x56, 0x4f, 0x27, 0x94, 0x50, 0x42, 0x17, 0xfe, 0x0e, 0x94,
4260 0x39, 0x71, 0x48, 0x5b, 0x78, 0xec, 0x7a, 0x1d, 0xe2, 0x31, 0x6e, 0x11, 0xa7, 0xa9, 0xa8, 0xd6,
4261 0x6a, 0x98, 0xb7, 0xe8, 0x0d, 0xc5, 0x92, 0xd0, 0x01, 0xeb, 0x5d, 0x7c, 0xf5, 0xd4, 0xc5, 0xf1,
4262 0x44, 0x4a, 0xaf, 0x39, 0x11, 0x38, 0x1c, 0x18, 0xeb, 0xa7, 0x09, 0x2d, 0x94, 0xd2, 0xae, 0x7e,
4263 0x37, 0x0f, 0x6e, 0x16, 0x56, 0x15, 0xfc, 0x1c, 0x40, 0xaf, 0xc5, 0x09, 0xeb, 0x11, 0xfb, 0xe1,
4264 0xe8, 0x34, 0xa1, 0x5e, 0xb4, 0x71, 0xf7, 0xd5, 0x02, 0xc1, 0xb3, 0x0c, 0x02, 0xe5, 0xb0, 0xe0,
4265 0x9f, 0x35, 0xb0, 0x66, 0x8f, 0xdc, 0x10, 0xbb, 0xe1, 0xd9, 0x51, 0x61, 0x3c, 0x7c, 0x9d, 0x7a,
4266 0x37, 0xeb, 0x93, 0x4a, 0x47, 0xae, 0x60, 0x7d, 0x6b, 0x57, 0x05, 0xb4, 0x96, 0xb0, 0xa1, 0xa4,
4267 0x53, 0x78, 0x0a, 0xa0, 0x1d, 0x4b, 0x72, 0x75, 0xa6, 0xc9, 0x14, 0x2f, 0x58, 0xb7, 0x94, 0xc2,
4268 0x6e, 0xc2, 0x6f, 0x04, 0x42, 0x39, 0x44, 0xf8, 0x0b, 0xb0, 0xde, 0x0e, 0x18, 0x23, 0xae, 0x78,
4269 0x44, 0xb0, 0x23, 0x2e, 0xfa, 0xfa, 0xbc, 0x94, 0xda, 0x53, 0x52, 0xeb, 0x0f, 0x12, 0x56, 0x94,
4270 0x42, 0x87, 0x7c, 0x9b, 0x70, 0xca, 0x88, 0x1d, 0xf1, 0x17, 0x92, 0xfc, 0x7a, 0xc2, 0x8a, 0x52,
4271 0x68, 0x78, 0x1f, 0xac, 0x92, 0x2b, 0x9f, 0xb4, 0xa3, 0x9c, 0x2e, 0x4a, 0xf6, 0x8e, 0x62, 0xaf,
4272 0x1e, 0x4d, 0xd8, 0x50, 0x02, 0xb9, 0xef, 0x00, 0x98, 0x4d, 0x22, 0xdc, 0x04, 0xa5, 0x4b, 0xd2,
4273 0x1f, 0x9d, 0x3c, 0x28, 0x7c, 0x84, 0x9f, 0x81, 0x85, 0x1e, 0x76, 0x02, 0xa2, 0x6a, 0xfd, 0xbd,
4274 0x57, 0xab, 0xf5, 0x27, 0xb4, 0x4b, 0xd0, 0x88, 0xf8, 0xd3, 0x1b, 0xf7, 0xb5, 0xea, 0xbf, 0x34,
4275 0xb0, 0xd5, 0xf0, 0xec, 0x26, 0x69, 0x07, 0x8c, 0x8a, 0x7e, 0x43, 0xae, 0xf3, 0x5b, 0xe8, 0xd9,
4276 0x28, 0xd1, 0xb3, 0x3f, 0x9c, 0x5e, 0x6b, 0xc9, 0xe8, 0x8a, 0x3a, 0x76, 0xf5, 0xb9, 0x06, 0x76,
4277 0x33, 0xe8, 0xb7, 0xd0, 0x51, 0x7f, 0x95, 0xec, 0xa8, 0xef, 0x5f, 0x67, 0x32, 0x05, 0xfd, 0xf4,
4278 0xbb, 0x8d, 0x9c, 0xa9, 0xc8, 0x6e, 0x1a, 0xde, 0xee, 0x18, 0xed, 0x51, 0x87, 0x74, 0x88, 0x2d,
4279 0x27, 0x53, 0x9e, 0xb8, 0xdd, 0xc5, 0x16, 0x34, 0x81, 0x82, 0x1c, 0xec, 0xd9, 0xe4, 0x1c, 0x07,
4280 0x8e, 0x38, 0xb4, 0xed, 0x07, 0xd8, 0xc7, 0x2d, 0xea, 0x50, 0x41, 0xd5, 0x75, 0x64, 0xd9, 0xfa,
4281 0x74, 0x38, 0x30, 0xf6, 0xea, 0xb9, 0x88, 0x97, 0x03, 0xe3, 0x56, 0xf6, 0x5e, 0x6e, 0xc6, 0x90,
4282 0x3e, 0x2a, 0x90, 0x86, 0x7d, 0xa0, 0x33, 0xf2, 0xc7, 0x20, 0xdc, 0x14, 0x75, 0xe6, 0xf9, 0x09,
4283 0xb7, 0x25, 0xe9, 0xf6, 0xe7, 0xc3, 0x81, 0xa1, 0xa3, 0x02, 0xcc, 0x6c, 0xc7, 0x85, 0xf2, 0xf0,
4284 0x4b, 0xb0, 0x8d, 0x47, 0x7d, 0x20, 0xe1, 0x75, 0x5e, 0x7a, 0xbd, 0x3f, 0x1c, 0x18, 0xdb, 0x87,
4285 0x59, 0xf3, 0x6c, 0x87, 0x79, 0xa2, 0xb0, 0x06, 0x96, 0x7a, 0xf2, 0xca, 0xce, 0xf5, 0x05, 0xa9,
4286 0xbf, 0x3b, 0x1c, 0x18, 0x4b, 0xa3, 0x5b, 0x7c, 0xa8, 0xb9, 0x78, 0xdc, 0x94, 0x17, 0xc1, 0x08,
4287 0x05, 0x3f, 0x06, 0x2b, 0x17, 0x1e, 0x17, 0xbf, 0x24, 0xe2, 0x2b, 0x8f, 0x5d, 0xca, 0xc6, 0x50,
4288 0xb6, 0xb6, 0xd5, 0x0a, 0xae, 0x3c, 0x1a, 0x9b, 0xd0, 0x24, 0x0e, 0xfe, 0x06, 0x2c, 0x5f, 0xa8,
4289 0x6b, 0x1f, 0xd7, 0x97, 0x64, 0xa1, 0xdd, 0x99, 0x52, 0x68, 0x89, 0x2b, 0xa2, 0xb5, 0xa5, 0xe4,
4290 0x97, 0xa3, 0x61, 0x8e, 0xc6, 0x6a, 0xf0, 0xc7, 0x60, 0x49, 0xbe, 0x9c, 0xd4, 0xf5, 0xb2, 0x8c,
4291 0x66, 0x43, 0xc1, 0x97, 0x1e, 0x8d, 0x86, 0x51, 0x64, 0x8f, 0xa0, 0x27, 0x8d, 0x07, 0xfa, 0x72,
4292 0x16, 0x7a, 0xd2, 0x78, 0x80, 0x22, 0x3b, 0x7c, 0x06, 0x96, 0x38, 0x79, 0x4c, 0xdd, 0xe0, 0x4a,
4293 0x07, 0x72, 0xcb, 0xdd, 0x9d, 0x12, 0x6e, 0xf3, 0x48, 0x22, 0x53, 0x17, 0xee, 0xb1, 0xba, 0xb2,
4294 0xa3, 0x48, 0x12, 0xda, 0x60, 0x99, 0x05, 0xee, 0x21, 0x7f, 0xca, 0x09, 0xd3, 0x57, 0x32, 0xa7,
4295 0x7d, 0x5a, 0x1f, 0x45, 0xd8, 0xb4, 0x87, 0x38, 0x33, 0x31, 0x02, 0x8d, 0x85, 0xe1, 0x5f, 0x34,
4296 0x00, 0x79, 0xe0, 0xfb, 0x0e, 0xe9, 0x12, 0x57, 0x60, 0x47, 0xde, 0xef, 0xb9, 0xbe, 0x2a, 0xfd,
4297 0xfd, 0x6c, 0xda, 0x7c, 0x32, 0xa4, 0xb4, 0xe3, 0xf8, 0x98, 0xce, 0x42, 0x51, 0x8e, 0xcf, 0x30,
4298 0x9d, 0xe7, 0x5c, 0x3e, 0xeb, 0x6b, 0x33, 0xd3, 0x99, 0xff, 0xfd, 0x32, 0x4e, 0xa7, 0xb2, 0xa3,
4299 0x48, 0x12, 0x7e, 0x01, 0xf6, 0xa2, 0xaf, 0x3b, 0xe4, 0x79, 0xe2, 0x98, 0x3a, 0x84, 0xf7, 0xb9,
4300 0x20, 0x5d, 0x7d, 0x5d, 0x2e, 0x73, 0x45, 0x31, 0xf7, 0x50, 0x2e, 0x0a, 0x15, 0xb0, 0x61, 0x17,
4301 0x18, 0x51, 0x7b, 0x08, 0xf7, 0x4e, 0xdc, 0x9f, 0x8e, 0x78, 0x1b, 0x3b, 0xa3, 0x5b, 0xcb, 0x86,
4302 0x74, 0xf0, 0xee, 0x70, 0x60, 0x18, 0xf5, 0xe9, 0x50, 0x34, 0x4b, 0x0b, 0xfe, 0x1a, 0xe8, 0xb8,
4303 0xc8, 0xcf, 0xa6, 0xf4, 0xf3, 0xc3, 0xb0, 0xe7, 0x14, 0x3a, 0x28, 0x64, 0x43, 0x1f, 0x6c, 0xe2,
4304 0xe4, 0x77, 0x36, 0xd7, 0xb7, 0xe4, 0x2e, 0x7c, 0x6f, 0xca, 0x3a, 0xa4, 0x3e, 0xcd, 0x2d, 0x5d,
4305 0xa5, 0x71, 0x33, 0x65, 0xe0, 0x28, 0xa3, 0x0e, 0xaf, 0x00, 0xc4, 0xe9, 0xdf, 0x02, 0x5c, 0x87,
4306 0x33, 0x8f, 0x98, 0xcc, 0xbf, 0x84, 0x71, 0xa9, 0x65, 0x4c, 0x1c, 0xe5, 0xf8, 0x80, 0x8f, 0xc1,
4307 0x8e, 0x1a, 0x7d, 0xea, 0x72, 0x7c, 0x4e, 0x9a, 0x7d, 0xde, 0x16, 0x0e, 0xd7, 0xb7, 0x65, 0x7f,
4308 0xd3, 0x87, 0x03, 0x63, 0xe7, 0x30, 0xc7, 0x8e, 0x72, 0x59, 0xf0, 0x33, 0xb0, 0x79, 0xee, 0xb1,
4309 0x16, 0xb5, 0x6d, 0xe2, 0x46, 0x4a, 0x3b, 0x52, 0x69, 0x27, 0xcc, 0xc4, 0x71, 0xca, 0x86, 0x32,
4310 0x68, 0xc8, 0xc1, 0xae, 0x52, 0x6e, 0x30, 0xaf, 0x7d, 0xea, 0x05, 0xae, 0x08, 0x5b, 0x2a, 0xd7,
4311 0x77, 0xe3, 0x63, 0x64, 0xf7, 0x30, 0x0f, 0xf0, 0x72, 0x60, 0xdc, 0xce, 0x69, 0xe9, 0x09, 0x10,
4312 0xca, 0xd7, 0x86, 0x36, 0x00, 0xb2, 0x0f, 0x8c, 0xb6, 0xdc, 0xde, 0xcc, 0x4f, 0x40, 0x14, 0x83,
4313 0xd3, 0xbb, 0x6e, 0x3d, 0x3c, 0x99, 0xc7, 0x66, 0x34, 0xa1, 0x5b, 0xfd, 0x9b, 0x06, 0x6e, 0x16,
4314 0x32, 0xe1, 0x27, 0x89, 0xff, 0x0d, 0xd5, 0xd4, 0xff, 0x06, 0x98, 0x25, 0xbe, 0x81, 0xdf, 0x0d,
4315 0x5f, 0x6b, 0x40, 0x2f, 0xea, 0x9e, 0xf0, 0xe3, 0x44, 0x80, 0xef, 0xa4, 0x02, 0xdc, 0xca, 0xf0,
4316 0xde, 0x40, 0x7c, 0xff, 0xd0, 0xc0, 0x5e, 0xfe, 0xe9, 0x01, 0xef, 0x25, 0xa2, 0x33, 0x52, 0xd1,
4317 0x6d, 0xa4, 0x58, 0x2a, 0xb6, 0xdf, 0x83, 0x75, 0x75, 0xc6, 0x24, 0xff, 0x36, 0x25, 0x62, 0x0c,
4318 0x2b, 0x29, 0xbc, 0x1e, 0x2a, 0x89, 0x68, 0xa5, 0xe5, 0x87, 0x5d, 0x72, 0x0c, 0xa5, 0xd4, 0xaa,
4319 0xff, 0xd4, 0xc0, 0x3b, 0x33, 0x4f, 0x07, 0x68, 0x25, 0x42, 0x37, 0x53, 0xa1, 0x57, 0x8a, 0x05,
4320 0xde, 0xcc, 0x4f, 0x27, 0xeb, 0x83, 0xe7, 0x2f, 0x2a, 0x73, 0xdf, 0xbc, 0xa8, 0xcc, 0x7d, 0xfb,
4321 0xa2, 0x32, 0xf7, 0xa7, 0x61, 0x45, 0x7b, 0x3e, 0xac, 0x68, 0xdf, 0x0c, 0x2b, 0xda, 0xb7, 0xc3,
4322 0x8a, 0xf6, 0xbf, 0x61, 0x45, 0xfb, 0xeb, 0xff, 0x2b, 0x73, 0xbf, 0x5d, 0x52, 0x72, 0xdf, 0x07,
4323 0x00, 0x00, 0xff, 0xff, 0x15, 0x2e, 0xf4, 0x72, 0x59, 0x16, 0x00, 0x00,
4324}