1
16
17
18
19
20 package v1beta1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28 v11 "k8s.io/api/core/v1"
29 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
30
31 math "math"
32 math_bits "math/bits"
33 reflect "reflect"
34 strings "strings"
35 )
36
37
38 var _ = proto.Marshal
39 var _ = fmt.Errorf
40 var _ = math.Inf
41
42
43
44
45
46 const _ = proto.GoGoProtoPackageIsVersion3
47
48 func (m *CronJob) Reset() { *m = CronJob{} }
49 func (*CronJob) ProtoMessage() {}
50 func (*CronJob) Descriptor() ([]byte, []int) {
51 return fileDescriptor_ed95843ae7b4086b, []int{0}
52 }
53 func (m *CronJob) XXX_Unmarshal(b []byte) error {
54 return m.Unmarshal(b)
55 }
56 func (m *CronJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
57 b = b[:cap(b)]
58 n, err := m.MarshalToSizedBuffer(b)
59 if err != nil {
60 return nil, err
61 }
62 return b[:n], nil
63 }
64 func (m *CronJob) XXX_Merge(src proto.Message) {
65 xxx_messageInfo_CronJob.Merge(m, src)
66 }
67 func (m *CronJob) XXX_Size() int {
68 return m.Size()
69 }
70 func (m *CronJob) XXX_DiscardUnknown() {
71 xxx_messageInfo_CronJob.DiscardUnknown(m)
72 }
73
74 var xxx_messageInfo_CronJob proto.InternalMessageInfo
75
76 func (m *CronJobList) Reset() { *m = CronJobList{} }
77 func (*CronJobList) ProtoMessage() {}
78 func (*CronJobList) Descriptor() ([]byte, []int) {
79 return fileDescriptor_ed95843ae7b4086b, []int{1}
80 }
81 func (m *CronJobList) XXX_Unmarshal(b []byte) error {
82 return m.Unmarshal(b)
83 }
84 func (m *CronJobList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
85 b = b[:cap(b)]
86 n, err := m.MarshalToSizedBuffer(b)
87 if err != nil {
88 return nil, err
89 }
90 return b[:n], nil
91 }
92 func (m *CronJobList) XXX_Merge(src proto.Message) {
93 xxx_messageInfo_CronJobList.Merge(m, src)
94 }
95 func (m *CronJobList) XXX_Size() int {
96 return m.Size()
97 }
98 func (m *CronJobList) XXX_DiscardUnknown() {
99 xxx_messageInfo_CronJobList.DiscardUnknown(m)
100 }
101
102 var xxx_messageInfo_CronJobList proto.InternalMessageInfo
103
104 func (m *CronJobSpec) Reset() { *m = CronJobSpec{} }
105 func (*CronJobSpec) ProtoMessage() {}
106 func (*CronJobSpec) Descriptor() ([]byte, []int) {
107 return fileDescriptor_ed95843ae7b4086b, []int{2}
108 }
109 func (m *CronJobSpec) XXX_Unmarshal(b []byte) error {
110 return m.Unmarshal(b)
111 }
112 func (m *CronJobSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
113 b = b[:cap(b)]
114 n, err := m.MarshalToSizedBuffer(b)
115 if err != nil {
116 return nil, err
117 }
118 return b[:n], nil
119 }
120 func (m *CronJobSpec) XXX_Merge(src proto.Message) {
121 xxx_messageInfo_CronJobSpec.Merge(m, src)
122 }
123 func (m *CronJobSpec) XXX_Size() int {
124 return m.Size()
125 }
126 func (m *CronJobSpec) XXX_DiscardUnknown() {
127 xxx_messageInfo_CronJobSpec.DiscardUnknown(m)
128 }
129
130 var xxx_messageInfo_CronJobSpec proto.InternalMessageInfo
131
132 func (m *CronJobStatus) Reset() { *m = CronJobStatus{} }
133 func (*CronJobStatus) ProtoMessage() {}
134 func (*CronJobStatus) Descriptor() ([]byte, []int) {
135 return fileDescriptor_ed95843ae7b4086b, []int{3}
136 }
137 func (m *CronJobStatus) XXX_Unmarshal(b []byte) error {
138 return m.Unmarshal(b)
139 }
140 func (m *CronJobStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
141 b = b[:cap(b)]
142 n, err := m.MarshalToSizedBuffer(b)
143 if err != nil {
144 return nil, err
145 }
146 return b[:n], nil
147 }
148 func (m *CronJobStatus) XXX_Merge(src proto.Message) {
149 xxx_messageInfo_CronJobStatus.Merge(m, src)
150 }
151 func (m *CronJobStatus) XXX_Size() int {
152 return m.Size()
153 }
154 func (m *CronJobStatus) XXX_DiscardUnknown() {
155 xxx_messageInfo_CronJobStatus.DiscardUnknown(m)
156 }
157
158 var xxx_messageInfo_CronJobStatus proto.InternalMessageInfo
159
160 func (m *JobTemplateSpec) Reset() { *m = JobTemplateSpec{} }
161 func (*JobTemplateSpec) ProtoMessage() {}
162 func (*JobTemplateSpec) Descriptor() ([]byte, []int) {
163 return fileDescriptor_ed95843ae7b4086b, []int{4}
164 }
165 func (m *JobTemplateSpec) XXX_Unmarshal(b []byte) error {
166 return m.Unmarshal(b)
167 }
168 func (m *JobTemplateSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
169 b = b[:cap(b)]
170 n, err := m.MarshalToSizedBuffer(b)
171 if err != nil {
172 return nil, err
173 }
174 return b[:n], nil
175 }
176 func (m *JobTemplateSpec) XXX_Merge(src proto.Message) {
177 xxx_messageInfo_JobTemplateSpec.Merge(m, src)
178 }
179 func (m *JobTemplateSpec) XXX_Size() int {
180 return m.Size()
181 }
182 func (m *JobTemplateSpec) XXX_DiscardUnknown() {
183 xxx_messageInfo_JobTemplateSpec.DiscardUnknown(m)
184 }
185
186 var xxx_messageInfo_JobTemplateSpec proto.InternalMessageInfo
187
188 func init() {
189 proto.RegisterType((*CronJob)(nil), "k8s.io.api.batch.v1beta1.CronJob")
190 proto.RegisterType((*CronJobList)(nil), "k8s.io.api.batch.v1beta1.CronJobList")
191 proto.RegisterType((*CronJobSpec)(nil), "k8s.io.api.batch.v1beta1.CronJobSpec")
192 proto.RegisterType((*CronJobStatus)(nil), "k8s.io.api.batch.v1beta1.CronJobStatus")
193 proto.RegisterType((*JobTemplateSpec)(nil), "k8s.io.api.batch.v1beta1.JobTemplateSpec")
194 }
195
196 func init() {
197 proto.RegisterFile("k8s.io/api/batch/v1beta1/generated.proto", fileDescriptor_ed95843ae7b4086b)
198 }
199
200 var fileDescriptor_ed95843ae7b4086b = []byte{
201
202 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x95, 0xcf, 0x8f, 0xdb, 0x44,
203 0x14, 0xc7, 0xe3, 0x6c, 0x7e, 0x75, 0xd2, 0xc2, 0x76, 0x40, 0x5b, 0x2b, 0x20, 0x3b, 0xa4, 0xaa,
204 0x08, 0x08, 0xc6, 0xec, 0x0a, 0x21, 0x4e, 0x95, 0x70, 0x51, 0x81, 0x25, 0xa8, 0x68, 0x52, 0x2e,
205 0x55, 0x85, 0x3a, 0x9e, 0x4c, 0x92, 0xe9, 0xda, 0x1e, 0xcb, 0x33, 0x5e, 0x29, 0x37, 0x2e, 0xdc,
206 0xf9, 0x5f, 0xb8, 0x73, 0xde, 0x63, 0x6f, 0xf4, 0x64, 0xb1, 0xe6, 0xbf, 0xe0, 0x84, 0x66, 0xe2,
207 0x4d, 0xd2, 0xc4, 0xe9, 0x96, 0x0b, 0xb7, 0xcc, 0xf3, 0xf7, 0xfb, 0x99, 0xa7, 0xf7, 0xde, 0xbc,
208 0x80, 0xe1, 0xd9, 0x97, 0x12, 0x71, 0xe1, 0x91, 0x84, 0x7b, 0x01, 0x51, 0x74, 0xee, 0x9d, 0x1f,
209 0x07, 0x4c, 0x91, 0x63, 0x6f, 0xc6, 0x62, 0x96, 0x12, 0xc5, 0x26, 0x28, 0x49, 0x85, 0x12, 0xd0,
210 0x5e, 0x2a, 0x11, 0x49, 0x38, 0x32, 0x4a, 0x54, 0x2a, 0x7b, 0x9f, 0xce, 0xb8, 0x9a, 0x67, 0x01,
211 0xa2, 0x22, 0xf2, 0x66, 0x62, 0x26, 0x3c, 0x63, 0x08, 0xb2, 0xa9, 0x39, 0x99, 0x83, 0xf9, 0xb5,
212 0x04, 0xf5, 0xee, 0x56, 0x5c, 0xb9, 0x7d, 0x5b, 0x6f, 0xb0, 0x21, 0xa2, 0x22, 0x65, 0x55, 0x9a,
213 0xcf, 0xd7, 0x9a, 0x88, 0xd0, 0x39, 0x8f, 0x59, 0xba, 0xf0, 0x92, 0xb3, 0x99, 0x0e, 0x48, 0x2f,
214 0x62, 0x8a, 0x54, 0xb9, 0xbc, 0x7d, 0xae, 0x34, 0x8b, 0x15, 0x8f, 0xd8, 0x8e, 0xe1, 0x8b, 0xeb,
215 0x0c, 0x92, 0xce, 0x59, 0x44, 0xb6, 0x7d, 0x83, 0x5f, 0xeb, 0xa0, 0xfd, 0x20, 0x15, 0xf1, 0xa9,
216 0x08, 0xe0, 0x33, 0xd0, 0xd1, 0xf9, 0x4c, 0x88, 0x22, 0xb6, 0xd5, 0xb7, 0x86, 0xdd, 0x93, 0xcf,
217 0xd0, 0xba, 0x9e, 0x2b, 0x2c, 0x4a, 0xce, 0x66, 0x3a, 0x20, 0x91, 0x56, 0xa3, 0xf3, 0x63, 0xf4,
218 0x28, 0x78, 0xce, 0xa8, 0xfa, 0x81, 0x29, 0xe2, 0xc3, 0x8b, 0xdc, 0xad, 0x15, 0xb9, 0x0b, 0xd6,
219 0x31, 0xbc, 0xa2, 0xc2, 0x6f, 0x40, 0x43, 0x26, 0x8c, 0xda, 0x75, 0x43, 0xbf, 0x87, 0xf6, 0x75,
220 0x0b, 0x95, 0x29, 0x8d, 0x13, 0x46, 0xfd, 0x9b, 0x25, 0xb2, 0xa1, 0x4f, 0xd8, 0x00, 0xe0, 0x23,
221 0xd0, 0x92, 0x8a, 0xa8, 0x4c, 0xda, 0x07, 0x06, 0xf5, 0xe1, 0xf5, 0x28, 0x23, 0xf7, 0xdf, 0x2a,
222 0x61, 0xad, 0xe5, 0x19, 0x97, 0x98, 0xc1, 0xef, 0x16, 0xe8, 0x96, 0xca, 0x11, 0x97, 0x0a, 0x3e,
223 0xdd, 0xa9, 0x05, 0x7a, 0xb3, 0x5a, 0x68, 0xb7, 0xa9, 0xc4, 0x61, 0x79, 0x53, 0xe7, 0x2a, 0xb2,
224 0x51, 0x87, 0x87, 0xa0, 0xc9, 0x15, 0x8b, 0xa4, 0x5d, 0xef, 0x1f, 0x0c, 0xbb, 0x27, 0x1f, 0x5c,
225 0x9b, 0xbd, 0x7f, 0xab, 0xa4, 0x35, 0xbf, 0xd3, 0x3e, 0xbc, 0xb4, 0x0f, 0xfe, 0x6c, 0xac, 0xb2,
226 0xd6, 0xc5, 0x81, 0x9f, 0x80, 0x8e, 0xee, 0xf3, 0x24, 0x0b, 0x99, 0xc9, 0xfa, 0xc6, 0x3a, 0x8b,
227 0x71, 0x19, 0xc7, 0x2b, 0x05, 0x1c, 0x82, 0x8e, 0x1e, 0x8d, 0x27, 0x22, 0x66, 0x76, 0xc7, 0xa8,
228 0x6f, 0x6a, 0xe5, 0xe3, 0x32, 0x86, 0x57, 0x5f, 0xe1, 0x4f, 0xe0, 0x8e, 0x54, 0x24, 0x55, 0x3c,
229 0x9e, 0x7d, 0xcd, 0xc8, 0x24, 0xe4, 0x31, 0x1b, 0x33, 0x2a, 0xe2, 0x89, 0x34, 0xad, 0x3c, 0xf0,
230 0xdf, 0x2b, 0x72, 0xf7, 0xce, 0xb8, 0x5a, 0x82, 0xf7, 0x79, 0xe1, 0x53, 0x70, 0x9b, 0x8a, 0x98,
231 0x66, 0x69, 0xca, 0x62, 0xba, 0xf8, 0x51, 0x84, 0x9c, 0x2e, 0x4c, 0x43, 0x6f, 0xf8, 0xa8, 0xcc,
232 0xfb, 0xf6, 0x83, 0x6d, 0xc1, 0x3f, 0x55, 0x41, 0xbc, 0x0b, 0x82, 0xf7, 0x40, 0x5b, 0x66, 0x32,
233 0x61, 0xf1, 0xc4, 0x6e, 0xf4, 0xad, 0x61, 0xc7, 0xef, 0x16, 0xb9, 0xdb, 0x1e, 0x2f, 0x43, 0xf8,
234 0xea, 0x1b, 0x7c, 0x06, 0xba, 0xcf, 0x45, 0xf0, 0x98, 0x45, 0x49, 0x48, 0x14, 0xb3, 0x9b, 0xa6,
235 0xd9, 0x1f, 0xed, 0xef, 0xc8, 0xe9, 0x5a, 0x6c, 0xc6, 0xf3, 0x9d, 0x32, 0xd3, 0xee, 0xc6, 0x07,
236 0xbc, 0x89, 0x84, 0x3f, 0x83, 0x9e, 0xcc, 0x28, 0x65, 0x52, 0x4e, 0xb3, 0xf0, 0x54, 0x04, 0xf2,
237 0x5b, 0x2e, 0x95, 0x48, 0x17, 0x23, 0x1e, 0x71, 0x65, 0xb7, 0xfa, 0xd6, 0xb0, 0xe9, 0x3b, 0x45,
238 0xee, 0xf6, 0xc6, 0x7b, 0x55, 0xf8, 0x35, 0x04, 0x88, 0xc1, 0xd1, 0x94, 0xf0, 0x90, 0x4d, 0x76,
239 0xd8, 0x6d, 0xc3, 0xee, 0x15, 0xb9, 0x7b, 0xf4, 0xb0, 0x52, 0x81, 0xf7, 0x38, 0x07, 0x7f, 0xd4,
240 0xc1, 0xad, 0x57, 0x5e, 0x0e, 0xfc, 0x1e, 0xb4, 0x08, 0x55, 0xfc, 0x5c, 0x4f, 0x96, 0x1e, 0xda,
241 0xbb, 0x9b, 0x25, 0xd2, 0xdb, 0x6f, 0xbd, 0x09, 0x30, 0x9b, 0x32, 0xdd, 0x09, 0xb6, 0x7e, 0x6e,
242 0x5f, 0x19, 0x2b, 0x2e, 0x11, 0x30, 0x04, 0x87, 0x21, 0x91, 0xea, 0x6a, 0x28, 0xf5, 0xc8, 0x99,
243 0x26, 0x75, 0x4f, 0x3e, 0x7e, 0xb3, 0x67, 0xa6, 0x1d, 0xfe, 0xbb, 0x45, 0xee, 0x1e, 0x8e, 0xb6,
244 0x38, 0x78, 0x87, 0x0c, 0x53, 0x00, 0x4d, 0x6c, 0x55, 0x42, 0x73, 0x5f, 0xf3, 0x3f, 0xdf, 0x77,
245 0x54, 0xe4, 0x2e, 0x1c, 0xed, 0x90, 0x70, 0x05, 0x5d, 0x2f, 0x94, 0xb7, 0xb7, 0x46, 0xe5, 0x7f,
246 0x58, 0xb0, 0xf7, 0x5f, 0x59, 0xb0, 0xef, 0x57, 0x4d, 0x31, 0x7a, 0xcd, 0x5e, 0xf5, 0xef, 0x5f,
247 0x5c, 0x3a, 0xb5, 0x17, 0x97, 0x4e, 0xed, 0xe5, 0xa5, 0x53, 0xfb, 0xa5, 0x70, 0xac, 0x8b, 0xc2,
248 0xb1, 0x5e, 0x14, 0x8e, 0xf5, 0xb2, 0x70, 0xac, 0xbf, 0x0a, 0xc7, 0xfa, 0xed, 0x6f, 0xa7, 0xf6,
249 0xc4, 0xde, 0xf7, 0x7f, 0xfc, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xaa, 0x2c, 0x86, 0xaa,
250 0x07, 0x00, 0x00,
251 }
252
253 func (m *CronJob) Marshal() (dAtA []byte, err error) {
254 size := m.Size()
255 dAtA = make([]byte, size)
256 n, err := m.MarshalToSizedBuffer(dAtA[:size])
257 if err != nil {
258 return nil, err
259 }
260 return dAtA[:n], nil
261 }
262
263 func (m *CronJob) MarshalTo(dAtA []byte) (int, error) {
264 size := m.Size()
265 return m.MarshalToSizedBuffer(dAtA[:size])
266 }
267
268 func (m *CronJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
269 i := len(dAtA)
270 _ = i
271 var l int
272 _ = l
273 {
274 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
275 if err != nil {
276 return 0, err
277 }
278 i -= size
279 i = encodeVarintGenerated(dAtA, i, uint64(size))
280 }
281 i--
282 dAtA[i] = 0x1a
283 {
284 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
285 if err != nil {
286 return 0, err
287 }
288 i -= size
289 i = encodeVarintGenerated(dAtA, i, uint64(size))
290 }
291 i--
292 dAtA[i] = 0x12
293 {
294 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
295 if err != nil {
296 return 0, err
297 }
298 i -= size
299 i = encodeVarintGenerated(dAtA, i, uint64(size))
300 }
301 i--
302 dAtA[i] = 0xa
303 return len(dAtA) - i, nil
304 }
305
306 func (m *CronJobList) Marshal() (dAtA []byte, err error) {
307 size := m.Size()
308 dAtA = make([]byte, size)
309 n, err := m.MarshalToSizedBuffer(dAtA[:size])
310 if err != nil {
311 return nil, err
312 }
313 return dAtA[:n], nil
314 }
315
316 func (m *CronJobList) MarshalTo(dAtA []byte) (int, error) {
317 size := m.Size()
318 return m.MarshalToSizedBuffer(dAtA[:size])
319 }
320
321 func (m *CronJobList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
322 i := len(dAtA)
323 _ = i
324 var l int
325 _ = l
326 if len(m.Items) > 0 {
327 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
328 {
329 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
330 if err != nil {
331 return 0, err
332 }
333 i -= size
334 i = encodeVarintGenerated(dAtA, i, uint64(size))
335 }
336 i--
337 dAtA[i] = 0x12
338 }
339 }
340 {
341 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
342 if err != nil {
343 return 0, err
344 }
345 i -= size
346 i = encodeVarintGenerated(dAtA, i, uint64(size))
347 }
348 i--
349 dAtA[i] = 0xa
350 return len(dAtA) - i, nil
351 }
352
353 func (m *CronJobSpec) Marshal() (dAtA []byte, err error) {
354 size := m.Size()
355 dAtA = make([]byte, size)
356 n, err := m.MarshalToSizedBuffer(dAtA[:size])
357 if err != nil {
358 return nil, err
359 }
360 return dAtA[:n], nil
361 }
362
363 func (m *CronJobSpec) MarshalTo(dAtA []byte) (int, error) {
364 size := m.Size()
365 return m.MarshalToSizedBuffer(dAtA[:size])
366 }
367
368 func (m *CronJobSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
369 i := len(dAtA)
370 _ = i
371 var l int
372 _ = l
373 if m.TimeZone != nil {
374 i -= len(*m.TimeZone)
375 copy(dAtA[i:], *m.TimeZone)
376 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.TimeZone)))
377 i--
378 dAtA[i] = 0x42
379 }
380 if m.FailedJobsHistoryLimit != nil {
381 i = encodeVarintGenerated(dAtA, i, uint64(*m.FailedJobsHistoryLimit))
382 i--
383 dAtA[i] = 0x38
384 }
385 if m.SuccessfulJobsHistoryLimit != nil {
386 i = encodeVarintGenerated(dAtA, i, uint64(*m.SuccessfulJobsHistoryLimit))
387 i--
388 dAtA[i] = 0x30
389 }
390 {
391 size, err := m.JobTemplate.MarshalToSizedBuffer(dAtA[:i])
392 if err != nil {
393 return 0, err
394 }
395 i -= size
396 i = encodeVarintGenerated(dAtA, i, uint64(size))
397 }
398 i--
399 dAtA[i] = 0x2a
400 if m.Suspend != nil {
401 i--
402 if *m.Suspend {
403 dAtA[i] = 1
404 } else {
405 dAtA[i] = 0
406 }
407 i--
408 dAtA[i] = 0x20
409 }
410 i -= len(m.ConcurrencyPolicy)
411 copy(dAtA[i:], m.ConcurrencyPolicy)
412 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ConcurrencyPolicy)))
413 i--
414 dAtA[i] = 0x1a
415 if m.StartingDeadlineSeconds != nil {
416 i = encodeVarintGenerated(dAtA, i, uint64(*m.StartingDeadlineSeconds))
417 i--
418 dAtA[i] = 0x10
419 }
420 i -= len(m.Schedule)
421 copy(dAtA[i:], m.Schedule)
422 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Schedule)))
423 i--
424 dAtA[i] = 0xa
425 return len(dAtA) - i, nil
426 }
427
428 func (m *CronJobStatus) Marshal() (dAtA []byte, err error) {
429 size := m.Size()
430 dAtA = make([]byte, size)
431 n, err := m.MarshalToSizedBuffer(dAtA[:size])
432 if err != nil {
433 return nil, err
434 }
435 return dAtA[:n], nil
436 }
437
438 func (m *CronJobStatus) MarshalTo(dAtA []byte) (int, error) {
439 size := m.Size()
440 return m.MarshalToSizedBuffer(dAtA[:size])
441 }
442
443 func (m *CronJobStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
444 i := len(dAtA)
445 _ = i
446 var l int
447 _ = l
448 if m.LastSuccessfulTime != nil {
449 {
450 size, err := m.LastSuccessfulTime.MarshalToSizedBuffer(dAtA[:i])
451 if err != nil {
452 return 0, err
453 }
454 i -= size
455 i = encodeVarintGenerated(dAtA, i, uint64(size))
456 }
457 i--
458 dAtA[i] = 0x2a
459 }
460 if m.LastScheduleTime != nil {
461 {
462 size, err := m.LastScheduleTime.MarshalToSizedBuffer(dAtA[:i])
463 if err != nil {
464 return 0, err
465 }
466 i -= size
467 i = encodeVarintGenerated(dAtA, i, uint64(size))
468 }
469 i--
470 dAtA[i] = 0x22
471 }
472 if len(m.Active) > 0 {
473 for iNdEx := len(m.Active) - 1; iNdEx >= 0; iNdEx-- {
474 {
475 size, err := m.Active[iNdEx].MarshalToSizedBuffer(dAtA[:i])
476 if err != nil {
477 return 0, err
478 }
479 i -= size
480 i = encodeVarintGenerated(dAtA, i, uint64(size))
481 }
482 i--
483 dAtA[i] = 0xa
484 }
485 }
486 return len(dAtA) - i, nil
487 }
488
489 func (m *JobTemplateSpec) Marshal() (dAtA []byte, err error) {
490 size := m.Size()
491 dAtA = make([]byte, size)
492 n, err := m.MarshalToSizedBuffer(dAtA[:size])
493 if err != nil {
494 return nil, err
495 }
496 return dAtA[:n], nil
497 }
498
499 func (m *JobTemplateSpec) MarshalTo(dAtA []byte) (int, error) {
500 size := m.Size()
501 return m.MarshalToSizedBuffer(dAtA[:size])
502 }
503
504 func (m *JobTemplateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
505 i := len(dAtA)
506 _ = i
507 var l int
508 _ = l
509 {
510 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
511 if err != nil {
512 return 0, err
513 }
514 i -= size
515 i = encodeVarintGenerated(dAtA, i, uint64(size))
516 }
517 i--
518 dAtA[i] = 0x12
519 {
520 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
521 if err != nil {
522 return 0, err
523 }
524 i -= size
525 i = encodeVarintGenerated(dAtA, i, uint64(size))
526 }
527 i--
528 dAtA[i] = 0xa
529 return len(dAtA) - i, nil
530 }
531
532 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
533 offset -= sovGenerated(v)
534 base := offset
535 for v >= 1<<7 {
536 dAtA[offset] = uint8(v&0x7f | 0x80)
537 v >>= 7
538 offset++
539 }
540 dAtA[offset] = uint8(v)
541 return base
542 }
543 func (m *CronJob) Size() (n int) {
544 if m == nil {
545 return 0
546 }
547 var l int
548 _ = l
549 l = m.ObjectMeta.Size()
550 n += 1 + l + sovGenerated(uint64(l))
551 l = m.Spec.Size()
552 n += 1 + l + sovGenerated(uint64(l))
553 l = m.Status.Size()
554 n += 1 + l + sovGenerated(uint64(l))
555 return n
556 }
557
558 func (m *CronJobList) Size() (n int) {
559 if m == nil {
560 return 0
561 }
562 var l int
563 _ = l
564 l = m.ListMeta.Size()
565 n += 1 + l + sovGenerated(uint64(l))
566 if len(m.Items) > 0 {
567 for _, e := range m.Items {
568 l = e.Size()
569 n += 1 + l + sovGenerated(uint64(l))
570 }
571 }
572 return n
573 }
574
575 func (m *CronJobSpec) Size() (n int) {
576 if m == nil {
577 return 0
578 }
579 var l int
580 _ = l
581 l = len(m.Schedule)
582 n += 1 + l + sovGenerated(uint64(l))
583 if m.StartingDeadlineSeconds != nil {
584 n += 1 + sovGenerated(uint64(*m.StartingDeadlineSeconds))
585 }
586 l = len(m.ConcurrencyPolicy)
587 n += 1 + l + sovGenerated(uint64(l))
588 if m.Suspend != nil {
589 n += 2
590 }
591 l = m.JobTemplate.Size()
592 n += 1 + l + sovGenerated(uint64(l))
593 if m.SuccessfulJobsHistoryLimit != nil {
594 n += 1 + sovGenerated(uint64(*m.SuccessfulJobsHistoryLimit))
595 }
596 if m.FailedJobsHistoryLimit != nil {
597 n += 1 + sovGenerated(uint64(*m.FailedJobsHistoryLimit))
598 }
599 if m.TimeZone != nil {
600 l = len(*m.TimeZone)
601 n += 1 + l + sovGenerated(uint64(l))
602 }
603 return n
604 }
605
606 func (m *CronJobStatus) Size() (n int) {
607 if m == nil {
608 return 0
609 }
610 var l int
611 _ = l
612 if len(m.Active) > 0 {
613 for _, e := range m.Active {
614 l = e.Size()
615 n += 1 + l + sovGenerated(uint64(l))
616 }
617 }
618 if m.LastScheduleTime != nil {
619 l = m.LastScheduleTime.Size()
620 n += 1 + l + sovGenerated(uint64(l))
621 }
622 if m.LastSuccessfulTime != nil {
623 l = m.LastSuccessfulTime.Size()
624 n += 1 + l + sovGenerated(uint64(l))
625 }
626 return n
627 }
628
629 func (m *JobTemplateSpec) Size() (n int) {
630 if m == nil {
631 return 0
632 }
633 var l int
634 _ = l
635 l = m.ObjectMeta.Size()
636 n += 1 + l + sovGenerated(uint64(l))
637 l = m.Spec.Size()
638 n += 1 + l + sovGenerated(uint64(l))
639 return n
640 }
641
642 func sovGenerated(x uint64) (n int) {
643 return (math_bits.Len64(x|1) + 6) / 7
644 }
645 func sozGenerated(x uint64) (n int) {
646 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
647 }
648 func (this *CronJob) String() string {
649 if this == nil {
650 return "nil"
651 }
652 s := strings.Join([]string{`&CronJob{`,
653 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
654 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CronJobSpec", "CronJobSpec", 1), `&`, ``, 1) + `,`,
655 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CronJobStatus", "CronJobStatus", 1), `&`, ``, 1) + `,`,
656 `}`,
657 }, "")
658 return s
659 }
660 func (this *CronJobList) String() string {
661 if this == nil {
662 return "nil"
663 }
664 repeatedStringForItems := "[]CronJob{"
665 for _, f := range this.Items {
666 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CronJob", "CronJob", 1), `&`, ``, 1) + ","
667 }
668 repeatedStringForItems += "}"
669 s := strings.Join([]string{`&CronJobList{`,
670 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
671 `Items:` + repeatedStringForItems + `,`,
672 `}`,
673 }, "")
674 return s
675 }
676 func (this *CronJobSpec) String() string {
677 if this == nil {
678 return "nil"
679 }
680 s := strings.Join([]string{`&CronJobSpec{`,
681 `Schedule:` + fmt.Sprintf("%v", this.Schedule) + `,`,
682 `StartingDeadlineSeconds:` + valueToStringGenerated(this.StartingDeadlineSeconds) + `,`,
683 `ConcurrencyPolicy:` + fmt.Sprintf("%v", this.ConcurrencyPolicy) + `,`,
684 `Suspend:` + valueToStringGenerated(this.Suspend) + `,`,
685 `JobTemplate:` + strings.Replace(strings.Replace(this.JobTemplate.String(), "JobTemplateSpec", "JobTemplateSpec", 1), `&`, ``, 1) + `,`,
686 `SuccessfulJobsHistoryLimit:` + valueToStringGenerated(this.SuccessfulJobsHistoryLimit) + `,`,
687 `FailedJobsHistoryLimit:` + valueToStringGenerated(this.FailedJobsHistoryLimit) + `,`,
688 `TimeZone:` + valueToStringGenerated(this.TimeZone) + `,`,
689 `}`,
690 }, "")
691 return s
692 }
693 func (this *CronJobStatus) String() string {
694 if this == nil {
695 return "nil"
696 }
697 repeatedStringForActive := "[]ObjectReference{"
698 for _, f := range this.Active {
699 repeatedStringForActive += fmt.Sprintf("%v", f) + ","
700 }
701 repeatedStringForActive += "}"
702 s := strings.Join([]string{`&CronJobStatus{`,
703 `Active:` + repeatedStringForActive + `,`,
704 `LastScheduleTime:` + strings.Replace(fmt.Sprintf("%v", this.LastScheduleTime), "Time", "v1.Time", 1) + `,`,
705 `LastSuccessfulTime:` + strings.Replace(fmt.Sprintf("%v", this.LastSuccessfulTime), "Time", "v1.Time", 1) + `,`,
706 `}`,
707 }, "")
708 return s
709 }
710 func (this *JobTemplateSpec) String() string {
711 if this == nil {
712 return "nil"
713 }
714 s := strings.Join([]string{`&JobTemplateSpec{`,
715 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
716 `Spec:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Spec), "JobSpec", "v12.JobSpec", 1), `&`, ``, 1) + `,`,
717 `}`,
718 }, "")
719 return s
720 }
721 func valueToStringGenerated(v interface{}) string {
722 rv := reflect.ValueOf(v)
723 if rv.IsNil() {
724 return "nil"
725 }
726 pv := reflect.Indirect(rv).Interface()
727 return fmt.Sprintf("*%v", pv)
728 }
729 func (m *CronJob) Unmarshal(dAtA []byte) error {
730 l := len(dAtA)
731 iNdEx := 0
732 for iNdEx < l {
733 preIndex := iNdEx
734 var wire uint64
735 for shift := uint(0); ; shift += 7 {
736 if shift >= 64 {
737 return ErrIntOverflowGenerated
738 }
739 if iNdEx >= l {
740 return io.ErrUnexpectedEOF
741 }
742 b := dAtA[iNdEx]
743 iNdEx++
744 wire |= uint64(b&0x7F) << shift
745 if b < 0x80 {
746 break
747 }
748 }
749 fieldNum := int32(wire >> 3)
750 wireType := int(wire & 0x7)
751 if wireType == 4 {
752 return fmt.Errorf("proto: CronJob: wiretype end group for non-group")
753 }
754 if fieldNum <= 0 {
755 return fmt.Errorf("proto: CronJob: illegal tag %d (wire type %d)", fieldNum, wire)
756 }
757 switch fieldNum {
758 case 1:
759 if wireType != 2 {
760 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
761 }
762 var msglen int
763 for shift := uint(0); ; shift += 7 {
764 if shift >= 64 {
765 return ErrIntOverflowGenerated
766 }
767 if iNdEx >= l {
768 return io.ErrUnexpectedEOF
769 }
770 b := dAtA[iNdEx]
771 iNdEx++
772 msglen |= int(b&0x7F) << shift
773 if b < 0x80 {
774 break
775 }
776 }
777 if msglen < 0 {
778 return ErrInvalidLengthGenerated
779 }
780 postIndex := iNdEx + msglen
781 if postIndex < 0 {
782 return ErrInvalidLengthGenerated
783 }
784 if postIndex > l {
785 return io.ErrUnexpectedEOF
786 }
787 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
788 return err
789 }
790 iNdEx = postIndex
791 case 2:
792 if wireType != 2 {
793 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
794 }
795 var msglen int
796 for shift := uint(0); ; shift += 7 {
797 if shift >= 64 {
798 return ErrIntOverflowGenerated
799 }
800 if iNdEx >= l {
801 return io.ErrUnexpectedEOF
802 }
803 b := dAtA[iNdEx]
804 iNdEx++
805 msglen |= int(b&0x7F) << shift
806 if b < 0x80 {
807 break
808 }
809 }
810 if msglen < 0 {
811 return ErrInvalidLengthGenerated
812 }
813 postIndex := iNdEx + msglen
814 if postIndex < 0 {
815 return ErrInvalidLengthGenerated
816 }
817 if postIndex > l {
818 return io.ErrUnexpectedEOF
819 }
820 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
821 return err
822 }
823 iNdEx = postIndex
824 case 3:
825 if wireType != 2 {
826 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
827 }
828 var msglen int
829 for shift := uint(0); ; shift += 7 {
830 if shift >= 64 {
831 return ErrIntOverflowGenerated
832 }
833 if iNdEx >= l {
834 return io.ErrUnexpectedEOF
835 }
836 b := dAtA[iNdEx]
837 iNdEx++
838 msglen |= int(b&0x7F) << shift
839 if b < 0x80 {
840 break
841 }
842 }
843 if msglen < 0 {
844 return ErrInvalidLengthGenerated
845 }
846 postIndex := iNdEx + msglen
847 if postIndex < 0 {
848 return ErrInvalidLengthGenerated
849 }
850 if postIndex > l {
851 return io.ErrUnexpectedEOF
852 }
853 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
854 return err
855 }
856 iNdEx = postIndex
857 default:
858 iNdEx = preIndex
859 skippy, err := skipGenerated(dAtA[iNdEx:])
860 if err != nil {
861 return err
862 }
863 if (skippy < 0) || (iNdEx+skippy) < 0 {
864 return ErrInvalidLengthGenerated
865 }
866 if (iNdEx + skippy) > l {
867 return io.ErrUnexpectedEOF
868 }
869 iNdEx += skippy
870 }
871 }
872
873 if iNdEx > l {
874 return io.ErrUnexpectedEOF
875 }
876 return nil
877 }
878 func (m *CronJobList) Unmarshal(dAtA []byte) error {
879 l := len(dAtA)
880 iNdEx := 0
881 for iNdEx < l {
882 preIndex := iNdEx
883 var wire uint64
884 for shift := uint(0); ; shift += 7 {
885 if shift >= 64 {
886 return ErrIntOverflowGenerated
887 }
888 if iNdEx >= l {
889 return io.ErrUnexpectedEOF
890 }
891 b := dAtA[iNdEx]
892 iNdEx++
893 wire |= uint64(b&0x7F) << shift
894 if b < 0x80 {
895 break
896 }
897 }
898 fieldNum := int32(wire >> 3)
899 wireType := int(wire & 0x7)
900 if wireType == 4 {
901 return fmt.Errorf("proto: CronJobList: wiretype end group for non-group")
902 }
903 if fieldNum <= 0 {
904 return fmt.Errorf("proto: CronJobList: illegal tag %d (wire type %d)", fieldNum, wire)
905 }
906 switch fieldNum {
907 case 1:
908 if wireType != 2 {
909 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
910 }
911 var msglen int
912 for shift := uint(0); ; shift += 7 {
913 if shift >= 64 {
914 return ErrIntOverflowGenerated
915 }
916 if iNdEx >= l {
917 return io.ErrUnexpectedEOF
918 }
919 b := dAtA[iNdEx]
920 iNdEx++
921 msglen |= int(b&0x7F) << shift
922 if b < 0x80 {
923 break
924 }
925 }
926 if msglen < 0 {
927 return ErrInvalidLengthGenerated
928 }
929 postIndex := iNdEx + msglen
930 if postIndex < 0 {
931 return ErrInvalidLengthGenerated
932 }
933 if postIndex > l {
934 return io.ErrUnexpectedEOF
935 }
936 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
937 return err
938 }
939 iNdEx = postIndex
940 case 2:
941 if wireType != 2 {
942 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
943 }
944 var msglen int
945 for shift := uint(0); ; shift += 7 {
946 if shift >= 64 {
947 return ErrIntOverflowGenerated
948 }
949 if iNdEx >= l {
950 return io.ErrUnexpectedEOF
951 }
952 b := dAtA[iNdEx]
953 iNdEx++
954 msglen |= int(b&0x7F) << shift
955 if b < 0x80 {
956 break
957 }
958 }
959 if msglen < 0 {
960 return ErrInvalidLengthGenerated
961 }
962 postIndex := iNdEx + msglen
963 if postIndex < 0 {
964 return ErrInvalidLengthGenerated
965 }
966 if postIndex > l {
967 return io.ErrUnexpectedEOF
968 }
969 m.Items = append(m.Items, CronJob{})
970 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
971 return err
972 }
973 iNdEx = postIndex
974 default:
975 iNdEx = preIndex
976 skippy, err := skipGenerated(dAtA[iNdEx:])
977 if err != nil {
978 return err
979 }
980 if (skippy < 0) || (iNdEx+skippy) < 0 {
981 return ErrInvalidLengthGenerated
982 }
983 if (iNdEx + skippy) > l {
984 return io.ErrUnexpectedEOF
985 }
986 iNdEx += skippy
987 }
988 }
989
990 if iNdEx > l {
991 return io.ErrUnexpectedEOF
992 }
993 return nil
994 }
995 func (m *CronJobSpec) Unmarshal(dAtA []byte) error {
996 l := len(dAtA)
997 iNdEx := 0
998 for iNdEx < l {
999 preIndex := iNdEx
1000 var wire uint64
1001 for shift := uint(0); ; shift += 7 {
1002 if shift >= 64 {
1003 return ErrIntOverflowGenerated
1004 }
1005 if iNdEx >= l {
1006 return io.ErrUnexpectedEOF
1007 }
1008 b := dAtA[iNdEx]
1009 iNdEx++
1010 wire |= uint64(b&0x7F) << shift
1011 if b < 0x80 {
1012 break
1013 }
1014 }
1015 fieldNum := int32(wire >> 3)
1016 wireType := int(wire & 0x7)
1017 if wireType == 4 {
1018 return fmt.Errorf("proto: CronJobSpec: wiretype end group for non-group")
1019 }
1020 if fieldNum <= 0 {
1021 return fmt.Errorf("proto: CronJobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1022 }
1023 switch fieldNum {
1024 case 1:
1025 if wireType != 2 {
1026 return fmt.Errorf("proto: wrong wireType = %d for field Schedule", wireType)
1027 }
1028 var stringLen uint64
1029 for shift := uint(0); ; shift += 7 {
1030 if shift >= 64 {
1031 return ErrIntOverflowGenerated
1032 }
1033 if iNdEx >= l {
1034 return io.ErrUnexpectedEOF
1035 }
1036 b := dAtA[iNdEx]
1037 iNdEx++
1038 stringLen |= uint64(b&0x7F) << shift
1039 if b < 0x80 {
1040 break
1041 }
1042 }
1043 intStringLen := int(stringLen)
1044 if intStringLen < 0 {
1045 return ErrInvalidLengthGenerated
1046 }
1047 postIndex := iNdEx + intStringLen
1048 if postIndex < 0 {
1049 return ErrInvalidLengthGenerated
1050 }
1051 if postIndex > l {
1052 return io.ErrUnexpectedEOF
1053 }
1054 m.Schedule = string(dAtA[iNdEx:postIndex])
1055 iNdEx = postIndex
1056 case 2:
1057 if wireType != 0 {
1058 return fmt.Errorf("proto: wrong wireType = %d for field StartingDeadlineSeconds", wireType)
1059 }
1060 var v int64
1061 for shift := uint(0); ; shift += 7 {
1062 if shift >= 64 {
1063 return ErrIntOverflowGenerated
1064 }
1065 if iNdEx >= l {
1066 return io.ErrUnexpectedEOF
1067 }
1068 b := dAtA[iNdEx]
1069 iNdEx++
1070 v |= int64(b&0x7F) << shift
1071 if b < 0x80 {
1072 break
1073 }
1074 }
1075 m.StartingDeadlineSeconds = &v
1076 case 3:
1077 if wireType != 2 {
1078 return fmt.Errorf("proto: wrong wireType = %d for field ConcurrencyPolicy", wireType)
1079 }
1080 var stringLen uint64
1081 for shift := uint(0); ; shift += 7 {
1082 if shift >= 64 {
1083 return ErrIntOverflowGenerated
1084 }
1085 if iNdEx >= l {
1086 return io.ErrUnexpectedEOF
1087 }
1088 b := dAtA[iNdEx]
1089 iNdEx++
1090 stringLen |= uint64(b&0x7F) << shift
1091 if b < 0x80 {
1092 break
1093 }
1094 }
1095 intStringLen := int(stringLen)
1096 if intStringLen < 0 {
1097 return ErrInvalidLengthGenerated
1098 }
1099 postIndex := iNdEx + intStringLen
1100 if postIndex < 0 {
1101 return ErrInvalidLengthGenerated
1102 }
1103 if postIndex > l {
1104 return io.ErrUnexpectedEOF
1105 }
1106 m.ConcurrencyPolicy = ConcurrencyPolicy(dAtA[iNdEx:postIndex])
1107 iNdEx = postIndex
1108 case 4:
1109 if wireType != 0 {
1110 return fmt.Errorf("proto: wrong wireType = %d for field Suspend", wireType)
1111 }
1112 var v int
1113 for shift := uint(0); ; shift += 7 {
1114 if shift >= 64 {
1115 return ErrIntOverflowGenerated
1116 }
1117 if iNdEx >= l {
1118 return io.ErrUnexpectedEOF
1119 }
1120 b := dAtA[iNdEx]
1121 iNdEx++
1122 v |= int(b&0x7F) << shift
1123 if b < 0x80 {
1124 break
1125 }
1126 }
1127 b := bool(v != 0)
1128 m.Suspend = &b
1129 case 5:
1130 if wireType != 2 {
1131 return fmt.Errorf("proto: wrong wireType = %d for field JobTemplate", wireType)
1132 }
1133 var msglen int
1134 for shift := uint(0); ; shift += 7 {
1135 if shift >= 64 {
1136 return ErrIntOverflowGenerated
1137 }
1138 if iNdEx >= l {
1139 return io.ErrUnexpectedEOF
1140 }
1141 b := dAtA[iNdEx]
1142 iNdEx++
1143 msglen |= int(b&0x7F) << shift
1144 if b < 0x80 {
1145 break
1146 }
1147 }
1148 if msglen < 0 {
1149 return ErrInvalidLengthGenerated
1150 }
1151 postIndex := iNdEx + msglen
1152 if postIndex < 0 {
1153 return ErrInvalidLengthGenerated
1154 }
1155 if postIndex > l {
1156 return io.ErrUnexpectedEOF
1157 }
1158 if err := m.JobTemplate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1159 return err
1160 }
1161 iNdEx = postIndex
1162 case 6:
1163 if wireType != 0 {
1164 return fmt.Errorf("proto: wrong wireType = %d for field SuccessfulJobsHistoryLimit", wireType)
1165 }
1166 var v int32
1167 for shift := uint(0); ; shift += 7 {
1168 if shift >= 64 {
1169 return ErrIntOverflowGenerated
1170 }
1171 if iNdEx >= l {
1172 return io.ErrUnexpectedEOF
1173 }
1174 b := dAtA[iNdEx]
1175 iNdEx++
1176 v |= int32(b&0x7F) << shift
1177 if b < 0x80 {
1178 break
1179 }
1180 }
1181 m.SuccessfulJobsHistoryLimit = &v
1182 case 7:
1183 if wireType != 0 {
1184 return fmt.Errorf("proto: wrong wireType = %d for field FailedJobsHistoryLimit", wireType)
1185 }
1186 var v int32
1187 for shift := uint(0); ; shift += 7 {
1188 if shift >= 64 {
1189 return ErrIntOverflowGenerated
1190 }
1191 if iNdEx >= l {
1192 return io.ErrUnexpectedEOF
1193 }
1194 b := dAtA[iNdEx]
1195 iNdEx++
1196 v |= int32(b&0x7F) << shift
1197 if b < 0x80 {
1198 break
1199 }
1200 }
1201 m.FailedJobsHistoryLimit = &v
1202 case 8:
1203 if wireType != 2 {
1204 return fmt.Errorf("proto: wrong wireType = %d for field TimeZone", wireType)
1205 }
1206 var stringLen uint64
1207 for shift := uint(0); ; shift += 7 {
1208 if shift >= 64 {
1209 return ErrIntOverflowGenerated
1210 }
1211 if iNdEx >= l {
1212 return io.ErrUnexpectedEOF
1213 }
1214 b := dAtA[iNdEx]
1215 iNdEx++
1216 stringLen |= uint64(b&0x7F) << shift
1217 if b < 0x80 {
1218 break
1219 }
1220 }
1221 intStringLen := int(stringLen)
1222 if intStringLen < 0 {
1223 return ErrInvalidLengthGenerated
1224 }
1225 postIndex := iNdEx + intStringLen
1226 if postIndex < 0 {
1227 return ErrInvalidLengthGenerated
1228 }
1229 if postIndex > l {
1230 return io.ErrUnexpectedEOF
1231 }
1232 s := string(dAtA[iNdEx:postIndex])
1233 m.TimeZone = &s
1234 iNdEx = postIndex
1235 default:
1236 iNdEx = preIndex
1237 skippy, err := skipGenerated(dAtA[iNdEx:])
1238 if err != nil {
1239 return err
1240 }
1241 if (skippy < 0) || (iNdEx+skippy) < 0 {
1242 return ErrInvalidLengthGenerated
1243 }
1244 if (iNdEx + skippy) > l {
1245 return io.ErrUnexpectedEOF
1246 }
1247 iNdEx += skippy
1248 }
1249 }
1250
1251 if iNdEx > l {
1252 return io.ErrUnexpectedEOF
1253 }
1254 return nil
1255 }
1256 func (m *CronJobStatus) Unmarshal(dAtA []byte) error {
1257 l := len(dAtA)
1258 iNdEx := 0
1259 for iNdEx < l {
1260 preIndex := iNdEx
1261 var wire uint64
1262 for shift := uint(0); ; shift += 7 {
1263 if shift >= 64 {
1264 return ErrIntOverflowGenerated
1265 }
1266 if iNdEx >= l {
1267 return io.ErrUnexpectedEOF
1268 }
1269 b := dAtA[iNdEx]
1270 iNdEx++
1271 wire |= uint64(b&0x7F) << shift
1272 if b < 0x80 {
1273 break
1274 }
1275 }
1276 fieldNum := int32(wire >> 3)
1277 wireType := int(wire & 0x7)
1278 if wireType == 4 {
1279 return fmt.Errorf("proto: CronJobStatus: wiretype end group for non-group")
1280 }
1281 if fieldNum <= 0 {
1282 return fmt.Errorf("proto: CronJobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1283 }
1284 switch fieldNum {
1285 case 1:
1286 if wireType != 2 {
1287 return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
1288 }
1289 var msglen int
1290 for shift := uint(0); ; shift += 7 {
1291 if shift >= 64 {
1292 return ErrIntOverflowGenerated
1293 }
1294 if iNdEx >= l {
1295 return io.ErrUnexpectedEOF
1296 }
1297 b := dAtA[iNdEx]
1298 iNdEx++
1299 msglen |= int(b&0x7F) << shift
1300 if b < 0x80 {
1301 break
1302 }
1303 }
1304 if msglen < 0 {
1305 return ErrInvalidLengthGenerated
1306 }
1307 postIndex := iNdEx + msglen
1308 if postIndex < 0 {
1309 return ErrInvalidLengthGenerated
1310 }
1311 if postIndex > l {
1312 return io.ErrUnexpectedEOF
1313 }
1314 m.Active = append(m.Active, v11.ObjectReference{})
1315 if err := m.Active[len(m.Active)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1316 return err
1317 }
1318 iNdEx = postIndex
1319 case 4:
1320 if wireType != 2 {
1321 return fmt.Errorf("proto: wrong wireType = %d for field LastScheduleTime", wireType)
1322 }
1323 var msglen int
1324 for shift := uint(0); ; shift += 7 {
1325 if shift >= 64 {
1326 return ErrIntOverflowGenerated
1327 }
1328 if iNdEx >= l {
1329 return io.ErrUnexpectedEOF
1330 }
1331 b := dAtA[iNdEx]
1332 iNdEx++
1333 msglen |= int(b&0x7F) << shift
1334 if b < 0x80 {
1335 break
1336 }
1337 }
1338 if msglen < 0 {
1339 return ErrInvalidLengthGenerated
1340 }
1341 postIndex := iNdEx + msglen
1342 if postIndex < 0 {
1343 return ErrInvalidLengthGenerated
1344 }
1345 if postIndex > l {
1346 return io.ErrUnexpectedEOF
1347 }
1348 if m.LastScheduleTime == nil {
1349 m.LastScheduleTime = &v1.Time{}
1350 }
1351 if err := m.LastScheduleTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1352 return err
1353 }
1354 iNdEx = postIndex
1355 case 5:
1356 if wireType != 2 {
1357 return fmt.Errorf("proto: wrong wireType = %d for field LastSuccessfulTime", wireType)
1358 }
1359 var msglen int
1360 for shift := uint(0); ; shift += 7 {
1361 if shift >= 64 {
1362 return ErrIntOverflowGenerated
1363 }
1364 if iNdEx >= l {
1365 return io.ErrUnexpectedEOF
1366 }
1367 b := dAtA[iNdEx]
1368 iNdEx++
1369 msglen |= int(b&0x7F) << shift
1370 if b < 0x80 {
1371 break
1372 }
1373 }
1374 if msglen < 0 {
1375 return ErrInvalidLengthGenerated
1376 }
1377 postIndex := iNdEx + msglen
1378 if postIndex < 0 {
1379 return ErrInvalidLengthGenerated
1380 }
1381 if postIndex > l {
1382 return io.ErrUnexpectedEOF
1383 }
1384 if m.LastSuccessfulTime == nil {
1385 m.LastSuccessfulTime = &v1.Time{}
1386 }
1387 if err := m.LastSuccessfulTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1388 return err
1389 }
1390 iNdEx = postIndex
1391 default:
1392 iNdEx = preIndex
1393 skippy, err := skipGenerated(dAtA[iNdEx:])
1394 if err != nil {
1395 return err
1396 }
1397 if (skippy < 0) || (iNdEx+skippy) < 0 {
1398 return ErrInvalidLengthGenerated
1399 }
1400 if (iNdEx + skippy) > l {
1401 return io.ErrUnexpectedEOF
1402 }
1403 iNdEx += skippy
1404 }
1405 }
1406
1407 if iNdEx > l {
1408 return io.ErrUnexpectedEOF
1409 }
1410 return nil
1411 }
1412 func (m *JobTemplateSpec) Unmarshal(dAtA []byte) error {
1413 l := len(dAtA)
1414 iNdEx := 0
1415 for iNdEx < l {
1416 preIndex := iNdEx
1417 var wire uint64
1418 for shift := uint(0); ; shift += 7 {
1419 if shift >= 64 {
1420 return ErrIntOverflowGenerated
1421 }
1422 if iNdEx >= l {
1423 return io.ErrUnexpectedEOF
1424 }
1425 b := dAtA[iNdEx]
1426 iNdEx++
1427 wire |= uint64(b&0x7F) << shift
1428 if b < 0x80 {
1429 break
1430 }
1431 }
1432 fieldNum := int32(wire >> 3)
1433 wireType := int(wire & 0x7)
1434 if wireType == 4 {
1435 return fmt.Errorf("proto: JobTemplateSpec: wiretype end group for non-group")
1436 }
1437 if fieldNum <= 0 {
1438 return fmt.Errorf("proto: JobTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1439 }
1440 switch fieldNum {
1441 case 1:
1442 if wireType != 2 {
1443 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1444 }
1445 var msglen int
1446 for shift := uint(0); ; shift += 7 {
1447 if shift >= 64 {
1448 return ErrIntOverflowGenerated
1449 }
1450 if iNdEx >= l {
1451 return io.ErrUnexpectedEOF
1452 }
1453 b := dAtA[iNdEx]
1454 iNdEx++
1455 msglen |= int(b&0x7F) << shift
1456 if b < 0x80 {
1457 break
1458 }
1459 }
1460 if msglen < 0 {
1461 return ErrInvalidLengthGenerated
1462 }
1463 postIndex := iNdEx + msglen
1464 if postIndex < 0 {
1465 return ErrInvalidLengthGenerated
1466 }
1467 if postIndex > l {
1468 return io.ErrUnexpectedEOF
1469 }
1470 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1471 return err
1472 }
1473 iNdEx = postIndex
1474 case 2:
1475 if wireType != 2 {
1476 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
1477 }
1478 var msglen int
1479 for shift := uint(0); ; shift += 7 {
1480 if shift >= 64 {
1481 return ErrIntOverflowGenerated
1482 }
1483 if iNdEx >= l {
1484 return io.ErrUnexpectedEOF
1485 }
1486 b := dAtA[iNdEx]
1487 iNdEx++
1488 msglen |= int(b&0x7F) << shift
1489 if b < 0x80 {
1490 break
1491 }
1492 }
1493 if msglen < 0 {
1494 return ErrInvalidLengthGenerated
1495 }
1496 postIndex := iNdEx + msglen
1497 if postIndex < 0 {
1498 return ErrInvalidLengthGenerated
1499 }
1500 if postIndex > l {
1501 return io.ErrUnexpectedEOF
1502 }
1503 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1504 return err
1505 }
1506 iNdEx = postIndex
1507 default:
1508 iNdEx = preIndex
1509 skippy, err := skipGenerated(dAtA[iNdEx:])
1510 if err != nil {
1511 return err
1512 }
1513 if (skippy < 0) || (iNdEx+skippy) < 0 {
1514 return ErrInvalidLengthGenerated
1515 }
1516 if (iNdEx + skippy) > l {
1517 return io.ErrUnexpectedEOF
1518 }
1519 iNdEx += skippy
1520 }
1521 }
1522
1523 if iNdEx > l {
1524 return io.ErrUnexpectedEOF
1525 }
1526 return nil
1527 }
1528 func skipGenerated(dAtA []byte) (n int, err error) {
1529 l := len(dAtA)
1530 iNdEx := 0
1531 depth := 0
1532 for iNdEx < l {
1533 var wire uint64
1534 for shift := uint(0); ; shift += 7 {
1535 if shift >= 64 {
1536 return 0, ErrIntOverflowGenerated
1537 }
1538 if iNdEx >= l {
1539 return 0, io.ErrUnexpectedEOF
1540 }
1541 b := dAtA[iNdEx]
1542 iNdEx++
1543 wire |= (uint64(b) & 0x7F) << shift
1544 if b < 0x80 {
1545 break
1546 }
1547 }
1548 wireType := int(wire & 0x7)
1549 switch wireType {
1550 case 0:
1551 for shift := uint(0); ; shift += 7 {
1552 if shift >= 64 {
1553 return 0, ErrIntOverflowGenerated
1554 }
1555 if iNdEx >= l {
1556 return 0, io.ErrUnexpectedEOF
1557 }
1558 iNdEx++
1559 if dAtA[iNdEx-1] < 0x80 {
1560 break
1561 }
1562 }
1563 case 1:
1564 iNdEx += 8
1565 case 2:
1566 var length int
1567 for shift := uint(0); ; shift += 7 {
1568 if shift >= 64 {
1569 return 0, ErrIntOverflowGenerated
1570 }
1571 if iNdEx >= l {
1572 return 0, io.ErrUnexpectedEOF
1573 }
1574 b := dAtA[iNdEx]
1575 iNdEx++
1576 length |= (int(b) & 0x7F) << shift
1577 if b < 0x80 {
1578 break
1579 }
1580 }
1581 if length < 0 {
1582 return 0, ErrInvalidLengthGenerated
1583 }
1584 iNdEx += length
1585 case 3:
1586 depth++
1587 case 4:
1588 if depth == 0 {
1589 return 0, ErrUnexpectedEndOfGroupGenerated
1590 }
1591 depth--
1592 case 5:
1593 iNdEx += 4
1594 default:
1595 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1596 }
1597 if iNdEx < 0 {
1598 return 0, ErrInvalidLengthGenerated
1599 }
1600 if depth == 0 {
1601 return iNdEx, nil
1602 }
1603 }
1604 return 0, io.ErrUnexpectedEOF
1605 }
1606
1607 var (
1608 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1609 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1610 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
1611 )
1612
View as plain text