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