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 intstr "k8s.io/apimachinery/pkg/util/intstr"
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 *ControllerRevision) Reset() { *m = ControllerRevision{} }
52 func (*ControllerRevision) ProtoMessage() {}
53 func (*ControllerRevision) Descriptor() ([]byte, []int) {
54 return fileDescriptor_5b781835628d5338, []int{0}
55 }
56 func (m *ControllerRevision) XXX_Unmarshal(b []byte) error {
57 return m.Unmarshal(b)
58 }
59 func (m *ControllerRevision) 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 *ControllerRevision) XXX_Merge(src proto.Message) {
68 xxx_messageInfo_ControllerRevision.Merge(m, src)
69 }
70 func (m *ControllerRevision) XXX_Size() int {
71 return m.Size()
72 }
73 func (m *ControllerRevision) XXX_DiscardUnknown() {
74 xxx_messageInfo_ControllerRevision.DiscardUnknown(m)
75 }
76
77 var xxx_messageInfo_ControllerRevision proto.InternalMessageInfo
78
79 func (m *ControllerRevisionList) Reset() { *m = ControllerRevisionList{} }
80 func (*ControllerRevisionList) ProtoMessage() {}
81 func (*ControllerRevisionList) Descriptor() ([]byte, []int) {
82 return fileDescriptor_5b781835628d5338, []int{1}
83 }
84 func (m *ControllerRevisionList) XXX_Unmarshal(b []byte) error {
85 return m.Unmarshal(b)
86 }
87 func (m *ControllerRevisionList) 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 *ControllerRevisionList) XXX_Merge(src proto.Message) {
96 xxx_messageInfo_ControllerRevisionList.Merge(m, src)
97 }
98 func (m *ControllerRevisionList) XXX_Size() int {
99 return m.Size()
100 }
101 func (m *ControllerRevisionList) XXX_DiscardUnknown() {
102 xxx_messageInfo_ControllerRevisionList.DiscardUnknown(m)
103 }
104
105 var xxx_messageInfo_ControllerRevisionList proto.InternalMessageInfo
106
107 func (m *DaemonSet) Reset() { *m = DaemonSet{} }
108 func (*DaemonSet) ProtoMessage() {}
109 func (*DaemonSet) Descriptor() ([]byte, []int) {
110 return fileDescriptor_5b781835628d5338, []int{2}
111 }
112 func (m *DaemonSet) XXX_Unmarshal(b []byte) error {
113 return m.Unmarshal(b)
114 }
115 func (m *DaemonSet) 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 *DaemonSet) XXX_Merge(src proto.Message) {
124 xxx_messageInfo_DaemonSet.Merge(m, src)
125 }
126 func (m *DaemonSet) XXX_Size() int {
127 return m.Size()
128 }
129 func (m *DaemonSet) XXX_DiscardUnknown() {
130 xxx_messageInfo_DaemonSet.DiscardUnknown(m)
131 }
132
133 var xxx_messageInfo_DaemonSet proto.InternalMessageInfo
134
135 func (m *DaemonSetCondition) Reset() { *m = DaemonSetCondition{} }
136 func (*DaemonSetCondition) ProtoMessage() {}
137 func (*DaemonSetCondition) Descriptor() ([]byte, []int) {
138 return fileDescriptor_5b781835628d5338, []int{3}
139 }
140 func (m *DaemonSetCondition) XXX_Unmarshal(b []byte) error {
141 return m.Unmarshal(b)
142 }
143 func (m *DaemonSetCondition) 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 *DaemonSetCondition) XXX_Merge(src proto.Message) {
152 xxx_messageInfo_DaemonSetCondition.Merge(m, src)
153 }
154 func (m *DaemonSetCondition) XXX_Size() int {
155 return m.Size()
156 }
157 func (m *DaemonSetCondition) XXX_DiscardUnknown() {
158 xxx_messageInfo_DaemonSetCondition.DiscardUnknown(m)
159 }
160
161 var xxx_messageInfo_DaemonSetCondition proto.InternalMessageInfo
162
163 func (m *DaemonSetList) Reset() { *m = DaemonSetList{} }
164 func (*DaemonSetList) ProtoMessage() {}
165 func (*DaemonSetList) Descriptor() ([]byte, []int) {
166 return fileDescriptor_5b781835628d5338, []int{4}
167 }
168 func (m *DaemonSetList) XXX_Unmarshal(b []byte) error {
169 return m.Unmarshal(b)
170 }
171 func (m *DaemonSetList) 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 *DaemonSetList) XXX_Merge(src proto.Message) {
180 xxx_messageInfo_DaemonSetList.Merge(m, src)
181 }
182 func (m *DaemonSetList) XXX_Size() int {
183 return m.Size()
184 }
185 func (m *DaemonSetList) XXX_DiscardUnknown() {
186 xxx_messageInfo_DaemonSetList.DiscardUnknown(m)
187 }
188
189 var xxx_messageInfo_DaemonSetList proto.InternalMessageInfo
190
191 func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} }
192 func (*DaemonSetSpec) ProtoMessage() {}
193 func (*DaemonSetSpec) Descriptor() ([]byte, []int) {
194 return fileDescriptor_5b781835628d5338, []int{5}
195 }
196 func (m *DaemonSetSpec) XXX_Unmarshal(b []byte) error {
197 return m.Unmarshal(b)
198 }
199 func (m *DaemonSetSpec) 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 *DaemonSetSpec) XXX_Merge(src proto.Message) {
208 xxx_messageInfo_DaemonSetSpec.Merge(m, src)
209 }
210 func (m *DaemonSetSpec) XXX_Size() int {
211 return m.Size()
212 }
213 func (m *DaemonSetSpec) XXX_DiscardUnknown() {
214 xxx_messageInfo_DaemonSetSpec.DiscardUnknown(m)
215 }
216
217 var xxx_messageInfo_DaemonSetSpec proto.InternalMessageInfo
218
219 func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} }
220 func (*DaemonSetStatus) ProtoMessage() {}
221 func (*DaemonSetStatus) Descriptor() ([]byte, []int) {
222 return fileDescriptor_5b781835628d5338, []int{6}
223 }
224 func (m *DaemonSetStatus) XXX_Unmarshal(b []byte) error {
225 return m.Unmarshal(b)
226 }
227 func (m *DaemonSetStatus) 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 *DaemonSetStatus) XXX_Merge(src proto.Message) {
236 xxx_messageInfo_DaemonSetStatus.Merge(m, src)
237 }
238 func (m *DaemonSetStatus) XXX_Size() int {
239 return m.Size()
240 }
241 func (m *DaemonSetStatus) XXX_DiscardUnknown() {
242 xxx_messageInfo_DaemonSetStatus.DiscardUnknown(m)
243 }
244
245 var xxx_messageInfo_DaemonSetStatus proto.InternalMessageInfo
246
247 func (m *DaemonSetUpdateStrategy) Reset() { *m = DaemonSetUpdateStrategy{} }
248 func (*DaemonSetUpdateStrategy) ProtoMessage() {}
249 func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) {
250 return fileDescriptor_5b781835628d5338, []int{7}
251 }
252 func (m *DaemonSetUpdateStrategy) XXX_Unmarshal(b []byte) error {
253 return m.Unmarshal(b)
254 }
255 func (m *DaemonSetUpdateStrategy) 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 *DaemonSetUpdateStrategy) XXX_Merge(src proto.Message) {
264 xxx_messageInfo_DaemonSetUpdateStrategy.Merge(m, src)
265 }
266 func (m *DaemonSetUpdateStrategy) XXX_Size() int {
267 return m.Size()
268 }
269 func (m *DaemonSetUpdateStrategy) XXX_DiscardUnknown() {
270 xxx_messageInfo_DaemonSetUpdateStrategy.DiscardUnknown(m)
271 }
272
273 var xxx_messageInfo_DaemonSetUpdateStrategy proto.InternalMessageInfo
274
275 func (m *Deployment) Reset() { *m = Deployment{} }
276 func (*Deployment) ProtoMessage() {}
277 func (*Deployment) Descriptor() ([]byte, []int) {
278 return fileDescriptor_5b781835628d5338, []int{8}
279 }
280 func (m *Deployment) XXX_Unmarshal(b []byte) error {
281 return m.Unmarshal(b)
282 }
283 func (m *Deployment) 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 *Deployment) XXX_Merge(src proto.Message) {
292 xxx_messageInfo_Deployment.Merge(m, src)
293 }
294 func (m *Deployment) XXX_Size() int {
295 return m.Size()
296 }
297 func (m *Deployment) XXX_DiscardUnknown() {
298 xxx_messageInfo_Deployment.DiscardUnknown(m)
299 }
300
301 var xxx_messageInfo_Deployment proto.InternalMessageInfo
302
303 func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} }
304 func (*DeploymentCondition) ProtoMessage() {}
305 func (*DeploymentCondition) Descriptor() ([]byte, []int) {
306 return fileDescriptor_5b781835628d5338, []int{9}
307 }
308 func (m *DeploymentCondition) XXX_Unmarshal(b []byte) error {
309 return m.Unmarshal(b)
310 }
311 func (m *DeploymentCondition) 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 *DeploymentCondition) XXX_Merge(src proto.Message) {
320 xxx_messageInfo_DeploymentCondition.Merge(m, src)
321 }
322 func (m *DeploymentCondition) XXX_Size() int {
323 return m.Size()
324 }
325 func (m *DeploymentCondition) XXX_DiscardUnknown() {
326 xxx_messageInfo_DeploymentCondition.DiscardUnknown(m)
327 }
328
329 var xxx_messageInfo_DeploymentCondition proto.InternalMessageInfo
330
331 func (m *DeploymentList) Reset() { *m = DeploymentList{} }
332 func (*DeploymentList) ProtoMessage() {}
333 func (*DeploymentList) Descriptor() ([]byte, []int) {
334 return fileDescriptor_5b781835628d5338, []int{10}
335 }
336 func (m *DeploymentList) XXX_Unmarshal(b []byte) error {
337 return m.Unmarshal(b)
338 }
339 func (m *DeploymentList) 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 *DeploymentList) XXX_Merge(src proto.Message) {
348 xxx_messageInfo_DeploymentList.Merge(m, src)
349 }
350 func (m *DeploymentList) XXX_Size() int {
351 return m.Size()
352 }
353 func (m *DeploymentList) XXX_DiscardUnknown() {
354 xxx_messageInfo_DeploymentList.DiscardUnknown(m)
355 }
356
357 var xxx_messageInfo_DeploymentList proto.InternalMessageInfo
358
359 func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} }
360 func (*DeploymentSpec) ProtoMessage() {}
361 func (*DeploymentSpec) Descriptor() ([]byte, []int) {
362 return fileDescriptor_5b781835628d5338, []int{11}
363 }
364 func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error {
365 return m.Unmarshal(b)
366 }
367 func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
368 b = b[:cap(b)]
369 n, err := m.MarshalToSizedBuffer(b)
370 if err != nil {
371 return nil, err
372 }
373 return b[:n], nil
374 }
375 func (m *DeploymentSpec) XXX_Merge(src proto.Message) {
376 xxx_messageInfo_DeploymentSpec.Merge(m, src)
377 }
378 func (m *DeploymentSpec) XXX_Size() int {
379 return m.Size()
380 }
381 func (m *DeploymentSpec) XXX_DiscardUnknown() {
382 xxx_messageInfo_DeploymentSpec.DiscardUnknown(m)
383 }
384
385 var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo
386
387 func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} }
388 func (*DeploymentStatus) ProtoMessage() {}
389 func (*DeploymentStatus) Descriptor() ([]byte, []int) {
390 return fileDescriptor_5b781835628d5338, []int{12}
391 }
392 func (m *DeploymentStatus) XXX_Unmarshal(b []byte) error {
393 return m.Unmarshal(b)
394 }
395 func (m *DeploymentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
396 b = b[:cap(b)]
397 n, err := m.MarshalToSizedBuffer(b)
398 if err != nil {
399 return nil, err
400 }
401 return b[:n], nil
402 }
403 func (m *DeploymentStatus) XXX_Merge(src proto.Message) {
404 xxx_messageInfo_DeploymentStatus.Merge(m, src)
405 }
406 func (m *DeploymentStatus) XXX_Size() int {
407 return m.Size()
408 }
409 func (m *DeploymentStatus) XXX_DiscardUnknown() {
410 xxx_messageInfo_DeploymentStatus.DiscardUnknown(m)
411 }
412
413 var xxx_messageInfo_DeploymentStatus proto.InternalMessageInfo
414
415 func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} }
416 func (*DeploymentStrategy) ProtoMessage() {}
417 func (*DeploymentStrategy) Descriptor() ([]byte, []int) {
418 return fileDescriptor_5b781835628d5338, []int{13}
419 }
420 func (m *DeploymentStrategy) XXX_Unmarshal(b []byte) error {
421 return m.Unmarshal(b)
422 }
423 func (m *DeploymentStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
424 b = b[:cap(b)]
425 n, err := m.MarshalToSizedBuffer(b)
426 if err != nil {
427 return nil, err
428 }
429 return b[:n], nil
430 }
431 func (m *DeploymentStrategy) XXX_Merge(src proto.Message) {
432 xxx_messageInfo_DeploymentStrategy.Merge(m, src)
433 }
434 func (m *DeploymentStrategy) XXX_Size() int {
435 return m.Size()
436 }
437 func (m *DeploymentStrategy) XXX_DiscardUnknown() {
438 xxx_messageInfo_DeploymentStrategy.DiscardUnknown(m)
439 }
440
441 var xxx_messageInfo_DeploymentStrategy proto.InternalMessageInfo
442
443 func (m *ReplicaSet) Reset() { *m = ReplicaSet{} }
444 func (*ReplicaSet) ProtoMessage() {}
445 func (*ReplicaSet) Descriptor() ([]byte, []int) {
446 return fileDescriptor_5b781835628d5338, []int{14}
447 }
448 func (m *ReplicaSet) XXX_Unmarshal(b []byte) error {
449 return m.Unmarshal(b)
450 }
451 func (m *ReplicaSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
452 b = b[:cap(b)]
453 n, err := m.MarshalToSizedBuffer(b)
454 if err != nil {
455 return nil, err
456 }
457 return b[:n], nil
458 }
459 func (m *ReplicaSet) XXX_Merge(src proto.Message) {
460 xxx_messageInfo_ReplicaSet.Merge(m, src)
461 }
462 func (m *ReplicaSet) XXX_Size() int {
463 return m.Size()
464 }
465 func (m *ReplicaSet) XXX_DiscardUnknown() {
466 xxx_messageInfo_ReplicaSet.DiscardUnknown(m)
467 }
468
469 var xxx_messageInfo_ReplicaSet proto.InternalMessageInfo
470
471 func (m *ReplicaSetCondition) Reset() { *m = ReplicaSetCondition{} }
472 func (*ReplicaSetCondition) ProtoMessage() {}
473 func (*ReplicaSetCondition) Descriptor() ([]byte, []int) {
474 return fileDescriptor_5b781835628d5338, []int{15}
475 }
476 func (m *ReplicaSetCondition) XXX_Unmarshal(b []byte) error {
477 return m.Unmarshal(b)
478 }
479 func (m *ReplicaSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
480 b = b[:cap(b)]
481 n, err := m.MarshalToSizedBuffer(b)
482 if err != nil {
483 return nil, err
484 }
485 return b[:n], nil
486 }
487 func (m *ReplicaSetCondition) XXX_Merge(src proto.Message) {
488 xxx_messageInfo_ReplicaSetCondition.Merge(m, src)
489 }
490 func (m *ReplicaSetCondition) XXX_Size() int {
491 return m.Size()
492 }
493 func (m *ReplicaSetCondition) XXX_DiscardUnknown() {
494 xxx_messageInfo_ReplicaSetCondition.DiscardUnknown(m)
495 }
496
497 var xxx_messageInfo_ReplicaSetCondition proto.InternalMessageInfo
498
499 func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} }
500 func (*ReplicaSetList) ProtoMessage() {}
501 func (*ReplicaSetList) Descriptor() ([]byte, []int) {
502 return fileDescriptor_5b781835628d5338, []int{16}
503 }
504 func (m *ReplicaSetList) XXX_Unmarshal(b []byte) error {
505 return m.Unmarshal(b)
506 }
507 func (m *ReplicaSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
508 b = b[:cap(b)]
509 n, err := m.MarshalToSizedBuffer(b)
510 if err != nil {
511 return nil, err
512 }
513 return b[:n], nil
514 }
515 func (m *ReplicaSetList) XXX_Merge(src proto.Message) {
516 xxx_messageInfo_ReplicaSetList.Merge(m, src)
517 }
518 func (m *ReplicaSetList) XXX_Size() int {
519 return m.Size()
520 }
521 func (m *ReplicaSetList) XXX_DiscardUnknown() {
522 xxx_messageInfo_ReplicaSetList.DiscardUnknown(m)
523 }
524
525 var xxx_messageInfo_ReplicaSetList proto.InternalMessageInfo
526
527 func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} }
528 func (*ReplicaSetSpec) ProtoMessage() {}
529 func (*ReplicaSetSpec) Descriptor() ([]byte, []int) {
530 return fileDescriptor_5b781835628d5338, []int{17}
531 }
532 func (m *ReplicaSetSpec) XXX_Unmarshal(b []byte) error {
533 return m.Unmarshal(b)
534 }
535 func (m *ReplicaSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
536 b = b[:cap(b)]
537 n, err := m.MarshalToSizedBuffer(b)
538 if err != nil {
539 return nil, err
540 }
541 return b[:n], nil
542 }
543 func (m *ReplicaSetSpec) XXX_Merge(src proto.Message) {
544 xxx_messageInfo_ReplicaSetSpec.Merge(m, src)
545 }
546 func (m *ReplicaSetSpec) XXX_Size() int {
547 return m.Size()
548 }
549 func (m *ReplicaSetSpec) XXX_DiscardUnknown() {
550 xxx_messageInfo_ReplicaSetSpec.DiscardUnknown(m)
551 }
552
553 var xxx_messageInfo_ReplicaSetSpec proto.InternalMessageInfo
554
555 func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} }
556 func (*ReplicaSetStatus) ProtoMessage() {}
557 func (*ReplicaSetStatus) Descriptor() ([]byte, []int) {
558 return fileDescriptor_5b781835628d5338, []int{18}
559 }
560 func (m *ReplicaSetStatus) XXX_Unmarshal(b []byte) error {
561 return m.Unmarshal(b)
562 }
563 func (m *ReplicaSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
564 b = b[:cap(b)]
565 n, err := m.MarshalToSizedBuffer(b)
566 if err != nil {
567 return nil, err
568 }
569 return b[:n], nil
570 }
571 func (m *ReplicaSetStatus) XXX_Merge(src proto.Message) {
572 xxx_messageInfo_ReplicaSetStatus.Merge(m, src)
573 }
574 func (m *ReplicaSetStatus) XXX_Size() int {
575 return m.Size()
576 }
577 func (m *ReplicaSetStatus) XXX_DiscardUnknown() {
578 xxx_messageInfo_ReplicaSetStatus.DiscardUnknown(m)
579 }
580
581 var xxx_messageInfo_ReplicaSetStatus proto.InternalMessageInfo
582
583 func (m *RollingUpdateDaemonSet) Reset() { *m = RollingUpdateDaemonSet{} }
584 func (*RollingUpdateDaemonSet) ProtoMessage() {}
585 func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) {
586 return fileDescriptor_5b781835628d5338, []int{19}
587 }
588 func (m *RollingUpdateDaemonSet) XXX_Unmarshal(b []byte) error {
589 return m.Unmarshal(b)
590 }
591 func (m *RollingUpdateDaemonSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
592 b = b[:cap(b)]
593 n, err := m.MarshalToSizedBuffer(b)
594 if err != nil {
595 return nil, err
596 }
597 return b[:n], nil
598 }
599 func (m *RollingUpdateDaemonSet) XXX_Merge(src proto.Message) {
600 xxx_messageInfo_RollingUpdateDaemonSet.Merge(m, src)
601 }
602 func (m *RollingUpdateDaemonSet) XXX_Size() int {
603 return m.Size()
604 }
605 func (m *RollingUpdateDaemonSet) XXX_DiscardUnknown() {
606 xxx_messageInfo_RollingUpdateDaemonSet.DiscardUnknown(m)
607 }
608
609 var xxx_messageInfo_RollingUpdateDaemonSet proto.InternalMessageInfo
610
611 func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} }
612 func (*RollingUpdateDeployment) ProtoMessage() {}
613 func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
614 return fileDescriptor_5b781835628d5338, []int{20}
615 }
616 func (m *RollingUpdateDeployment) XXX_Unmarshal(b []byte) error {
617 return m.Unmarshal(b)
618 }
619 func (m *RollingUpdateDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
620 b = b[:cap(b)]
621 n, err := m.MarshalToSizedBuffer(b)
622 if err != nil {
623 return nil, err
624 }
625 return b[:n], nil
626 }
627 func (m *RollingUpdateDeployment) XXX_Merge(src proto.Message) {
628 xxx_messageInfo_RollingUpdateDeployment.Merge(m, src)
629 }
630 func (m *RollingUpdateDeployment) XXX_Size() int {
631 return m.Size()
632 }
633 func (m *RollingUpdateDeployment) XXX_DiscardUnknown() {
634 xxx_messageInfo_RollingUpdateDeployment.DiscardUnknown(m)
635 }
636
637 var xxx_messageInfo_RollingUpdateDeployment proto.InternalMessageInfo
638
639 func (m *RollingUpdateStatefulSetStrategy) Reset() { *m = RollingUpdateStatefulSetStrategy{} }
640 func (*RollingUpdateStatefulSetStrategy) ProtoMessage() {}
641 func (*RollingUpdateStatefulSetStrategy) Descriptor() ([]byte, []int) {
642 return fileDescriptor_5b781835628d5338, []int{21}
643 }
644 func (m *RollingUpdateStatefulSetStrategy) XXX_Unmarshal(b []byte) error {
645 return m.Unmarshal(b)
646 }
647 func (m *RollingUpdateStatefulSetStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
648 b = b[:cap(b)]
649 n, err := m.MarshalToSizedBuffer(b)
650 if err != nil {
651 return nil, err
652 }
653 return b[:n], nil
654 }
655 func (m *RollingUpdateStatefulSetStrategy) XXX_Merge(src proto.Message) {
656 xxx_messageInfo_RollingUpdateStatefulSetStrategy.Merge(m, src)
657 }
658 func (m *RollingUpdateStatefulSetStrategy) XXX_Size() int {
659 return m.Size()
660 }
661 func (m *RollingUpdateStatefulSetStrategy) XXX_DiscardUnknown() {
662 xxx_messageInfo_RollingUpdateStatefulSetStrategy.DiscardUnknown(m)
663 }
664
665 var xxx_messageInfo_RollingUpdateStatefulSetStrategy proto.InternalMessageInfo
666
667 func (m *StatefulSet) Reset() { *m = StatefulSet{} }
668 func (*StatefulSet) ProtoMessage() {}
669 func (*StatefulSet) Descriptor() ([]byte, []int) {
670 return fileDescriptor_5b781835628d5338, []int{22}
671 }
672 func (m *StatefulSet) XXX_Unmarshal(b []byte) error {
673 return m.Unmarshal(b)
674 }
675 func (m *StatefulSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
676 b = b[:cap(b)]
677 n, err := m.MarshalToSizedBuffer(b)
678 if err != nil {
679 return nil, err
680 }
681 return b[:n], nil
682 }
683 func (m *StatefulSet) XXX_Merge(src proto.Message) {
684 xxx_messageInfo_StatefulSet.Merge(m, src)
685 }
686 func (m *StatefulSet) XXX_Size() int {
687 return m.Size()
688 }
689 func (m *StatefulSet) XXX_DiscardUnknown() {
690 xxx_messageInfo_StatefulSet.DiscardUnknown(m)
691 }
692
693 var xxx_messageInfo_StatefulSet proto.InternalMessageInfo
694
695 func (m *StatefulSetCondition) Reset() { *m = StatefulSetCondition{} }
696 func (*StatefulSetCondition) ProtoMessage() {}
697 func (*StatefulSetCondition) Descriptor() ([]byte, []int) {
698 return fileDescriptor_5b781835628d5338, []int{23}
699 }
700 func (m *StatefulSetCondition) XXX_Unmarshal(b []byte) error {
701 return m.Unmarshal(b)
702 }
703 func (m *StatefulSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
704 b = b[:cap(b)]
705 n, err := m.MarshalToSizedBuffer(b)
706 if err != nil {
707 return nil, err
708 }
709 return b[:n], nil
710 }
711 func (m *StatefulSetCondition) XXX_Merge(src proto.Message) {
712 xxx_messageInfo_StatefulSetCondition.Merge(m, src)
713 }
714 func (m *StatefulSetCondition) XXX_Size() int {
715 return m.Size()
716 }
717 func (m *StatefulSetCondition) XXX_DiscardUnknown() {
718 xxx_messageInfo_StatefulSetCondition.DiscardUnknown(m)
719 }
720
721 var xxx_messageInfo_StatefulSetCondition proto.InternalMessageInfo
722
723 func (m *StatefulSetList) Reset() { *m = StatefulSetList{} }
724 func (*StatefulSetList) ProtoMessage() {}
725 func (*StatefulSetList) Descriptor() ([]byte, []int) {
726 return fileDescriptor_5b781835628d5338, []int{24}
727 }
728 func (m *StatefulSetList) XXX_Unmarshal(b []byte) error {
729 return m.Unmarshal(b)
730 }
731 func (m *StatefulSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
732 b = b[:cap(b)]
733 n, err := m.MarshalToSizedBuffer(b)
734 if err != nil {
735 return nil, err
736 }
737 return b[:n], nil
738 }
739 func (m *StatefulSetList) XXX_Merge(src proto.Message) {
740 xxx_messageInfo_StatefulSetList.Merge(m, src)
741 }
742 func (m *StatefulSetList) XXX_Size() int {
743 return m.Size()
744 }
745 func (m *StatefulSetList) XXX_DiscardUnknown() {
746 xxx_messageInfo_StatefulSetList.DiscardUnknown(m)
747 }
748
749 var xxx_messageInfo_StatefulSetList proto.InternalMessageInfo
750
751 func (m *StatefulSetOrdinals) Reset() { *m = StatefulSetOrdinals{} }
752 func (*StatefulSetOrdinals) ProtoMessage() {}
753 func (*StatefulSetOrdinals) Descriptor() ([]byte, []int) {
754 return fileDescriptor_5b781835628d5338, []int{25}
755 }
756 func (m *StatefulSetOrdinals) XXX_Unmarshal(b []byte) error {
757 return m.Unmarshal(b)
758 }
759 func (m *StatefulSetOrdinals) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
760 b = b[:cap(b)]
761 n, err := m.MarshalToSizedBuffer(b)
762 if err != nil {
763 return nil, err
764 }
765 return b[:n], nil
766 }
767 func (m *StatefulSetOrdinals) XXX_Merge(src proto.Message) {
768 xxx_messageInfo_StatefulSetOrdinals.Merge(m, src)
769 }
770 func (m *StatefulSetOrdinals) XXX_Size() int {
771 return m.Size()
772 }
773 func (m *StatefulSetOrdinals) XXX_DiscardUnknown() {
774 xxx_messageInfo_StatefulSetOrdinals.DiscardUnknown(m)
775 }
776
777 var xxx_messageInfo_StatefulSetOrdinals proto.InternalMessageInfo
778
779 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Reset() {
780 *m = StatefulSetPersistentVolumeClaimRetentionPolicy{}
781 }
782 func (*StatefulSetPersistentVolumeClaimRetentionPolicy) ProtoMessage() {}
783 func (*StatefulSetPersistentVolumeClaimRetentionPolicy) Descriptor() ([]byte, []int) {
784 return fileDescriptor_5b781835628d5338, []int{26}
785 }
786 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Unmarshal(b []byte) error {
787 return m.Unmarshal(b)
788 }
789 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
790 b = b[:cap(b)]
791 n, err := m.MarshalToSizedBuffer(b)
792 if err != nil {
793 return nil, err
794 }
795 return b[:n], nil
796 }
797 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Merge(src proto.Message) {
798 xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.Merge(m, src)
799 }
800 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Size() int {
801 return m.Size()
802 }
803 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_DiscardUnknown() {
804 xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.DiscardUnknown(m)
805 }
806
807 var xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy proto.InternalMessageInfo
808
809 func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} }
810 func (*StatefulSetSpec) ProtoMessage() {}
811 func (*StatefulSetSpec) Descriptor() ([]byte, []int) {
812 return fileDescriptor_5b781835628d5338, []int{27}
813 }
814 func (m *StatefulSetSpec) XXX_Unmarshal(b []byte) error {
815 return m.Unmarshal(b)
816 }
817 func (m *StatefulSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
818 b = b[:cap(b)]
819 n, err := m.MarshalToSizedBuffer(b)
820 if err != nil {
821 return nil, err
822 }
823 return b[:n], nil
824 }
825 func (m *StatefulSetSpec) XXX_Merge(src proto.Message) {
826 xxx_messageInfo_StatefulSetSpec.Merge(m, src)
827 }
828 func (m *StatefulSetSpec) XXX_Size() int {
829 return m.Size()
830 }
831 func (m *StatefulSetSpec) XXX_DiscardUnknown() {
832 xxx_messageInfo_StatefulSetSpec.DiscardUnknown(m)
833 }
834
835 var xxx_messageInfo_StatefulSetSpec proto.InternalMessageInfo
836
837 func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} }
838 func (*StatefulSetStatus) ProtoMessage() {}
839 func (*StatefulSetStatus) Descriptor() ([]byte, []int) {
840 return fileDescriptor_5b781835628d5338, []int{28}
841 }
842 func (m *StatefulSetStatus) XXX_Unmarshal(b []byte) error {
843 return m.Unmarshal(b)
844 }
845 func (m *StatefulSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
846 b = b[:cap(b)]
847 n, err := m.MarshalToSizedBuffer(b)
848 if err != nil {
849 return nil, err
850 }
851 return b[:n], nil
852 }
853 func (m *StatefulSetStatus) XXX_Merge(src proto.Message) {
854 xxx_messageInfo_StatefulSetStatus.Merge(m, src)
855 }
856 func (m *StatefulSetStatus) XXX_Size() int {
857 return m.Size()
858 }
859 func (m *StatefulSetStatus) XXX_DiscardUnknown() {
860 xxx_messageInfo_StatefulSetStatus.DiscardUnknown(m)
861 }
862
863 var xxx_messageInfo_StatefulSetStatus proto.InternalMessageInfo
864
865 func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} }
866 func (*StatefulSetUpdateStrategy) ProtoMessage() {}
867 func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) {
868 return fileDescriptor_5b781835628d5338, []int{29}
869 }
870 func (m *StatefulSetUpdateStrategy) XXX_Unmarshal(b []byte) error {
871 return m.Unmarshal(b)
872 }
873 func (m *StatefulSetUpdateStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
874 b = b[:cap(b)]
875 n, err := m.MarshalToSizedBuffer(b)
876 if err != nil {
877 return nil, err
878 }
879 return b[:n], nil
880 }
881 func (m *StatefulSetUpdateStrategy) XXX_Merge(src proto.Message) {
882 xxx_messageInfo_StatefulSetUpdateStrategy.Merge(m, src)
883 }
884 func (m *StatefulSetUpdateStrategy) XXX_Size() int {
885 return m.Size()
886 }
887 func (m *StatefulSetUpdateStrategy) XXX_DiscardUnknown() {
888 xxx_messageInfo_StatefulSetUpdateStrategy.DiscardUnknown(m)
889 }
890
891 var xxx_messageInfo_StatefulSetUpdateStrategy proto.InternalMessageInfo
892
893 func init() {
894 proto.RegisterType((*ControllerRevision)(nil), "k8s.io.api.apps.v1.ControllerRevision")
895 proto.RegisterType((*ControllerRevisionList)(nil), "k8s.io.api.apps.v1.ControllerRevisionList")
896 proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.apps.v1.DaemonSet")
897 proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.apps.v1.DaemonSetCondition")
898 proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.apps.v1.DaemonSetList")
899 proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.apps.v1.DaemonSetSpec")
900 proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.apps.v1.DaemonSetStatus")
901 proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.apps.v1.DaemonSetUpdateStrategy")
902 proto.RegisterType((*Deployment)(nil), "k8s.io.api.apps.v1.Deployment")
903 proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.apps.v1.DeploymentCondition")
904 proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.apps.v1.DeploymentList")
905 proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.apps.v1.DeploymentSpec")
906 proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.apps.v1.DeploymentStatus")
907 proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.apps.v1.DeploymentStrategy")
908 proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.apps.v1.ReplicaSet")
909 proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.apps.v1.ReplicaSetCondition")
910 proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.apps.v1.ReplicaSetList")
911 proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.apps.v1.ReplicaSetSpec")
912 proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.apps.v1.ReplicaSetStatus")
913 proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.apps.v1.RollingUpdateDaemonSet")
914 proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.apps.v1.RollingUpdateDeployment")
915 proto.RegisterType((*RollingUpdateStatefulSetStrategy)(nil), "k8s.io.api.apps.v1.RollingUpdateStatefulSetStrategy")
916 proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1.StatefulSet")
917 proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1.StatefulSetCondition")
918 proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1.StatefulSetList")
919 proto.RegisterType((*StatefulSetOrdinals)(nil), "k8s.io.api.apps.v1.StatefulSetOrdinals")
920 proto.RegisterType((*StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), "k8s.io.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy")
921 proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1.StatefulSetSpec")
922 proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1.StatefulSetStatus")
923 proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1.StatefulSetUpdateStrategy")
924 }
925
926 func init() {
927 proto.RegisterFile("k8s.io/api/apps/v1/generated.proto", fileDescriptor_5b781835628d5338)
928 }
929
930 var fileDescriptor_5b781835628d5338 = []byte{
931
932 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x1b, 0xc7,
933 0x15, 0xd7, 0xf2, 0x43, 0xa2, 0x86, 0x96, 0x64, 0x8f, 0x54, 0x89, 0xb1, 0x1b, 0xd2, 0xdd, 0xb8,
934 0xb6, 0x12, 0xc7, 0x64, 0xed, 0x38, 0x41, 0xe0, 0x14, 0x09, 0x44, 0x2a, 0x4d, 0xd3, 0xe8, 0xab,
935 0x43, 0xcb, 0x01, 0xdc, 0xb4, 0xe8, 0x68, 0x39, 0xa6, 0x36, 0xde, 0x2f, 0xec, 0x0e, 0x15, 0x0b,
936 0xbd, 0x14, 0x05, 0x7a, 0xeb, 0xa1, 0x7f, 0x43, 0xff, 0x81, 0xa2, 0x28, 0x9a, 0x5b, 0x10, 0x04,
937 0xbd, 0xf8, 0x52, 0x20, 0xe8, 0xa5, 0x39, 0x11, 0x35, 0x73, 0x2a, 0x8a, 0xde, 0xda, 0x8b, 0x2f,
938 0x2d, 0x66, 0x76, 0xf6, 0x7b, 0x56, 0xa4, 0xe4, 0x58, 0x69, 0x82, 0xdc, 0xb8, 0x33, 0xbf, 0xf7,
939 0xdb, 0x37, 0x33, 0xef, 0xcd, 0xfb, 0xcd, 0x2c, 0x81, 0x7a, 0xff, 0x55, 0xaf, 0xa9, 0xdb, 0x2d,
940 0xec, 0xe8, 0x2d, 0xec, 0x38, 0x5e, 0xeb, 0xe0, 0x7a, 0xab, 0x4f, 0x2c, 0xe2, 0x62, 0x4a, 0x7a,
941 0x4d, 0xc7, 0xb5, 0xa9, 0x0d, 0xa1, 0x8f, 0x69, 0x62, 0x47, 0x6f, 0x32, 0x4c, 0xf3, 0xe0, 0xfa,
942 0xf9, 0x6b, 0x7d, 0x9d, 0xee, 0x0f, 0xf6, 0x9a, 0x9a, 0x6d, 0xb6, 0xfa, 0x76, 0xdf, 0x6e, 0x71,
943 0xe8, 0xde, 0xe0, 0x1e, 0x7f, 0xe2, 0x0f, 0xfc, 0x97, 0x4f, 0x71, 0x3e, 0xfe, 0x1a, 0xcd, 0x76,
944 0x89, 0xe4, 0x35, 0xe7, 0x6f, 0x46, 0x18, 0x13, 0x6b, 0xfb, 0xba, 0x45, 0xdc, 0xc3, 0x96, 0x73,
945 0xbf, 0xcf, 0x1a, 0xbc, 0x96, 0x49, 0x28, 0x96, 0x59, 0xb5, 0xf2, 0xac, 0xdc, 0x81, 0x45, 0x75,
946 0x93, 0x64, 0x0c, 0x5e, 0x19, 0x67, 0xe0, 0x69, 0xfb, 0xc4, 0xc4, 0x19, 0xbb, 0x97, 0xf2, 0xec,
947 0x06, 0x54, 0x37, 0x5a, 0xba, 0x45, 0x3d, 0xea, 0xa6, 0x8d, 0xd4, 0xff, 0x28, 0x00, 0x76, 0x6c,
948 0x8b, 0xba, 0xb6, 0x61, 0x10, 0x17, 0x91, 0x03, 0xdd, 0xd3, 0x6d, 0x0b, 0xfe, 0x1c, 0x54, 0xd8,
949 0x78, 0x7a, 0x98, 0xe2, 0x9a, 0x72, 0x51, 0x59, 0xad, 0xde, 0xf8, 0x5e, 0x33, 0x9a, 0xe4, 0x90,
950 0xbe, 0xe9, 0xdc, 0xef, 0xb3, 0x06, 0xaf, 0xc9, 0xd0, 0xcd, 0x83, 0xeb, 0xcd, 0xed, 0xbd, 0xf7,
951 0x89, 0x46, 0x37, 0x09, 0xc5, 0x6d, 0xf8, 0x70, 0xd8, 0x98, 0x1a, 0x0d, 0x1b, 0x20, 0x6a, 0x43,
952 0x21, 0x2b, 0xdc, 0x06, 0x25, 0xce, 0x5e, 0xe0, 0xec, 0xd7, 0x72, 0xd9, 0xc5, 0xa0, 0x9b, 0x08,
953 0x7f, 0xf0, 0xe6, 0x03, 0x4a, 0x2c, 0xe6, 0x5e, 0xfb, 0x8c, 0xa0, 0x2e, 0xad, 0x63, 0x8a, 0x11,
954 0x27, 0x82, 0x2f, 0x82, 0x8a, 0x2b, 0xdc, 0xaf, 0x15, 0x2f, 0x2a, 0xab, 0xc5, 0xf6, 0x59, 0x81,
955 0xaa, 0x04, 0xc3, 0x42, 0x21, 0x42, 0xfd, 0xb3, 0x02, 0x96, 0xb3, 0xe3, 0xde, 0xd0, 0x3d, 0x0a,
956 0xdf, 0xcb, 0x8c, 0xbd, 0x39, 0xd9, 0xd8, 0x99, 0x35, 0x1f, 0x79, 0xf8, 0xe2, 0xa0, 0x25, 0x36,
957 0xee, 0x77, 0x40, 0x59, 0xa7, 0xc4, 0xf4, 0x6a, 0x85, 0x8b, 0xc5, 0xd5, 0xea, 0x8d, 0xcb, 0xcd,
958 0x6c, 0xec, 0x36, 0xb3, 0x8e, 0xb5, 0xe7, 0x04, 0x65, 0xf9, 0x6d, 0x66, 0x8c, 0x7c, 0x0e, 0xf5,
959 0xbf, 0x0a, 0x98, 0x5d, 0xc7, 0xc4, 0xb4, 0xad, 0x2e, 0xa1, 0xa7, 0xb0, 0x68, 0x1d, 0x50, 0xf2,
960 0x1c, 0xa2, 0x89, 0x45, 0xfb, 0x8e, 0xcc, 0xf7, 0xd0, 0x9d, 0xae, 0x43, 0xb4, 0x68, 0xa1, 0xd8,
961 0x13, 0xe2, 0xc6, 0xf0, 0x1d, 0x30, 0xed, 0x51, 0x4c, 0x07, 0x1e, 0x5f, 0xa6, 0xea, 0x8d, 0xe7,
962 0x8e, 0xa6, 0xe1, 0xd0, 0xf6, 0xbc, 0x20, 0x9a, 0xf6, 0x9f, 0x91, 0xa0, 0x50, 0xff, 0x51, 0x00,
963 0x30, 0xc4, 0x76, 0x6c, 0xab, 0xa7, 0x53, 0x16, 0xbf, 0xb7, 0x40, 0x89, 0x1e, 0x3a, 0x84, 0x4f,
964 0xc3, 0x6c, 0xfb, 0x72, 0xe0, 0xc5, 0xed, 0x43, 0x87, 0x3c, 0x1e, 0x36, 0x96, 0xb3, 0x16, 0xac,
965 0x07, 0x71, 0x1b, 0xb8, 0x11, 0xfa, 0x57, 0xe0, 0xd6, 0x37, 0x93, 0xaf, 0x7e, 0x3c, 0x6c, 0x48,
966 0x36, 0x8b, 0x66, 0xc8, 0x94, 0x74, 0x10, 0x1e, 0x00, 0x68, 0x60, 0x8f, 0xde, 0x76, 0xb1, 0xe5,
967 0xf9, 0x6f, 0xd2, 0x4d, 0x22, 0x46, 0xfe, 0xc2, 0x64, 0xcb, 0xc3, 0x2c, 0xda, 0xe7, 0x85, 0x17,
968 0x70, 0x23, 0xc3, 0x86, 0x24, 0x6f, 0x80, 0x97, 0xc1, 0xb4, 0x4b, 0xb0, 0x67, 0x5b, 0xb5, 0x12,
969 0x1f, 0x45, 0x38, 0x81, 0x88, 0xb7, 0x22, 0xd1, 0x0b, 0x9f, 0x07, 0x33, 0x26, 0xf1, 0x3c, 0xdc,
970 0x27, 0xb5, 0x32, 0x07, 0x2e, 0x08, 0xe0, 0xcc, 0xa6, 0xdf, 0x8c, 0x82, 0x7e, 0xf5, 0x0f, 0x0a,
971 0x98, 0x0b, 0x67, 0xee, 0x14, 0x52, 0xa5, 0x9d, 0x4c, 0x95, 0x67, 0x8f, 0x8c, 0x93, 0x9c, 0x0c,
972 0xf9, 0xb8, 0x18, 0xf3, 0x99, 0x05, 0x21, 0xfc, 0x29, 0xa8, 0x78, 0xc4, 0x20, 0x1a, 0xb5, 0x5d,
973 0xe1, 0xf3, 0x4b, 0x13, 0xfa, 0x8c, 0xf7, 0x88, 0xd1, 0x15, 0xa6, 0xed, 0x33, 0xcc, 0xe9, 0xe0,
974 0x09, 0x85, 0x94, 0xf0, 0xc7, 0xa0, 0x42, 0x89, 0xe9, 0x18, 0x98, 0x12, 0x91, 0x26, 0x89, 0xf8,
975 0x66, 0xe1, 0xc2, 0xc8, 0x76, 0xec, 0xde, 0x6d, 0x01, 0xe3, 0x89, 0x12, 0xce, 0x43, 0xd0, 0x8a,
976 0x42, 0x1a, 0x78, 0x1f, 0xcc, 0x0f, 0x9c, 0x1e, 0x43, 0x52, 0xb6, 0x75, 0xf7, 0x0f, 0x45, 0xf8,
977 0x5c, 0x3d, 0x72, 0x42, 0x76, 0x13, 0x26, 0xed, 0x65, 0xf1, 0x82, 0xf9, 0x64, 0x3b, 0x4a, 0x51,
978 0xc3, 0x35, 0xb0, 0x60, 0xea, 0x16, 0x22, 0xb8, 0x77, 0xd8, 0x25, 0x9a, 0x6d, 0xf5, 0x3c, 0x1e,
979 0x40, 0xe5, 0xf6, 0x8a, 0x20, 0x58, 0xd8, 0x4c, 0x76, 0xa3, 0x34, 0x1e, 0x6e, 0x80, 0xa5, 0x60,
980 0x9f, 0xfd, 0xa1, 0xee, 0x51, 0xdb, 0x3d, 0xdc, 0xd0, 0x4d, 0x9d, 0xd6, 0xa6, 0x39, 0x4f, 0x6d,
981 0x34, 0x6c, 0x2c, 0x21, 0x49, 0x3f, 0x92, 0x5a, 0xa9, 0xbf, 0x99, 0x06, 0x0b, 0xa9, 0xdd, 0x00,
982 0xde, 0x01, 0xcb, 0xda, 0xc0, 0x75, 0x89, 0x45, 0xb7, 0x06, 0xe6, 0x1e, 0x71, 0xbb, 0xda, 0x3e,
983 0xe9, 0x0d, 0x0c, 0xd2, 0xe3, 0x2b, 0x5a, 0x6e, 0xd7, 0x85, 0xaf, 0xcb, 0x1d, 0x29, 0x0a, 0xe5,
984 0x58, 0xc3, 0x1f, 0x01, 0x68, 0xf1, 0xa6, 0x4d, 0xdd, 0xf3, 0x42, 0xce, 0x02, 0xe7, 0x0c, 0x13,
985 0x70, 0x2b, 0x83, 0x40, 0x12, 0x2b, 0xe6, 0x63, 0x8f, 0x78, 0xba, 0x4b, 0x7a, 0x69, 0x1f, 0x8b,
986 0x49, 0x1f, 0xd7, 0xa5, 0x28, 0x94, 0x63, 0x0d, 0x5f, 0x06, 0x55, 0xff, 0x6d, 0x7c, 0xce, 0xc5,
987 0xe2, 0x2c, 0x0a, 0xb2, 0xea, 0x56, 0xd4, 0x85, 0xe2, 0x38, 0x36, 0x34, 0x7b, 0xcf, 0x23, 0xee,
988 0x01, 0xe9, 0xbd, 0xe5, 0x6b, 0x00, 0x56, 0x28, 0xcb, 0xbc, 0x50, 0x86, 0x43, 0xdb, 0xce, 0x20,
989 0x90, 0xc4, 0x8a, 0x0d, 0xcd, 0x8f, 0x9a, 0xcc, 0xd0, 0xa6, 0x93, 0x43, 0xdb, 0x95, 0xa2, 0x50,
990 0x8e, 0x35, 0x8b, 0x3d, 0xdf, 0xe5, 0xb5, 0x03, 0xac, 0x1b, 0x78, 0xcf, 0x20, 0xb5, 0x99, 0x64,
991 0xec, 0x6d, 0x25, 0xbb, 0x51, 0x1a, 0x0f, 0xdf, 0x02, 0xe7, 0xfc, 0xa6, 0x5d, 0x0b, 0x87, 0x24,
992 0x15, 0x4e, 0xf2, 0x8c, 0x20, 0x39, 0xb7, 0x95, 0x06, 0xa0, 0xac, 0x0d, 0xbc, 0x05, 0xe6, 0x35,
993 0xdb, 0x30, 0x78, 0x3c, 0x76, 0xec, 0x81, 0x45, 0x6b, 0xb3, 0x9c, 0x05, 0xb2, 0x1c, 0xea, 0x24,
994 0x7a, 0x50, 0x0a, 0x09, 0xef, 0x02, 0xa0, 0x05, 0xe5, 0xc0, 0xab, 0x81, 0xfc, 0x42, 0x9f, 0xad,
995 0x43, 0x51, 0x01, 0x0e, 0x9b, 0x3c, 0x14, 0x63, 0x53, 0x3f, 0x56, 0xc0, 0x4a, 0x4e, 0x8e, 0xc3,
996 0x37, 0x12, 0x55, 0xef, 0x6a, 0xaa, 0xea, 0x5d, 0xc8, 0x31, 0x8b, 0x95, 0x3e, 0x0d, 0xcc, 0x31,
997 0xdd, 0xa1, 0x5b, 0x7d, 0x1f, 0x22, 0x76, 0xb0, 0x17, 0x64, 0xbe, 0xa3, 0x38, 0x30, 0xda, 0x86,
998 0xcf, 0x8d, 0x86, 0x8d, 0xb9, 0x44, 0x1f, 0x4a, 0x72, 0xaa, 0xbf, 0x2a, 0x00, 0xb0, 0x4e, 0x1c,
999 0xc3, 0x3e, 0x34, 0x89, 0x75, 0x1a, 0xaa, 0x65, 0x3d, 0xa1, 0x5a, 0x54, 0xe9, 0x42, 0x84, 0xfe,
1000 0xe4, 0xca, 0x96, 0x8d, 0x94, 0x6c, 0xb9, 0x34, 0x86, 0xe7, 0x68, 0xdd, 0xf2, 0xb7, 0x22, 0x58,
1001 0x8c, 0xc0, 0x91, 0x70, 0x79, 0x2d, 0xb1, 0x84, 0x57, 0x52, 0x4b, 0xb8, 0x22, 0x31, 0x79, 0x6a,
1002 0xca, 0xe5, 0x7d, 0x30, 0xcf, 0x74, 0x85, 0xbf, 0x6a, 0x5c, 0xb5, 0x4c, 0x1f, 0x5b, 0xb5, 0x84,
1003 0x55, 0x67, 0x23, 0xc1, 0x84, 0x52, 0xcc, 0x39, 0x2a, 0x69, 0xe6, 0xab, 0xa8, 0x92, 0xfe, 0xa8,
1004 0x80, 0xf9, 0x68, 0x99, 0x4e, 0x41, 0x26, 0x75, 0x92, 0x32, 0xa9, 0x7e, 0x74, 0x5c, 0xe6, 0xe8,
1005 0xa4, 0xbf, 0x96, 0xe2, 0x5e, 0x73, 0xa1, 0xb4, 0xca, 0x0e, 0x54, 0x8e, 0xa1, 0x6b, 0xd8, 0x13,
1006 0x65, 0xf5, 0x8c, 0x7f, 0x98, 0xf2, 0xdb, 0x50, 0xd8, 0x9b, 0x90, 0x54, 0x85, 0xa7, 0x2b, 0xa9,
1007 0x8a, 0x5f, 0x8c, 0xa4, 0xba, 0x0d, 0x2a, 0x5e, 0x20, 0xa6, 0x4a, 0x9c, 0xf2, 0xf2, 0xb8, 0x74,
1008 0x16, 0x3a, 0x2a, 0x64, 0x0d, 0x15, 0x54, 0xc8, 0x24, 0xd3, 0x4e, 0xe5, 0x2f, 0x53, 0x3b, 0xb1,
1009 0xf0, 0x76, 0xf0, 0xc0, 0x23, 0x3d, 0x9e, 0x4a, 0x95, 0x28, 0xbc, 0x77, 0x78, 0x2b, 0x12, 0xbd,
1010 0x70, 0x17, 0xac, 0x38, 0xae, 0xdd, 0x77, 0x89, 0xe7, 0xad, 0x13, 0xdc, 0x33, 0x74, 0x8b, 0x04,
1011 0x03, 0xf0, 0xab, 0xde, 0x85, 0xd1, 0xb0, 0xb1, 0xb2, 0x23, 0x87, 0xa0, 0x3c, 0x5b, 0xf5, 0xa3,
1012 0x12, 0x38, 0x9b, 0xde, 0x11, 0x73, 0x84, 0x88, 0x72, 0x22, 0x21, 0xf2, 0x62, 0x2c, 0x44, 0x7d,
1013 0x95, 0x16, 0x3b, 0xf3, 0x67, 0xc2, 0x74, 0x0d, 0x2c, 0x08, 0xe1, 0x11, 0x74, 0x0a, 0x29, 0x16,
1014 0x2e, 0xcf, 0x6e, 0xb2, 0x1b, 0xa5, 0xf1, 0xf0, 0x35, 0x30, 0xe7, 0x72, 0x6d, 0x15, 0x10, 0xf8,
1015 0xfa, 0xe4, 0x5b, 0x82, 0x60, 0x0e, 0xc5, 0x3b, 0x51, 0x12, 0xcb, 0xb4, 0x49, 0x24, 0x39, 0x02,
1016 0x82, 0x52, 0x52, 0x9b, 0xac, 0xa5, 0x01, 0x28, 0x6b, 0x03, 0x37, 0xc1, 0xe2, 0xc0, 0xca, 0x52,
1017 0xf9, 0xb1, 0x76, 0x41, 0x50, 0x2d, 0xee, 0x66, 0x21, 0x48, 0x66, 0x07, 0x7f, 0x92, 0x90, 0x2b,
1018 0xd3, 0x7c, 0x17, 0xb9, 0x72, 0x74, 0x3a, 0x4c, 0xac, 0x57, 0x24, 0x3a, 0xaa, 0x32, 0xa9, 0x8e,
1019 0x52, 0x3f, 0x54, 0x00, 0xcc, 0xa6, 0xe0, 0xd8, 0xc3, 0x7d, 0xc6, 0x22, 0x56, 0x22, 0x7b, 0x72,
1020 0x85, 0x73, 0x75, 0xbc, 0xc2, 0x89, 0x76, 0xd0, 0xc9, 0x24, 0x8e, 0x98, 0xde, 0xd3, 0xb9, 0x98,
1021 0x99, 0x40, 0xe2, 0x44, 0xfe, 0x3c, 0x99, 0xc4, 0x89, 0xf1, 0x1c, 0x2d, 0x71, 0xfe, 0x59, 0x00,
1022 0x8b, 0x11, 0x78, 0x62, 0x89, 0x23, 0x31, 0xf9, 0xe6, 0x72, 0x66, 0x32, 0xd9, 0x11, 0x4d, 0xdd,
1023 0xff, 0x89, 0xec, 0x88, 0x1c, 0xca, 0x91, 0x1d, 0xbf, 0x2f, 0xc4, 0xbd, 0x3e, 0xa6, 0xec, 0xf8,
1024 0x02, 0xae, 0x2a, 0xbe, 0x72, 0xca, 0x45, 0xfd, 0xa4, 0x08, 0xce, 0xa6, 0x53, 0x30, 0x51, 0x07,
1025 0x95, 0xb1, 0x75, 0x70, 0x07, 0x2c, 0xdd, 0x1b, 0x18, 0xc6, 0x21, 0x1f, 0x43, 0xac, 0x18, 0xfa,
1026 0x15, 0xf4, 0xdb, 0xc2, 0x72, 0xe9, 0x07, 0x12, 0x0c, 0x92, 0x5a, 0x66, 0xcb, 0x62, 0xe9, 0x49,
1027 0xcb, 0x62, 0xf9, 0x04, 0x65, 0x51, 0xae, 0x2c, 0x8a, 0x27, 0x52, 0x16, 0x13, 0xd7, 0x44, 0xc9,
1028 0x76, 0x35, 0xf6, 0x0c, 0x3f, 0x52, 0xc0, 0xb2, 0xfc, 0xf8, 0x0c, 0x0d, 0x30, 0x6f, 0xe2, 0x07,
1029 0xf1, 0xcb, 0x8b, 0x71, 0x05, 0x63, 0x40, 0x75, 0xa3, 0xe9, 0x7f, 0xdd, 0x69, 0xbe, 0x6d, 0xd1,
1030 0x6d, 0xb7, 0x4b, 0x5d, 0xdd, 0xea, 0xfb, 0x05, 0x76, 0x33, 0xc1, 0x85, 0x52, 0xdc, 0xf0, 0x2e,
1031 0xa8, 0x98, 0xf8, 0x41, 0x77, 0xe0, 0xf6, 0x83, 0x42, 0x78, 0xfc, 0xf7, 0xf0, 0xd8, 0xdf, 0x14,
1032 0x2c, 0x28, 0xe4, 0x53, 0x3f, 0x57, 0xc0, 0x4a, 0x4e, 0x05, 0xfd, 0x1a, 0x8d, 0xf2, 0x23, 0x05,
1033 0x5c, 0x4c, 0x8c, 0x92, 0x65, 0x24, 0xb9, 0x37, 0x30, 0x78, 0x72, 0x0a, 0xc1, 0x72, 0x15, 0xcc,
1034 0x3a, 0xd8, 0xa5, 0x7a, 0xa8, 0x74, 0xcb, 0xed, 0xb9, 0xd1, 0xb0, 0x31, 0xbb, 0x13, 0x34, 0xa2,
1035 0xa8, 0x5f, 0x32, 0x37, 0x85, 0xa7, 0x37, 0x37, 0xea, 0xaf, 0x0b, 0xa0, 0x1a, 0x73, 0xf9, 0x14,
1036 0xa4, 0xca, 0x9b, 0x09, 0xa9, 0x22, 0xfd, 0xf8, 0x13, 0x9f, 0xc3, 0x3c, 0xad, 0xb2, 0x99, 0xd2,
1037 0x2a, 0xdf, 0x1d, 0x47, 0x74, 0xb4, 0x58, 0xf9, 0x57, 0x01, 0x2c, 0xc5, 0xd0, 0x91, 0x5a, 0xf9,
1038 0x7e, 0x42, 0xad, 0xac, 0xa6, 0xd4, 0x4a, 0x4d, 0x66, 0xf3, 0x8d, 0x5c, 0x19, 0x2f, 0x57, 0xfe,
1039 0xa4, 0x80, 0x85, 0xd8, 0xdc, 0x9d, 0x82, 0x5e, 0x59, 0x4f, 0xea, 0x95, 0xc6, 0x98, 0x78, 0xc9,
1040 0x11, 0x2c, 0xb7, 0xc0, 0x62, 0x0c, 0xb4, 0xed, 0xf6, 0x74, 0x0b, 0x1b, 0x1e, 0x7c, 0x0e, 0x94,
1041 0x3d, 0x8a, 0x5d, 0x1a, 0x64, 0x77, 0x60, 0xdb, 0x65, 0x8d, 0xc8, 0xef, 0x53, 0xff, 0xad, 0x80,
1042 0x56, 0xcc, 0x78, 0x87, 0xb8, 0x9e, 0xee, 0x51, 0x62, 0xd1, 0x3b, 0xb6, 0x31, 0x30, 0x49, 0xc7,
1043 0xc0, 0xba, 0x89, 0x08, 0x6b, 0xd0, 0x6d, 0x6b, 0xc7, 0x36, 0x74, 0xed, 0x10, 0x62, 0x50, 0xfd,
1044 0x60, 0x9f, 0x58, 0xeb, 0xc4, 0x20, 0x54, 0x7c, 0xde, 0x98, 0x6d, 0xbf, 0x11, 0xdc, 0xf6, 0xbf,
1045 0x1b, 0x75, 0x3d, 0x1e, 0x36, 0x56, 0x27, 0x61, 0xe4, 0xc1, 0x19, 0xe7, 0x84, 0x3f, 0x03, 0x80,
1046 0x3d, 0x76, 0x35, 0x1c, 0x7c, 0xec, 0x98, 0x6d, 0xbf, 0x1e, 0xa4, 0xf0, 0xbb, 0x61, 0xcf, 0xb1,
1047 0x5e, 0x10, 0x63, 0x54, 0x7f, 0x57, 0x49, 0x2c, 0xf5, 0xd7, 0xfe, 0x6e, 0xe9, 0x17, 0x60, 0xe9,
1048 0x20, 0x9a, 0x9d, 0x00, 0xc0, 0x34, 0x11, 0x8b, 0xbb, 0xe7, 0xa5, 0xf4, 0xb2, 0x79, 0x8d, 0x94,
1049 0xd8, 0x1d, 0x09, 0x1d, 0x92, 0xbe, 0x04, 0xbe, 0x0c, 0xaa, 0x4c, 0xcb, 0xe8, 0x1a, 0xd9, 0xc2,
1050 0x66, 0x90, 0x86, 0xe1, 0xd7, 0xa1, 0x6e, 0xd4, 0x85, 0xe2, 0x38, 0xb8, 0x0f, 0x16, 0x1d, 0xbb,
1051 0xb7, 0x89, 0x2d, 0xdc, 0x27, 0xac, 0x42, 0xfb, 0x4b, 0xc9, 0x6f, 0x9d, 0x66, 0xdb, 0xaf, 0x04,
1052 0x37, 0x0a, 0x3b, 0x59, 0x08, 0x3b, 0xb1, 0x49, 0x9a, 0x79, 0x10, 0xc8, 0x28, 0xa1, 0x99, 0xf9,
1053 0x98, 0x39, 0x93, 0xf9, 0x07, 0x88, 0x2c, 0x1f, 0x4f, 0xf8, 0x39, 0x33, 0xef, 0x3e, 0xad, 0x72,
1054 0xa2, 0xfb, 0x34, 0xc9, 0x89, 0x63, 0xf6, 0x98, 0x27, 0x8e, 0x4f, 0x14, 0x70, 0xc9, 0x99, 0x20,
1055 0x8d, 0x6a, 0x80, 0x4f, 0x4b, 0x67, 0xcc, 0xb4, 0x4c, 0x92, 0x91, 0xed, 0xd5, 0xd1, 0xb0, 0x71,
1056 0x69, 0x12, 0x24, 0x9a, 0xc8, 0x35, 0x96, 0x34, 0xb6, 0xd8, 0xf9, 0x6a, 0x55, 0xee, 0xe6, 0x95,
1057 0x31, 0x6e, 0x06, 0x1b, 0xa5, 0x9f, 0x87, 0xc1, 0x13, 0x0a, 0x69, 0xd4, 0x0f, 0xcb, 0xe0, 0x5c,
1058 0xa6, 0x5a, 0x7f, 0x89, 0x77, 0x85, 0x99, 0x13, 0x4d, 0xf1, 0x18, 0x27, 0x9a, 0x35, 0xb0, 0x20,
1059 0x3e, 0x30, 0xa7, 0x0e, 0x44, 0x61, 0x98, 0x74, 0x92, 0xdd, 0x28, 0x8d, 0x97, 0xdd, 0x55, 0x96,
1060 0x8f, 0x79, 0x57, 0x19, 0xf7, 0x42, 0xfc, 0x2f, 0xca, 0xcf, 0xe7, 0xac, 0x17, 0xe2, 0xef, 0x51,
1061 0x69, 0x3c, 0x7c, 0x3d, 0x48, 0xd6, 0x90, 0x61, 0x86, 0x33, 0xa4, 0xb2, 0x2f, 0x24, 0x48, 0xa1,
1062 0x9f, 0xe8, 0x23, 0xea, 0x7b, 0x92, 0x8f, 0xa8, 0xab, 0x63, 0xc2, 0x6c, 0xf2, 0x6b, 0x49, 0xe9,
1063 0xa1, 0xb3, 0x7a, 0xfc, 0x43, 0xa7, 0xfa, 0x17, 0x05, 0x3c, 0x93, 0xbb, 0x4d, 0xc1, 0xb5, 0x84,
1064 0x7a, 0xbc, 0x96, 0x52, 0x8f, 0xcf, 0xe6, 0x1a, 0xc6, 0x24, 0xa4, 0x29, 0xbf, 0xb1, 0xbc, 0x39,
1065 0xf6, 0xc6, 0x52, 0x72, 0x12, 0x19, 0x7f, 0x75, 0xd9, 0x7e, 0xf5, 0xe1, 0xa3, 0xfa, 0xd4, 0xa7,
1066 0x8f, 0xea, 0x53, 0x9f, 0x3d, 0xaa, 0x4f, 0xfd, 0x72, 0x54, 0x57, 0x1e, 0x8e, 0xea, 0xca, 0xa7,
1067 0xa3, 0xba, 0xf2, 0xd9, 0xa8, 0xae, 0xfc, 0x7d, 0x54, 0x57, 0x7e, 0xfb, 0x79, 0x7d, 0xea, 0x2e,
1068 0xcc, 0xfe, 0x2b, 0xf3, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd3, 0xfa, 0xed, 0x70, 0xaa, 0x29,
1069 0x00, 0x00,
1070 }
1071
1072 func (m *ControllerRevision) Marshal() (dAtA []byte, err error) {
1073 size := m.Size()
1074 dAtA = make([]byte, size)
1075 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1076 if err != nil {
1077 return nil, err
1078 }
1079 return dAtA[:n], nil
1080 }
1081
1082 func (m *ControllerRevision) MarshalTo(dAtA []byte) (int, error) {
1083 size := m.Size()
1084 return m.MarshalToSizedBuffer(dAtA[:size])
1085 }
1086
1087 func (m *ControllerRevision) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1088 i := len(dAtA)
1089 _ = i
1090 var l int
1091 _ = l
1092 i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
1093 i--
1094 dAtA[i] = 0x18
1095 {
1096 size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
1097 if err != nil {
1098 return 0, err
1099 }
1100 i -= size
1101 i = encodeVarintGenerated(dAtA, i, uint64(size))
1102 }
1103 i--
1104 dAtA[i] = 0x12
1105 {
1106 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1107 if err != nil {
1108 return 0, err
1109 }
1110 i -= size
1111 i = encodeVarintGenerated(dAtA, i, uint64(size))
1112 }
1113 i--
1114 dAtA[i] = 0xa
1115 return len(dAtA) - i, nil
1116 }
1117
1118 func (m *ControllerRevisionList) Marshal() (dAtA []byte, err error) {
1119 size := m.Size()
1120 dAtA = make([]byte, size)
1121 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1122 if err != nil {
1123 return nil, err
1124 }
1125 return dAtA[:n], nil
1126 }
1127
1128 func (m *ControllerRevisionList) MarshalTo(dAtA []byte) (int, error) {
1129 size := m.Size()
1130 return m.MarshalToSizedBuffer(dAtA[:size])
1131 }
1132
1133 func (m *ControllerRevisionList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1134 i := len(dAtA)
1135 _ = i
1136 var l int
1137 _ = l
1138 if len(m.Items) > 0 {
1139 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1140 {
1141 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1142 if err != nil {
1143 return 0, err
1144 }
1145 i -= size
1146 i = encodeVarintGenerated(dAtA, i, uint64(size))
1147 }
1148 i--
1149 dAtA[i] = 0x12
1150 }
1151 }
1152 {
1153 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1154 if err != nil {
1155 return 0, err
1156 }
1157 i -= size
1158 i = encodeVarintGenerated(dAtA, i, uint64(size))
1159 }
1160 i--
1161 dAtA[i] = 0xa
1162 return len(dAtA) - i, nil
1163 }
1164
1165 func (m *DaemonSet) Marshal() (dAtA []byte, err error) {
1166 size := m.Size()
1167 dAtA = make([]byte, size)
1168 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1169 if err != nil {
1170 return nil, err
1171 }
1172 return dAtA[:n], nil
1173 }
1174
1175 func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) {
1176 size := m.Size()
1177 return m.MarshalToSizedBuffer(dAtA[:size])
1178 }
1179
1180 func (m *DaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1181 i := len(dAtA)
1182 _ = i
1183 var l int
1184 _ = l
1185 {
1186 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1187 if err != nil {
1188 return 0, err
1189 }
1190 i -= size
1191 i = encodeVarintGenerated(dAtA, i, uint64(size))
1192 }
1193 i--
1194 dAtA[i] = 0x1a
1195 {
1196 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1197 if err != nil {
1198 return 0, err
1199 }
1200 i -= size
1201 i = encodeVarintGenerated(dAtA, i, uint64(size))
1202 }
1203 i--
1204 dAtA[i] = 0x12
1205 {
1206 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1207 if err != nil {
1208 return 0, err
1209 }
1210 i -= size
1211 i = encodeVarintGenerated(dAtA, i, uint64(size))
1212 }
1213 i--
1214 dAtA[i] = 0xa
1215 return len(dAtA) - i, nil
1216 }
1217
1218 func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) {
1219 size := m.Size()
1220 dAtA = make([]byte, size)
1221 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1222 if err != nil {
1223 return nil, err
1224 }
1225 return dAtA[:n], nil
1226 }
1227
1228 func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) {
1229 size := m.Size()
1230 return m.MarshalToSizedBuffer(dAtA[:size])
1231 }
1232
1233 func (m *DaemonSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1234 i := len(dAtA)
1235 _ = i
1236 var l int
1237 _ = l
1238 i -= len(m.Message)
1239 copy(dAtA[i:], m.Message)
1240 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1241 i--
1242 dAtA[i] = 0x2a
1243 i -= len(m.Reason)
1244 copy(dAtA[i:], m.Reason)
1245 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1246 i--
1247 dAtA[i] = 0x22
1248 {
1249 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1250 if err != nil {
1251 return 0, err
1252 }
1253 i -= size
1254 i = encodeVarintGenerated(dAtA, i, uint64(size))
1255 }
1256 i--
1257 dAtA[i] = 0x1a
1258 i -= len(m.Status)
1259 copy(dAtA[i:], m.Status)
1260 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1261 i--
1262 dAtA[i] = 0x12
1263 i -= len(m.Type)
1264 copy(dAtA[i:], m.Type)
1265 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1266 i--
1267 dAtA[i] = 0xa
1268 return len(dAtA) - i, nil
1269 }
1270
1271 func (m *DaemonSetList) Marshal() (dAtA []byte, err error) {
1272 size := m.Size()
1273 dAtA = make([]byte, size)
1274 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1275 if err != nil {
1276 return nil, err
1277 }
1278 return dAtA[:n], nil
1279 }
1280
1281 func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) {
1282 size := m.Size()
1283 return m.MarshalToSizedBuffer(dAtA[:size])
1284 }
1285
1286 func (m *DaemonSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1287 i := len(dAtA)
1288 _ = i
1289 var l int
1290 _ = l
1291 if len(m.Items) > 0 {
1292 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1293 {
1294 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1295 if err != nil {
1296 return 0, err
1297 }
1298 i -= size
1299 i = encodeVarintGenerated(dAtA, i, uint64(size))
1300 }
1301 i--
1302 dAtA[i] = 0x12
1303 }
1304 }
1305 {
1306 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1307 if err != nil {
1308 return 0, err
1309 }
1310 i -= size
1311 i = encodeVarintGenerated(dAtA, i, uint64(size))
1312 }
1313 i--
1314 dAtA[i] = 0xa
1315 return len(dAtA) - i, nil
1316 }
1317
1318 func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) {
1319 size := m.Size()
1320 dAtA = make([]byte, size)
1321 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1322 if err != nil {
1323 return nil, err
1324 }
1325 return dAtA[:n], nil
1326 }
1327
1328 func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) {
1329 size := m.Size()
1330 return m.MarshalToSizedBuffer(dAtA[:size])
1331 }
1332
1333 func (m *DaemonSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1334 i := len(dAtA)
1335 _ = i
1336 var l int
1337 _ = l
1338 if m.RevisionHistoryLimit != nil {
1339 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
1340 i--
1341 dAtA[i] = 0x30
1342 }
1343 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
1344 i--
1345 dAtA[i] = 0x20
1346 {
1347 size, err := m.UpdateStrategy.MarshalToSizedBuffer(dAtA[:i])
1348 if err != nil {
1349 return 0, err
1350 }
1351 i -= size
1352 i = encodeVarintGenerated(dAtA, i, uint64(size))
1353 }
1354 i--
1355 dAtA[i] = 0x1a
1356 {
1357 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
1358 if err != nil {
1359 return 0, err
1360 }
1361 i -= size
1362 i = encodeVarintGenerated(dAtA, i, uint64(size))
1363 }
1364 i--
1365 dAtA[i] = 0x12
1366 if m.Selector != nil {
1367 {
1368 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
1369 if err != nil {
1370 return 0, err
1371 }
1372 i -= size
1373 i = encodeVarintGenerated(dAtA, i, uint64(size))
1374 }
1375 i--
1376 dAtA[i] = 0xa
1377 }
1378 return len(dAtA) - i, nil
1379 }
1380
1381 func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) {
1382 size := m.Size()
1383 dAtA = make([]byte, size)
1384 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1385 if err != nil {
1386 return nil, err
1387 }
1388 return dAtA[:n], nil
1389 }
1390
1391 func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) {
1392 size := m.Size()
1393 return m.MarshalToSizedBuffer(dAtA[:size])
1394 }
1395
1396 func (m *DaemonSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1397 i := len(dAtA)
1398 _ = i
1399 var l int
1400 _ = l
1401 if len(m.Conditions) > 0 {
1402 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1403 {
1404 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1405 if err != nil {
1406 return 0, err
1407 }
1408 i -= size
1409 i = encodeVarintGenerated(dAtA, i, uint64(size))
1410 }
1411 i--
1412 dAtA[i] = 0x52
1413 }
1414 }
1415 if m.CollisionCount != nil {
1416 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1417 i--
1418 dAtA[i] = 0x48
1419 }
1420 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable))
1421 i--
1422 dAtA[i] = 0x40
1423 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable))
1424 i--
1425 dAtA[i] = 0x38
1426 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled))
1427 i--
1428 dAtA[i] = 0x30
1429 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1430 i--
1431 dAtA[i] = 0x28
1432 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady))
1433 i--
1434 dAtA[i] = 0x20
1435 i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled))
1436 i--
1437 dAtA[i] = 0x18
1438 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled))
1439 i--
1440 dAtA[i] = 0x10
1441 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled))
1442 i--
1443 dAtA[i] = 0x8
1444 return len(dAtA) - i, nil
1445 }
1446
1447 func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
1448 size := m.Size()
1449 dAtA = make([]byte, size)
1450 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1451 if err != nil {
1452 return nil, err
1453 }
1454 return dAtA[:n], nil
1455 }
1456
1457 func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
1458 size := m.Size()
1459 return m.MarshalToSizedBuffer(dAtA[:size])
1460 }
1461
1462 func (m *DaemonSetUpdateStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1463 i := len(dAtA)
1464 _ = i
1465 var l int
1466 _ = l
1467 if m.RollingUpdate != nil {
1468 {
1469 size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
1470 if err != nil {
1471 return 0, err
1472 }
1473 i -= size
1474 i = encodeVarintGenerated(dAtA, i, uint64(size))
1475 }
1476 i--
1477 dAtA[i] = 0x12
1478 }
1479 i -= len(m.Type)
1480 copy(dAtA[i:], m.Type)
1481 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1482 i--
1483 dAtA[i] = 0xa
1484 return len(dAtA) - i, nil
1485 }
1486
1487 func (m *Deployment) Marshal() (dAtA []byte, err error) {
1488 size := m.Size()
1489 dAtA = make([]byte, size)
1490 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1491 if err != nil {
1492 return nil, err
1493 }
1494 return dAtA[:n], nil
1495 }
1496
1497 func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
1498 size := m.Size()
1499 return m.MarshalToSizedBuffer(dAtA[:size])
1500 }
1501
1502 func (m *Deployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1503 i := len(dAtA)
1504 _ = i
1505 var l int
1506 _ = l
1507 {
1508 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1509 if err != nil {
1510 return 0, err
1511 }
1512 i -= size
1513 i = encodeVarintGenerated(dAtA, i, uint64(size))
1514 }
1515 i--
1516 dAtA[i] = 0x1a
1517 {
1518 size, err := m.Spec.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 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1529 if err != nil {
1530 return 0, err
1531 }
1532 i -= size
1533 i = encodeVarintGenerated(dAtA, i, uint64(size))
1534 }
1535 i--
1536 dAtA[i] = 0xa
1537 return len(dAtA) - i, nil
1538 }
1539
1540 func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
1541 size := m.Size()
1542 dAtA = make([]byte, size)
1543 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1544 if err != nil {
1545 return nil, err
1546 }
1547 return dAtA[:n], nil
1548 }
1549
1550 func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
1551 size := m.Size()
1552 return m.MarshalToSizedBuffer(dAtA[:size])
1553 }
1554
1555 func (m *DeploymentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1556 i := len(dAtA)
1557 _ = i
1558 var l int
1559 _ = l
1560 {
1561 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1562 if err != nil {
1563 return 0, err
1564 }
1565 i -= size
1566 i = encodeVarintGenerated(dAtA, i, uint64(size))
1567 }
1568 i--
1569 dAtA[i] = 0x3a
1570 {
1571 size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
1572 if err != nil {
1573 return 0, err
1574 }
1575 i -= size
1576 i = encodeVarintGenerated(dAtA, i, uint64(size))
1577 }
1578 i--
1579 dAtA[i] = 0x32
1580 i -= len(m.Message)
1581 copy(dAtA[i:], m.Message)
1582 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1583 i--
1584 dAtA[i] = 0x2a
1585 i -= len(m.Reason)
1586 copy(dAtA[i:], m.Reason)
1587 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1588 i--
1589 dAtA[i] = 0x22
1590 i -= len(m.Status)
1591 copy(dAtA[i:], m.Status)
1592 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1593 i--
1594 dAtA[i] = 0x12
1595 i -= len(m.Type)
1596 copy(dAtA[i:], m.Type)
1597 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1598 i--
1599 dAtA[i] = 0xa
1600 return len(dAtA) - i, nil
1601 }
1602
1603 func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
1604 size := m.Size()
1605 dAtA = make([]byte, size)
1606 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1607 if err != nil {
1608 return nil, err
1609 }
1610 return dAtA[:n], nil
1611 }
1612
1613 func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
1614 size := m.Size()
1615 return m.MarshalToSizedBuffer(dAtA[:size])
1616 }
1617
1618 func (m *DeploymentList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1619 i := len(dAtA)
1620 _ = i
1621 var l int
1622 _ = l
1623 if len(m.Items) > 0 {
1624 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1625 {
1626 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1627 if err != nil {
1628 return 0, err
1629 }
1630 i -= size
1631 i = encodeVarintGenerated(dAtA, i, uint64(size))
1632 }
1633 i--
1634 dAtA[i] = 0x12
1635 }
1636 }
1637 {
1638 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1639 if err != nil {
1640 return 0, err
1641 }
1642 i -= size
1643 i = encodeVarintGenerated(dAtA, i, uint64(size))
1644 }
1645 i--
1646 dAtA[i] = 0xa
1647 return len(dAtA) - i, nil
1648 }
1649
1650 func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
1651 size := m.Size()
1652 dAtA = make([]byte, size)
1653 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1654 if err != nil {
1655 return nil, err
1656 }
1657 return dAtA[:n], nil
1658 }
1659
1660 func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
1661 size := m.Size()
1662 return m.MarshalToSizedBuffer(dAtA[:size])
1663 }
1664
1665 func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1666 i := len(dAtA)
1667 _ = i
1668 var l int
1669 _ = l
1670 if m.ProgressDeadlineSeconds != nil {
1671 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
1672 i--
1673 dAtA[i] = 0x48
1674 }
1675 i--
1676 if m.Paused {
1677 dAtA[i] = 1
1678 } else {
1679 dAtA[i] = 0
1680 }
1681 i--
1682 dAtA[i] = 0x38
1683 if m.RevisionHistoryLimit != nil {
1684 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
1685 i--
1686 dAtA[i] = 0x30
1687 }
1688 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
1689 i--
1690 dAtA[i] = 0x28
1691 {
1692 size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i])
1693 if err != nil {
1694 return 0, err
1695 }
1696 i -= size
1697 i = encodeVarintGenerated(dAtA, i, uint64(size))
1698 }
1699 i--
1700 dAtA[i] = 0x22
1701 {
1702 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
1703 if err != nil {
1704 return 0, err
1705 }
1706 i -= size
1707 i = encodeVarintGenerated(dAtA, i, uint64(size))
1708 }
1709 i--
1710 dAtA[i] = 0x1a
1711 if m.Selector != nil {
1712 {
1713 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
1714 if err != nil {
1715 return 0, err
1716 }
1717 i -= size
1718 i = encodeVarintGenerated(dAtA, i, uint64(size))
1719 }
1720 i--
1721 dAtA[i] = 0x12
1722 }
1723 if m.Replicas != nil {
1724 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
1725 i--
1726 dAtA[i] = 0x8
1727 }
1728 return len(dAtA) - i, nil
1729 }
1730
1731 func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
1732 size := m.Size()
1733 dAtA = make([]byte, size)
1734 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1735 if err != nil {
1736 return nil, err
1737 }
1738 return dAtA[:n], nil
1739 }
1740
1741 func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
1742 size := m.Size()
1743 return m.MarshalToSizedBuffer(dAtA[:size])
1744 }
1745
1746 func (m *DeploymentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1747 i := len(dAtA)
1748 _ = i
1749 var l int
1750 _ = l
1751 if m.CollisionCount != nil {
1752 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1753 i--
1754 dAtA[i] = 0x40
1755 }
1756 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1757 i--
1758 dAtA[i] = 0x38
1759 if len(m.Conditions) > 0 {
1760 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1761 {
1762 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1763 if err != nil {
1764 return 0, err
1765 }
1766 i -= size
1767 i = encodeVarintGenerated(dAtA, i, uint64(size))
1768 }
1769 i--
1770 dAtA[i] = 0x32
1771 }
1772 }
1773 i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
1774 i--
1775 dAtA[i] = 0x28
1776 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1777 i--
1778 dAtA[i] = 0x20
1779 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1780 i--
1781 dAtA[i] = 0x18
1782 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1783 i--
1784 dAtA[i] = 0x10
1785 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1786 i--
1787 dAtA[i] = 0x8
1788 return len(dAtA) - i, nil
1789 }
1790
1791 func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
1792 size := m.Size()
1793 dAtA = make([]byte, size)
1794 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1795 if err != nil {
1796 return nil, err
1797 }
1798 return dAtA[:n], nil
1799 }
1800
1801 func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
1802 size := m.Size()
1803 return m.MarshalToSizedBuffer(dAtA[:size])
1804 }
1805
1806 func (m *DeploymentStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1807 i := len(dAtA)
1808 _ = i
1809 var l int
1810 _ = l
1811 if m.RollingUpdate != nil {
1812 {
1813 size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
1814 if err != nil {
1815 return 0, err
1816 }
1817 i -= size
1818 i = encodeVarintGenerated(dAtA, i, uint64(size))
1819 }
1820 i--
1821 dAtA[i] = 0x12
1822 }
1823 i -= len(m.Type)
1824 copy(dAtA[i:], m.Type)
1825 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1826 i--
1827 dAtA[i] = 0xa
1828 return len(dAtA) - i, nil
1829 }
1830
1831 func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
1832 size := m.Size()
1833 dAtA = make([]byte, size)
1834 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1835 if err != nil {
1836 return nil, err
1837 }
1838 return dAtA[:n], nil
1839 }
1840
1841 func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
1842 size := m.Size()
1843 return m.MarshalToSizedBuffer(dAtA[:size])
1844 }
1845
1846 func (m *ReplicaSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1847 i := len(dAtA)
1848 _ = i
1849 var l int
1850 _ = l
1851 {
1852 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1853 if err != nil {
1854 return 0, err
1855 }
1856 i -= size
1857 i = encodeVarintGenerated(dAtA, i, uint64(size))
1858 }
1859 i--
1860 dAtA[i] = 0x1a
1861 {
1862 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1863 if err != nil {
1864 return 0, err
1865 }
1866 i -= size
1867 i = encodeVarintGenerated(dAtA, i, uint64(size))
1868 }
1869 i--
1870 dAtA[i] = 0x12
1871 {
1872 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1873 if err != nil {
1874 return 0, err
1875 }
1876 i -= size
1877 i = encodeVarintGenerated(dAtA, i, uint64(size))
1878 }
1879 i--
1880 dAtA[i] = 0xa
1881 return len(dAtA) - i, nil
1882 }
1883
1884 func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
1885 size := m.Size()
1886 dAtA = make([]byte, size)
1887 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1888 if err != nil {
1889 return nil, err
1890 }
1891 return dAtA[:n], nil
1892 }
1893
1894 func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
1895 size := m.Size()
1896 return m.MarshalToSizedBuffer(dAtA[:size])
1897 }
1898
1899 func (m *ReplicaSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1900 i := len(dAtA)
1901 _ = i
1902 var l int
1903 _ = l
1904 i -= len(m.Message)
1905 copy(dAtA[i:], m.Message)
1906 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1907 i--
1908 dAtA[i] = 0x2a
1909 i -= len(m.Reason)
1910 copy(dAtA[i:], m.Reason)
1911 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1912 i--
1913 dAtA[i] = 0x22
1914 {
1915 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1916 if err != nil {
1917 return 0, err
1918 }
1919 i -= size
1920 i = encodeVarintGenerated(dAtA, i, uint64(size))
1921 }
1922 i--
1923 dAtA[i] = 0x1a
1924 i -= len(m.Status)
1925 copy(dAtA[i:], m.Status)
1926 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1927 i--
1928 dAtA[i] = 0x12
1929 i -= len(m.Type)
1930 copy(dAtA[i:], m.Type)
1931 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1932 i--
1933 dAtA[i] = 0xa
1934 return len(dAtA) - i, nil
1935 }
1936
1937 func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) {
1938 size := m.Size()
1939 dAtA = make([]byte, size)
1940 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1941 if err != nil {
1942 return nil, err
1943 }
1944 return dAtA[:n], nil
1945 }
1946
1947 func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) {
1948 size := m.Size()
1949 return m.MarshalToSizedBuffer(dAtA[:size])
1950 }
1951
1952 func (m *ReplicaSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1953 i := len(dAtA)
1954 _ = i
1955 var l int
1956 _ = l
1957 if len(m.Items) > 0 {
1958 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1959 {
1960 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1961 if err != nil {
1962 return 0, err
1963 }
1964 i -= size
1965 i = encodeVarintGenerated(dAtA, i, uint64(size))
1966 }
1967 i--
1968 dAtA[i] = 0x12
1969 }
1970 }
1971 {
1972 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1973 if err != nil {
1974 return 0, err
1975 }
1976 i -= size
1977 i = encodeVarintGenerated(dAtA, i, uint64(size))
1978 }
1979 i--
1980 dAtA[i] = 0xa
1981 return len(dAtA) - i, nil
1982 }
1983
1984 func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
1985 size := m.Size()
1986 dAtA = make([]byte, size)
1987 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1988 if err != nil {
1989 return nil, err
1990 }
1991 return dAtA[:n], nil
1992 }
1993
1994 func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
1995 size := m.Size()
1996 return m.MarshalToSizedBuffer(dAtA[:size])
1997 }
1998
1999 func (m *ReplicaSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2000 i := len(dAtA)
2001 _ = i
2002 var l int
2003 _ = l
2004 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
2005 i--
2006 dAtA[i] = 0x20
2007 {
2008 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
2009 if err != nil {
2010 return 0, err
2011 }
2012 i -= size
2013 i = encodeVarintGenerated(dAtA, i, uint64(size))
2014 }
2015 i--
2016 dAtA[i] = 0x1a
2017 if m.Selector != nil {
2018 {
2019 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
2020 if err != nil {
2021 return 0, err
2022 }
2023 i -= size
2024 i = encodeVarintGenerated(dAtA, i, uint64(size))
2025 }
2026 i--
2027 dAtA[i] = 0x12
2028 }
2029 if m.Replicas != nil {
2030 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
2031 i--
2032 dAtA[i] = 0x8
2033 }
2034 return len(dAtA) - i, nil
2035 }
2036
2037 func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
2038 size := m.Size()
2039 dAtA = make([]byte, size)
2040 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2041 if err != nil {
2042 return nil, err
2043 }
2044 return dAtA[:n], nil
2045 }
2046
2047 func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
2048 size := m.Size()
2049 return m.MarshalToSizedBuffer(dAtA[:size])
2050 }
2051
2052 func (m *ReplicaSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2053 i := len(dAtA)
2054 _ = i
2055 var l int
2056 _ = l
2057 if len(m.Conditions) > 0 {
2058 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
2059 {
2060 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2061 if err != nil {
2062 return 0, err
2063 }
2064 i -= size
2065 i = encodeVarintGenerated(dAtA, i, uint64(size))
2066 }
2067 i--
2068 dAtA[i] = 0x32
2069 }
2070 }
2071 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
2072 i--
2073 dAtA[i] = 0x28
2074 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
2075 i--
2076 dAtA[i] = 0x20
2077 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
2078 i--
2079 dAtA[i] = 0x18
2080 i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas))
2081 i--
2082 dAtA[i] = 0x10
2083 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2084 i--
2085 dAtA[i] = 0x8
2086 return len(dAtA) - i, nil
2087 }
2088
2089 func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) {
2090 size := m.Size()
2091 dAtA = make([]byte, size)
2092 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2093 if err != nil {
2094 return nil, err
2095 }
2096 return dAtA[:n], nil
2097 }
2098
2099 func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) {
2100 size := m.Size()
2101 return m.MarshalToSizedBuffer(dAtA[:size])
2102 }
2103
2104 func (m *RollingUpdateDaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2105 i := len(dAtA)
2106 _ = i
2107 var l int
2108 _ = l
2109 if m.MaxSurge != nil {
2110 {
2111 size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
2112 if err != nil {
2113 return 0, err
2114 }
2115 i -= size
2116 i = encodeVarintGenerated(dAtA, i, uint64(size))
2117 }
2118 i--
2119 dAtA[i] = 0x12
2120 }
2121 if m.MaxUnavailable != nil {
2122 {
2123 size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
2124 if err != nil {
2125 return 0, err
2126 }
2127 i -= size
2128 i = encodeVarintGenerated(dAtA, i, uint64(size))
2129 }
2130 i--
2131 dAtA[i] = 0xa
2132 }
2133 return len(dAtA) - i, nil
2134 }
2135
2136 func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
2137 size := m.Size()
2138 dAtA = make([]byte, size)
2139 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2140 if err != nil {
2141 return nil, err
2142 }
2143 return dAtA[:n], nil
2144 }
2145
2146 func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
2147 size := m.Size()
2148 return m.MarshalToSizedBuffer(dAtA[:size])
2149 }
2150
2151 func (m *RollingUpdateDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2152 i := len(dAtA)
2153 _ = i
2154 var l int
2155 _ = l
2156 if m.MaxSurge != nil {
2157 {
2158 size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
2159 if err != nil {
2160 return 0, err
2161 }
2162 i -= size
2163 i = encodeVarintGenerated(dAtA, i, uint64(size))
2164 }
2165 i--
2166 dAtA[i] = 0x12
2167 }
2168 if m.MaxUnavailable != nil {
2169 {
2170 size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
2171 if err != nil {
2172 return 0, err
2173 }
2174 i -= size
2175 i = encodeVarintGenerated(dAtA, i, uint64(size))
2176 }
2177 i--
2178 dAtA[i] = 0xa
2179 }
2180 return len(dAtA) - i, nil
2181 }
2182
2183 func (m *RollingUpdateStatefulSetStrategy) Marshal() (dAtA []byte, err error) {
2184 size := m.Size()
2185 dAtA = make([]byte, size)
2186 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2187 if err != nil {
2188 return nil, err
2189 }
2190 return dAtA[:n], nil
2191 }
2192
2193 func (m *RollingUpdateStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) {
2194 size := m.Size()
2195 return m.MarshalToSizedBuffer(dAtA[:size])
2196 }
2197
2198 func (m *RollingUpdateStatefulSetStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2199 i := len(dAtA)
2200 _ = i
2201 var l int
2202 _ = l
2203 if m.MaxUnavailable != nil {
2204 {
2205 size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
2206 if err != nil {
2207 return 0, err
2208 }
2209 i -= size
2210 i = encodeVarintGenerated(dAtA, i, uint64(size))
2211 }
2212 i--
2213 dAtA[i] = 0x12
2214 }
2215 if m.Partition != nil {
2216 i = encodeVarintGenerated(dAtA, i, uint64(*m.Partition))
2217 i--
2218 dAtA[i] = 0x8
2219 }
2220 return len(dAtA) - i, nil
2221 }
2222
2223 func (m *StatefulSet) Marshal() (dAtA []byte, err error) {
2224 size := m.Size()
2225 dAtA = make([]byte, size)
2226 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2227 if err != nil {
2228 return nil, err
2229 }
2230 return dAtA[:n], nil
2231 }
2232
2233 func (m *StatefulSet) MarshalTo(dAtA []byte) (int, error) {
2234 size := m.Size()
2235 return m.MarshalToSizedBuffer(dAtA[:size])
2236 }
2237
2238 func (m *StatefulSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2239 i := len(dAtA)
2240 _ = i
2241 var l int
2242 _ = l
2243 {
2244 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
2245 if err != nil {
2246 return 0, err
2247 }
2248 i -= size
2249 i = encodeVarintGenerated(dAtA, i, uint64(size))
2250 }
2251 i--
2252 dAtA[i] = 0x1a
2253 {
2254 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
2255 if err != nil {
2256 return 0, err
2257 }
2258 i -= size
2259 i = encodeVarintGenerated(dAtA, i, uint64(size))
2260 }
2261 i--
2262 dAtA[i] = 0x12
2263 {
2264 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
2265 if err != nil {
2266 return 0, err
2267 }
2268 i -= size
2269 i = encodeVarintGenerated(dAtA, i, uint64(size))
2270 }
2271 i--
2272 dAtA[i] = 0xa
2273 return len(dAtA) - i, nil
2274 }
2275
2276 func (m *StatefulSetCondition) Marshal() (dAtA []byte, err error) {
2277 size := m.Size()
2278 dAtA = make([]byte, size)
2279 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2280 if err != nil {
2281 return nil, err
2282 }
2283 return dAtA[:n], nil
2284 }
2285
2286 func (m *StatefulSetCondition) MarshalTo(dAtA []byte) (int, error) {
2287 size := m.Size()
2288 return m.MarshalToSizedBuffer(dAtA[:size])
2289 }
2290
2291 func (m *StatefulSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2292 i := len(dAtA)
2293 _ = i
2294 var l int
2295 _ = l
2296 i -= len(m.Message)
2297 copy(dAtA[i:], m.Message)
2298 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
2299 i--
2300 dAtA[i] = 0x2a
2301 i -= len(m.Reason)
2302 copy(dAtA[i:], m.Reason)
2303 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
2304 i--
2305 dAtA[i] = 0x22
2306 {
2307 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
2308 if err != nil {
2309 return 0, err
2310 }
2311 i -= size
2312 i = encodeVarintGenerated(dAtA, i, uint64(size))
2313 }
2314 i--
2315 dAtA[i] = 0x1a
2316 i -= len(m.Status)
2317 copy(dAtA[i:], m.Status)
2318 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
2319 i--
2320 dAtA[i] = 0x12
2321 i -= len(m.Type)
2322 copy(dAtA[i:], m.Type)
2323 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2324 i--
2325 dAtA[i] = 0xa
2326 return len(dAtA) - i, nil
2327 }
2328
2329 func (m *StatefulSetList) Marshal() (dAtA []byte, err error) {
2330 size := m.Size()
2331 dAtA = make([]byte, size)
2332 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2333 if err != nil {
2334 return nil, err
2335 }
2336 return dAtA[:n], nil
2337 }
2338
2339 func (m *StatefulSetList) MarshalTo(dAtA []byte) (int, error) {
2340 size := m.Size()
2341 return m.MarshalToSizedBuffer(dAtA[:size])
2342 }
2343
2344 func (m *StatefulSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2345 i := len(dAtA)
2346 _ = i
2347 var l int
2348 _ = l
2349 if len(m.Items) > 0 {
2350 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
2351 {
2352 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2353 if err != nil {
2354 return 0, err
2355 }
2356 i -= size
2357 i = encodeVarintGenerated(dAtA, i, uint64(size))
2358 }
2359 i--
2360 dAtA[i] = 0x12
2361 }
2362 }
2363 {
2364 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
2365 if err != nil {
2366 return 0, err
2367 }
2368 i -= size
2369 i = encodeVarintGenerated(dAtA, i, uint64(size))
2370 }
2371 i--
2372 dAtA[i] = 0xa
2373 return len(dAtA) - i, nil
2374 }
2375
2376 func (m *StatefulSetOrdinals) Marshal() (dAtA []byte, err error) {
2377 size := m.Size()
2378 dAtA = make([]byte, size)
2379 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2380 if err != nil {
2381 return nil, err
2382 }
2383 return dAtA[:n], nil
2384 }
2385
2386 func (m *StatefulSetOrdinals) MarshalTo(dAtA []byte) (int, error) {
2387 size := m.Size()
2388 return m.MarshalToSizedBuffer(dAtA[:size])
2389 }
2390
2391 func (m *StatefulSetOrdinals) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2392 i := len(dAtA)
2393 _ = i
2394 var l int
2395 _ = l
2396 i = encodeVarintGenerated(dAtA, i, uint64(m.Start))
2397 i--
2398 dAtA[i] = 0x8
2399 return len(dAtA) - i, nil
2400 }
2401
2402 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Marshal() (dAtA []byte, err error) {
2403 size := m.Size()
2404 dAtA = make([]byte, size)
2405 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2406 if err != nil {
2407 return nil, err
2408 }
2409 return dAtA[:n], nil
2410 }
2411
2412 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalTo(dAtA []byte) (int, error) {
2413 size := m.Size()
2414 return m.MarshalToSizedBuffer(dAtA[:size])
2415 }
2416
2417 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2418 i := len(dAtA)
2419 _ = i
2420 var l int
2421 _ = l
2422 i -= len(m.WhenScaled)
2423 copy(dAtA[i:], m.WhenScaled)
2424 i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenScaled)))
2425 i--
2426 dAtA[i] = 0x12
2427 i -= len(m.WhenDeleted)
2428 copy(dAtA[i:], m.WhenDeleted)
2429 i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenDeleted)))
2430 i--
2431 dAtA[i] = 0xa
2432 return len(dAtA) - i, nil
2433 }
2434
2435 func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) {
2436 size := m.Size()
2437 dAtA = make([]byte, size)
2438 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2439 if err != nil {
2440 return nil, err
2441 }
2442 return dAtA[:n], nil
2443 }
2444
2445 func (m *StatefulSetSpec) MarshalTo(dAtA []byte) (int, error) {
2446 size := m.Size()
2447 return m.MarshalToSizedBuffer(dAtA[:size])
2448 }
2449
2450 func (m *StatefulSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2451 i := len(dAtA)
2452 _ = i
2453 var l int
2454 _ = l
2455 if m.Ordinals != nil {
2456 {
2457 size, err := m.Ordinals.MarshalToSizedBuffer(dAtA[:i])
2458 if err != nil {
2459 return 0, err
2460 }
2461 i -= size
2462 i = encodeVarintGenerated(dAtA, i, uint64(size))
2463 }
2464 i--
2465 dAtA[i] = 0x5a
2466 }
2467 if m.PersistentVolumeClaimRetentionPolicy != nil {
2468 {
2469 size, err := m.PersistentVolumeClaimRetentionPolicy.MarshalToSizedBuffer(dAtA[:i])
2470 if err != nil {
2471 return 0, err
2472 }
2473 i -= size
2474 i = encodeVarintGenerated(dAtA, i, uint64(size))
2475 }
2476 i--
2477 dAtA[i] = 0x52
2478 }
2479 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
2480 i--
2481 dAtA[i] = 0x48
2482 if m.RevisionHistoryLimit != nil {
2483 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
2484 i--
2485 dAtA[i] = 0x40
2486 }
2487 {
2488 size, err := m.UpdateStrategy.MarshalToSizedBuffer(dAtA[:i])
2489 if err != nil {
2490 return 0, err
2491 }
2492 i -= size
2493 i = encodeVarintGenerated(dAtA, i, uint64(size))
2494 }
2495 i--
2496 dAtA[i] = 0x3a
2497 i -= len(m.PodManagementPolicy)
2498 copy(dAtA[i:], m.PodManagementPolicy)
2499 i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodManagementPolicy)))
2500 i--
2501 dAtA[i] = 0x32
2502 i -= len(m.ServiceName)
2503 copy(dAtA[i:], m.ServiceName)
2504 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
2505 i--
2506 dAtA[i] = 0x2a
2507 if len(m.VolumeClaimTemplates) > 0 {
2508 for iNdEx := len(m.VolumeClaimTemplates) - 1; iNdEx >= 0; iNdEx-- {
2509 {
2510 size, err := m.VolumeClaimTemplates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2511 if err != nil {
2512 return 0, err
2513 }
2514 i -= size
2515 i = encodeVarintGenerated(dAtA, i, uint64(size))
2516 }
2517 i--
2518 dAtA[i] = 0x22
2519 }
2520 }
2521 {
2522 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
2523 if err != nil {
2524 return 0, err
2525 }
2526 i -= size
2527 i = encodeVarintGenerated(dAtA, i, uint64(size))
2528 }
2529 i--
2530 dAtA[i] = 0x1a
2531 if m.Selector != nil {
2532 {
2533 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
2534 if err != nil {
2535 return 0, err
2536 }
2537 i -= size
2538 i = encodeVarintGenerated(dAtA, i, uint64(size))
2539 }
2540 i--
2541 dAtA[i] = 0x12
2542 }
2543 if m.Replicas != nil {
2544 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
2545 i--
2546 dAtA[i] = 0x8
2547 }
2548 return len(dAtA) - i, nil
2549 }
2550
2551 func (m *StatefulSetStatus) Marshal() (dAtA []byte, err error) {
2552 size := m.Size()
2553 dAtA = make([]byte, size)
2554 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2555 if err != nil {
2556 return nil, err
2557 }
2558 return dAtA[:n], nil
2559 }
2560
2561 func (m *StatefulSetStatus) MarshalTo(dAtA []byte) (int, error) {
2562 size := m.Size()
2563 return m.MarshalToSizedBuffer(dAtA[:size])
2564 }
2565
2566 func (m *StatefulSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2567 i := len(dAtA)
2568 _ = i
2569 var l int
2570 _ = l
2571 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
2572 i--
2573 dAtA[i] = 0x58
2574 if len(m.Conditions) > 0 {
2575 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
2576 {
2577 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2578 if err != nil {
2579 return 0, err
2580 }
2581 i -= size
2582 i = encodeVarintGenerated(dAtA, i, uint64(size))
2583 }
2584 i--
2585 dAtA[i] = 0x52
2586 }
2587 }
2588 if m.CollisionCount != nil {
2589 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
2590 i--
2591 dAtA[i] = 0x48
2592 }
2593 i -= len(m.UpdateRevision)
2594 copy(dAtA[i:], m.UpdateRevision)
2595 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UpdateRevision)))
2596 i--
2597 dAtA[i] = 0x3a
2598 i -= len(m.CurrentRevision)
2599 copy(dAtA[i:], m.CurrentRevision)
2600 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentRevision)))
2601 i--
2602 dAtA[i] = 0x32
2603 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
2604 i--
2605 dAtA[i] = 0x28
2606 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas))
2607 i--
2608 dAtA[i] = 0x20
2609 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
2610 i--
2611 dAtA[i] = 0x18
2612 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2613 i--
2614 dAtA[i] = 0x10
2615 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
2616 i--
2617 dAtA[i] = 0x8
2618 return len(dAtA) - i, nil
2619 }
2620
2621 func (m *StatefulSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
2622 size := m.Size()
2623 dAtA = make([]byte, size)
2624 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2625 if err != nil {
2626 return nil, err
2627 }
2628 return dAtA[:n], nil
2629 }
2630
2631 func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
2632 size := m.Size()
2633 return m.MarshalToSizedBuffer(dAtA[:size])
2634 }
2635
2636 func (m *StatefulSetUpdateStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2637 i := len(dAtA)
2638 _ = i
2639 var l int
2640 _ = l
2641 if m.RollingUpdate != nil {
2642 {
2643 size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
2644 if err != nil {
2645 return 0, err
2646 }
2647 i -= size
2648 i = encodeVarintGenerated(dAtA, i, uint64(size))
2649 }
2650 i--
2651 dAtA[i] = 0x12
2652 }
2653 i -= len(m.Type)
2654 copy(dAtA[i:], m.Type)
2655 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2656 i--
2657 dAtA[i] = 0xa
2658 return len(dAtA) - i, nil
2659 }
2660
2661 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
2662 offset -= sovGenerated(v)
2663 base := offset
2664 for v >= 1<<7 {
2665 dAtA[offset] = uint8(v&0x7f | 0x80)
2666 v >>= 7
2667 offset++
2668 }
2669 dAtA[offset] = uint8(v)
2670 return base
2671 }
2672 func (m *ControllerRevision) Size() (n int) {
2673 if m == nil {
2674 return 0
2675 }
2676 var l int
2677 _ = l
2678 l = m.ObjectMeta.Size()
2679 n += 1 + l + sovGenerated(uint64(l))
2680 l = m.Data.Size()
2681 n += 1 + l + sovGenerated(uint64(l))
2682 n += 1 + sovGenerated(uint64(m.Revision))
2683 return n
2684 }
2685
2686 func (m *ControllerRevisionList) Size() (n int) {
2687 if m == nil {
2688 return 0
2689 }
2690 var l int
2691 _ = l
2692 l = m.ListMeta.Size()
2693 n += 1 + l + sovGenerated(uint64(l))
2694 if len(m.Items) > 0 {
2695 for _, e := range m.Items {
2696 l = e.Size()
2697 n += 1 + l + sovGenerated(uint64(l))
2698 }
2699 }
2700 return n
2701 }
2702
2703 func (m *DaemonSet) Size() (n int) {
2704 if m == nil {
2705 return 0
2706 }
2707 var l int
2708 _ = l
2709 l = m.ObjectMeta.Size()
2710 n += 1 + l + sovGenerated(uint64(l))
2711 l = m.Spec.Size()
2712 n += 1 + l + sovGenerated(uint64(l))
2713 l = m.Status.Size()
2714 n += 1 + l + sovGenerated(uint64(l))
2715 return n
2716 }
2717
2718 func (m *DaemonSetCondition) Size() (n int) {
2719 if m == nil {
2720 return 0
2721 }
2722 var l int
2723 _ = l
2724 l = len(m.Type)
2725 n += 1 + l + sovGenerated(uint64(l))
2726 l = len(m.Status)
2727 n += 1 + l + sovGenerated(uint64(l))
2728 l = m.LastTransitionTime.Size()
2729 n += 1 + l + sovGenerated(uint64(l))
2730 l = len(m.Reason)
2731 n += 1 + l + sovGenerated(uint64(l))
2732 l = len(m.Message)
2733 n += 1 + l + sovGenerated(uint64(l))
2734 return n
2735 }
2736
2737 func (m *DaemonSetList) Size() (n int) {
2738 if m == nil {
2739 return 0
2740 }
2741 var l int
2742 _ = l
2743 l = m.ListMeta.Size()
2744 n += 1 + l + sovGenerated(uint64(l))
2745 if len(m.Items) > 0 {
2746 for _, e := range m.Items {
2747 l = e.Size()
2748 n += 1 + l + sovGenerated(uint64(l))
2749 }
2750 }
2751 return n
2752 }
2753
2754 func (m *DaemonSetSpec) Size() (n int) {
2755 if m == nil {
2756 return 0
2757 }
2758 var l int
2759 _ = l
2760 if m.Selector != nil {
2761 l = m.Selector.Size()
2762 n += 1 + l + sovGenerated(uint64(l))
2763 }
2764 l = m.Template.Size()
2765 n += 1 + l + sovGenerated(uint64(l))
2766 l = m.UpdateStrategy.Size()
2767 n += 1 + l + sovGenerated(uint64(l))
2768 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2769 if m.RevisionHistoryLimit != nil {
2770 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2771 }
2772 return n
2773 }
2774
2775 func (m *DaemonSetStatus) Size() (n int) {
2776 if m == nil {
2777 return 0
2778 }
2779 var l int
2780 _ = l
2781 n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
2782 n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
2783 n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
2784 n += 1 + sovGenerated(uint64(m.NumberReady))
2785 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2786 n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled))
2787 n += 1 + sovGenerated(uint64(m.NumberAvailable))
2788 n += 1 + sovGenerated(uint64(m.NumberUnavailable))
2789 if m.CollisionCount != nil {
2790 n += 1 + sovGenerated(uint64(*m.CollisionCount))
2791 }
2792 if len(m.Conditions) > 0 {
2793 for _, e := range m.Conditions {
2794 l = e.Size()
2795 n += 1 + l + sovGenerated(uint64(l))
2796 }
2797 }
2798 return n
2799 }
2800
2801 func (m *DaemonSetUpdateStrategy) Size() (n int) {
2802 if m == nil {
2803 return 0
2804 }
2805 var l int
2806 _ = l
2807 l = len(m.Type)
2808 n += 1 + l + sovGenerated(uint64(l))
2809 if m.RollingUpdate != nil {
2810 l = m.RollingUpdate.Size()
2811 n += 1 + l + sovGenerated(uint64(l))
2812 }
2813 return n
2814 }
2815
2816 func (m *Deployment) Size() (n int) {
2817 if m == nil {
2818 return 0
2819 }
2820 var l int
2821 _ = l
2822 l = m.ObjectMeta.Size()
2823 n += 1 + l + sovGenerated(uint64(l))
2824 l = m.Spec.Size()
2825 n += 1 + l + sovGenerated(uint64(l))
2826 l = m.Status.Size()
2827 n += 1 + l + sovGenerated(uint64(l))
2828 return n
2829 }
2830
2831 func (m *DeploymentCondition) Size() (n int) {
2832 if m == nil {
2833 return 0
2834 }
2835 var l int
2836 _ = l
2837 l = len(m.Type)
2838 n += 1 + l + sovGenerated(uint64(l))
2839 l = len(m.Status)
2840 n += 1 + l + sovGenerated(uint64(l))
2841 l = len(m.Reason)
2842 n += 1 + l + sovGenerated(uint64(l))
2843 l = len(m.Message)
2844 n += 1 + l + sovGenerated(uint64(l))
2845 l = m.LastUpdateTime.Size()
2846 n += 1 + l + sovGenerated(uint64(l))
2847 l = m.LastTransitionTime.Size()
2848 n += 1 + l + sovGenerated(uint64(l))
2849 return n
2850 }
2851
2852 func (m *DeploymentList) Size() (n int) {
2853 if m == nil {
2854 return 0
2855 }
2856 var l int
2857 _ = l
2858 l = m.ListMeta.Size()
2859 n += 1 + l + sovGenerated(uint64(l))
2860 if len(m.Items) > 0 {
2861 for _, e := range m.Items {
2862 l = e.Size()
2863 n += 1 + l + sovGenerated(uint64(l))
2864 }
2865 }
2866 return n
2867 }
2868
2869 func (m *DeploymentSpec) Size() (n int) {
2870 if m == nil {
2871 return 0
2872 }
2873 var l int
2874 _ = l
2875 if m.Replicas != nil {
2876 n += 1 + sovGenerated(uint64(*m.Replicas))
2877 }
2878 if m.Selector != nil {
2879 l = m.Selector.Size()
2880 n += 1 + l + sovGenerated(uint64(l))
2881 }
2882 l = m.Template.Size()
2883 n += 1 + l + sovGenerated(uint64(l))
2884 l = m.Strategy.Size()
2885 n += 1 + l + sovGenerated(uint64(l))
2886 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2887 if m.RevisionHistoryLimit != nil {
2888 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2889 }
2890 n += 2
2891 if m.ProgressDeadlineSeconds != nil {
2892 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
2893 }
2894 return n
2895 }
2896
2897 func (m *DeploymentStatus) Size() (n int) {
2898 if m == nil {
2899 return 0
2900 }
2901 var l int
2902 _ = l
2903 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2904 n += 1 + sovGenerated(uint64(m.Replicas))
2905 n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
2906 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
2907 n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
2908 if len(m.Conditions) > 0 {
2909 for _, e := range m.Conditions {
2910 l = e.Size()
2911 n += 1 + l + sovGenerated(uint64(l))
2912 }
2913 }
2914 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
2915 if m.CollisionCount != nil {
2916 n += 1 + sovGenerated(uint64(*m.CollisionCount))
2917 }
2918 return n
2919 }
2920
2921 func (m *DeploymentStrategy) Size() (n int) {
2922 if m == nil {
2923 return 0
2924 }
2925 var l int
2926 _ = l
2927 l = len(m.Type)
2928 n += 1 + l + sovGenerated(uint64(l))
2929 if m.RollingUpdate != nil {
2930 l = m.RollingUpdate.Size()
2931 n += 1 + l + sovGenerated(uint64(l))
2932 }
2933 return n
2934 }
2935
2936 func (m *ReplicaSet) Size() (n int) {
2937 if m == nil {
2938 return 0
2939 }
2940 var l int
2941 _ = l
2942 l = m.ObjectMeta.Size()
2943 n += 1 + l + sovGenerated(uint64(l))
2944 l = m.Spec.Size()
2945 n += 1 + l + sovGenerated(uint64(l))
2946 l = m.Status.Size()
2947 n += 1 + l + sovGenerated(uint64(l))
2948 return n
2949 }
2950
2951 func (m *ReplicaSetCondition) Size() (n int) {
2952 if m == nil {
2953 return 0
2954 }
2955 var l int
2956 _ = l
2957 l = len(m.Type)
2958 n += 1 + l + sovGenerated(uint64(l))
2959 l = len(m.Status)
2960 n += 1 + l + sovGenerated(uint64(l))
2961 l = m.LastTransitionTime.Size()
2962 n += 1 + l + sovGenerated(uint64(l))
2963 l = len(m.Reason)
2964 n += 1 + l + sovGenerated(uint64(l))
2965 l = len(m.Message)
2966 n += 1 + l + sovGenerated(uint64(l))
2967 return n
2968 }
2969
2970 func (m *ReplicaSetList) Size() (n int) {
2971 if m == nil {
2972 return 0
2973 }
2974 var l int
2975 _ = l
2976 l = m.ListMeta.Size()
2977 n += 1 + l + sovGenerated(uint64(l))
2978 if len(m.Items) > 0 {
2979 for _, e := range m.Items {
2980 l = e.Size()
2981 n += 1 + l + sovGenerated(uint64(l))
2982 }
2983 }
2984 return n
2985 }
2986
2987 func (m *ReplicaSetSpec) Size() (n int) {
2988 if m == nil {
2989 return 0
2990 }
2991 var l int
2992 _ = l
2993 if m.Replicas != nil {
2994 n += 1 + sovGenerated(uint64(*m.Replicas))
2995 }
2996 if m.Selector != nil {
2997 l = m.Selector.Size()
2998 n += 1 + l + sovGenerated(uint64(l))
2999 }
3000 l = m.Template.Size()
3001 n += 1 + l + sovGenerated(uint64(l))
3002 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
3003 return n
3004 }
3005
3006 func (m *ReplicaSetStatus) Size() (n int) {
3007 if m == nil {
3008 return 0
3009 }
3010 var l int
3011 _ = l
3012 n += 1 + sovGenerated(uint64(m.Replicas))
3013 n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
3014 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3015 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3016 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3017 if len(m.Conditions) > 0 {
3018 for _, e := range m.Conditions {
3019 l = e.Size()
3020 n += 1 + l + sovGenerated(uint64(l))
3021 }
3022 }
3023 return n
3024 }
3025
3026 func (m *RollingUpdateDaemonSet) Size() (n int) {
3027 if m == nil {
3028 return 0
3029 }
3030 var l int
3031 _ = l
3032 if m.MaxUnavailable != nil {
3033 l = m.MaxUnavailable.Size()
3034 n += 1 + l + sovGenerated(uint64(l))
3035 }
3036 if m.MaxSurge != nil {
3037 l = m.MaxSurge.Size()
3038 n += 1 + l + sovGenerated(uint64(l))
3039 }
3040 return n
3041 }
3042
3043 func (m *RollingUpdateDeployment) Size() (n int) {
3044 if m == nil {
3045 return 0
3046 }
3047 var l int
3048 _ = l
3049 if m.MaxUnavailable != nil {
3050 l = m.MaxUnavailable.Size()
3051 n += 1 + l + sovGenerated(uint64(l))
3052 }
3053 if m.MaxSurge != nil {
3054 l = m.MaxSurge.Size()
3055 n += 1 + l + sovGenerated(uint64(l))
3056 }
3057 return n
3058 }
3059
3060 func (m *RollingUpdateStatefulSetStrategy) Size() (n int) {
3061 if m == nil {
3062 return 0
3063 }
3064 var l int
3065 _ = l
3066 if m.Partition != nil {
3067 n += 1 + sovGenerated(uint64(*m.Partition))
3068 }
3069 if m.MaxUnavailable != nil {
3070 l = m.MaxUnavailable.Size()
3071 n += 1 + l + sovGenerated(uint64(l))
3072 }
3073 return n
3074 }
3075
3076 func (m *StatefulSet) Size() (n int) {
3077 if m == nil {
3078 return 0
3079 }
3080 var l int
3081 _ = l
3082 l = m.ObjectMeta.Size()
3083 n += 1 + l + sovGenerated(uint64(l))
3084 l = m.Spec.Size()
3085 n += 1 + l + sovGenerated(uint64(l))
3086 l = m.Status.Size()
3087 n += 1 + l + sovGenerated(uint64(l))
3088 return n
3089 }
3090
3091 func (m *StatefulSetCondition) Size() (n int) {
3092 if m == nil {
3093 return 0
3094 }
3095 var l int
3096 _ = l
3097 l = len(m.Type)
3098 n += 1 + l + sovGenerated(uint64(l))
3099 l = len(m.Status)
3100 n += 1 + l + sovGenerated(uint64(l))
3101 l = m.LastTransitionTime.Size()
3102 n += 1 + l + sovGenerated(uint64(l))
3103 l = len(m.Reason)
3104 n += 1 + l + sovGenerated(uint64(l))
3105 l = len(m.Message)
3106 n += 1 + l + sovGenerated(uint64(l))
3107 return n
3108 }
3109
3110 func (m *StatefulSetList) Size() (n int) {
3111 if m == nil {
3112 return 0
3113 }
3114 var l int
3115 _ = l
3116 l = m.ListMeta.Size()
3117 n += 1 + l + sovGenerated(uint64(l))
3118 if len(m.Items) > 0 {
3119 for _, e := range m.Items {
3120 l = e.Size()
3121 n += 1 + l + sovGenerated(uint64(l))
3122 }
3123 }
3124 return n
3125 }
3126
3127 func (m *StatefulSetOrdinals) Size() (n int) {
3128 if m == nil {
3129 return 0
3130 }
3131 var l int
3132 _ = l
3133 n += 1 + sovGenerated(uint64(m.Start))
3134 return n
3135 }
3136
3137 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Size() (n int) {
3138 if m == nil {
3139 return 0
3140 }
3141 var l int
3142 _ = l
3143 l = len(m.WhenDeleted)
3144 n += 1 + l + sovGenerated(uint64(l))
3145 l = len(m.WhenScaled)
3146 n += 1 + l + sovGenerated(uint64(l))
3147 return n
3148 }
3149
3150 func (m *StatefulSetSpec) Size() (n int) {
3151 if m == nil {
3152 return 0
3153 }
3154 var l int
3155 _ = l
3156 if m.Replicas != nil {
3157 n += 1 + sovGenerated(uint64(*m.Replicas))
3158 }
3159 if m.Selector != nil {
3160 l = m.Selector.Size()
3161 n += 1 + l + sovGenerated(uint64(l))
3162 }
3163 l = m.Template.Size()
3164 n += 1 + l + sovGenerated(uint64(l))
3165 if len(m.VolumeClaimTemplates) > 0 {
3166 for _, e := range m.VolumeClaimTemplates {
3167 l = e.Size()
3168 n += 1 + l + sovGenerated(uint64(l))
3169 }
3170 }
3171 l = len(m.ServiceName)
3172 n += 1 + l + sovGenerated(uint64(l))
3173 l = len(m.PodManagementPolicy)
3174 n += 1 + l + sovGenerated(uint64(l))
3175 l = m.UpdateStrategy.Size()
3176 n += 1 + l + sovGenerated(uint64(l))
3177 if m.RevisionHistoryLimit != nil {
3178 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
3179 }
3180 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
3181 if m.PersistentVolumeClaimRetentionPolicy != nil {
3182 l = m.PersistentVolumeClaimRetentionPolicy.Size()
3183 n += 1 + l + sovGenerated(uint64(l))
3184 }
3185 if m.Ordinals != nil {
3186 l = m.Ordinals.Size()
3187 n += 1 + l + sovGenerated(uint64(l))
3188 }
3189 return n
3190 }
3191
3192 func (m *StatefulSetStatus) Size() (n int) {
3193 if m == nil {
3194 return 0
3195 }
3196 var l int
3197 _ = l
3198 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3199 n += 1 + sovGenerated(uint64(m.Replicas))
3200 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3201 n += 1 + sovGenerated(uint64(m.CurrentReplicas))
3202 n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
3203 l = len(m.CurrentRevision)
3204 n += 1 + l + sovGenerated(uint64(l))
3205 l = len(m.UpdateRevision)
3206 n += 1 + l + sovGenerated(uint64(l))
3207 if m.CollisionCount != nil {
3208 n += 1 + sovGenerated(uint64(*m.CollisionCount))
3209 }
3210 if len(m.Conditions) > 0 {
3211 for _, e := range m.Conditions {
3212 l = e.Size()
3213 n += 1 + l + sovGenerated(uint64(l))
3214 }
3215 }
3216 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3217 return n
3218 }
3219
3220 func (m *StatefulSetUpdateStrategy) Size() (n int) {
3221 if m == nil {
3222 return 0
3223 }
3224 var l int
3225 _ = l
3226 l = len(m.Type)
3227 n += 1 + l + sovGenerated(uint64(l))
3228 if m.RollingUpdate != nil {
3229 l = m.RollingUpdate.Size()
3230 n += 1 + l + sovGenerated(uint64(l))
3231 }
3232 return n
3233 }
3234
3235 func sovGenerated(x uint64) (n int) {
3236 return (math_bits.Len64(x|1) + 6) / 7
3237 }
3238 func sozGenerated(x uint64) (n int) {
3239 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3240 }
3241 func (this *ControllerRevision) String() string {
3242 if this == nil {
3243 return "nil"
3244 }
3245 s := strings.Join([]string{`&ControllerRevision{`,
3246 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3247 `Data:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Data), "RawExtension", "runtime.RawExtension", 1), `&`, ``, 1) + `,`,
3248 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
3249 `}`,
3250 }, "")
3251 return s
3252 }
3253 func (this *ControllerRevisionList) String() string {
3254 if this == nil {
3255 return "nil"
3256 }
3257 repeatedStringForItems := "[]ControllerRevision{"
3258 for _, f := range this.Items {
3259 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ControllerRevision", "ControllerRevision", 1), `&`, ``, 1) + ","
3260 }
3261 repeatedStringForItems += "}"
3262 s := strings.Join([]string{`&ControllerRevisionList{`,
3263 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
3264 `Items:` + repeatedStringForItems + `,`,
3265 `}`,
3266 }, "")
3267 return s
3268 }
3269 func (this *DaemonSet) String() string {
3270 if this == nil {
3271 return "nil"
3272 }
3273 s := strings.Join([]string{`&DaemonSet{`,
3274 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3275 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`,
3276 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`,
3277 `}`,
3278 }, "")
3279 return s
3280 }
3281 func (this *DaemonSetCondition) String() string {
3282 if this == nil {
3283 return "nil"
3284 }
3285 s := strings.Join([]string{`&DaemonSetCondition{`,
3286 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3287 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3288 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
3289 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3290 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3291 `}`,
3292 }, "")
3293 return s
3294 }
3295 func (this *DaemonSetList) String() string {
3296 if this == nil {
3297 return "nil"
3298 }
3299 repeatedStringForItems := "[]DaemonSet{"
3300 for _, f := range this.Items {
3301 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + ","
3302 }
3303 repeatedStringForItems += "}"
3304 s := strings.Join([]string{`&DaemonSetList{`,
3305 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
3306 `Items:` + repeatedStringForItems + `,`,
3307 `}`,
3308 }, "")
3309 return s
3310 }
3311 func (this *DaemonSetSpec) String() string {
3312 if this == nil {
3313 return "nil"
3314 }
3315 s := strings.Join([]string{`&DaemonSetSpec{`,
3316 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
3317 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3318 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
3319 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3320 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3321 `}`,
3322 }, "")
3323 return s
3324 }
3325 func (this *DaemonSetStatus) String() string {
3326 if this == nil {
3327 return "nil"
3328 }
3329 repeatedStringForConditions := "[]DaemonSetCondition{"
3330 for _, f := range this.Conditions {
3331 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + ","
3332 }
3333 repeatedStringForConditions += "}"
3334 s := strings.Join([]string{`&DaemonSetStatus{`,
3335 `CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`,
3336 `NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`,
3337 `DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`,
3338 `NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`,
3339 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3340 `UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`,
3341 `NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`,
3342 `NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`,
3343 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3344 `Conditions:` + repeatedStringForConditions + `,`,
3345 `}`,
3346 }, "")
3347 return s
3348 }
3349 func (this *DaemonSetUpdateStrategy) String() string {
3350 if this == nil {
3351 return "nil"
3352 }
3353 s := strings.Join([]string{`&DaemonSetUpdateStrategy{`,
3354 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3355 `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`,
3356 `}`,
3357 }, "")
3358 return s
3359 }
3360 func (this *Deployment) String() string {
3361 if this == nil {
3362 return "nil"
3363 }
3364 s := strings.Join([]string{`&Deployment{`,
3365 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3366 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
3367 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
3368 `}`,
3369 }, "")
3370 return s
3371 }
3372 func (this *DeploymentCondition) String() string {
3373 if this == nil {
3374 return "nil"
3375 }
3376 s := strings.Join([]string{`&DeploymentCondition{`,
3377 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3378 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3379 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3380 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3381 `LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
3382 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
3383 `}`,
3384 }, "")
3385 return s
3386 }
3387 func (this *DeploymentList) String() string {
3388 if this == nil {
3389 return "nil"
3390 }
3391 repeatedStringForItems := "[]Deployment{"
3392 for _, f := range this.Items {
3393 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Deployment", "Deployment", 1), `&`, ``, 1) + ","
3394 }
3395 repeatedStringForItems += "}"
3396 s := strings.Join([]string{`&DeploymentList{`,
3397 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
3398 `Items:` + repeatedStringForItems + `,`,
3399 `}`,
3400 }, "")
3401 return s
3402 }
3403 func (this *DeploymentSpec) String() string {
3404 if this == nil {
3405 return "nil"
3406 }
3407 s := strings.Join([]string{`&DeploymentSpec{`,
3408 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
3409 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
3410 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3411 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
3412 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3413 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3414 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
3415 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
3416 `}`,
3417 }, "")
3418 return s
3419 }
3420 func (this *DeploymentStatus) String() string {
3421 if this == nil {
3422 return "nil"
3423 }
3424 repeatedStringForConditions := "[]DeploymentCondition{"
3425 for _, f := range this.Conditions {
3426 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + ","
3427 }
3428 repeatedStringForConditions += "}"
3429 s := strings.Join([]string{`&DeploymentStatus{`,
3430 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3431 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
3432 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
3433 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
3434 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
3435 `Conditions:` + repeatedStringForConditions + `,`,
3436 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
3437 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3438 `}`,
3439 }, "")
3440 return s
3441 }
3442 func (this *DeploymentStrategy) String() string {
3443 if this == nil {
3444 return "nil"
3445 }
3446 s := strings.Join([]string{`&DeploymentStrategy{`,
3447 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3448 `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
3449 `}`,
3450 }, "")
3451 return s
3452 }
3453 func (this *ReplicaSet) String() string {
3454 if this == nil {
3455 return "nil"
3456 }
3457 s := strings.Join([]string{`&ReplicaSet{`,
3458 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3459 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
3460 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
3461 `}`,
3462 }, "")
3463 return s
3464 }
3465 func (this *ReplicaSetCondition) String() string {
3466 if this == nil {
3467 return "nil"
3468 }
3469 s := strings.Join([]string{`&ReplicaSetCondition{`,
3470 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3471 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3472 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
3473 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3474 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3475 `}`,
3476 }, "")
3477 return s
3478 }
3479 func (this *ReplicaSetList) String() string {
3480 if this == nil {
3481 return "nil"
3482 }
3483 repeatedStringForItems := "[]ReplicaSet{"
3484 for _, f := range this.Items {
3485 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + ","
3486 }
3487 repeatedStringForItems += "}"
3488 s := strings.Join([]string{`&ReplicaSetList{`,
3489 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
3490 `Items:` + repeatedStringForItems + `,`,
3491 `}`,
3492 }, "")
3493 return s
3494 }
3495 func (this *ReplicaSetSpec) String() string {
3496 if this == nil {
3497 return "nil"
3498 }
3499 s := strings.Join([]string{`&ReplicaSetSpec{`,
3500 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
3501 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
3502 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3503 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3504 `}`,
3505 }, "")
3506 return s
3507 }
3508 func (this *ReplicaSetStatus) String() string {
3509 if this == nil {
3510 return "nil"
3511 }
3512 repeatedStringForConditions := "[]ReplicaSetCondition{"
3513 for _, f := range this.Conditions {
3514 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + ","
3515 }
3516 repeatedStringForConditions += "}"
3517 s := strings.Join([]string{`&ReplicaSetStatus{`,
3518 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
3519 `FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
3520 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3521 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
3522 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
3523 `Conditions:` + repeatedStringForConditions + `,`,
3524 `}`,
3525 }, "")
3526 return s
3527 }
3528 func (this *RollingUpdateDaemonSet) String() string {
3529 if this == nil {
3530 return "nil"
3531 }
3532 s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
3533 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
3534 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
3535 `}`,
3536 }, "")
3537 return s
3538 }
3539 func (this *RollingUpdateDeployment) String() string {
3540 if this == nil {
3541 return "nil"
3542 }
3543 s := strings.Join([]string{`&RollingUpdateDeployment{`,
3544 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
3545 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
3546 `}`,
3547 }, "")
3548 return s
3549 }
3550 func (this *RollingUpdateStatefulSetStrategy) String() string {
3551 if this == nil {
3552 return "nil"
3553 }
3554 s := strings.Join([]string{`&RollingUpdateStatefulSetStrategy{`,
3555 `Partition:` + valueToStringGenerated(this.Partition) + `,`,
3556 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
3557 `}`,
3558 }, "")
3559 return s
3560 }
3561 func (this *StatefulSet) String() string {
3562 if this == nil {
3563 return "nil"
3564 }
3565 s := strings.Join([]string{`&StatefulSet{`,
3566 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3567 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "StatefulSetSpec", "StatefulSetSpec", 1), `&`, ``, 1) + `,`,
3568 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "StatefulSetStatus", "StatefulSetStatus", 1), `&`, ``, 1) + `,`,
3569 `}`,
3570 }, "")
3571 return s
3572 }
3573 func (this *StatefulSetCondition) String() string {
3574 if this == nil {
3575 return "nil"
3576 }
3577 s := strings.Join([]string{`&StatefulSetCondition{`,
3578 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3579 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3580 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
3581 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3582 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3583 `}`,
3584 }, "")
3585 return s
3586 }
3587 func (this *StatefulSetList) String() string {
3588 if this == nil {
3589 return "nil"
3590 }
3591 repeatedStringForItems := "[]StatefulSet{"
3592 for _, f := range this.Items {
3593 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "StatefulSet", "StatefulSet", 1), `&`, ``, 1) + ","
3594 }
3595 repeatedStringForItems += "}"
3596 s := strings.Join([]string{`&StatefulSetList{`,
3597 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
3598 `Items:` + repeatedStringForItems + `,`,
3599 `}`,
3600 }, "")
3601 return s
3602 }
3603 func (this *StatefulSetOrdinals) String() string {
3604 if this == nil {
3605 return "nil"
3606 }
3607 s := strings.Join([]string{`&StatefulSetOrdinals{`,
3608 `Start:` + fmt.Sprintf("%v", this.Start) + `,`,
3609 `}`,
3610 }, "")
3611 return s
3612 }
3613 func (this *StatefulSetPersistentVolumeClaimRetentionPolicy) String() string {
3614 if this == nil {
3615 return "nil"
3616 }
3617 s := strings.Join([]string{`&StatefulSetPersistentVolumeClaimRetentionPolicy{`,
3618 `WhenDeleted:` + fmt.Sprintf("%v", this.WhenDeleted) + `,`,
3619 `WhenScaled:` + fmt.Sprintf("%v", this.WhenScaled) + `,`,
3620 `}`,
3621 }, "")
3622 return s
3623 }
3624 func (this *StatefulSetSpec) String() string {
3625 if this == nil {
3626 return "nil"
3627 }
3628 repeatedStringForVolumeClaimTemplates := "[]PersistentVolumeClaim{"
3629 for _, f := range this.VolumeClaimTemplates {
3630 repeatedStringForVolumeClaimTemplates += fmt.Sprintf("%v", f) + ","
3631 }
3632 repeatedStringForVolumeClaimTemplates += "}"
3633 s := strings.Join([]string{`&StatefulSetSpec{`,
3634 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
3635 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
3636 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3637 `VolumeClaimTemplates:` + repeatedStringForVolumeClaimTemplates + `,`,
3638 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
3639 `PodManagementPolicy:` + fmt.Sprintf("%v", this.PodManagementPolicy) + `,`,
3640 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
3641 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3642 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3643 `PersistentVolumeClaimRetentionPolicy:` + strings.Replace(this.PersistentVolumeClaimRetentionPolicy.String(), "StatefulSetPersistentVolumeClaimRetentionPolicy", "StatefulSetPersistentVolumeClaimRetentionPolicy", 1) + `,`,
3644 `Ordinals:` + strings.Replace(this.Ordinals.String(), "StatefulSetOrdinals", "StatefulSetOrdinals", 1) + `,`,
3645 `}`,
3646 }, "")
3647 return s
3648 }
3649 func (this *StatefulSetStatus) String() string {
3650 if this == nil {
3651 return "nil"
3652 }
3653 repeatedStringForConditions := "[]StatefulSetCondition{"
3654 for _, f := range this.Conditions {
3655 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "StatefulSetCondition", "StatefulSetCondition", 1), `&`, ``, 1) + ","
3656 }
3657 repeatedStringForConditions += "}"
3658 s := strings.Join([]string{`&StatefulSetStatus{`,
3659 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3660 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
3661 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
3662 `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`,
3663 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
3664 `CurrentRevision:` + fmt.Sprintf("%v", this.CurrentRevision) + `,`,
3665 `UpdateRevision:` + fmt.Sprintf("%v", this.UpdateRevision) + `,`,
3666 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3667 `Conditions:` + repeatedStringForConditions + `,`,
3668 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
3669 `}`,
3670 }, "")
3671 return s
3672 }
3673 func (this *StatefulSetUpdateStrategy) String() string {
3674 if this == nil {
3675 return "nil"
3676 }
3677 s := strings.Join([]string{`&StatefulSetUpdateStrategy{`,
3678 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3679 `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateStatefulSetStrategy", "RollingUpdateStatefulSetStrategy", 1) + `,`,
3680 `}`,
3681 }, "")
3682 return s
3683 }
3684 func valueToStringGenerated(v interface{}) string {
3685 rv := reflect.ValueOf(v)
3686 if rv.IsNil() {
3687 return "nil"
3688 }
3689 pv := reflect.Indirect(rv).Interface()
3690 return fmt.Sprintf("*%v", pv)
3691 }
3692 func (m *ControllerRevision) Unmarshal(dAtA []byte) error {
3693 l := len(dAtA)
3694 iNdEx := 0
3695 for iNdEx < l {
3696 preIndex := iNdEx
3697 var wire uint64
3698 for shift := uint(0); ; shift += 7 {
3699 if shift >= 64 {
3700 return ErrIntOverflowGenerated
3701 }
3702 if iNdEx >= l {
3703 return io.ErrUnexpectedEOF
3704 }
3705 b := dAtA[iNdEx]
3706 iNdEx++
3707 wire |= uint64(b&0x7F) << shift
3708 if b < 0x80 {
3709 break
3710 }
3711 }
3712 fieldNum := int32(wire >> 3)
3713 wireType := int(wire & 0x7)
3714 if wireType == 4 {
3715 return fmt.Errorf("proto: ControllerRevision: wiretype end group for non-group")
3716 }
3717 if fieldNum <= 0 {
3718 return fmt.Errorf("proto: ControllerRevision: illegal tag %d (wire type %d)", fieldNum, wire)
3719 }
3720 switch fieldNum {
3721 case 1:
3722 if wireType != 2 {
3723 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3724 }
3725 var msglen int
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 msglen |= int(b&0x7F) << shift
3736 if b < 0x80 {
3737 break
3738 }
3739 }
3740 if msglen < 0 {
3741 return ErrInvalidLengthGenerated
3742 }
3743 postIndex := iNdEx + msglen
3744 if postIndex < 0 {
3745 return ErrInvalidLengthGenerated
3746 }
3747 if postIndex > l {
3748 return io.ErrUnexpectedEOF
3749 }
3750 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3751 return err
3752 }
3753 iNdEx = postIndex
3754 case 2:
3755 if wireType != 2 {
3756 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
3757 }
3758 var msglen 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 msglen |= int(b&0x7F) << shift
3769 if b < 0x80 {
3770 break
3771 }
3772 }
3773 if msglen < 0 {
3774 return ErrInvalidLengthGenerated
3775 }
3776 postIndex := iNdEx + msglen
3777 if postIndex < 0 {
3778 return ErrInvalidLengthGenerated
3779 }
3780 if postIndex > l {
3781 return io.ErrUnexpectedEOF
3782 }
3783 if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3784 return err
3785 }
3786 iNdEx = postIndex
3787 case 3:
3788 if wireType != 0 {
3789 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
3790 }
3791 m.Revision = 0
3792 for shift := uint(0); ; shift += 7 {
3793 if shift >= 64 {
3794 return ErrIntOverflowGenerated
3795 }
3796 if iNdEx >= l {
3797 return io.ErrUnexpectedEOF
3798 }
3799 b := dAtA[iNdEx]
3800 iNdEx++
3801 m.Revision |= int64(b&0x7F) << shift
3802 if b < 0x80 {
3803 break
3804 }
3805 }
3806 default:
3807 iNdEx = preIndex
3808 skippy, err := skipGenerated(dAtA[iNdEx:])
3809 if err != nil {
3810 return err
3811 }
3812 if (skippy < 0) || (iNdEx+skippy) < 0 {
3813 return ErrInvalidLengthGenerated
3814 }
3815 if (iNdEx + skippy) > l {
3816 return io.ErrUnexpectedEOF
3817 }
3818 iNdEx += skippy
3819 }
3820 }
3821
3822 if iNdEx > l {
3823 return io.ErrUnexpectedEOF
3824 }
3825 return nil
3826 }
3827 func (m *ControllerRevisionList) Unmarshal(dAtA []byte) error {
3828 l := len(dAtA)
3829 iNdEx := 0
3830 for iNdEx < l {
3831 preIndex := iNdEx
3832 var wire uint64
3833 for shift := uint(0); ; shift += 7 {
3834 if shift >= 64 {
3835 return ErrIntOverflowGenerated
3836 }
3837 if iNdEx >= l {
3838 return io.ErrUnexpectedEOF
3839 }
3840 b := dAtA[iNdEx]
3841 iNdEx++
3842 wire |= uint64(b&0x7F) << shift
3843 if b < 0x80 {
3844 break
3845 }
3846 }
3847 fieldNum := int32(wire >> 3)
3848 wireType := int(wire & 0x7)
3849 if wireType == 4 {
3850 return fmt.Errorf("proto: ControllerRevisionList: wiretype end group for non-group")
3851 }
3852 if fieldNum <= 0 {
3853 return fmt.Errorf("proto: ControllerRevisionList: illegal tag %d (wire type %d)", fieldNum, wire)
3854 }
3855 switch fieldNum {
3856 case 1:
3857 if wireType != 2 {
3858 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3859 }
3860 var msglen int
3861 for shift := uint(0); ; shift += 7 {
3862 if shift >= 64 {
3863 return ErrIntOverflowGenerated
3864 }
3865 if iNdEx >= l {
3866 return io.ErrUnexpectedEOF
3867 }
3868 b := dAtA[iNdEx]
3869 iNdEx++
3870 msglen |= int(b&0x7F) << shift
3871 if b < 0x80 {
3872 break
3873 }
3874 }
3875 if msglen < 0 {
3876 return ErrInvalidLengthGenerated
3877 }
3878 postIndex := iNdEx + msglen
3879 if postIndex < 0 {
3880 return ErrInvalidLengthGenerated
3881 }
3882 if postIndex > l {
3883 return io.ErrUnexpectedEOF
3884 }
3885 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3886 return err
3887 }
3888 iNdEx = postIndex
3889 case 2:
3890 if wireType != 2 {
3891 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3892 }
3893 var msglen int
3894 for shift := uint(0); ; shift += 7 {
3895 if shift >= 64 {
3896 return ErrIntOverflowGenerated
3897 }
3898 if iNdEx >= l {
3899 return io.ErrUnexpectedEOF
3900 }
3901 b := dAtA[iNdEx]
3902 iNdEx++
3903 msglen |= int(b&0x7F) << shift
3904 if b < 0x80 {
3905 break
3906 }
3907 }
3908 if msglen < 0 {
3909 return ErrInvalidLengthGenerated
3910 }
3911 postIndex := iNdEx + msglen
3912 if postIndex < 0 {
3913 return ErrInvalidLengthGenerated
3914 }
3915 if postIndex > l {
3916 return io.ErrUnexpectedEOF
3917 }
3918 m.Items = append(m.Items, ControllerRevision{})
3919 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3920 return err
3921 }
3922 iNdEx = postIndex
3923 default:
3924 iNdEx = preIndex
3925 skippy, err := skipGenerated(dAtA[iNdEx:])
3926 if err != nil {
3927 return err
3928 }
3929 if (skippy < 0) || (iNdEx+skippy) < 0 {
3930 return ErrInvalidLengthGenerated
3931 }
3932 if (iNdEx + skippy) > l {
3933 return io.ErrUnexpectedEOF
3934 }
3935 iNdEx += skippy
3936 }
3937 }
3938
3939 if iNdEx > l {
3940 return io.ErrUnexpectedEOF
3941 }
3942 return nil
3943 }
3944 func (m *DaemonSet) Unmarshal(dAtA []byte) error {
3945 l := len(dAtA)
3946 iNdEx := 0
3947 for iNdEx < l {
3948 preIndex := iNdEx
3949 var wire uint64
3950 for shift := uint(0); ; shift += 7 {
3951 if shift >= 64 {
3952 return ErrIntOverflowGenerated
3953 }
3954 if iNdEx >= l {
3955 return io.ErrUnexpectedEOF
3956 }
3957 b := dAtA[iNdEx]
3958 iNdEx++
3959 wire |= uint64(b&0x7F) << shift
3960 if b < 0x80 {
3961 break
3962 }
3963 }
3964 fieldNum := int32(wire >> 3)
3965 wireType := int(wire & 0x7)
3966 if wireType == 4 {
3967 return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
3968 }
3969 if fieldNum <= 0 {
3970 return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
3971 }
3972 switch fieldNum {
3973 case 1:
3974 if wireType != 2 {
3975 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3976 }
3977 var msglen int
3978 for shift := uint(0); ; shift += 7 {
3979 if shift >= 64 {
3980 return ErrIntOverflowGenerated
3981 }
3982 if iNdEx >= l {
3983 return io.ErrUnexpectedEOF
3984 }
3985 b := dAtA[iNdEx]
3986 iNdEx++
3987 msglen |= int(b&0x7F) << shift
3988 if b < 0x80 {
3989 break
3990 }
3991 }
3992 if msglen < 0 {
3993 return ErrInvalidLengthGenerated
3994 }
3995 postIndex := iNdEx + msglen
3996 if postIndex < 0 {
3997 return ErrInvalidLengthGenerated
3998 }
3999 if postIndex > l {
4000 return io.ErrUnexpectedEOF
4001 }
4002 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4003 return err
4004 }
4005 iNdEx = postIndex
4006 case 2:
4007 if wireType != 2 {
4008 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4009 }
4010 var msglen int
4011 for shift := uint(0); ; shift += 7 {
4012 if shift >= 64 {
4013 return ErrIntOverflowGenerated
4014 }
4015 if iNdEx >= l {
4016 return io.ErrUnexpectedEOF
4017 }
4018 b := dAtA[iNdEx]
4019 iNdEx++
4020 msglen |= int(b&0x7F) << shift
4021 if b < 0x80 {
4022 break
4023 }
4024 }
4025 if msglen < 0 {
4026 return ErrInvalidLengthGenerated
4027 }
4028 postIndex := iNdEx + msglen
4029 if postIndex < 0 {
4030 return ErrInvalidLengthGenerated
4031 }
4032 if postIndex > l {
4033 return io.ErrUnexpectedEOF
4034 }
4035 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4036 return err
4037 }
4038 iNdEx = postIndex
4039 case 3:
4040 if wireType != 2 {
4041 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4042 }
4043 var msglen int
4044 for shift := uint(0); ; shift += 7 {
4045 if shift >= 64 {
4046 return ErrIntOverflowGenerated
4047 }
4048 if iNdEx >= l {
4049 return io.ErrUnexpectedEOF
4050 }
4051 b := dAtA[iNdEx]
4052 iNdEx++
4053 msglen |= int(b&0x7F) << shift
4054 if b < 0x80 {
4055 break
4056 }
4057 }
4058 if msglen < 0 {
4059 return ErrInvalidLengthGenerated
4060 }
4061 postIndex := iNdEx + msglen
4062 if postIndex < 0 {
4063 return ErrInvalidLengthGenerated
4064 }
4065 if postIndex > l {
4066 return io.ErrUnexpectedEOF
4067 }
4068 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4069 return err
4070 }
4071 iNdEx = postIndex
4072 default:
4073 iNdEx = preIndex
4074 skippy, err := skipGenerated(dAtA[iNdEx:])
4075 if err != nil {
4076 return err
4077 }
4078 if (skippy < 0) || (iNdEx+skippy) < 0 {
4079 return ErrInvalidLengthGenerated
4080 }
4081 if (iNdEx + skippy) > l {
4082 return io.ErrUnexpectedEOF
4083 }
4084 iNdEx += skippy
4085 }
4086 }
4087
4088 if iNdEx > l {
4089 return io.ErrUnexpectedEOF
4090 }
4091 return nil
4092 }
4093 func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error {
4094 l := len(dAtA)
4095 iNdEx := 0
4096 for iNdEx < l {
4097 preIndex := iNdEx
4098 var wire uint64
4099 for shift := uint(0); ; shift += 7 {
4100 if shift >= 64 {
4101 return ErrIntOverflowGenerated
4102 }
4103 if iNdEx >= l {
4104 return io.ErrUnexpectedEOF
4105 }
4106 b := dAtA[iNdEx]
4107 iNdEx++
4108 wire |= uint64(b&0x7F) << shift
4109 if b < 0x80 {
4110 break
4111 }
4112 }
4113 fieldNum := int32(wire >> 3)
4114 wireType := int(wire & 0x7)
4115 if wireType == 4 {
4116 return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group")
4117 }
4118 if fieldNum <= 0 {
4119 return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4120 }
4121 switch fieldNum {
4122 case 1:
4123 if wireType != 2 {
4124 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4125 }
4126 var stringLen uint64
4127 for shift := uint(0); ; shift += 7 {
4128 if shift >= 64 {
4129 return ErrIntOverflowGenerated
4130 }
4131 if iNdEx >= l {
4132 return io.ErrUnexpectedEOF
4133 }
4134 b := dAtA[iNdEx]
4135 iNdEx++
4136 stringLen |= uint64(b&0x7F) << shift
4137 if b < 0x80 {
4138 break
4139 }
4140 }
4141 intStringLen := int(stringLen)
4142 if intStringLen < 0 {
4143 return ErrInvalidLengthGenerated
4144 }
4145 postIndex := iNdEx + intStringLen
4146 if postIndex < 0 {
4147 return ErrInvalidLengthGenerated
4148 }
4149 if postIndex > l {
4150 return io.ErrUnexpectedEOF
4151 }
4152 m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex])
4153 iNdEx = postIndex
4154 case 2:
4155 if wireType != 2 {
4156 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4157 }
4158 var stringLen uint64
4159 for shift := uint(0); ; shift += 7 {
4160 if shift >= 64 {
4161 return ErrIntOverflowGenerated
4162 }
4163 if iNdEx >= l {
4164 return io.ErrUnexpectedEOF
4165 }
4166 b := dAtA[iNdEx]
4167 iNdEx++
4168 stringLen |= uint64(b&0x7F) << shift
4169 if b < 0x80 {
4170 break
4171 }
4172 }
4173 intStringLen := int(stringLen)
4174 if intStringLen < 0 {
4175 return ErrInvalidLengthGenerated
4176 }
4177 postIndex := iNdEx + intStringLen
4178 if postIndex < 0 {
4179 return ErrInvalidLengthGenerated
4180 }
4181 if postIndex > l {
4182 return io.ErrUnexpectedEOF
4183 }
4184 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
4185 iNdEx = postIndex
4186 case 3:
4187 if wireType != 2 {
4188 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4189 }
4190 var msglen int
4191 for shift := uint(0); ; shift += 7 {
4192 if shift >= 64 {
4193 return ErrIntOverflowGenerated
4194 }
4195 if iNdEx >= l {
4196 return io.ErrUnexpectedEOF
4197 }
4198 b := dAtA[iNdEx]
4199 iNdEx++
4200 msglen |= int(b&0x7F) << shift
4201 if b < 0x80 {
4202 break
4203 }
4204 }
4205 if msglen < 0 {
4206 return ErrInvalidLengthGenerated
4207 }
4208 postIndex := iNdEx + msglen
4209 if postIndex < 0 {
4210 return ErrInvalidLengthGenerated
4211 }
4212 if postIndex > l {
4213 return io.ErrUnexpectedEOF
4214 }
4215 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4216 return err
4217 }
4218 iNdEx = postIndex
4219 case 4:
4220 if wireType != 2 {
4221 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4222 }
4223 var stringLen uint64
4224 for shift := uint(0); ; shift += 7 {
4225 if shift >= 64 {
4226 return ErrIntOverflowGenerated
4227 }
4228 if iNdEx >= l {
4229 return io.ErrUnexpectedEOF
4230 }
4231 b := dAtA[iNdEx]
4232 iNdEx++
4233 stringLen |= uint64(b&0x7F) << shift
4234 if b < 0x80 {
4235 break
4236 }
4237 }
4238 intStringLen := int(stringLen)
4239 if intStringLen < 0 {
4240 return ErrInvalidLengthGenerated
4241 }
4242 postIndex := iNdEx + intStringLen
4243 if postIndex < 0 {
4244 return ErrInvalidLengthGenerated
4245 }
4246 if postIndex > l {
4247 return io.ErrUnexpectedEOF
4248 }
4249 m.Reason = string(dAtA[iNdEx:postIndex])
4250 iNdEx = postIndex
4251 case 5:
4252 if wireType != 2 {
4253 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
4254 }
4255 var stringLen uint64
4256 for shift := uint(0); ; shift += 7 {
4257 if shift >= 64 {
4258 return ErrIntOverflowGenerated
4259 }
4260 if iNdEx >= l {
4261 return io.ErrUnexpectedEOF
4262 }
4263 b := dAtA[iNdEx]
4264 iNdEx++
4265 stringLen |= uint64(b&0x7F) << shift
4266 if b < 0x80 {
4267 break
4268 }
4269 }
4270 intStringLen := int(stringLen)
4271 if intStringLen < 0 {
4272 return ErrInvalidLengthGenerated
4273 }
4274 postIndex := iNdEx + intStringLen
4275 if postIndex < 0 {
4276 return ErrInvalidLengthGenerated
4277 }
4278 if postIndex > l {
4279 return io.ErrUnexpectedEOF
4280 }
4281 m.Message = string(dAtA[iNdEx:postIndex])
4282 iNdEx = postIndex
4283 default:
4284 iNdEx = preIndex
4285 skippy, err := skipGenerated(dAtA[iNdEx:])
4286 if err != nil {
4287 return err
4288 }
4289 if (skippy < 0) || (iNdEx+skippy) < 0 {
4290 return ErrInvalidLengthGenerated
4291 }
4292 if (iNdEx + skippy) > l {
4293 return io.ErrUnexpectedEOF
4294 }
4295 iNdEx += skippy
4296 }
4297 }
4298
4299 if iNdEx > l {
4300 return io.ErrUnexpectedEOF
4301 }
4302 return nil
4303 }
4304 func (m *DaemonSetList) Unmarshal(dAtA []byte) error {
4305 l := len(dAtA)
4306 iNdEx := 0
4307 for iNdEx < l {
4308 preIndex := iNdEx
4309 var wire uint64
4310 for shift := uint(0); ; shift += 7 {
4311 if shift >= 64 {
4312 return ErrIntOverflowGenerated
4313 }
4314 if iNdEx >= l {
4315 return io.ErrUnexpectedEOF
4316 }
4317 b := dAtA[iNdEx]
4318 iNdEx++
4319 wire |= uint64(b&0x7F) << shift
4320 if b < 0x80 {
4321 break
4322 }
4323 }
4324 fieldNum := int32(wire >> 3)
4325 wireType := int(wire & 0x7)
4326 if wireType == 4 {
4327 return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
4328 }
4329 if fieldNum <= 0 {
4330 return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
4331 }
4332 switch fieldNum {
4333 case 1:
4334 if wireType != 2 {
4335 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4336 }
4337 var msglen int
4338 for shift := uint(0); ; shift += 7 {
4339 if shift >= 64 {
4340 return ErrIntOverflowGenerated
4341 }
4342 if iNdEx >= l {
4343 return io.ErrUnexpectedEOF
4344 }
4345 b := dAtA[iNdEx]
4346 iNdEx++
4347 msglen |= int(b&0x7F) << shift
4348 if b < 0x80 {
4349 break
4350 }
4351 }
4352 if msglen < 0 {
4353 return ErrInvalidLengthGenerated
4354 }
4355 postIndex := iNdEx + msglen
4356 if postIndex < 0 {
4357 return ErrInvalidLengthGenerated
4358 }
4359 if postIndex > l {
4360 return io.ErrUnexpectedEOF
4361 }
4362 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4363 return err
4364 }
4365 iNdEx = postIndex
4366 case 2:
4367 if wireType != 2 {
4368 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4369 }
4370 var msglen int
4371 for shift := uint(0); ; shift += 7 {
4372 if shift >= 64 {
4373 return ErrIntOverflowGenerated
4374 }
4375 if iNdEx >= l {
4376 return io.ErrUnexpectedEOF
4377 }
4378 b := dAtA[iNdEx]
4379 iNdEx++
4380 msglen |= int(b&0x7F) << shift
4381 if b < 0x80 {
4382 break
4383 }
4384 }
4385 if msglen < 0 {
4386 return ErrInvalidLengthGenerated
4387 }
4388 postIndex := iNdEx + msglen
4389 if postIndex < 0 {
4390 return ErrInvalidLengthGenerated
4391 }
4392 if postIndex > l {
4393 return io.ErrUnexpectedEOF
4394 }
4395 m.Items = append(m.Items, DaemonSet{})
4396 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4397 return err
4398 }
4399 iNdEx = postIndex
4400 default:
4401 iNdEx = preIndex
4402 skippy, err := skipGenerated(dAtA[iNdEx:])
4403 if err != nil {
4404 return err
4405 }
4406 if (skippy < 0) || (iNdEx+skippy) < 0 {
4407 return ErrInvalidLengthGenerated
4408 }
4409 if (iNdEx + skippy) > l {
4410 return io.ErrUnexpectedEOF
4411 }
4412 iNdEx += skippy
4413 }
4414 }
4415
4416 if iNdEx > l {
4417 return io.ErrUnexpectedEOF
4418 }
4419 return nil
4420 }
4421 func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error {
4422 l := len(dAtA)
4423 iNdEx := 0
4424 for iNdEx < l {
4425 preIndex := iNdEx
4426 var wire uint64
4427 for shift := uint(0); ; shift += 7 {
4428 if shift >= 64 {
4429 return ErrIntOverflowGenerated
4430 }
4431 if iNdEx >= l {
4432 return io.ErrUnexpectedEOF
4433 }
4434 b := dAtA[iNdEx]
4435 iNdEx++
4436 wire |= uint64(b&0x7F) << shift
4437 if b < 0x80 {
4438 break
4439 }
4440 }
4441 fieldNum := int32(wire >> 3)
4442 wireType := int(wire & 0x7)
4443 if wireType == 4 {
4444 return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
4445 }
4446 if fieldNum <= 0 {
4447 return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4448 }
4449 switch fieldNum {
4450 case 1:
4451 if wireType != 2 {
4452 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
4453 }
4454 var msglen int
4455 for shift := uint(0); ; shift += 7 {
4456 if shift >= 64 {
4457 return ErrIntOverflowGenerated
4458 }
4459 if iNdEx >= l {
4460 return io.ErrUnexpectedEOF
4461 }
4462 b := dAtA[iNdEx]
4463 iNdEx++
4464 msglen |= int(b&0x7F) << shift
4465 if b < 0x80 {
4466 break
4467 }
4468 }
4469 if msglen < 0 {
4470 return ErrInvalidLengthGenerated
4471 }
4472 postIndex := iNdEx + msglen
4473 if postIndex < 0 {
4474 return ErrInvalidLengthGenerated
4475 }
4476 if postIndex > l {
4477 return io.ErrUnexpectedEOF
4478 }
4479 if m.Selector == nil {
4480 m.Selector = &v1.LabelSelector{}
4481 }
4482 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4483 return err
4484 }
4485 iNdEx = postIndex
4486 case 2:
4487 if wireType != 2 {
4488 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
4489 }
4490 var msglen int
4491 for shift := uint(0); ; shift += 7 {
4492 if shift >= 64 {
4493 return ErrIntOverflowGenerated
4494 }
4495 if iNdEx >= l {
4496 return io.ErrUnexpectedEOF
4497 }
4498 b := dAtA[iNdEx]
4499 iNdEx++
4500 msglen |= int(b&0x7F) << shift
4501 if b < 0x80 {
4502 break
4503 }
4504 }
4505 if msglen < 0 {
4506 return ErrInvalidLengthGenerated
4507 }
4508 postIndex := iNdEx + msglen
4509 if postIndex < 0 {
4510 return ErrInvalidLengthGenerated
4511 }
4512 if postIndex > l {
4513 return io.ErrUnexpectedEOF
4514 }
4515 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4516 return err
4517 }
4518 iNdEx = postIndex
4519 case 3:
4520 if wireType != 2 {
4521 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
4522 }
4523 var msglen int
4524 for shift := uint(0); ; shift += 7 {
4525 if shift >= 64 {
4526 return ErrIntOverflowGenerated
4527 }
4528 if iNdEx >= l {
4529 return io.ErrUnexpectedEOF
4530 }
4531 b := dAtA[iNdEx]
4532 iNdEx++
4533 msglen |= int(b&0x7F) << shift
4534 if b < 0x80 {
4535 break
4536 }
4537 }
4538 if msglen < 0 {
4539 return ErrInvalidLengthGenerated
4540 }
4541 postIndex := iNdEx + msglen
4542 if postIndex < 0 {
4543 return ErrInvalidLengthGenerated
4544 }
4545 if postIndex > l {
4546 return io.ErrUnexpectedEOF
4547 }
4548 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4549 return err
4550 }
4551 iNdEx = postIndex
4552 case 4:
4553 if wireType != 0 {
4554 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
4555 }
4556 m.MinReadySeconds = 0
4557 for shift := uint(0); ; shift += 7 {
4558 if shift >= 64 {
4559 return ErrIntOverflowGenerated
4560 }
4561 if iNdEx >= l {
4562 return io.ErrUnexpectedEOF
4563 }
4564 b := dAtA[iNdEx]
4565 iNdEx++
4566 m.MinReadySeconds |= int32(b&0x7F) << shift
4567 if b < 0x80 {
4568 break
4569 }
4570 }
4571 case 6:
4572 if wireType != 0 {
4573 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
4574 }
4575 var v int32
4576 for shift := uint(0); ; shift += 7 {
4577 if shift >= 64 {
4578 return ErrIntOverflowGenerated
4579 }
4580 if iNdEx >= l {
4581 return io.ErrUnexpectedEOF
4582 }
4583 b := dAtA[iNdEx]
4584 iNdEx++
4585 v |= int32(b&0x7F) << shift
4586 if b < 0x80 {
4587 break
4588 }
4589 }
4590 m.RevisionHistoryLimit = &v
4591 default:
4592 iNdEx = preIndex
4593 skippy, err := skipGenerated(dAtA[iNdEx:])
4594 if err != nil {
4595 return err
4596 }
4597 if (skippy < 0) || (iNdEx+skippy) < 0 {
4598 return ErrInvalidLengthGenerated
4599 }
4600 if (iNdEx + skippy) > l {
4601 return io.ErrUnexpectedEOF
4602 }
4603 iNdEx += skippy
4604 }
4605 }
4606
4607 if iNdEx > l {
4608 return io.ErrUnexpectedEOF
4609 }
4610 return nil
4611 }
4612 func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error {
4613 l := len(dAtA)
4614 iNdEx := 0
4615 for iNdEx < l {
4616 preIndex := iNdEx
4617 var wire uint64
4618 for shift := uint(0); ; shift += 7 {
4619 if shift >= 64 {
4620 return ErrIntOverflowGenerated
4621 }
4622 if iNdEx >= l {
4623 return io.ErrUnexpectedEOF
4624 }
4625 b := dAtA[iNdEx]
4626 iNdEx++
4627 wire |= uint64(b&0x7F) << shift
4628 if b < 0x80 {
4629 break
4630 }
4631 }
4632 fieldNum := int32(wire >> 3)
4633 wireType := int(wire & 0x7)
4634 if wireType == 4 {
4635 return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
4636 }
4637 if fieldNum <= 0 {
4638 return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4639 }
4640 switch fieldNum {
4641 case 1:
4642 if wireType != 0 {
4643 return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
4644 }
4645 m.CurrentNumberScheduled = 0
4646 for shift := uint(0); ; shift += 7 {
4647 if shift >= 64 {
4648 return ErrIntOverflowGenerated
4649 }
4650 if iNdEx >= l {
4651 return io.ErrUnexpectedEOF
4652 }
4653 b := dAtA[iNdEx]
4654 iNdEx++
4655 m.CurrentNumberScheduled |= int32(b&0x7F) << shift
4656 if b < 0x80 {
4657 break
4658 }
4659 }
4660 case 2:
4661 if wireType != 0 {
4662 return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
4663 }
4664 m.NumberMisscheduled = 0
4665 for shift := uint(0); ; shift += 7 {
4666 if shift >= 64 {
4667 return ErrIntOverflowGenerated
4668 }
4669 if iNdEx >= l {
4670 return io.ErrUnexpectedEOF
4671 }
4672 b := dAtA[iNdEx]
4673 iNdEx++
4674 m.NumberMisscheduled |= int32(b&0x7F) << shift
4675 if b < 0x80 {
4676 break
4677 }
4678 }
4679 case 3:
4680 if wireType != 0 {
4681 return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
4682 }
4683 m.DesiredNumberScheduled = 0
4684 for shift := uint(0); ; shift += 7 {
4685 if shift >= 64 {
4686 return ErrIntOverflowGenerated
4687 }
4688 if iNdEx >= l {
4689 return io.ErrUnexpectedEOF
4690 }
4691 b := dAtA[iNdEx]
4692 iNdEx++
4693 m.DesiredNumberScheduled |= int32(b&0x7F) << shift
4694 if b < 0x80 {
4695 break
4696 }
4697 }
4698 case 4:
4699 if wireType != 0 {
4700 return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType)
4701 }
4702 m.NumberReady = 0
4703 for shift := uint(0); ; shift += 7 {
4704 if shift >= 64 {
4705 return ErrIntOverflowGenerated
4706 }
4707 if iNdEx >= l {
4708 return io.ErrUnexpectedEOF
4709 }
4710 b := dAtA[iNdEx]
4711 iNdEx++
4712 m.NumberReady |= int32(b&0x7F) << shift
4713 if b < 0x80 {
4714 break
4715 }
4716 }
4717 case 5:
4718 if wireType != 0 {
4719 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
4720 }
4721 m.ObservedGeneration = 0
4722 for shift := uint(0); ; shift += 7 {
4723 if shift >= 64 {
4724 return ErrIntOverflowGenerated
4725 }
4726 if iNdEx >= l {
4727 return io.ErrUnexpectedEOF
4728 }
4729 b := dAtA[iNdEx]
4730 iNdEx++
4731 m.ObservedGeneration |= int64(b&0x7F) << shift
4732 if b < 0x80 {
4733 break
4734 }
4735 }
4736 case 6:
4737 if wireType != 0 {
4738 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType)
4739 }
4740 m.UpdatedNumberScheduled = 0
4741 for shift := uint(0); ; shift += 7 {
4742 if shift >= 64 {
4743 return ErrIntOverflowGenerated
4744 }
4745 if iNdEx >= l {
4746 return io.ErrUnexpectedEOF
4747 }
4748 b := dAtA[iNdEx]
4749 iNdEx++
4750 m.UpdatedNumberScheduled |= int32(b&0x7F) << shift
4751 if b < 0x80 {
4752 break
4753 }
4754 }
4755 case 7:
4756 if wireType != 0 {
4757 return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType)
4758 }
4759 m.NumberAvailable = 0
4760 for shift := uint(0); ; shift += 7 {
4761 if shift >= 64 {
4762 return ErrIntOverflowGenerated
4763 }
4764 if iNdEx >= l {
4765 return io.ErrUnexpectedEOF
4766 }
4767 b := dAtA[iNdEx]
4768 iNdEx++
4769 m.NumberAvailable |= int32(b&0x7F) << shift
4770 if b < 0x80 {
4771 break
4772 }
4773 }
4774 case 8:
4775 if wireType != 0 {
4776 return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType)
4777 }
4778 m.NumberUnavailable = 0
4779 for shift := uint(0); ; shift += 7 {
4780 if shift >= 64 {
4781 return ErrIntOverflowGenerated
4782 }
4783 if iNdEx >= l {
4784 return io.ErrUnexpectedEOF
4785 }
4786 b := dAtA[iNdEx]
4787 iNdEx++
4788 m.NumberUnavailable |= int32(b&0x7F) << shift
4789 if b < 0x80 {
4790 break
4791 }
4792 }
4793 case 9:
4794 if wireType != 0 {
4795 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
4796 }
4797 var v int32
4798 for shift := uint(0); ; shift += 7 {
4799 if shift >= 64 {
4800 return ErrIntOverflowGenerated
4801 }
4802 if iNdEx >= l {
4803 return io.ErrUnexpectedEOF
4804 }
4805 b := dAtA[iNdEx]
4806 iNdEx++
4807 v |= int32(b&0x7F) << shift
4808 if b < 0x80 {
4809 break
4810 }
4811 }
4812 m.CollisionCount = &v
4813 case 10:
4814 if wireType != 2 {
4815 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
4816 }
4817 var msglen int
4818 for shift := uint(0); ; shift += 7 {
4819 if shift >= 64 {
4820 return ErrIntOverflowGenerated
4821 }
4822 if iNdEx >= l {
4823 return io.ErrUnexpectedEOF
4824 }
4825 b := dAtA[iNdEx]
4826 iNdEx++
4827 msglen |= int(b&0x7F) << shift
4828 if b < 0x80 {
4829 break
4830 }
4831 }
4832 if msglen < 0 {
4833 return ErrInvalidLengthGenerated
4834 }
4835 postIndex := iNdEx + msglen
4836 if postIndex < 0 {
4837 return ErrInvalidLengthGenerated
4838 }
4839 if postIndex > l {
4840 return io.ErrUnexpectedEOF
4841 }
4842 m.Conditions = append(m.Conditions, DaemonSetCondition{})
4843 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4844 return err
4845 }
4846 iNdEx = postIndex
4847 default:
4848 iNdEx = preIndex
4849 skippy, err := skipGenerated(dAtA[iNdEx:])
4850 if err != nil {
4851 return err
4852 }
4853 if (skippy < 0) || (iNdEx+skippy) < 0 {
4854 return ErrInvalidLengthGenerated
4855 }
4856 if (iNdEx + skippy) > l {
4857 return io.ErrUnexpectedEOF
4858 }
4859 iNdEx += skippy
4860 }
4861 }
4862
4863 if iNdEx > l {
4864 return io.ErrUnexpectedEOF
4865 }
4866 return nil
4867 }
4868 func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error {
4869 l := len(dAtA)
4870 iNdEx := 0
4871 for iNdEx < l {
4872 preIndex := iNdEx
4873 var wire uint64
4874 for shift := uint(0); ; shift += 7 {
4875 if shift >= 64 {
4876 return ErrIntOverflowGenerated
4877 }
4878 if iNdEx >= l {
4879 return io.ErrUnexpectedEOF
4880 }
4881 b := dAtA[iNdEx]
4882 iNdEx++
4883 wire |= uint64(b&0x7F) << shift
4884 if b < 0x80 {
4885 break
4886 }
4887 }
4888 fieldNum := int32(wire >> 3)
4889 wireType := int(wire & 0x7)
4890 if wireType == 4 {
4891 return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group")
4892 }
4893 if fieldNum <= 0 {
4894 return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
4895 }
4896 switch fieldNum {
4897 case 1:
4898 if wireType != 2 {
4899 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4900 }
4901 var stringLen uint64
4902 for shift := uint(0); ; shift += 7 {
4903 if shift >= 64 {
4904 return ErrIntOverflowGenerated
4905 }
4906 if iNdEx >= l {
4907 return io.ErrUnexpectedEOF
4908 }
4909 b := dAtA[iNdEx]
4910 iNdEx++
4911 stringLen |= uint64(b&0x7F) << shift
4912 if b < 0x80 {
4913 break
4914 }
4915 }
4916 intStringLen := int(stringLen)
4917 if intStringLen < 0 {
4918 return ErrInvalidLengthGenerated
4919 }
4920 postIndex := iNdEx + intStringLen
4921 if postIndex < 0 {
4922 return ErrInvalidLengthGenerated
4923 }
4924 if postIndex > l {
4925 return io.ErrUnexpectedEOF
4926 }
4927 m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex])
4928 iNdEx = postIndex
4929 case 2:
4930 if wireType != 2 {
4931 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
4932 }
4933 var msglen int
4934 for shift := uint(0); ; shift += 7 {
4935 if shift >= 64 {
4936 return ErrIntOverflowGenerated
4937 }
4938 if iNdEx >= l {
4939 return io.ErrUnexpectedEOF
4940 }
4941 b := dAtA[iNdEx]
4942 iNdEx++
4943 msglen |= int(b&0x7F) << shift
4944 if b < 0x80 {
4945 break
4946 }
4947 }
4948 if msglen < 0 {
4949 return ErrInvalidLengthGenerated
4950 }
4951 postIndex := iNdEx + msglen
4952 if postIndex < 0 {
4953 return ErrInvalidLengthGenerated
4954 }
4955 if postIndex > l {
4956 return io.ErrUnexpectedEOF
4957 }
4958 if m.RollingUpdate == nil {
4959 m.RollingUpdate = &RollingUpdateDaemonSet{}
4960 }
4961 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4962 return err
4963 }
4964 iNdEx = postIndex
4965 default:
4966 iNdEx = preIndex
4967 skippy, err := skipGenerated(dAtA[iNdEx:])
4968 if err != nil {
4969 return err
4970 }
4971 if (skippy < 0) || (iNdEx+skippy) < 0 {
4972 return ErrInvalidLengthGenerated
4973 }
4974 if (iNdEx + skippy) > l {
4975 return io.ErrUnexpectedEOF
4976 }
4977 iNdEx += skippy
4978 }
4979 }
4980
4981 if iNdEx > l {
4982 return io.ErrUnexpectedEOF
4983 }
4984 return nil
4985 }
4986 func (m *Deployment) Unmarshal(dAtA []byte) error {
4987 l := len(dAtA)
4988 iNdEx := 0
4989 for iNdEx < l {
4990 preIndex := iNdEx
4991 var wire uint64
4992 for shift := uint(0); ; shift += 7 {
4993 if shift >= 64 {
4994 return ErrIntOverflowGenerated
4995 }
4996 if iNdEx >= l {
4997 return io.ErrUnexpectedEOF
4998 }
4999 b := dAtA[iNdEx]
5000 iNdEx++
5001 wire |= uint64(b&0x7F) << shift
5002 if b < 0x80 {
5003 break
5004 }
5005 }
5006 fieldNum := int32(wire >> 3)
5007 wireType := int(wire & 0x7)
5008 if wireType == 4 {
5009 return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
5010 }
5011 if fieldNum <= 0 {
5012 return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
5013 }
5014 switch fieldNum {
5015 case 1:
5016 if wireType != 2 {
5017 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
5018 }
5019 var msglen int
5020 for shift := uint(0); ; shift += 7 {
5021 if shift >= 64 {
5022 return ErrIntOverflowGenerated
5023 }
5024 if iNdEx >= l {
5025 return io.ErrUnexpectedEOF
5026 }
5027 b := dAtA[iNdEx]
5028 iNdEx++
5029 msglen |= int(b&0x7F) << shift
5030 if b < 0x80 {
5031 break
5032 }
5033 }
5034 if msglen < 0 {
5035 return ErrInvalidLengthGenerated
5036 }
5037 postIndex := iNdEx + msglen
5038 if postIndex < 0 {
5039 return ErrInvalidLengthGenerated
5040 }
5041 if postIndex > l {
5042 return io.ErrUnexpectedEOF
5043 }
5044 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5045 return err
5046 }
5047 iNdEx = postIndex
5048 case 2:
5049 if wireType != 2 {
5050 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
5051 }
5052 var msglen int
5053 for shift := uint(0); ; shift += 7 {
5054 if shift >= 64 {
5055 return ErrIntOverflowGenerated
5056 }
5057 if iNdEx >= l {
5058 return io.ErrUnexpectedEOF
5059 }
5060 b := dAtA[iNdEx]
5061 iNdEx++
5062 msglen |= int(b&0x7F) << shift
5063 if b < 0x80 {
5064 break
5065 }
5066 }
5067 if msglen < 0 {
5068 return ErrInvalidLengthGenerated
5069 }
5070 postIndex := iNdEx + msglen
5071 if postIndex < 0 {
5072 return ErrInvalidLengthGenerated
5073 }
5074 if postIndex > l {
5075 return io.ErrUnexpectedEOF
5076 }
5077 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5078 return err
5079 }
5080 iNdEx = postIndex
5081 case 3:
5082 if wireType != 2 {
5083 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5084 }
5085 var msglen int
5086 for shift := uint(0); ; shift += 7 {
5087 if shift >= 64 {
5088 return ErrIntOverflowGenerated
5089 }
5090 if iNdEx >= l {
5091 return io.ErrUnexpectedEOF
5092 }
5093 b := dAtA[iNdEx]
5094 iNdEx++
5095 msglen |= int(b&0x7F) << shift
5096 if b < 0x80 {
5097 break
5098 }
5099 }
5100 if msglen < 0 {
5101 return ErrInvalidLengthGenerated
5102 }
5103 postIndex := iNdEx + msglen
5104 if postIndex < 0 {
5105 return ErrInvalidLengthGenerated
5106 }
5107 if postIndex > l {
5108 return io.ErrUnexpectedEOF
5109 }
5110 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5111 return err
5112 }
5113 iNdEx = postIndex
5114 default:
5115 iNdEx = preIndex
5116 skippy, err := skipGenerated(dAtA[iNdEx:])
5117 if err != nil {
5118 return err
5119 }
5120 if (skippy < 0) || (iNdEx+skippy) < 0 {
5121 return ErrInvalidLengthGenerated
5122 }
5123 if (iNdEx + skippy) > l {
5124 return io.ErrUnexpectedEOF
5125 }
5126 iNdEx += skippy
5127 }
5128 }
5129
5130 if iNdEx > l {
5131 return io.ErrUnexpectedEOF
5132 }
5133 return nil
5134 }
5135 func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
5136 l := len(dAtA)
5137 iNdEx := 0
5138 for iNdEx < l {
5139 preIndex := iNdEx
5140 var wire uint64
5141 for shift := uint(0); ; shift += 7 {
5142 if shift >= 64 {
5143 return ErrIntOverflowGenerated
5144 }
5145 if iNdEx >= l {
5146 return io.ErrUnexpectedEOF
5147 }
5148 b := dAtA[iNdEx]
5149 iNdEx++
5150 wire |= uint64(b&0x7F) << shift
5151 if b < 0x80 {
5152 break
5153 }
5154 }
5155 fieldNum := int32(wire >> 3)
5156 wireType := int(wire & 0x7)
5157 if wireType == 4 {
5158 return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
5159 }
5160 if fieldNum <= 0 {
5161 return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
5162 }
5163 switch fieldNum {
5164 case 1:
5165 if wireType != 2 {
5166 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5167 }
5168 var stringLen uint64
5169 for shift := uint(0); ; shift += 7 {
5170 if shift >= 64 {
5171 return ErrIntOverflowGenerated
5172 }
5173 if iNdEx >= l {
5174 return io.ErrUnexpectedEOF
5175 }
5176 b := dAtA[iNdEx]
5177 iNdEx++
5178 stringLen |= uint64(b&0x7F) << shift
5179 if b < 0x80 {
5180 break
5181 }
5182 }
5183 intStringLen := int(stringLen)
5184 if intStringLen < 0 {
5185 return ErrInvalidLengthGenerated
5186 }
5187 postIndex := iNdEx + intStringLen
5188 if postIndex < 0 {
5189 return ErrInvalidLengthGenerated
5190 }
5191 if postIndex > l {
5192 return io.ErrUnexpectedEOF
5193 }
5194 m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
5195 iNdEx = postIndex
5196 case 2:
5197 if wireType != 2 {
5198 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5199 }
5200 var stringLen uint64
5201 for shift := uint(0); ; shift += 7 {
5202 if shift >= 64 {
5203 return ErrIntOverflowGenerated
5204 }
5205 if iNdEx >= l {
5206 return io.ErrUnexpectedEOF
5207 }
5208 b := dAtA[iNdEx]
5209 iNdEx++
5210 stringLen |= uint64(b&0x7F) << shift
5211 if b < 0x80 {
5212 break
5213 }
5214 }
5215 intStringLen := int(stringLen)
5216 if intStringLen < 0 {
5217 return ErrInvalidLengthGenerated
5218 }
5219 postIndex := iNdEx + intStringLen
5220 if postIndex < 0 {
5221 return ErrInvalidLengthGenerated
5222 }
5223 if postIndex > l {
5224 return io.ErrUnexpectedEOF
5225 }
5226 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
5227 iNdEx = postIndex
5228 case 4:
5229 if wireType != 2 {
5230 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5231 }
5232 var stringLen uint64
5233 for shift := uint(0); ; shift += 7 {
5234 if shift >= 64 {
5235 return ErrIntOverflowGenerated
5236 }
5237 if iNdEx >= l {
5238 return io.ErrUnexpectedEOF
5239 }
5240 b := dAtA[iNdEx]
5241 iNdEx++
5242 stringLen |= uint64(b&0x7F) << shift
5243 if b < 0x80 {
5244 break
5245 }
5246 }
5247 intStringLen := int(stringLen)
5248 if intStringLen < 0 {
5249 return ErrInvalidLengthGenerated
5250 }
5251 postIndex := iNdEx + intStringLen
5252 if postIndex < 0 {
5253 return ErrInvalidLengthGenerated
5254 }
5255 if postIndex > l {
5256 return io.ErrUnexpectedEOF
5257 }
5258 m.Reason = string(dAtA[iNdEx:postIndex])
5259 iNdEx = postIndex
5260 case 5:
5261 if wireType != 2 {
5262 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5263 }
5264 var stringLen uint64
5265 for shift := uint(0); ; shift += 7 {
5266 if shift >= 64 {
5267 return ErrIntOverflowGenerated
5268 }
5269 if iNdEx >= l {
5270 return io.ErrUnexpectedEOF
5271 }
5272 b := dAtA[iNdEx]
5273 iNdEx++
5274 stringLen |= uint64(b&0x7F) << shift
5275 if b < 0x80 {
5276 break
5277 }
5278 }
5279 intStringLen := int(stringLen)
5280 if intStringLen < 0 {
5281 return ErrInvalidLengthGenerated
5282 }
5283 postIndex := iNdEx + intStringLen
5284 if postIndex < 0 {
5285 return ErrInvalidLengthGenerated
5286 }
5287 if postIndex > l {
5288 return io.ErrUnexpectedEOF
5289 }
5290 m.Message = string(dAtA[iNdEx:postIndex])
5291 iNdEx = postIndex
5292 case 6:
5293 if wireType != 2 {
5294 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
5295 }
5296 var msglen int
5297 for shift := uint(0); ; shift += 7 {
5298 if shift >= 64 {
5299 return ErrIntOverflowGenerated
5300 }
5301 if iNdEx >= l {
5302 return io.ErrUnexpectedEOF
5303 }
5304 b := dAtA[iNdEx]
5305 iNdEx++
5306 msglen |= int(b&0x7F) << shift
5307 if b < 0x80 {
5308 break
5309 }
5310 }
5311 if msglen < 0 {
5312 return ErrInvalidLengthGenerated
5313 }
5314 postIndex := iNdEx + msglen
5315 if postIndex < 0 {
5316 return ErrInvalidLengthGenerated
5317 }
5318 if postIndex > l {
5319 return io.ErrUnexpectedEOF
5320 }
5321 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5322 return err
5323 }
5324 iNdEx = postIndex
5325 case 7:
5326 if wireType != 2 {
5327 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
5328 }
5329 var msglen int
5330 for shift := uint(0); ; shift += 7 {
5331 if shift >= 64 {
5332 return ErrIntOverflowGenerated
5333 }
5334 if iNdEx >= l {
5335 return io.ErrUnexpectedEOF
5336 }
5337 b := dAtA[iNdEx]
5338 iNdEx++
5339 msglen |= int(b&0x7F) << shift
5340 if b < 0x80 {
5341 break
5342 }
5343 }
5344 if msglen < 0 {
5345 return ErrInvalidLengthGenerated
5346 }
5347 postIndex := iNdEx + msglen
5348 if postIndex < 0 {
5349 return ErrInvalidLengthGenerated
5350 }
5351 if postIndex > l {
5352 return io.ErrUnexpectedEOF
5353 }
5354 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5355 return err
5356 }
5357 iNdEx = postIndex
5358 default:
5359 iNdEx = preIndex
5360 skippy, err := skipGenerated(dAtA[iNdEx:])
5361 if err != nil {
5362 return err
5363 }
5364 if (skippy < 0) || (iNdEx+skippy) < 0 {
5365 return ErrInvalidLengthGenerated
5366 }
5367 if (iNdEx + skippy) > l {
5368 return io.ErrUnexpectedEOF
5369 }
5370 iNdEx += skippy
5371 }
5372 }
5373
5374 if iNdEx > l {
5375 return io.ErrUnexpectedEOF
5376 }
5377 return nil
5378 }
5379 func (m *DeploymentList) Unmarshal(dAtA []byte) error {
5380 l := len(dAtA)
5381 iNdEx := 0
5382 for iNdEx < l {
5383 preIndex := iNdEx
5384 var wire uint64
5385 for shift := uint(0); ; shift += 7 {
5386 if shift >= 64 {
5387 return ErrIntOverflowGenerated
5388 }
5389 if iNdEx >= l {
5390 return io.ErrUnexpectedEOF
5391 }
5392 b := dAtA[iNdEx]
5393 iNdEx++
5394 wire |= uint64(b&0x7F) << shift
5395 if b < 0x80 {
5396 break
5397 }
5398 }
5399 fieldNum := int32(wire >> 3)
5400 wireType := int(wire & 0x7)
5401 if wireType == 4 {
5402 return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
5403 }
5404 if fieldNum <= 0 {
5405 return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
5406 }
5407 switch fieldNum {
5408 case 1:
5409 if wireType != 2 {
5410 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5411 }
5412 var msglen int
5413 for shift := uint(0); ; shift += 7 {
5414 if shift >= 64 {
5415 return ErrIntOverflowGenerated
5416 }
5417 if iNdEx >= l {
5418 return io.ErrUnexpectedEOF
5419 }
5420 b := dAtA[iNdEx]
5421 iNdEx++
5422 msglen |= int(b&0x7F) << shift
5423 if b < 0x80 {
5424 break
5425 }
5426 }
5427 if msglen < 0 {
5428 return ErrInvalidLengthGenerated
5429 }
5430 postIndex := iNdEx + msglen
5431 if postIndex < 0 {
5432 return ErrInvalidLengthGenerated
5433 }
5434 if postIndex > l {
5435 return io.ErrUnexpectedEOF
5436 }
5437 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5438 return err
5439 }
5440 iNdEx = postIndex
5441 case 2:
5442 if wireType != 2 {
5443 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5444 }
5445 var msglen int
5446 for shift := uint(0); ; shift += 7 {
5447 if shift >= 64 {
5448 return ErrIntOverflowGenerated
5449 }
5450 if iNdEx >= l {
5451 return io.ErrUnexpectedEOF
5452 }
5453 b := dAtA[iNdEx]
5454 iNdEx++
5455 msglen |= int(b&0x7F) << shift
5456 if b < 0x80 {
5457 break
5458 }
5459 }
5460 if msglen < 0 {
5461 return ErrInvalidLengthGenerated
5462 }
5463 postIndex := iNdEx + msglen
5464 if postIndex < 0 {
5465 return ErrInvalidLengthGenerated
5466 }
5467 if postIndex > l {
5468 return io.ErrUnexpectedEOF
5469 }
5470 m.Items = append(m.Items, Deployment{})
5471 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5472 return err
5473 }
5474 iNdEx = postIndex
5475 default:
5476 iNdEx = preIndex
5477 skippy, err := skipGenerated(dAtA[iNdEx:])
5478 if err != nil {
5479 return err
5480 }
5481 if (skippy < 0) || (iNdEx+skippy) < 0 {
5482 return ErrInvalidLengthGenerated
5483 }
5484 if (iNdEx + skippy) > l {
5485 return io.ErrUnexpectedEOF
5486 }
5487 iNdEx += skippy
5488 }
5489 }
5490
5491 if iNdEx > l {
5492 return io.ErrUnexpectedEOF
5493 }
5494 return nil
5495 }
5496 func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
5497 l := len(dAtA)
5498 iNdEx := 0
5499 for iNdEx < l {
5500 preIndex := iNdEx
5501 var wire uint64
5502 for shift := uint(0); ; shift += 7 {
5503 if shift >= 64 {
5504 return ErrIntOverflowGenerated
5505 }
5506 if iNdEx >= l {
5507 return io.ErrUnexpectedEOF
5508 }
5509 b := dAtA[iNdEx]
5510 iNdEx++
5511 wire |= uint64(b&0x7F) << shift
5512 if b < 0x80 {
5513 break
5514 }
5515 }
5516 fieldNum := int32(wire >> 3)
5517 wireType := int(wire & 0x7)
5518 if wireType == 4 {
5519 return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
5520 }
5521 if fieldNum <= 0 {
5522 return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
5523 }
5524 switch fieldNum {
5525 case 1:
5526 if wireType != 0 {
5527 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
5528 }
5529 var v int32
5530 for shift := uint(0); ; shift += 7 {
5531 if shift >= 64 {
5532 return ErrIntOverflowGenerated
5533 }
5534 if iNdEx >= l {
5535 return io.ErrUnexpectedEOF
5536 }
5537 b := dAtA[iNdEx]
5538 iNdEx++
5539 v |= int32(b&0x7F) << shift
5540 if b < 0x80 {
5541 break
5542 }
5543 }
5544 m.Replicas = &v
5545 case 2:
5546 if wireType != 2 {
5547 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
5548 }
5549 var msglen int
5550 for shift := uint(0); ; shift += 7 {
5551 if shift >= 64 {
5552 return ErrIntOverflowGenerated
5553 }
5554 if iNdEx >= l {
5555 return io.ErrUnexpectedEOF
5556 }
5557 b := dAtA[iNdEx]
5558 iNdEx++
5559 msglen |= int(b&0x7F) << shift
5560 if b < 0x80 {
5561 break
5562 }
5563 }
5564 if msglen < 0 {
5565 return ErrInvalidLengthGenerated
5566 }
5567 postIndex := iNdEx + msglen
5568 if postIndex < 0 {
5569 return ErrInvalidLengthGenerated
5570 }
5571 if postIndex > l {
5572 return io.ErrUnexpectedEOF
5573 }
5574 if m.Selector == nil {
5575 m.Selector = &v1.LabelSelector{}
5576 }
5577 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5578 return err
5579 }
5580 iNdEx = postIndex
5581 case 3:
5582 if wireType != 2 {
5583 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
5584 }
5585 var msglen int
5586 for shift := uint(0); ; shift += 7 {
5587 if shift >= 64 {
5588 return ErrIntOverflowGenerated
5589 }
5590 if iNdEx >= l {
5591 return io.ErrUnexpectedEOF
5592 }
5593 b := dAtA[iNdEx]
5594 iNdEx++
5595 msglen |= int(b&0x7F) << shift
5596 if b < 0x80 {
5597 break
5598 }
5599 }
5600 if msglen < 0 {
5601 return ErrInvalidLengthGenerated
5602 }
5603 postIndex := iNdEx + msglen
5604 if postIndex < 0 {
5605 return ErrInvalidLengthGenerated
5606 }
5607 if postIndex > l {
5608 return io.ErrUnexpectedEOF
5609 }
5610 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5611 return err
5612 }
5613 iNdEx = postIndex
5614 case 4:
5615 if wireType != 2 {
5616 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
5617 }
5618 var msglen int
5619 for shift := uint(0); ; shift += 7 {
5620 if shift >= 64 {
5621 return ErrIntOverflowGenerated
5622 }
5623 if iNdEx >= l {
5624 return io.ErrUnexpectedEOF
5625 }
5626 b := dAtA[iNdEx]
5627 iNdEx++
5628 msglen |= int(b&0x7F) << shift
5629 if b < 0x80 {
5630 break
5631 }
5632 }
5633 if msglen < 0 {
5634 return ErrInvalidLengthGenerated
5635 }
5636 postIndex := iNdEx + msglen
5637 if postIndex < 0 {
5638 return ErrInvalidLengthGenerated
5639 }
5640 if postIndex > l {
5641 return io.ErrUnexpectedEOF
5642 }
5643 if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5644 return err
5645 }
5646 iNdEx = postIndex
5647 case 5:
5648 if wireType != 0 {
5649 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
5650 }
5651 m.MinReadySeconds = 0
5652 for shift := uint(0); ; shift += 7 {
5653 if shift >= 64 {
5654 return ErrIntOverflowGenerated
5655 }
5656 if iNdEx >= l {
5657 return io.ErrUnexpectedEOF
5658 }
5659 b := dAtA[iNdEx]
5660 iNdEx++
5661 m.MinReadySeconds |= int32(b&0x7F) << shift
5662 if b < 0x80 {
5663 break
5664 }
5665 }
5666 case 6:
5667 if wireType != 0 {
5668 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
5669 }
5670 var v int32
5671 for shift := uint(0); ; shift += 7 {
5672 if shift >= 64 {
5673 return ErrIntOverflowGenerated
5674 }
5675 if iNdEx >= l {
5676 return io.ErrUnexpectedEOF
5677 }
5678 b := dAtA[iNdEx]
5679 iNdEx++
5680 v |= int32(b&0x7F) << shift
5681 if b < 0x80 {
5682 break
5683 }
5684 }
5685 m.RevisionHistoryLimit = &v
5686 case 7:
5687 if wireType != 0 {
5688 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
5689 }
5690 var v int
5691 for shift := uint(0); ; shift += 7 {
5692 if shift >= 64 {
5693 return ErrIntOverflowGenerated
5694 }
5695 if iNdEx >= l {
5696 return io.ErrUnexpectedEOF
5697 }
5698 b := dAtA[iNdEx]
5699 iNdEx++
5700 v |= int(b&0x7F) << shift
5701 if b < 0x80 {
5702 break
5703 }
5704 }
5705 m.Paused = bool(v != 0)
5706 case 9:
5707 if wireType != 0 {
5708 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
5709 }
5710 var v int32
5711 for shift := uint(0); ; shift += 7 {
5712 if shift >= 64 {
5713 return ErrIntOverflowGenerated
5714 }
5715 if iNdEx >= l {
5716 return io.ErrUnexpectedEOF
5717 }
5718 b := dAtA[iNdEx]
5719 iNdEx++
5720 v |= int32(b&0x7F) << shift
5721 if b < 0x80 {
5722 break
5723 }
5724 }
5725 m.ProgressDeadlineSeconds = &v
5726 default:
5727 iNdEx = preIndex
5728 skippy, err := skipGenerated(dAtA[iNdEx:])
5729 if err != nil {
5730 return err
5731 }
5732 if (skippy < 0) || (iNdEx+skippy) < 0 {
5733 return ErrInvalidLengthGenerated
5734 }
5735 if (iNdEx + skippy) > l {
5736 return io.ErrUnexpectedEOF
5737 }
5738 iNdEx += skippy
5739 }
5740 }
5741
5742 if iNdEx > l {
5743 return io.ErrUnexpectedEOF
5744 }
5745 return nil
5746 }
5747 func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
5748 l := len(dAtA)
5749 iNdEx := 0
5750 for iNdEx < l {
5751 preIndex := iNdEx
5752 var wire uint64
5753 for shift := uint(0); ; shift += 7 {
5754 if shift >= 64 {
5755 return ErrIntOverflowGenerated
5756 }
5757 if iNdEx >= l {
5758 return io.ErrUnexpectedEOF
5759 }
5760 b := dAtA[iNdEx]
5761 iNdEx++
5762 wire |= uint64(b&0x7F) << shift
5763 if b < 0x80 {
5764 break
5765 }
5766 }
5767 fieldNum := int32(wire >> 3)
5768 wireType := int(wire & 0x7)
5769 if wireType == 4 {
5770 return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
5771 }
5772 if fieldNum <= 0 {
5773 return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5774 }
5775 switch fieldNum {
5776 case 1:
5777 if wireType != 0 {
5778 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
5779 }
5780 m.ObservedGeneration = 0
5781 for shift := uint(0); ; shift += 7 {
5782 if shift >= 64 {
5783 return ErrIntOverflowGenerated
5784 }
5785 if iNdEx >= l {
5786 return io.ErrUnexpectedEOF
5787 }
5788 b := dAtA[iNdEx]
5789 iNdEx++
5790 m.ObservedGeneration |= int64(b&0x7F) << shift
5791 if b < 0x80 {
5792 break
5793 }
5794 }
5795 case 2:
5796 if wireType != 0 {
5797 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
5798 }
5799 m.Replicas = 0
5800 for shift := uint(0); ; shift += 7 {
5801 if shift >= 64 {
5802 return ErrIntOverflowGenerated
5803 }
5804 if iNdEx >= l {
5805 return io.ErrUnexpectedEOF
5806 }
5807 b := dAtA[iNdEx]
5808 iNdEx++
5809 m.Replicas |= int32(b&0x7F) << shift
5810 if b < 0x80 {
5811 break
5812 }
5813 }
5814 case 3:
5815 if wireType != 0 {
5816 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
5817 }
5818 m.UpdatedReplicas = 0
5819 for shift := uint(0); ; shift += 7 {
5820 if shift >= 64 {
5821 return ErrIntOverflowGenerated
5822 }
5823 if iNdEx >= l {
5824 return io.ErrUnexpectedEOF
5825 }
5826 b := dAtA[iNdEx]
5827 iNdEx++
5828 m.UpdatedReplicas |= int32(b&0x7F) << shift
5829 if b < 0x80 {
5830 break
5831 }
5832 }
5833 case 4:
5834 if wireType != 0 {
5835 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
5836 }
5837 m.AvailableReplicas = 0
5838 for shift := uint(0); ; shift += 7 {
5839 if shift >= 64 {
5840 return ErrIntOverflowGenerated
5841 }
5842 if iNdEx >= l {
5843 return io.ErrUnexpectedEOF
5844 }
5845 b := dAtA[iNdEx]
5846 iNdEx++
5847 m.AvailableReplicas |= int32(b&0x7F) << shift
5848 if b < 0x80 {
5849 break
5850 }
5851 }
5852 case 5:
5853 if wireType != 0 {
5854 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
5855 }
5856 m.UnavailableReplicas = 0
5857 for shift := uint(0); ; shift += 7 {
5858 if shift >= 64 {
5859 return ErrIntOverflowGenerated
5860 }
5861 if iNdEx >= l {
5862 return io.ErrUnexpectedEOF
5863 }
5864 b := dAtA[iNdEx]
5865 iNdEx++
5866 m.UnavailableReplicas |= int32(b&0x7F) << shift
5867 if b < 0x80 {
5868 break
5869 }
5870 }
5871 case 6:
5872 if wireType != 2 {
5873 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
5874 }
5875 var msglen int
5876 for shift := uint(0); ; shift += 7 {
5877 if shift >= 64 {
5878 return ErrIntOverflowGenerated
5879 }
5880 if iNdEx >= l {
5881 return io.ErrUnexpectedEOF
5882 }
5883 b := dAtA[iNdEx]
5884 iNdEx++
5885 msglen |= int(b&0x7F) << shift
5886 if b < 0x80 {
5887 break
5888 }
5889 }
5890 if msglen < 0 {
5891 return ErrInvalidLengthGenerated
5892 }
5893 postIndex := iNdEx + msglen
5894 if postIndex < 0 {
5895 return ErrInvalidLengthGenerated
5896 }
5897 if postIndex > l {
5898 return io.ErrUnexpectedEOF
5899 }
5900 m.Conditions = append(m.Conditions, DeploymentCondition{})
5901 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5902 return err
5903 }
5904 iNdEx = postIndex
5905 case 7:
5906 if wireType != 0 {
5907 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
5908 }
5909 m.ReadyReplicas = 0
5910 for shift := uint(0); ; shift += 7 {
5911 if shift >= 64 {
5912 return ErrIntOverflowGenerated
5913 }
5914 if iNdEx >= l {
5915 return io.ErrUnexpectedEOF
5916 }
5917 b := dAtA[iNdEx]
5918 iNdEx++
5919 m.ReadyReplicas |= int32(b&0x7F) << shift
5920 if b < 0x80 {
5921 break
5922 }
5923 }
5924 case 8:
5925 if wireType != 0 {
5926 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
5927 }
5928 var v int32
5929 for shift := uint(0); ; shift += 7 {
5930 if shift >= 64 {
5931 return ErrIntOverflowGenerated
5932 }
5933 if iNdEx >= l {
5934 return io.ErrUnexpectedEOF
5935 }
5936 b := dAtA[iNdEx]
5937 iNdEx++
5938 v |= int32(b&0x7F) << shift
5939 if b < 0x80 {
5940 break
5941 }
5942 }
5943 m.CollisionCount = &v
5944 default:
5945 iNdEx = preIndex
5946 skippy, err := skipGenerated(dAtA[iNdEx:])
5947 if err != nil {
5948 return err
5949 }
5950 if (skippy < 0) || (iNdEx+skippy) < 0 {
5951 return ErrInvalidLengthGenerated
5952 }
5953 if (iNdEx + skippy) > l {
5954 return io.ErrUnexpectedEOF
5955 }
5956 iNdEx += skippy
5957 }
5958 }
5959
5960 if iNdEx > l {
5961 return io.ErrUnexpectedEOF
5962 }
5963 return nil
5964 }
5965 func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
5966 l := len(dAtA)
5967 iNdEx := 0
5968 for iNdEx < l {
5969 preIndex := iNdEx
5970 var wire uint64
5971 for shift := uint(0); ; shift += 7 {
5972 if shift >= 64 {
5973 return ErrIntOverflowGenerated
5974 }
5975 if iNdEx >= l {
5976 return io.ErrUnexpectedEOF
5977 }
5978 b := dAtA[iNdEx]
5979 iNdEx++
5980 wire |= uint64(b&0x7F) << shift
5981 if b < 0x80 {
5982 break
5983 }
5984 }
5985 fieldNum := int32(wire >> 3)
5986 wireType := int(wire & 0x7)
5987 if wireType == 4 {
5988 return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
5989 }
5990 if fieldNum <= 0 {
5991 return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
5992 }
5993 switch fieldNum {
5994 case 1:
5995 if wireType != 2 {
5996 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5997 }
5998 var stringLen uint64
5999 for shift := uint(0); ; shift += 7 {
6000 if shift >= 64 {
6001 return ErrIntOverflowGenerated
6002 }
6003 if iNdEx >= l {
6004 return io.ErrUnexpectedEOF
6005 }
6006 b := dAtA[iNdEx]
6007 iNdEx++
6008 stringLen |= uint64(b&0x7F) << shift
6009 if b < 0x80 {
6010 break
6011 }
6012 }
6013 intStringLen := int(stringLen)
6014 if intStringLen < 0 {
6015 return ErrInvalidLengthGenerated
6016 }
6017 postIndex := iNdEx + intStringLen
6018 if postIndex < 0 {
6019 return ErrInvalidLengthGenerated
6020 }
6021 if postIndex > l {
6022 return io.ErrUnexpectedEOF
6023 }
6024 m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
6025 iNdEx = postIndex
6026 case 2:
6027 if wireType != 2 {
6028 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
6029 }
6030 var msglen int
6031 for shift := uint(0); ; shift += 7 {
6032 if shift >= 64 {
6033 return ErrIntOverflowGenerated
6034 }
6035 if iNdEx >= l {
6036 return io.ErrUnexpectedEOF
6037 }
6038 b := dAtA[iNdEx]
6039 iNdEx++
6040 msglen |= int(b&0x7F) << shift
6041 if b < 0x80 {
6042 break
6043 }
6044 }
6045 if msglen < 0 {
6046 return ErrInvalidLengthGenerated
6047 }
6048 postIndex := iNdEx + msglen
6049 if postIndex < 0 {
6050 return ErrInvalidLengthGenerated
6051 }
6052 if postIndex > l {
6053 return io.ErrUnexpectedEOF
6054 }
6055 if m.RollingUpdate == nil {
6056 m.RollingUpdate = &RollingUpdateDeployment{}
6057 }
6058 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6059 return err
6060 }
6061 iNdEx = postIndex
6062 default:
6063 iNdEx = preIndex
6064 skippy, err := skipGenerated(dAtA[iNdEx:])
6065 if err != nil {
6066 return err
6067 }
6068 if (skippy < 0) || (iNdEx+skippy) < 0 {
6069 return ErrInvalidLengthGenerated
6070 }
6071 if (iNdEx + skippy) > l {
6072 return io.ErrUnexpectedEOF
6073 }
6074 iNdEx += skippy
6075 }
6076 }
6077
6078 if iNdEx > l {
6079 return io.ErrUnexpectedEOF
6080 }
6081 return nil
6082 }
6083 func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
6084 l := len(dAtA)
6085 iNdEx := 0
6086 for iNdEx < l {
6087 preIndex := iNdEx
6088 var wire uint64
6089 for shift := uint(0); ; shift += 7 {
6090 if shift >= 64 {
6091 return ErrIntOverflowGenerated
6092 }
6093 if iNdEx >= l {
6094 return io.ErrUnexpectedEOF
6095 }
6096 b := dAtA[iNdEx]
6097 iNdEx++
6098 wire |= uint64(b&0x7F) << shift
6099 if b < 0x80 {
6100 break
6101 }
6102 }
6103 fieldNum := int32(wire >> 3)
6104 wireType := int(wire & 0x7)
6105 if wireType == 4 {
6106 return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
6107 }
6108 if fieldNum <= 0 {
6109 return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
6110 }
6111 switch fieldNum {
6112 case 1:
6113 if wireType != 2 {
6114 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
6115 }
6116 var msglen int
6117 for shift := uint(0); ; shift += 7 {
6118 if shift >= 64 {
6119 return ErrIntOverflowGenerated
6120 }
6121 if iNdEx >= l {
6122 return io.ErrUnexpectedEOF
6123 }
6124 b := dAtA[iNdEx]
6125 iNdEx++
6126 msglen |= int(b&0x7F) << shift
6127 if b < 0x80 {
6128 break
6129 }
6130 }
6131 if msglen < 0 {
6132 return ErrInvalidLengthGenerated
6133 }
6134 postIndex := iNdEx + msglen
6135 if postIndex < 0 {
6136 return ErrInvalidLengthGenerated
6137 }
6138 if postIndex > l {
6139 return io.ErrUnexpectedEOF
6140 }
6141 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6142 return err
6143 }
6144 iNdEx = postIndex
6145 case 2:
6146 if wireType != 2 {
6147 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
6148 }
6149 var msglen int
6150 for shift := uint(0); ; shift += 7 {
6151 if shift >= 64 {
6152 return ErrIntOverflowGenerated
6153 }
6154 if iNdEx >= l {
6155 return io.ErrUnexpectedEOF
6156 }
6157 b := dAtA[iNdEx]
6158 iNdEx++
6159 msglen |= int(b&0x7F) << shift
6160 if b < 0x80 {
6161 break
6162 }
6163 }
6164 if msglen < 0 {
6165 return ErrInvalidLengthGenerated
6166 }
6167 postIndex := iNdEx + msglen
6168 if postIndex < 0 {
6169 return ErrInvalidLengthGenerated
6170 }
6171 if postIndex > l {
6172 return io.ErrUnexpectedEOF
6173 }
6174 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6175 return err
6176 }
6177 iNdEx = postIndex
6178 case 3:
6179 if wireType != 2 {
6180 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
6181 }
6182 var msglen int
6183 for shift := uint(0); ; shift += 7 {
6184 if shift >= 64 {
6185 return ErrIntOverflowGenerated
6186 }
6187 if iNdEx >= l {
6188 return io.ErrUnexpectedEOF
6189 }
6190 b := dAtA[iNdEx]
6191 iNdEx++
6192 msglen |= int(b&0x7F) << shift
6193 if b < 0x80 {
6194 break
6195 }
6196 }
6197 if msglen < 0 {
6198 return ErrInvalidLengthGenerated
6199 }
6200 postIndex := iNdEx + msglen
6201 if postIndex < 0 {
6202 return ErrInvalidLengthGenerated
6203 }
6204 if postIndex > l {
6205 return io.ErrUnexpectedEOF
6206 }
6207 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6208 return err
6209 }
6210 iNdEx = postIndex
6211 default:
6212 iNdEx = preIndex
6213 skippy, err := skipGenerated(dAtA[iNdEx:])
6214 if err != nil {
6215 return err
6216 }
6217 if (skippy < 0) || (iNdEx+skippy) < 0 {
6218 return ErrInvalidLengthGenerated
6219 }
6220 if (iNdEx + skippy) > l {
6221 return io.ErrUnexpectedEOF
6222 }
6223 iNdEx += skippy
6224 }
6225 }
6226
6227 if iNdEx > l {
6228 return io.ErrUnexpectedEOF
6229 }
6230 return nil
6231 }
6232 func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
6233 l := len(dAtA)
6234 iNdEx := 0
6235 for iNdEx < l {
6236 preIndex := iNdEx
6237 var wire uint64
6238 for shift := uint(0); ; shift += 7 {
6239 if shift >= 64 {
6240 return ErrIntOverflowGenerated
6241 }
6242 if iNdEx >= l {
6243 return io.ErrUnexpectedEOF
6244 }
6245 b := dAtA[iNdEx]
6246 iNdEx++
6247 wire |= uint64(b&0x7F) << shift
6248 if b < 0x80 {
6249 break
6250 }
6251 }
6252 fieldNum := int32(wire >> 3)
6253 wireType := int(wire & 0x7)
6254 if wireType == 4 {
6255 return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
6256 }
6257 if fieldNum <= 0 {
6258 return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
6259 }
6260 switch fieldNum {
6261 case 1:
6262 if wireType != 2 {
6263 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
6264 }
6265 var stringLen uint64
6266 for shift := uint(0); ; shift += 7 {
6267 if shift >= 64 {
6268 return ErrIntOverflowGenerated
6269 }
6270 if iNdEx >= l {
6271 return io.ErrUnexpectedEOF
6272 }
6273 b := dAtA[iNdEx]
6274 iNdEx++
6275 stringLen |= uint64(b&0x7F) << shift
6276 if b < 0x80 {
6277 break
6278 }
6279 }
6280 intStringLen := int(stringLen)
6281 if intStringLen < 0 {
6282 return ErrInvalidLengthGenerated
6283 }
6284 postIndex := iNdEx + intStringLen
6285 if postIndex < 0 {
6286 return ErrInvalidLengthGenerated
6287 }
6288 if postIndex > l {
6289 return io.ErrUnexpectedEOF
6290 }
6291 m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex])
6292 iNdEx = postIndex
6293 case 2:
6294 if wireType != 2 {
6295 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
6296 }
6297 var stringLen uint64
6298 for shift := uint(0); ; shift += 7 {
6299 if shift >= 64 {
6300 return ErrIntOverflowGenerated
6301 }
6302 if iNdEx >= l {
6303 return io.ErrUnexpectedEOF
6304 }
6305 b := dAtA[iNdEx]
6306 iNdEx++
6307 stringLen |= uint64(b&0x7F) << shift
6308 if b < 0x80 {
6309 break
6310 }
6311 }
6312 intStringLen := int(stringLen)
6313 if intStringLen < 0 {
6314 return ErrInvalidLengthGenerated
6315 }
6316 postIndex := iNdEx + intStringLen
6317 if postIndex < 0 {
6318 return ErrInvalidLengthGenerated
6319 }
6320 if postIndex > l {
6321 return io.ErrUnexpectedEOF
6322 }
6323 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
6324 iNdEx = postIndex
6325 case 3:
6326 if wireType != 2 {
6327 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
6328 }
6329 var msglen int
6330 for shift := uint(0); ; shift += 7 {
6331 if shift >= 64 {
6332 return ErrIntOverflowGenerated
6333 }
6334 if iNdEx >= l {
6335 return io.ErrUnexpectedEOF
6336 }
6337 b := dAtA[iNdEx]
6338 iNdEx++
6339 msglen |= int(b&0x7F) << shift
6340 if b < 0x80 {
6341 break
6342 }
6343 }
6344 if msglen < 0 {
6345 return ErrInvalidLengthGenerated
6346 }
6347 postIndex := iNdEx + msglen
6348 if postIndex < 0 {
6349 return ErrInvalidLengthGenerated
6350 }
6351 if postIndex > l {
6352 return io.ErrUnexpectedEOF
6353 }
6354 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6355 return err
6356 }
6357 iNdEx = postIndex
6358 case 4:
6359 if wireType != 2 {
6360 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
6361 }
6362 var stringLen uint64
6363 for shift := uint(0); ; shift += 7 {
6364 if shift >= 64 {
6365 return ErrIntOverflowGenerated
6366 }
6367 if iNdEx >= l {
6368 return io.ErrUnexpectedEOF
6369 }
6370 b := dAtA[iNdEx]
6371 iNdEx++
6372 stringLen |= uint64(b&0x7F) << shift
6373 if b < 0x80 {
6374 break
6375 }
6376 }
6377 intStringLen := int(stringLen)
6378 if intStringLen < 0 {
6379 return ErrInvalidLengthGenerated
6380 }
6381 postIndex := iNdEx + intStringLen
6382 if postIndex < 0 {
6383 return ErrInvalidLengthGenerated
6384 }
6385 if postIndex > l {
6386 return io.ErrUnexpectedEOF
6387 }
6388 m.Reason = string(dAtA[iNdEx:postIndex])
6389 iNdEx = postIndex
6390 case 5:
6391 if wireType != 2 {
6392 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
6393 }
6394 var stringLen uint64
6395 for shift := uint(0); ; shift += 7 {
6396 if shift >= 64 {
6397 return ErrIntOverflowGenerated
6398 }
6399 if iNdEx >= l {
6400 return io.ErrUnexpectedEOF
6401 }
6402 b := dAtA[iNdEx]
6403 iNdEx++
6404 stringLen |= uint64(b&0x7F) << shift
6405 if b < 0x80 {
6406 break
6407 }
6408 }
6409 intStringLen := int(stringLen)
6410 if intStringLen < 0 {
6411 return ErrInvalidLengthGenerated
6412 }
6413 postIndex := iNdEx + intStringLen
6414 if postIndex < 0 {
6415 return ErrInvalidLengthGenerated
6416 }
6417 if postIndex > l {
6418 return io.ErrUnexpectedEOF
6419 }
6420 m.Message = string(dAtA[iNdEx:postIndex])
6421 iNdEx = postIndex
6422 default:
6423 iNdEx = preIndex
6424 skippy, err := skipGenerated(dAtA[iNdEx:])
6425 if err != nil {
6426 return err
6427 }
6428 if (skippy < 0) || (iNdEx+skippy) < 0 {
6429 return ErrInvalidLengthGenerated
6430 }
6431 if (iNdEx + skippy) > l {
6432 return io.ErrUnexpectedEOF
6433 }
6434 iNdEx += skippy
6435 }
6436 }
6437
6438 if iNdEx > l {
6439 return io.ErrUnexpectedEOF
6440 }
6441 return nil
6442 }
6443 func (m *ReplicaSetList) Unmarshal(dAtA []byte) error {
6444 l := len(dAtA)
6445 iNdEx := 0
6446 for iNdEx < l {
6447 preIndex := iNdEx
6448 var wire uint64
6449 for shift := uint(0); ; shift += 7 {
6450 if shift >= 64 {
6451 return ErrIntOverflowGenerated
6452 }
6453 if iNdEx >= l {
6454 return io.ErrUnexpectedEOF
6455 }
6456 b := dAtA[iNdEx]
6457 iNdEx++
6458 wire |= uint64(b&0x7F) << shift
6459 if b < 0x80 {
6460 break
6461 }
6462 }
6463 fieldNum := int32(wire >> 3)
6464 wireType := int(wire & 0x7)
6465 if wireType == 4 {
6466 return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
6467 }
6468 if fieldNum <= 0 {
6469 return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
6470 }
6471 switch fieldNum {
6472 case 1:
6473 if wireType != 2 {
6474 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
6475 }
6476 var msglen int
6477 for shift := uint(0); ; shift += 7 {
6478 if shift >= 64 {
6479 return ErrIntOverflowGenerated
6480 }
6481 if iNdEx >= l {
6482 return io.ErrUnexpectedEOF
6483 }
6484 b := dAtA[iNdEx]
6485 iNdEx++
6486 msglen |= int(b&0x7F) << shift
6487 if b < 0x80 {
6488 break
6489 }
6490 }
6491 if msglen < 0 {
6492 return ErrInvalidLengthGenerated
6493 }
6494 postIndex := iNdEx + msglen
6495 if postIndex < 0 {
6496 return ErrInvalidLengthGenerated
6497 }
6498 if postIndex > l {
6499 return io.ErrUnexpectedEOF
6500 }
6501 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6502 return err
6503 }
6504 iNdEx = postIndex
6505 case 2:
6506 if wireType != 2 {
6507 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
6508 }
6509 var msglen int
6510 for shift := uint(0); ; shift += 7 {
6511 if shift >= 64 {
6512 return ErrIntOverflowGenerated
6513 }
6514 if iNdEx >= l {
6515 return io.ErrUnexpectedEOF
6516 }
6517 b := dAtA[iNdEx]
6518 iNdEx++
6519 msglen |= int(b&0x7F) << shift
6520 if b < 0x80 {
6521 break
6522 }
6523 }
6524 if msglen < 0 {
6525 return ErrInvalidLengthGenerated
6526 }
6527 postIndex := iNdEx + msglen
6528 if postIndex < 0 {
6529 return ErrInvalidLengthGenerated
6530 }
6531 if postIndex > l {
6532 return io.ErrUnexpectedEOF
6533 }
6534 m.Items = append(m.Items, ReplicaSet{})
6535 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6536 return err
6537 }
6538 iNdEx = postIndex
6539 default:
6540 iNdEx = preIndex
6541 skippy, err := skipGenerated(dAtA[iNdEx:])
6542 if err != nil {
6543 return err
6544 }
6545 if (skippy < 0) || (iNdEx+skippy) < 0 {
6546 return ErrInvalidLengthGenerated
6547 }
6548 if (iNdEx + skippy) > l {
6549 return io.ErrUnexpectedEOF
6550 }
6551 iNdEx += skippy
6552 }
6553 }
6554
6555 if iNdEx > l {
6556 return io.ErrUnexpectedEOF
6557 }
6558 return nil
6559 }
6560 func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
6561 l := len(dAtA)
6562 iNdEx := 0
6563 for iNdEx < l {
6564 preIndex := iNdEx
6565 var wire uint64
6566 for shift := uint(0); ; shift += 7 {
6567 if shift >= 64 {
6568 return ErrIntOverflowGenerated
6569 }
6570 if iNdEx >= l {
6571 return io.ErrUnexpectedEOF
6572 }
6573 b := dAtA[iNdEx]
6574 iNdEx++
6575 wire |= uint64(b&0x7F) << shift
6576 if b < 0x80 {
6577 break
6578 }
6579 }
6580 fieldNum := int32(wire >> 3)
6581 wireType := int(wire & 0x7)
6582 if wireType == 4 {
6583 return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
6584 }
6585 if fieldNum <= 0 {
6586 return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
6587 }
6588 switch fieldNum {
6589 case 1:
6590 if wireType != 0 {
6591 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6592 }
6593 var v int32
6594 for shift := uint(0); ; shift += 7 {
6595 if shift >= 64 {
6596 return ErrIntOverflowGenerated
6597 }
6598 if iNdEx >= l {
6599 return io.ErrUnexpectedEOF
6600 }
6601 b := dAtA[iNdEx]
6602 iNdEx++
6603 v |= int32(b&0x7F) << shift
6604 if b < 0x80 {
6605 break
6606 }
6607 }
6608 m.Replicas = &v
6609 case 2:
6610 if wireType != 2 {
6611 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
6612 }
6613 var msglen int
6614 for shift := uint(0); ; shift += 7 {
6615 if shift >= 64 {
6616 return ErrIntOverflowGenerated
6617 }
6618 if iNdEx >= l {
6619 return io.ErrUnexpectedEOF
6620 }
6621 b := dAtA[iNdEx]
6622 iNdEx++
6623 msglen |= int(b&0x7F) << shift
6624 if b < 0x80 {
6625 break
6626 }
6627 }
6628 if msglen < 0 {
6629 return ErrInvalidLengthGenerated
6630 }
6631 postIndex := iNdEx + msglen
6632 if postIndex < 0 {
6633 return ErrInvalidLengthGenerated
6634 }
6635 if postIndex > l {
6636 return io.ErrUnexpectedEOF
6637 }
6638 if m.Selector == nil {
6639 m.Selector = &v1.LabelSelector{}
6640 }
6641 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6642 return err
6643 }
6644 iNdEx = postIndex
6645 case 3:
6646 if wireType != 2 {
6647 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
6648 }
6649 var msglen int
6650 for shift := uint(0); ; shift += 7 {
6651 if shift >= 64 {
6652 return ErrIntOverflowGenerated
6653 }
6654 if iNdEx >= l {
6655 return io.ErrUnexpectedEOF
6656 }
6657 b := dAtA[iNdEx]
6658 iNdEx++
6659 msglen |= int(b&0x7F) << shift
6660 if b < 0x80 {
6661 break
6662 }
6663 }
6664 if msglen < 0 {
6665 return ErrInvalidLengthGenerated
6666 }
6667 postIndex := iNdEx + msglen
6668 if postIndex < 0 {
6669 return ErrInvalidLengthGenerated
6670 }
6671 if postIndex > l {
6672 return io.ErrUnexpectedEOF
6673 }
6674 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6675 return err
6676 }
6677 iNdEx = postIndex
6678 case 4:
6679 if wireType != 0 {
6680 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
6681 }
6682 m.MinReadySeconds = 0
6683 for shift := uint(0); ; shift += 7 {
6684 if shift >= 64 {
6685 return ErrIntOverflowGenerated
6686 }
6687 if iNdEx >= l {
6688 return io.ErrUnexpectedEOF
6689 }
6690 b := dAtA[iNdEx]
6691 iNdEx++
6692 m.MinReadySeconds |= int32(b&0x7F) << shift
6693 if b < 0x80 {
6694 break
6695 }
6696 }
6697 default:
6698 iNdEx = preIndex
6699 skippy, err := skipGenerated(dAtA[iNdEx:])
6700 if err != nil {
6701 return err
6702 }
6703 if (skippy < 0) || (iNdEx+skippy) < 0 {
6704 return ErrInvalidLengthGenerated
6705 }
6706 if (iNdEx + skippy) > l {
6707 return io.ErrUnexpectedEOF
6708 }
6709 iNdEx += skippy
6710 }
6711 }
6712
6713 if iNdEx > l {
6714 return io.ErrUnexpectedEOF
6715 }
6716 return nil
6717 }
6718 func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
6719 l := len(dAtA)
6720 iNdEx := 0
6721 for iNdEx < l {
6722 preIndex := iNdEx
6723 var wire uint64
6724 for shift := uint(0); ; shift += 7 {
6725 if shift >= 64 {
6726 return ErrIntOverflowGenerated
6727 }
6728 if iNdEx >= l {
6729 return io.ErrUnexpectedEOF
6730 }
6731 b := dAtA[iNdEx]
6732 iNdEx++
6733 wire |= uint64(b&0x7F) << shift
6734 if b < 0x80 {
6735 break
6736 }
6737 }
6738 fieldNum := int32(wire >> 3)
6739 wireType := int(wire & 0x7)
6740 if wireType == 4 {
6741 return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
6742 }
6743 if fieldNum <= 0 {
6744 return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6745 }
6746 switch fieldNum {
6747 case 1:
6748 if wireType != 0 {
6749 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6750 }
6751 m.Replicas = 0
6752 for shift := uint(0); ; shift += 7 {
6753 if shift >= 64 {
6754 return ErrIntOverflowGenerated
6755 }
6756 if iNdEx >= l {
6757 return io.ErrUnexpectedEOF
6758 }
6759 b := dAtA[iNdEx]
6760 iNdEx++
6761 m.Replicas |= int32(b&0x7F) << shift
6762 if b < 0x80 {
6763 break
6764 }
6765 }
6766 case 2:
6767 if wireType != 0 {
6768 return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
6769 }
6770 m.FullyLabeledReplicas = 0
6771 for shift := uint(0); ; shift += 7 {
6772 if shift >= 64 {
6773 return ErrIntOverflowGenerated
6774 }
6775 if iNdEx >= l {
6776 return io.ErrUnexpectedEOF
6777 }
6778 b := dAtA[iNdEx]
6779 iNdEx++
6780 m.FullyLabeledReplicas |= int32(b&0x7F) << shift
6781 if b < 0x80 {
6782 break
6783 }
6784 }
6785 case 3:
6786 if wireType != 0 {
6787 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
6788 }
6789 m.ObservedGeneration = 0
6790 for shift := uint(0); ; shift += 7 {
6791 if shift >= 64 {
6792 return ErrIntOverflowGenerated
6793 }
6794 if iNdEx >= l {
6795 return io.ErrUnexpectedEOF
6796 }
6797 b := dAtA[iNdEx]
6798 iNdEx++
6799 m.ObservedGeneration |= int64(b&0x7F) << shift
6800 if b < 0x80 {
6801 break
6802 }
6803 }
6804 case 4:
6805 if wireType != 0 {
6806 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
6807 }
6808 m.ReadyReplicas = 0
6809 for shift := uint(0); ; shift += 7 {
6810 if shift >= 64 {
6811 return ErrIntOverflowGenerated
6812 }
6813 if iNdEx >= l {
6814 return io.ErrUnexpectedEOF
6815 }
6816 b := dAtA[iNdEx]
6817 iNdEx++
6818 m.ReadyReplicas |= int32(b&0x7F) << shift
6819 if b < 0x80 {
6820 break
6821 }
6822 }
6823 case 5:
6824 if wireType != 0 {
6825 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
6826 }
6827 m.AvailableReplicas = 0
6828 for shift := uint(0); ; shift += 7 {
6829 if shift >= 64 {
6830 return ErrIntOverflowGenerated
6831 }
6832 if iNdEx >= l {
6833 return io.ErrUnexpectedEOF
6834 }
6835 b := dAtA[iNdEx]
6836 iNdEx++
6837 m.AvailableReplicas |= int32(b&0x7F) << shift
6838 if b < 0x80 {
6839 break
6840 }
6841 }
6842 case 6:
6843 if wireType != 2 {
6844 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
6845 }
6846 var msglen int
6847 for shift := uint(0); ; shift += 7 {
6848 if shift >= 64 {
6849 return ErrIntOverflowGenerated
6850 }
6851 if iNdEx >= l {
6852 return io.ErrUnexpectedEOF
6853 }
6854 b := dAtA[iNdEx]
6855 iNdEx++
6856 msglen |= int(b&0x7F) << shift
6857 if b < 0x80 {
6858 break
6859 }
6860 }
6861 if msglen < 0 {
6862 return ErrInvalidLengthGenerated
6863 }
6864 postIndex := iNdEx + msglen
6865 if postIndex < 0 {
6866 return ErrInvalidLengthGenerated
6867 }
6868 if postIndex > l {
6869 return io.ErrUnexpectedEOF
6870 }
6871 m.Conditions = append(m.Conditions, ReplicaSetCondition{})
6872 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6873 return err
6874 }
6875 iNdEx = postIndex
6876 default:
6877 iNdEx = preIndex
6878 skippy, err := skipGenerated(dAtA[iNdEx:])
6879 if err != nil {
6880 return err
6881 }
6882 if (skippy < 0) || (iNdEx+skippy) < 0 {
6883 return ErrInvalidLengthGenerated
6884 }
6885 if (iNdEx + skippy) > l {
6886 return io.ErrUnexpectedEOF
6887 }
6888 iNdEx += skippy
6889 }
6890 }
6891
6892 if iNdEx > l {
6893 return io.ErrUnexpectedEOF
6894 }
6895 return nil
6896 }
6897 func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
6898 l := len(dAtA)
6899 iNdEx := 0
6900 for iNdEx < l {
6901 preIndex := iNdEx
6902 var wire uint64
6903 for shift := uint(0); ; shift += 7 {
6904 if shift >= 64 {
6905 return ErrIntOverflowGenerated
6906 }
6907 if iNdEx >= l {
6908 return io.ErrUnexpectedEOF
6909 }
6910 b := dAtA[iNdEx]
6911 iNdEx++
6912 wire |= uint64(b&0x7F) << shift
6913 if b < 0x80 {
6914 break
6915 }
6916 }
6917 fieldNum := int32(wire >> 3)
6918 wireType := int(wire & 0x7)
6919 if wireType == 4 {
6920 return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group")
6921 }
6922 if fieldNum <= 0 {
6923 return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
6924 }
6925 switch fieldNum {
6926 case 1:
6927 if wireType != 2 {
6928 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
6929 }
6930 var msglen int
6931 for shift := uint(0); ; shift += 7 {
6932 if shift >= 64 {
6933 return ErrIntOverflowGenerated
6934 }
6935 if iNdEx >= l {
6936 return io.ErrUnexpectedEOF
6937 }
6938 b := dAtA[iNdEx]
6939 iNdEx++
6940 msglen |= int(b&0x7F) << shift
6941 if b < 0x80 {
6942 break
6943 }
6944 }
6945 if msglen < 0 {
6946 return ErrInvalidLengthGenerated
6947 }
6948 postIndex := iNdEx + msglen
6949 if postIndex < 0 {
6950 return ErrInvalidLengthGenerated
6951 }
6952 if postIndex > l {
6953 return io.ErrUnexpectedEOF
6954 }
6955 if m.MaxUnavailable == nil {
6956 m.MaxUnavailable = &intstr.IntOrString{}
6957 }
6958 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6959 return err
6960 }
6961 iNdEx = postIndex
6962 case 2:
6963 if wireType != 2 {
6964 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
6965 }
6966 var msglen int
6967 for shift := uint(0); ; shift += 7 {
6968 if shift >= 64 {
6969 return ErrIntOverflowGenerated
6970 }
6971 if iNdEx >= l {
6972 return io.ErrUnexpectedEOF
6973 }
6974 b := dAtA[iNdEx]
6975 iNdEx++
6976 msglen |= int(b&0x7F) << shift
6977 if b < 0x80 {
6978 break
6979 }
6980 }
6981 if msglen < 0 {
6982 return ErrInvalidLengthGenerated
6983 }
6984 postIndex := iNdEx + msglen
6985 if postIndex < 0 {
6986 return ErrInvalidLengthGenerated
6987 }
6988 if postIndex > l {
6989 return io.ErrUnexpectedEOF
6990 }
6991 if m.MaxSurge == nil {
6992 m.MaxSurge = &intstr.IntOrString{}
6993 }
6994 if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6995 return err
6996 }
6997 iNdEx = postIndex
6998 default:
6999 iNdEx = preIndex
7000 skippy, err := skipGenerated(dAtA[iNdEx:])
7001 if err != nil {
7002 return err
7003 }
7004 if (skippy < 0) || (iNdEx+skippy) < 0 {
7005 return ErrInvalidLengthGenerated
7006 }
7007 if (iNdEx + skippy) > l {
7008 return io.ErrUnexpectedEOF
7009 }
7010 iNdEx += skippy
7011 }
7012 }
7013
7014 if iNdEx > l {
7015 return io.ErrUnexpectedEOF
7016 }
7017 return nil
7018 }
7019 func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
7020 l := len(dAtA)
7021 iNdEx := 0
7022 for iNdEx < l {
7023 preIndex := iNdEx
7024 var wire uint64
7025 for shift := uint(0); ; shift += 7 {
7026 if shift >= 64 {
7027 return ErrIntOverflowGenerated
7028 }
7029 if iNdEx >= l {
7030 return io.ErrUnexpectedEOF
7031 }
7032 b := dAtA[iNdEx]
7033 iNdEx++
7034 wire |= uint64(b&0x7F) << shift
7035 if b < 0x80 {
7036 break
7037 }
7038 }
7039 fieldNum := int32(wire >> 3)
7040 wireType := int(wire & 0x7)
7041 if wireType == 4 {
7042 return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
7043 }
7044 if fieldNum <= 0 {
7045 return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
7046 }
7047 switch fieldNum {
7048 case 1:
7049 if wireType != 2 {
7050 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
7051 }
7052 var msglen int
7053 for shift := uint(0); ; shift += 7 {
7054 if shift >= 64 {
7055 return ErrIntOverflowGenerated
7056 }
7057 if iNdEx >= l {
7058 return io.ErrUnexpectedEOF
7059 }
7060 b := dAtA[iNdEx]
7061 iNdEx++
7062 msglen |= int(b&0x7F) << shift
7063 if b < 0x80 {
7064 break
7065 }
7066 }
7067 if msglen < 0 {
7068 return ErrInvalidLengthGenerated
7069 }
7070 postIndex := iNdEx + msglen
7071 if postIndex < 0 {
7072 return ErrInvalidLengthGenerated
7073 }
7074 if postIndex > l {
7075 return io.ErrUnexpectedEOF
7076 }
7077 if m.MaxUnavailable == nil {
7078 m.MaxUnavailable = &intstr.IntOrString{}
7079 }
7080 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7081 return err
7082 }
7083 iNdEx = postIndex
7084 case 2:
7085 if wireType != 2 {
7086 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
7087 }
7088 var msglen int
7089 for shift := uint(0); ; shift += 7 {
7090 if shift >= 64 {
7091 return ErrIntOverflowGenerated
7092 }
7093 if iNdEx >= l {
7094 return io.ErrUnexpectedEOF
7095 }
7096 b := dAtA[iNdEx]
7097 iNdEx++
7098 msglen |= int(b&0x7F) << shift
7099 if b < 0x80 {
7100 break
7101 }
7102 }
7103 if msglen < 0 {
7104 return ErrInvalidLengthGenerated
7105 }
7106 postIndex := iNdEx + msglen
7107 if postIndex < 0 {
7108 return ErrInvalidLengthGenerated
7109 }
7110 if postIndex > l {
7111 return io.ErrUnexpectedEOF
7112 }
7113 if m.MaxSurge == nil {
7114 m.MaxSurge = &intstr.IntOrString{}
7115 }
7116 if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7117 return err
7118 }
7119 iNdEx = postIndex
7120 default:
7121 iNdEx = preIndex
7122 skippy, err := skipGenerated(dAtA[iNdEx:])
7123 if err != nil {
7124 return err
7125 }
7126 if (skippy < 0) || (iNdEx+skippy) < 0 {
7127 return ErrInvalidLengthGenerated
7128 }
7129 if (iNdEx + skippy) > l {
7130 return io.ErrUnexpectedEOF
7131 }
7132 iNdEx += skippy
7133 }
7134 }
7135
7136 if iNdEx > l {
7137 return io.ErrUnexpectedEOF
7138 }
7139 return nil
7140 }
7141 func (m *RollingUpdateStatefulSetStrategy) Unmarshal(dAtA []byte) error {
7142 l := len(dAtA)
7143 iNdEx := 0
7144 for iNdEx < l {
7145 preIndex := iNdEx
7146 var wire uint64
7147 for shift := uint(0); ; shift += 7 {
7148 if shift >= 64 {
7149 return ErrIntOverflowGenerated
7150 }
7151 if iNdEx >= l {
7152 return io.ErrUnexpectedEOF
7153 }
7154 b := dAtA[iNdEx]
7155 iNdEx++
7156 wire |= uint64(b&0x7F) << shift
7157 if b < 0x80 {
7158 break
7159 }
7160 }
7161 fieldNum := int32(wire >> 3)
7162 wireType := int(wire & 0x7)
7163 if wireType == 4 {
7164 return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: wiretype end group for non-group")
7165 }
7166 if fieldNum <= 0 {
7167 return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
7168 }
7169 switch fieldNum {
7170 case 1:
7171 if wireType != 0 {
7172 return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
7173 }
7174 var v int32
7175 for shift := uint(0); ; shift += 7 {
7176 if shift >= 64 {
7177 return ErrIntOverflowGenerated
7178 }
7179 if iNdEx >= l {
7180 return io.ErrUnexpectedEOF
7181 }
7182 b := dAtA[iNdEx]
7183 iNdEx++
7184 v |= int32(b&0x7F) << shift
7185 if b < 0x80 {
7186 break
7187 }
7188 }
7189 m.Partition = &v
7190 case 2:
7191 if wireType != 2 {
7192 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
7193 }
7194 var msglen int
7195 for shift := uint(0); ; shift += 7 {
7196 if shift >= 64 {
7197 return ErrIntOverflowGenerated
7198 }
7199 if iNdEx >= l {
7200 return io.ErrUnexpectedEOF
7201 }
7202 b := dAtA[iNdEx]
7203 iNdEx++
7204 msglen |= int(b&0x7F) << shift
7205 if b < 0x80 {
7206 break
7207 }
7208 }
7209 if msglen < 0 {
7210 return ErrInvalidLengthGenerated
7211 }
7212 postIndex := iNdEx + msglen
7213 if postIndex < 0 {
7214 return ErrInvalidLengthGenerated
7215 }
7216 if postIndex > l {
7217 return io.ErrUnexpectedEOF
7218 }
7219 if m.MaxUnavailable == nil {
7220 m.MaxUnavailable = &intstr.IntOrString{}
7221 }
7222 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7223 return err
7224 }
7225 iNdEx = postIndex
7226 default:
7227 iNdEx = preIndex
7228 skippy, err := skipGenerated(dAtA[iNdEx:])
7229 if err != nil {
7230 return err
7231 }
7232 if (skippy < 0) || (iNdEx+skippy) < 0 {
7233 return ErrInvalidLengthGenerated
7234 }
7235 if (iNdEx + skippy) > l {
7236 return io.ErrUnexpectedEOF
7237 }
7238 iNdEx += skippy
7239 }
7240 }
7241
7242 if iNdEx > l {
7243 return io.ErrUnexpectedEOF
7244 }
7245 return nil
7246 }
7247 func (m *StatefulSet) Unmarshal(dAtA []byte) error {
7248 l := len(dAtA)
7249 iNdEx := 0
7250 for iNdEx < l {
7251 preIndex := iNdEx
7252 var wire uint64
7253 for shift := uint(0); ; shift += 7 {
7254 if shift >= 64 {
7255 return ErrIntOverflowGenerated
7256 }
7257 if iNdEx >= l {
7258 return io.ErrUnexpectedEOF
7259 }
7260 b := dAtA[iNdEx]
7261 iNdEx++
7262 wire |= uint64(b&0x7F) << shift
7263 if b < 0x80 {
7264 break
7265 }
7266 }
7267 fieldNum := int32(wire >> 3)
7268 wireType := int(wire & 0x7)
7269 if wireType == 4 {
7270 return fmt.Errorf("proto: StatefulSet: wiretype end group for non-group")
7271 }
7272 if fieldNum <= 0 {
7273 return fmt.Errorf("proto: StatefulSet: illegal tag %d (wire type %d)", fieldNum, wire)
7274 }
7275 switch fieldNum {
7276 case 1:
7277 if wireType != 2 {
7278 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
7279 }
7280 var msglen int
7281 for shift := uint(0); ; shift += 7 {
7282 if shift >= 64 {
7283 return ErrIntOverflowGenerated
7284 }
7285 if iNdEx >= l {
7286 return io.ErrUnexpectedEOF
7287 }
7288 b := dAtA[iNdEx]
7289 iNdEx++
7290 msglen |= int(b&0x7F) << shift
7291 if b < 0x80 {
7292 break
7293 }
7294 }
7295 if msglen < 0 {
7296 return ErrInvalidLengthGenerated
7297 }
7298 postIndex := iNdEx + msglen
7299 if postIndex < 0 {
7300 return ErrInvalidLengthGenerated
7301 }
7302 if postIndex > l {
7303 return io.ErrUnexpectedEOF
7304 }
7305 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7306 return err
7307 }
7308 iNdEx = postIndex
7309 case 2:
7310 if wireType != 2 {
7311 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
7312 }
7313 var msglen int
7314 for shift := uint(0); ; shift += 7 {
7315 if shift >= 64 {
7316 return ErrIntOverflowGenerated
7317 }
7318 if iNdEx >= l {
7319 return io.ErrUnexpectedEOF
7320 }
7321 b := dAtA[iNdEx]
7322 iNdEx++
7323 msglen |= int(b&0x7F) << shift
7324 if b < 0x80 {
7325 break
7326 }
7327 }
7328 if msglen < 0 {
7329 return ErrInvalidLengthGenerated
7330 }
7331 postIndex := iNdEx + msglen
7332 if postIndex < 0 {
7333 return ErrInvalidLengthGenerated
7334 }
7335 if postIndex > l {
7336 return io.ErrUnexpectedEOF
7337 }
7338 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7339 return err
7340 }
7341 iNdEx = postIndex
7342 case 3:
7343 if wireType != 2 {
7344 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7345 }
7346 var msglen int
7347 for shift := uint(0); ; shift += 7 {
7348 if shift >= 64 {
7349 return ErrIntOverflowGenerated
7350 }
7351 if iNdEx >= l {
7352 return io.ErrUnexpectedEOF
7353 }
7354 b := dAtA[iNdEx]
7355 iNdEx++
7356 msglen |= int(b&0x7F) << shift
7357 if b < 0x80 {
7358 break
7359 }
7360 }
7361 if msglen < 0 {
7362 return ErrInvalidLengthGenerated
7363 }
7364 postIndex := iNdEx + msglen
7365 if postIndex < 0 {
7366 return ErrInvalidLengthGenerated
7367 }
7368 if postIndex > l {
7369 return io.ErrUnexpectedEOF
7370 }
7371 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7372 return err
7373 }
7374 iNdEx = postIndex
7375 default:
7376 iNdEx = preIndex
7377 skippy, err := skipGenerated(dAtA[iNdEx:])
7378 if err != nil {
7379 return err
7380 }
7381 if (skippy < 0) || (iNdEx+skippy) < 0 {
7382 return ErrInvalidLengthGenerated
7383 }
7384 if (iNdEx + skippy) > l {
7385 return io.ErrUnexpectedEOF
7386 }
7387 iNdEx += skippy
7388 }
7389 }
7390
7391 if iNdEx > l {
7392 return io.ErrUnexpectedEOF
7393 }
7394 return nil
7395 }
7396 func (m *StatefulSetCondition) Unmarshal(dAtA []byte) error {
7397 l := len(dAtA)
7398 iNdEx := 0
7399 for iNdEx < l {
7400 preIndex := iNdEx
7401 var wire uint64
7402 for shift := uint(0); ; shift += 7 {
7403 if shift >= 64 {
7404 return ErrIntOverflowGenerated
7405 }
7406 if iNdEx >= l {
7407 return io.ErrUnexpectedEOF
7408 }
7409 b := dAtA[iNdEx]
7410 iNdEx++
7411 wire |= uint64(b&0x7F) << shift
7412 if b < 0x80 {
7413 break
7414 }
7415 }
7416 fieldNum := int32(wire >> 3)
7417 wireType := int(wire & 0x7)
7418 if wireType == 4 {
7419 return fmt.Errorf("proto: StatefulSetCondition: wiretype end group for non-group")
7420 }
7421 if fieldNum <= 0 {
7422 return fmt.Errorf("proto: StatefulSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
7423 }
7424 switch fieldNum {
7425 case 1:
7426 if wireType != 2 {
7427 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7428 }
7429 var stringLen uint64
7430 for shift := uint(0); ; shift += 7 {
7431 if shift >= 64 {
7432 return ErrIntOverflowGenerated
7433 }
7434 if iNdEx >= l {
7435 return io.ErrUnexpectedEOF
7436 }
7437 b := dAtA[iNdEx]
7438 iNdEx++
7439 stringLen |= uint64(b&0x7F) << shift
7440 if b < 0x80 {
7441 break
7442 }
7443 }
7444 intStringLen := int(stringLen)
7445 if intStringLen < 0 {
7446 return ErrInvalidLengthGenerated
7447 }
7448 postIndex := iNdEx + intStringLen
7449 if postIndex < 0 {
7450 return ErrInvalidLengthGenerated
7451 }
7452 if postIndex > l {
7453 return io.ErrUnexpectedEOF
7454 }
7455 m.Type = StatefulSetConditionType(dAtA[iNdEx:postIndex])
7456 iNdEx = postIndex
7457 case 2:
7458 if wireType != 2 {
7459 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7460 }
7461 var stringLen uint64
7462 for shift := uint(0); ; shift += 7 {
7463 if shift >= 64 {
7464 return ErrIntOverflowGenerated
7465 }
7466 if iNdEx >= l {
7467 return io.ErrUnexpectedEOF
7468 }
7469 b := dAtA[iNdEx]
7470 iNdEx++
7471 stringLen |= uint64(b&0x7F) << shift
7472 if b < 0x80 {
7473 break
7474 }
7475 }
7476 intStringLen := int(stringLen)
7477 if intStringLen < 0 {
7478 return ErrInvalidLengthGenerated
7479 }
7480 postIndex := iNdEx + intStringLen
7481 if postIndex < 0 {
7482 return ErrInvalidLengthGenerated
7483 }
7484 if postIndex > l {
7485 return io.ErrUnexpectedEOF
7486 }
7487 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
7488 iNdEx = postIndex
7489 case 3:
7490 if wireType != 2 {
7491 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
7492 }
7493 var msglen int
7494 for shift := uint(0); ; shift += 7 {
7495 if shift >= 64 {
7496 return ErrIntOverflowGenerated
7497 }
7498 if iNdEx >= l {
7499 return io.ErrUnexpectedEOF
7500 }
7501 b := dAtA[iNdEx]
7502 iNdEx++
7503 msglen |= int(b&0x7F) << shift
7504 if b < 0x80 {
7505 break
7506 }
7507 }
7508 if msglen < 0 {
7509 return ErrInvalidLengthGenerated
7510 }
7511 postIndex := iNdEx + msglen
7512 if postIndex < 0 {
7513 return ErrInvalidLengthGenerated
7514 }
7515 if postIndex > l {
7516 return io.ErrUnexpectedEOF
7517 }
7518 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7519 return err
7520 }
7521 iNdEx = postIndex
7522 case 4:
7523 if wireType != 2 {
7524 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
7525 }
7526 var stringLen uint64
7527 for shift := uint(0); ; shift += 7 {
7528 if shift >= 64 {
7529 return ErrIntOverflowGenerated
7530 }
7531 if iNdEx >= l {
7532 return io.ErrUnexpectedEOF
7533 }
7534 b := dAtA[iNdEx]
7535 iNdEx++
7536 stringLen |= uint64(b&0x7F) << shift
7537 if b < 0x80 {
7538 break
7539 }
7540 }
7541 intStringLen := int(stringLen)
7542 if intStringLen < 0 {
7543 return ErrInvalidLengthGenerated
7544 }
7545 postIndex := iNdEx + intStringLen
7546 if postIndex < 0 {
7547 return ErrInvalidLengthGenerated
7548 }
7549 if postIndex > l {
7550 return io.ErrUnexpectedEOF
7551 }
7552 m.Reason = string(dAtA[iNdEx:postIndex])
7553 iNdEx = postIndex
7554 case 5:
7555 if wireType != 2 {
7556 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
7557 }
7558 var stringLen uint64
7559 for shift := uint(0); ; shift += 7 {
7560 if shift >= 64 {
7561 return ErrIntOverflowGenerated
7562 }
7563 if iNdEx >= l {
7564 return io.ErrUnexpectedEOF
7565 }
7566 b := dAtA[iNdEx]
7567 iNdEx++
7568 stringLen |= uint64(b&0x7F) << shift
7569 if b < 0x80 {
7570 break
7571 }
7572 }
7573 intStringLen := int(stringLen)
7574 if intStringLen < 0 {
7575 return ErrInvalidLengthGenerated
7576 }
7577 postIndex := iNdEx + intStringLen
7578 if postIndex < 0 {
7579 return ErrInvalidLengthGenerated
7580 }
7581 if postIndex > l {
7582 return io.ErrUnexpectedEOF
7583 }
7584 m.Message = string(dAtA[iNdEx:postIndex])
7585 iNdEx = postIndex
7586 default:
7587 iNdEx = preIndex
7588 skippy, err := skipGenerated(dAtA[iNdEx:])
7589 if err != nil {
7590 return err
7591 }
7592 if (skippy < 0) || (iNdEx+skippy) < 0 {
7593 return ErrInvalidLengthGenerated
7594 }
7595 if (iNdEx + skippy) > l {
7596 return io.ErrUnexpectedEOF
7597 }
7598 iNdEx += skippy
7599 }
7600 }
7601
7602 if iNdEx > l {
7603 return io.ErrUnexpectedEOF
7604 }
7605 return nil
7606 }
7607 func (m *StatefulSetList) Unmarshal(dAtA []byte) error {
7608 l := len(dAtA)
7609 iNdEx := 0
7610 for iNdEx < l {
7611 preIndex := iNdEx
7612 var wire uint64
7613 for shift := uint(0); ; shift += 7 {
7614 if shift >= 64 {
7615 return ErrIntOverflowGenerated
7616 }
7617 if iNdEx >= l {
7618 return io.ErrUnexpectedEOF
7619 }
7620 b := dAtA[iNdEx]
7621 iNdEx++
7622 wire |= uint64(b&0x7F) << shift
7623 if b < 0x80 {
7624 break
7625 }
7626 }
7627 fieldNum := int32(wire >> 3)
7628 wireType := int(wire & 0x7)
7629 if wireType == 4 {
7630 return fmt.Errorf("proto: StatefulSetList: wiretype end group for non-group")
7631 }
7632 if fieldNum <= 0 {
7633 return fmt.Errorf("proto: StatefulSetList: illegal tag %d (wire type %d)", fieldNum, wire)
7634 }
7635 switch fieldNum {
7636 case 1:
7637 if wireType != 2 {
7638 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
7639 }
7640 var msglen int
7641 for shift := uint(0); ; shift += 7 {
7642 if shift >= 64 {
7643 return ErrIntOverflowGenerated
7644 }
7645 if iNdEx >= l {
7646 return io.ErrUnexpectedEOF
7647 }
7648 b := dAtA[iNdEx]
7649 iNdEx++
7650 msglen |= int(b&0x7F) << shift
7651 if b < 0x80 {
7652 break
7653 }
7654 }
7655 if msglen < 0 {
7656 return ErrInvalidLengthGenerated
7657 }
7658 postIndex := iNdEx + msglen
7659 if postIndex < 0 {
7660 return ErrInvalidLengthGenerated
7661 }
7662 if postIndex > l {
7663 return io.ErrUnexpectedEOF
7664 }
7665 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7666 return err
7667 }
7668 iNdEx = postIndex
7669 case 2:
7670 if wireType != 2 {
7671 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7672 }
7673 var msglen int
7674 for shift := uint(0); ; shift += 7 {
7675 if shift >= 64 {
7676 return ErrIntOverflowGenerated
7677 }
7678 if iNdEx >= l {
7679 return io.ErrUnexpectedEOF
7680 }
7681 b := dAtA[iNdEx]
7682 iNdEx++
7683 msglen |= int(b&0x7F) << shift
7684 if b < 0x80 {
7685 break
7686 }
7687 }
7688 if msglen < 0 {
7689 return ErrInvalidLengthGenerated
7690 }
7691 postIndex := iNdEx + msglen
7692 if postIndex < 0 {
7693 return ErrInvalidLengthGenerated
7694 }
7695 if postIndex > l {
7696 return io.ErrUnexpectedEOF
7697 }
7698 m.Items = append(m.Items, StatefulSet{})
7699 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7700 return err
7701 }
7702 iNdEx = postIndex
7703 default:
7704 iNdEx = preIndex
7705 skippy, err := skipGenerated(dAtA[iNdEx:])
7706 if err != nil {
7707 return err
7708 }
7709 if (skippy < 0) || (iNdEx+skippy) < 0 {
7710 return ErrInvalidLengthGenerated
7711 }
7712 if (iNdEx + skippy) > l {
7713 return io.ErrUnexpectedEOF
7714 }
7715 iNdEx += skippy
7716 }
7717 }
7718
7719 if iNdEx > l {
7720 return io.ErrUnexpectedEOF
7721 }
7722 return nil
7723 }
7724 func (m *StatefulSetOrdinals) Unmarshal(dAtA []byte) error {
7725 l := len(dAtA)
7726 iNdEx := 0
7727 for iNdEx < l {
7728 preIndex := iNdEx
7729 var wire uint64
7730 for shift := uint(0); ; shift += 7 {
7731 if shift >= 64 {
7732 return ErrIntOverflowGenerated
7733 }
7734 if iNdEx >= l {
7735 return io.ErrUnexpectedEOF
7736 }
7737 b := dAtA[iNdEx]
7738 iNdEx++
7739 wire |= uint64(b&0x7F) << shift
7740 if b < 0x80 {
7741 break
7742 }
7743 }
7744 fieldNum := int32(wire >> 3)
7745 wireType := int(wire & 0x7)
7746 if wireType == 4 {
7747 return fmt.Errorf("proto: StatefulSetOrdinals: wiretype end group for non-group")
7748 }
7749 if fieldNum <= 0 {
7750 return fmt.Errorf("proto: StatefulSetOrdinals: illegal tag %d (wire type %d)", fieldNum, wire)
7751 }
7752 switch fieldNum {
7753 case 1:
7754 if wireType != 0 {
7755 return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
7756 }
7757 m.Start = 0
7758 for shift := uint(0); ; shift += 7 {
7759 if shift >= 64 {
7760 return ErrIntOverflowGenerated
7761 }
7762 if iNdEx >= l {
7763 return io.ErrUnexpectedEOF
7764 }
7765 b := dAtA[iNdEx]
7766 iNdEx++
7767 m.Start |= int32(b&0x7F) << shift
7768 if b < 0x80 {
7769 break
7770 }
7771 }
7772 default:
7773 iNdEx = preIndex
7774 skippy, err := skipGenerated(dAtA[iNdEx:])
7775 if err != nil {
7776 return err
7777 }
7778 if (skippy < 0) || (iNdEx+skippy) < 0 {
7779 return ErrInvalidLengthGenerated
7780 }
7781 if (iNdEx + skippy) > l {
7782 return io.ErrUnexpectedEOF
7783 }
7784 iNdEx += skippy
7785 }
7786 }
7787
7788 if iNdEx > l {
7789 return io.ErrUnexpectedEOF
7790 }
7791 return nil
7792 }
7793 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Unmarshal(dAtA []byte) error {
7794 l := len(dAtA)
7795 iNdEx := 0
7796 for iNdEx < l {
7797 preIndex := iNdEx
7798 var wire uint64
7799 for shift := uint(0); ; shift += 7 {
7800 if shift >= 64 {
7801 return ErrIntOverflowGenerated
7802 }
7803 if iNdEx >= l {
7804 return io.ErrUnexpectedEOF
7805 }
7806 b := dAtA[iNdEx]
7807 iNdEx++
7808 wire |= uint64(b&0x7F) << shift
7809 if b < 0x80 {
7810 break
7811 }
7812 }
7813 fieldNum := int32(wire >> 3)
7814 wireType := int(wire & 0x7)
7815 if wireType == 4 {
7816 return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: wiretype end group for non-group")
7817 }
7818 if fieldNum <= 0 {
7819 return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
7820 }
7821 switch fieldNum {
7822 case 1:
7823 if wireType != 2 {
7824 return fmt.Errorf("proto: wrong wireType = %d for field WhenDeleted", wireType)
7825 }
7826 var stringLen uint64
7827 for shift := uint(0); ; shift += 7 {
7828 if shift >= 64 {
7829 return ErrIntOverflowGenerated
7830 }
7831 if iNdEx >= l {
7832 return io.ErrUnexpectedEOF
7833 }
7834 b := dAtA[iNdEx]
7835 iNdEx++
7836 stringLen |= uint64(b&0x7F) << shift
7837 if b < 0x80 {
7838 break
7839 }
7840 }
7841 intStringLen := int(stringLen)
7842 if intStringLen < 0 {
7843 return ErrInvalidLengthGenerated
7844 }
7845 postIndex := iNdEx + intStringLen
7846 if postIndex < 0 {
7847 return ErrInvalidLengthGenerated
7848 }
7849 if postIndex > l {
7850 return io.ErrUnexpectedEOF
7851 }
7852 m.WhenDeleted = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex])
7853 iNdEx = postIndex
7854 case 2:
7855 if wireType != 2 {
7856 return fmt.Errorf("proto: wrong wireType = %d for field WhenScaled", wireType)
7857 }
7858 var stringLen uint64
7859 for shift := uint(0); ; shift += 7 {
7860 if shift >= 64 {
7861 return ErrIntOverflowGenerated
7862 }
7863 if iNdEx >= l {
7864 return io.ErrUnexpectedEOF
7865 }
7866 b := dAtA[iNdEx]
7867 iNdEx++
7868 stringLen |= uint64(b&0x7F) << shift
7869 if b < 0x80 {
7870 break
7871 }
7872 }
7873 intStringLen := int(stringLen)
7874 if intStringLen < 0 {
7875 return ErrInvalidLengthGenerated
7876 }
7877 postIndex := iNdEx + intStringLen
7878 if postIndex < 0 {
7879 return ErrInvalidLengthGenerated
7880 }
7881 if postIndex > l {
7882 return io.ErrUnexpectedEOF
7883 }
7884 m.WhenScaled = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex])
7885 iNdEx = postIndex
7886 default:
7887 iNdEx = preIndex
7888 skippy, err := skipGenerated(dAtA[iNdEx:])
7889 if err != nil {
7890 return err
7891 }
7892 if (skippy < 0) || (iNdEx+skippy) < 0 {
7893 return ErrInvalidLengthGenerated
7894 }
7895 if (iNdEx + skippy) > l {
7896 return io.ErrUnexpectedEOF
7897 }
7898 iNdEx += skippy
7899 }
7900 }
7901
7902 if iNdEx > l {
7903 return io.ErrUnexpectedEOF
7904 }
7905 return nil
7906 }
7907 func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error {
7908 l := len(dAtA)
7909 iNdEx := 0
7910 for iNdEx < l {
7911 preIndex := iNdEx
7912 var wire uint64
7913 for shift := uint(0); ; shift += 7 {
7914 if shift >= 64 {
7915 return ErrIntOverflowGenerated
7916 }
7917 if iNdEx >= l {
7918 return io.ErrUnexpectedEOF
7919 }
7920 b := dAtA[iNdEx]
7921 iNdEx++
7922 wire |= uint64(b&0x7F) << shift
7923 if b < 0x80 {
7924 break
7925 }
7926 }
7927 fieldNum := int32(wire >> 3)
7928 wireType := int(wire & 0x7)
7929 if wireType == 4 {
7930 return fmt.Errorf("proto: StatefulSetSpec: wiretype end group for non-group")
7931 }
7932 if fieldNum <= 0 {
7933 return fmt.Errorf("proto: StatefulSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
7934 }
7935 switch fieldNum {
7936 case 1:
7937 if wireType != 0 {
7938 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
7939 }
7940 var v int32
7941 for shift := uint(0); ; shift += 7 {
7942 if shift >= 64 {
7943 return ErrIntOverflowGenerated
7944 }
7945 if iNdEx >= l {
7946 return io.ErrUnexpectedEOF
7947 }
7948 b := dAtA[iNdEx]
7949 iNdEx++
7950 v |= int32(b&0x7F) << shift
7951 if b < 0x80 {
7952 break
7953 }
7954 }
7955 m.Replicas = &v
7956 case 2:
7957 if wireType != 2 {
7958 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
7959 }
7960 var msglen int
7961 for shift := uint(0); ; shift += 7 {
7962 if shift >= 64 {
7963 return ErrIntOverflowGenerated
7964 }
7965 if iNdEx >= l {
7966 return io.ErrUnexpectedEOF
7967 }
7968 b := dAtA[iNdEx]
7969 iNdEx++
7970 msglen |= int(b&0x7F) << shift
7971 if b < 0x80 {
7972 break
7973 }
7974 }
7975 if msglen < 0 {
7976 return ErrInvalidLengthGenerated
7977 }
7978 postIndex := iNdEx + msglen
7979 if postIndex < 0 {
7980 return ErrInvalidLengthGenerated
7981 }
7982 if postIndex > l {
7983 return io.ErrUnexpectedEOF
7984 }
7985 if m.Selector == nil {
7986 m.Selector = &v1.LabelSelector{}
7987 }
7988 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7989 return err
7990 }
7991 iNdEx = postIndex
7992 case 3:
7993 if wireType != 2 {
7994 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
7995 }
7996 var msglen int
7997 for shift := uint(0); ; shift += 7 {
7998 if shift >= 64 {
7999 return ErrIntOverflowGenerated
8000 }
8001 if iNdEx >= l {
8002 return io.ErrUnexpectedEOF
8003 }
8004 b := dAtA[iNdEx]
8005 iNdEx++
8006 msglen |= int(b&0x7F) << shift
8007 if b < 0x80 {
8008 break
8009 }
8010 }
8011 if msglen < 0 {
8012 return ErrInvalidLengthGenerated
8013 }
8014 postIndex := iNdEx + msglen
8015 if postIndex < 0 {
8016 return ErrInvalidLengthGenerated
8017 }
8018 if postIndex > l {
8019 return io.ErrUnexpectedEOF
8020 }
8021 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8022 return err
8023 }
8024 iNdEx = postIndex
8025 case 4:
8026 if wireType != 2 {
8027 return fmt.Errorf("proto: wrong wireType = %d for field VolumeClaimTemplates", wireType)
8028 }
8029 var msglen int
8030 for shift := uint(0); ; shift += 7 {
8031 if shift >= 64 {
8032 return ErrIntOverflowGenerated
8033 }
8034 if iNdEx >= l {
8035 return io.ErrUnexpectedEOF
8036 }
8037 b := dAtA[iNdEx]
8038 iNdEx++
8039 msglen |= int(b&0x7F) << shift
8040 if b < 0x80 {
8041 break
8042 }
8043 }
8044 if msglen < 0 {
8045 return ErrInvalidLengthGenerated
8046 }
8047 postIndex := iNdEx + msglen
8048 if postIndex < 0 {
8049 return ErrInvalidLengthGenerated
8050 }
8051 if postIndex > l {
8052 return io.ErrUnexpectedEOF
8053 }
8054 m.VolumeClaimTemplates = append(m.VolumeClaimTemplates, v11.PersistentVolumeClaim{})
8055 if err := m.VolumeClaimTemplates[len(m.VolumeClaimTemplates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8056 return err
8057 }
8058 iNdEx = postIndex
8059 case 5:
8060 if wireType != 2 {
8061 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
8062 }
8063 var stringLen uint64
8064 for shift := uint(0); ; shift += 7 {
8065 if shift >= 64 {
8066 return ErrIntOverflowGenerated
8067 }
8068 if iNdEx >= l {
8069 return io.ErrUnexpectedEOF
8070 }
8071 b := dAtA[iNdEx]
8072 iNdEx++
8073 stringLen |= uint64(b&0x7F) << shift
8074 if b < 0x80 {
8075 break
8076 }
8077 }
8078 intStringLen := int(stringLen)
8079 if intStringLen < 0 {
8080 return ErrInvalidLengthGenerated
8081 }
8082 postIndex := iNdEx + intStringLen
8083 if postIndex < 0 {
8084 return ErrInvalidLengthGenerated
8085 }
8086 if postIndex > l {
8087 return io.ErrUnexpectedEOF
8088 }
8089 m.ServiceName = string(dAtA[iNdEx:postIndex])
8090 iNdEx = postIndex
8091 case 6:
8092 if wireType != 2 {
8093 return fmt.Errorf("proto: wrong wireType = %d for field PodManagementPolicy", wireType)
8094 }
8095 var stringLen uint64
8096 for shift := uint(0); ; shift += 7 {
8097 if shift >= 64 {
8098 return ErrIntOverflowGenerated
8099 }
8100 if iNdEx >= l {
8101 return io.ErrUnexpectedEOF
8102 }
8103 b := dAtA[iNdEx]
8104 iNdEx++
8105 stringLen |= uint64(b&0x7F) << shift
8106 if b < 0x80 {
8107 break
8108 }
8109 }
8110 intStringLen := int(stringLen)
8111 if intStringLen < 0 {
8112 return ErrInvalidLengthGenerated
8113 }
8114 postIndex := iNdEx + intStringLen
8115 if postIndex < 0 {
8116 return ErrInvalidLengthGenerated
8117 }
8118 if postIndex > l {
8119 return io.ErrUnexpectedEOF
8120 }
8121 m.PodManagementPolicy = PodManagementPolicyType(dAtA[iNdEx:postIndex])
8122 iNdEx = postIndex
8123 case 7:
8124 if wireType != 2 {
8125 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
8126 }
8127 var msglen int
8128 for shift := uint(0); ; shift += 7 {
8129 if shift >= 64 {
8130 return ErrIntOverflowGenerated
8131 }
8132 if iNdEx >= l {
8133 return io.ErrUnexpectedEOF
8134 }
8135 b := dAtA[iNdEx]
8136 iNdEx++
8137 msglen |= int(b&0x7F) << shift
8138 if b < 0x80 {
8139 break
8140 }
8141 }
8142 if msglen < 0 {
8143 return ErrInvalidLengthGenerated
8144 }
8145 postIndex := iNdEx + msglen
8146 if postIndex < 0 {
8147 return ErrInvalidLengthGenerated
8148 }
8149 if postIndex > l {
8150 return io.ErrUnexpectedEOF
8151 }
8152 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8153 return err
8154 }
8155 iNdEx = postIndex
8156 case 8:
8157 if wireType != 0 {
8158 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
8159 }
8160 var v int32
8161 for shift := uint(0); ; shift += 7 {
8162 if shift >= 64 {
8163 return ErrIntOverflowGenerated
8164 }
8165 if iNdEx >= l {
8166 return io.ErrUnexpectedEOF
8167 }
8168 b := dAtA[iNdEx]
8169 iNdEx++
8170 v |= int32(b&0x7F) << shift
8171 if b < 0x80 {
8172 break
8173 }
8174 }
8175 m.RevisionHistoryLimit = &v
8176 case 9:
8177 if wireType != 0 {
8178 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
8179 }
8180 m.MinReadySeconds = 0
8181 for shift := uint(0); ; shift += 7 {
8182 if shift >= 64 {
8183 return ErrIntOverflowGenerated
8184 }
8185 if iNdEx >= l {
8186 return io.ErrUnexpectedEOF
8187 }
8188 b := dAtA[iNdEx]
8189 iNdEx++
8190 m.MinReadySeconds |= int32(b&0x7F) << shift
8191 if b < 0x80 {
8192 break
8193 }
8194 }
8195 case 10:
8196 if wireType != 2 {
8197 return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaimRetentionPolicy", wireType)
8198 }
8199 var msglen int
8200 for shift := uint(0); ; shift += 7 {
8201 if shift >= 64 {
8202 return ErrIntOverflowGenerated
8203 }
8204 if iNdEx >= l {
8205 return io.ErrUnexpectedEOF
8206 }
8207 b := dAtA[iNdEx]
8208 iNdEx++
8209 msglen |= int(b&0x7F) << shift
8210 if b < 0x80 {
8211 break
8212 }
8213 }
8214 if msglen < 0 {
8215 return ErrInvalidLengthGenerated
8216 }
8217 postIndex := iNdEx + msglen
8218 if postIndex < 0 {
8219 return ErrInvalidLengthGenerated
8220 }
8221 if postIndex > l {
8222 return io.ErrUnexpectedEOF
8223 }
8224 if m.PersistentVolumeClaimRetentionPolicy == nil {
8225 m.PersistentVolumeClaimRetentionPolicy = &StatefulSetPersistentVolumeClaimRetentionPolicy{}
8226 }
8227 if err := m.PersistentVolumeClaimRetentionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8228 return err
8229 }
8230 iNdEx = postIndex
8231 case 11:
8232 if wireType != 2 {
8233 return fmt.Errorf("proto: wrong wireType = %d for field Ordinals", wireType)
8234 }
8235 var msglen int
8236 for shift := uint(0); ; shift += 7 {
8237 if shift >= 64 {
8238 return ErrIntOverflowGenerated
8239 }
8240 if iNdEx >= l {
8241 return io.ErrUnexpectedEOF
8242 }
8243 b := dAtA[iNdEx]
8244 iNdEx++
8245 msglen |= int(b&0x7F) << shift
8246 if b < 0x80 {
8247 break
8248 }
8249 }
8250 if msglen < 0 {
8251 return ErrInvalidLengthGenerated
8252 }
8253 postIndex := iNdEx + msglen
8254 if postIndex < 0 {
8255 return ErrInvalidLengthGenerated
8256 }
8257 if postIndex > l {
8258 return io.ErrUnexpectedEOF
8259 }
8260 if m.Ordinals == nil {
8261 m.Ordinals = &StatefulSetOrdinals{}
8262 }
8263 if err := m.Ordinals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8264 return err
8265 }
8266 iNdEx = postIndex
8267 default:
8268 iNdEx = preIndex
8269 skippy, err := skipGenerated(dAtA[iNdEx:])
8270 if err != nil {
8271 return err
8272 }
8273 if (skippy < 0) || (iNdEx+skippy) < 0 {
8274 return ErrInvalidLengthGenerated
8275 }
8276 if (iNdEx + skippy) > l {
8277 return io.ErrUnexpectedEOF
8278 }
8279 iNdEx += skippy
8280 }
8281 }
8282
8283 if iNdEx > l {
8284 return io.ErrUnexpectedEOF
8285 }
8286 return nil
8287 }
8288 func (m *StatefulSetStatus) Unmarshal(dAtA []byte) error {
8289 l := len(dAtA)
8290 iNdEx := 0
8291 for iNdEx < l {
8292 preIndex := iNdEx
8293 var wire uint64
8294 for shift := uint(0); ; shift += 7 {
8295 if shift >= 64 {
8296 return ErrIntOverflowGenerated
8297 }
8298 if iNdEx >= l {
8299 return io.ErrUnexpectedEOF
8300 }
8301 b := dAtA[iNdEx]
8302 iNdEx++
8303 wire |= uint64(b&0x7F) << shift
8304 if b < 0x80 {
8305 break
8306 }
8307 }
8308 fieldNum := int32(wire >> 3)
8309 wireType := int(wire & 0x7)
8310 if wireType == 4 {
8311 return fmt.Errorf("proto: StatefulSetStatus: wiretype end group for non-group")
8312 }
8313 if fieldNum <= 0 {
8314 return fmt.Errorf("proto: StatefulSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
8315 }
8316 switch fieldNum {
8317 case 1:
8318 if wireType != 0 {
8319 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
8320 }
8321 m.ObservedGeneration = 0
8322 for shift := uint(0); ; shift += 7 {
8323 if shift >= 64 {
8324 return ErrIntOverflowGenerated
8325 }
8326 if iNdEx >= l {
8327 return io.ErrUnexpectedEOF
8328 }
8329 b := dAtA[iNdEx]
8330 iNdEx++
8331 m.ObservedGeneration |= int64(b&0x7F) << shift
8332 if b < 0x80 {
8333 break
8334 }
8335 }
8336 case 2:
8337 if wireType != 0 {
8338 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
8339 }
8340 m.Replicas = 0
8341 for shift := uint(0); ; shift += 7 {
8342 if shift >= 64 {
8343 return ErrIntOverflowGenerated
8344 }
8345 if iNdEx >= l {
8346 return io.ErrUnexpectedEOF
8347 }
8348 b := dAtA[iNdEx]
8349 iNdEx++
8350 m.Replicas |= int32(b&0x7F) << shift
8351 if b < 0x80 {
8352 break
8353 }
8354 }
8355 case 3:
8356 if wireType != 0 {
8357 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
8358 }
8359 m.ReadyReplicas = 0
8360 for shift := uint(0); ; shift += 7 {
8361 if shift >= 64 {
8362 return ErrIntOverflowGenerated
8363 }
8364 if iNdEx >= l {
8365 return io.ErrUnexpectedEOF
8366 }
8367 b := dAtA[iNdEx]
8368 iNdEx++
8369 m.ReadyReplicas |= int32(b&0x7F) << shift
8370 if b < 0x80 {
8371 break
8372 }
8373 }
8374 case 4:
8375 if wireType != 0 {
8376 return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
8377 }
8378 m.CurrentReplicas = 0
8379 for shift := uint(0); ; shift += 7 {
8380 if shift >= 64 {
8381 return ErrIntOverflowGenerated
8382 }
8383 if iNdEx >= l {
8384 return io.ErrUnexpectedEOF
8385 }
8386 b := dAtA[iNdEx]
8387 iNdEx++
8388 m.CurrentReplicas |= int32(b&0x7F) << shift
8389 if b < 0x80 {
8390 break
8391 }
8392 }
8393 case 5:
8394 if wireType != 0 {
8395 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
8396 }
8397 m.UpdatedReplicas = 0
8398 for shift := uint(0); ; shift += 7 {
8399 if shift >= 64 {
8400 return ErrIntOverflowGenerated
8401 }
8402 if iNdEx >= l {
8403 return io.ErrUnexpectedEOF
8404 }
8405 b := dAtA[iNdEx]
8406 iNdEx++
8407 m.UpdatedReplicas |= int32(b&0x7F) << shift
8408 if b < 0x80 {
8409 break
8410 }
8411 }
8412 case 6:
8413 if wireType != 2 {
8414 return fmt.Errorf("proto: wrong wireType = %d for field CurrentRevision", wireType)
8415 }
8416 var stringLen uint64
8417 for shift := uint(0); ; shift += 7 {
8418 if shift >= 64 {
8419 return ErrIntOverflowGenerated
8420 }
8421 if iNdEx >= l {
8422 return io.ErrUnexpectedEOF
8423 }
8424 b := dAtA[iNdEx]
8425 iNdEx++
8426 stringLen |= uint64(b&0x7F) << shift
8427 if b < 0x80 {
8428 break
8429 }
8430 }
8431 intStringLen := int(stringLen)
8432 if intStringLen < 0 {
8433 return ErrInvalidLengthGenerated
8434 }
8435 postIndex := iNdEx + intStringLen
8436 if postIndex < 0 {
8437 return ErrInvalidLengthGenerated
8438 }
8439 if postIndex > l {
8440 return io.ErrUnexpectedEOF
8441 }
8442 m.CurrentRevision = string(dAtA[iNdEx:postIndex])
8443 iNdEx = postIndex
8444 case 7:
8445 if wireType != 2 {
8446 return fmt.Errorf("proto: wrong wireType = %d for field UpdateRevision", wireType)
8447 }
8448 var stringLen uint64
8449 for shift := uint(0); ; shift += 7 {
8450 if shift >= 64 {
8451 return ErrIntOverflowGenerated
8452 }
8453 if iNdEx >= l {
8454 return io.ErrUnexpectedEOF
8455 }
8456 b := dAtA[iNdEx]
8457 iNdEx++
8458 stringLen |= uint64(b&0x7F) << shift
8459 if b < 0x80 {
8460 break
8461 }
8462 }
8463 intStringLen := int(stringLen)
8464 if intStringLen < 0 {
8465 return ErrInvalidLengthGenerated
8466 }
8467 postIndex := iNdEx + intStringLen
8468 if postIndex < 0 {
8469 return ErrInvalidLengthGenerated
8470 }
8471 if postIndex > l {
8472 return io.ErrUnexpectedEOF
8473 }
8474 m.UpdateRevision = string(dAtA[iNdEx:postIndex])
8475 iNdEx = postIndex
8476 case 9:
8477 if wireType != 0 {
8478 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
8479 }
8480 var v int32
8481 for shift := uint(0); ; shift += 7 {
8482 if shift >= 64 {
8483 return ErrIntOverflowGenerated
8484 }
8485 if iNdEx >= l {
8486 return io.ErrUnexpectedEOF
8487 }
8488 b := dAtA[iNdEx]
8489 iNdEx++
8490 v |= int32(b&0x7F) << shift
8491 if b < 0x80 {
8492 break
8493 }
8494 }
8495 m.CollisionCount = &v
8496 case 10:
8497 if wireType != 2 {
8498 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
8499 }
8500 var msglen int
8501 for shift := uint(0); ; shift += 7 {
8502 if shift >= 64 {
8503 return ErrIntOverflowGenerated
8504 }
8505 if iNdEx >= l {
8506 return io.ErrUnexpectedEOF
8507 }
8508 b := dAtA[iNdEx]
8509 iNdEx++
8510 msglen |= int(b&0x7F) << shift
8511 if b < 0x80 {
8512 break
8513 }
8514 }
8515 if msglen < 0 {
8516 return ErrInvalidLengthGenerated
8517 }
8518 postIndex := iNdEx + msglen
8519 if postIndex < 0 {
8520 return ErrInvalidLengthGenerated
8521 }
8522 if postIndex > l {
8523 return io.ErrUnexpectedEOF
8524 }
8525 m.Conditions = append(m.Conditions, StatefulSetCondition{})
8526 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8527 return err
8528 }
8529 iNdEx = postIndex
8530 case 11:
8531 if wireType != 0 {
8532 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
8533 }
8534 m.AvailableReplicas = 0
8535 for shift := uint(0); ; shift += 7 {
8536 if shift >= 64 {
8537 return ErrIntOverflowGenerated
8538 }
8539 if iNdEx >= l {
8540 return io.ErrUnexpectedEOF
8541 }
8542 b := dAtA[iNdEx]
8543 iNdEx++
8544 m.AvailableReplicas |= int32(b&0x7F) << shift
8545 if b < 0x80 {
8546 break
8547 }
8548 }
8549 default:
8550 iNdEx = preIndex
8551 skippy, err := skipGenerated(dAtA[iNdEx:])
8552 if err != nil {
8553 return err
8554 }
8555 if (skippy < 0) || (iNdEx+skippy) < 0 {
8556 return ErrInvalidLengthGenerated
8557 }
8558 if (iNdEx + skippy) > l {
8559 return io.ErrUnexpectedEOF
8560 }
8561 iNdEx += skippy
8562 }
8563 }
8564
8565 if iNdEx > l {
8566 return io.ErrUnexpectedEOF
8567 }
8568 return nil
8569 }
8570 func (m *StatefulSetUpdateStrategy) Unmarshal(dAtA []byte) error {
8571 l := len(dAtA)
8572 iNdEx := 0
8573 for iNdEx < l {
8574 preIndex := iNdEx
8575 var wire uint64
8576 for shift := uint(0); ; shift += 7 {
8577 if shift >= 64 {
8578 return ErrIntOverflowGenerated
8579 }
8580 if iNdEx >= l {
8581 return io.ErrUnexpectedEOF
8582 }
8583 b := dAtA[iNdEx]
8584 iNdEx++
8585 wire |= uint64(b&0x7F) << shift
8586 if b < 0x80 {
8587 break
8588 }
8589 }
8590 fieldNum := int32(wire >> 3)
8591 wireType := int(wire & 0x7)
8592 if wireType == 4 {
8593 return fmt.Errorf("proto: StatefulSetUpdateStrategy: wiretype end group for non-group")
8594 }
8595 if fieldNum <= 0 {
8596 return fmt.Errorf("proto: StatefulSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
8597 }
8598 switch fieldNum {
8599 case 1:
8600 if wireType != 2 {
8601 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
8602 }
8603 var stringLen uint64
8604 for shift := uint(0); ; shift += 7 {
8605 if shift >= 64 {
8606 return ErrIntOverflowGenerated
8607 }
8608 if iNdEx >= l {
8609 return io.ErrUnexpectedEOF
8610 }
8611 b := dAtA[iNdEx]
8612 iNdEx++
8613 stringLen |= uint64(b&0x7F) << shift
8614 if b < 0x80 {
8615 break
8616 }
8617 }
8618 intStringLen := int(stringLen)
8619 if intStringLen < 0 {
8620 return ErrInvalidLengthGenerated
8621 }
8622 postIndex := iNdEx + intStringLen
8623 if postIndex < 0 {
8624 return ErrInvalidLengthGenerated
8625 }
8626 if postIndex > l {
8627 return io.ErrUnexpectedEOF
8628 }
8629 m.Type = StatefulSetUpdateStrategyType(dAtA[iNdEx:postIndex])
8630 iNdEx = postIndex
8631 case 2:
8632 if wireType != 2 {
8633 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
8634 }
8635 var msglen int
8636 for shift := uint(0); ; shift += 7 {
8637 if shift >= 64 {
8638 return ErrIntOverflowGenerated
8639 }
8640 if iNdEx >= l {
8641 return io.ErrUnexpectedEOF
8642 }
8643 b := dAtA[iNdEx]
8644 iNdEx++
8645 msglen |= int(b&0x7F) << shift
8646 if b < 0x80 {
8647 break
8648 }
8649 }
8650 if msglen < 0 {
8651 return ErrInvalidLengthGenerated
8652 }
8653 postIndex := iNdEx + msglen
8654 if postIndex < 0 {
8655 return ErrInvalidLengthGenerated
8656 }
8657 if postIndex > l {
8658 return io.ErrUnexpectedEOF
8659 }
8660 if m.RollingUpdate == nil {
8661 m.RollingUpdate = &RollingUpdateStatefulSetStrategy{}
8662 }
8663 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8664 return err
8665 }
8666 iNdEx = postIndex
8667 default:
8668 iNdEx = preIndex
8669 skippy, err := skipGenerated(dAtA[iNdEx:])
8670 if err != nil {
8671 return err
8672 }
8673 if (skippy < 0) || (iNdEx+skippy) < 0 {
8674 return ErrInvalidLengthGenerated
8675 }
8676 if (iNdEx + skippy) > l {
8677 return io.ErrUnexpectedEOF
8678 }
8679 iNdEx += skippy
8680 }
8681 }
8682
8683 if iNdEx > l {
8684 return io.ErrUnexpectedEOF
8685 }
8686 return nil
8687 }
8688 func skipGenerated(dAtA []byte) (n int, err error) {
8689 l := len(dAtA)
8690 iNdEx := 0
8691 depth := 0
8692 for iNdEx < l {
8693 var wire uint64
8694 for shift := uint(0); ; shift += 7 {
8695 if shift >= 64 {
8696 return 0, ErrIntOverflowGenerated
8697 }
8698 if iNdEx >= l {
8699 return 0, io.ErrUnexpectedEOF
8700 }
8701 b := dAtA[iNdEx]
8702 iNdEx++
8703 wire |= (uint64(b) & 0x7F) << shift
8704 if b < 0x80 {
8705 break
8706 }
8707 }
8708 wireType := int(wire & 0x7)
8709 switch wireType {
8710 case 0:
8711 for shift := uint(0); ; shift += 7 {
8712 if shift >= 64 {
8713 return 0, ErrIntOverflowGenerated
8714 }
8715 if iNdEx >= l {
8716 return 0, io.ErrUnexpectedEOF
8717 }
8718 iNdEx++
8719 if dAtA[iNdEx-1] < 0x80 {
8720 break
8721 }
8722 }
8723 case 1:
8724 iNdEx += 8
8725 case 2:
8726 var length int
8727 for shift := uint(0); ; shift += 7 {
8728 if shift >= 64 {
8729 return 0, ErrIntOverflowGenerated
8730 }
8731 if iNdEx >= l {
8732 return 0, io.ErrUnexpectedEOF
8733 }
8734 b := dAtA[iNdEx]
8735 iNdEx++
8736 length |= (int(b) & 0x7F) << shift
8737 if b < 0x80 {
8738 break
8739 }
8740 }
8741 if length < 0 {
8742 return 0, ErrInvalidLengthGenerated
8743 }
8744 iNdEx += length
8745 case 3:
8746 depth++
8747 case 4:
8748 if depth == 0 {
8749 return 0, ErrUnexpectedEndOfGroupGenerated
8750 }
8751 depth--
8752 case 5:
8753 iNdEx += 4
8754 default:
8755 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
8756 }
8757 if iNdEx < 0 {
8758 return 0, ErrInvalidLengthGenerated
8759 }
8760 if depth == 0 {
8761 return iNdEx, nil
8762 }
8763 }
8764 return 0, io.ErrUnexpectedEOF
8765 }
8766
8767 var (
8768 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
8769 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
8770 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
8771 )
8772
View as plain text