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